?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 98299ad1251baa2727aab065c47e9d935978c732
[wine/hacks.git] / dlls / user32 / tests / msg.c
bloba865d74b7583a5943416635532dc137e6c44a2b4
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 #define _WIN32_WINNT 0x0501 /* For WM_CHANGEUISTATE,QS_RAWINPUT */
24
25 #include <assert.h>
26 #include <stdarg.h>
27 #include <stdio.h>
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 static HHOOK hCBT_hook;
82 static DWORD cbt_hook_thread_id;
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 WPARAM wp_mask; /* mask for wParam checks */
116 LPARAM lp_mask; /* mask for lParam checks */
117 };
118
119 struct recvd_message {
120 UINT message; /* the WM_* code */
121 msg_flags_t flags; /* message props */
122 HWND hwnd; /* window that received the message */
123 WPARAM wParam; /* expected value of wParam */
124 LPARAM lParam; /* expected value of lParam */
125 int line; /* source line where logged */
126 const char *descr; /* description for trace output */
127 char output[512]; /* trace output */
128 };
129
130 /* Empty message sequence */
131 static const struct message WmEmptySeq[] =
132 {
133 { 0 }
134 };
135 /* CreateWindow (for overlapped window, not initially visible) (16/32) */
136 static const struct message WmCreateOverlappedSeq[] = {
137 { HCBT_CREATEWND, hook },
138 { WM_GETMINMAXINFO, sent },
139 { WM_NCCREATE, sent },
140 { WM_NCCALCSIZE, sent|wparam, 0 },
141 { 0x0093, sent|defwinproc|optional },
142 { 0x0094, sent|defwinproc|optional },
143 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
144 { WM_CREATE, sent },
145 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
146 { 0 }
147 };
148 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
149 * for a not visible overlapped window.
150 */
151 static const struct message WmSWP_ShowOverlappedSeq[] = {
152 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
153 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
154 { WM_NCPAINT, sent|wparam|optional, 1 },
155 { WM_GETTEXT, sent|defwinproc|optional },
156 { WM_ERASEBKGND, sent|optional },
157 { HCBT_ACTIVATE, hook },
158 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
159 { WM_NOTIFYFORMAT, sent|optional },
160 { WM_QUERYUISTATE, sent|optional },
161 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
162 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* Win9x: SWP_NOSENDCHANGING */
163 { WM_ACTIVATEAPP, sent|wparam, 1 },
164 { WM_NCACTIVATE, sent|wparam, 1 },
165 { WM_GETTEXT, sent|defwinproc|optional },
166 { WM_ACTIVATE, sent|wparam, 1 },
167 { HCBT_SETFOCUS, hook },
168 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
169 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
170 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
171 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
172 { WM_GETTEXT, sent|optional },
173 { WM_NCPAINT, sent|wparam|optional, 1 },
174 { WM_GETTEXT, sent|defwinproc|optional },
175 { WM_ERASEBKGND, sent|optional },
176 /* Win9x adds SWP_NOZORDER below */
177 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
178 { WM_GETTEXT, sent|optional },
179 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
180 { WM_NCPAINT, sent|wparam|optional, 1 },
181 { WM_ERASEBKGND, sent|optional },
182 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
183 { WM_PAINT, sent|optional },
184 { WM_NCPAINT, sent|beginpaint|optional },
185 { WM_ERASEBKGND, sent|beginpaint|optional },
186 { 0 }
187 };
188 /* SetWindowPos(SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE)
189 * for a visible overlapped window.
190 */
191 static const struct message WmSWP_HideOverlappedSeq[] = {
192 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
193 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
194 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
195 { 0 }
196 };
197
198 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE)
199 * for a visible overlapped window.
200 */
201 static const struct message WmSWP_ResizeSeq[] = {
202 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE },
203 { WM_GETMINMAXINFO, sent|defwinproc },
204 { WM_NCCALCSIZE, sent|wparam, TRUE },
205 { WM_NCPAINT, sent|optional },
206 { WM_GETTEXT, sent|defwinproc|optional },
207 { WM_ERASEBKGND, sent|optional },
208 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
209 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
210 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
211 { WM_NCPAINT, sent|optional },
212 { WM_GETTEXT, sent|defwinproc|optional },
213 { WM_ERASEBKGND, sent|optional },
214 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
215 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
216 { 0 }
217 };
218
219 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE)
220 * for a visible popup window.
221 */
222 static const struct message WmSWP_ResizePopupSeq[] = {
223 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE },
224 { WM_GETMINMAXINFO, sent|defwinproc|optional }, /* Win9x */
225 { WM_NCCALCSIZE, sent|wparam, TRUE },
226 { WM_NCPAINT, sent|optional },
227 { WM_GETTEXT, sent|defwinproc|optional },
228 { WM_ERASEBKGND, sent|optional },
229 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
230 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
231 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
232 { WM_NCPAINT, sent|optional },
233 { WM_GETTEXT, sent|defwinproc|optional },
234 { WM_ERASEBKGND, sent|optional },
235 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
236 { 0 }
237 };
238
239 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE)
240 * for a visible overlapped window.
241 */
242 static const struct message WmSWP_MoveSeq[] = {
243 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOSIZE },
244 { WM_NCPAINT, sent|optional },
245 { WM_GETTEXT, sent|defwinproc|optional },
246 { WM_ERASEBKGND, sent|optional },
247 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOCLIENTSIZE },
248 { WM_MOVE, sent|defwinproc|wparam, 0 },
249 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
250 { 0 }
251 };
252 /* Resize with SetWindowPos(SWP_NOZORDER)
253 * for a visible overlapped window
254 * SWP_NOZORDER is stripped by the logging code
255 */
256 static const struct message WmSWP_ResizeNoZOrder[] = {
257 { WM_WINDOWPOSCHANGING, sent|wparam, /*SWP_NOZORDER|*/SWP_NOACTIVATE },
258 { WM_GETMINMAXINFO, sent|defwinproc },
259 { WM_NCCALCSIZE, sent|wparam, 1 },
260 { WM_NCPAINT, sent },
261 { WM_GETTEXT, sent|defwinproc|optional },
262 { WM_ERASEBKGND, sent|optional }, /* FIXME: remove optional once Wine is fixed */
263 { WM_WINDOWPOSCHANGED, sent|wparam, /*SWP_NOZORDER|*/SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE },
264 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
265 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* Win9x doesn't send it */
266 { WM_NCPAINT, sent|optional }, /* Win9x doesn't send it */
267 { WM_GETTEXT, sent|defwinproc|optional }, /* Win9x doesn't send it */
268 { WM_ERASEBKGND, sent|optional }, /* Win9x doesn't send it */
269 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
270 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
271 { 0 }
272 };
273
274 /* Switch visible mdi children */
275 static const struct message WmSwitchChild[] = {
276 /* Switch MDI child */
277 { WM_MDIACTIVATE, sent },/* in the MDI client */
278 { WM_WINDOWPOSCHANGING, sent|wparam,SWP_NOSIZE|SWP_NOMOVE },/* in the 1st MDI child */
279 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
280 { WM_CHILDACTIVATE, sent },/* in the 1st MDI child */
281 /* Deactivate 2nd MDI child */
282 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 2nd MDI child */
283 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 2nd MDI child */
284 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
285 /* Preparing for maximize and maximaze the 1st MDI child */
286 { WM_GETMINMAXINFO, sent|defwinproc }, /* in the 1st MDI child */
287 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_STATECHANGED }, /* in the 1st MDI child */
288 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 }, /* in the 1st MDI child */
289 { WM_CHILDACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
290 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED }, /* in the 1st MDI child */
291 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED }, /* in the 1st MDI child */
292 /* Lock redraw 2nd MDI child */
293 { WM_SETREDRAW, sent|wparam|defwinproc, 0 }, /* in the 2nd MDI child */
294 { HCBT_MINMAX, hook|lparam, 0, SW_NORMALNA },
295 /* Restore 2nd MDI child */
296 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED },/* in the 2nd MDI child */
297 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },/* in the 2nd MDI child */
298 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 }, /* in the 2nd MDI child */
299 { 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 */
300 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED }, /* in the 2nd MDI child */
301 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* in the 2nd MDI child */
302 /* Redraw 2nd MDI child */
303 { WM_SETREDRAW, sent|wparam|defwinproc, 1 },/* in the 2nd MDI child */
304 /* Redraw MDI frame */
305 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },/* in MDI frame */
306 { WM_NCCALCSIZE, sent|wparam, 1 },/* in MDI frame */
307 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE}, /* in MDI frame */
308 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* in MDI frame */
309 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* in the 1st MDI child */
310 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE }, /* in the 1st MDI child */
311 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 }, /* in the 1st MDI child */
312 { HCBT_SETFOCUS, hook },
313 { WM_KILLFOCUS, sent|defwinproc }, /* in the 2nd MDI child */
314 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },/* in the 1st MDI child */
315 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
316 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
317 { WM_SETFOCUS, sent },/* in the MDI client */
318 { HCBT_SETFOCUS, hook },
319 { WM_KILLFOCUS, sent },/* in the MDI client */
320 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
321 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 }, /* in the 1st MDI child */
322 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
323 { WM_SETFOCUS, sent|defwinproc }, /* in the 1st MDI child */
324 { WM_MDIACTIVATE, sent|defwinproc },/* in the 1st MDI child */
325 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE }, /* in the 1st MDI child */
326 { 0 }
327 };
328
329 /* Switch visible not maximized mdi children */
330 static const struct message WmSwitchNotMaximizedChild[] = {
331 /* Switch not maximized MDI child */
332 { WM_MDIACTIVATE, sent },/* in the MDI client */
333 { WM_WINDOWPOSCHANGING, sent|wparam,SWP_NOSIZE|SWP_NOMOVE },/* in the 2nd MDI child */
334 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
335 { WM_CHILDACTIVATE, sent },/* in the 2nd MDI child */
336 /* Deactivate 1st MDI child */
337 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
338 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
339 /* Activate 2nd MDI child */
340 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE}, /* in the 2nd MDI child */
341 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 }, /* in the 2nd MDI child */
342 { HCBT_SETFOCUS, hook }, /* in the 1st MDI child */
343 { WM_KILLFOCUS, sent|defwinproc }, /* in the 1st MDI child */
344 { WM_IME_SETCONTEXT, sent|defwinproc|optional }, /* in the 1st MDI child */
345 { WM_IME_SETCONTEXT, sent|optional }, /* in the MDI client */
346 { WM_SETFOCUS, sent, 0 }, /* in the MDI client */
347 { HCBT_SETFOCUS, hook },
348 { WM_KILLFOCUS, sent }, /* in the MDI client */
349 { WM_IME_SETCONTEXT, sent|optional }, /* in the MDI client */
350 { WM_IME_SETCONTEXT, sent|defwinproc|optional }, /* in the 1st MDI child */
351 { WM_SETFOCUS, sent|defwinproc }, /* in the 2nd MDI child */
352 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 2nd MDI child */
353 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE}, /* in the 2nd MDI child */
354 { 0 }
355 };
356
357
358 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|
359 SWP_NOZORDER|SWP_FRAMECHANGED)
360 * for a visible overlapped window with WS_CLIPCHILDREN style set.
361 */
362 static const struct message WmSWP_FrameChanged_clip[] = {
363 { WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED },
364 { WM_NCCALCSIZE, sent|wparam|parent, 1 },
365 { WM_NCPAINT, sent|parent }, /* wparam != 1 */
366 { WM_GETTEXT, sent|parent|defwinproc|optional },
367 { WM_ERASEBKGND, sent|parent|optional }, /* FIXME: remove optional once Wine is fixed */
368 { WM_NCPAINT, sent }, /* wparam != 1 */
369 { WM_ERASEBKGND, sent },
370 { WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
371 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
372 { WM_PAINT, sent },
373 { 0 }
374 };
375 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|
376 SWP_NOZORDER|SWP_FRAMECHANGED)
377 * for a visible overlapped window.
378 */
379 static const struct message WmSWP_FrameChangedDeferErase[] = {
380 { WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|SWP_FRAMECHANGED },
381 { WM_NCCALCSIZE, sent|wparam|parent, 1 },
382 { WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
383 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
384 { WM_PAINT, sent|parent },
385 { WM_NCPAINT, sent|beginpaint|parent }, /* wparam != 1 */
386 { WM_GETTEXT, sent|beginpaint|parent|defwinproc|optional },
387 { WM_PAINT, sent },
388 { WM_NCPAINT, sent|beginpaint }, /* wparam != 1 */
389 { WM_ERASEBKGND, sent|beginpaint },
390 { 0 }
391 };
392
393 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|
394 SWP_NOZORDER|SWP_FRAMECHANGED)
395 * for a visible overlapped window without WS_CLIPCHILDREN style set.
396 */
397 static const struct message WmSWP_FrameChanged_noclip[] = {
398 { WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED },
399 { WM_NCCALCSIZE, sent|wparam|parent, 1 },
400 { WM_NCPAINT, sent|parent }, /* wparam != 1 */
401 { WM_GETTEXT, sent|parent|defwinproc|optional },
402 { WM_ERASEBKGND, sent|parent|optional }, /* FIXME: remove optional once Wine is fixed */
403 { WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
404 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
405 { WM_PAINT, sent },
406 { WM_NCPAINT, sent|beginpaint }, /* wparam != 1 */
407 { WM_ERASEBKGND, sent|beginpaint },
408 { 0 }
409 };
410
411 /* ShowWindow(SW_SHOW) for a not visible overlapped window */
412 static const struct message WmShowOverlappedSeq[] = {
413 { WM_SHOWWINDOW, sent|wparam, 1 },
414 { WM_NCPAINT, sent|wparam|optional, 1 },
415 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
416 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
417 { WM_NCPAINT, sent|wparam|optional, 1 },
418 { WM_GETTEXT, sent|defwinproc|optional },
419 { WM_ERASEBKGND, sent|optional },
420 { HCBT_ACTIVATE, hook },
421 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
422 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
423 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
424 { WM_NCPAINT, sent|wparam|optional, 1 },
425 { WM_ACTIVATEAPP, sent|wparam, 1 },
426 { WM_NCACTIVATE, sent|wparam, 1 },
427 { WM_GETTEXT, sent|defwinproc|optional },
428 { WM_ACTIVATE, sent|wparam, 1 },
429 { HCBT_SETFOCUS, hook },
430 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
431 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
432 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
433 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
434 { WM_GETTEXT, sent|optional },
435 { WM_NCPAINT, sent|wparam|optional, 1 },
436 { WM_GETTEXT, sent|defwinproc|optional },
437 { WM_ERASEBKGND, sent|optional },
438 /* Win9x adds SWP_NOZORDER below */
439 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
440 { WM_NCCALCSIZE, sent|optional },
441 { WM_GETTEXT, sent|optional },
442 { WM_NCPAINT, sent|optional },
443 { WM_ERASEBKGND, sent|optional },
444 #if 0 /* CreateWindow/ShowWindow(SW_SHOW) also generates WM_SIZE/WM_MOVE
445 * messages. Does that mean that CreateWindow doesn't set initial
446 * window dimensions for overlapped windows?
447 */
448 { WM_SIZE, sent },
449 { WM_MOVE, sent },
450 #endif
451 { WM_PAINT, sent|optional },
452 { WM_NCPAINT, sent|beginpaint|optional },
453 { 0 }
454 };
455 /* ShowWindow(SW_SHOWMAXIMIZED) for a not visible overlapped window */
456 static const struct message WmShowMaxOverlappedSeq[] = {
457 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
458 { WM_GETMINMAXINFO, sent },
459 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
460 { WM_GETMINMAXINFO, sent|defwinproc },
461 { WM_NCCALCSIZE, sent|wparam, TRUE },
462 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
463 { HCBT_ACTIVATE, hook },
464 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
465 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
466 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
467 { WM_ACTIVATEAPP, sent|wparam, 1 },
468 { WM_NCACTIVATE, sent|wparam, 1 },
469 { WM_GETTEXT, sent|defwinproc|optional },
470 { WM_ACTIVATE, sent|wparam, 1 },
471 { HCBT_SETFOCUS, hook },
472 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
473 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
474 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
475 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
476 { WM_GETTEXT, sent|optional },
477 { WM_NCPAINT, sent|wparam|optional, 1 },
478 { WM_GETTEXT, sent|defwinproc|optional },
479 { WM_ERASEBKGND, sent|optional },
480 /* Win9x adds SWP_NOZORDER below */
481 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
482 { WM_MOVE, sent|defwinproc },
483 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
484 { WM_GETTEXT, sent|optional },
485 { WM_NCCALCSIZE, sent|optional },
486 { WM_NCPAINT, sent|optional },
487 { WM_ERASEBKGND, sent|optional },
488 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
489 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
490 { WM_PAINT, sent|optional },
491 { WM_NCPAINT, sent|beginpaint|optional },
492 { WM_ERASEBKGND, sent|beginpaint|optional },
493 { 0 }
494 };
495 /* ShowWindow(SW_RESTORE) for a not visible maximized overlapped window */
496 static const struct message WmShowRestoreMaxOverlappedSeq[] = {
497 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
498 { WM_GETTEXT, sent|optional },
499 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
500 { WM_GETMINMAXINFO, sent|defwinproc },
501 { WM_NCCALCSIZE, sent|wparam, TRUE },
502 { WM_NCPAINT, sent|optional },
503 { WM_GETTEXT, sent|defwinproc|optional },
504 { WM_ERASEBKGND, sent|optional },
505 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
506 { WM_MOVE, sent|defwinproc|optional },
507 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
508 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
509 { WM_NCPAINT, sent|optional },
510 { WM_ERASEBKGND, sent|optional },
511 { WM_PAINT, sent|optional },
512 { WM_NCPAINT, sent|beginpaint|optional },
513 { WM_ERASEBKGND, sent|beginpaint|optional },
514 { 0 }
515 };
516 /* ShowWindow(SW_RESTORE) for a not visible minimized overlapped window */
517 static const struct message WmShowRestoreMinOverlappedSeq[] = {
518 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
519 { WM_QUERYOPEN, sent|optional },
520 { WM_GETTEXT, sent|optional },
521 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED|SWP_NOCOPYBITS },
522 { WM_GETMINMAXINFO, sent|defwinproc },
523 { WM_NCCALCSIZE, sent|wparam, TRUE },
524 { HCBT_ACTIVATE, hook },
525 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
526 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
527 { WM_ACTIVATEAPP, sent|wparam, 1 },
528 { WM_NCACTIVATE, sent|wparam, 1 },
529 { WM_GETTEXT, sent|defwinproc|optional },
530 { WM_ACTIVATE, sent|wparam, 1 },
531 { HCBT_SETFOCUS, hook },
532 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
533 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
534 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
535 { WM_GETTEXT, sent|optional },
536 { WM_NCPAINT, sent|wparam|optional, 1 },
537 { WM_GETTEXT, sent|defwinproc|optional },
538 { WM_ERASEBKGND, sent },
539 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_STATECHANGED|SWP_FRAMECHANGED|SWP_NOCOPYBITS },
540 { WM_MOVE, sent|defwinproc },
541 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
542 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
543 { WM_NCPAINT, sent|wparam|optional, 1 },
544 { WM_ERASEBKGND, sent|optional },
545 { WM_ACTIVATE, sent|wparam, 1 },
546 { WM_GETTEXT, sent|optional },
547 { WM_PAINT, sent|optional },
548 { WM_NCPAINT, sent|beginpaint|optional },
549 { WM_ERASEBKGND, sent|beginpaint|optional },
550 { 0 }
551 };
552 /* ShowWindow(SW_SHOWMINIMIZED) for a not visible overlapped window */
553 static const struct message WmShowMinOverlappedSeq[] = {
554 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
555 { HCBT_SETFOCUS, hook },
556 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
557 { WM_KILLFOCUS, sent },
558 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
559 { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
560 { WM_GETTEXT, sent|optional },
561 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOCOPYBITS|SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
562 { WM_GETMINMAXINFO, sent|defwinproc },
563 { WM_NCCALCSIZE, sent|wparam, TRUE },
564 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
565 { WM_NCPAINT, sent|optional },
566 { WM_GETTEXT, sent|defwinproc|optional },
567 { WM_WINDOWPOSCHANGED, sent },
568 { WM_MOVE, sent|defwinproc },
569 { WM_SIZE, sent|defwinproc|wparam, SIZE_MINIMIZED },
570 { WM_NCCALCSIZE, sent|optional },
571 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
572 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
573 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, 0, 0 },
574 { WM_NCACTIVATE, sent|wparam, 0 },
575 { WM_GETTEXT, sent|defwinproc|optional },
576 { WM_ACTIVATE, sent },
577 { WM_ACTIVATEAPP, sent|wparam, 0 },
578 { WM_SYSCOMMAND, sent|optional|wparam, SC_RESTORE },
579 { HCBT_SYSCOMMAND, hook|optional|wparam, SC_RESTORE },
580 { WM_PAINT, sent|optional },
581 { WM_NCPAINT, sent|beginpaint|optional },
582 { WM_ERASEBKGND, sent|beginpaint|optional },
583 { 0 }
584 };
585 /* ShowWindow(SW_HIDE) for a visible overlapped window */
586 static const struct message WmHideOverlappedSeq[] = {
587 { WM_SHOWWINDOW, sent|wparam, 0 },
588 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
589 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
590 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
591 { WM_SIZE, sent|optional }, /* XP doesn't send it */
592 { WM_MOVE, sent|optional }, /* XP doesn't send it */
593 { WM_NCACTIVATE, sent|wparam, 0 },
594 { WM_ACTIVATE, sent|wparam, 0 },
595 { WM_ACTIVATEAPP, sent|wparam, 0 },
596 { WM_KILLFOCUS, sent|wparam, 0 },
597 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
598 { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
599 { 0 }
600 };
601 /* DestroyWindow for a visible overlapped window */
602 static const struct message WmDestroyOverlappedSeq[] = {
603 { HCBT_DESTROYWND, hook },
604 { 0x0090, sent|optional },
605 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
606 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
607 { 0x0090, sent|optional },
608 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
609 { WM_NCACTIVATE, sent|optional|wparam, 0 },
610 { WM_ACTIVATE, sent|optional|wparam, 0 },
611 { WM_ACTIVATEAPP, sent|optional|wparam, 0 },
612 { WM_KILLFOCUS, sent|optional|wparam, 0 },
613 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
614 { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
615 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
616 { WM_DESTROY, sent },
617 { WM_NCDESTROY, sent },
618 { 0 }
619 };
620 /* CreateWindow(WS_MAXIMIZE|WS_VISIBLE) for popup window */
621 static const struct message WmCreateMaxPopupSeq[] = {
622 { HCBT_CREATEWND, hook },
623 { WM_NCCREATE, sent },
624 { WM_NCCALCSIZE, sent|wparam, 0 },
625 { WM_CREATE, sent },
626 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
627 { WM_SIZE, sent|wparam, SIZE_RESTORED },
628 { WM_MOVE, sent },
629 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
630 { WM_GETMINMAXINFO, sent },
631 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED },
632 { WM_NCCALCSIZE, sent|wparam, TRUE },
633 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_STATECHANGED },
634 { WM_MOVE, sent|defwinproc },
635 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
636 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
637 { WM_SHOWWINDOW, sent|wparam, 1 },
638 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
639 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
640 { HCBT_ACTIVATE, hook },
641 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
642 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
643 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
644 { WM_NCPAINT, sent|wparam|optional, 1 },
645 { WM_ERASEBKGND, sent|optional },
646 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOCLIENTMOVE|SWP_NOCLIENTSIZE|SWP_NOMOVE|SWP_NOSIZE },
647 { WM_ACTIVATEAPP, sent|wparam, 1 },
648 { WM_NCACTIVATE, sent|wparam, 1 },
649 { WM_ACTIVATE, sent|wparam, 1 },
650 { HCBT_SETFOCUS, hook },
651 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
652 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
653 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
654 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
655 { WM_GETTEXT, sent|optional },
656 { WM_SYNCPAINT, sent|wparam|optional, 4 },
657 { WM_NCPAINT, sent|wparam|optional, 1 },
658 { WM_ERASEBKGND, sent|optional },
659 { WM_NCPAINT, sent|wparam|defwinproc|optional, 1 },
660 { WM_ERASEBKGND, sent|defwinproc|optional },
661 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTMOVE|SWP_NOCLIENTSIZE|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOSIZE },
662 { 0 }
663 };
664 /* CreateWindow(WS_MAXIMIZE) for popup window, not initially visible */
665 static const struct message WmCreateInvisibleMaxPopupSeq[] = {
666 { HCBT_CREATEWND, hook },
667 { WM_NCCREATE, sent },
668 { WM_NCCALCSIZE, sent|wparam, 0 },
669 { WM_CREATE, sent },
670 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
671 { WM_SIZE, sent|wparam, SIZE_RESTORED },
672 { WM_MOVE, sent },
673 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
674 { WM_GETMINMAXINFO, sent },
675 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED },
676 { WM_NCCALCSIZE, sent|wparam, TRUE },
677 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_STATECHANGED },
678 { WM_MOVE, sent|defwinproc },
679 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
680 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
681 { 0 }
682 };
683 /* ShowWindow(SW_SHOWMAXIMIZED) for a resized not visible popup window */
684 static const struct message WmShowMaxPopupResizedSeq[] = {
685 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
686 { WM_GETMINMAXINFO, sent },
687 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED },
688 { WM_NCCALCSIZE, sent|wparam, TRUE },
689 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
690 { HCBT_ACTIVATE, hook },
691 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
692 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
693 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
694 { WM_NCPAINT, sent|wparam|optional, 1 },
695 { WM_ERASEBKGND, sent|optional },
696 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
697 { WM_ACTIVATEAPP, sent|wparam, 1 },
698 { WM_NCACTIVATE, sent|wparam, 1 },
699 { WM_ACTIVATE, sent|wparam, 1 },
700 { HCBT_SETFOCUS, hook },
701 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
702 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
703 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
704 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
705 { WM_GETTEXT, sent|optional },
706 { WM_NCPAINT, sent|wparam|optional, 1 },
707 { WM_ERASEBKGND, sent|optional },
708 { WM_WINDOWPOSCHANGED, sent },
709 /* WinNT4.0 sends WM_MOVE */
710 { WM_MOVE, sent|defwinproc|optional },
711 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
712 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
713 { 0 }
714 };
715 /* ShowWindow(SW_SHOWMAXIMIZED) for a not visible popup window */
716 static const struct message WmShowMaxPopupSeq[] = {
717 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
718 { WM_GETMINMAXINFO, sent },
719 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED },
720 { WM_NCCALCSIZE, sent|wparam, TRUE },
721 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
722 { HCBT_ACTIVATE, hook },
723 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
724 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
725 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
726 { WM_ACTIVATEAPP, sent|wparam, 1 },
727 { WM_NCACTIVATE, sent|wparam, 1 },
728 { WM_ACTIVATE, sent|wparam, 1 },
729 { HCBT_SETFOCUS, hook },
730 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
731 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
732 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
733 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
734 { WM_GETTEXT, sent|optional },
735 { WM_SYNCPAINT, sent|wparam|optional, 4 },
736 { WM_NCPAINT, sent|wparam|optional, 1 },
737 { WM_ERASEBKGND, sent|optional },
738 { WM_NCPAINT, sent|wparam|defwinproc|optional, 1 },
739 { WM_ERASEBKGND, sent|defwinproc|optional },
740 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOSIZE },
741 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
742 { 0 }
743 };
744 /* CreateWindow(WS_VISIBLE) for popup window */
745 static const struct message WmCreatePopupSeq[] = {
746 { HCBT_CREATEWND, hook },
747 { WM_NCCREATE, sent },
748 { WM_NCCALCSIZE, sent|wparam, 0 },
749 { WM_CREATE, sent },
750 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
751 { WM_SIZE, sent|wparam, SIZE_RESTORED },
752 { WM_MOVE, sent },
753 { WM_SHOWWINDOW, sent|wparam, 1 },
754 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
755 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
756 { HCBT_ACTIVATE, hook },
757 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
758 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
759 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
760 { WM_NCPAINT, sent|wparam|optional, 1 },
761 { WM_ERASEBKGND, sent|optional },
762 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
763 { WM_ACTIVATEAPP, sent|wparam, 1 },
764 { WM_NCACTIVATE, sent|wparam, 1 },
765 { WM_ACTIVATE, sent|wparam, 1 },
766 { HCBT_SETFOCUS, hook },
767 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
768 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
769 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
770 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
771 { WM_GETTEXT, sent|optional },
772 { WM_SYNCPAINT, sent|wparam|optional, 4 },
773 { WM_NCPAINT, sent|wparam|optional, 1 },
774 { WM_ERASEBKGND, sent|optional },
775 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTMOVE|SWP_NOCLIENTSIZE|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOSIZE },
776 { 0 }
777 };
778 /* ShowWindow(SW_SHOWMAXIMIZED) for a visible popup window */
779 static const struct message WmShowVisMaxPopupSeq[] = {
780 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
781 { WM_GETMINMAXINFO, sent },
782 { WM_GETTEXT, sent|optional },
783 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
784 { WM_GETTEXT, sent|optional },
785 { WM_NCCALCSIZE, sent|wparam, TRUE },
786 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
787 { WM_NCPAINT, sent|wparam|optional, 1 },
788 { WM_ERASEBKGND, sent|optional },
789 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
790 { WM_MOVE, sent|defwinproc },
791 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
792 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
793 { 0 }
794 };
795 /* CreateWindow (for a child popup window, not initially visible) */
796 static const struct message WmCreateChildPopupSeq[] = {
797 { HCBT_CREATEWND, hook },
798 { WM_NCCREATE, sent },
799 { WM_NCCALCSIZE, sent|wparam, 0 },
800 { WM_CREATE, sent },
801 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
802 { WM_SIZE, sent|wparam, SIZE_RESTORED },
803 { WM_MOVE, sent },
804 { 0 }
805 };
806 /* CreateWindow (for a popup window, not initially visible,
807 * which sets WS_VISIBLE in WM_CREATE handler)
808 */
809 static const struct message WmCreateInvisiblePopupSeq[] = {
810 { HCBT_CREATEWND, hook },
811 { WM_NCCREATE, sent },
812 { WM_NCCALCSIZE, sent|wparam, 0 },
813 { WM_CREATE, sent },
814 { WM_STYLECHANGING, sent },
815 { WM_STYLECHANGED, sent },
816 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
817 { WM_SIZE, sent|wparam, SIZE_RESTORED },
818 { WM_MOVE, sent },
819 { 0 }
820 };
821 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER)
822 * for a popup window with WS_VISIBLE style set
823 */
824 static const struct message WmShowVisiblePopupSeq_2[] = {
825 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
826 { 0 }
827 };
828 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
829 * for a popup window with WS_VISIBLE style set
830 */
831 static const struct message WmShowVisiblePopupSeq_3[] = {
832 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
833 { HCBT_ACTIVATE, hook },
834 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
835 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
836 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
837 { WM_NCACTIVATE, sent|wparam, 1 },
838 { WM_ACTIVATE, sent|wparam, 1 },
839 { HCBT_SETFOCUS, hook },
840 { WM_KILLFOCUS, sent|parent },
841 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
842 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
843 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
844 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
845 { WM_SETFOCUS, sent|defwinproc },
846 { WM_GETTEXT, sent|optional },
847 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
848 { 0 }
849 };
850 /* CreateWindow (for child window, not initially visible) */
851 static const struct message WmCreateChildSeq[] = {
852 { HCBT_CREATEWND, hook },
853 { WM_NCCREATE, sent },
854 /* child is inserted into parent's child list after WM_NCCREATE returns */
855 { WM_NCCALCSIZE, sent|wparam, 0 },
856 { WM_CREATE, sent },
857 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
858 { WM_SIZE, sent|wparam, SIZE_RESTORED },
859 { WM_MOVE, sent },
860 { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
861 { 0 }
862 };
863 /* CreateWindow (for maximized child window, not initially visible) */
864 static const struct message WmCreateMaximizedChildSeq[] = {
865 { HCBT_CREATEWND, hook },
866 { WM_NCCREATE, sent },
867 { WM_NCCALCSIZE, sent|wparam, 0 },
868 { WM_CREATE, sent },
869 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
870 { WM_SIZE, sent|wparam, SIZE_RESTORED },
871 { WM_MOVE, sent },
872 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
873 { WM_GETMINMAXINFO, sent },
874 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
875 { WM_NCCALCSIZE, sent|wparam, 1 },
876 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
877 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
878 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
879 { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
880 { 0 }
881 };
882 /* CreateWindow (for a child window, initially visible) */
883 static const struct message WmCreateVisibleChildSeq[] = {
884 { HCBT_CREATEWND, hook },
885 { WM_NCCREATE, sent },
886 /* child is inserted into parent's child list after WM_NCCREATE returns */
887 { WM_NCCALCSIZE, sent|wparam, 0 },
888 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
889 { WM_CREATE, sent },
890 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
891 { WM_SIZE, sent|wparam, SIZE_RESTORED },
892 { WM_MOVE, sent },
893 { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
894 { WM_SHOWWINDOW, sent|wparam, 1 },
895 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
896 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
897 { WM_ERASEBKGND, sent|parent|optional },
898 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
899 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* WinXP */
900 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
901 { 0 }
902 };
903 /* ShowWindow(SW_SHOW) for a not visible child window */
904 static const struct message WmShowChildSeq[] = {
905 { WM_SHOWWINDOW, sent|wparam, 1 },
906 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
907 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
908 { WM_ERASEBKGND, sent|parent|optional },
909 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
910 { 0 }
911 };
912 /* ShowWindow(SW_HIDE) for a visible child window */
913 static const struct message WmHideChildSeq[] = {
914 { WM_SHOWWINDOW, sent|wparam, 0 },
915 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
916 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
917 { WM_ERASEBKGND, sent|parent|optional },
918 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
919 { 0 }
920 };
921 /* ShowWindow(SW_HIDE) for a visible child window checking all parent events*/
922 static const struct message WmHideChildSeq2[] = {
923 { WM_SHOWWINDOW, sent|wparam, 0 },
924 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
925 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
926 { WM_ERASEBKGND, sent|parent|optional },
927 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
928 { 0 }
929 };
930 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
931 * for a not visible child window
932 */
933 static const struct message WmShowChildSeq_2[] = {
934 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
935 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
936 { WM_CHILDACTIVATE, sent },
937 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
938 { 0 }
939 };
940 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE)
941 * for a not visible child window
942 */
943 static const struct message WmShowChildSeq_3[] = {
944 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
945 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
946 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
947 { 0 }
948 };
949 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
950 * for a visible child window with a caption
951 */
952 static const struct message WmShowChildSeq_4[] = {
953 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
954 { WM_CHILDACTIVATE, sent },
955 { 0 }
956 };
957 /* ShowWindow(SW_MINIMIZE) for child with invisible parent */
958 static const struct message WmShowChildInvisibleParentSeq_1[] = {
959 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
960 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
961 { WM_NCCALCSIZE, sent|wparam, 1 },
962 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
963 { WM_CHILDACTIVATE, sent|optional },
964 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
965 { WM_MOVE, sent|defwinproc },
966 { WM_SIZE, sent|defwinproc|wparam, SIZE_MINIMIZED },
967 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
968 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, 0, 0 },
969 /* FIXME: Wine creates an icon/title window while Windows doesn't */
970 { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE },
971 { WM_GETTEXT, sent|optional },
972 { 0 }
973 };
974 /* repeated ShowWindow(SW_MINIMIZE) for child with invisible parent */
975 static const struct message WmShowChildInvisibleParentSeq_1r[] = {
976 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
977 { 0 }
978 };
979 /* ShowWindow(SW_MAXIMIZE) for child with invisible parent */
980 static const struct message WmShowChildInvisibleParentSeq_2[] = {
981 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
982 { WM_GETMINMAXINFO, sent },
983 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
984 { WM_NCCALCSIZE, sent|wparam, 1 },
985 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
986 { WM_CHILDACTIVATE, sent },
987 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
988 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
989 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
990 { 0 }
991 };
992 /* repeated ShowWindow(SW_MAXIMIZE) for child with invisible parent */
993 static const struct message WmShowChildInvisibleParentSeq_2r[] = {
994 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
995 { 0 }
996 };
997 /* ShowWindow(SW_SHOWMINIMIZED) for child with invisible parent */
998 static const struct message WmShowChildInvisibleParentSeq_3[] = {
999 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
1000 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
1001 { WM_NCCALCSIZE, sent|wparam, 1 },
1002 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1003 { WM_CHILDACTIVATE, sent },
1004 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_NOCOPYBITS|SWP_STATECHANGED },
1005 { WM_MOVE, sent|defwinproc },
1006 { WM_SIZE, sent|defwinproc|wparam, SIZE_MINIMIZED },
1007 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1008 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, 0, 0 },
1009 /* FIXME: Wine creates an icon/title window while Windows doesn't */
1010 { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE },
1011 { WM_GETTEXT, sent|optional },
1012 { 0 }
1013 };
1014 /* repeated ShowWindow(SW_SHOWMINIMIZED) for child with invisible parent */
1015 static const struct message WmShowChildInvisibleParentSeq_3r[] = {
1016 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
1017 { 0 }
1018 };
1019 /* ShowWindow(SW_SHOWMINNOACTIVE) for child with invisible parent */
1020 static const struct message WmShowChildInvisibleParentSeq_4[] = {
1021 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
1022 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_STATECHANGED },
1023 { WM_NCCALCSIZE, sent|wparam, 1 },
1024 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1025 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_NOCOPYBITS|SWP_STATECHANGED },
1026 { WM_MOVE, sent|defwinproc },
1027 { WM_SIZE, sent|defwinproc|wparam, SIZE_MINIMIZED },
1028 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1029 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, 0, 0 },
1030 /* FIXME: Wine creates an icon/title window while Windows doesn't */
1031 { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE },
1032 { WM_GETTEXT, sent|optional },
1033 { 0 }
1034 };
1035 /* repeated ShowWindow(SW_SHOWMINNOACTIVE) for child with invisible parent */
1036 static const struct message WmShowChildInvisibleParentSeq_4r[] = {
1037 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
1038 { 0 }
1039 };
1040 /* ShowWindow(SW_SHOW) for child with invisible parent */
1041 static const struct message WmShowChildInvisibleParentSeq_5[] = {
1042 { WM_SHOWWINDOW, sent|wparam, 1 },
1043 { 0 }
1044 };
1045 /* ShowWindow(SW_HIDE) for child with invisible parent */
1046 static const struct message WmHideChildInvisibleParentSeq[] = {
1047 { WM_SHOWWINDOW, sent|wparam, 0 },
1048 { 0 }
1049 };
1050 /* SetWindowPos(SWP_SHOWWINDOW) for child with invisible parent */
1051 static const struct message WmShowChildInvisibleParentSeq_6[] = {
1052 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1053 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1054 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1055 { 0 }
1056 };
1057 /* SetWindowPos(SWP_HIDEWINDOW) for child with invisible parent */
1058 static const struct message WmHideChildInvisibleParentSeq_2[] = {
1059 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1060 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1061 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1062 { 0 }
1063 };
1064 /* DestroyWindow for a visible child window */
1065 static const struct message WmDestroyChildSeq[] = {
1066 { HCBT_DESTROYWND, hook },
1067 { 0x0090, sent|optional },
1068 { WM_PARENTNOTIFY, sent|parent|wparam, WM_DESTROY },
1069 { WM_SHOWWINDOW, sent|wparam, 0 },
1070 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1071 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1072 { WM_ERASEBKGND, sent|parent|optional },
1073 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1074 { HCBT_SETFOCUS, hook }, /* set focus to a parent */
1075 { WM_KILLFOCUS, sent },
1076 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1077 { WM_IME_SETCONTEXT, sent|wparam|parent|optional, 1 },
1078 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1079 { WM_SETFOCUS, sent|parent },
1080 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1081 { WM_DESTROY, sent },
1082 { WM_DESTROY, sent|optional }, /* some other (IME?) window */
1083 { WM_NCDESTROY, sent|optional }, /* some other (IME?) window */
1084 { WM_NCDESTROY, sent },
1085 { 0 }
1086 };
1087 /* DestroyWindow for a visible child window with invisible parent */
1088 static const struct message WmDestroyInvisibleChildSeq[] = {
1089 { HCBT_DESTROYWND, hook },
1090 { 0x0090, sent|optional },
1091 { WM_PARENTNOTIFY, sent|parent|wparam, WM_DESTROY },
1092 { WM_SHOWWINDOW, sent|wparam, 0 },
1093 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1094 { WM_DESTROY, sent },
1095 { WM_NCDESTROY, sent },
1096 { 0 }
1097 };
1098 /* Moving the mouse in nonclient area */
1099 static const struct message WmMouseMoveInNonClientAreaSeq[] = { /* FIXME: add */
1100 { WM_NCHITTEST, sent },
1101 { WM_SETCURSOR, sent },
1102 { WM_NCMOUSEMOVE, posted },
1103 { 0 }
1104 };
1105 /* Moving the mouse in client area */
1106 static const struct message WmMouseMoveInClientAreaSeq[] = { /* FIXME: add */
1107 { WM_NCHITTEST, sent },
1108 { WM_SETCURSOR, sent },
1109 { WM_MOUSEMOVE, posted },
1110 { 0 }
1111 };
1112 /* Moving by dragging the title bar (after WM_NCHITTEST and WM_SETCURSOR) (outline move) */
1113 static const struct message WmDragTitleBarSeq[] = { /* FIXME: add */
1114 { WM_NCLBUTTONDOWN, sent|wparam, HTCAPTION },
1115 { WM_SYSCOMMAND, sent|defwinproc|wparam, SC_MOVE+2 },
1116 { WM_GETMINMAXINFO, sent|defwinproc },
1117 { WM_ENTERSIZEMOVE, sent|defwinproc },
1118 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, 0 },
1119 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, 0 },
1120 { WM_MOVE, sent|defwinproc },
1121 { WM_EXITSIZEMOVE, sent|defwinproc },
1122 { 0 }
1123 };
1124 /* Sizing by dragging the thick borders (after WM_NCHITTEST and WM_SETCURSOR) (outline move) */
1125 static const struct message WmDragThickBordersBarSeq[] = { /* FIXME: add */
1126 { WM_NCLBUTTONDOWN, sent|wparam, 0xd },
1127 { WM_SYSCOMMAND, sent|defwinproc|wparam, 0xf004 },
1128 { WM_GETMINMAXINFO, sent|defwinproc },
1129 { WM_ENTERSIZEMOVE, sent|defwinproc },
1130 { WM_SIZING, sent|defwinproc|wparam, 4}, /* one for each mouse movement */
1131 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, 0 },
1132 { WM_GETMINMAXINFO, sent|defwinproc },
1133 { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
1134 { WM_NCPAINT, sent|defwinproc|wparam, 1 },
1135 { WM_GETTEXT, sent|defwinproc },
1136 { WM_ERASEBKGND, sent|defwinproc },
1137 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, 0 },
1138 { WM_MOVE, sent|defwinproc },
1139 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1140 { WM_EXITSIZEMOVE, sent|defwinproc },
1141 { 0 }
1142 };
1143 /* Resizing child window with MoveWindow (32) */
1144 static const struct message WmResizingChildWithMoveWindowSeq[] = {
1145 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
1146 { WM_NCCALCSIZE, sent|wparam, 1 },
1147 { WM_ERASEBKGND, sent|parent|optional },
1148 { WM_ERASEBKGND, sent|optional },
1149 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE },
1150 { WM_MOVE, sent|defwinproc },
1151 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1152 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1153 { 0 }
1154 };
1155 /* Clicking on inactive button */
1156 static const struct message WmClickInactiveButtonSeq[] = { /* FIXME: add */
1157 { WM_NCHITTEST, sent },
1158 { WM_PARENTNOTIFY, sent|parent|wparam, WM_LBUTTONDOWN },
1159 { WM_MOUSEACTIVATE, sent },
1160 { WM_MOUSEACTIVATE, sent|parent|defwinproc },
1161 { WM_SETCURSOR, sent },
1162 { WM_SETCURSOR, sent|parent|defwinproc },
1163 { WM_LBUTTONDOWN, posted },
1164 { WM_KILLFOCUS, posted|parent },
1165 { WM_SETFOCUS, posted },
1166 { WM_CTLCOLORBTN, posted|parent },
1167 { BM_SETSTATE, posted },
1168 { WM_CTLCOLORBTN, posted|parent },
1169 { WM_LBUTTONUP, posted },
1170 { BM_SETSTATE, posted },
1171 { WM_CTLCOLORBTN, posted|parent },
1172 { WM_COMMAND, posted|parent },
1173 { 0 }
1174 };
1175 /* Reparenting a button (16/32) */
1176 /* The last child (button) reparented gets topmost for its new parent. */
1177 static const struct message WmReparentButtonSeq[] = { /* FIXME: add */
1178 { WM_SHOWWINDOW, sent|wparam, 0 },
1179 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE },
1180 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1181 { WM_ERASEBKGND, sent|parent },
1182 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE },
1183 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE },
1184 { WM_CHILDACTIVATE, sent },
1185 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOREDRAW },
1186 { WM_MOVE, sent|defwinproc },
1187 { WM_SHOWWINDOW, sent|wparam, 1 },
1188 { 0 }
1189 };
1190 /* Creation of a custom dialog (32) */
1191 static const struct message WmCreateCustomDialogSeq[] = {
1192 { HCBT_CREATEWND, hook },
1193 { WM_GETMINMAXINFO, sent },
1194 { WM_NCCREATE, sent },
1195 { WM_NCCALCSIZE, sent|wparam, 0 },
1196 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1197 { WM_CREATE, sent },
1198 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1199 { WM_NOTIFYFORMAT, sent|optional },
1200 { WM_QUERYUISTATE, sent|optional },
1201 { WM_WINDOWPOSCHANGING, sent|optional },
1202 { WM_GETMINMAXINFO, sent|optional },
1203 { WM_NCCALCSIZE, sent|optional },
1204 { WM_WINDOWPOSCHANGED, sent|optional },
1205 { WM_SHOWWINDOW, sent|wparam, 1 },
1206 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1207 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1208 { HCBT_ACTIVATE, hook },
1209 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1210
1211
1212 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1213
1214 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
1215
1216 { WM_NCACTIVATE, sent|wparam, 1 },
1217 { WM_GETTEXT, sent|optional|defwinproc },
1218 { WM_GETTEXT, sent|optional|defwinproc },
1219 { WM_GETTEXT, sent|optional|defwinproc },
1220 { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
1221 { WM_ACTIVATE, sent|wparam, 1 },
1222 { WM_GETTEXT, sent|optional },
1223 { WM_KILLFOCUS, sent|parent },
1224 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1225 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1226 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1227 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1228 { WM_SETFOCUS, sent },
1229 { WM_GETDLGCODE, sent|defwinproc|wparam, 0 },
1230 { WM_NCPAINT, sent|wparam, 1 },
1231 { WM_GETTEXT, sent|optional|defwinproc },
1232 { WM_GETTEXT, sent|optional|defwinproc },
1233 { WM_ERASEBKGND, sent },
1234 { WM_CTLCOLORDLG, sent|defwinproc },
1235 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1236 { WM_GETTEXT, sent|optional },
1237 { WM_GETTEXT, sent|optional },
1238 { WM_NCCALCSIZE, sent|optional },
1239 { WM_NCPAINT, sent|optional },
1240 { WM_GETTEXT, sent|optional|defwinproc },
1241 { WM_GETTEXT, sent|optional|defwinproc },
1242 { WM_ERASEBKGND, sent|optional },
1243 { WM_CTLCOLORDLG, sent|optional|defwinproc },
1244 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1245 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1246 { WM_MOVE, sent },
1247 { 0 }
1248 };
1249 /* Calling EndDialog for a custom dialog (32) */
1250 static const struct message WmEndCustomDialogSeq[] = {
1251 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1252 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1253 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1254 { WM_GETTEXT, sent|optional },
1255 { HCBT_ACTIVATE, hook },
1256 { WM_NCACTIVATE, sent|wparam, 0 },
1257 { WM_GETTEXT, sent|optional|defwinproc },
1258 { WM_GETTEXT, sent|optional|defwinproc },
1259 { WM_ACTIVATE, sent|wparam, 0 },
1260 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1261 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1262 { HCBT_SETFOCUS, hook },
1263 { WM_KILLFOCUS, sent },
1264 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1265 { WM_IME_SETCONTEXT, sent|parent|wparam|defwinproc|optional, 1 },
1266 { WM_IME_NOTIFY, sent|wparam|optional, 1 },
1267 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1268 { WM_SETFOCUS, sent|parent|defwinproc },
1269 { 0 }
1270 };
1271 /* ShowWindow(SW_SHOW) for a custom dialog (initially invisible) */
1272 static const struct message WmShowCustomDialogSeq[] = {
1273 { WM_SHOWWINDOW, sent|wparam, 1 },
1274 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1275 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1276 { HCBT_ACTIVATE, hook },
1277 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1278
1279 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1280
1281 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
1282 { WM_ACTIVATEAPP, sent|wparam|optional, 1 },
1283 { WM_NCACTIVATE, sent|wparam, 1 },
1284 { WM_ACTIVATE, sent|wparam, 1 },
1285 { WM_GETTEXT, sent|optional },
1286
1287 { WM_KILLFOCUS, sent|parent },
1288 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1289 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1290 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1291 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1292 { WM_SETFOCUS, sent },
1293 { WM_GETDLGCODE, sent|defwinproc|wparam, 0 },
1294 { WM_NCPAINT, sent|wparam, 1 },
1295 { WM_ERASEBKGND, sent },
1296 { WM_CTLCOLORDLG, sent|defwinproc },
1297 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1298 { 0 }
1299 };
1300 /* Creation and destruction of a modal dialog (32) */
1301 static const struct message WmModalDialogSeq[] = {
1302 { WM_CANCELMODE, sent|parent },
1303 { HCBT_SETFOCUS, hook },
1304 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1305 { WM_KILLFOCUS, sent|parent },
1306 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1307 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1308 { WM_ENABLE, sent|parent|wparam, 0 },
1309 { HCBT_CREATEWND, hook },
1310 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1311 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1312 { WM_SETFONT, sent },
1313 { WM_INITDIALOG, sent },
1314 { WM_CHANGEUISTATE, sent|optional },
1315 { WM_UPDATEUISTATE, sent|optional },
1316 { WM_SHOWWINDOW, sent },
1317 { HCBT_ACTIVATE, hook },
1318 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1319 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1320 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
1321 { WM_NCACTIVATE, sent|wparam, 1 },
1322 { WM_GETTEXT, sent|optional },
1323 { WM_ACTIVATE, sent|wparam, 1 },
1324 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1325 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1326 { WM_NCPAINT, sent },
1327 { WM_GETTEXT, sent|optional },
1328 { WM_ERASEBKGND, sent },
1329 { WM_CTLCOLORDLG, sent },
1330 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1331 { WM_GETTEXT, sent|optional },
1332 { WM_NCCALCSIZE, sent|optional },
1333 { WM_NCPAINT, sent|optional },
1334 { WM_GETTEXT, sent|optional },
1335 { WM_ERASEBKGND, sent|optional },
1336 { WM_CTLCOLORDLG, sent|optional },
1337 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1338 { WM_PAINT, sent|optional },
1339 { WM_CTLCOLORBTN, sent },
1340 { WM_ENTERIDLE, sent|parent|optional },
1341 { WM_ENTERIDLE, sent|parent|optional },
1342 { WM_ENTERIDLE, sent|parent|optional },
1343 { WM_ENTERIDLE, sent|parent|optional },
1344 { WM_ENTERIDLE, sent|parent|optional },
1345 { WM_ENTERIDLE, sent|parent|optional },
1346 { WM_ENTERIDLE, sent|parent|optional },
1347 { WM_ENTERIDLE, sent|parent|optional },
1348 { WM_ENTERIDLE, sent|parent|optional },
1349 { WM_ENTERIDLE, sent|parent|optional },
1350 { WM_ENTERIDLE, sent|parent|optional },
1351 { WM_ENTERIDLE, sent|parent|optional },
1352 { WM_ENTERIDLE, sent|parent|optional },
1353 { WM_ENTERIDLE, sent|parent|optional },
1354 { WM_ENTERIDLE, sent|parent|optional },
1355 { WM_ENTERIDLE, sent|parent|optional },
1356 { WM_ENTERIDLE, sent|parent|optional },
1357 { WM_ENTERIDLE, sent|parent|optional },
1358 { WM_ENTERIDLE, sent|parent|optional },
1359 { WM_ENTERIDLE, sent|parent|optional },
1360 { WM_TIMER, sent },
1361 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1362 { WM_ENABLE, sent|parent|wparam, 1 },
1363 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1364 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1365 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1366 { WM_GETTEXT, sent|optional },
1367 { HCBT_ACTIVATE, hook },
1368 { WM_NCACTIVATE, sent|wparam, 0 },
1369 { WM_GETTEXT, sent|optional },
1370 { WM_ACTIVATE, sent|wparam, 0 },
1371 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1372 { WM_WINDOWPOSCHANGING, sent|optional },
1373 { WM_WINDOWPOSCHANGED, sent|optional },
1374 { HCBT_SETFOCUS, hook },
1375 { WM_IME_SETCONTEXT, sent|parent|wparam|defwinproc|optional, 1 },
1376 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1377 { WM_SETFOCUS, sent|parent|defwinproc },
1378 { EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam, 0, 0 },
1379 { HCBT_DESTROYWND, hook },
1380 { 0x0090, sent|optional },
1381 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1382 { WM_DESTROY, sent },
1383 { WM_NCDESTROY, sent },
1384 { 0 }
1385 };
1386 /* Creation of a modal dialog that is resized inside WM_INITDIALOG (32) */
1387 static const struct message WmCreateModalDialogResizeSeq[] = { /* FIXME: add */
1388 /* (inside dialog proc, handling WM_INITDIALOG) */
1389 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
1390 { WM_NCCALCSIZE, sent },
1391 { WM_NCACTIVATE, sent|parent|wparam, 0 },
1392 { WM_GETTEXT, sent|defwinproc },
1393 { WM_ACTIVATE, sent|parent|wparam, 0 },
1394 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
1395 { WM_WINDOWPOSCHANGING, sent|parent },
1396 { WM_NCACTIVATE, sent|wparam, 1 },
1397 { WM_ACTIVATE, sent|wparam, 1 },
1398 { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
1399 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1400 /* (setting focus) */
1401 { WM_SHOWWINDOW, sent|wparam, 1 },
1402 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
1403 { WM_NCPAINT, sent },
1404 { WM_GETTEXT, sent|defwinproc },
1405 { WM_ERASEBKGND, sent },
1406 { WM_CTLCOLORDLG, sent|defwinproc },
1407 { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
1408 { WM_PAINT, sent },
1409 /* (bunch of WM_CTLCOLOR* for each control) */
1410 { WM_PAINT, sent|parent },
1411 { WM_ENTERIDLE, sent|parent|wparam, 0 },
1412 { WM_SETCURSOR, sent|parent },
1413 { 0 }
1414 };
1415 /* SetMenu for NonVisible windows with size change*/
1416 static const struct message WmSetMenuNonVisibleSizeChangeSeq[] = {
1417 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1418 { WM_NCCALCSIZE, sent|wparam, 1 },
1419 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1420 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW },
1421 { WM_MOVE, sent|defwinproc },
1422 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1423 { WM_NCCALCSIZE,sent|wparam|optional, 1 }, /* XP */
1424 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1425 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
1426 { WM_GETTEXT, sent|optional },
1427 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
1428 { 0 }
1429 };
1430 /* SetMenu for NonVisible windows with no size change */
1431 static const struct message WmSetMenuNonVisibleNoSizeChangeSeq[] = {
1432 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1433 { WM_NCCALCSIZE, sent|wparam, 1 },
1434 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1435 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1436 { 0 }
1437 };
1438 /* SetMenu for Visible windows with size change */
1439 static const struct message WmSetMenuVisibleSizeChangeSeq[] = {
1440 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1441 { WM_NCCALCSIZE, sent|wparam, 1 },
1442 { 0x0093, sent|defwinproc|optional },
1443 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1444 { WM_NCPAINT, sent|optional }, /* wparam != 1 */
1445 { 0x0093, sent|defwinproc|optional },
1446 { 0x0093, sent|defwinproc|optional },
1447 { 0x0091, sent|defwinproc|optional },
1448 { 0x0092, sent|defwinproc|optional },
1449 { WM_GETTEXT, sent|defwinproc|optional },
1450 { WM_ERASEBKGND, sent|optional },
1451 { WM_ACTIVATE, sent|optional },
1452 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1453 { WM_MOVE, sent|defwinproc },
1454 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1455 { 0x0093, sent|optional },
1456 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
1457 { 0x0093, sent|defwinproc|optional },
1458 { WM_NCPAINT, sent|optional }, /* wparam != 1 */
1459 { 0x0093, sent|defwinproc|optional },
1460 { 0x0093, sent|defwinproc|optional },
1461 { 0x0091, sent|defwinproc|optional },
1462 { 0x0092, sent|defwinproc|optional },
1463 { WM_ERASEBKGND, sent|optional },
1464 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1465 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
1466 { 0 }
1467 };
1468 /* SetMenu for Visible windows with no size change */
1469 static const struct message WmSetMenuVisibleNoSizeChangeSeq[] = {
1470 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1471 { WM_NCCALCSIZE, sent|wparam, 1 },
1472 { WM_NCPAINT, sent|optional }, /* wparam != 1 */
1473 { WM_GETTEXT, sent|defwinproc|optional },
1474 { WM_ERASEBKGND, sent|optional },
1475 { WM_ACTIVATE, sent|optional },
1476 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1477 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1478 { 0 }
1479 };
1480 /* DrawMenuBar for a visible window */
1481 static const struct message WmDrawMenuBarSeq[] =
1482 {
1483 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1484 { WM_NCCALCSIZE, sent|wparam, 1 },
1485 { 0x0093, sent|defwinproc|optional },
1486 { WM_NCPAINT, sent|optional }, /* wparam != 1 */
1487 { 0x0093, sent|defwinproc|optional },
1488 { 0x0093, sent|defwinproc|optional },
1489 { 0x0091, sent|defwinproc|optional },
1490 { 0x0092, sent|defwinproc|optional },
1491 { WM_GETTEXT, sent|defwinproc|optional },
1492 { WM_ERASEBKGND, sent|optional },
1493 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1494 { 0x0093, sent|optional },
1495 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1496 { 0 }
1497 };
1498
1499 static const struct message WmSetRedrawFalseSeq[] =
1500 {
1501 { WM_SETREDRAW, sent|wparam, 0 },
1502 { 0 }
1503 };
1504
1505 static const struct message WmSetRedrawTrueSeq[] =
1506 {
1507 { WM_SETREDRAW, sent|wparam, 1 },
1508 { 0 }
1509 };
1510
1511 static const struct message WmEnableWindowSeq_1[] =
1512 {
1513 { WM_CANCELMODE, sent|wparam|lparam, 0, 0 },
1514 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1515 { WM_ENABLE, sent|wparam|lparam, FALSE, 0 },
1516 { 0 }
1517 };
1518
1519 static const struct message WmEnableWindowSeq_2[] =
1520 {
1521 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1522 { WM_ENABLE, sent|wparam|lparam, TRUE, 0 },
1523 { 0 }
1524 };
1525
1526 static const struct message WmGetScrollRangeSeq[] =
1527 {
1528 { SBM_GETRANGE, sent },
1529 { 0 }
1530 };
1531 static const struct message WmGetScrollInfoSeq[] =
1532 {
1533 { SBM_GETSCROLLINFO, sent },
1534 { 0 }
1535 };
1536 static const struct message WmSetScrollRangeSeq[] =
1537 {
1538 /* MSDN claims that Windows sends SBM_SETRANGE message, but win2k SP4
1539 sends SBM_SETSCROLLINFO.
1540 */
1541 { SBM_SETSCROLLINFO, sent },
1542 { 0 }
1543 };
1544 /* SetScrollRange for a window without a non-client area */
1545 static const struct message WmSetScrollRangeHSeq_empty[] =
1546 {
1547 { EVENT_OBJECT_VALUECHANGE, winevent_hook|wparam|lparam, OBJID_HSCROLL, 0 },
1548 { 0 }
1549 };
1550 static const struct message WmSetScrollRangeVSeq_empty[] =
1551 {
1552 { EVENT_OBJECT_VALUECHANGE, winevent_hook|wparam|lparam, OBJID_VSCROLL, 0 },
1553 { 0 }
1554 };
1555 static const struct message WmSetScrollRangeHVSeq[] =
1556 {
1557 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE },
1558 { WM_NCCALCSIZE, sent|wparam, 1 },
1559 { WM_GETTEXT, sent|defwinproc|optional },
1560 { WM_ERASEBKGND, sent|optional },
1561 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1562 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1563 { EVENT_OBJECT_VALUECHANGE, winevent_hook|lparam|optional, 0/*OBJID_HSCROLL or OBJID_VSCROLL*/, 0 },
1564 { 0 }
1565 };
1566 /* SetScrollRange for a window with a non-client area */
1567 static const struct message WmSetScrollRangeHV_NC_Seq[] =
1568 {
1569 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE },
1570 { WM_NCCALCSIZE, sent|wparam, 1 },
1571 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1572 { WM_NCPAINT, sent|optional },
1573 { WM_STYLECHANGING, sent|defwinproc|optional },
1574 { WM_STYLECHANGED, sent|defwinproc|optional },
1575 { WM_STYLECHANGING, sent|defwinproc|optional },
1576 { WM_STYLECHANGED, sent|defwinproc|optional },
1577 { WM_STYLECHANGING, sent|defwinproc|optional },
1578 { WM_STYLECHANGED, sent|defwinproc|optional },
1579 { WM_STYLECHANGING, sent|defwinproc|optional },
1580 { WM_STYLECHANGED, sent|defwinproc|optional },
1581 { WM_GETTEXT, sent|defwinproc|optional },
1582 { WM_GETTEXT, sent|defwinproc|optional },
1583 { WM_ERASEBKGND, sent|optional },
1584 { WM_CTLCOLORDLG, sent|defwinproc|optional }, /* sent to a parent of the dialog */
1585 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOCLIENTMOVE },
1586 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1587 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1588 { EVENT_OBJECT_VALUECHANGE, winevent_hook|lparam|optional, 0/*OBJID_HSCROLL or OBJID_VSCROLL*/, 0 },
1589 { WM_GETTEXT, sent|optional },
1590 { WM_GETTEXT, sent|optional },
1591 { WM_GETTEXT, sent|optional },
1592 { WM_GETTEXT, sent|optional },
1593 { 0 }
1594 };
1595 /* test if we receive the right sequence of messages */
1596 /* after calling ShowWindow( SW_SHOWNA) */
1597 static const struct message WmSHOWNAChildInvisParInvis[] = {
1598 { WM_SHOWWINDOW, sent|wparam, 1 },
1599 { 0 }
1600 };
1601 static const struct message WmSHOWNAChildVisParInvis[] = {
1602 { WM_SHOWWINDOW, sent|wparam, 1 },
1603 { 0 }
1604 };
1605 static const struct message WmSHOWNAChildVisParVis[] = {
1606 { WM_SHOWWINDOW, sent|wparam, 1 },
1607 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1608 { 0 }
1609 };
1610 static const struct message WmSHOWNAChildInvisParVis[] = {
1611 { WM_SHOWWINDOW, sent|wparam, 1 },
1612 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1613 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1614 { WM_ERASEBKGND, sent|optional },
1615 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOACTIVATE|SWP_NOCLIENTMOVE },
1616 { 0 }
1617 };
1618 static const struct message WmSHOWNATopVisible[] = {
1619 { WM_SHOWWINDOW, sent|wparam, 1 },
1620 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1621 { WM_NCPAINT, sent|wparam|optional, 1 },
1622 { WM_GETTEXT, sent|defwinproc|optional },
1623 { WM_ERASEBKGND, sent|optional },
1624 { WM_WINDOWPOSCHANGED, sent|optional },
1625 { 0 }
1626 };
1627 static const struct message WmSHOWNATopInvisible[] = {
1628 { WM_NOTIFYFORMAT, sent|optional },
1629 { WM_QUERYUISTATE, sent|optional },
1630 { WM_WINDOWPOSCHANGING, sent|optional },
1631 { WM_GETMINMAXINFO, sent|optional },
1632 { WM_NCCALCSIZE, sent|optional },
1633 { WM_WINDOWPOSCHANGED, sent|optional },
1634 { WM_SHOWWINDOW, sent|wparam, 1 },
1635 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1636 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1637 { WM_NCPAINT, sent|wparam, 1 },
1638 { WM_GETTEXT, sent|defwinproc|optional },
1639 { WM_ERASEBKGND, sent|optional },
1640 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1641 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
1642 { WM_NCPAINT, sent|wparam|optional, 1 },
1643 { WM_ERASEBKGND, sent|optional },
1644 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1645 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1646 { WM_MOVE, sent },
1647 { 0 }
1648 };
1649
1650 static int after_end_dialog, test_def_id;
1651 static int sequence_cnt, sequence_size;
1652 static struct recvd_message* sequence;
1653 static int log_all_parent_messages;
1654 static int paint_loop_done;
1655
1656 /* user32 functions */
1657 static HWND (WINAPI *pGetAncestor)(HWND,UINT);
1658 static BOOL (WINAPI *pGetMenuInfo)(HMENU,LPCMENUINFO);
1659 static void (WINAPI *pNotifyWinEvent)(DWORD, HWND, LONG, LONG);
1660 static BOOL (WINAPI *pSetMenuInfo)(HMENU,LPCMENUINFO);
1661 static HWINEVENTHOOK (WINAPI *pSetWinEventHook)(DWORD, DWORD, HMODULE, WINEVENTPROC, DWORD, DWORD, DWORD);
1662 static BOOL (WINAPI *pTrackMouseEvent)(TRACKMOUSEEVENT*);
1663 static BOOL (WINAPI *pUnhookWinEvent)(HWINEVENTHOOK);
1664 /* kernel32 functions */
1665 static BOOL (WINAPI *pGetCPInfoExA)(UINT, DWORD, LPCPINFOEXA);
1666
1667 static void init_procs(void)
1668 {
1669 HMODULE user32 = GetModuleHandleA("user32.dll");
1670 HMODULE kernel32 = GetModuleHandleA("kernel32.dll");
1671
1672 #define GET_PROC(dll, func) \
1673 p ## func = (void*)GetProcAddress(dll, #func); \
1674 if(!p ## func) { \
1675 trace("GetProcAddress(%s) failed\n", #func); \
1676 }
1677
1678 GET_PROC(user32, GetAncestor)
1679 GET_PROC(user32, GetMenuInfo)
1680 GET_PROC(user32, NotifyWinEvent)
1681 GET_PROC(user32, SetMenuInfo)
1682 GET_PROC(user32, SetWinEventHook)
1683 GET_PROC(user32, TrackMouseEvent)
1684 GET_PROC(user32, UnhookWinEvent)
1685
1686 GET_PROC(kernel32, GetCPInfoExA)
1687
1688 #undef GET_PROC
1689 }
1690
1691 static const char *get_winpos_flags(UINT flags)
1692 {
1693 static char buffer[300];
1694
1695 buffer[0] = 0;
1696 #define DUMP(flag) do { if (flags & flag) { strcat( buffer, "|" #flag ); flags &= ~flag; } } while(0)
1697 DUMP( SWP_SHOWWINDOW );
1698 DUMP( SWP_HIDEWINDOW );
1699 DUMP( SWP_NOACTIVATE );
1700 DUMP( SWP_FRAMECHANGED );
1701 DUMP( SWP_NOCOPYBITS );
1702 DUMP( SWP_NOOWNERZORDER );
1703 DUMP( SWP_NOSENDCHANGING );
1704 DUMP( SWP_DEFERERASE );
1705 DUMP( SWP_ASYNCWINDOWPOS );
1706 DUMP( SWP_NOZORDER );
1707 DUMP( SWP_NOREDRAW );
1708 DUMP( SWP_NOSIZE );
1709 DUMP( SWP_NOMOVE );
1710 DUMP( SWP_NOCLIENTSIZE );
1711 DUMP( SWP_NOCLIENTMOVE );
1712 if (flags) sprintf(buffer + strlen(buffer),"|0x%04x", flags);
1713 return buffer + 1;
1714 #undef DUMP
1715 }
1716
1717
1718 #define add_message(msg) add_message_(__LINE__,msg);
1719 static void add_message_(int line, const struct recvd_message *msg)
1720 {
1721 struct recvd_message *seq;
1722
1723 if (!sequence)
1724 {
1725 sequence_size = 10;
1726 sequence = HeapAlloc( GetProcessHeap(), 0, sequence_size * sizeof(*sequence) );
1727 }
1728 if (sequence_cnt == sequence_size)
1729 {
1730 sequence_size *= 2;
1731 sequence = HeapReAlloc( GetProcessHeap(), 0, sequence, sequence_size * sizeof(*sequence) );
1732 }
1733 assert(sequence);
1734
1735 seq = &sequence[sequence_cnt];
1736 seq->hwnd = msg->hwnd;
1737 seq->message = msg->message;
1738 seq->flags = msg->flags;
1739 seq->wParam = msg->wParam;
1740 seq->lParam = msg->lParam;
1741 seq->line = line;
1742 seq->descr = msg->descr;
1743 seq->output[0] = 0;
1744
1745 if (msg->descr)
1746 {
1747 if (msg->flags & hook)
1748 {
1749 static const char * const CBT_code_name[10] =
1750 {
1751 "HCBT_MOVESIZE",
1752 "HCBT_MINMAX",
1753 "HCBT_QS",
1754 "HCBT_CREATEWND",
1755 "HCBT_DESTROYWND",
1756 "HCBT_ACTIVATE",
1757 "HCBT_CLICKSKIPPED",
1758 "HCBT_KEYSKIPPED",
1759 "HCBT_SYSCOMMAND",
1760 "HCBT_SETFOCUS"
1761 };
1762 const char *code_name = (msg->message <= HCBT_SETFOCUS) ? CBT_code_name[msg->message] : "Unknown";
1763
1764 snprintf( seq->output, sizeof(seq->output), "%s: hook %d (%s) wp %08lx lp %08lx",
1765 msg->descr, msg->message, code_name, msg->wParam, msg->lParam );
1766 }
1767 else if (msg->flags & winevent_hook)
1768 {
1769 snprintf( seq->output, sizeof(seq->output), "%s: winevent %p %08x %08lx %08lx",
1770 msg->descr, msg->hwnd, msg->message, msg->wParam, msg->lParam );
1771 }
1772 else
1773 {
1774 switch (msg->message)
1775 {
1776 case WM_WINDOWPOSCHANGING:
1777 case WM_WINDOWPOSCHANGED:
1778 {
1779 WINDOWPOS *winpos = (WINDOWPOS *)msg->lParam;
1780
1781 snprintf( seq->output, sizeof(seq->output),
1782 "%s: %p WM_WINDOWPOS%s wp %08lx lp %08lx after %p x %d y %d cx %d cy %d flags %s",
1783 msg->descr, msg->hwnd,
1784 (msg->message == WM_WINDOWPOSCHANGING) ? "CHANGING" : "CHANGED",
1785 msg->wParam, msg->lParam, winpos->hwndInsertAfter,
1786 winpos->x, winpos->y, winpos->cx, winpos->cy,
1787 get_winpos_flags(winpos->flags) );
1788
1789 /* Log only documented flags, win2k uses 0x1000 and 0x2000
1790 * in the high word for internal purposes
1791 */
1792 seq->wParam = winpos->flags & 0xffff;
1793 /* We are not interested in the flags that don't match under XP and Win9x */
1794 seq->wParam &= ~SWP_NOZORDER;
1795 break;
1796 }
1797
1798 case WM_DRAWITEM:
1799 {
1800 DRAW_ITEM_STRUCT di;
1801 DRAWITEMSTRUCT *dis = (DRAWITEMSTRUCT *)msg->lParam;
1802
1803 snprintf( seq->output, sizeof(seq->output),
1804 "%s: %p WM_DRAWITEM: type %x, ctl_id %x, item_id %x, action %x, state %x",
1805 msg->descr, msg->hwnd, dis->CtlType, dis->CtlID,
1806 dis->itemID, dis->itemAction, dis->itemState);
1807
1808 di.u.item.type = dis->CtlType;
1809 di.u.item.ctl_id = dis->CtlID;
1810 di.u.item.item_id = dis->itemID;
1811 di.u.item.action = dis->itemAction;
1812 di.u.item.state = dis->itemState;
1813
1814 seq->lParam = di.u.lp;
1815 break;
1816 }
1817 default:
1818 if (msg->message >= 0xc000) return; /* ignore registered messages */
1819 snprintf( seq->output, sizeof(seq->output), "%s: %p %04x wp %08lx lp %08lx",
1820 msg->descr, msg->hwnd, msg->message, msg->wParam, msg->lParam );
1821 }
1822 }
1823 }
1824
1825 sequence_cnt++;
1826 }
1827
1828 /* try to make sure pending X events have been processed before continuing */
1829 static void flush_events(void)
1830 {
1831 MSG msg;
1832 int diff = 200;
1833 int min_timeout = 100;
1834 DWORD time = GetTickCount() + diff;
1835
1836 while (diff > 0)
1837 {
1838 if (MsgWaitForMultipleObjects( 0, NULL, FALSE, min_timeout, QS_ALLINPUT ) == WAIT_TIMEOUT) break;
1839 while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
1840 diff = time - GetTickCount();
1841 }
1842 }
1843
1844 static void flush_sequence(void)
1845 {
1846 HeapFree(GetProcessHeap(), 0, sequence);
1847 sequence = 0;
1848 sequence_cnt = sequence_size = 0;
1849 }
1850
1851 static void dump_sequence(const struct message *expected, const char *context, const char *file, int line)
1852 {
1853 const struct recvd_message *actual = sequence;
1854 unsigned int count = 0;
1855
1856 trace_(file, line)("Failed sequence %s:\n", context );
1857 while (expected->message && actual->message)
1858 {
1859 if (actual->output[0])
1860 {
1861 if (expected->flags & hook)
1862 {
1863 trace_(file, line)( " %u: expected: hook %04x - actual: %s\n",
1864 count, expected->message, actual->output );
1865 }
1866 else if (expected->flags & winevent_hook)
1867 {
1868 trace_(file, line)( " %u: expected: winevent %04x - actual: %s\n",
1869 count, expected->message, actual->output );
1870 }
1871 else
1872 {
1873 trace_(file, line)( " %u: expected: msg %04x - actual: %s\n",
1874 count, expected->message, actual->output );
1875 }
1876 }
1877
1878 if (expected->message == actual->message)
1879 {
1880 if ((expected->flags & defwinproc) != (actual->flags & defwinproc) &&
1881 (expected->flags & optional))
1882 {
1883 /* don't match messages if their defwinproc status differs */
1884 expected++;
1885 }
1886 else
1887 {
1888 expected++;
1889 actual++;
1890 }
1891 }
1892 /* silently drop winevent messages if there is no support for them */
1893 else if ((expected->flags & optional) || ((expected->flags & winevent_hook) && !hEvent_hook))
1894 expected++;
1895 else
1896 {
1897 expected++;
1898 actual++;
1899 }
1900 count++;
1901 }
1902
1903 /* optional trailing messages */
1904 while (expected->message && ((expected->flags & optional) ||
1905 ((expected->flags & winevent_hook) && !hEvent_hook)))
1906 {
1907 trace_(file, line)( " %u: expected: msg %04x - actual: nothing\n", count, expected->message );
1908 expected++;
1909 count++;
1910 }
1911
1912 if (expected->message)
1913 trace_(file, line)( " %u: expected: msg %04x - actual: nothing\n", count, expected->message );
1914 else if (actual->message && actual->output[0])
1915 trace_(file, line)( " %u: expected: nothing - actual: %s\n", count, actual->output );
1916 }
1917
1918 #define ok_sequence( exp, contx, todo) \
1919 ok_sequence_( (exp), (contx), (todo), __FILE__, __LINE__)
1920
1921
1922 static void ok_sequence_(const struct message *expected_list, const char *context, int todo,
1923 const char *file, int line)
1924 {
1925 static const struct recvd_message end_of_sequence;
1926 const struct message *expected = expected_list;
1927 const struct recvd_message *actual;
1928 int failcount = 0, dump = 0;
1929 unsigned int count = 0;
1930
1931 add_message(&end_of_sequence);
1932
1933 actual = sequence;
1934
1935 while (expected->message && actual->message)
1936 {
1937 if (expected->message == actual->message)
1938 {
1939 if (expected->flags & wparam)
1940 {
1941 if (((expected->wParam ^ actual->wParam) & ~expected->wp_mask) && todo)
1942 {
1943 todo_wine {
1944 failcount ++;
1945 if (strcmp(winetest_platform, "wine")) dump++;
1946 ok_( file, line) (FALSE,
1947 "%s: %u: in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
1948 context, count, expected->message, expected->wParam, actual->wParam);
1949 }
1950 }
1951 else
1952 {
1953 ok_( file, line)( ((expected->wParam ^ actual->wParam) & ~expected->wp_mask) == 0,
1954 "%s: %u: in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
1955 context, count, expected->message, expected->wParam, actual->wParam);
1956 if ((expected->wParam ^ actual->wParam) & ~expected->wp_mask) dump++;
1957 }
1958
1959 }
1960 if (expected->flags & lparam)
1961 {
1962 if (((expected->lParam ^ actual->lParam) & ~expected->lp_mask) && todo)
1963 {
1964 todo_wine {
1965 failcount ++;
1966 if (strcmp(winetest_platform, "wine")) dump++;
1967 ok_( file, line) (FALSE,
1968 "%s: %u: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
1969 context, count, expected->message, expected->lParam, actual->lParam);
1970 }
1971 }
1972 else
1973 {
1974 ok_( file, line)(((expected->lParam ^ actual->lParam) & ~expected->lp_mask) == 0,
1975 "%s: %u: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
1976 context, count, expected->message, expected->lParam, actual->lParam);
1977 if ((expected->lParam ^ actual->lParam) & ~expected->lp_mask) dump++;
1978 }
1979 }
1980 if ((expected->flags & defwinproc) != (actual->flags & defwinproc) &&
1981 (expected->flags & optional))
1982 {
1983 /* don't match messages if their defwinproc status differs */
1984 expected++;
1985 count++;
1986 continue;
1987 }
1988 if ((expected->flags & defwinproc) != (actual->flags & defwinproc) && todo)
1989 {
1990 todo_wine {
1991 failcount ++;
1992 if (strcmp(winetest_platform, "wine")) dump++;
1993 ok_( file, line) (FALSE,
1994 "%s: %u: the msg 0x%04x should %shave been sent by DefWindowProc\n",
1995 context, count, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
1996 }
1997 }
1998 else
1999 {
2000 ok_( file, line) ((expected->flags & defwinproc) == (actual->flags & defwinproc),
2001 "%s: %u: the msg 0x%04x should %shave been sent by DefWindowProc\n",
2002 context, count, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
2003 if ((expected->flags & defwinproc) != (actual->flags & defwinproc)) dump++;
2004 }
2005
2006 ok_( file, line) ((expected->flags & beginpaint) == (actual->flags & beginpaint),
2007 "%s: %u: the msg 0x%04x should %shave been sent by BeginPaint\n",
2008 context, count, expected->message, (expected->flags & beginpaint) ? "" : "NOT ");
2009 if ((expected->flags & beginpaint) != (actual->flags & beginpaint)) dump++;
2010
2011 ok_( file, line) ((expected->flags & (sent|posted)) == (actual->flags & (sent|posted)),
2012 "%s: %u: the msg 0x%04x should have been %s\n",
2013 context, count, expected->message, (expected->flags & posted) ? "posted" : "sent");
2014 if ((expected->flags & (sent|posted)) != (actual->flags & (sent|posted))) dump++;
2015
2016 ok_( file, line) ((expected->flags & parent) == (actual->flags & parent),
2017 "%s: %u: the msg 0x%04x was expected in %s\n",
2018 context, count, expected->message, (expected->flags & parent) ? "parent" : "child");
2019 if ((expected->flags & parent) != (actual->flags & parent)) dump++;
2020
2021 ok_( file, line) ((expected->flags & hook) == (actual->flags & hook),
2022 "%s: %u: the msg 0x%04x should have been sent by a hook\n",
2023 context, count, expected->message);
2024 if ((expected->flags & hook) != (actual->flags & hook)) dump++;
2025
2026 ok_( file, line) ((expected->flags & winevent_hook) == (actual->flags & winevent_hook),
2027 "%s: %u: the msg 0x%04x should have been sent by a winevent hook\n",
2028 context, count, expected->message);
2029 if ((expected->flags & winevent_hook) != (actual->flags & winevent_hook)) dump++;
2030
2031 expected++;
2032 actual++;
2033 }
2034 /* silently drop hook messages if there is no support for them */
2035 else if ((expected->flags & optional) ||
2036 ((expected->flags & hook) && !hCBT_hook) ||
2037 ((expected->flags & winevent_hook) && !hEvent_hook))
2038 expected++;
2039 else if (todo)
2040 {
2041 failcount++;
2042 todo_wine {
2043 if (strcmp(winetest_platform, "wine")) dump++;
2044 ok_( file, line) (FALSE, "%s: %u: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
2045 context, count, expected->message, actual->message);
2046 }
2047 goto done;
2048 }
2049 else
2050 {
2051 ok_( file, line) (FALSE, "%s: %u: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
2052 context, count, expected->message, actual->message);
2053 dump++;
2054 expected++;
2055 actual++;
2056 }
2057 count++;
2058 }
2059
2060 /* skip all optional trailing messages */
2061 while (expected->message && ((expected->flags & optional) ||
2062 ((expected->flags & hook) && !hCBT_hook) ||
2063 ((expected->flags & winevent_hook) && !hEvent_hook)))
2064 expected++;
2065
2066 if (todo)
2067 {
2068 todo_wine {
2069 if (expected->message || actual->message) {
2070 failcount++;
2071 if (strcmp(winetest_platform, "wine")) dump++;
2072 ok_( file, line) (FALSE, "%s: %u: the msg sequence is not complete: expected %04x - actual %04x\n",
2073 context, count, expected->message, actual->message);
2074 }
2075 }
2076 }
2077 else
2078 {
2079 if (expected->message || actual->message)
2080 {
2081 dump++;
2082 ok_( file, line) (FALSE, "%s: %u: the msg sequence is not complete: expected %04x - actual %04x\n",
2083 context, count, expected->message, actual->message);
2084 }
2085 }
2086 if( todo && !failcount) /* succeeded yet marked todo */
2087 todo_wine {
2088 if (!strcmp(winetest_platform, "wine")) dump++;
2089 ok_( file, line)( TRUE, "%s: marked \"todo_wine\" but succeeds\n", context);
2090 }
2091
2092 done:
2093 if (dump) dump_sequence(expected_list, context, file, line);
2094 flush_sequence();
2095 }
2096
2097 #define expect(EXPECTED,GOT) ok((GOT)==(EXPECTED), "Expected %d, got %d\n", (EXPECTED), (GOT))
2098
2099 /******************************** MDI test **********************************/
2100
2101 /* CreateWindow for MDI frame window, initially visible */
2102 static const struct message WmCreateMDIframeSeq[] = {
2103 { HCBT_CREATEWND, hook },
2104 { WM_GETMINMAXINFO, sent },
2105 { WM_NCCREATE, sent },
2106 { WM_NCCALCSIZE, sent|wparam, 0 },
2107 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
2108 { WM_CREATE, sent },
2109 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2110 { WM_NOTIFYFORMAT, sent|optional },
2111 { WM_QUERYUISTATE, sent|optional },
2112 { WM_WINDOWPOSCHANGING, sent|optional },
2113 { WM_GETMINMAXINFO, sent|optional },
2114 { WM_NCCALCSIZE, sent|optional },
2115 { WM_WINDOWPOSCHANGED, sent|optional },
2116 { WM_SHOWWINDOW, sent|wparam, 1 },
2117 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2118 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2119 { HCBT_ACTIVATE, hook },
2120 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
2121 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
2122 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* XP */
2123 { WM_ACTIVATEAPP, sent|wparam|optional, 1 }, /* Win9x doesn't send it */
2124 { WM_NCACTIVATE, sent|wparam, 1 },
2125 { WM_GETTEXT, sent|defwinproc|optional },
2126 { WM_ACTIVATE, sent|wparam, 1 },
2127 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* Win9x */
2128 { HCBT_SETFOCUS, hook },
2129 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2130 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
2131 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2132 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
2133 /* Win9x adds SWP_NOZORDER below */
2134 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2135 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP */
2136 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
2137 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2138 { WM_MOVE, sent },
2139 { 0 }
2140 };
2141 /* DestroyWindow for MDI frame window, initially visible */
2142 static const struct message WmDestroyMDIframeSeq[] = {
2143 { HCBT_DESTROYWND, hook },
2144 { 0x0090, sent|optional },
2145 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2146 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2147 { WM_NCACTIVATE, sent|wparam|optional, 0 }, /* Win9x */
2148 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2149 { WM_NCACTIVATE, sent|wparam|optional, 0 }, /* XP */
2150 { WM_ACTIVATE, sent|wparam|optional, 0 }, /* Win9x */
2151 { WM_ACTIVATEAPP, sent|wparam|optional, 0 }, /* Win9x */
2152 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
2153 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2154 { WM_DESTROY, sent },
2155 { WM_NCDESTROY, sent },
2156 { 0 }
2157 };
2158 /* CreateWindow for MDI client window, initially visible */
2159 static const struct message WmCreateMDIclientSeq[] = {
2160 { HCBT_CREATEWND, hook },
2161 { WM_NCCREATE, sent },
2162 { WM_NCCALCSIZE, sent|wparam, 0 },
2163 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
2164 { WM_CREATE, sent },
2165 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
2166 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2167 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2168 { WM_MOVE, sent },
2169 { WM_PARENTNOTIFY, sent|wparam, WM_CREATE }, /* in MDI frame */
2170 { WM_SHOWWINDOW, sent|wparam, 1 },
2171 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2172 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2173 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2174 { 0 }
2175 };
2176 /* ShowWindow(SW_SHOW) for MDI client window */
2177 static const struct message WmShowMDIclientSeq[] = {
2178 { WM_SHOWWINDOW, sent|wparam, 1 },
2179 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2180 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2181 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2182 { 0 }
2183 };
2184 /* ShowWindow(SW_HIDE) for MDI client window */
2185 static const struct message WmHideMDIclientSeq[] = {
2186 { WM_SHOWWINDOW, sent|wparam, 0 },
2187 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2188 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|optional, 0, 0 }, /* win2000 */
2189 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP */
2190 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2191 { 0 }
2192 };
2193 /* DestroyWindow for MDI client window, initially visible */
2194 static const struct message WmDestroyMDIclientSeq[] = {
2195 { HCBT_DESTROYWND, hook },
2196 { 0x0090, sent|optional },
2197 { WM_PARENTNOTIFY, sent|wparam, WM_DESTROY }, /* in MDI frame */
2198 { WM_SHOWWINDOW, sent|wparam, 0 },
2199 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2200 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2201 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2202 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2203 { WM_DESTROY, sent },
2204 { WM_NCDESTROY, sent },
2205 { 0 }
2206 };
2207 /* CreateWindow for MDI child window, initially visible */
2208 static const struct message WmCreateMDIchildVisibleSeq[] = {
2209 { HCBT_CREATEWND, hook },
2210 { WM_NCCREATE, sent },
2211 { WM_NCCALCSIZE, sent|wparam, 0 },
2212 { WM_CREATE, sent },
2213 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2214 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2215 { WM_MOVE, sent },
2216 /* Win2k sends wparam set to
2217 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2218 * while Win9x doesn't bother to set child window id according to
2219 * CLIENTCREATESTRUCT.idFirstChild
2220 */
2221 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2222 { WM_SHOWWINDOW, sent|wparam, 1 },
2223 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2224 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2225 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2226 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
2227 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2228 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2229 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2230
2231 /* Win9x: message sequence terminates here. */
2232
2233 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2234 { HCBT_SETFOCUS, hook }, /* in MDI client */
2235 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2236 { WM_IME_NOTIFY, sent|wparam|optional, 2 }, /* in MDI client */
2237 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2238 { WM_SETFOCUS, sent }, /* in MDI client */
2239 { HCBT_SETFOCUS, hook },
2240 { WM_KILLFOCUS, sent }, /* in MDI client */
2241 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2242 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2243 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2244 { WM_SETFOCUS, sent|defwinproc },
2245 { WM_MDIACTIVATE, sent|defwinproc },
2246 { 0 }
2247 };
2248 /* CreateWindow for MDI child window with invisible parent */
2249 static const struct message WmCreateMDIchildInvisibleParentSeq[] = {
2250 { HCBT_CREATEWND, hook },
2251 { WM_GETMINMAXINFO, sent },
2252 { WM_NCCREATE, sent },
2253 { WM_NCCALCSIZE, sent|wparam, 0 },
2254 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
2255 { WM_CREATE, sent },
2256 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2257 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2258 { WM_MOVE, sent },
2259 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2260 { WM_SHOWWINDOW, sent|wparam, 1 },
2261 { WM_MDIREFRESHMENU, sent }, /* in MDI client */
2262 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2263 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2264 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2265
2266 /* Win9x: message sequence terminates here. */
2267
2268 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2269 { HCBT_SETFOCUS, hook }, /* in MDI client */
2270 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2271 { WM_IME_NOTIFY, sent|wparam|optional, 2 }, /* in MDI client */
2272 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2273 { WM_SETFOCUS, sent }, /* in MDI client */
2274 { HCBT_SETFOCUS, hook },
2275 { WM_KILLFOCUS, sent }, /* in MDI client */
2276 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2277 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2278 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2279 { WM_SETFOCUS, sent|defwinproc },
2280 { WM_MDIACTIVATE, sent|defwinproc },
2281 { 0 }
2282 };
2283 /* DestroyWindow for MDI child window, initially visible */
2284 static const struct message WmDestroyMDIchildVisibleSeq[] = {
2285 { HCBT_DESTROYWND, hook },
2286 /* Win2k sends wparam set to
2287 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
2288 * while Win9x doesn't bother to set child window id according to
2289 * CLIENTCREATESTRUCT.idFirstChild
2290 */
2291 { 0x0090, sent|optional },
2292 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
2293 { WM_SHOWWINDOW, sent|wparam, 0 },
2294 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2295 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2296 { WM_ERASEBKGND, sent|parent|optional },
2297 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2298
2299 /* { WM_DESTROY, sent }
2300 * Win9x: message sequence terminates here.
2301 */
2302
2303 { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
2304 { WM_KILLFOCUS, sent },
2305 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2306 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2307 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2308 { WM_SETFOCUS, sent }, /* in MDI client */
2309
2310 { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
2311 { WM_KILLFOCUS, sent }, /* in MDI client */
2312 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2313 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2314 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2315 { WM_SETFOCUS, sent }, /* in MDI client */
2316
2317 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2318
2319 { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
2320 { WM_KILLFOCUS, sent },
2321 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2322 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2323 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2324 { WM_SETFOCUS, sent }, /* in MDI client */
2325
2326 { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
2327 { WM_KILLFOCUS, sent }, /* in MDI client */
2328 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2329 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2330 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2331 { WM_SETFOCUS, sent }, /* in MDI client */
2332
2333 { WM_DESTROY, sent },
2334
2335 { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
2336 { WM_KILLFOCUS, sent },
2337 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2338 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2339 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2340 { WM_SETFOCUS, sent }, /* in MDI client */
2341
2342 { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
2343 { WM_KILLFOCUS, sent }, /* in MDI client */
2344 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2345 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2346 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2347 { WM_SETFOCUS, sent }, /* in MDI client */
2348
2349 { WM_NCDESTROY, sent },
2350 { 0 }
2351 };
2352 /* CreateWindow for MDI child window, initially invisible */
2353 static const struct message WmCreateMDIchildInvisibleSeq[] = {
2354 { HCBT_CREATEWND, hook },
2355 { WM_NCCREATE, sent },
2356 { WM_NCCALCSIZE, sent|wparam, 0 },
2357 { WM_CREATE, sent },
2358 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2359 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2360 { WM_MOVE, sent },
2361 /* Win2k sends wparam set to
2362 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2363 * while Win9x doesn't bother to set child window id according to
2364 * CLIENTCREATESTRUCT.idFirstChild
2365 */
2366 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2367 { 0 }
2368 };
2369 /* DestroyWindow for MDI child window, initially invisible */
2370 static const struct message WmDestroyMDIchildInvisibleSeq[] = {
2371 { HCBT_DESTROYWND, hook },
2372 /* Win2k sends wparam set to
2373 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
2374 * while Win9x doesn't bother to set child window id according to
2375 * CLIENTCREATESTRUCT.idFirstChild
2376 */
2377 { 0x0090, sent|optional },
2378 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
2379 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2380 { WM_DESTROY, sent },
2381 { WM_NCDESTROY, sent },
2382 /* FIXME: Wine destroys an icon/title window while Windows doesn't */
2383 { WM_PARENTNOTIFY, sent|wparam|optional, WM_DESTROY }, /* MDI client */
2384 { 0 }
2385 };
2386 /* CreateWindow for the 1st MDI child window, initially visible and maximized */
2387 static const struct message WmCreateMDIchildVisibleMaxSeq1[] = {
2388 { HCBT_CREATEWND, hook },
2389 { WM_NCCREATE, sent },
2390 { WM_NCCALCSIZE, sent|wparam, 0 },
2391 { WM_CREATE, sent },
2392 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2393 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2394 { WM_MOVE, sent },
2395 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2396 { WM_GETMINMAXINFO, sent },
2397 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
2398 { WM_NCCALCSIZE, sent|wparam, 1 },
2399 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2400 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2401 /* in MDI frame */
2402 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2403 { WM_NCCALCSIZE, sent|wparam, 1 },
2404 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2405 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2406 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2407 /* Win2k sends wparam set to
2408 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2409 * while Win9x doesn't bother to set child window id according to
2410 * CLIENTCREATESTRUCT.idFirstChild
2411 */
2412 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2413 { WM_SHOWWINDOW, sent|wparam, 1 },
2414 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2415 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2416 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2417 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
2418 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2419 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2420 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2421
2422 /* Win9x: message sequence terminates here. */
2423
2424 { WM_NCACTIVATE, sent|wparam|defwinproc|optional, 1 },
2425 { HCBT_SETFOCUS, hook|optional }, /* in MDI client */
2426 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2427 { WM_IME_NOTIFY, sent|wparam|optional, 2 }, /* in MDI client */
2428 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2429 { WM_SETFOCUS, sent|optional }, /* in MDI client */
2430 { HCBT_SETFOCUS, hook|optional },
2431 { WM_KILLFOCUS, sent|optional }, /* in MDI client */
2432 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2433 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2434 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2435 { WM_SETFOCUS, sent|defwinproc|optional },
2436 { WM_MDIACTIVATE, sent|defwinproc|optional },
2437 /* in MDI frame */
2438 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2439 { WM_NCCALCSIZE, sent|wparam, 1 },
2440 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2441 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2442 { 0 }
2443 };
2444 /* CreateWindow for the 2nd MDI child window, initially visible and maximized */
2445 static const struct message WmCreateMDIchildVisibleMaxSeq2[] = {
2446 /* restore the 1st MDI child */
2447 { WM_SETREDRAW, sent|wparam, 0 },
2448 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNORMAL },
2449 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
2450 { WM_NCCALCSIZE, sent|wparam, 1 },
2451 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2452 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2453 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2454 /* in MDI frame */
2455 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2456 { WM_NCCALCSIZE, sent|wparam, 1 },
2457 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2458 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2459 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2460 { WM_SETREDRAW, sent|wparam, 1 }, /* in the 1st MDI child */
2461 /* create the 2nd MDI child */
2462 { HCBT_CREATEWND, hook },
2463 { WM_NCCREATE, sent },
2464 { WM_NCCALCSIZE, sent|wparam, 0 },
2465 { WM_CREATE, sent },
2466 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2467 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2468 { WM_MOVE, sent },
2469 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2470 { WM_GETMINMAXINFO, sent },
2471 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
2472 { WM_NCCALCSIZE, sent|wparam, 1 },
2473 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2474 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2475 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2476 /* in MDI frame */
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_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2480 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2481 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2482 /* Win2k sends wparam set to
2483 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2484 * while Win9x doesn't bother to set child window id according to
2485 * CLIENTCREATESTRUCT.idFirstChild
2486 */
2487 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2488 { WM_SHOWWINDOW, sent|wparam, 1 },
2489 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2490 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2491 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2492 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
2493 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2494 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2495
2496 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
2497 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
2498
2499 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2500
2501 /* Win9x: message sequence terminates here. */
2502
2503 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2504 { HCBT_SETFOCUS, hook },
2505 { WM_KILLFOCUS, sent|defwinproc|optional }, /* in the 1st MDI child */
2506 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 }, /* in the 1st MDI child */
2507 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2508 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2509 { WM_SETFOCUS, sent }, /* in MDI client */
2510 { HCBT_SETFOCUS, hook },
2511 { WM_KILLFOCUS, sent }, /* in MDI client */
2512 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2513 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2514 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2515 { WM_SETFOCUS, sent|defwinproc },
2516
2517 { WM_MDIACTIVATE, sent|defwinproc },
2518 /* in MDI frame */
2519 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2520 { WM_NCCALCSIZE, sent|wparam, 1 },
2521 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2522 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2523 { 0 }
2524 };
2525 /* WM_MDICREATE MDI child window, initially visible and maximized */
2526 static const struct message WmCreateMDIchildVisibleMaxSeq3[] = {
2527 { WM_MDICREATE, sent },
2528 { HCBT_CREATEWND, hook },
2529 { WM_NCCREATE, sent },
2530 { WM_NCCALCSIZE, sent|wparam, 0 },
2531 { WM_CREATE, sent },
2532 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2533 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2534 { WM_MOVE, sent },
2535 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2536 { WM_GETMINMAXINFO, sent },
2537 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
2538 { WM_NCCALCSIZE, sent|wparam, 1 },
2539 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2540 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2541
2542 /* in MDI frame */
2543 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2544 { WM_NCCALCSIZE, sent|wparam, 1 },
2545 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2546 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2547 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2548
2549 /* Win2k sends wparam set to
2550 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2551 * while Win9x doesn't bother to set child window id according to
2552 * CLIENTCREATESTRUCT.idFirstChild
2553 */
2554 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2555 { WM_SHOWWINDOW, sent|wparam, 1 },
2556 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2557
2558 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2559
2560 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2561 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
2562 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2563
2564 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2565 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2566
2567 /* Win9x: message sequence terminates here. */
2568
2569 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2570 { WM_SETFOCUS, sent|optional }, /* in MDI client */
2571 { HCBT_SETFOCUS, hook }, /* in MDI client */
2572 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2573 { WM_IME_NOTIFY, sent|wparam|optional, 2 },
2574 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
2575 { WM_SETFOCUS, sent|optional }, /* in MDI client */
2576 { HCBT_SETFOCUS, hook|optional },
2577 { WM_KILLFOCUS, sent }, /* in MDI client */
2578 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2579 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2580 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2581 { WM_SETFOCUS, sent|defwinproc },
2582
2583 { WM_MDIACTIVATE, sent|defwinproc },
2584
2585 /* in MDI child */
2586 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2587 { WM_NCCALCSIZE, sent|wparam, 1 },
2588 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2589 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
2590
2591 /* in MDI frame */
2592 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2593 { WM_NCCALCSIZE, sent|wparam, 1 },
2594 { 0x0093, sent|defwinproc|optional },
2595 { 0x0093, sent|defwinproc|optional },
2596 { 0x0093, sent|defwinproc|optional },
2597 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2598 { WM_MOVE, sent|defwinproc },
2599 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2600
2601 /* in MDI client */
2602 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2603 { WM_NCCALCSIZE, sent|wparam, 1 },
2604 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2605 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2606
2607 /* in MDI child */
2608 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2609 { WM_NCCALCSIZE, sent|wparam, 1 },
2610 { 0x0093, sent|optional },
2611 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2612 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2613
2614 { 0x0093, sent|optional },
2615 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2616 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2617 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP sends it to MDI frame */
2618 { 0x0093, sent|defwinproc|optional },
2619 { 0x0093, sent|defwinproc|optional },
2620 { 0x0093, sent|defwinproc|optional },
2621 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2622 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
2623
2624 { 0 }
2625 };
2626 /* CreateWindow for the 1st MDI child window, initially invisible and maximized */
2627 static const struct message WmCreateMDIchildInvisibleMaxSeq4[] = {
2628 { HCBT_CREATEWND, hook },
2629 { WM_GETMINMAXINFO, sent },
2630 { WM_NCCREATE, sent },
2631 { WM_NCCALCSIZE, sent|wparam, 0 },
2632 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
2633 { WM_CREATE, sent },
2634 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2635 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2636 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE, 0, SWP_NOZORDER }, /* MDI frame */
2637 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* MDI frame */
2638 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE, 0, SWP_NOZORDER }, /* MDI frame */
2639 { WM_MOVE, sent },
2640 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2641 { WM_GETMINMAXINFO, sent },
2642 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
2643 { WM_GETMINMAXINFO, sent|defwinproc },
2644 { WM_NCCALCSIZE, sent|wparam, 1 },
2645 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_STATECHANGED },
2646 { WM_MOVE, sent|defwinproc },
2647 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2648 /* in MDI frame */
2649 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2650 { WM_NCCALCSIZE, sent|wparam, 1 },
2651 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2652 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2653 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* MDI child */
2654 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2655 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2656 /* Win2k sends wparam set to
2657 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2658 * while Win9x doesn't bother to set child window id according to
2659 * CLIENTCREATESTRUCT.idFirstChild
2660 */
2661 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2662 { 0 }
2663 };
2664 /* WM_SYSCOMMAND/SC_CLOSE for the 2nd MDI child window, initially visible and maximized */
2665 static const struct message WmDestroyMDIchildVisibleMaxSeq2[] = {
2666 { WM_SYSCOMMAND, sent|wparam, SC_CLOSE },
2667 { HCBT_SYSCOMMAND, hook },
2668 { WM_CLOSE, sent|defwinproc },
2669 { WM_MDIDESTROY, sent }, /* in MDI client */
2670
2671 /* bring the 1st MDI child to top */
2672 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE }, /* in the 1st MDI child */
2673 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE }, /* in the 2nd MDI child */
2674
2675 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2676
2677 { WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 }, /* in the 1st MDI child */
2678 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
2679 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
2680
2681 /* maximize the 1st MDI child */
2682 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2683 { WM_GETMINMAXINFO, sent|defwinproc },
2684 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_STATECHANGED },
2685 { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
2686 { WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 },
2687 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2688 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2689
2690 /* restore the 2nd MDI child */
2691 { WM_SETREDRAW, sent|defwinproc|wparam, 0 },
2692 { HCBT_MINMAX, hook|lparam, 0, SW_NORMALNA },
2693 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_STATECHANGED },
2694 { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
2695
2696 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2697
2698 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2699 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2700
2701 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2702
2703 { WM_SETREDRAW, sent|defwinproc|wparam, 1 },
2704 /* in MDI frame */
2705 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2706 { WM_NCCALCSIZE, sent|wparam, 1 },
2707 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2708 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2709 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2710
2711 /* bring the 1st MDI child to top */
2712 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2713 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2714 { HCBT_SETFOCUS, hook },
2715 { WM_KILLFOCUS, sent|defwinproc },
2716 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
2717 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2718 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2719 { WM_SETFOCUS, sent }, /* in MDI client */
2720 { HCBT_SETFOCUS, hook },
2721 { WM_KILLFOCUS, sent }, /* in MDI client */
2722 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2723 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2724 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2725 { WM_SETFOCUS, sent|defwinproc },
2726 { WM_MDIACTIVATE, sent|defwinproc },
2727 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2728
2729 /* apparently ShowWindow(SW_SHOW) on an MDI client */
2730 { WM_SHOWWINDOW, sent|wparam, 1 },
2731 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2732 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2733 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2734 { WM_MDIREFRESHMENU, sent },
2735
2736 { HCBT_DESTROYWND, hook },
2737 /* Win2k sends wparam set to
2738 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
2739 * while Win9x doesn't bother to set child window id according to
2740 * CLIENTCREATESTRUCT.idFirstChild
2741 */
2742 { 0x0090, sent|defwinproc|optional },
2743 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
2744 { WM_SHOWWINDOW, sent|defwinproc|wparam, 0 },
2745 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2746 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2747 { WM_ERASEBKGND, sent|parent|optional },
2748 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2749
2750 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2751 { WM_DESTROY, sent|defwinproc },
2752 { WM_NCDESTROY, sent|defwinproc },
2753 { 0 }
2754 };
2755 /* WM_MDIDESTROY for the single MDI child window, initially visible and maximized */
2756 static const struct message WmDestroyMDIchildVisibleMaxSeq1[] = {
2757 { WM_MDIDESTROY, sent }, /* in MDI client */
2758 { WM_SHOWWINDOW, sent|wparam, 0 },
2759 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2760 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2761 { WM_ERASEBKGND, sent|parent|optional },
2762 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2763
2764 { HCBT_SETFOCUS, hook },
2765 { WM_KILLFOCUS, sent },
2766 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2767 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2768 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2769 { WM_SETFOCUS, sent }, /* in MDI client */
2770 { HCBT_SETFOCUS, hook },
2771 { WM_KILLFOCUS, sent }, /* in MDI client */
2772 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2773 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2774 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2775 { WM_SETFOCUS, sent },
2776
2777 /* in MDI child */
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_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2781 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2782
2783 /* in MDI frame */
2784 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2785 { WM_NCCALCSIZE, sent|wparam, 1 },
2786 { 0x0093, sent|defwinproc|optional },
2787 { 0x0093, sent|defwinproc|optional },
2788 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2789 { WM_MOVE, sent|defwinproc },
2790 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2791
2792 /* in MDI client */
2793 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2794 { WM_NCCALCSIZE, sent|wparam, 1 },
2795 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2796 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2797
2798 /* in MDI child */
2799 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2800 { WM_NCCALCSIZE, sent|wparam, 1 },
2801 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
2802 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2803
2804 /* in MDI child */
2805 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2806 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2807 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2808 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2809
2810 /* in MDI frame */
2811 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2812 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2813 { 0x0093, sent|defwinproc|optional },
2814 { 0x0093, sent|defwinproc|optional },
2815 { 0x0093, sent|defwinproc|optional },
2816 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2817 { WM_MOVE, sent|defwinproc },
2818 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2819
2820 /* in MDI client */
2821 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2822 { WM_NCCALCSIZE, sent|wparam, 1 },
2823 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2824 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2825
2826 /* in MDI child */
2827 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE },
2828 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2829 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
2830 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2831 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2832 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2833
2834 { 0x0093, sent|defwinproc|optional },
2835 { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 }, /* XP sends it to MDI frame */
2836 { 0x0093, sent|defwinproc|optional },
2837 { 0x0093, sent|defwinproc|optional },
2838 { 0x0093, sent|defwinproc|optional },
2839 { 0x0093, sent|optional },
2840
2841 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2842 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2843 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2844 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2845 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
2846
2847 /* in MDI frame */
2848 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2849 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
2850 { 0x0093, sent|defwinproc|optional },
2851 { 0x0093, sent|defwinproc|optional },
2852 { 0x0093, sent|defwinproc|optional },
2853 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2854 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2855 { 0x0093, sent|optional },
2856
2857 { WM_NCACTIVATE, sent|wparam, 0 },
2858 { WM_MDIACTIVATE, sent },
2859
2860 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNORMAL },
2861 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_STATECHANGED },
2862 { WM_NCCALCSIZE, sent|wparam, 1 },
2863
2864 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2865
2866 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2867 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2868 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2869
2870 /* in MDI child */
2871 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2872 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2873 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2874 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2875
2876 /* in MDI frame */
2877 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2878 { WM_NCCALCSIZE, sent|wparam, 1 },
2879 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2880 { WM_MOVE, sent|defwinproc },
2881 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2882
2883 /* in MDI client */
2884 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2885 { WM_NCCALCSIZE, sent|wparam, 1 },
2886 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2887 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2888 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2889 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP */
2890 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2891 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2892 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
2893
2894 { HCBT_SETFOCUS, hook },
2895 { WM_KILLFOCUS, sent },
2896 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2897 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2898 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2899 { WM_SETFOCUS, sent }, /* in MDI client */
2900
2901 { WM_MDIREFRESHMENU, sent }, /* in MDI client */
2902
2903 { HCBT_DESTROYWND, hook },
2904 /* Win2k sends wparam set to
2905 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
2906 * while Win9x doesn't bother to set child window id according to
2907 * CLIENTCREATESTRUCT.idFirstChild
2908 */
2909 { 0x0090, sent|optional },
2910 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
2911
2912 { WM_SHOWWINDOW, sent|wparam, 0 },
2913 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2914 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2915 { WM_ERASEBKGND, sent|parent|optional },
2916 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2917
2918 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2919 { WM_DESTROY, sent },
2920 { WM_NCDESTROY, sent },
2921 { 0 }
2922 };
2923 /* ShowWindow(SW_MAXIMIZE) for a not visible MDI child window */
2924 static const struct message WmMaximizeMDIchildInvisibleSeq[] = {
2925 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2926 { WM_GETMINMAXINFO, sent },
2927 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
2928 { WM_NCCALCSIZE, sent|wparam, 1 },
2929 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2930 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2931
2932 { WM_WINDOWPOSCHANGING, sent|wparam|optional|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2933 { WM_NCACTIVATE, sent|wparam|optional|defwinproc, 1 },
2934 { HCBT_SETFOCUS, hook|optional },
2935 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2936 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2937 { WM_SETFOCUS, sent|optional }, /* in MDI client */
2938 { HCBT_SETFOCUS, hook|optional },
2939 { WM_KILLFOCUS, sent|optional }, /* in MDI client */
2940 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2941 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2942 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2943 { WM_SETFOCUS, sent|optional|defwinproc },
2944 { WM_MDIACTIVATE, sent|optional|defwinproc },
2945 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2946 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2947 /* in MDI frame */
2948 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2949 { WM_NCCALCSIZE, sent|wparam, 1 },
2950 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2951 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2952 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2953 { 0 }
2954 };
2955 /* ShowWindow(SW_MAXIMIZE) for a not visible maximized MDI child window */
2956 static const struct message WmMaximizeMDIchildInvisibleSeq2[] = {
2957 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2958 { WM_GETMINMAXINFO, sent },
2959 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED },
2960 { WM_GETMINMAXINFO, sent|defwinproc },
2961 { WM_NCCALCSIZE, sent|wparam, 1 },
2962 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2963 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2964
2965 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2966 { WM_NCACTIVATE, sent|wparam|defwinproc|optional, 1 },
2967 { HCBT_SETFOCUS, hook|optional },
2968 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2969 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2970 { WM_SETFOCUS, sent|optional }, /* in MDI client */
2971 { HCBT_SETFOCUS, hook|optional },
2972 { WM_KILLFOCUS, sent|optional }, /* in MDI client */
2973 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2974 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2975 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2976 { WM_SETFOCUS, sent|defwinproc|optional },
2977 { WM_MDIACTIVATE, sent|defwinproc|optional },
2978 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2979 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2980 { 0 }
2981 };
2982 /* WM_MDIMAXIMIZE for an MDI child window with invisible parent */
2983 static const struct message WmMaximizeMDIchildInvisibleParentSeq[] = {
2984 { WM_MDIMAXIMIZE, sent }, /* in MDI client */
2985 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2986 { WM_GETMINMAXINFO, sent },
2987 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
2988 { WM_GETMINMAXINFO, sent|defwinproc },
2989 { WM_NCCALCSIZE, sent|wparam, 1 },
2990 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP doesn't send it */
2991 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2992 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_STATECHANGED },
2993 { WM_MOVE, sent|defwinproc },
2994 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2995
2996 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2997 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2998 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2999 { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 },
3000 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
3001 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI client XP */
3002 /* in MDI frame */
3003 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3004 { WM_NCCALCSIZE, sent|wparam, 1 },
3005 { 0x0093, sent|defwinproc|optional },
3006 { 0x0094, sent|defwinproc|optional },
3007 { 0x0094, sent|defwinproc|optional },
3008 { 0x0094, sent|defwinproc|optional },
3009 { 0x0094, sent|defwinproc|optional },
3010 { 0x0093, sent|defwinproc|optional },
3011 { 0x0093, sent|defwinproc|optional },
3012 { 0x0091, sent|defwinproc|optional },
3013 { 0x0092, sent|defwinproc|optional },
3014 { 0x0092, sent|defwinproc|optional },
3015 { 0x0092, sent|defwinproc|optional },
3016 { 0x0092, sent|defwinproc|optional },
3017 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3018 { WM_MOVE, sent|defwinproc },
3019 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3020 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame win2000 */
3021 /* in MDI client */
3022 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
3023 { WM_NCCALCSIZE, sent|wparam, 1 },
3024 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
3025 { WM_SIZE, sent|wparam, SIZE_RESTORED },
3026 /* in MDI child */
3027 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE },
3028 { WM_GETMINMAXINFO, sent|defwinproc },
3029 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
3030 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
3031 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3032 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child win2000 */
3033 { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 },
3034 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
3035 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
3036 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI client XP */
3037 /* in MDI frame */
3038 { 0x0093, sent|optional },
3039 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
3040 { 0x0093, sent|defwinproc|optional },
3041 { 0x0093, sent|defwinproc|optional },
3042 { 0x0093, sent|defwinproc|optional },
3043 { 0x0091, sent|defwinproc|optional },
3044 { 0x0092, sent|defwinproc|optional },
3045 { 0x0092, sent|defwinproc|optional },
3046 { 0x0092, sent|defwinproc|optional },
3047 { 0x0092, sent|defwinproc|optional },
3048 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame XP */
3049 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame XP */
3050 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
3051 { 0 }
3052 };
3053 /* ShowWindow(SW_MAXIMIZE) for a visible MDI child window */
3054 static const struct message WmMaximizeMDIchildVisibleSeq[] = {
3055 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
3056 { WM_GETMINMAXINFO, sent },
3057 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
3058 { WM_NCCALCSIZE, sent|wparam, 1 },
3059 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3060 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3061 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3062 /* in MDI frame */
3063 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3064 { WM_NCCALCSIZE, sent|wparam, 1 },
3065 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3066 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
3067 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3068 { 0 }
3069 };
3070 /* ShowWindow(SW_RESTORE) for a visible maximized MDI child window */
3071 static const struct message WmRestoreMDIchildVisibleSeq[] = {
3072 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
3073 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
3074 { WM_NCCALCSIZE, sent|wparam, 1 },
3075 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3076 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3077 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3078 /* in MDI frame */
3079 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3080 { WM_NCCALCSIZE, sent|wparam, 1 },
3081 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3082 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
3083 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3084 { 0 }
3085 };
3086 /* ShowWindow(SW_RESTORE) for a visible minimized MDI child window */
3087 static const struct message WmRestoreMDIchildVisibleSeq_2[] = {
3088 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
3089 { WM_QUERYOPEN, sent|wparam|lparam, 0, 0 },
3090 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
3091 { WM_NCCALCSIZE, sent|wparam, 1 },
3092 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3093 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_NOCLIENTSIZE|SWP_STATECHANGED },
3094 { WM_MOVE, sent|defwinproc },
3095 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3096 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3097 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3098 { HCBT_SETFOCUS, hook },
3099 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
3100 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
3101 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3102 { WM_SETFOCUS, sent },
3103 { 0 }
3104 };
3105 /* ShowWindow(SW_MINIMIZE) for a visible restored MDI child window */
3106 static const struct message WmMinimizeMDIchildVisibleSeq[] = {
3107 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
3108 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_STATECHANGED },
3109 { WM_NCCALCSIZE, sent|wparam, 1 },
3110 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_NOCLIENTSIZE|SWP_STATECHANGED },
3111 { WM_MOVE, sent|defwinproc },
3112 { WM_SIZE, sent|defwinproc|wparam, SIZE_MINIMIZED },
3113 { WM_CHILDACTIVATE, sent|wparam|lparam|defwinproc, 0, 0 },
3114 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3115 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3116 /* FIXME: Wine creates an icon/title window while Windows doesn't */
3117 { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE }, /* MDI client */
3118 { 0 }
3119 };
3120 /* ShowWindow(SW_RESTORE) for a not visible MDI child window */
3121 static const struct message WmRestoreMDIchildInisibleSeq[] = {
3122 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
3123 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
3124 { WM_NCCALCSIZE, sent|wparam, 1 },
3125 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
3126 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3127 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3128 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3129 /* in MDI frame */
3130 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3131 { WM_NCCALCSIZE, sent|wparam, 1 },
3132 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3133 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
3134 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3135 { 0 }
3136 };
3137
3138 static HWND mdi_client;
3139 static WNDPROC old_mdi_client_proc;
3140
3141 static LRESULT WINAPI mdi_client_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3142 {
3143 struct recvd_message msg;
3144
3145 /* do not log painting messages */
3146 if (message != WM_PAINT &&
3147 message != WM_NCPAINT &&
3148 message != WM_SYNCPAINT &&
3149 message != WM_ERASEBKGND &&
3150 message != WM_NCHITTEST &&
3151 message != WM_GETTEXT &&
3152 message != WM_MDIGETACTIVE &&
3153 message != WM_GETICON &&
3154 message != WM_GETOBJECT &&
3155 message != WM_DEVICECHANGE)
3156 {
3157 msg.hwnd = hwnd;
3158 msg.message = message;
3159 msg.flags = sent|wparam|lparam;
3160 msg.wParam = wParam;
3161 msg.lParam = lParam;
3162 msg.descr = "mdi client";
3163 add_message(&msg);
3164 }
3165
3166 return CallWindowProcA(old_mdi_client_proc, hwnd, message, wParam, lParam);
3167 }
3168
3169 static LRESULT WINAPI mdi_child_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3170 {
3171 static long defwndproc_counter = 0;
3172 LRESULT ret;
3173 struct recvd_message msg;
3174
3175 /* do not log painting messages */
3176 if (message != WM_PAINT &&
3177 message != WM_NCPAINT &&
3178 message != WM_SYNCPAINT &&
3179 message != WM_ERASEBKGND &&
3180 message != WM_NCHITTEST &&
3181 message != WM_GETTEXT &&
3182 message != WM_GETICON &&
3183 message != WM_GETOBJECT &&
3184 message != WM_DEVICECHANGE)
3185 {
3186 switch (message)
3187 {
3188 case WM_MDIACTIVATE:
3189 {
3190 HWND active, client = GetParent(hwnd);
3191
3192 active = (HWND)SendMessageA(client, WM_MDIGETACTIVE, 0, 0);
3193
3194 if (hwnd == (HWND)lParam) /* if we are being activated */
3195 ok (active == (HWND)lParam, "new active %p != active %p\n", (HWND)lParam, active);
3196 else
3197 ok (active == (HWND)wParam, "old active %p != active %p\n", (HWND)wParam, active);
3198 break;
3199 }
3200 }
3201
3202 msg.hwnd = hwnd;
3203 msg.message = message;
3204 msg.flags = sent|wparam|lparam;
3205 if (defwndproc_counter) msg.flags |= defwinproc;
3206 msg.wParam = wParam;
3207 msg.lParam = lParam;
3208 msg.descr = "mdi child";
3209 add_message(&msg);
3210 }
3211
3212 defwndproc_counter++;
3213 ret = DefMDIChildProcA(hwnd, message, wParam, lParam);
3214 defwndproc_counter--;
3215
3216 return ret;
3217 }
3218
3219 static LRESULT WINAPI mdi_frame_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3220 {
3221 static long defwndproc_counter = 0;
3222 LRESULT ret;
3223 struct recvd_message msg;
3224
3225 /* do not log painting messages */
3226 if (message != WM_PAINT &&
3227 message != WM_NCPAINT &&
3228 message != WM_SYNCPAINT &&
3229 message != WM_ERASEBKGND &&
3230 message != WM_NCHITTEST &&
3231 message != WM_GETTEXT &&
3232 message != WM_GETICON &&
3233 message != WM_GETOBJECT &&
3234 message != WM_DEVICECHANGE)
3235 {
3236 msg.hwnd = hwnd;
3237 msg.message = message;
3238 msg.flags = sent|wparam|lparam;
3239 if (defwndproc_counter) msg.flags |= defwinproc;
3240 msg.wParam = wParam;
3241 msg.lParam = lParam;
3242 msg.descr = "mdi frame";
3243 add_message(&msg);
3244 }
3245
3246 defwndproc_counter++;
3247 ret = DefFrameProcA(hwnd, mdi_client, message, wParam, lParam);
3248 defwndproc_counter--;
3249
3250 return ret;
3251 }
3252
3253 static BOOL mdi_RegisterWindowClasses(void)
3254 {
3255 WNDCLASSA cls;
3256
3257 cls.style = 0;
3258 cls.lpfnWndProc = mdi_frame_wnd_proc;
3259 cls.cbClsExtra = 0;
3260 cls.cbWndExtra = 0;
3261 cls.hInstance = GetModuleHandleA(0);
3262 cls.hIcon = 0;
3263 cls.hCursor = LoadCursorA(0, IDC_ARROW);
3264 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
3265 cls.lpszMenuName = NULL;
3266 cls.lpszClassName = "MDI_frame_class";
3267 if (!RegisterClassA(&cls)) return FALSE;
3268
3269 cls.lpfnWndProc = mdi_child_wnd_proc;
3270 cls.lpszClassName = "MDI_child_class";
3271 if (!RegisterClassA(&cls)) return FALSE;
3272
3273 if (!GetClassInfoA(0, "MDIClient", &cls)) assert(0);
3274 old_mdi_client_proc = cls.lpfnWndProc;
3275 cls.hInstance = GetModuleHandleA(0);
3276 cls.lpfnWndProc = mdi_client_hook_proc;
3277 cls.lpszClassName = "MDI_client_class";
3278 if (!RegisterClassA(&cls)) assert(0);
3279
3280 return TRUE;
3281 }
3282
3283 static void test_mdi_messages(void)
3284 {
3285 MDICREATESTRUCTA mdi_cs;
3286 CLIENTCREATESTRUCT client_cs;
3287 HWND mdi_frame, mdi_child, mdi_child2, active_child;
3288 BOOL zoomed;
3289 HMENU hMenu = CreateMenu();
3290
3291 assert(mdi_RegisterWindowClasses());
3292
3293 flush_sequence();
3294
3295 trace("creating MDI frame window\n");
3296 mdi_frame = CreateWindowExA(0, "MDI_frame_class", "MDI frame window",
3297 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
3298 WS_MAXIMIZEBOX | WS_VISIBLE,
3299 100, 100, CW_USEDEFAULT, CW_USEDEFAULT,
3300 GetDesktopWindow(), hMenu,
3301 GetModuleHandleA(0), NULL);
3302 assert(mdi_frame);
3303 ok_sequence(WmCreateMDIframeSeq, "Create MDI frame window", FALSE);
3304
3305 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3306 ok(GetFocus() == mdi_frame, "wrong focus window %p\n", GetFocus());
3307
3308 trace("creating MDI client window\n");
3309 client_cs.hWindowMenu = 0;
3310 client_cs.idFirstChild = MDI_FIRST_CHILD_ID;
3311 mdi_client = CreateWindowExA(0, "MDI_client_class",
3312 NULL,
3313 WS_CHILD | WS_VISIBLE | MDIS_ALLCHILDSTYLES,
3314 0, 0, 0, 0,
3315 mdi_frame, 0, GetModuleHandleA(0), &client_cs);
3316 assert(mdi_client);
3317 ok_sequence(WmCreateMDIclientSeq, "Create visible MDI client window", FALSE);
3318
3319 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3320 ok(GetFocus() == mdi_frame, "input focus should be on MDI frame not on %p\n", GetFocus());
3321
3322 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3323 ok(!active_child, "wrong active MDI child %p\n", active_child);
3324 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3325
3326 SetFocus(0);
3327 flush_sequence();
3328
3329 trace("creating invisible MDI child window\n");
3330 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3331 WS_CHILD,
3332 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3333 mdi_client, 0, GetModuleHandleA(0), NULL);
3334 assert(mdi_child);
3335
3336 flush_sequence();
3337 ShowWindow(mdi_child, SW_SHOWNORMAL);
3338 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOWNORMAL) MDI child window", FALSE);
3339
3340 ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3341 ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
3342
3343 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3344 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3345
3346 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3347 ok(!active_child, "wrong active MDI child %p\n", active_child);
3348 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3349
3350 ShowWindow(mdi_child, SW_HIDE);
3351 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE) MDI child window", FALSE);
3352 flush_sequence();
3353
3354 ShowWindow(mdi_child, SW_SHOW);
3355 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW) MDI child window", FALSE);
3356
3357 ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3358 ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
3359
3360 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3361 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3362
3363 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3364 ok(!active_child, "wrong active MDI child %p\n", active_child);
3365 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3366
3367 DestroyWindow(mdi_child);
3368 flush_sequence();
3369
3370 trace("creating visible MDI child window\n");
3371 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3372 WS_CHILD | WS_VISIBLE,
3373 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3374 mdi_client, 0, GetModuleHandleA(0), NULL);
3375 assert(mdi_child);
3376 ok_sequence(WmCreateMDIchildVisibleSeq, "Create visible MDI child window", FALSE);
3377
3378 ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3379 ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
3380
3381 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3382 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3383
3384 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3385 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3386 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3387 flush_sequence();
3388
3389 DestroyWindow(mdi_child);
3390 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
3391
3392 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3393 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3394
3395 /* Win2k: MDI client still returns a just destroyed child as active
3396 * Win9x: MDI client returns 0
3397 */
3398 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3399 ok(active_child == mdi_child || /* win2k */
3400 !active_child, /* win9x */
3401 "wrong active MDI child %p\n", active_child);
3402 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3403
3404 flush_sequence();
3405
3406 trace("creating invisible MDI child window\n");
3407 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3408 WS_CHILD,
3409 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3410 mdi_client, 0, GetModuleHandleA(0), NULL);
3411 assert(mdi_child2);
3412 ok_sequence(WmCreateMDIchildInvisibleSeq, "Create invisible MDI child window", FALSE);
3413
3414 ok(!(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE), "MDI child should not be visible\n");
3415 ok(!IsWindowVisible(mdi_child2), "MDI child should not be visible\n");
3416
3417 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3418 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3419
3420 /* Win2k: MDI client still returns a just destroyed child as active
3421 * Win9x: MDI client returns mdi_child2
3422 */
3423 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3424 ok(active_child == mdi_child || /* win2k */
3425 active_child == mdi_child2, /* win9x */
3426 "wrong active MDI child %p\n", active_child);
3427 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3428 flush_sequence();
3429
3430 ShowWindow(mdi_child2, SW_MAXIMIZE);
3431 ok_sequence(WmMaximizeMDIchildInvisibleSeq, "ShowWindow(SW_MAXIMIZE):invisible MDI child", FALSE);
3432
3433 ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3434 ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
3435
3436 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3437 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3438 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3439 flush_sequence();
3440
3441 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3442 ok(GetFocus() == mdi_child2 || /* win2k */
3443 GetFocus() == 0, /* win9x */
3444 "wrong focus window %p\n", GetFocus());
3445
3446 SetFocus(0);
3447 flush_sequence();
3448
3449 ShowWindow(mdi_child2, SW_HIDE);
3450 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
3451
3452 ShowWindow(mdi_child2, SW_RESTORE);
3453 ok_sequence(WmRestoreMDIchildInisibleSeq, "ShowWindow(SW_RESTORE):invisible MDI child", FALSE);
3454 flush_sequence();
3455
3456 ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3457 ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
3458
3459 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3460 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3461 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3462 flush_sequence();
3463
3464 SetFocus(0);
3465 flush_sequence();
3466
3467 ShowWindow(mdi_child2, SW_HIDE);
3468 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
3469
3470 ShowWindow(mdi_child2, SW_SHOW);
3471 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):MDI child", FALSE);
3472
3473 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3474 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3475
3476 ShowWindow(mdi_child2, SW_MAXIMIZE);
3477 ok_sequence(WmMaximizeMDIchildVisibleSeq, "ShowWindow(SW_MAXIMIZE):MDI child", FALSE);
3478
3479 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3480 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3481
3482 ShowWindow(mdi_child2, SW_RESTORE);
3483 ok_sequence(WmRestoreMDIchildVisibleSeq, "ShowWindow(SW_RESTORE):maximized MDI child", FALSE);
3484
3485 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3486 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3487
3488 ShowWindow(mdi_child2, SW_MINIMIZE);
3489 ok_sequence(WmMinimizeMDIchildVisibleSeq, "ShowWindow(SW_MINIMIZE):MDI child", TRUE);
3490
3491 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3492 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3493
3494 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3495 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3496 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3497 flush_sequence();
3498
3499 ShowWindow(mdi_child2, SW_RESTORE);
3500 ok_sequence(WmRestoreMDIchildVisibleSeq_2, "ShowWindow(SW_RESTORE):minimized MDI child", TRUE);
3501
3502 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3503 ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
3504
3505 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3506 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3507 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3508 flush_sequence();
3509
3510 SetFocus(0);
3511 flush_sequence();
3512
3513 ShowWindow(mdi_child2, SW_HIDE);
3514 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
3515
3516 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3517 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3518
3519 DestroyWindow(mdi_child2);
3520 ok_sequence(WmDestroyMDIchildInvisibleSeq, "Destroy invisible MDI child window", FALSE);
3521
3522 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3523 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3524
3525 /* test for maximized MDI children */
3526 trace("creating maximized visible MDI child window 1\n");
3527 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3528 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3529 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3530 mdi_client, 0, GetModuleHandleA(0), NULL);
3531 assert(mdi_child);
3532 ok_sequence(WmCreateMDIchildVisibleMaxSeq1, "Create maximized visible 1st MDI child window", TRUE);
3533 ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
3534
3535 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3536 ok(GetFocus() == mdi_child || /* win2k */
3537 GetFocus() == 0, /* win9x */
3538 "wrong focus window %p\n", GetFocus());
3539
3540 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3541 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3542 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3543 flush_sequence();
3544
3545 trace("creating maximized visible MDI child window 2\n");
3546 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3547 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3548 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3549 mdi_client, 0, GetModuleHandleA(0), NULL);
3550 assert(mdi_child2);
3551 ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
3552 ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
3553 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
3554
3555 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3556 ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
3557
3558 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3559 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3560 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3561 flush_sequence();
3562
3563 trace("destroying maximized visible MDI child window 2\n");
3564 DestroyWindow(mdi_child2);
3565 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
3566
3567 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
3568
3569 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3570 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3571
3572 /* Win2k: MDI client still returns a just destroyed child as active
3573 * Win9x: MDI client returns 0
3574 */
3575 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3576 ok(active_child == mdi_child2 || /* win2k */
3577 !active_child, /* win9x */
3578 "wrong active MDI child %p\n", active_child);
3579 flush_sequence();
3580
3581 ShowWindow(mdi_child, SW_MAXIMIZE);
3582 ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
3583 flush_sequence();
3584
3585 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3586 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3587
3588 trace("re-creating maximized visible MDI child window 2\n");
3589 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3590 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3591 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3592 mdi_client, 0, GetModuleHandleA(0), NULL);
3593 assert(mdi_child2);
3594 ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
3595 ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
3596 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
3597
3598 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3599 ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
3600
3601 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3602 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3603 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3604 flush_sequence();
3605
3606 SendMessageA(mdi_child2, WM_SYSCOMMAND, SC_CLOSE, 0);
3607 ok_sequence(WmDestroyMDIchildVisibleMaxSeq2, "WM_SYSCOMMAND/SC_CLOSE on a visible maximized MDI child window", TRUE);
3608 ok(!IsWindow(mdi_child2), "MDI child 2 should be destroyed\n");
3609
3610 ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
3611 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3612 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3613
3614 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3615 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3616 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3617 flush_sequence();
3618
3619 DestroyWindow(mdi_child);
3620 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
3621
3622 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3623 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3624
3625 /* Win2k: MDI client still returns a just destroyed child as active
3626 * Win9x: MDI client returns 0
3627 */
3628 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3629 ok(active_child == mdi_child || /* win2k */
3630 !active_child, /* win9x */
3631 "wrong active MDI child %p\n", active_child);
3632 flush_sequence();
3633
3634 trace("creating maximized invisible MDI child window\n");
3635 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3636 WS_CHILD | WS_MAXIMIZE | WS_CAPTION | WS_THICKFRAME,
3637 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3638 mdi_client, 0, GetModuleHandleA(0), NULL);
3639 assert(mdi_child2);
3640 ok_sequence(WmCreateMDIchildInvisibleMaxSeq4, "Create maximized invisible MDI child window", FALSE);
3641 ok(IsZoomed(mdi_child2), "MDI child should be maximized\n");
3642 ok(!(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE), "MDI child should be not visible\n");
3643 ok(!IsWindowVisible(mdi_child2), "MDI child should be not visible\n");
3644
3645 /* Win2k: MDI client still returns a just destroyed child as active
3646 * Win9x: MDI client returns 0
3647 */
3648 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3649 ok(active_child == mdi_child || /* win2k */
3650 !active_child, /* win9x */
3651 "wrong active MDI child %p\n", active_child);
3652 flush_sequence();
3653
3654 trace("call ShowWindow(mdi_child, SW_MAXIMIZE)\n");
3655 ShowWindow(mdi_child2, SW_MAXIMIZE);
3656 ok_sequence(WmMaximizeMDIchildInvisibleSeq2, "ShowWindow(SW_MAXIMIZE):invisible maximized MDI child", FALSE);
3657 ok(IsZoomed(mdi_child2), "MDI child should be maximized\n");
3658 ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3659 ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
3660
3661 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3662 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3663 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3664 flush_sequence();
3665
3666 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child2, 0);
3667 flush_sequence();
3668
3669 /* end of test for maximized MDI children */
3670 SetFocus(0);
3671 flush_sequence();
3672 trace("creating maximized visible MDI child window 1(Switch test)\n");
3673 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3674 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3675 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3676 mdi_client, 0, GetModuleHandleA(0), NULL);
3677 assert(mdi_child);
3678 ok_sequence(WmCreateMDIchildVisibleMaxSeq1, "Create maximized visible 1st MDI child window(Switch test)", TRUE);
3679 ok(IsZoomed(mdi_child), "1st MDI child should be maximized(Switch test)\n");
3680
3681 ok(GetActiveWindow() == mdi_frame, "wrong active window %p(Switch test)\n", GetActiveWindow());
3682 ok(GetFocus() == mdi_child || /* win2k */
3683 GetFocus() == 0, /* win9x */
3684 "wrong focus window %p(Switch test)\n", GetFocus());
3685
3686 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3687 ok(active_child == mdi_child, "wrong active MDI child %p(Switch test)\n", active_child);
3688 ok(zoomed, "wrong zoomed state %d(Switch test)\n", zoomed);
3689 flush_sequence();
3690
3691 trace("creating maximized visible MDI child window 2(Switch test)\n");
3692 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3693 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3694 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3695 mdi_client, 0, GetModuleHandleA(0), NULL);
3696 assert(mdi_child2);
3697 ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child window (Switch test)", TRUE);
3698
3699 ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized(Switch test)\n");
3700 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized(Switch test)\n");
3701
3702 ok(GetActiveWindow() == mdi_frame, "wrong active window %p(Switch test)\n", GetActiveWindow());
3703 ok(GetFocus() == mdi_child2, "wrong focus window %p(Switch test)\n", GetFocus());
3704
3705 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3706 ok(active_child == mdi_child2, "wrong active MDI child %p(Switch test)\n", active_child);
3707 ok(zoomed, "wrong zoomed state %d(Switch test)\n", zoomed);
3708 flush_sequence();
3709
3710 trace("Switch child window.\n");
3711 SendMessageA(mdi_client, WM_MDIACTIVATE, (WPARAM)mdi_child, 0);
3712 ok_sequence(WmSwitchChild, "Child did not switch correctly", TRUE);
3713 trace("end of test for switch maximized MDI children\n");
3714 flush_sequence();
3715
3716 /* Prepare for switching test of not maximized MDI children */
3717 ShowWindow( mdi_child, SW_NORMAL );
3718 ok(!IsZoomed(mdi_child), "wrong zoomed state for %p(Switch test)\n", mdi_child);
3719 ok(!IsZoomed(mdi_child2), "wrong zoomed state for %p(Switch test)\n", mdi_child2);
3720 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, 0);
3721 ok(active_child == mdi_child, "wrong active MDI child %p(Switch test)\n", active_child);
3722 flush_sequence();
3723
3724 SendMessageA(mdi_client, WM_MDIACTIVATE, (WPARAM)mdi_child2, 0);
3725 ok_sequence(WmSwitchNotMaximizedChild, "Not maximized child did not switch correctly", FALSE);
3726 trace("end of test for switch not maximized MDI children\n");
3727 flush_sequence();
3728
3729 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child, 0);
3730 flush_sequence();
3731
3732 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child2, 0);
3733 flush_sequence();
3734
3735 SetFocus(0);
3736 flush_sequence();
3737 /* end of tests for switch maximized/not maximized MDI children */
3738
3739 mdi_cs.szClass = "MDI_child_Class";
3740 mdi_cs.szTitle = "MDI child";
3741 mdi_cs.hOwner = GetModuleHandleA(0);
3742 mdi_cs.x = 0;
3743 mdi_cs.y = 0;
3744 mdi_cs.cx = CW_USEDEFAULT;
3745 mdi_cs.cy = CW_USEDEFAULT;
3746 mdi_cs.style = WS_CHILD | WS_SYSMENU | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE;
3747 mdi_cs.lParam = 0;
3748 mdi_child = (HWND)SendMessageA(mdi_client, WM_MDICREATE, 0, (LPARAM)&mdi_cs);
3749 ok(mdi_child != 0, "MDI child creation failed\n");
3750 ok_sequence(WmCreateMDIchildVisibleMaxSeq3, "WM_MDICREATE for maximized visible MDI child window", TRUE);
3751
3752 ok(GetMenuItemID(hMenu, GetMenuItemCount(hMenu) - 1) == SC_CLOSE, "SC_CLOSE menu item not found\n");
3753
3754 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3755 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3756
3757 ok(IsZoomed(mdi_child), "MDI child should be maximized\n");
3758 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3759 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3760
3761 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3762 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3763 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3764 flush_sequence();
3765
3766 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child, 0);
3767 ok_sequence(WmDestroyMDIchildVisibleMaxSeq1, "Destroy visible maximized MDI child window", TRUE);
3768
3769 ok(!IsWindow(mdi_child), "MDI child should be destroyed\n");
3770 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3771 ok(!active_child, "wrong active MDI child %p\n", active_child);
3772
3773 SetFocus(0);
3774 flush_sequence();
3775
3776 DestroyWindow(mdi_client);
3777 ok_sequence(WmDestroyMDIclientSeq, "Destroy MDI client window", FALSE);
3778
3779 /* test maximization of MDI child with invisible parent */
3780 client_cs.hWindowMenu = 0;
3781 mdi_client = CreateWindow("MDI_client_class",
3782 NULL,
3783 WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL | WS_VISIBLE,
3784 0, 0, 660, 430,
3785 mdi_frame, 0, GetModuleHandleA(0), &client_cs);
3786 ok_sequence(WmCreateMDIclientSeq, "Create MDI client window", FALSE);
3787
3788 ShowWindow(mdi_client, SW_HIDE);
3789 ok_sequence(WmHideMDIclientSeq, "Hide MDI client window", FALSE);
3790
3791 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3792 WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL,
3793 0, 0, 650, 440,
3794 mdi_client, 0, GetModuleHandleA(0), NULL);
3795 ok_sequence(WmCreateMDIchildInvisibleParentSeq, "Create MDI child window with invisible parent", FALSE);
3796
3797 SendMessage(mdi_client, WM_MDIMAXIMIZE, (WPARAM) mdi_child, 0);
3798 ok_sequence(WmMaximizeMDIchildInvisibleParentSeq, "Maximize MDI child window with invisible parent", TRUE);
3799 zoomed = IsZoomed(mdi_child);
3800 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3801
3802 ShowWindow(mdi_client, SW_SHOW);
3803 ok_sequence(WmShowMDIclientSeq, "Show MDI client window", FALSE);
3804
3805 DestroyWindow(mdi_child);
3806 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible maximized MDI child window", TRUE);
3807
3808 /* end of test for maximization of MDI child with invisible parent */
3809
3810 DestroyWindow(mdi_client);
3811 ok_sequence(WmDestroyMDIclientSeq, "Destroy MDI client window", FALSE);
3812
3813 DestroyWindow(mdi_frame);
3814 ok_sequence(WmDestroyMDIframeSeq, "Destroy MDI frame window", FALSE);
3815 }
3816 /************************* End of MDI test **********************************/
3817
3818 static void test_WM_SETREDRAW(HWND hwnd)
3819 {
3820 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
3821
3822 flush_events();
3823 flush_sequence();
3824
3825 SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
3826 ok_sequence(WmSetRedrawFalseSeq, "SetRedraw:FALSE", FALSE);
3827
3828 ok(!(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should NOT be set\n");
3829 ok(!IsWindowVisible(hwnd), "IsWindowVisible() should return FALSE\n");
3830
3831 flush_sequence();
3832 SendMessageA(hwnd, WM_SETREDRAW, TRUE, 0);
3833 ok_sequence(WmSetRedrawTrueSeq, "SetRedraw:TRUE", FALSE);
3834
3835 ok(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
3836 ok(IsWindowVisible(hwnd), "IsWindowVisible() should return TRUE\n");
3837
3838 /* restore original WS_VISIBLE state */
3839 SetWindowLongA(hwnd, GWL_STYLE, style);
3840
3841 flush_events();
3842 flush_sequence();
3843 }
3844
3845 static INT_PTR CALLBACK TestModalDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3846 {
3847 struct recvd_message msg;
3848
3849 switch (message)
3850 {
3851 /* ignore */
3852 case WM_GETICON:
3853 case WM_GETOBJECT:
3854 case WM_MOUSEMOVE:
3855 case WM_NCMOUSEMOVE:
3856 case WM_NCMOUSELEAVE:
3857 case WM_SETCURSOR:
3858 case WM_DEVICECHANGE:
3859 return 0;
3860 case WM_NCHITTEST:
3861 return HTCLIENT;
3862 }
3863
3864 msg.hwnd = hwnd;
3865 msg.message = message;
3866 msg.flags = sent|wparam|lparam;
3867 msg.wParam = wParam;
3868 msg.lParam = lParam;
3869 msg.descr = "dialog";
3870 add_message(&msg);
3871
3872 if (message == WM_INITDIALOG) SetTimer( hwnd, 1, 100, NULL );
3873 if (message == WM_TIMER) EndDialog( hwnd, 0 );
3874 return 0;
3875 }
3876
3877 static void test_hv_scroll_1(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
3878 {
3879 DWORD style, exstyle;
3880 INT xmin, xmax;
3881 BOOL ret;
3882
3883 exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
3884 style = GetWindowLongA(hwnd, GWL_STYLE);
3885 /* do not be confused by WS_DLGFRAME set */
3886 if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
3887
3888 if (clear) ok(style & clear, "style %08x should be set\n", clear);
3889 if (set) ok(!(style & set), "style %08x should not be set\n", set);
3890
3891 ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
3892 ok( ret, "SetScrollRange(%d) error %d\n", ctl, GetLastError());
3893 if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
3894 ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollRange(SB_HORZ/SB_VERT) NC", FALSE);
3895 else
3896 ok_sequence(WmSetScrollRangeHVSeq, "SetScrollRange(SB_HORZ/SB_VERT)", FALSE);
3897
3898 style = GetWindowLongA(hwnd, GWL_STYLE);
3899 if (set) ok(style & set, "style %08x should be set\n", set);
3900 if (clear) ok(!(style & clear), "style %08x should not be set\n", clear);
3901
3902 /* a subsequent call should do nothing */
3903 ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
3904 ok( ret, "SetScrollRange(%d) error %d\n", ctl, GetLastError());
3905 ok_sequence(WmEmptySeq, "SetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
3906
3907 xmin = 0xdeadbeef;
3908 xmax = 0xdeadbeef;
3909 trace("Ignore GetScrollRange error below if you are on Win9x\n");
3910 ret = GetScrollRange(hwnd, ctl, &xmin, &xmax);
3911 ok( ret, "GetScrollRange(%d) error %d\n", ctl, GetLastError());
3912 ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
3913 ok(xmin == min, "unexpected min scroll value %d\n", xmin);
3914 ok(xmax == max, "unexpected max scroll value %d\n", xmax);
3915 }
3916
3917 static void test_hv_scroll_2(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
3918 {
3919 DWORD style, exstyle;
3920 SCROLLINFO si;
3921 BOOL ret;
3922
3923 exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
3924 style = GetWindowLongA(hwnd, GWL_STYLE);
3925 /* do not be confused by WS_DLGFRAME set */
3926 if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
3927
3928 if (clear) ok(style & clear, "style %08x should be set\n", clear);
3929 if (set) ok(!(style & set), "style %08x should not be set\n", set);
3930
3931 si.cbSize = sizeof(si);
3932 si.fMask = SIF_RANGE;
3933 si.nMin = min;
3934 si.nMax = max;
3935 SetScrollInfo(hwnd, ctl, &si, TRUE);
3936 if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
3937 ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollInfo(SB_HORZ/SB_VERT) NC", FALSE);
3938 else
3939 ok_sequence(WmSetScrollRangeHVSeq, "SetScrollInfo(SB_HORZ/SB_VERT)", FALSE);
3940
3941 style = GetWindowLongA(hwnd, GWL_STYLE);
3942 if (set) ok(style & set, "style %08x should be set\n", set);
3943 if (clear) ok(!(style & clear), "style %08x should not be set\n", clear);
3944
3945 /* a subsequent call should do nothing */
3946 SetScrollInfo(hwnd, ctl, &si, TRUE);
3947 if (style & WS_HSCROLL)
3948 ok_sequence(WmSetScrollRangeHSeq_empty, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
3949 else if (style & WS_VSCROLL)
3950 ok_sequence(WmSetScrollRangeVSeq_empty, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
3951 else
3952 ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
3953
3954 si.fMask = SIF_PAGE;
3955 si.nPage = 5;
3956 SetScrollInfo(hwnd, ctl, &si, FALSE);
3957 ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
3958
3959 si.fMask = SIF_POS;
3960 si.nPos = max - 1;
3961 SetScrollInfo(hwnd, ctl, &si, FALSE);
3962 ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
3963
3964 si.fMask = SIF_RANGE;
3965 si.nMin = 0xdeadbeef;
3966 si.nMax = 0xdeadbeef;
3967 ret = GetScrollInfo(hwnd, ctl, &si);
3968 ok( ret, "GetScrollInfo error %d\n", GetLastError());
3969 ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
3970 ok(si.nMin == min, "unexpected min scroll value %d\n", si.nMin);
3971 ok(si.nMax == max, "unexpected max scroll value %d\n", si.nMax);
3972 }
3973
3974 /* Win9x sends WM_USER+xxx while and NT versions send SBM_xxx messages */
3975 static void test_scroll_messages(HWND hwnd)
3976 {
3977 SCROLLINFO si;
3978 INT min, max;
3979 BOOL ret;
3980
3981 flush_events();
3982 flush_sequence();
3983
3984 min = 0xdeadbeef;
3985 max = 0xdeadbeef;
3986 ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
3987 ok( ret, "GetScrollRange error %d\n", GetLastError());
3988 if (sequence->message != WmGetScrollRangeSeq[0].message)
3989 trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
3990 /* values of min and max are undefined */
3991 flush_sequence();
3992
3993 ret = SetScrollRange(hwnd, SB_CTL, 10, 150, FALSE);
3994 ok( ret, "SetScrollRange error %d\n", GetLastError());
3995 if (sequence->message != WmSetScrollRangeSeq[0].message)
3996 trace("SetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
3997 flush_sequence();
3998
3999 min = 0xdeadbeef;
4000 max = 0xdeadbeef;
4001 ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
4002 ok( ret, "GetScrollRange error %d\n", GetLastError());
4003 if (sequence->message != WmGetScrollRangeSeq[0].message)
4004 trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
4005 /* values of min and max are undefined */
4006 flush_sequence();
4007
4008 si.cbSize = sizeof(si);
4009 si.fMask = SIF_RANGE;
4010 si.nMin = 20;
4011 si.nMax = 160;
4012 SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
4013 if (sequence->message != WmSetScrollRangeSeq[0].message)
4014 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
4015 flush_sequence();
4016
4017 si.fMask = SIF_PAGE;
4018 si.nPage = 10;
4019 SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
4020 if (sequence->message != WmSetScrollRangeSeq[0].message)
4021 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
4022 flush_sequence();
4023
4024 si.fMask = SIF_POS;
4025 si.nPos = 20;
4026 SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
4027 if (sequence->message != WmSetScrollRangeSeq[0].message)
4028 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
4029 flush_sequence();
4030
4031 si.fMask = SIF_RANGE;
4032 si.nMin = 0xdeadbeef;
4033 si.nMax = 0xdeadbeef;
4034 ret = GetScrollInfo(hwnd, SB_CTL, &si);
4035 ok( ret, "GetScrollInfo error %d\n", GetLastError());
4036 if (sequence->message != WmGetScrollInfoSeq[0].message)
4037 trace("GetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
4038 /* values of min and max are undefined */
4039 flush_sequence();
4040
4041 /* set WS_HSCROLL */
4042 test_hv_scroll_1(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
4043 /* clear WS_HSCROLL */
4044 test_hv_scroll_1(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
4045
4046 /* set WS_HSCROLL */
4047 test_hv_scroll_2(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
4048 /* clear WS_HSCROLL */
4049 test_hv_scroll_2(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
4050
4051 /* set WS_VSCROLL */
4052 test_hv_scroll_1(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
4053 /* clear WS_VSCROLL */
4054 test_hv_scroll_1(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
4055
4056 /* set WS_VSCROLL */
4057 test_hv_scroll_2(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
4058 /* clear WS_VSCROLL */
4059 test_hv_scroll_2(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
4060 }
4061
4062 static void test_showwindow(void)
4063 {
4064 HWND hwnd, hchild;
4065 RECT rc;
4066
4067 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
4068 100, 100, 200, 200, 0, 0, 0, NULL);
4069 ok (hwnd != 0, "Failed to create overlapped window\n");
4070 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4071 0, 0, 10, 10, hwnd, 0, 0, NULL);
4072 ok (hchild != 0, "Failed to create child\n");
4073 flush_sequence();
4074
4075 /* ShowWindow( SW_SHOWNA) for invisible top level window */
4076 trace("calling ShowWindow( SW_SHOWNA) for invisible top level window\n");
4077 ok( ShowWindow(hwnd, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
4078 ok_sequence(WmSHOWNATopInvisible, "ShowWindow(SW_SHOWNA) on invisible top level window", TRUE);
4079
4080 /* ShowWindow( SW_SHOWNA) for now visible top level window */
4081 trace("calling ShowWindow( SW_SHOWNA) for now visible top level window\n");
4082 ok( ShowWindow(hwnd, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
4083 ok_sequence(WmSHOWNATopVisible, "ShowWindow(SW_SHOWNA) on visible top level window", FALSE);
4084 /* back to invisible */
4085 ShowWindow(hchild, SW_HIDE);
4086 ShowWindow(hwnd, SW_HIDE);
4087 flush_sequence();
4088 /* ShowWindow(SW_SHOWNA) with child and parent invisible */
4089 trace("calling ShowWindow( SW_SHOWNA) for invisible child with invisible parent\n");
4090 ok( ShowWindow(hchild, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
4091 ok_sequence(WmSHOWNAChildInvisParInvis, "ShowWindow(SW_SHOWNA) invisible child and parent", FALSE);
4092 /* ShowWindow(SW_SHOWNA) with child visible and parent invisible */
4093 ok( ShowWindow(hchild, SW_SHOW) != FALSE, "ShowWindow: window was invisible\n" );
4094 flush_sequence();
4095 trace("calling ShowWindow( SW_SHOWNA) for the visible child and invisible parent\n");
4096 ok( ShowWindow(hchild, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
4097 ok_sequence(WmSHOWNAChildVisParInvis, "ShowWindow(SW_SHOWNA) visible child and invisible parent", FALSE);
4098 /* ShowWindow(SW_SHOWNA) with child visible and parent visible */
4099 ShowWindow( hwnd, SW_SHOW);
4100 flush_sequence();
4101 trace("calling ShowWindow( SW_SHOWNA) for the visible child and parent\n");
4102 ok( ShowWindow(hchild, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
4103 ok_sequence(WmSHOWNAChildVisParVis, "ShowWindow(SW_SHOWNA) for the visible child and parent", FALSE);
4104
4105 /* ShowWindow(SW_SHOWNA) with child invisible and parent visible */
4106 ShowWindow( hchild, SW_HIDE);
4107 flush_sequence();
4108 trace("calling ShowWindow( SW_SHOWNA) for the invisible child and visible parent\n");
4109 ok( ShowWindow(hchild, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
4110 ok_sequence(WmSHOWNAChildInvisParVis, "ShowWindow(SW_SHOWNA) for the invisible child and visible parent", FALSE);
4111
4112 SetCapture(hchild);
4113 ok(GetCapture() == hchild, "wrong capture window %p\n", GetCapture());
4114 DestroyWindow(hchild);
4115 ok(!GetCapture(), "wrong capture window %p\n", GetCapture());
4116
4117 DestroyWindow(hwnd);
4118 flush_sequence();
4119
4120 /* Popup windows */
4121 /* Test 1:
4122 * 1. Create invisible maximized popup window.
4123 * 2. Move and resize it.
4124 * 3. Show it maximized.
4125 */
4126 trace("calling CreateWindowExA( WS_MAXIMIZE ) for invisible maximized popup window\n");
4127 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE,
4128 100, 100, 200, 200, 0, 0, 0, NULL);
4129 ok (hwnd != 0, "Failed to create popup window\n");
4130 ok(IsZoomed(hwnd), "window should be maximized\n");
4131 ok_sequence(WmCreateInvisibleMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
4132
4133 GetWindowRect(hwnd, &rc);
4134 ok( rc.right-rc.left == GetSystemMetrics(SM_CXSCREEN) &&
4135 rc.bottom-rc.top == GetSystemMetrics(SM_CYSCREEN),
4136 "Invalid maximized size before ShowWindow (%d,%d)-(%d,%d)\n",
4137 rc.left, rc.top, rc.right, rc.bottom);
4138 /* Reset window's size & position */
4139 SetWindowPos(hwnd, 0, 10, 10, 200, 200, SWP_NOZORDER | SWP_NOACTIVATE);
4140 ok(IsZoomed(hwnd), "window should be maximized\n");
4141 flush_sequence();
4142
4143 trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for invisible maximized popup window\n");
4144 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
4145 ok(IsZoomed(hwnd), "window should be maximized\n");
4146 ok_sequence(WmShowMaxPopupResizedSeq, "ShowWindow(SW_SHOWMAXIMIZED):invisible maximized and resized popup", FALSE);
4147
4148 GetWindowRect(hwnd, &rc);
4149 ok( rc.right-rc.left == GetSystemMetrics(SM_CXSCREEN) &&
4150 rc.bottom-rc.top == GetSystemMetrics(SM_CYSCREEN),
4151 "Invalid maximized size after ShowWindow (%d,%d)-(%d,%d)\n",
4152 rc.left, rc.top, rc.right, rc.bottom);
4153 DestroyWindow(hwnd);
4154 flush_sequence();
4155
4156 /* Test 2:
4157 * 1. Create invisible maximized popup window.
4158 * 2. Show it maximized.
4159 */
4160 trace("calling CreateWindowExA( WS_MAXIMIZE ) for invisible maximized popup window\n");
4161 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE,
4162 100, 100, 200, 200, 0, 0, 0, NULL);
4163 ok (hwnd != 0, "Failed to create popup window\n");
4164 ok(IsZoomed(hwnd), "window should be maximized\n");
4165 ok_sequence(WmCreateInvisibleMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
4166
4167 trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for invisible maximized popup window\n");
4168 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
4169 ok(IsZoomed(hwnd), "window should be maximized\n");
4170 ok_sequence(WmShowMaxPopupSeq, "ShowWindow(SW_SHOWMAXIMIZED):invisible maximized popup", FALSE);
4171 DestroyWindow(hwnd);
4172 flush_sequence();
4173
4174 /* Test 3:
4175 * 1. Create visible maximized popup window.
4176 */
4177 trace("calling CreateWindowExA( WS_MAXIMIZE ) for maximized popup window\n");
4178 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE | WS_VISIBLE,
4179 100, 100, 200, 200, 0, 0, 0, NULL);
4180 ok (hwnd != 0, "Failed to create popup window\n");
4181 ok(IsZoomed(hwnd), "window should be maximized\n");
4182 ok_sequence(WmCreateMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
4183 DestroyWindow(hwnd);
4184 flush_sequence();
4185
4186 /* Test 4:
4187 * 1. Create visible popup window.
4188 * 2. Maximize it.
4189 */
4190 trace("calling CreateWindowExA( WS_VISIBLE ) for popup window\n");
4191 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_VISIBLE,
4192 100, 100, 200, 200, 0, 0, 0, NULL);
4193 ok (hwnd != 0, "Failed to create popup window\n");
4194 ok(!IsZoomed(hwnd), "window should NOT be maximized\n");
4195 ok_sequence(WmCreatePopupSeq, "CreateWindow(WS_VISIBLE):popup", FALSE);
4196
4197 trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for visible popup window\n");
4198 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
4199 ok(IsZoomed(hwnd), "window should be maximized\n");
4200 ok_sequence(WmShowVisMaxPopupSeq, "ShowWindow(SW_SHOWMAXIMIZED):popup", FALSE);
4201 DestroyWindow(hwnd);
4202 flush_sequence();
4203 }
4204
4205 static void test_sys_menu(void)
4206 {
4207 HWND hwnd;
4208 HMENU hmenu;
4209 UINT state;
4210
4211 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
4212 100, 100, 200, 200, 0, 0, 0, NULL);
4213 ok (hwnd != 0, "Failed to create overlapped window\n");
4214
4215 flush_sequence();
4216
4217 /* test existing window without CS_NOCLOSE style */
4218 hmenu = GetSystemMenu(hwnd, FALSE);
4219 ok(hmenu != 0, "GetSystemMenu error %d\n", GetLastError());
4220
4221 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
4222 ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
4223 ok(!(state & (MF_DISABLED | MF_GRAYED)), "wrong SC_CLOSE state %x\n", state);
4224
4225 EnableMenuItem(hmenu, SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
4226 ok_sequence(WmEmptySeq, "WmEnableMenuItem", FALSE);
4227
4228 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
4229 ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
4230 ok((state & (MF_DISABLED | MF_GRAYED)) == MF_GRAYED, "wrong SC_CLOSE state %x\n", state);
4231
4232 EnableMenuItem(hmenu, SC_CLOSE, 0);
4233 ok_sequence(WmEmptySeq, "WmEnableMenuItem", FALSE);
4234
4235 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
4236 ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
4237 ok(!(state & (MF_DISABLED | MF_GRAYED)), "wrong SC_CLOSE state %x\n", state);
4238
4239 /* test whether removing WS_SYSMENU destroys a system menu */
4240 SetWindowLongW(hwnd, GWL_STYLE, WS_POPUP);
4241 SetWindowPos(hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_FRAMECHANGED);
4242 flush_sequence();
4243 hmenu = GetSystemMenu(hwnd, FALSE);
4244 ok(hmenu != 0, "GetSystemMenu error %d\n", GetLastError());
4245
4246 DestroyWindow(hwnd);
4247
4248 /* test new window with CS_NOCLOSE style */
4249 hwnd = CreateWindowExA(0, "NoCloseWindowClass", NULL, WS_OVERLAPPEDWINDOW,
4250 100, 100, 200, 200, 0, 0, 0, NULL);
4251 ok (hwnd != 0, "Failed to create overlapped window\n");
4252
4253 hmenu = GetSystemMenu(hwnd, FALSE);
4254 ok(hmenu != 0, "GetSystemMenu error %d\n", GetLastError());
4255
4256 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
4257 ok(state == 0xffffffff, "wrong SC_CLOSE state %x\n", state);
4258
4259 DestroyWindow(hwnd);
4260
4261 /* test new window without WS_SYSMENU style */
4262 hwnd = CreateWindowExA(0, "NoCloseWindowClass", NULL, WS_OVERLAPPEDWINDOW & ~WS_SYSMENU,
4263 100, 100, 200, 200, 0, 0, 0, NULL);
4264 ok(hwnd != 0, "Failed to create overlapped window\n");
4265
4266 hmenu = GetSystemMenu(hwnd, FALSE);
4267 ok(!hmenu, "GetSystemMenu error %d\n", GetLastError());
4268
4269 DestroyWindow(hwnd);
4270 }
4271
4272 /* For shown WS_OVERLAPPEDWINDOW */
4273 static const struct message WmSetIcon_1[] = {
4274 { WM_SETICON, sent },
4275 { 0x00AE, sent|defwinproc|optional }, /* XP */
4276 { WM_GETTEXT, sent|defwinproc|optional },
4277 { WM_GETTEXT, sent|defwinproc|optional }, /* XP sends a duplicate */
4278 { 0 }
4279 };
4280
4281 /* For WS_POPUP and hidden WS_OVERLAPPEDWINDOW */
4282 static const struct message WmSetIcon_2[] = {
4283 { WM_SETICON, sent },
4284 { 0 }
4285 };
4286
4287 /* Sending undocumented 0x3B message with wparam = 0x8000000b */
4288 static const struct message WmInitEndSession[] = {
4289 { 0x003B, sent },
4290 { WM_QUERYENDSESSION, sent|defwinproc|wparam|lparam, 0, ENDSESSION_LOGOFF },
4291 { 0 }
4292 };
4293
4294 /* Sending undocumented 0x3B message with wparam = 0x0000000b */
4295 static const struct message WmInitEndSession_2[] = {
4296 { 0x003B, sent },
4297 { WM_QUERYENDSESSION, sent|defwinproc|wparam|lparam, 0, 0 },
4298 { 0 }
4299 };
4300
4301 /* Sending undocumented 0x3B message with wparam = 0x80000008 */
4302 static const struct message WmInitEndSession_3[] = {
4303 { 0x003B, sent },
4304 { WM_ENDSESSION, sent|defwinproc|wparam|lparam, 0, ENDSESSION_LOGOFF },
4305 { 0 }
4306 };
4307
4308 /* Sending undocumented 0x3B message with wparam = 0x00000008 */
4309 static const struct message WmInitEndSession_4[] = {
4310 { 0x003B, sent },
4311 { WM_ENDSESSION, sent|defwinproc|wparam|lparam, 0, 0 },
4312 { 0 }
4313 };
4314
4315 /* Sending undocumented 0x3B message with wparam = 0x80000001 */
4316 static const struct message WmInitEndSession_5[] = {
4317 { 0x003B, sent },
4318 { WM_ENDSESSION, sent|defwinproc/*|wparam*/|lparam, 1, ENDSESSION_LOGOFF },
4319 { 0 }
4320 };
4321
4322 static const struct message WmOptionalPaint[] = {
4323 { WM_PAINT, sent|optional },
4324 { WM_NCPAINT, sent|beginpaint|optional },
4325 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
4326 { WM_ERASEBKGND, sent|beginpaint|optional },
4327 { 0 }
4328 };
4329
4330 static const struct message WmZOrder[] = {
4331 { WM_WINDOWPOSCHANGING, sent|wparam, 0, 0 },
4332 { WM_GETMINMAXINFO, sent|defwinproc|wparam, 0, 0 },
4333 { HCBT_ACTIVATE, hook },
4334 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
4335 { WM_WINDOWPOSCHANGING, sent|wparam, 3, 0 },
4336 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOREDRAW|SWP_NOMOVE|SWP_NOSIZE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE, 0 },
4337 { WM_GETTEXT, sent|optional },
4338 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
4339 { WM_ACTIVATEAPP, sent|wparam, 1, 0 },
4340 { WM_NCACTIVATE, sent|wparam|lparam, 1, 0 },
4341 { WM_GETTEXT, sent|defwinproc|optional },
4342 { WM_GETTEXT, sent|defwinproc|optional },
4343 { WM_ACTIVATE, sent|wparam|lparam, 1, 0 },
4344 { HCBT_SETFOCUS, hook },
4345 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
4346 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
4347 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
4348 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
4349 { WM_GETTEXT, sent|optional },
4350 { WM_NCCALCSIZE, sent|optional },
4351 { 0 }
4352 };
4353
4354 static void test_MsgWaitForMultipleObjects(HWND hwnd)
4355 {
4356 DWORD ret;
4357 MSG msg;
4358
4359 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4360 ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %x\n", ret);
4361
4362 PostMessageA(hwnd, WM_USER, 0, 0);
4363
4364 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4365 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %x\n", ret);
4366
4367 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
4368 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4369
4370 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4371 ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %x\n", ret);
4372
4373 PostMessageA(hwnd, WM_USER, 0, 0);
4374
4375 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4376 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %x\n", ret);
4377
4378 ok(PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ), "PeekMessage should succeed\n");
4379 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4380
4381 /* shows QS_POSTMESSAGE flag is cleared in the PeekMessage call */
4382 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4383 ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %x\n", ret);
4384
4385 PostMessageA(hwnd, WM_USER, 0, 0);
4386
4387 /* new incoming message causes it to become signaled again */
4388 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4389 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %x\n", ret);
4390
4391 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
4392 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4393 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
4394 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4395 }
4396
4397 /* test if we receive the right sequence of messages */
4398 static void test_messages(void)
4399 {
4400 HWND hwnd, hparent, hchild;
4401 HWND hchild2, hbutton;
4402 HMENU hmenu;
4403 MSG msg;
4404 LRESULT res;
4405
4406 flush_sequence();
4407
4408 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
4409 100, 100, 200, 200, 0, 0, 0, NULL);
4410 ok (hwnd != 0, "Failed to create overlapped window\n");
4411 ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
4412
4413 /* test ShowWindow(SW_HIDE) on a newly created invisible window */
4414 ok( ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow: window was visible\n" );
4415 ok_sequence(WmEmptySeq, "ShowWindow(SW_HIDE):overlapped, invisible", FALSE);
4416
4417 /* test WM_SETREDRAW on a not visible top level window */
4418 test_WM_SETREDRAW(hwnd);
4419
4420 SetWindowPos(hwnd, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4421 flush_events();
4422 ok_sequence(WmSWP_ShowOverlappedSeq, "SetWindowPos:SWP_SHOWWINDOW:overlapped", FALSE);
4423 ok(IsWindowVisible(hwnd), "window should be visible at this point\n");
4424
4425 ok(GetActiveWindow() == hwnd, "window should be active\n");
4426 ok(GetFocus() == hwnd, "window should have input focus\n");
4427 ShowWindow(hwnd, SW_HIDE);
4428 flush_events();
4429 ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
4430
4431 ShowWindow(hwnd, SW_SHOW);
4432 flush_events();
4433 ok_sequence(WmShowOverlappedSeq, "ShowWindow(SW_SHOW):overlapped", TRUE);
4434
4435 ShowWindow(hwnd, SW_HIDE);
4436 flush_events();
4437 ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
4438
4439 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
4440 flush_events();
4441 ok_sequence(WmShowMaxOverlappedSeq, "ShowWindow(SW_SHOWMAXIMIZED):overlapped", TRUE);
4442 flush_sequence();
4443
4444 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_MAXIMIZE)
4445 {
4446 ShowWindow(hwnd, SW_RESTORE);
4447 flush_events();
4448 ok_sequence(WmShowRestoreMaxOverlappedSeq, "ShowWindow(SW_RESTORE):overlapped", FALSE);
4449 flush_sequence();
4450 }
4451
4452 ShowWindow(hwnd, SW_MINIMIZE);
4453 flush_events();
4454 ok_sequence(WmShowMinOverlappedSeq, "ShowWindow(SW_SHOWMINIMIZED):overlapped", TRUE);
4455 flush_sequence();
4456
4457 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_MINIMIZE)
4458 {
4459 ShowWindow(hwnd, SW_RESTORE);
4460 flush_events();
4461 ok_sequence(WmShowRestoreMinOverlappedSeq, "ShowWindow(SW_RESTORE):overlapped", TRUE);
4462 flush_sequence();
4463 }
4464
4465 ShowWindow(hwnd, SW_SHOW);
4466 flush_events();
4467 ok_sequence(WmOptionalPaint, "ShowWindow(SW_SHOW):overlapped already visible", FALSE);
4468
4469 ok(GetActiveWindow() == hwnd, "window should be active\n");
4470 ok(GetFocus() == hwnd, "window should have input focus\n");
4471 SetWindowPos(hwnd, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4472 ok_sequence(WmSWP_HideOverlappedSeq, "SetWindowPos:SWP_HIDEWINDOW:overlapped", FALSE);
4473 ok(!IsWindowVisible(hwnd), "window should not be visible at this point\n");
4474 ok(GetActiveWindow() == hwnd, "window should still be active\n");
4475
4476 /* test WM_SETREDRAW on a visible top level window */
4477 ShowWindow(hwnd, SW_SHOW);
4478 flush_events();
4479 test_WM_SETREDRAW(hwnd);
4480
4481 trace("testing scroll APIs on a visible top level window %p\n", hwnd);
4482 test_scroll_messages(hwnd);
4483
4484 /* test resizing and moving */
4485 SetWindowPos( hwnd, 0, 0, 0, 300, 300, SWP_NOMOVE|SWP_NOACTIVATE );
4486 ok_sequence(WmSWP_ResizeSeq, "SetWindowPos:Resize", FALSE );
4487 flush_events();
4488 flush_sequence();
4489 SetWindowPos( hwnd, 0, 200, 200, 0, 0, SWP_NOSIZE|SWP_NOACTIVATE );
4490 ok_sequence(WmSWP_MoveSeq, "SetWindowPos:Move", FALSE );
4491 flush_events();
4492 flush_sequence();
4493 SetWindowPos( hwnd, 0, 200, 200, 250, 250, SWP_NOZORDER|SWP_NOACTIVATE );
4494 ok_sequence(WmSWP_ResizeNoZOrder, "SetWindowPos:WmSWP_ResizeNoZOrder", FALSE );
4495 flush_events();
4496 flush_sequence();
4497
4498 /* popups don't get WM_GETMINMAXINFO */
4499 SetWindowLongW( hwnd, GWL_STYLE, WS_VISIBLE|WS_POPUP );
4500 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_FRAMECHANGED);
4501 flush_sequence();
4502 SetWindowPos( hwnd, 0, 0, 0, 200, 200, SWP_NOMOVE|SWP_NOACTIVATE );
4503 ok_sequence(WmSWP_ResizePopupSeq, "SetWindowPos:ResizePopup", FALSE );
4504
4505 DestroyWindow(hwnd);
4506 ok_sequence(WmDestroyOverlappedSeq, "DestroyWindow:overlapped", FALSE);
4507
4508 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
4509 100, 100, 200, 200, 0, 0, 0, NULL);
4510 ok (hparent != 0, "Failed to create parent window\n");
4511 flush_sequence();
4512
4513 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_MAXIMIZE,
4514 0, 0, 10, 10, hparent, 0, 0, NULL);
4515 ok (hchild != 0, "Failed to create child window\n");
4516 ok_sequence(WmCreateMaximizedChildSeq, "CreateWindow:maximized child", FALSE);
4517 DestroyWindow(hchild);
4518 flush_sequence();
4519
4520 /* visible child window with a caption */
4521 hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
4522 WS_CHILD | WS_VISIBLE | WS_CAPTION,
4523 0, 0, 10, 10, hparent, 0, 0, NULL);
4524 ok (hchild != 0, "Failed to create child window\n");
4525 ok_sequence(WmCreateVisibleChildSeq, "CreateWindow:visible child", FALSE);
4526
4527 trace("testing scroll APIs on a visible child window %p\n", hchild);
4528 test_scroll_messages(hchild);
4529
4530 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4531 ok_sequence(WmShowChildSeq_4, "SetWindowPos(SWP_SHOWWINDOW):child with a caption", FALSE);
4532
4533 DestroyWindow(hchild);
4534 flush_sequence();
4535
4536 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4537 0, 0, 10, 10, hparent, 0, 0, NULL);
4538 ok (hchild != 0, "Failed to create child window\n");
4539 ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
4540
4541 hchild2 = CreateWindowExA(0, "SimpleWindowClass", "Test child2", WS_CHILD,
4542 100, 100, 50, 50, hparent, 0, 0, NULL);
4543 ok (hchild2 != 0, "Failed to create child2 window\n");
4544 flush_sequence();
4545
4546 hbutton = CreateWindowExA(0, "TestWindowClass", "Test button", WS_CHILD,
4547 0, 100, 50, 50, hchild, 0, 0, NULL);
4548 ok (hbutton != 0, "Failed to create button window\n");
4549
4550 /* test WM_SETREDRAW on a not visible child window */
4551 test_WM_SETREDRAW(hchild);
4552
4553 ShowWindow(hchild, SW_SHOW);
4554 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
4555
4556 /* check parent messages too */
4557 log_all_parent_messages++;
4558 ShowWindow(hchild, SW_HIDE);
4559 ok_sequence(WmHideChildSeq2, "ShowWindow(SW_HIDE):child", FALSE);
4560 log_all_parent_messages--;
4561
4562 ShowWindow(hchild, SW_SHOW);
4563 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
4564
4565 ShowWindow(hchild, SW_HIDE);
4566 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):child", FALSE);
4567
4568 ShowWindow(hchild, SW_SHOW);
4569 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
4570
4571 /* test WM_SETREDRAW on a visible child window */
4572 test_WM_SETREDRAW(hchild);
4573
4574 log_all_parent_messages++;
4575 MoveWindow(hchild, 10, 10, 20, 20, TRUE);
4576 ok_sequence(WmResizingChildWithMoveWindowSeq, "MoveWindow:child", FALSE);
4577 log_all_parent_messages--;
4578
4579 ShowWindow(hchild, SW_HIDE);
4580 flush_sequence();
4581 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4582 ok_sequence(WmShowChildSeq_2, "SetWindowPos:show_child_2", FALSE);
4583
4584 ShowWindow(hchild, SW_HIDE);
4585 flush_sequence();
4586 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE);
4587 ok_sequence(WmShowChildSeq_3, "SetWindowPos:show_child_3", FALSE);
4588
4589 /* DestroyWindow sequence below expects that a child has focus */
4590 SetFocus(hchild);
4591 flush_sequence();
4592
4593 DestroyWindow(hchild);
4594 ok_sequence(WmDestroyChildSeq, "DestroyWindow:child", FALSE);
4595 DestroyWindow(hchild2);
4596 DestroyWindow(hbutton);
4597
4598 flush_sequence();
4599 hchild = CreateWindowExA(0, "TestWindowClass", "Test Child Popup", WS_CHILD | WS_POPUP,
4600 0, 0, 100, 100, hparent, 0, 0, NULL);
4601 ok (hchild != 0, "Failed to create child popup window\n");
4602 ok_sequence(WmCreateChildPopupSeq, "CreateWindow:child_popup", FALSE);
4603 DestroyWindow(hchild);
4604
4605 /* test what happens to a window which sets WS_VISIBLE in WM_CREATE */
4606 flush_sequence();
4607 hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP,
4608 0, 0, 100, 100, hparent, 0, 0, NULL);
4609 ok (hchild != 0, "Failed to create popup window\n");
4610 ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
4611 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4612 ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
4613 flush_sequence();
4614 ShowWindow(hchild, SW_SHOW);
4615 ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
4616 flush_sequence();
4617 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
4618 ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
4619 flush_sequence();
4620 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4621 ok_sequence(WmShowVisiblePopupSeq_3, "SetWindowPos:show_visible_popup_3", FALSE);
4622 DestroyWindow(hchild);
4623
4624 /* this time add WS_VISIBLE for CreateWindowEx, but this fact actually
4625 * changes nothing in message sequences.
4626 */
4627 flush_sequence();
4628 hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP | WS_VISIBLE,
4629 0, 0, 100, 100, hparent, 0, 0, NULL);
4630 ok (hchild != 0, "Failed to create popup window\n");
4631 ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
4632 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4633 ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
4634 flush_sequence();
4635 ShowWindow(hchild, SW_SHOW);
4636 ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
4637 flush_sequence();
4638 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
4639 ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
4640 DestroyWindow(hchild);
4641
4642 flush_sequence();
4643 hwnd = CreateWindowExA(WS_EX_DLGMODALFRAME, "TestDialogClass", NULL, WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
4644 0, 0, 100, 100, hparent, 0, 0, NULL);
4645 ok(hwnd != 0, "Failed to create custom dialog window\n");
4646 ok_sequence(WmCreateCustomDialogSeq, "CreateCustomDialog", TRUE);
4647
4648 /*
4649 trace("testing scroll APIs on a visible dialog %p\n", hwnd);
4650 test_scroll_messages(hwnd);
4651 */
4652
4653 flush_sequence();
4654
4655 test_def_id = 1;
4656 SendMessage(hwnd, WM_NULL, 0, 0);
4657
4658 flush_sequence();
4659 after_end_dialog = 1;
4660 EndDialog( hwnd, 0 );
4661 ok_sequence(WmEndCustomDialogSeq, "EndCustomDialog", FALSE);
4662
4663 DestroyWindow(hwnd);
4664 after_end_dialog = 0;
4665 test_def_id = 0;
4666
4667 hwnd = CreateWindowExA(0, "TestDialogClass", NULL, WS_POPUP,
4668 0, 0, 100, 100, 0, 0, GetModuleHandleA(0), NULL);
4669 ok(hwnd != 0, "Failed to create custom dialog window\n");
4670 flush_sequence();
4671 trace("call ShowWindow(%p, SW_SHOW)\n", hwnd);
4672 ShowWindow(hwnd, SW_SHOW);
4673 ok_sequence(WmShowCustomDialogSeq, "ShowCustomDialog", TRUE);
4674 DestroyWindow(hwnd);
4675
4676 flush_sequence();
4677 DialogBoxA( 0, "TEST_DIALOG", hparent, TestModalDlgProcA );
4678 ok_sequence(WmModalDialogSeq, "ModalDialog", TRUE);
4679
4680 DestroyWindow(hparent);
4681 flush_sequence();
4682
4683 /* Message sequence for SetMenu */
4684 ok(!DrawMenuBar(hwnd), "DrawMenuBar should return FALSE for a window without a menu\n");
4685 ok_sequence(WmEmptySeq, "DrawMenuBar for a window without a menu", FALSE);
4686
4687 hmenu = CreateMenu();
4688 ok (hmenu != 0, "Failed to create menu\n");
4689 ok (InsertMenuA(hmenu, -1, MF_BYPOSITION, 0x1000, "foo"), "InsertMenu failed\n");
4690 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
4691 100, 100, 200, 200, 0, hmenu, 0, NULL);
4692 ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
4693 ok (SetMenu(hwnd, 0), "SetMenu\n");
4694 ok_sequence(WmSetMenuNonVisibleSizeChangeSeq, "SetMenu:NonVisibleSizeChange", FALSE);
4695 ok (SetMenu(hwnd, 0), "SetMenu\n");
4696 ok_sequence(WmSetMenuNonVisibleNoSizeChangeSeq, "SetMenu:NonVisibleNoSizeChange", FALSE);
4697 ShowWindow(hwnd, SW_SHOW);
4698 UpdateWindow( hwnd );
4699 flush_events();
4700 flush_sequence();
4701 ok (SetMenu(hwnd, 0), "SetMenu\n");
4702 ok_sequence(WmSetMenuVisibleNoSizeChangeSeq, "SetMenu:VisibleNoSizeChange", FALSE);
4703 ok (SetMenu(hwnd, hmenu), "SetMenu\n");
4704 ok_sequence(WmSetMenuVisibleSizeChangeSeq, "SetMenu:VisibleSizeChange", FALSE);
4705
4706 UpdateWindow( hwnd );
4707 flush_events();
4708 flush_sequence();
4709 ok(DrawMenuBar(hwnd), "DrawMenuBar\n");
4710 flush_events();
4711 ok_sequence(WmDrawMenuBarSeq, "DrawMenuBar", FALSE);
4712
4713 DestroyWindow(hwnd);
4714 flush_sequence();
4715
4716 /* Message sequence for EnableWindow */
4717 hparent = CreateWindowExA(0, "TestWindowClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
4718 100, 100, 200, 200, 0, 0, 0, NULL);
4719 ok (hparent != 0, "Failed to create parent window\n");
4720 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
4721 0, 0, 10, 10, hparent, 0, 0, NULL);
4722 ok (hchild != 0, "Failed to create child window\n");
4723
4724 SetFocus(hchild);
4725 flush_events();
4726 flush_sequence();
4727
4728 EnableWindow(hparent, FALSE);
4729 ok_sequence(WmEnableWindowSeq_1, "EnableWindow(FALSE)", FALSE);
4730
4731 EnableWindow(hparent, TRUE);
4732 ok_sequence(WmEnableWindowSeq_2, "EnableWindow(TRUE)", FALSE);
4733
4734 flush_events();
4735 flush_sequence();
4736
4737 test_MsgWaitForMultipleObjects(hparent);
4738
4739 /* the following test causes an exception in user.exe under win9x */
4740 if (!PostMessageW( hparent, WM_USER, 0, 0 ))
4741 {
4742 DestroyWindow(hparent);
4743 flush_sequence();
4744 return;
4745 }
4746 PostMessageW( hparent, WM_USER+1, 0, 0 );
4747 /* PeekMessage(NULL) fails, but still removes the message */
4748 SetLastError(0xdeadbeef);
4749 ok( !PeekMessageW( NULL, 0, 0, 0, PM_REMOVE ), "PeekMessage(NULL) should fail\n" );
4750 ok( GetLastError() == ERROR_NOACCESS || /* Win2k */
4751 GetLastError() == 0xdeadbeef, /* NT4 */
4752 "last error is %d\n", GetLastError() );
4753 ok( PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n" );
4754 ok( msg.message == WM_USER+1, "got %x instead of WM_USER+1\n", msg.message );
4755
4756 DestroyWindow(hchild);
4757 DestroyWindow(hparent);
4758 flush_sequence();
4759
4760 /* Message sequences for WM_SETICON */
4761 trace("testing WM_SETICON\n");
4762 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
4763 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
4764 NULL, NULL, 0);
4765 ShowWindow(hwnd, SW_SHOW);
4766 UpdateWindow(hwnd);
4767 flush_events();
4768 flush_sequence();
4769 SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIcon(0, IDI_APPLICATION));
4770 ok_sequence(WmSetIcon_1, "WM_SETICON for shown window with caption", FALSE);
4771
4772 ShowWindow(hwnd, SW_HIDE);
4773 flush_events();
4774 flush_sequence();
4775 SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIcon(0, IDI_APPLICATION));
4776 ok_sequence(WmSetIcon_2, "WM_SETICON for hidden window with caption", FALSE);
4777 DestroyWindow(hwnd);
4778 flush_sequence();
4779
4780 hwnd = CreateWindowExA(0, "TestPopupClass", NULL, WS_POPUP,
4781 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
4782 NULL, NULL, 0);
4783 ShowWindow(hwnd, SW_SHOW);
4784 UpdateWindow(hwnd);
4785 flush_events();
4786 flush_sequence();
4787 SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIcon(0, IDI_APPLICATION));
4788 ok_sequence(WmSetIcon_2, "WM_SETICON for shown window without caption", FALSE);
4789
4790 ShowWindow(hwnd, SW_HIDE);
4791 flush_events();
4792 flush_sequence();
4793 SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIcon(0, IDI_APPLICATION));
4794 ok_sequence(WmSetIcon_2, "WM_SETICON for hidden window without caption", FALSE);
4795
4796 flush_sequence();
4797 res = SendMessage(hwnd, 0x3B, 0x8000000b, 0);
4798 if (!res)
4799 {
4800 todo_wine win_skip( "Message 0x3b not supported\n" );
4801 goto done;
4802 }
4803 ok_sequence(WmInitEndSession, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x8000000b", TRUE);
4804 ok(res == 1, "SendMessage(hwnd, 0x3B, 0x8000000b, 0) should have returned 1 instead of %ld\n", res);
4805 res = SendMessage(hwnd, 0x3B, 0x0000000b, 0);
4806 ok_sequence(WmInitEndSession_2, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x0000000b", TRUE);
4807 ok(res == 1, "SendMessage(hwnd, 0x3B, 0x0000000b, 0) should have returned 1 instead of %ld\n", res);
4808 res = SendMessage(hwnd, 0x3B, 0x0000000f, 0);
4809 ok_sequence(WmInitEndSession_2, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x0000000f", TRUE);
4810 ok(res == 1, "SendMessage(hwnd, 0x3B, 0x0000000f, 0) should have returned 1 instead of %ld\n", res);
4811
4812 flush_sequence();
4813 res = SendMessage(hwnd, 0x3B, 0x80000008, 0);
4814 ok_sequence(WmInitEndSession_3, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x80000008", TRUE);
4815 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x80000008, 0) should have returned 2 instead of %ld\n", res);
4816 res = SendMessage(hwnd, 0x3B, 0x00000008, 0);
4817 ok_sequence(WmInitEndSession_4, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x00000008", TRUE);
4818 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x00000008, 0) should have returned 2 instead of %ld\n", res);
4819
4820 res = SendMessage(hwnd, 0x3B, 0x80000004, 0);
4821 ok_sequence(WmInitEndSession_3, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x80000004", TRUE);
4822 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x80000004, 0) should have returned 2 instead of %ld\n", res);
4823
4824 res = SendMessage(hwnd, 0x3B, 0x80000001, 0);
4825 ok_sequence(WmInitEndSession_5, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x80000001", TRUE);
4826 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x80000001, 0) should have returned 2 instead of %ld\n", res);
4827
4828 done:
4829 DestroyWindow(hwnd);
4830 flush_sequence();
4831 }
4832
4833 static void test_setwindowpos(void)
4834 {
4835 HWND hwnd;
4836 RECT rc;
4837 LRESULT res;
4838 const INT winX = 100;
4839 const INT winY = 100;
4840 const INT sysX = GetSystemMetrics(SM_CXMINTRACK);
4841
4842 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, 0,
4843 0, 0, winX, winY, 0,
4844 NULL, NULL, 0);
4845
4846 GetWindowRect(hwnd, &rc);
4847 expect(sysX, rc.right);
4848 expect(winY, rc.bottom);
4849
4850 flush_events();
4851 flush_sequence();
4852 res = SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, winX, winY, 0);
4853 ok_sequence(WmZOrder, "Z-Order", TRUE);
4854 ok(res == TRUE, "SetWindowPos expected TRUE, got %ld\n", res);
4855
4856 GetWindowRect(hwnd, &rc);
4857 expect(sysX, rc.right);
4858 expect(winY, rc.bottom);
4859 DestroyWindow(hwnd);
4860 }
4861
4862 static void invisible_parent_tests(void)
4863 {
4864 HWND hparent, hchild;
4865
4866 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW,
4867 100, 100, 200, 200, 0, 0, 0, NULL);
4868 ok (hparent != 0, "Failed to create parent window\n");
4869 flush_sequence();
4870
4871 /* test showing child with hidden parent */
4872
4873 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4874 0, 0, 10, 10, hparent, 0, 0, NULL);
4875 ok (hchild != 0, "Failed to create child window\n");
4876 ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
4877
4878 ShowWindow( hchild, SW_MINIMIZE );
4879 ok_sequence(WmShowChildInvisibleParentSeq_1, "ShowWindow(SW_MINIMIZE) child with invisible parent", FALSE);
4880 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4881 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4882
4883 /* repeat */
4884 flush_events();
4885 flush_sequence();
4886 ShowWindow( hchild, SW_MINIMIZE );
4887 ok_sequence(WmShowChildInvisibleParentSeq_1r, "ShowWindow(SW_MINIMIZE) child with invisible parent", FALSE);
4888
4889 DestroyWindow(hchild);
4890 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4891 0, 0, 10, 10, hparent, 0, 0, NULL);
4892 flush_sequence();
4893
4894 ShowWindow( hchild, SW_MAXIMIZE );
4895 ok_sequence(WmShowChildInvisibleParentSeq_2, "ShowWindow(SW_MAXIMIZE) child with invisible parent", FALSE);
4896 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4897 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4898
4899 /* repeat */
4900 flush_events();
4901 flush_sequence();
4902 ShowWindow( hchild, SW_MAXIMIZE );
4903 ok_sequence(WmShowChildInvisibleParentSeq_2r, "ShowWindow(SW_MAXIMIZE) child with invisible parent", FALSE);
4904
4905 DestroyWindow(hchild);
4906 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4907 0, 0, 10, 10, hparent, 0, 0, NULL);
4908 flush_sequence();
4909
4910 ShowWindow( hchild, SW_RESTORE );
4911 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_RESTORE) child with invisible parent", FALSE);
4912 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4913 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4914
4915 DestroyWindow(hchild);
4916 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4917 0, 0, 10, 10, hparent, 0, 0, NULL);
4918 flush_sequence();
4919
4920 ShowWindow( hchild, SW_SHOWMINIMIZED );
4921 ok_sequence(WmShowChildInvisibleParentSeq_3, "ShowWindow(SW_SHOWMINIMIZED) child with invisible parent", FALSE);
4922 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4923 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4924
4925 /* repeat */
4926 flush_events();
4927 flush_sequence();
4928 ShowWindow( hchild, SW_SHOWMINIMIZED );
4929 ok_sequence(WmShowChildInvisibleParentSeq_3r, "ShowWindow(SW_SHOWMINIMIZED) child with invisible parent", FALSE);
4930
4931 DestroyWindow(hchild);
4932 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4933 0, 0, 10, 10, hparent, 0, 0, NULL);
4934 flush_sequence();
4935
4936 /* same as ShowWindow( hchild, SW_MAXIMIZE ); */
4937 ShowWindow( hchild, SW_SHOWMAXIMIZED );
4938 ok_sequence(WmShowChildInvisibleParentSeq_2, "ShowWindow(SW_SHOWMAXIMIZED) child with invisible parent", FALSE);
4939 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4940 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4941
4942 DestroyWindow(hchild);
4943 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4944 0, 0, 10, 10, hparent, 0, 0, NULL);
4945 flush_sequence();
4946
4947 ShowWindow( hchild, SW_SHOWMINNOACTIVE );
4948 ok_sequence(WmShowChildInvisibleParentSeq_4, "ShowWindow(SW_SHOWMINNOACTIVE) child with invisible parent", FALSE);
4949 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4950 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4951
4952 /* repeat */
4953 flush_events();
4954 flush_sequence();
4955 ShowWindow( hchild, SW_SHOWMINNOACTIVE );
4956 ok_sequence(WmShowChildInvisibleParentSeq_4r, "ShowWindow(SW_SHOWMINNOACTIVE) child with invisible parent", FALSE);
4957
4958 DestroyWindow(hchild);
4959 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4960 0, 0, 10, 10, hparent, 0, 0, NULL);
4961 flush_sequence();
4962
4963 /* FIXME: looks like XP SP2 doesn't know about SW_FORCEMINIMIZE at all */
4964 ShowWindow( hchild, SW_FORCEMINIMIZE );
4965 ok_sequence(WmEmptySeq, "ShowWindow(SW_FORCEMINIMIZE) child with invisible parent", TRUE);
4966 todo_wine {
4967 ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should be not set\n");
4968 }
4969 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4970
4971 DestroyWindow(hchild);
4972 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4973 0, 0, 10, 10, hparent, 0, 0, NULL);
4974 flush_sequence();
4975
4976 ShowWindow( hchild, SW_SHOWNA );
4977 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOWNA) child with invisible parent", FALSE);
4978 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4979 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4980
4981 /* repeat */
4982 flush_events();
4983 flush_sequence();
4984 ShowWindow( hchild, SW_SHOWNA );
4985 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOWNA) child with invisible parent", FALSE);
4986
4987 DestroyWindow(hchild);
4988 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4989 0, 0, 10, 10, hparent, 0, 0, NULL);
4990 flush_sequence();
4991
4992 ShowWindow( hchild, SW_SHOW );
4993 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOW) child with invisible parent", FALSE);
4994 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4995 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4996
4997 /* repeat */
4998 flush_events();
4999 flush_sequence();
5000 ShowWindow( hchild, SW_SHOW );
5001 ok_sequence(WmEmptySeq, "ShowWindow(SW_SHOW) child with invisible parent", FALSE);
5002
5003 ShowWindow( hchild, SW_HIDE );
5004 ok_sequence(WmHideChildInvisibleParentSeq, "ShowWindow:hide child with invisible parent", FALSE);
5005 ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should be not set\n");
5006 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5007
5008 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
5009 ok_sequence(WmShowChildInvisibleParentSeq_6, "SetWindowPos:show child with invisible parent", FALSE);
5010 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5011 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5012
5013 SetWindowPos(hchild, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
5014 ok_sequence(WmHideChildInvisibleParentSeq_2, "SetWindowPos:hide child with invisible parent", FALSE);
5015 ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should not be set\n");
5016 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5017
5018 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
5019 flush_sequence();
5020 DestroyWindow(hchild);
5021 ok_sequence(WmDestroyInvisibleChildSeq, "DestroyInvisibleChildSeq", FALSE);
5022
5023 DestroyWindow(hparent);
5024 flush_sequence();
5025 }
5026
5027 /****************** button message test *************************/
5028 static const struct message WmSetFocusButtonSeq[] =
5029 {
5030 { HCBT_SETFOCUS, hook },
5031 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
5032 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
5033 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5034 { WM_SETFOCUS, sent|wparam, 0 },
5035 { WM_CTLCOLORBTN, sent|defwinproc },
5036 { 0 }
5037 };
5038 static const struct message WmKillFocusButtonSeq[] =
5039 {
5040 { HCBT_SETFOCUS, hook },
5041 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5042 { WM_KILLFOCUS, sent|wparam, 0 },
5043 { WM_CTLCOLORBTN, sent|defwinproc },
5044 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
5045 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
5046 { 0 }
5047 };
5048 static const struct message WmSetFocusStaticSeq[] =
5049 {
5050 { HCBT_SETFOCUS, hook },
5051 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
5052 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
5053 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5054 { WM_SETFOCUS, sent|wparam, 0 },
5055 { WM_CTLCOLORSTATIC, sent|defwinproc },
5056 { 0 }
5057 };
5058 static const struct message WmKillFocusStaticSeq[] =
5059 {
5060 { HCBT_SETFOCUS, hook },
5061 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5062 { WM_KILLFOCUS, sent|wparam, 0 },
5063 { WM_CTLCOLORSTATIC, sent|defwinproc },
5064 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
5065 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
5066 { 0 }
5067 };
5068 static const struct message WmLButtonDownSeq[] =
5069 {
5070 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
5071 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
5072 { HCBT_SETFOCUS, hook },
5073 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
5074 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
5075 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5076 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
5077 { WM_CTLCOLORBTN, sent|defwinproc },
5078 { BM_SETSTATE, sent|wparam|defwinproc, TRUE },
5079 { WM_CTLCOLORBTN, sent|defwinproc },
5080 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5081 { 0 }
5082 };
5083 static const struct message WmLButtonUpSeq[] =
5084 {
5085 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
5086 { BM_SETSTATE, sent|wparam|defwinproc, FALSE },
5087 { WM_CTLCOLORBTN, sent|defwinproc },
5088 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5089 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
5090 { WM_CAPTURECHANGED, sent|wparam|defwinproc, 0 },
5091 { 0 }
5092 };
5093 static const struct message WmSetFontButtonSeq[] =
5094 {
5095 { WM_SETFONT, sent },
5096 { WM_PAINT, sent },
5097 { WM_ERASEBKGND, sent|defwinproc|optional },
5098 { WM_CTLCOLORBTN, sent|defwinproc },
5099 { 0 }
5100 };
5101
5102 static WNDPROC old_button_proc;
5103
5104 static LRESULT CALLBACK button_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
5105 {
5106 static long defwndproc_counter = 0;
5107 LRESULT ret;
5108 struct recvd_message msg;
5109
5110 switch (message)
5111 {
5112 case WM_GETICON:
5113 case WM_GETOBJECT:
5114 return 0; /* ignore them */
5115 case WM_SYNCPAINT:
5116 break;
5117 case BM_SETSTATE:
5118 ok(GetCapture() == hwnd, "GetCapture() = %p\n", GetCapture());
5119 /* fall through */
5120 default:
5121 msg.hwnd = hwnd;
5122 msg.message = message;
5123 msg.flags = sent|wparam|lparam;
5124 if (defwndproc_counter) msg.flags |= defwinproc;
5125 msg.wParam = wParam;
5126 msg.lParam = lParam;
5127 msg.descr = "button";
5128 add_message(&msg);
5129 }
5130
5131 defwndproc_counter++;
5132 ret = CallWindowProcA(old_button_proc, hwnd, message, wParam, lParam);
5133 defwndproc_counter--;
5134
5135 return ret;
5136 }
5137
5138 static void subclass_button(void)
5139 {
5140 WNDCLASSA cls;
5141
5142 if (!GetClassInfoA(0, "button", &cls)) assert(0);
5143
5144 old_button_proc = cls.lpfnWndProc;
5145
5146 cls.hInstance = GetModuleHandle(0);
5147 cls.lpfnWndProc = button_hook_proc;
5148 cls.lpszClassName = "my_button_class";
5149 UnregisterClass(cls.lpszClassName, cls.hInstance);
5150 if (!RegisterClassA(&cls)) assert(0);
5151 }
5152
5153 static void test_button_messages(void)
5154 {
5155 static const struct
5156 {
5157 DWORD style;
5158 DWORD dlg_code;
5159 const struct message *setfocus;
5160 const struct message *killfocus;
5161 } button[] = {
5162 { BS_PUSHBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
5163 WmSetFocusButtonSeq, WmKillFocusButtonSeq },
5164 { BS_DEFPUSHBUTTON, DLGC_BUTTON | DLGC_DEFPUSHBUTTON,
5165 WmSetFocusButtonSeq, WmKillFocusButtonSeq },
5166 { BS_CHECKBOX, DLGC_BUTTON,
5167 WmSetFocusStaticSeq, WmKillFocusStaticSeq },
5168 { BS_AUTOCHECKBOX, DLGC_BUTTON,
5169 WmSetFocusStaticSeq, WmKillFocusStaticSeq },
5170 { BS_RADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
5171 WmSetFocusStaticSeq, WmKillFocusStaticSeq },
5172 { BS_3STATE, DLGC_BUTTON,
5173 WmSetFocusStaticSeq, WmKillFocusStaticSeq },
5174 { BS_AUTO3STATE, DLGC_BUTTON,
5175 WmSetFocusStaticSeq, WmKillFocusStaticSeq },
5176 { BS_GROUPBOX, DLGC_STATIC,
5177 WmSetFocusStaticSeq, WmKillFocusStaticSeq },
5178 { BS_USERBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
5179 WmSetFocusButtonSeq, WmKillFocusButtonSeq },
5180 { BS_AUTORADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
5181 WmSetFocusStaticSeq, WmKillFocusStaticSeq },
5182 { BS_OWNERDRAW, DLGC_BUTTON,
5183 WmSetFocusButtonSeq, WmKillFocusButtonSeq }
5184 };
5185 unsigned int i;
5186 HWND hwnd;
5187 DWORD dlg_code;
5188 HFONT zfont;
5189
5190 subclass_button();
5191
5192 for (i = 0; i < sizeof(button)/sizeof(button[0]); i++)
5193 {
5194 hwnd = CreateWindowExA(0, "my_button_class", "test", button[i].style | WS_POPUP,
5195 0, 0, 50, 14, 0, 0, 0, NULL);
5196 ok(hwnd != 0, "Failed to create button window\n");
5197
5198 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
5199 ok(dlg_code == button[i].dlg_code, "%u: wrong dlg_code %08x\n", i, dlg_code);
5200
5201 ShowWindow(hwnd, SW_SHOW);
5202 UpdateWindow(hwnd);
5203 SetFocus(0);
5204 flush_sequence();
5205
5206 trace("button style %08x\n", button[i].style);
5207 SetFocus(hwnd);
5208 ok_sequence(button[i].setfocus, "SetFocus(hwnd) on a button", FALSE);
5209
5210 SetFocus(0);
5211 ok_sequence(button[i].killfocus, "SetFocus(0) on a button", FALSE);
5212
5213 DestroyWindow(hwnd);
5214 }
5215
5216 hwnd = CreateWindowExA(0, "my_button_class", "test", BS_PUSHBUTTON | WS_POPUP | WS_VISIBLE,
5217 0, 0, 50, 14, 0, 0, 0, NULL);
5218 ok(hwnd != 0, "Failed to create button window\n");
5219
5220 SetForegroundWindow(hwnd);
5221 flush_events();
5222
5223 SetActiveWindow(hwnd);
5224 SetFocus(0);
5225 flush_sequence();
5226
5227 SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
5228 ok_sequence(WmLButtonDownSeq, "WM_LBUTTONDOWN on a button", FALSE);
5229
5230 SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
5231 ok_sequence(WmLButtonUpSeq, "WM_LBUTTONUP on a button", FALSE);
5232
5233 flush_sequence();
5234 zfont = GetStockObject(SYSTEM_FONT);
5235 SendMessageA(hwnd, WM_SETFONT, (WPARAM)zfont, TRUE);
5236 UpdateWindow(hwnd);
5237 ok_sequence(WmSetFontButtonSeq, "WM_SETFONT on a button", FALSE);
5238
5239 DestroyWindow(hwnd);
5240 }
5241
5242 /****************** static message test *************************/
5243 static const struct message WmSetFontStaticSeq[] =
5244 {
5245 { WM_SETFONT, sent },
5246 { WM_PAINT, sent|defwinproc|optional },
5247 { WM_ERASEBKGND, sent|defwinproc|optional },
5248 { WM_CTLCOLORSTATIC, sent|defwinproc|optional },
5249 { 0 }
5250 };
5251
5252 static WNDPROC old_static_proc;
5253
5254 static LRESULT CALLBACK static_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
5255 {
5256 static long defwndproc_counter = 0;
5257 LRESULT ret;
5258 struct recvd_message msg;
5259
5260 if (message == WM_GETICON || message == WM_GETOBJECT) return 0; /* ignore them */
5261
5262 msg.hwnd = hwnd;
5263 msg.message = message;
5264 msg.flags = sent|wparam|lparam;
5265 if (defwndproc_counter) msg.flags |= defwinproc;
5266 msg.wParam = wParam;
5267 msg.lParam = lParam;
5268 msg.descr = "static";
5269 add_message(&msg);
5270
5271 defwndproc_counter++;
5272 ret = CallWindowProcA(old_static_proc, hwnd, message, wParam, lParam);
5273 defwndproc_counter--;
5274
5275 return ret;
5276 }
5277
5278 static void subclass_static(void)
5279 {
5280 WNDCLASSA cls;
5281
5282 if (!GetClassInfoA(0, "static", &cls)) assert(0);
5283
5284 old_static_proc = cls.lpfnWndProc;
5285
5286 cls.hInstance = GetModuleHandle(0);
5287 cls.lpfnWndProc = static_hook_proc;
5288 cls.lpszClassName = "my_static_class";
5289 UnregisterClass(cls.lpszClassName, cls.hInstance);
5290 if (!RegisterClassA(&cls)) assert(0);
5291 }
5292
5293 static void test_static_messages(void)
5294 {
5295 /* FIXME: make as comprehensive as the button message test */
5296 static const struct
5297 {
5298 DWORD style;
5299 DWORD dlg_code;
5300 const struct message *setfont;
5301 } static_ctrl[] = {
5302 { SS_LEFT, DLGC_STATIC,
5303 WmSetFontStaticSeq }
5304 };
5305 unsigned int i;
5306 HWND hwnd;
5307 DWORD dlg_code;
5308
5309 subclass_static();
5310
5311 for (i = 0; i < sizeof(static_ctrl)/sizeof(static_ctrl[0]); i++)
5312 {
5313 hwnd = CreateWindowExA(0, "my_static_class", "test", static_ctrl[i].style | WS_POPUP,
5314 0, 0, 50, 14, 0, 0, 0, NULL);
5315 ok(hwnd != 0, "Failed to create static window\n");
5316
5317 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
5318 ok(dlg_code == static_ctrl[i].dlg_code, "%u: wrong dlg_code %08x\n", i, dlg_code);
5319
5320 ShowWindow(hwnd, SW_SHOW);
5321 UpdateWindow(hwnd);
5322 SetFocus(0);
5323 flush_sequence();
5324
5325 trace("static style %08x\n", static_ctrl[i].style);
5326 SendMessage(hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
5327 ok_sequence(static_ctrl[i].setfont, "WM_SETFONT on a static", FALSE);
5328
5329 DestroyWindow(hwnd);
5330 }
5331 }
5332
5333 /****************** ComboBox message test *************************/
5334 #define ID_COMBOBOX 0x000f
5335
5336 static const struct message WmKeyDownComboSeq[] =
5337 {
5338 { WM_KEYDOWN, sent|wparam|lparam, VK_DOWN, 0 },
5339 { WM_COMMAND, sent|wparam|defwinproc, MAKEWPARAM(1000, LBN_SELCHANGE) },
5340 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_COMBOBOX, CBN_SELENDOK) },
5341 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_COMBOBOX, CBN_SELCHANGE) },
5342 { WM_CTLCOLOREDIT, sent|parent },
5343 { WM_KEYUP, sent|wparam|lparam, VK_DOWN, 0 },
5344 { 0 }
5345 };
5346
5347 static WNDPROC old_combobox_proc;
5348
5349 static LRESULT CALLBACK combobox_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
5350 {
5351 static long defwndproc_counter = 0;
5352 LRESULT ret;
5353 struct recvd_message msg;
5354
5355 /* do not log painting messages */
5356 if (message != WM_PAINT &&
5357 message != WM_NCPAINT &&
5358 message != WM_SYNCPAINT &&
5359 message != WM_ERASEBKGND &&
5360 message != WM_NCHITTEST &&
5361 message != WM_GETTEXT &&
5362 message != WM_GETICON &&
5363 message != WM_GETOBJECT &&
5364 message != WM_DEVICECHANGE)
5365 {
5366 msg.hwnd = hwnd;
5367 msg.message = message;
5368 msg.flags = sent|wparam|lparam;
5369 if (defwndproc_counter) msg.flags |= defwinproc;
5370 msg.wParam = wParam;
5371 msg.lParam = lParam;
5372 msg.descr = "combo";
5373 add_message(&msg);
5374 }
5375
5376 defwndproc_counter++;
5377 ret = CallWindowProcA(old_combobox_proc, hwnd, message, wParam, lParam);
5378 defwndproc_counter--;
5379
5380 return ret;
5381 }
5382
5383 static void subclass_combobox(void)
5384 {
5385 WNDCLASSA cls;
5386
5387 if (!GetClassInfoA(0, "ComboBox", &cls)) assert(0);
5388
5389 old_combobox_proc = cls.lpfnWndProc;
5390
5391 cls.hInstance = GetModuleHandle(0);
5392 cls.lpfnWndProc = combobox_hook_proc;
5393 cls.lpszClassName = "my_combobox_class";
5394 UnregisterClass(cls.lpszClassName, cls.hInstance);
5395 if (!RegisterClassA(&cls)) assert(0);
5396 }
5397
5398 static void test_combobox_messages(void)
5399 {
5400 HWND parent, combo;
5401 LRESULT ret;
5402
5403 subclass_combobox();
5404
5405 parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
5406 100, 100, 200, 200, 0, 0, 0, NULL);
5407 ok(parent != 0, "Failed to create parent window\n");
5408 flush_sequence();
5409
5410 combo = CreateWindowEx(0, "my_combobox_class", "test", WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | CBS_HASSTRINGS,
5411 0, 0, 100, 150, parent, (HMENU)ID_COMBOBOX, 0, NULL);
5412 ok(combo != 0, "Failed to create combobox window\n");
5413
5414 UpdateWindow(combo);
5415
5416 ret = SendMessage(combo, WM_GETDLGCODE, 0, 0);
5417 ok(ret == (DLGC_WANTCHARS | DLGC_WANTARROWS), "wrong dlg_code %08lx\n", ret);
5418
5419 ret = SendMessage(combo, CB_ADDSTRING, 0, (LPARAM)"item 0");
5420 ok(ret == 0, "expected 0, got %ld\n", ret);
5421 ret = SendMessage(combo, CB_ADDSTRING, 0, (LPARAM)"item 1");
5422 ok(ret == 1, "expected 1, got %ld\n", ret);
5423 ret = SendMessage(combo, CB_ADDSTRING, 0, (LPARAM)"item 2");
5424 ok(ret == 2, "expected 2, got %ld\n", ret);
5425
5426 SendMessage(combo, CB_SETCURSEL, 0, 0);
5427 SetFocus(combo);
5428 flush_sequence();
5429
5430 log_all_parent_messages++;
5431 SendMessage(combo, WM_KEYDOWN, VK_DOWN, 0);
5432 SendMessage(combo, WM_KEYUP, VK_DOWN, 0);
5433 log_all_parent_messages--;
5434 ok_sequence(WmKeyDownComboSeq, "WM_KEYDOWN/VK_DOWN on a ComboBox", FALSE);
5435
5436 DestroyWindow(combo);
5437 DestroyWindow(parent);
5438 }
5439
5440 /****************** WM_IME_KEYDOWN message test *******************/
5441
5442 static const struct message WmImeKeydownMsgSeq_0[] =
5443 {
5444 { WM_IME_KEYDOWN, wparam, VK_RETURN },
5445 { WM_CHAR, wparam, 'A' },
5446 { 0 }
5447 };
5448
5449 static const struct message WmImeKeydownMsgSeq_1[] =
5450 {
5451 { WM_KEYDOWN, optional|wparam, VK_RETURN },
5452 { WM_CHAR, optional|wparam, VK_RETURN },
5453 { 0 }
5454 };
5455
5456 static LRESULT WINAPI wmime_keydown_procA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
5457 {
5458 struct recvd_message msg;
5459
5460 msg.hwnd = hwnd;
5461 msg.message = message;
5462 msg.flags = wparam|lparam;
5463 msg.wParam = wParam;
5464 msg.lParam = lParam;
5465 msg.descr = "wmime_keydown";
5466 add_message(&msg);
5467
5468 return DefWindowProcA(hwnd, message, wParam, lParam);
5469 }
5470
5471 static void register_wmime_keydown_class(void)
5472 {
5473 WNDCLASSA cls;
5474
5475 ZeroMemory(&cls, sizeof(WNDCLASSA));
5476 cls.lpfnWndProc = wmime_keydown_procA;
5477 cls.hInstance = GetModuleHandleA(0);
5478 cls.lpszClassName = "wmime_keydown_class";
5479 if (!RegisterClassA(&cls)) assert(0);
5480 }
5481
5482 static void test_wmime_keydown_message(void)
5483 {
5484 HWND hwnd;
5485 MSG msg;
5486
5487 trace("Message sequences by WM_IME_KEYDOWN\n");
5488
5489 register_wmime_keydown_class();
5490 hwnd = CreateWindowExA(0, "wmime_keydown_class", NULL, WS_OVERLAPPEDWINDOW,
5491 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
5492 NULL, NULL, 0);
5493 flush_events();
5494 flush_sequence();
5495
5496 SendMessage(hwnd, WM_IME_KEYDOWN, VK_RETURN, 0x1c0001);
5497 SendMessage(hwnd, WM_CHAR, 'A', 1);
5498 ok_sequence(WmImeKeydownMsgSeq_0, "WM_IME_KEYDOWN 0", FALSE);
5499
5500 while ( PeekMessage(&msg, 0, 0, 0, PM_REMOVE) )
5501 {
5502 TranslateMessage(&msg);
5503 DispatchMessage(&msg);
5504 }
5505 ok_sequence(WmImeKeydownMsgSeq_1, "WM_IME_KEYDOWN 1", FALSE);
5506
5507 DestroyWindow(hwnd);
5508 }
5509
5510 /************* painting message test ********************/
5511
5512 void dump_region(HRGN hrgn)
5513 {
5514 DWORD i, size;
5515 RGNDATA *data = NULL;
5516 RECT *rect;
5517
5518 if (!hrgn)
5519 {
5520 printf( "null region\n" );
5521 return;
5522 }
5523 if (!(size = GetRegionData( hrgn, 0, NULL ))) return;
5524 if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return;
5525 GetRegionData( hrgn, size, data );
5526 printf("%d rects:", data->rdh.nCount );
5527 for (i = 0, rect = (RECT *)data->Buffer; i < data->rdh.nCount; i++, rect++)
5528 printf( " (%d,%d)-(%d,%d)", rect->left, rect->top, rect->right, rect->bottom );
5529 printf("\n");
5530 HeapFree( GetProcessHeap(), 0, data );
5531 }
5532
5533 static void check_update_rgn( HWND hwnd, HRGN hrgn )
5534 {
5535 INT ret;
5536 RECT r1, r2;
5537 HRGN tmp = CreateRectRgn( 0, 0, 0, 0 );
5538 HRGN update = CreateRectRgn( 0, 0, 0, 0 );
5539
5540 ret = GetUpdateRgn( hwnd, update, FALSE );
5541 ok( ret != ERROR, "GetUpdateRgn failed\n" );
5542 if (ret == NULLREGION)
5543 {
5544 ok( !hrgn, "Update region shouldn't be empty\n" );
5545 }
5546 else
5547 {
5548 if (CombineRgn( tmp, hrgn, update, RGN_XOR ) != NULLREGION)
5549 {
5550 ok( 0, "Regions are different\n" );
5551 if (winetest_debug > 0)
5552 {
5553 printf( "Update region: " );
5554 dump_region( update );
5555 printf( "Wanted region: " );
5556 dump_region( hrgn );
5557 }
5558 }
5559 }
5560 GetRgnBox( update, &r1 );
5561 GetUpdateRect( hwnd, &r2, FALSE );
5562 ok( r1.left == r2.left && r1.top == r2.top && r1.right == r2.right && r1.bottom == r2.bottom,
5563 "Rectangles are different: %d,%d-%d,%d / %d,%d-%d,%d\n",
5564 r1.left, r1.top, r1.right, r1.bottom, r2.left, r2.top, r2.right, r2.bottom );
5565
5566 DeleteObject( tmp );
5567 DeleteObject( update );
5568 }
5569
5570 static const struct message WmInvalidateRgn[] = {
5571 { WM_NCPAINT, sent },
5572 { WM_GETTEXT, sent|defwinproc|optional },
5573 { 0 }
5574 };
5575
5576 static const struct message WmGetUpdateRect[] = {
5577 { WM_NCPAINT, sent },
5578 { WM_GETTEXT, sent|defwinproc|optional },
5579 { WM_PAINT, sent },
5580 { 0 }
5581 };
5582
5583 static const struct message WmInvalidateFull[] = {
5584 { WM_NCPAINT, sent|wparam, 1 },
5585 { WM_GETTEXT, sent|defwinproc|optional },
5586 { 0 }
5587 };
5588
5589 static const struct message WmInvalidateErase[] = {
5590 { WM_NCPAINT, sent|wparam, 1 },
5591 { WM_GETTEXT, sent|defwinproc|optional },
5592 { WM_ERASEBKGND, sent },
5593 { 0 }
5594 };
5595
5596 static const struct message WmInvalidatePaint[] = {
5597 { WM_PAINT, sent },
5598 { WM_NCPAINT, sent|wparam|beginpaint, 1 },
5599 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
5600 { 0 }
5601 };
5602
5603 static const struct message WmInvalidateErasePaint[] = {
5604 { WM_PAINT, sent },
5605 { WM_NCPAINT, sent|wparam|beginpaint, 1 },
5606 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
5607 { WM_ERASEBKGND, sent|beginpaint },
5608 { 0 }
5609 };
5610
5611 static const struct message WmInvalidateErasePaint2[] = {
5612 { WM_PAINT, sent },
5613 { WM_NCPAINT, sent|beginpaint },
5614 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
5615 { WM_ERASEBKGND, sent|beginpaint|optional },
5616 { 0 }
5617 };
5618
5619 static const struct message WmErase[] = {
5620 { WM_ERASEBKGND, sent },
5621 { 0 }
5622 };
5623
5624 static const struct message WmPaint[] = {
5625 { WM_PAINT, sent },
5626 { 0 }
5627 };
5628
5629 static const struct message WmParentOnlyPaint[] = {
5630 { WM_PAINT, sent|parent },
5631 { 0 }
5632 };
5633
5634 static const struct message WmInvalidateParent[] = {
5635 { WM_NCPAINT, sent|parent },
5636 { WM_GETTEXT, sent|defwinproc|parent|optional },
5637 { WM_ERASEBKGND, sent|parent },
5638 { 0 }
5639 };
5640
5641 static const struct message WmInvalidateParentChild[] = {
5642 { WM_NCPAINT, sent|parent },
5643 { WM_GETTEXT, sent|defwinproc|parent|optional },
5644 { WM_ERASEBKGND, sent|parent },
5645 { WM_NCPAINT, sent },
5646 { WM_GETTEXT, sent|defwinproc|optional },
5647 { WM_ERASEBKGND, sent },
5648 { 0 }
5649 };
5650
5651 static const struct message WmInvalidateParentChild2[] = {
5652 { WM_ERASEBKGND, sent|parent },
5653 { WM_NCPAINT, sent },
5654 { WM_GETTEXT, sent|defwinproc|optional },
5655 { WM_ERASEBKGND, sent },
5656 { 0 }
5657 };
5658
5659 static const struct message WmParentPaint[] = {
5660 { WM_PAINT, sent|parent },
5661 { WM_PAINT, sent },
5662 { 0 }
5663 };
5664
5665 static const struct message WmParentPaintNc[] = {
5666 { WM_PAINT, sent|parent },
5667 { WM_PAINT, sent },
5668 { WM_NCPAINT, sent|beginpaint },
5669 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
5670 { WM_ERASEBKGND, sent|beginpaint|optional },
5671 { 0 }
5672 };
5673
5674 static const struct message WmChildPaintNc[] = {
5675 { WM_PAINT, sent },
5676 { WM_NCPAINT, sent|beginpaint },
5677 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
5678 { WM_ERASEBKGND, sent|beginpaint },
5679 { 0 }
5680 };
5681
5682 static const struct message WmParentErasePaint[] = {
5683 { WM_PAINT, sent|parent },
5684 { WM_NCPAINT, sent|parent|beginpaint },
5685 { WM_GETTEXT, sent|parent|beginpaint|defwinproc|optional },
5686 { WM_ERASEBKGND, sent|parent|beginpaint|optional },
5687 { WM_PAINT, sent },
5688 { WM_NCPAINT, sent|beginpaint },
5689 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
5690 { WM_ERASEBKGND, sent|beginpaint|optional },
5691 { 0 }
5692 };
5693
5694 static const struct message WmParentOnlyNcPaint[] = {
5695 { WM_PAINT, sent|parent },
5696 { WM_NCPAINT, sent|parent|beginpaint },
5697 { WM_GETTEXT, sent|parent|beginpaint|defwinproc|optional },
5698 { 0 }
5699 };
5700
5701 static const struct message WmSetParentStyle[] = {
5702 { WM_STYLECHANGING, sent|parent },
5703 { WM_STYLECHANGED, sent|parent },
5704 { 0 }
5705 };
5706
5707 static void test_paint_messages(void)
5708 {
5709 BOOL ret;
5710 RECT rect;
5711 POINT pt;
5712 MSG msg;
5713 HWND hparent, hchild;
5714 HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
5715 HRGN hrgn2 = CreateRectRgn( 0, 0, 0, 0 );
5716 HWND hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
5717 100, 100, 200, 200, 0, 0, 0, NULL);
5718 ok (hwnd != 0, "Failed to create overlapped window\n");
5719
5720 ShowWindow( hwnd, SW_SHOW );
5721 UpdateWindow( hwnd );
5722 flush_events();
5723 flush_sequence();
5724
5725 check_update_rgn( hwnd, 0 );
5726 SetRectRgn( hrgn, 10, 10, 20, 20 );
5727 ret = RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
5728 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
5729 check_update_rgn( hwnd, hrgn );
5730 SetRectRgn( hrgn2, 20, 20, 30, 30 );
5731 ret = RedrawWindow( hwnd, NULL, hrgn2, RDW_INVALIDATE );
5732 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
5733 CombineRgn( hrgn, hrgn, hrgn2, RGN_OR );
5734 check_update_rgn( hwnd, hrgn );
5735 /* validate everything */
5736 ret = RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
5737 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
5738 check_update_rgn( hwnd, 0 );
5739
5740 /* test empty region */
5741 SetRectRgn( hrgn, 10, 10, 10, 15 );
5742 ret = RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
5743 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
5744 check_update_rgn( hwnd, 0 );
5745 /* test empty rect */
5746 SetRect( &rect, 10, 10, 10, 15 );
5747 ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
5748 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
5749 check_update_rgn( hwnd, 0 );
5750
5751 /* flush pending messages */
5752 flush_events();
5753 flush_sequence();
5754
5755 GetClientRect( hwnd, &rect );
5756 SetRectRgn( hrgn, 0, 0, rect.right - rect.left, rect.bottom - rect.top );
5757 /* MSDN: if hwnd parameter is NULL, InvalidateRect invalidates and redraws
5758 * all windows and sends WM_ERASEBKGND and WM_NCPAINT.
5759 */
5760 trace("testing InvalidateRect(0, NULL, FALSE)\n");
5761 SetRectEmpty( &rect );
5762 ok(InvalidateRect(0, &rect, FALSE), "InvalidateRect(0, &rc, FALSE) should fail\n");
5763 check_update_rgn( hwnd, hrgn );
5764 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
5765 flush_events();
5766 ok_sequence( WmPaint, "Paint", FALSE );
5767 RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
5768 check_update_rgn( hwnd, 0 );
5769
5770 /* MSDN: if hwnd parameter is NULL, ValidateRect invalidates and redraws
5771 * all windows and sends WM_ERASEBKGND and WM_NCPAINT.
5772 */
5773 trace("testing ValidateRect(0, NULL)\n");
5774 SetRectEmpty( &rect );
5775 if (ValidateRect(0, &rect)) /* not supported on Win9x */
5776 {
5777 check_update_rgn( hwnd, hrgn );
5778 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
5779 flush_events();
5780 ok_sequence( WmPaint, "Paint", FALSE );
5781 RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
5782 check_update_rgn( hwnd, 0 );
5783 }
5784
5785 trace("testing InvalidateRgn(0, NULL, FALSE)\n");
5786 SetLastError(0xdeadbeef);
5787 ok(!InvalidateRgn(0, NULL, FALSE), "InvalidateRgn(0, NULL, FALSE) should fail\n");
5788 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || GetLastError() == 0xdeadbeef,
5789 "wrong error code %d\n", GetLastError());
5790 check_update_rgn( hwnd, 0 );
5791 flush_events();
5792 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
5793
5794 trace("testing ValidateRgn(0, NULL)\n");
5795 SetLastError(0xdeadbeef);
5796 ok(!ValidateRgn(0, NULL), "ValidateRgn(0, NULL) should fail\n");
5797 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE ||
5798 broken( GetLastError() == 0xdeadbeef ) /* win9x */,
5799 "wrong error code %d\n", GetLastError());
5800 check_update_rgn( hwnd, 0 );
5801 flush_events();
5802 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
5803
5804 /* now with frame */
5805 SetRectRgn( hrgn, -5, -5, 20, 20 );
5806
5807 /* flush pending messages */
5808 flush_events();
5809 flush_sequence();
5810 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
5811 ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
5812
5813 SetRectRgn( hrgn, 0, 0, 20, 20 ); /* GetUpdateRgn clips to client area */
5814 check_update_rgn( hwnd, hrgn );
5815
5816 flush_sequence();
5817 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
5818 ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
5819
5820 flush_sequence();
5821 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
5822 ok_sequence( WmInvalidateFull, "InvalidateFull", FALSE );
5823
5824 GetClientRect( hwnd, &rect );
5825 SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
5826 check_update_rgn( hwnd, hrgn );
5827
5828 flush_sequence();
5829 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW );
5830 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
5831
5832 flush_sequence();
5833 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW | RDW_UPDATENOW );
5834 ok_sequence( WmInvalidatePaint, "InvalidatePaint", FALSE );
5835 check_update_rgn( hwnd, 0 );
5836
5837 flush_sequence();
5838 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_UPDATENOW );
5839 ok_sequence( WmInvalidateErasePaint, "InvalidateErasePaint", FALSE );
5840 check_update_rgn( hwnd, 0 );
5841
5842 flush_sequence();
5843 SetRectRgn( hrgn, 0, 0, 100, 100 );
5844 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
5845 SetRectRgn( hrgn, 0, 0, 50, 100 );
5846 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE );
5847 SetRectRgn( hrgn, 50, 0, 100, 100 );
5848 check_update_rgn( hwnd, hrgn );
5849 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
5850 ok_sequence( WmEmptySeq, "EmptySeq", FALSE ); /* must not generate messages, everything is valid */
5851 check_update_rgn( hwnd, 0 );
5852
5853 flush_sequence();
5854 SetRectRgn( hrgn, 0, 0, 100, 100 );
5855 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
5856 SetRectRgn( hrgn, 0, 0, 100, 50 );
5857 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
5858 ok_sequence( WmErase, "Erase", FALSE );
5859 SetRectRgn( hrgn, 0, 50, 100, 100 );
5860 check_update_rgn( hwnd, hrgn );
5861
5862 flush_sequence();
5863 SetRectRgn( hrgn, 0, 0, 100, 100 );
5864 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
5865 SetRectRgn( hrgn, 0, 0, 50, 50 );
5866 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOERASE | RDW_UPDATENOW );
5867 ok_sequence( WmPaint, "Paint", FALSE );
5868
5869 flush_sequence();
5870 SetRectRgn( hrgn, -4, -4, -2, -2 );
5871 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
5872 SetRectRgn( hrgn, -200, -200, -198, -198 );
5873 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME | RDW_ERASENOW );
5874 ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
5875
5876 flush_sequence();
5877 SetRectRgn( hrgn, -4, -4, -2, -2 );
5878 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
5879 SetRectRgn( hrgn, -4, -4, -3, -3 );
5880 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME );
5881 SetRectRgn( hrgn, 0, 0, 1, 1 );
5882 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_UPDATENOW );
5883 ok_sequence( WmPaint, "Paint", FALSE );
5884
5885 flush_sequence();
5886 SetRectRgn( hrgn, -4, -4, -1, -1 );
5887 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
5888 RedrawWindow( hwnd, NULL, 0, RDW_ERASENOW );
5889 /* make sure no WM_PAINT was generated */
5890 flush_events();
5891 ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
5892
5893 flush_sequence();
5894 SetRectRgn( hrgn, -4, -4, -1, -1 );
5895 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
5896 while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
5897 {
5898 if (msg.hwnd == hwnd && msg.message == WM_PAINT)
5899 {
5900 /* GetUpdateRgn must return empty region since only nonclient area is invalidated */
5901 INT ret = GetUpdateRgn( hwnd, hrgn, FALSE );
5902 ok( ret == NULLREGION, "Invalid GetUpdateRgn result %d\n", ret );
5903 ret = GetUpdateRect( hwnd, &rect, FALSE );
5904 ok( ret, "Invalid GetUpdateRect result %d\n", ret );
5905 /* this will send WM_NCPAINT and validate the non client area */
5906 ret = GetUpdateRect( hwnd, &rect, TRUE );
5907 ok( !ret, "Invalid GetUpdateRect result %d\n", ret );
5908 }
5909 DispatchMessage( &msg );
5910 }
5911 ok_sequence( WmGetUpdateRect, "GetUpdateRect", FALSE );
5912
5913 DestroyWindow( hwnd );
5914
5915 /* now test with a child window */
5916
5917 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW,
5918 100, 100, 200, 200, 0, 0, 0, NULL);
5919 ok (hparent != 0, "Failed to create parent window\n");
5920
5921 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE | WS_BORDER,
5922 10, 10, 100, 100, hparent, 0, 0, NULL);
5923 ok (hchild != 0, "Failed to create child window\n");
5924
5925 ShowWindow( hparent, SW_SHOW );
5926 UpdateWindow( hparent );
5927 UpdateWindow( hchild );
5928 flush_events();
5929 flush_sequence();
5930 log_all_parent_messages++;
5931
5932 SetRect( &rect, 0, 0, 50, 50 );
5933 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5934 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW | RDW_ALLCHILDREN );
5935 ok_sequence( WmInvalidateParentChild, "InvalidateParentChild", FALSE );
5936
5937 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5938 pt.x = pt.y = 0;
5939 MapWindowPoints( hchild, hparent, &pt, 1 );
5940 SetRectRgn( hrgn, 0, 0, 50 - pt.x, 50 - pt.y );
5941 check_update_rgn( hchild, hrgn );
5942 SetRectRgn( hrgn, 0, 0, 50, 50 );
5943 check_update_rgn( hparent, hrgn );
5944 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
5945 ok_sequence( WmInvalidateParent, "InvalidateParent", FALSE );
5946 RedrawWindow( hchild, NULL, 0, RDW_ERASENOW );
5947 ok_sequence( WmEmptySeq, "EraseNow child", FALSE );
5948
5949 flush_events();
5950 ok_sequence( WmParentPaintNc, "WmParentPaintNc", FALSE );
5951
5952 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
5953 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
5954 ok_sequence( WmInvalidateParent, "InvalidateParent2", FALSE );
5955 RedrawWindow( hchild, NULL, 0, RDW_ERASENOW );
5956 ok_sequence( WmEmptySeq, "EraseNow child", FALSE );
5957
5958 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
5959 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW | RDW_ALLCHILDREN );
5960 ok_sequence( WmInvalidateParentChild2, "InvalidateParentChild2", FALSE );
5961
5962 SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) | WS_CLIPCHILDREN );
5963 flush_sequence();
5964 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
5965 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
5966 ok_sequence( WmInvalidateParentChild, "InvalidateParentChild3", FALSE );
5967
5968 /* flush all paint messages */
5969 flush_events();
5970 flush_sequence();
5971
5972 /* RDW_UPDATENOW on child with WS_CLIPCHILDREN doesn't change corresponding parent area */
5973 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
5974 SetRectRgn( hrgn, 0, 0, 50, 50 );
5975 check_update_rgn( hparent, hrgn );
5976 RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
5977 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
5978 SetRectRgn( hrgn, 0, 0, 50, 50 );
5979 check_update_rgn( hparent, hrgn );
5980
5981 /* flush all paint messages */
5982 flush_events();
5983 SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
5984 flush_sequence();
5985
5986 /* RDW_UPDATENOW on child without WS_CLIPCHILDREN will validate corresponding parent area */
5987 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5988 SetRectRgn( hrgn, 0, 0, 50, 50 );
5989 check_update_rgn( hparent, hrgn );
5990 RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
5991 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
5992 SetRectRgn( hrgn2, 10, 10, 50, 50 );
5993 CombineRgn( hrgn, hrgn, hrgn2, RGN_DIFF );
5994 check_update_rgn( hparent, hrgn );
5995 /* flush all paint messages */
5996 flush_events();
5997 flush_sequence();
5998
5999 /* same as above but parent gets completely validated */
6000 SetRect( &rect, 20, 20, 30, 30 );
6001 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6002 SetRectRgn( hrgn, 20, 20, 30, 30 );
6003 check_update_rgn( hparent, hrgn );
6004 RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
6005 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
6006 check_update_rgn( hparent, 0 ); /* no update region */
6007 flush_events();
6008 ok_sequence( WmEmptySeq, "WmEmpty", FALSE ); /* and no paint messages */
6009
6010 /* make sure RDW_VALIDATE on child doesn't have the same effect */
6011 flush_sequence();
6012 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6013 SetRectRgn( hrgn, 20, 20, 30, 30 );
6014 check_update_rgn( hparent, hrgn );
6015 RedrawWindow( hchild, NULL, 0, RDW_VALIDATE | RDW_NOERASE );
6016 SetRectRgn( hrgn, 20, 20, 30, 30 );
6017 check_update_rgn( hparent, hrgn );
6018
6019 /* same as above but normal WM_PAINT doesn't validate parent */
6020 flush_sequence();
6021 SetRect( &rect, 20, 20, 30, 30 );
6022 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6023 SetRectRgn( hrgn, 20, 20, 30, 30 );
6024 check_update_rgn( hparent, hrgn );
6025 /* no WM_PAINT in child while parent still pending */
6026 while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
6027 ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
6028 while (PeekMessage( &msg, hparent, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
6029 ok_sequence( WmParentErasePaint, "WmParentErasePaint", FALSE );
6030
6031 flush_sequence();
6032 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6033 /* no WM_PAINT in child while parent still pending */
6034 while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
6035 ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
6036 RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_NOERASE | RDW_NOCHILDREN );
6037 /* now that parent is valid child should get WM_PAINT */
6038 while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
6039 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
6040 while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
6041 ok_sequence( WmEmptySeq, "No other message", FALSE );
6042
6043 /* same thing with WS_CLIPCHILDREN in parent */
6044 flush_sequence();
6045 SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) | WS_CLIPCHILDREN );
6046 ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
6047 /* changing style invalidates non client area, but we need to invalidate something else to see it */
6048 RedrawWindow( hparent, &rect, 0, RDW_UPDATENOW );
6049 ok_sequence( WmEmptySeq, "No message", FALSE );
6050 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_UPDATENOW );
6051 ok_sequence( WmParentOnlyNcPaint, "WmParentOnlyNcPaint", FALSE );
6052
6053 flush_sequence();
6054 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN );
6055 SetRectRgn( hrgn, 20, 20, 30, 30 );
6056 check_update_rgn( hparent, hrgn );
6057 /* no WM_PAINT in child while parent still pending */
6058 while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
6059 ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
6060 /* WM_PAINT in parent first */
6061 while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
6062 ok_sequence( WmParentPaintNc, "WmParentPaintNc2", FALSE );
6063
6064 /* no RDW_ERASE in parent still causes RDW_ERASE and RDW_FRAME in child */
6065 flush_sequence();
6066 SetRect( &rect, 0, 0, 30, 30 );
6067 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ALLCHILDREN );
6068 SetRectRgn( hrgn, 0, 0, 30, 30 );
6069 check_update_rgn( hparent, hrgn );
6070 flush_events();
6071 ok_sequence( WmParentPaintNc, "WmParentPaintNc3", FALSE );
6072
6073 /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
6074 flush_sequence();
6075 SetRect( &rect, -10, 0, 30, 30 );
6076 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE );
6077 SetRect( &rect, 0, 0, 20, 20 );
6078 RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_ALLCHILDREN );
6079 RedrawWindow( hparent, NULL, 0, RDW_UPDATENOW );
6080 ok_sequence( WmChildPaintNc, "WmChildPaintNc", FALSE );
6081
6082 /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
6083 flush_sequence();
6084 SetRect( &rect, -10, 0, 30, 30 );
6085 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE );
6086 SetRect( &rect, 0, 0, 100, 100 );
6087 RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_ALLCHILDREN );
6088 RedrawWindow( hparent, NULL, 0, RDW_UPDATENOW );
6089 ok_sequence( WmEmptySeq, "WmChildPaintNc2", FALSE );
6090 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
6091 ok_sequence( WmEmptySeq, "WmChildPaintNc3", FALSE );
6092
6093 /* test RDW_INTERNALPAINT behavior */
6094
6095 flush_sequence();
6096 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_NOCHILDREN );
6097 flush_events();
6098 ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
6099
6100 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_ALLCHILDREN );
6101 flush_events();
6102 ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
6103
6104 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
6105 flush_events();
6106 ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
6107
6108 assert( GetWindowLong(hparent, GWL_STYLE) & WS_CLIPCHILDREN );
6109 UpdateWindow( hparent );
6110 flush_events();
6111 flush_sequence();
6112 trace("testing SWP_FRAMECHANGED on parent with WS_CLIPCHILDREN\n");
6113 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6114 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
6115 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
6116 flush_events();
6117 ok_sequence(WmSWP_FrameChanged_clip, "SetWindowPos:FrameChanged_clip", FALSE );
6118
6119 UpdateWindow( hparent );
6120 flush_events();
6121 flush_sequence();
6122 trace("testing SWP_FRAMECHANGED|SWP_DEFERERASE on parent with WS_CLIPCHILDREN\n");
6123 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6124 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_DEFERERASE |
6125 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
6126 flush_events();
6127 ok_sequence(WmSWP_FrameChangedDeferErase, "SetWindowPos:FrameChangedDeferErase", FALSE );
6128
6129 SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
6130 ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
6131 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
6132 flush_events();
6133 ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
6134
6135 assert( !(GetWindowLong(hparent, GWL_STYLE) & WS_CLIPCHILDREN) );
6136 UpdateWindow( hparent );
6137 flush_events();
6138 flush_sequence();
6139 trace("testing SWP_FRAMECHANGED on parent without WS_CLIPCHILDREN\n");
6140 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6141 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
6142 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
6143 flush_events();
6144 ok_sequence(WmSWP_FrameChanged_noclip, "SetWindowPos:FrameChanged_noclip", FALSE );
6145
6146 UpdateWindow( hparent );
6147 flush_events();
6148 flush_sequence();
6149 trace("testing SWP_FRAMECHANGED|SWP_DEFERERASE on parent without WS_CLIPCHILDREN\n");
6150 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6151 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_DEFERERASE |
6152 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
6153 flush_events();
6154 ok_sequence(WmSWP_FrameChangedDeferErase, "SetWindowPos:FrameChangedDeferErase", FALSE );
6155
6156 ok(GetWindowLong( hparent, GWL_STYLE ) & WS_VISIBLE, "parent should be visible\n");
6157 ok(GetWindowLong( hchild, GWL_STYLE ) & WS_VISIBLE, "child should be visible\n");
6158
6159 UpdateWindow( hparent );
6160 flush_events();
6161 flush_sequence();
6162 trace("testing SetWindowPos(-10000, -10000) on child\n");
6163 SetWindowPos( hchild, 0, -10000, -10000, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER );
6164 check_update_rgn( hchild, 0 );
6165 flush_events();
6166
6167 #if 0 /* this one doesn't pass under Wine yet */
6168 UpdateWindow( hparent );
6169 flush_events();
6170 flush_sequence();
6171 trace("testing ShowWindow(SW_MINIMIZE) on child\n");
6172 ShowWindow( hchild, SW_MINIMIZE );
6173 check_update_rgn( hchild, 0 );
6174 flush_events();
6175 #endif
6176
6177 UpdateWindow( hparent );
6178 flush_events();
6179 flush_sequence();
6180 trace("testing SetWindowPos(-10000, -10000) on parent\n");
6181 SetWindowPos( hparent, 0, -10000, -10000, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER );
6182 check_update_rgn( hparent, 0 );
6183 flush_events();
6184
6185 log_all_parent_messages--;
6186 DestroyWindow( hparent );
6187 ok(!IsWindow(hchild), "child must be destroyed with its parent\n");
6188
6189 /* tests for moving windows off-screen (needs simple WS_POPUP windows) */
6190
6191 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_POPUP | WS_VISIBLE,
6192 100, 100, 200, 200, 0, 0, 0, NULL);
6193 ok (hparent != 0, "Failed to create parent window\n");
6194
6195 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
6196 10, 10, 100, 100, hparent, 0, 0, NULL);
6197 ok (hchild != 0, "Failed to create child window\n");
6198
6199 ShowWindow( hparent, SW_SHOW );
6200 UpdateWindow( hparent );
6201 UpdateWindow( hchild );
6202 flush_events();
6203 flush_sequence();
6204
6205 /* moving child outside of parent boundaries changes update region */
6206 SetRect( &rect, 0, 0, 40, 40 );
6207 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
6208 SetRectRgn( hrgn, 0, 0, 40, 40 );
6209 check_update_rgn( hchild, hrgn );
6210 MoveWindow( hchild, -10, 10, 100, 100, FALSE );
6211 SetRectRgn( hrgn, 10, 0, 40, 40 );
6212 check_update_rgn( hchild, hrgn );
6213 MoveWindow( hchild, -10, -10, 100, 100, FALSE );
6214 SetRectRgn( hrgn, 10, 10, 40, 40 );
6215 check_update_rgn( hchild, hrgn );
6216
6217 /* moving parent off-screen does too */
6218 SetRect( &rect, 0, 0, 100, 100 );
6219 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_NOCHILDREN );
6220 SetRectRgn( hrgn, 0, 0, 100, 100 );
6221 check_update_rgn( hparent, hrgn );
6222 SetRectRgn( hrgn, 10, 10, 40, 40 );
6223 check_update_rgn( hchild, hrgn );
6224 MoveWindow( hparent, -20, -20, 200, 200, FALSE );
6225 SetRectRgn( hrgn, 20, 20, 100, 100 );
6226 check_update_rgn( hparent, hrgn );
6227 SetRectRgn( hrgn, 30, 30, 40, 40 );
6228 check_update_rgn( hchild, hrgn );
6229
6230 /* invalidated region is cropped by the parent rects */
6231 SetRect( &rect, 0, 0, 50, 50 );
6232 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
6233 SetRectRgn( hrgn, 30, 30, 50, 50 );
6234 check_update_rgn( hchild, hrgn );
6235
6236 DestroyWindow( hparent );
6237 ok(!IsWindow(hchild), "child must be destroyed with its parent\n");
6238 flush_sequence();
6239
6240 DeleteObject( hrgn );
6241 DeleteObject( hrgn2 );
6242 }
6243
6244 struct wnd_event
6245 {
6246 HWND hwnd;
6247 HANDLE event;
6248 };
6249
6250 static DWORD WINAPI thread_proc(void *param)
6251 {
6252 MSG msg;
6253 struct wnd_event *wnd_event = param;
6254
6255 wnd_event->hwnd = CreateWindowExA(0, "TestWindowClass", "window caption text", WS_OVERLAPPEDWINDOW,
6256 100, 100, 200, 200, 0, 0, 0, NULL);
6257 ok(wnd_event->hwnd != 0, "Failed to create overlapped window\n");
6258
6259 SetEvent(wnd_event->event);
6260
6261 while (GetMessage(&msg, 0, 0, 0))
6262 {
6263 TranslateMessage(&msg);
6264 DispatchMessage(&msg);
6265 }
6266
6267 ok(IsWindow(wnd_event->hwnd), "window should still exist\n");
6268
6269 return 0;
6270 }
6271
6272 static void test_interthread_messages(void)
6273 {
6274 HANDLE hThread;
6275 DWORD tid;
6276 WNDPROC proc;
6277 MSG msg;
6278 char buf[256];
6279 int len, expected_len;
6280 struct wnd_event wnd_event;
6281 BOOL ret;
6282
6283 wnd_event.event = CreateEventW(NULL, 0, 0, NULL);
6284 if (!wnd_event.event)
6285 {
6286 trace("skipping interthread message test under win9x\n");
6287 return;
6288 }
6289
6290 hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
6291 ok(hThread != NULL, "CreateThread failed, error %d\n", GetLastError());
6292
6293 ok(WaitForSingleObject(wnd_event.event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
6294
6295 CloseHandle(wnd_event.event);
6296
6297 SetLastError(0xdeadbeef);
6298 ok(!DestroyWindow(wnd_event.hwnd), "DestroyWindow succeded\n");
6299 ok(GetLastError() == ERROR_ACCESS_DENIED || GetLastError() == 0xdeadbeef,
6300 "wrong error code %d\n", GetLastError());
6301
6302 proc = (WNDPROC)GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
6303 ok(proc != NULL, "GetWindowLongPtrA(GWLP_WNDPROC) error %d\n", GetLastError());
6304
6305 expected_len = lstrlenA("window caption text");
6306 memset(buf, 0, sizeof(buf));
6307 SetLastError(0xdeadbeef);
6308 len = CallWindowProcA(proc, wnd_event.hwnd, WM_GETTEXT, sizeof(buf), (LPARAM)buf);
6309 ok(len == expected_len, "CallWindowProcA(WM_GETTEXT) error %d, len %d, expected len %d\n", GetLastError(), len, expected_len);
6310 ok(!lstrcmpA(buf, "window caption text"), "window text mismatch\n");
6311
6312 msg.hwnd = wnd_event.hwnd;
6313 msg.message = WM_GETTEXT;
6314 msg.wParam = sizeof(buf);
6315 msg.lParam = (LPARAM)buf;
6316 memset(buf, 0, sizeof(buf));
6317 SetLastError(0xdeadbeef);
6318 len = DispatchMessageA(&msg);
6319 ok((!len && GetLastError() == ERROR_MESSAGE_SYNC_ONLY) || broken(len), /* nt4 */
6320 "DispatchMessageA(WM_GETTEXT) succeded on another thread window: ret %d, error %d\n", len, GetLastError());
6321
6322 /* the following test causes an exception in user.exe under win9x */
6323 msg.hwnd = wnd_event.hwnd;
6324 msg.message = WM_TIMER;
6325 msg.wParam = 0;
6326 msg.lParam = GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
6327 SetLastError(0xdeadbeef);
6328 len = DispatchMessageA(&msg);
6329 ok(!len && GetLastError() == 0xdeadbeef,
6330 "DispatchMessageA(WM_TIMER) failed on another thread window: ret %d, error %d\n", len, GetLastError());
6331
6332 ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
6333 ok( ret, "PostMessageA(WM_QUIT) error %d\n", GetLastError());
6334
6335 ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
6336 CloseHandle(hThread);
6337
6338 ok(!IsWindow(wnd_event.hwnd), "window should be destroyed on thread exit\n");
6339 }
6340
6341
6342 static const struct message WmVkN[] = {
6343 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
6344 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
6345 { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
6346 { WM_CHAR, wparam|lparam, 'n', 1 },
6347 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1002,1), 0 },
6348 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
6349 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
6350 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
6351 { 0 }
6352 };
6353 static const struct message WmShiftVkN[] = {
6354 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
6355 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
6356 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
6357 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
6358 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
6359 { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
6360 { WM_CHAR, wparam|lparam, 'N', 1 },
6361 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1001,1), 0 },
6362 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
6363 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
6364 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
6365 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xc0000001 }, /* XP */
6366 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
6367 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
6368 { 0 }
6369 };
6370 static const struct message WmCtrlVkN[] = {
6371 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
6372 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
6373 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
6374 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
6375 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
6376 { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
6377 { WM_CHAR, wparam|lparam, 0x000e, 1 },
6378 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
6379 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
6380 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
6381 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
6382 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
6383 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
6384 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
6385 { 0 }
6386 };
6387 static const struct message WmCtrlVkN_2[] = {
6388 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
6389 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
6390 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
6391 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
6392 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
6393 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
6394 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
6395 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
6396 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
6397 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
6398 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
6399 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
6400 { 0 }
6401 };
6402 static const struct message WmAltVkN[] = {
6403 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
6404 { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
6405 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
6406 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
6407 { WM_SYSKEYDOWN, wparam|lparam, 'N', 0x20000001 },
6408 { WM_SYSKEYDOWN, sent|wparam|lparam, 'N', 0x20000001 },
6409 { WM_SYSCHAR, wparam|lparam, 'n', 0x20000001 },
6410 { WM_SYSCHAR, sent|wparam|lparam, 'n', 0x20000001 },
6411 { WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 'n' },
6412 { HCBT_SYSCOMMAND, hook },
6413 { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
6414 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
6415 { 0x00AE, sent|defwinproc|optional }, /* XP */
6416 { WM_GETTEXT, sent|defwinproc|optional }, /* XP */
6417 { WM_INITMENU, sent|defwinproc },
6418 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
6419 { WM_MENUCHAR, sent|defwinproc|wparam, MAKEWPARAM('n',MF_SYSMENU) },
6420 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
6421 { WM_CAPTURECHANGED, sent|defwinproc },
6422 { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,0xffff) },
6423 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
6424 { WM_EXITMENULOOP, sent|defwinproc },
6425 { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) }, /* Win95 bug */
6426 { WM_EXITMENULOOP, sent|defwinproc|optional }, /* Win95 bug */
6427 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
6428 { WM_SYSKEYUP, wparam|lparam, 'N', 0xe0000001 },
6429 { WM_SYSKEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
6430 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
6431 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
6432 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
6433 { 0 }
6434 };
6435 static const struct message WmAltVkN_2[] = {
6436 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
6437 { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
6438 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
6439 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
6440 { WM_SYSKEYDOWN, wparam|lparam, 'N', 0x20000001 },
6441 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1003,1), 0 },
6442 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
6443 { WM_SYSKEYUP, wparam|lparam, 'N', 0xe0000001 },
6444 { WM_SYSKEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
6445 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
6446 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
6447 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
6448 { 0 }
6449 };
6450 static const struct message WmCtrlAltVkN[] = {
6451 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
6452 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
6453 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
6454 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
6455 { WM_KEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
6456 { WM_KEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
6457 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
6458 { WM_KEYDOWN, wparam|lparam, 'N', 0x20000001 },
6459 { WM_KEYDOWN, sent|wparam|lparam, 'N', 0x20000001 },
6460 { WM_CHAR, optional },
6461 { WM_CHAR, sent|optional },
6462 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
6463 { WM_KEYUP, wparam|lparam, 'N', 0xe0000001 },
6464 { WM_KEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
6465 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
6466 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
6467 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
6468 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
6469 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
6470 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
6471 { 0 }
6472 };
6473 static const struct message WmCtrlShiftVkN[] = {
6474 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
6475 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
6476 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
6477 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
6478 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
6479 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
6480 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
6481 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
6482 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1004,1), 0 },
6483 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
6484 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
6485 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
6486 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xc0000001 }, /* XP */
6487 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
6488 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
6489 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
6490 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
6491 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
6492 { 0 }
6493 };
6494 static const struct message WmCtrlAltShiftVkN[] = {
6495 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
6496 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
6497 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
6498 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
6499 { WM_KEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
6500 { WM_KEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
6501 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0x20000001 }, /* XP */
6502 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0x20000001 },
6503 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 0x20000001 },
6504 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
6505 { WM_KEYDOWN, wparam|lparam, 'N', 0x20000001 },
6506 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1005,1), 0 },
6507 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
6508 { WM_KEYUP, wparam|lparam, 'N', 0xe0000001 },
6509 { WM_KEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
6510 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xe0000001 }, /* XP */
6511 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xe0000001 },
6512 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xe0000001 },
6513 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
6514 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
6515 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
6516 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
6517 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
6518 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
6519 { 0 }
6520 };
6521 static const struct message WmAltPressRelease[] = {
6522 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
6523 { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
6524 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
6525 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
6526 { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
6527 { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
6528 { WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 0 },
6529 { HCBT_SYSCOMMAND, hook },
6530 { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
6531 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
6532 { WM_INITMENU, sent|defwinproc },
6533 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
6534 { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,MF_SYSMENU|MF_POPUP|MF_HILITE) },
6535 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
6536
6537 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x30000001 }, /* XP */
6538
6539 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
6540 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0, },
6541 { WM_CAPTURECHANGED, sent|defwinproc },
6542 { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) },
6543 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
6544 { WM_EXITMENULOOP, sent|defwinproc },
6545 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
6546 { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
6547 { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
6548 { 0 }
6549 };
6550 static const struct message WmShiftMouseButton[] = {
6551 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
6552 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
6553 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
6554 { WM_MOUSEMOVE, wparam|optional, 0, 0 },
6555 { WM_MOUSEMOVE, sent|wparam|optional, 0, 0 },
6556 { WM_LBUTTONDOWN, wparam, MK_LBUTTON|MK_SHIFT, 0 },
6557 { WM_LBUTTONDOWN, sent|wparam, MK_LBUTTON|MK_SHIFT, 0 },
6558 { WM_LBUTTONUP, wparam, MK_SHIFT, 0 },
6559 { WM_LBUTTONUP, sent|wparam, MK_SHIFT, 0 },
6560 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xc0000001 }, /* XP */
6561 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
6562 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
6563 { 0 }
6564 };
6565 static const struct message WmF1Seq[] = {
6566 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F1, 1 }, /* XP */
6567 { WM_KEYDOWN, wparam|lparam, VK_F1, 1 },
6568 { WM_KEYDOWN, sent|wparam|lparam, VK_F1, 0x00000001 },
6569 { WM_KEYF1, wparam|lparam, 0, 0 },
6570 { WM_KEYF1, sent|wparam|lparam, 0, 0 },
6571 { WM_HELP, sent|defwinproc },
6572 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F1, 0xc0000001 }, /* XP */
6573 { WM_KEYUP, wparam|lparam, VK_F1, 0xc0000001 },
6574 { WM_KEYUP, sent|wparam|lparam, VK_F1, 0xc0000001 },
6575 { 0 }
6576 };
6577 static const struct message WmVkAppsSeq[] = {
6578 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_APPS, 1 }, /* XP */
6579 { WM_KEYDOWN, wparam|lparam, VK_APPS, 1 },
6580 { WM_KEYDOWN, sent|wparam|lparam, VK_APPS, 0x00000001 },
6581 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_APPS, 0xc0000001 }, /* XP */
6582 { WM_KEYUP, wparam|lparam, VK_APPS, 0xc0000001 },
6583 { WM_KEYUP, sent|wparam|lparam, VK_APPS, 0xc0000001 },
6584 { WM_CONTEXTMENU, lparam, /*hwnd*/0, (LPARAM)-1 },
6585 { WM_CONTEXTMENU, sent|lparam, /*hwnd*/0, (LPARAM)-1 },
6586 { 0 }
6587 };
6588
6589 static void pump_msg_loop(HWND hwnd, HACCEL hAccel)
6590 {
6591 MSG msg;
6592
6593 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
6594 {
6595 struct recvd_message log_msg;
6596
6597 /* ignore some unwanted messages */
6598 if (msg.message == WM_MOUSEMOVE ||
6599 msg.message == WM_GETICON ||
6600 msg.message == WM_GETOBJECT ||
6601 msg.message == WM_TIMER ||
6602 msg.message == WM_DEVICECHANGE)
6603 continue;
6604
6605 log_msg.hwnd = msg.hwnd;
6606 log_msg.message = msg.message;
6607 log_msg.flags = wparam|lparam;
6608 log_msg.wParam = msg.wParam;
6609 log_msg.lParam = msg.lParam;
6610 log_msg.descr = "accel";
6611 add_message(&log_msg);
6612
6613 if (!hAccel || !TranslateAccelerator(hwnd, hAccel, &msg))
6614 {
6615 TranslateMessage(&msg);
6616 DispatchMessage(&msg);
6617 }
6618 }
6619 }
6620
6621 static void test_accelerators(void)
6622 {
6623 RECT rc;
6624 POINT pt;
6625 SHORT state;
6626 HACCEL hAccel;
6627 HWND hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
6628 100, 100, 200, 200, 0, 0, 0, NULL);
6629 BOOL ret;
6630
6631 assert(hwnd != 0);
6632 UpdateWindow(hwnd);
6633 flush_events();
6634 flush_sequence();
6635
6636 SetFocus(hwnd);
6637 ok(GetFocus() == hwnd, "wrong focus window %p\n", GetFocus());
6638
6639 state = GetKeyState(VK_SHIFT);
6640 ok(!(state & 0x8000), "wrong Shift state %04x\n", state);
6641 state = GetKeyState(VK_CAPITAL);
6642 ok(state == 0, "wrong CapsLock state %04x\n", state);
6643
6644 hAccel = LoadAccelerators(GetModuleHandleA(0), MAKEINTRESOURCE(1));
6645 assert(hAccel != 0);
6646
6647 flush_events();
6648 pump_msg_loop(hwnd, 0);
6649 flush_sequence();
6650
6651 trace("testing VK_N press/release\n");
6652 flush_sequence();
6653 keybd_event('N', 0, 0, 0);
6654 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6655 pump_msg_loop(hwnd, hAccel);
6656 ok_sequence(WmVkN, "VK_N press/release", FALSE);
6657
6658 trace("testing Shift+VK_N press/release\n");
6659 flush_sequence();
6660 keybd_event(VK_SHIFT, 0, 0, 0);
6661 keybd_event('N', 0, 0, 0);
6662 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6663 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
6664 pump_msg_loop(hwnd, hAccel);
6665 ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
6666
6667 trace("testing Ctrl+VK_N press/release\n");
6668 flush_sequence();
6669 keybd_event(VK_CONTROL, 0, 0, 0);
6670 keybd_event('N', 0, 0, 0);
6671 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6672 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
6673 pump_msg_loop(hwnd, hAccel);
6674 ok_sequence(WmCtrlVkN, "Ctrl+VK_N press/release", FALSE);
6675
6676 trace("testing Alt+VK_N press/release\n");
6677 flush_sequence();
6678 keybd_event(VK_MENU, 0, 0, 0);
6679 keybd_event('N', 0, 0, 0);
6680 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6681 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
6682 pump_msg_loop(hwnd, hAccel);
6683 ok_sequence(WmAltVkN, "Alt+VK_N press/release", FALSE);
6684
6685 trace("testing Ctrl+Alt+VK_N press/release 1\n");
6686 flush_sequence();
6687 keybd_event(VK_CONTROL, 0, 0, 0);
6688 keybd_event(VK_MENU, 0, 0, 0);
6689 keybd_event('N', 0, 0, 0);
6690 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6691 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
6692 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
6693 pump_msg_loop(hwnd, hAccel);
6694 ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 1", FALSE);
6695
6696 ret = DestroyAcceleratorTable(hAccel);
6697 ok( ret, "DestroyAcceleratorTable error %d\n", GetLastError());
6698
6699 hAccel = LoadAccelerators(GetModuleHandleA(0), MAKEINTRESOURCE(2));
6700 assert(hAccel != 0);
6701
6702 trace("testing VK_N press/release\n");
6703 flush_sequence();
6704 keybd_event('N', 0, 0, 0);
6705 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6706 pump_msg_loop(hwnd, hAccel);
6707 ok_sequence(WmVkN, "VK_N press/release", FALSE);
6708
6709 trace("testing Shift+VK_N press/release\n");
6710 flush_sequence();
6711 keybd_event(VK_SHIFT, 0, 0, 0);
6712 keybd_event('N', 0, 0, 0);
6713 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6714 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
6715 pump_msg_loop(hwnd, hAccel);
6716 ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
6717
6718 trace("testing Ctrl+VK_N press/release 2\n");
6719 flush_sequence();
6720 keybd_event(VK_CONTROL, 0, 0, 0);
6721 keybd_event('N', 0, 0, 0);
6722 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6723 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
6724 pump_msg_loop(hwnd, hAccel);
6725 ok_sequence(WmCtrlVkN_2, "Ctrl+VK_N press/release 2", FALSE);
6726
6727 trace("testing Alt+VK_N press/release 2\n");
6728 flush_sequence();
6729 keybd_event(VK_MENU, 0, 0, 0);
6730 keybd_event('N', 0, 0, 0);
6731 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6732 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
6733 pump_msg_loop(hwnd, hAccel);
6734 ok_sequence(WmAltVkN_2, "Alt+VK_N press/release 2", FALSE);
6735
6736 trace("testing Ctrl+Alt+VK_N press/release 2\n");
6737 flush_sequence();
6738 keybd_event(VK_CONTROL, 0, 0, 0);
6739 keybd_event(VK_MENU, 0, 0, 0);
6740 keybd_event('N', 0, 0, 0);
6741 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6742 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
6743 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
6744 pump_msg_loop(hwnd, hAccel);
6745 ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 2", FALSE);
6746
6747 trace("testing Ctrl+Shift+VK_N press/release\n");
6748 flush_sequence();
6749 keybd_event(VK_CONTROL, 0, 0, 0);
6750 keybd_event(VK_SHIFT, 0, 0, 0);
6751 keybd_event('N', 0, 0, 0);
6752 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6753 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
6754 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
6755 pump_msg_loop(hwnd, hAccel);
6756 ok_sequence(WmCtrlShiftVkN, "Ctrl+Shift+VK_N press/release", FALSE);
6757
6758 trace("testing Ctrl+Alt+Shift+VK_N press/release\n");
6759 flush_sequence();
6760 keybd_event(VK_CONTROL, 0, 0, 0);
6761 keybd_event(VK_MENU, 0, 0, 0);
6762 keybd_event(VK_SHIFT, 0, 0, 0);
6763 keybd_event('N', 0, 0, 0);
6764 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6765 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
6766 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
6767 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
6768 pump_msg_loop(hwnd, hAccel);
6769 ok_sequence(WmCtrlAltShiftVkN, "Ctrl+Alt+Shift+VK_N press/release", FALSE);
6770
6771 ret = DestroyAcceleratorTable(hAccel);
6772 ok( ret, "DestroyAcceleratorTable error %d\n", GetLastError());
6773
6774 trace("testing Alt press/release\n");
6775 flush_sequence();
6776 keybd_event(VK_MENU, 0, 0, 0);
6777 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
6778 keybd_event(VK_MENU, 0, 0, 0);
6779 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
6780 pump_msg_loop(hwnd, 0);
6781 /* this test doesn't pass in Wine for managed windows */
6782 ok_sequence(WmAltPressRelease, "Alt press/release", TRUE);
6783
6784 trace("testing Shift+MouseButton press/release\n");
6785 /* first, move mouse pointer inside of the window client area */
6786 GetClientRect(hwnd, &rc);
6787 MapWindowPoints(hwnd, 0, (LPPOINT)&rc, 2);
6788 rc.left += (rc.right - rc.left)/2;
6789 rc.top += (rc.bottom - rc.top)/2;
6790 SetCursorPos(rc.left, rc.top);
6791 SetActiveWindow(hwnd);
6792
6793 flush_events();
6794 flush_sequence();
6795 GetCursorPos(&pt);
6796 if (pt.x == rc.left && pt.y == rc.top)
6797 {
6798 keybd_event(VK_SHIFT, 0, 0, 0);
6799 mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
6800 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
6801 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
6802 pump_msg_loop(hwnd, 0);
6803 ok_sequence(WmShiftMouseButton, "Shift+MouseButton press/release", FALSE);
6804 }
6805
6806 trace("testing VK_F1 press/release\n");
6807 keybd_event(VK_F1, 0, 0, 0);
6808 keybd_event(VK_F1, 0, KEYEVENTF_KEYUP, 0);
6809 pump_msg_loop(hwnd, 0);
6810 ok_sequence(WmF1Seq, "F1 press/release", FALSE);
6811
6812 trace("testing VK_APPS press/release\n");
6813 keybd_event(VK_APPS, 0, 0, 0);
6814 keybd_event(VK_APPS, 0, KEYEVENTF_KEYUP, 0);
6815 pump_msg_loop(hwnd, 0);
6816 ok_sequence(WmVkAppsSeq, "VK_APPS press/release", FALSE);
6817
6818 DestroyWindow(hwnd);
6819 }
6820
6821 /************* window procedures ********************/
6822
6823 static LRESULT MsgCheckProc (BOOL unicode, HWND hwnd, UINT message,
6824 WPARAM wParam, LPARAM lParam)
6825 {
6826 static long defwndproc_counter = 0;
6827 static long beginpaint_counter = 0;
6828 LRESULT ret;
6829 struct recvd_message msg;
6830
6831 /* ignore registered messages */
6832 if (message >= 0xc000) return 0;
6833
6834 switch (message)
6835 {
6836 case WM_ENABLE:
6837 {
6838 LONG style = GetWindowLongA(hwnd, GWL_STYLE);
6839 ok((BOOL)wParam == !(style & WS_DISABLED),
6840 "wrong WS_DISABLED state: %ld != %d\n", wParam, !(style & WS_DISABLED));
6841 break;
6842 }
6843
6844 case WM_CAPTURECHANGED:
6845 if (test_DestroyWindow_flag)
6846 {
6847 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
6848 if (style & WS_CHILD)
6849 lParam = GetWindowLongPtrA(hwnd, GWLP_ID);
6850 else if (style & WS_POPUP)
6851 lParam = WND_POPUP_ID;
6852 else
6853 lParam = WND_PARENT_ID;
6854 }
6855 break;
6856
6857 case WM_NCDESTROY:
6858 {
6859 HWND capture;
6860
6861 ok(!GetWindow(hwnd, GW_CHILD), "children should be unlinked at this point\n");
6862 capture = GetCapture();
6863 if (capture)
6864 {
6865 ok(capture == hwnd, "capture should NOT be released at this point (capture %p)\n", capture);
6866 trace("current capture %p, releasing...\n", capture);
6867 ReleaseCapture();
6868 }
6869 }
6870 /* fall through */
6871 case WM_DESTROY:
6872 if (pGetAncestor)
6873 ok(pGetAncestor(hwnd, GA_PARENT) != 0, "parent should NOT be unlinked at this point\n");
6874 if (test_DestroyWindow_flag)
6875 {
6876 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
6877 if (style & WS_CHILD)
6878 lParam = GetWindowLongPtrA(hwnd, GWLP_ID);
6879 else if (style & WS_POPUP)
6880 lParam = WND_POPUP_ID;
6881 else
6882 lParam = WND_PARENT_ID;
6883 }
6884 break;
6885
6886 /* test_accelerators() depends on this */
6887 case WM_NCHITTEST:
6888 return HTCLIENT;
6889
6890 /* ignore */
6891 case WM_MOUSEMOVE:
6892 case WM_MOUSEACTIVATE:
6893 case WM_NCMOUSEMOVE:
6894 case WM_SETCURSOR:
6895 case WM_GETICON:
6896 case WM_GETOBJECT:
6897 case WM_DEVICECHANGE:
6898 case WM_IME_SELECT:
6899 return 0;
6900 }
6901
6902 msg.hwnd = hwnd;
6903 msg.message = message;
6904 msg.flags = sent|wparam|lparam;
6905 if (defwndproc_counter) msg.flags |= defwinproc;
6906 if (beginpaint_counter) msg.flags |= beginpaint;
6907 msg.wParam = wParam;
6908 msg.lParam = lParam;
6909 msg.descr = "MsgCheckProc";
6910 add_message(&msg);
6911
6912 if (message == WM_GETMINMAXINFO && (GetWindowLongA(hwnd, GWL_STYLE) & WS_CHILD))
6913 {
6914 HWND parent = GetParent(hwnd);
6915 RECT rc;
6916 MINMAXINFO *minmax = (MINMAXINFO *)lParam;
6917
6918 GetClientRect(parent, &rc);
6919 trace("parent %p client size = (%d x %d)\n", parent, rc.right, rc.bottom);
6920 trace("Reserved=%d,%d MaxSize=%d,%d MaxPos=%d,%d MinTrack=%d,%d MaxTrack=%d,%d\n",
6921 minmax->ptReserved.x, minmax->ptReserved.y,
6922 minmax->ptMaxSize.x, minmax->ptMaxSize.y,
6923 minmax->ptMaxPosition.x, minmax->ptMaxPosition.y,
6924 minmax->ptMinTrackSize.x, minmax->ptMinTrackSize.y,
6925 minmax->ptMaxTrackSize.x, minmax->ptMaxTrackSize.y);
6926
6927 ok(minmax->ptMaxSize.x == rc.right, "default width of maximized child %d != %d\n",
6928 minmax->ptMaxSize.x, rc.right);
6929 ok(minmax->ptMaxSize.y == rc.bottom, "default height of maximized child %d != %d\n",
6930 minmax->ptMaxSize.y, rc.bottom);
6931 }
6932
6933 if (message == WM_PAINT)
6934 {
6935 PAINTSTRUCT ps;
6936 beginpaint_counter++;
6937 BeginPaint( hwnd, &ps );
6938 beginpaint_counter--;
6939 EndPaint( hwnd, &ps );
6940 return 0;
6941 }
6942
6943 defwndproc_counter++;
6944 ret = unicode ? DefWindowProcW(hwnd, message, wParam, lParam)
6945 : DefWindowProcA(hwnd, message, wParam, lParam);
6946 defwndproc_counter--;
6947
6948 return ret;
6949 }
6950
6951 static LRESULT WINAPI MsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6952 {
6953 return MsgCheckProc (FALSE, hwnd, message, wParam, lParam);
6954 }
6955
6956 static LRESULT WINAPI MsgCheckProcW(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6957 {
6958 return MsgCheckProc (TRUE, hwnd, message, wParam, lParam);
6959 }
6960
6961 static LRESULT WINAPI PopupMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6962 {
6963 static long defwndproc_counter = 0;
6964 LRESULT ret;
6965 struct recvd_message msg;
6966
6967 switch (message)
6968 {
6969 case WM_GETICON:
6970 case WM_GETOBJECT:
6971 return 0; /* ignore them */
6972 case WM_QUERYENDSESSION:
6973 case WM_ENDSESSION:
6974 lParam &= ~0x01; /* Vista adds a 0x01 flag */
6975 break;
6976 }
6977
6978 msg.hwnd = hwnd;
6979 msg.message = message;
6980 msg.flags = sent|wparam|lparam;
6981 if (defwndproc_counter) msg.flags |= defwinproc;
6982 msg.wParam = wParam;
6983 msg.lParam = lParam;
6984 msg.descr = "popup";
6985 add_message(&msg);
6986
6987 if (message == WM_CREATE)
6988 {
6989 DWORD style = GetWindowLongA(hwnd, GWL_STYLE) | WS_VISIBLE;
6990 SetWindowLongA(hwnd, GWL_STYLE, style);
6991 }
6992
6993 defwndproc_counter++;
6994 ret = DefWindowProcA(hwnd, message, wParam, lParam);
6995 defwndproc_counter--;
6996
6997 return ret;
6998 }
6999
7000 static LRESULT WINAPI ParentMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
7001 {
7002 static long defwndproc_counter = 0;
7003 static long beginpaint_counter = 0;
7004 LRESULT ret;
7005 struct recvd_message msg;
7006
7007 if (message == WM_GETICON || message == WM_GETOBJECT) return 0; /* ignore them */
7008
7009 /* ignore registered messages */
7010 if (message >= 0xc000) return 0;
7011
7012 if (log_all_parent_messages ||
7013 message == WM_PARENTNOTIFY || message == WM_CANCELMODE ||
7014 message == WM_SETFOCUS || message == WM_KILLFOCUS ||
7015 message == WM_ENABLE || message == WM_ENTERIDLE ||
7016 message == WM_DRAWITEM ||
7017 message == WM_IME_SETCONTEXT)
7018 {
7019 switch (message)
7020 {
7021 /* ignore */
7022 case WM_NCHITTEST:
7023 return HTCLIENT;
7024 case WM_SETCURSOR:
7025 case WM_MOUSEMOVE:
7026 case WM_NCMOUSEMOVE:
7027 return 0;
7028
7029 case WM_ERASEBKGND:
7030 {
7031 RECT rc;
7032 INT ret = GetClipBox((HDC)wParam, &rc);
7033
7034 trace("WM_ERASEBKGND: GetClipBox()=%d, (%d,%d-%d,%d)\n",
7035 ret, rc.left, rc.top, rc.right, rc.bottom);
7036 break;
7037 }
7038 }
7039
7040 msg.hwnd = hwnd;
7041 msg.message = message;
7042 msg.flags = sent|parent|wparam|lparam;
7043 if (defwndproc_counter) msg.flags |= defwinproc;
7044 if (beginpaint_counter) msg.flags |= beginpaint;
7045 msg.wParam = wParam;
7046 msg.lParam = lParam;
7047 msg.descr = "parent";
7048 add_message(&msg);
7049 }
7050
7051 if (message == WM_PAINT)
7052 {
7053 PAINTSTRUCT ps;
7054 beginpaint_counter++;
7055 BeginPaint( hwnd, &ps );
7056 beginpaint_counter--;
7057 EndPaint( hwnd, &ps );
7058 return 0;
7059 }
7060
7061 defwndproc_counter++;
7062 ret = DefWindowProcA(hwnd, message, wParam, lParam);
7063 defwndproc_counter--;
7064
7065 return ret;
7066 }
7067
7068 static LRESULT WINAPI TestDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
7069 {
7070 static long defwndproc_counter = 0;
7071 LRESULT ret;
7072 struct recvd_message msg;
7073
7074 if (message == WM_GETICON || message == WM_GETOBJECT) return 0; /* ignore them */
7075
7076 if (test_def_id)
7077 {
7078 DefDlgProcA(hwnd, DM_SETDEFID, 1, 0);
7079 ret = DefDlgProcA(hwnd, DM_GETDEFID, 0, 0);
7080 if (after_end_dialog)
7081 ok( ret == 0, "DM_GETDEFID should return 0 after EndDialog, got %lx\n", ret );
7082 else
7083 ok(HIWORD(ret) == DC_HASDEFID, "DM_GETDEFID should return DC_HASDEFID, got %lx\n", ret);
7084 }
7085
7086 msg.hwnd = hwnd;
7087 msg.message = message;
7088 msg.flags = sent|wparam|lparam;
7089 if (defwndproc_counter) msg.flags |= defwinproc;
7090 msg.wParam = wParam;
7091 msg.lParam = lParam;
7092 msg.descr = "dialog";
7093 add_message(&msg);
7094
7095 defwndproc_counter++;
7096 ret = DefDlgProcA(hwnd, message, wParam, lParam);
7097 defwndproc_counter--;
7098
7099 return ret;
7100 }
7101
7102 static LRESULT WINAPI ShowWindowProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
7103 {
7104 static long defwndproc_counter = 0;
7105 LRESULT ret;
7106 struct recvd_message msg;
7107
7108 /* log only specific messages we are interested in */
7109 switch (message)
7110 {
7111 #if 0 /* probably log these as well */
7112 case WM_ACTIVATE:
7113 case WM_SETFOCUS:
7114 case WM_KILLFOCUS:
7115 #endif
7116 case WM_SHOWWINDOW:
7117 case WM_SIZE:
7118 case WM_MOVE:
7119 case WM_GETMINMAXINFO:
7120 case WM_WINDOWPOSCHANGING:
7121 case WM_WINDOWPOSCHANGED:
7122 break;
7123
7124 default: /* ignore */
7125 /*trace("showwindow: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);*/
7126 return DefWindowProcA(hwnd, message, wParam, lParam);
7127 }
7128
7129 msg.hwnd = hwnd;
7130 msg.message = message;
7131 msg.flags = sent|wparam|lparam;
7132 if (defwndproc_counter) msg.flags |= defwinproc;
7133 msg.wParam = wParam;
7134 msg.lParam = lParam;
7135 msg.descr = "show";
7136 add_message(&msg);
7137
7138 defwndproc_counter++;
7139 ret = DefWindowProcA(hwnd, message, wParam, lParam);
7140 defwndproc_counter--;
7141
7142 return ret;
7143 }
7144
7145 static LRESULT WINAPI PaintLoopProcA(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
7146 {
7147 switch (msg)
7148 {
7149 case WM_CREATE: return 0;
7150 case WM_PAINT:
7151 {
7152 MSG msg2;
7153 static int i = 0;
7154
7155 if (i < 256)
7156 {
7157 i++;
7158 if (PeekMessageA(&msg2, 0, 0, 0, 1))
7159 {
7160 TranslateMessage(&msg2);
7161 DispatchMessage(&msg2);
7162 }
7163 i--;
7164 }
7165 else ok(broken(1), "infinite loop\n");
7166 if ( i == 0)
7167 paint_loop_done = 1;
7168 return DefWindowProcA(hWnd,msg,wParam,lParam);
7169 }
7170 }
7171 return DefWindowProcA(hWnd,msg,wParam,lParam);
7172 }
7173
7174 static BOOL RegisterWindowClasses(void)
7175 {
7176 WNDCLASSA cls;
7177 WNDCLASSW clsW;
7178
7179 cls.style = 0;
7180 cls.lpfnWndProc = MsgCheckProcA;
7181 cls.cbClsExtra = 0;
7182 cls.cbWndExtra = 0;
7183 cls.hInstance = GetModuleHandleA(0);
7184 cls.hIcon = 0;
7185 cls.hCursor = LoadCursorA(0, IDC_ARROW);
7186 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
7187 cls.lpszMenuName = NULL;
7188 cls.lpszClassName = "TestWindowClass";
7189 if(!RegisterClassA(&cls)) return FALSE;
7190
7191 cls.lpfnWndProc = ShowWindowProcA;
7192 cls.lpszClassName = "ShowWindowClass";
7193 if(!RegisterClassA(&cls)) return FALSE;
7194
7195 cls.lpfnWndProc = PopupMsgCheckProcA;
7196 cls.lpszClassName = "TestPopupClass";
7197 if(!RegisterClassA(&cls)) return FALSE;
7198
7199 cls.lpfnWndProc = ParentMsgCheckProcA;
7200 cls.lpszClassName = "TestParentClass";
7201 if(!RegisterClassA(&cls)) return FALSE;
7202
7203 cls.lpfnWndProc = DefWindowProcA;
7204 cls.lpszClassName = "SimpleWindowClass";
7205 if(!RegisterClassA(&cls)) return FALSE;
7206
7207 cls.lpfnWndProc = PaintLoopProcA;
7208 cls.lpszClassName = "PaintLoopWindowClass";
7209 if(!RegisterClassA(&cls)) return FALSE;
7210
7211 cls.style = CS_NOCLOSE;
7212 cls.lpszClassName = "NoCloseWindowClass";
7213 if(!RegisterClassA(&cls)) return FALSE;
7214
7215 ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
7216 cls.style = 0;
7217 cls.hInstance = GetModuleHandleA(0);
7218 cls.hbrBackground = 0;
7219 cls.lpfnWndProc = TestDlgProcA;
7220 cls.lpszClassName = "TestDialogClass";
7221 if(!RegisterClassA(&cls)) return FALSE;
7222
7223 clsW.style = 0;
7224 clsW.lpfnWndProc = MsgCheckProcW;
7225 clsW.cbClsExtra = 0;
7226 clsW.cbWndExtra = 0;
7227 clsW.hInstance = GetModuleHandleW(0);
7228 clsW.hIcon = 0;
7229 clsW.hCursor = LoadCursorW(0, (LPWSTR)IDC_ARROW);
7230 clsW.hbrBackground = GetStockObject(WHITE_BRUSH);
7231 clsW.lpszMenuName = NULL;
7232 clsW.lpszClassName = testWindowClassW;
7233 RegisterClassW(&clsW); /* ignore error, this fails on Win9x */
7234
7235 return TRUE;
7236 }
7237
7238 static BOOL is_our_logged_class(HWND hwnd)
7239 {
7240 char buf[256];
7241
7242 if (GetClassNameA(hwnd, buf, sizeof(buf)))
7243 {
7244 if (!lstrcmpiA(buf, "TestWindowClass") ||
7245 !lstrcmpiA(buf, "ShowWindowClass") ||
7246 !lstrcmpiA(buf, "TestParentClass") ||
7247 !lstrcmpiA(buf, "TestPopupClass") ||
7248 !lstrcmpiA(buf, "SimpleWindowClass") ||
7249 !lstrcmpiA(buf, "TestDialogClass") ||
7250 !lstrcmpiA(buf, "MDI_frame_class") ||
7251 !lstrcmpiA(buf, "MDI_client_class") ||
7252 !lstrcmpiA(buf, "MDI_child_class") ||
7253 !lstrcmpiA(buf, "my_button_class") ||
7254 !lstrcmpiA(buf, "my_edit_class") ||
7255 !lstrcmpiA(buf, "static") ||
7256 !lstrcmpiA(buf, "ListBox") ||
7257 !lstrcmpiA(buf, "ComboBox") ||
7258 !lstrcmpiA(buf, "MyDialogClass") ||
7259 !lstrcmpiA(buf, "#32770") ||
7260 !lstrcmpiA(buf, "#32768"))
7261 return TRUE;
7262 }
7263 return FALSE;
7264 }
7265
7266 static LRESULT CALLBACK cbt_hook_proc(int nCode, WPARAM wParam, LPARAM lParam)
7267 {
7268 HWND hwnd;
7269
7270 ok(cbt_hook_thread_id == GetCurrentThreadId(), "we didn't ask for events from other threads\n");
7271
7272 if (nCode == HCBT_CLICKSKIPPED)
7273 {
7274 /* ignore this event, XP sends it a lot when switching focus between windows */
7275 return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
7276 }
7277
7278 if (nCode == HCBT_SYSCOMMAND || nCode == HCBT_KEYSKIPPED)
7279 {
7280 struct recvd_message msg;
7281
7282 msg.hwnd = 0;
7283 msg.message = nCode;
7284 msg.flags = hook|wparam|lparam;
7285 msg.wParam = wParam;
7286 msg.lParam = lParam;
7287 msg.descr = "CBT";
7288 add_message(&msg);
7289
7290 return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
7291 }
7292
7293 if (nCode == HCBT_DESTROYWND)
7294 {
7295 if (test_DestroyWindow_flag)
7296 {
7297 DWORD style = GetWindowLongA((HWND)wParam, GWL_STYLE);
7298 if (style & WS_CHILD)
7299 lParam = GetWindowLongPtrA((HWND)wParam, GWLP_ID);
7300 else if (style & WS_POPUP)
7301 lParam = WND_POPUP_ID;
7302 else
7303 lParam = WND_PARENT_ID;
7304 }
7305 }
7306
7307 /* Log also SetFocus(0) calls */
7308 hwnd = wParam ? (HWND)wParam : (HWND)lParam;
7309
7310 if (is_our_logged_class(hwnd))
7311 {
7312 struct recvd_message msg;
7313
7314 msg.hwnd = hwnd;
7315 msg.message = nCode;
7316 msg.flags = hook|wparam|lparam;
7317 msg.wParam = wParam;
7318 msg.lParam = lParam;
7319 msg.descr = "CBT";
7320 add_message(&msg);
7321 }
7322 return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
7323 }
7324
7325 static void CALLBACK win_event_proc(HWINEVENTHOOK hevent,
7326 DWORD event,
7327 HWND hwnd,
7328 LONG object_id,
7329 LONG child_id,
7330 DWORD thread_id,
7331 DWORD event_time)
7332 {
7333 ok(thread_id == GetCurrentThreadId(), "we didn't ask for events from other threads\n");
7334
7335 /* ignore mouse cursor events */
7336 if (object_id == OBJID_CURSOR) return;
7337
7338 if (!hwnd || is_our_logged_class(hwnd))
7339 {
7340 struct recvd_message msg;
7341
7342 msg.hwnd = hwnd;
7343 msg.message = event;
7344 msg.flags = winevent_hook|wparam|lparam;
7345 msg.wParam = object_id;
7346 msg.lParam = child_id;
7347 msg.descr = "WEH";
7348 add_message(&msg);
7349 }
7350 }
7351
7352 static const WCHAR wszUnicode[] = {'U','n','i','c','o','d','e',0};
7353 static const WCHAR wszAnsi[] = {'U',0};
7354
7355 static LRESULT CALLBACK MsgConversionProcW(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
7356 {
7357 switch (uMsg)
7358 {
7359 case CB_FINDSTRINGEXACT:
7360 trace("String: %p\n", (LPCWSTR)lParam);
7361 if (!lstrcmpW((LPCWSTR)lParam, wszUnicode))
7362 return 1;
7363 if (!lstrcmpW((LPCWSTR)lParam, wszAnsi))
7364 return 0;
7365 return -1;
7366 }
7367 return DefWindowProcW(hwnd, uMsg, wParam, lParam);
7368 }
7369
7370 static const struct message WmGetTextLengthAfromW[] = {
7371 { WM_GETTEXTLENGTH, sent },
7372 { WM_GETTEXT, sent|optional },
7373 { 0 }
7374 };
7375
7376 static const WCHAR dummy_window_text[] = {'d','u','m','m','y',' ','t','e','x','t',0};
7377
7378 /* dummy window proc for WM_GETTEXTLENGTH test */
7379 static LRESULT CALLBACK get_text_len_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
7380 {
7381 switch(msg)
7382 {
7383 case WM_GETTEXTLENGTH:
7384 return lstrlenW(dummy_window_text) + 37; /* some random length */
7385 case WM_GETTEXT:
7386 lstrcpynW( (LPWSTR)lp, dummy_window_text, wp );
7387 return lstrlenW( (LPWSTR)lp );
7388 default:
7389 return DefWindowProcW( hwnd, msg, wp, lp );
7390 }
7391 }
7392
7393 static void test_message_conversion(void)
7394 {
7395 static const WCHAR wszMsgConversionClass[] =
7396 {'M','s','g','C','o','n','v','e','r','s','i','o','n','C','l','a','s','s',0};
7397 WNDCLASSW cls;
7398 LRESULT lRes;
7399 HWND hwnd;
7400 WNDPROC wndproc, newproc;
7401 BOOL ret;
7402
7403 cls.style = 0;
7404 cls.lpfnWndProc = MsgConversionProcW;
7405 cls.cbClsExtra = 0;
7406 cls.cbWndExtra = 0;
7407 cls.hInstance = GetModuleHandleW(NULL);
7408 cls.hIcon = NULL;
7409 cls.hCursor = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
7410 cls.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
7411 cls.lpszMenuName = NULL;
7412 cls.lpszClassName = wszMsgConversionClass;
7413 /* this call will fail on Win9x, but that doesn't matter as this test is
7414 * meaningless on those platforms */
7415 if(!RegisterClassW(&cls)) return;
7416
7417 hwnd = CreateWindowExW(0, wszMsgConversionClass, NULL, WS_OVERLAPPED,
7418 100, 100, 200, 200, 0, 0, 0, NULL);
7419 ok(hwnd != NULL, "Window creation failed\n");
7420
7421 /* {W, A} -> A */
7422
7423 wndproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC);
7424 lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7425 ok(lRes == 0, "String should have been converted\n");
7426 lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7427 ok(lRes == 1, "String shouldn't have been converted\n");
7428
7429 /* {W, A} -> W */
7430
7431 wndproc = (WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC);
7432 lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7433 ok(lRes == 1, "String shouldn't have been converted\n");
7434 lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7435 ok(lRes == 1, "String shouldn't have been converted\n");
7436
7437 /* Synchronous messages */
7438
7439 lRes = SendMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7440 ok(lRes == 0, "String should have been converted\n");
7441 lRes = SendMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7442 ok(lRes == 1, "String shouldn't have been converted\n");
7443
7444 /* Asynchronous messages */
7445
7446 SetLastError(0);
7447 lRes = PostMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7448 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
7449 "PostMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
7450 SetLastError(0);
7451 lRes = PostMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7452 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
7453 "PostMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
7454 SetLastError(0);
7455 lRes = PostThreadMessageA(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7456 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
7457 "PosThreadtMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
7458 SetLastError(0);
7459 lRes = PostThreadMessageW(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7460 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
7461 "PosThreadtMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
7462 SetLastError(0);
7463 lRes = SendNotifyMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7464 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
7465 "SendNotifyMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
7466 SetLastError(0);
7467 lRes = SendNotifyMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7468 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
7469 "SendNotifyMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
7470 SetLastError(0);
7471 lRes = SendMessageCallbackA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
7472 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
7473 "SendMessageCallback on sync only message returned %ld, last error %d\n", lRes, GetLastError());
7474 SetLastError(0);
7475 lRes = SendMessageCallbackW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
7476 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
7477 "SendMessageCallback on sync only message returned %ld, last error %d\n", lRes, GetLastError());
7478
7479 /* Check WM_GETTEXTLENGTH A->W behaviour, whether WM_GETTEXT is also sent or not */
7480
7481 hwnd = CreateWindowW (testWindowClassW, wszUnicode,
7482 WS_OVERLAPPEDWINDOW,
7483 100, 100, 200, 200, 0, 0, 0, NULL);
7484 assert(hwnd);
7485 flush_sequence();
7486 lRes = SendMessageA (hwnd, WM_GETTEXTLENGTH, 0, 0);
7487 ok_sequence(WmGetTextLengthAfromW, "ANSI WM_GETTEXTLENGTH to Unicode window", FALSE);
7488 ok( lRes == WideCharToMultiByte( CP_ACP, 0, wszUnicode, lstrlenW(wszUnicode), NULL, 0, NULL, NULL ),
7489 "got bad length %ld\n", lRes );
7490
7491 flush_sequence();
7492 lRes = CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ),
7493 hwnd, WM_GETTEXTLENGTH, 0, 0);
7494 ok_sequence(WmGetTextLengthAfromW, "ANSI WM_GETTEXTLENGTH to Unicode window", FALSE);
7495 ok( lRes == WideCharToMultiByte( CP_ACP, 0, wszUnicode, lstrlenW(wszUnicode), NULL, 0, NULL, NULL ),
7496 "got bad length %ld\n", lRes );
7497
7498 wndproc = (WNDPROC)SetWindowLongPtrW( hwnd, GWLP_WNDPROC, (LONG_PTR)get_text_len_proc );
7499 newproc = (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC );
7500 lRes = CallWindowProcA( newproc, hwnd, WM_GETTEXTLENGTH, 0, 0 );
7501 ok( lRes == WideCharToMultiByte( CP_ACP, 0, dummy_window_text, lstrlenW(dummy_window_text),
7502 NULL, 0, NULL, NULL ) ||
7503 broken(lRes == lstrlenW(dummy_window_text) + 37),
7504 "got bad length %ld\n", lRes );
7505
7506 SetWindowLongPtrW( hwnd, GWLP_WNDPROC, (LONG_PTR)wndproc ); /* restore old wnd proc */
7507 lRes = CallWindowProcA( newproc, hwnd, WM_GETTEXTLENGTH, 0, 0 );
7508 ok( lRes == WideCharToMultiByte( CP_ACP, 0, dummy_window_text, lstrlenW(dummy_window_text),
7509 NULL, 0, NULL, NULL ) ||
7510 broken(lRes == lstrlenW(dummy_window_text) + 37),
7511 "got bad length %ld\n", lRes );
7512
7513 ret = DestroyWindow(hwnd);
7514 ok( ret, "DestroyWindow() error %d\n", GetLastError());
7515 }
7516
7517 struct timer_info
7518 {
7519 HWND hWnd;
7520 HANDLE handles[2];
7521 DWORD id;
7522 };
7523
7524 static VOID CALLBACK tfunc(HWND hwnd, UINT uMsg, UINT_PTR id, DWORD dwTime)
7525 {
7526 }
7527
7528 #define TIMER_ID 0x19
7529
7530 static DWORD WINAPI timer_thread_proc(LPVOID x)
7531 {
7532 struct timer_info *info = x;
7533 DWORD r;
7534
7535 r = KillTimer(info->hWnd, 0x19);
7536 ok(r,"KillTimer failed in thread\n");
7537 r = SetTimer(info->hWnd,TIMER_ID,10000,tfunc);
7538 ok(r,"SetTimer failed in thread\n");
7539 ok(r==TIMER_ID,"SetTimer id different\n");
7540 r = SetEvent(info->handles[0]);
7541 ok(r,"SetEvent failed in thread\n");
7542 return 0;
7543 }
7544
7545 static void test_timers(void)
7546 {
7547 struct timer_info info;
7548 DWORD id;
7549
7550 info.hWnd = CreateWindow ("TestWindowClass", NULL,
7551 WS_OVERLAPPEDWINDOW ,
7552 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
7553 NULL, NULL, 0);
7554
7555 info.id = SetTimer(info.hWnd,TIMER_ID,10000,tfunc);
7556 ok(info.id, "SetTimer failed\n");
7557 ok(info.id==TIMER_ID, "SetTimer timer ID different\n");
7558 info.handles[0] = CreateEvent(NULL,0,0,NULL);
7559 info.handles[1] = CreateThread(NULL,0,timer_thread_proc,&info,0,&id);
7560
7561 WaitForMultipleObjects(2, info.handles, FALSE, INFINITE);
7562
7563 WaitForSingleObject(info.handles[1], INFINITE);
7564
7565 CloseHandle(info.handles[0]);
7566 CloseHandle(info.handles[1]);
7567
7568 ok( KillTimer(info.hWnd, TIMER_ID), "KillTimer failed\n");
7569
7570 ok(DestroyWindow(info.hWnd), "failed to destroy window\n");
7571 }
7572
7573 static int count = 0;
7574 static VOID CALLBACK callback_count(
7575 HWND hwnd,
7576 UINT uMsg,
7577 UINT_PTR idEvent,
7578 DWORD dwTime
7579 )
7580 {
7581 count++;
7582 }
7583
7584 static void test_timers_no_wnd(void)
7585 {
7586 UINT_PTR id, id2;
7587 MSG msg;
7588
7589 count = 0;
7590 id = SetTimer(NULL, 0, 100, callback_count);
7591 ok(id != 0, "did not get id from SetTimer.\n");
7592 id2 = SetTimer(NULL, id, 200, callback_count);
7593 ok(id2 == id, "did not get same id from SetTimer when replacing (%li expected %li).\n", id2, id);
7594 Sleep(150);
7595 while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessage(&msg);
7596 ok(count == 0, "did not get zero count as expected (%i).\n", count);
7597 Sleep(150);
7598 while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessage(&msg);
7599 ok(count == 1, "did not get one count as expected (%i).\n", count);
7600 KillTimer(NULL, id);
7601 Sleep(250);
7602 while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessage(&msg);
7603 ok(count == 1, "killing replaced timer did not work (%i).\n", count);
7604 }
7605
7606 /* Various win events with arbitrary parameters */
7607 static const struct message WmWinEventsSeq[] = {
7608 { EVENT_SYSTEM_SOUND, winevent_hook|wparam|lparam, OBJID_WINDOW, 0 },
7609 { EVENT_SYSTEM_ALERT, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
7610 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, OBJID_TITLEBAR, 2 },
7611 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_MENU, 3 },
7612 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_CLIENT, 4 },
7613 { EVENT_SYSTEM_MENUPOPUPSTART, winevent_hook|wparam|lparam, OBJID_VSCROLL, 5 },
7614 { EVENT_SYSTEM_MENUPOPUPEND, winevent_hook|wparam|lparam, OBJID_HSCROLL, 6 },
7615 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, OBJID_SIZEGRIP, 7 },
7616 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, OBJID_CARET, 8 },
7617 /* our win event hook ignores OBJID_CURSOR events */
7618 /*{ EVENT_SYSTEM_MOVESIZESTART, winevent_hook|wparam|lparam, OBJID_CURSOR, 9 },*/
7619 { EVENT_SYSTEM_MOVESIZEEND, winevent_hook|wparam|lparam, OBJID_ALERT, 10 },
7620 { EVENT_SYSTEM_CONTEXTHELPSTART, winevent_hook|wparam|lparam, OBJID_SOUND, 11 },
7621 { EVENT_SYSTEM_CONTEXTHELPEND, winevent_hook|wparam|lparam, OBJID_QUERYCLASSNAMEIDX, 12 },
7622 { EVENT_SYSTEM_DRAGDROPSTART, winevent_hook|wparam|lparam, OBJID_NATIVEOM, 13 },
7623 { EVENT_SYSTEM_DRAGDROPEND, winevent_hook|wparam|lparam, OBJID_WINDOW, 0 },
7624 { EVENT_SYSTEM_DIALOGSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
7625 { EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam, OBJID_TITLEBAR, 2 },
7626 { EVENT_SYSTEM_SCROLLINGSTART, winevent_hook|wparam|lparam, OBJID_MENU, 3 },
7627 { EVENT_SYSTEM_SCROLLINGEND, winevent_hook|wparam|lparam, OBJID_CLIENT, 4 },
7628 { EVENT_SYSTEM_SWITCHSTART, winevent_hook|wparam|lparam, OBJID_VSCROLL, 5 },
7629 { EVENT_SYSTEM_SWITCHEND, winevent_hook|wparam|lparam, OBJID_HSCROLL, 6 },
7630 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, OBJID_SIZEGRIP, 7 },
7631 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam, OBJID_CARET, 8 },
7632 { 0 }
7633 };
7634 static const struct message WmWinEventCaretSeq[] = {
7635 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
7636 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
7637 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 2 */
7638 { EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
7639 { 0 }
7640 };
7641 static const struct message WmWinEventCaretSeq_2[] = {
7642 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
7643 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
7644 { EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
7645 { 0 }
7646 };
7647 static const struct message WmWinEventAlertSeq[] = {
7648 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_ALERT, 0 },
7649 { 0 }
7650 };
7651 static const struct message WmWinEventAlertSeq_2[] = {
7652 /* create window in the thread proc */
7653 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_WINDOW, 2 },
7654 /* our test event */
7655 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_ALERT, 2 },
7656 { 0 }
7657 };
7658 static const struct message WmGlobalHookSeq_1[] = {
7659 /* create window in the thread proc */
7660 { HCBT_CREATEWND, hook|lparam, 0, 2 },
7661 /* our test events */
7662 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 2 },
7663 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 2 },
7664 { 0 }
7665 };
7666 static const struct message WmGlobalHookSeq_2[] = {
7667 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 0 }, /* old local hook */
7668 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 2 }, /* new global hook */
7669 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 0 }, /* old local hook */
7670 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 2 }, /* new global hook */
7671 { 0 }
7672 };
7673
7674 static const struct message WmMouseLLHookSeq[] = {
7675 { WM_MOUSEMOVE, hook },
7676 { WM_LBUTTONUP, hook },
7677 { WM_MOUSEMOVE, hook },
7678 { 0 }
7679 };
7680
7681 static void CALLBACK win_event_global_hook_proc(HWINEVENTHOOK hevent,
7682 DWORD event,
7683 HWND hwnd,
7684 LONG object_id,
7685 LONG child_id,
7686 DWORD thread_id,
7687 DWORD event_time)
7688 {
7689 char buf[256];
7690
7691 if (GetClassNameA(hwnd, buf, sizeof(buf)))
7692 {
7693 if (!lstrcmpiA(buf, "TestWindowClass") ||
7694 !lstrcmpiA(buf, "static"))
7695 {
7696 struct recvd_message msg;
7697
7698 msg.hwnd = hwnd;
7699 msg.message = event;
7700 msg.flags = winevent_hook|wparam|lparam;
7701 msg.wParam = object_id;
7702 msg.lParam = (thread_id == GetCurrentThreadId()) ? child_id : (child_id + 2);
7703 msg.descr = "WEH_2";
7704 add_message(&msg);
7705 }
7706 }
7707 }
7708
7709 static HHOOK hCBT_global_hook;
7710 static DWORD cbt_global_hook_thread_id;
7711
7712 static LRESULT CALLBACK cbt_global_hook_proc(int nCode, WPARAM wParam, LPARAM lParam)
7713 {
7714 HWND hwnd;
7715 char buf[256];
7716
7717 if (nCode == HCBT_SYSCOMMAND)
7718 {
7719 struct recvd_message msg;
7720
7721 msg.hwnd = 0;
7722 msg.message = nCode;
7723 msg.flags = hook|wparam|lparam;
7724 msg.wParam = wParam;
7725 msg.lParam = (cbt_global_hook_thread_id == GetCurrentThreadId()) ? 1 : 2;
7726 msg.descr = "CBT_2";
7727 add_message(&msg);
7728
7729 return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
7730 }
7731 /* WH_MOUSE_LL hook */
7732 if (nCode == HC_ACTION)
7733 {
7734 MSLLHOOKSTRUCT *mhll = (MSLLHOOKSTRUCT *)lParam;
7735
7736 /* we can't test for real mouse events */
7737 if (mhll->flags & LLMHF_INJECTED)
7738 {
7739 struct recvd_message msg;
7740
7741 memset (&msg, 0, sizeof (msg));
7742 msg.message = wParam;
7743 msg.flags = hook;
7744 msg.descr = "CBT_2";
7745 add_message(&msg);
7746 }
7747 return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
7748 }
7749
7750 /* Log also SetFocus(0) calls */
7751 hwnd = wParam ? (HWND)wParam : (HWND)lParam;
7752
7753 if (GetClassNameA(hwnd, buf, sizeof(buf)))
7754 {
7755 if (!lstrcmpiA(buf, "TestWindowClass") ||
7756 !lstrcmpiA(buf, "static"))
7757 {
7758 struct recvd_message msg;
7759
7760 msg.hwnd = hwnd;
7761 msg.message = nCode;
7762 msg.flags = hook|wparam|lparam;
7763 msg.wParam = wParam;
7764 msg.lParam = (cbt_global_hook_thread_id == GetCurrentThreadId()) ? 1 : 2;
7765 msg.descr = "CBT_2";
7766 add_message(&msg);
7767 }
7768 }
7769 return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
7770 }
7771
7772 static DWORD WINAPI win_event_global_thread_proc(void *param)
7773 {
7774 HWND hwnd;
7775 MSG msg;
7776 HANDLE hevent = *(HANDLE *)param;
7777
7778 assert(pNotifyWinEvent);
7779
7780 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
7781 assert(hwnd);
7782 trace("created thread window %p\n", hwnd);
7783
7784 *(HWND *)param = hwnd;
7785
7786 flush_sequence();
7787 /* this event should be received only by our new hook proc,
7788 * an old one does not expect an event from another thread.
7789 */
7790 pNotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE, hwnd, OBJID_ALERT, 0);
7791 SetEvent(hevent);
7792
7793 while (GetMessage(&msg, 0, 0, 0))
7794 {
7795 TranslateMessage(&msg);
7796 DispatchMessage(&msg);
7797 }
7798 return 0;
7799 }
7800
7801 static DWORD WINAPI cbt_global_hook_thread_proc(void *param)
7802 {
7803 HWND hwnd;
7804 MSG msg;
7805 HANDLE hevent = *(HANDLE *)param;
7806
7807 flush_sequence();
7808 /* these events should be received only by our new hook proc,
7809 * an old one does not expect an event from another thread.
7810 */
7811
7812 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
7813 assert(hwnd);
7814 trace("created thread window %p\n", hwnd);
7815
7816 *(HWND *)param = hwnd;
7817
7818 /* Windows doesn't like when a thread plays games with the focus,
7819 that leads to all kinds of misbehaviours and failures to activate
7820 a window. So, better keep next lines commented out.
7821 SetFocus(0);
7822 SetFocus(hwnd);*/
7823
7824 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_PREVWINDOW, 0);
7825 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0);
7826
7827 SetEvent(hevent);
7828
7829 while (GetMessage(&msg, 0, 0, 0))
7830 {
7831 TranslateMessage(&msg);
7832 DispatchMessage(&msg);
7833 }
7834 return 0;
7835 }
7836
7837 static DWORD WINAPI mouse_ll_global_thread_proc(void *param)
7838 {
7839 HWND hwnd;
7840 MSG msg;
7841 HANDLE hevent = *(HANDLE *)param;
7842
7843 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
7844 assert(hwnd);
7845 trace("created thread window %p\n", hwnd);
7846
7847 *(HWND *)param = hwnd;
7848
7849 flush_sequence();
7850
7851 /* Windows doesn't like when a thread plays games with the focus,
7852 * that leads to all kinds of misbehaviours and failures to activate
7853 * a window. So, better don't generate a mouse click message below.
7854 */
7855 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
7856 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
7857 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
7858
7859 SetEvent(hevent);
7860 while (GetMessage(&msg, 0, 0, 0))
7861 {
7862 TranslateMessage(&msg);
7863 DispatchMessage(&msg);
7864 }
7865 return 0;
7866 }
7867
7868 static void test_winevents(void)
7869 {
7870 BOOL ret;
7871 MSG msg;
7872 HWND hwnd, hwnd2;
7873 UINT i;
7874 HANDLE hthread, hevent;
7875 DWORD tid;
7876 HWINEVENTHOOK hhook;
7877 const struct message *events = WmWinEventsSeq;
7878
7879 hwnd = CreateWindowExA(0, "TestWindowClass", NULL,
7880 WS_OVERLAPPEDWINDOW,
7881 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
7882 NULL, NULL, 0);
7883 assert(hwnd);
7884
7885 /****** start of global hook test *************/
7886 hCBT_global_hook = SetWindowsHookExA(WH_CBT, cbt_global_hook_proc, GetModuleHandleA(0), 0);
7887 if (!hCBT_global_hook)
7888 {
7889 ok(DestroyWindow(hwnd), "failed to destroy window\n");
7890 skip( "cannot set global hook\n" );
7891 return;
7892 }
7893
7894 hevent = CreateEventA(NULL, 0, 0, NULL);
7895 assert(hevent);
7896 hwnd2 = hevent;
7897
7898 hthread = CreateThread(NULL, 0, cbt_global_hook_thread_proc, &hwnd2, 0, &tid);
7899 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
7900
7901 ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7902
7903 ok_sequence(WmGlobalHookSeq_1, "global hook 1", FALSE);
7904
7905 flush_sequence();
7906 /* this one should be received only by old hook proc */
7907 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0);
7908 /* this one should be received only by old hook proc */
7909 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_PREVWINDOW, 0);
7910
7911 ok_sequence(WmGlobalHookSeq_2, "global hook 2", FALSE);
7912
7913 ret = UnhookWindowsHookEx(hCBT_global_hook);
7914 ok( ret, "UnhookWindowsHookEx error %d\n", GetLastError());
7915
7916 PostThreadMessageA(tid, WM_QUIT, 0, 0);
7917 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7918 CloseHandle(hthread);
7919 CloseHandle(hevent);
7920 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
7921 /****** end of global hook test *************/
7922
7923 if (!pSetWinEventHook || !pNotifyWinEvent || !pUnhookWinEvent)
7924 {
7925 ok(DestroyWindow(hwnd), "failed to destroy window\n");
7926 return;
7927 }
7928
7929 flush_sequence();
7930
7931 if (0)
7932 {
7933 /* this test doesn't pass under Win9x */
7934 /* win2k ignores events with hwnd == 0 */
7935 SetLastError(0xdeadbeef);
7936 pNotifyWinEvent(events[0].message, 0, events[0].wParam, events[0].lParam);
7937 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || /* Win2k */
7938 GetLastError() == 0xdeadbeef, /* Win9x */
7939 "unexpected error %d\n", GetLastError());
7940 ok_sequence(WmEmptySeq, "empty notify winevents", FALSE);
7941 }
7942
7943 for (i = 0; i < sizeof(WmWinEventsSeq)/sizeof(WmWinEventsSeq[0]); i++)
7944 pNotifyWinEvent(events[i].message, hwnd, events[i].wParam, events[i].lParam);
7945
7946 ok_sequence(WmWinEventsSeq, "notify winevents", FALSE);
7947
7948 /****** start of event filtering test *************/
7949 hhook = pSetWinEventHook(
7950 EVENT_OBJECT_SHOW, /* 0x8002 */
7951 EVENT_OBJECT_LOCATIONCHANGE, /* 0x800B */
7952 GetModuleHandleA(0), win_event_global_hook_proc,
7953 GetCurrentProcessId(), 0,
7954 WINEVENT_INCONTEXT);
7955 ok(hhook != 0, "SetWinEventHook error %d\n", GetLastError());
7956
7957 hevent = CreateEventA(NULL, 0, 0, NULL);
7958 assert(hevent);
7959 hwnd2 = hevent;
7960
7961 hthread = CreateThread(NULL, 0, win_event_global_thread_proc, &hwnd2, 0, &tid);
7962 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
7963
7964 ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7965
7966 ok_sequence(WmWinEventAlertSeq, "alert winevent", FALSE);
7967
7968 flush_sequence();
7969 /* this one should be received only by old hook proc */
7970 pNotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_CARET, 0); /* 0x8000 */
7971 pNotifyWinEvent(EVENT_OBJECT_SHOW, hwnd, OBJID_CARET, 0); /* 0x8002 */
7972 /* this one should be received only by old hook proc */
7973 pNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, hwnd, OBJID_CARET, 0); /* 0x800C */
7974
7975 ok_sequence(WmWinEventCaretSeq, "caret winevent", FALSE);
7976
7977 ret = pUnhookWinEvent(hhook);
7978 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
7979
7980 PostThreadMessageA(tid, WM_QUIT, 0, 0);
7981 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7982 CloseHandle(hthread);
7983 CloseHandle(hevent);
7984 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
7985 /****** end of event filtering test *************/
7986
7987 /****** start of out of context event test *************/
7988 hhook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0,
7989 win_event_global_hook_proc, GetCurrentProcessId(), 0,
7990 WINEVENT_OUTOFCONTEXT);
7991 ok(hhook != 0, "SetWinEventHook error %d\n", GetLastError());
7992
7993 hevent = CreateEventA(NULL, 0, 0, NULL);
7994 assert(hevent);
7995 hwnd2 = hevent;
7996
7997 flush_sequence();
7998
7999 hthread = CreateThread(NULL, 0, win_event_global_thread_proc, &hwnd2, 0, &tid);
8000 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
8001
8002 ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
8003
8004 ok_sequence(WmEmptySeq, "empty notify winevents", FALSE);
8005 /* process pending winevent messages */
8006 ok(!PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE), "msg queue should be empty\n");
8007 ok_sequence(WmWinEventAlertSeq_2, "alert winevent for out of context proc", FALSE);
8008
8009 flush_sequence();
8010 /* this one should be received only by old hook proc */
8011 pNotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_CARET, 0); /* 0x8000 */
8012 pNotifyWinEvent(EVENT_OBJECT_SHOW, hwnd, OBJID_CARET, 0); /* 0x8002 */
8013 /* this one should be received only by old hook proc */
8014 pNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, hwnd, OBJID_CARET, 0); /* 0x800C */
8015
8016 ok_sequence(WmWinEventCaretSeq_2, "caret winevent for incontext proc", FALSE);
8017 /* process pending winevent messages */
8018 ok(!PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE), "msg queue should be empty\n");
8019 ok_sequence(WmWinEventCaretSeq_2, "caret winevent for out of context proc", FALSE);
8020
8021 ret = pUnhookWinEvent(hhook);
8022 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
8023
8024 PostThreadMessageA(tid, WM_QUIT, 0, 0);
8025 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
8026 CloseHandle(hthread);
8027 CloseHandle(hevent);
8028 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
8029 /****** end of out of context event test *************/
8030
8031 /****** start of MOUSE_LL hook test *************/
8032 hCBT_global_hook = SetWindowsHookExA(WH_MOUSE_LL, cbt_global_hook_proc, GetModuleHandleA(0), 0);
8033 /* WH_MOUSE_LL is not supported on Win9x platforms */
8034 if (!hCBT_global_hook)
8035 {
8036 trace("Skipping WH_MOUSE_LL test on this platform\n");
8037 goto skip_mouse_ll_hook_test;
8038 }
8039
8040 hevent = CreateEventA(NULL, 0, 0, NULL);
8041 assert(hevent);
8042 hwnd2 = hevent;
8043
8044 hthread = CreateThread(NULL, 0, mouse_ll_global_thread_proc, &hwnd2, 0, &tid);
8045 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
8046
8047 while (WaitForSingleObject(hevent, 100) == WAIT_TIMEOUT)
8048 while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
8049
8050 ok_sequence(WmMouseLLHookSeq, "MOUSE_LL hook other thread", FALSE);
8051 flush_sequence();
8052
8053 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
8054 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
8055 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
8056
8057 ok_sequence(WmMouseLLHookSeq, "MOUSE_LL hook same thread", FALSE);
8058
8059 ret = UnhookWindowsHookEx(hCBT_global_hook);
8060 ok( ret, "UnhookWindowsHookEx error %d\n", GetLastError());
8061
8062 PostThreadMessageA(tid, WM_QUIT, 0, 0);
8063 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
8064 CloseHandle(hthread);
8065 CloseHandle(hevent);
8066 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
8067 /****** end of MOUSE_LL hook test *************/
8068 skip_mouse_ll_hook_test:
8069
8070 ok(DestroyWindow(hwnd), "failed to destroy window\n");
8071 }
8072
8073 static void test_set_hook(void)
8074 {
8075 BOOL ret;
8076 HHOOK hhook;
8077 HWINEVENTHOOK hwinevent_hook;
8078
8079 hhook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, GetModuleHandleA(0), GetCurrentThreadId());
8080 ok(hhook != 0, "local hook does not require hModule set to 0\n");
8081 UnhookWindowsHookEx(hhook);
8082
8083 if (0)
8084 {
8085 /* this test doesn't pass under Win9x: BUG! */
8086 SetLastError(0xdeadbeef);
8087 hhook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, 0);
8088 ok(!hhook, "global hook requires hModule != 0\n");
8089 ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD, "unexpected error %d\n", GetLastError());
8090 }
8091
8092 SetLastError(0xdeadbeef);
8093 hhook = SetWindowsHookExA(WH_CBT, 0, GetModuleHandleA(0), GetCurrentThreadId());
8094 ok(!hhook, "SetWinEventHook with invalid proc should fail\n");
8095 ok(GetLastError() == ERROR_INVALID_FILTER_PROC || /* Win2k */
8096 GetLastError() == 0xdeadbeef, /* Win9x */
8097 "unexpected error %d\n", GetLastError());
8098
8099 SetLastError(0xdeadbeef);
8100 ok(!UnhookWindowsHookEx((HHOOK)0xdeadbeef), "UnhookWindowsHookEx succeeded\n");
8101 ok(GetLastError() == ERROR_INVALID_HOOK_HANDLE || /* Win2k */
8102 GetLastError() == 0xdeadbeef, /* Win9x */
8103 "unexpected error %d\n", GetLastError());
8104
8105 if (!pSetWinEventHook || !pUnhookWinEvent) return;
8106
8107 /* even process local incontext hooks require hmodule */
8108 SetLastError(0xdeadbeef);
8109 hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
8110 GetCurrentProcessId(), 0, WINEVENT_INCONTEXT);
8111 ok(!hwinevent_hook, "WINEVENT_INCONTEXT requires hModule != 0\n");
8112 ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD || /* Win2k */
8113 GetLastError() == 0xdeadbeef, /* Win9x */
8114 "unexpected error %d\n", GetLastError());
8115
8116 /* even thread local incontext hooks require hmodule */
8117 SetLastError(0xdeadbeef);
8118 hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
8119 GetCurrentProcessId(), GetCurrentThreadId(), WINEVENT_INCONTEXT);
8120 ok(!hwinevent_hook, "WINEVENT_INCONTEXT requires hModule != 0\n");
8121 ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD || /* Win2k */
8122 GetLastError() == 0xdeadbeef, /* Win9x */
8123 "unexpected error %d\n", GetLastError());
8124
8125 if (0)
8126 {
8127 /* these 3 tests don't pass under Win9x */
8128 SetLastError(0xdeadbeef);
8129 hwinevent_hook = pSetWinEventHook(1, 0, 0, win_event_proc,
8130 GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
8131 ok(!hwinevent_hook, "SetWinEventHook with invalid event range should fail\n");
8132 ok(GetLastError() == ERROR_INVALID_HOOK_FILTER, "unexpected error %d\n", GetLastError());
8133
8134 SetLastError(0xdeadbeef);
8135 hwinevent_hook = pSetWinEventHook(-1, 1, 0, win_event_proc,
8136 GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
8137 ok(!hwinevent_hook, "SetWinEventHook with invalid event range should fail\n");
8138 ok(GetLastError() == ERROR_INVALID_HOOK_FILTER, "unexpected error %d\n", GetLastError());
8139
8140 SetLastError(0xdeadbeef);
8141 hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
8142 0, 0xdeadbeef, WINEVENT_OUTOFCONTEXT);
8143 ok(!hwinevent_hook, "SetWinEventHook with invalid tid should fail\n");
8144 ok(GetLastError() == ERROR_INVALID_THREAD_ID, "unexpected error %d\n", GetLastError());
8145 }
8146
8147 SetLastError(0xdeadbeef);
8148 hwinevent_hook = pSetWinEventHook(0, 0, 0, win_event_proc,
8149 GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
8150 ok(hwinevent_hook != 0, "SetWinEventHook error %d\n", GetLastError());
8151 ok(GetLastError() == 0xdeadbeef, "unexpected error %d\n", GetLastError());
8152 ret = pUnhookWinEvent(hwinevent_hook);
8153 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
8154
8155 todo_wine {
8156 /* This call succeeds under win2k SP4, but fails under Wine.
8157 Does win2k test/use passed process id? */
8158 SetLastError(0xdeadbeef);
8159 hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
8160 0xdeadbeef, 0, WINEVENT_OUTOFCONTEXT);
8161 ok(hwinevent_hook != 0, "SetWinEventHook error %d\n", GetLastError());
8162 ok(GetLastError() == 0xdeadbeef, "unexpected error %d\n", GetLastError());
8163 ret = pUnhookWinEvent(hwinevent_hook);
8164 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
8165 }
8166
8167 SetLastError(0xdeadbeef);
8168 ok(!pUnhookWinEvent((HWINEVENTHOOK)0xdeadbeef), "UnhookWinEvent succeeded\n");
8169 ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
8170 GetLastError() == 0xdeadbeef, /* Win9x */
8171 "unexpected error %d\n", GetLastError());
8172 }
8173
8174 static const struct message ScrollWindowPaint1[] = {
8175 { WM_PAINT, sent },
8176 { WM_ERASEBKGND, sent|beginpaint },
8177 { 0 }
8178 };
8179
8180 static const struct message ScrollWindowPaint2[] = {
8181 { WM_PAINT, sent },
8182 { 0 }
8183 };
8184
8185 static void test_scrollwindowex(void)
8186 {
8187 HWND hwnd, hchild;
8188 RECT rect={0,0,130,130};
8189
8190 hwnd = CreateWindowExA(0, "TestWindowClass", "Test Scroll",
8191 WS_VISIBLE|WS_OVERLAPPEDWINDOW,
8192 100, 100, 200, 200, 0, 0, 0, NULL);
8193 ok (hwnd != 0, "Failed to create overlapped window\n");
8194 hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
8195 WS_VISIBLE|WS_CAPTION|WS_CHILD,
8196 10, 10, 150, 150, hwnd, 0, 0, NULL);
8197 ok (hchild != 0, "Failed to create child\n");
8198 UpdateWindow(hwnd);
8199 flush_events();
8200 flush_sequence();
8201
8202 /* scroll without the child window */
8203 trace("start scroll\n");
8204 ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL,
8205 SW_ERASE|SW_INVALIDATE);
8206 ok_sequence(WmEmptySeq, "ScrollWindowEx", 0);
8207 trace("end scroll\n");
8208 flush_sequence();
8209 flush_events();
8210 ok_sequence(ScrollWindowPaint1, "ScrollWindowEx", 0);
8211 flush_events();
8212 flush_sequence();
8213
8214 /* Now without the SW_ERASE flag */
8215 trace("start scroll\n");
8216 ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL, SW_INVALIDATE);
8217 ok_sequence(WmEmptySeq, "ScrollWindowEx", 0);
8218 trace("end scroll\n");
8219 flush_sequence();
8220 flush_events();
8221 ok_sequence(ScrollWindowPaint2, "ScrollWindowEx", 0);
8222 flush_events();
8223 flush_sequence();
8224
8225 /* now scroll the child window as well */
8226 trace("start scroll\n");
8227 ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL,
8228 SW_SCROLLCHILDREN|SW_ERASE|SW_INVALIDATE);
8229 /* wine sends WM_POSCHANGING, WM_POSCHANGED messages */
8230 /* windows sometimes a WM_MOVE */
8231 ok_sequence(WmEmptySeq, "ScrollWindowEx", TRUE);
8232 trace("end scroll\n");
8233 flush_sequence();
8234 flush_events();
8235 ok_sequence(ScrollWindowPaint1, "ScrollWindowEx", 0);
8236 flush_events();
8237 flush_sequence();
8238
8239 /* now scroll with ScrollWindow() */
8240 trace("start scroll with ScrollWindow\n");
8241 ScrollWindow( hwnd, 5, 5, NULL, NULL);
8242 trace("end scroll\n");
8243 flush_sequence();
8244 flush_events();
8245 ok_sequence(ScrollWindowPaint1, "ScrollWindow", 0);
8246
8247 ok(DestroyWindow(hchild), "failed to destroy window\n");
8248 ok(DestroyWindow(hwnd), "failed to destroy window\n");
8249 flush_sequence();
8250 }
8251
8252 static const struct message destroy_window_with_children[] = {
8253 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 }, /* popup */
8254 { HCBT_DESTROYWND, hook|lparam, 0, WND_PARENT_ID }, /* parent */
8255 { 0x0090, sent|optional },
8256 { HCBT_DESTROYWND, hook|lparam, 0, WND_POPUP_ID }, /* popup */
8257 { 0x0090, sent|optional },
8258 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 }, /* popup */
8259 { WM_DESTROY, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
8260 { WM_CAPTURECHANGED, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
8261 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
8262 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 }, /* parent */
8263 { WM_DESTROY, sent|wparam|lparam, 0, WND_PARENT_ID }, /* parent */
8264 { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 2 }, /* child2 */
8265 { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 1 }, /* child1 */
8266 { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 3 }, /* child3 */
8267 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 2 }, /* child2 */
8268 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 3 }, /* child3 */
8269 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 1 }, /* child1 */
8270 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_PARENT_ID }, /* parent */
8271 { 0 }
8272 };
8273
8274 static void test_DestroyWindow(void)
8275 {
8276 BOOL ret;
8277 HWND parent, child1, child2, child3, child4, test;
8278 UINT_PTR child_id = WND_CHILD_ID + 1;
8279
8280 parent = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
8281 100, 100, 200, 200, 0, 0, 0, NULL);
8282 assert(parent != 0);
8283 child1 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
8284 0, 0, 50, 50, parent, (HMENU)child_id++, 0, NULL);
8285 assert(child1 != 0);
8286 child2 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
8287 0, 0, 50, 50, GetDesktopWindow(), (HMENU)child_id++, 0, NULL);
8288 assert(child2 != 0);
8289 child3 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
8290 0, 0, 50, 50, child1, (HMENU)child_id++, 0, NULL);
8291 assert(child3 != 0);
8292 child4 = CreateWindowExA(0, "TestWindowClass", NULL, WS_POPUP,
8293 0, 0, 50, 50, parent, 0, 0, NULL);
8294 assert(child4 != 0);
8295
8296 /* test owner/parent of child2 */
8297 test = GetParent(child2);
8298 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
8299 ok(!IsChild(parent, child2), "wrong parent/child %p/%p\n", parent, child2);
8300 if(pGetAncestor) {
8301 test = pGetAncestor(child2, GA_PARENT);
8302 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
8303 }
8304 test = GetWindow(child2, GW_OWNER);
8305 ok(!test, "wrong owner %p\n", test);
8306
8307 test = SetParent(child2, parent);
8308 ok(test == GetDesktopWindow(), "wrong old parent %p\n", test);
8309
8310 /* test owner/parent of the parent */
8311 test = GetParent(parent);
8312 ok(!test, "wrong parent %p\n", test);
8313 ok(!IsChild(GetDesktopWindow(), parent), "wrong parent/child %p/%p\n", GetDesktopWindow(), parent);
8314 if(pGetAncestor) {
8315 test = pGetAncestor(parent, GA_PARENT);
8316 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
8317 }
8318 test = GetWindow(parent, GW_OWNER);
8319 ok(!test, "wrong owner %p\n", test);
8320
8321 /* test owner/parent of child1 */
8322 test = GetParent(child1);
8323 ok(test == parent, "wrong parent %p\n", test);
8324 ok(IsChild(parent, child1), "wrong parent/child %p/%p\n", parent, child1);
8325 if(pGetAncestor) {
8326 test = pGetAncestor(child1, GA_PARENT);
8327 ok(test == parent, "wrong parent %p\n", test);
8328 }
8329 test = GetWindow(child1, GW_OWNER);
8330 ok(!test, "wrong owner %p\n", test);
8331
8332 /* test owner/parent of child2 */
8333 test = GetParent(child2);
8334 ok(test == parent, "wrong parent %p\n", test);
8335 ok(IsChild(parent, child2), "wrong parent/child %p/%p\n", parent, child2);
8336 if(pGetAncestor) {
8337 test = pGetAncestor(child2, GA_PARENT);
8338 ok(test == parent, "wrong parent %p\n", test);
8339 }
8340 test = GetWindow(child2, GW_OWNER);
8341 ok(!test, "wrong owner %p\n", test);
8342
8343 /* test owner/parent of child3 */
8344 test = GetParent(child3);
8345 ok(test == child1, "wrong parent %p\n", test);
8346 ok(IsChild(parent, child3), "wrong parent/child %p/%p\n", parent, child3);
8347 if(pGetAncestor) {
8348 test = pGetAncestor(child3, GA_PARENT);
8349 ok(test == child1, "wrong parent %p\n", test);
8350 }
8351 test = GetWindow(child3, GW_OWNER);
8352 ok(!test, "wrong owner %p\n", test);
8353
8354 /* test owner/parent of child4 */
8355 test = GetParent(child4);
8356 ok(test == parent, "wrong parent %p\n", test);
8357 ok(!IsChild(parent, child4), "wrong parent/child %p/%p\n", parent, child4);
8358 if(pGetAncestor) {
8359 test = pGetAncestor(child4, GA_PARENT);
8360 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
8361 }
8362 test = GetWindow(child4, GW_OWNER);
8363 ok(test == parent, "wrong owner %p\n", test);
8364
8365 flush_sequence();
8366
8367 trace("parent %p, child1 %p, child2 %p, child3 %p, child4 %p\n",
8368 parent, child1, child2, child3, child4);
8369
8370 SetCapture(child4);
8371 test = GetCapture();
8372 ok(test == child4, "wrong capture window %p\n", test);
8373
8374 test_DestroyWindow_flag = TRUE;
8375 ret = DestroyWindow(parent);
8376 ok( ret, "DestroyWindow() error %d\n", GetLastError());
8377 test_DestroyWindow_flag = FALSE;
8378 ok_sequence(destroy_window_with_children, "destroy window with children", 0);
8379
8380 ok(!IsWindow(parent), "parent still exists\n");
8381 ok(!IsWindow(child1), "child1 still exists\n");
8382 ok(!IsWindow(child2), "child2 still exists\n");
8383 ok(!IsWindow(child3), "child3 still exists\n");
8384 ok(!IsWindow(child4), "child4 still exists\n");
8385
8386 test = GetCapture();
8387 ok(!test, "wrong capture window %p\n", test);
8388 }
8389
8390
8391 static const struct message WmDispatchPaint[] = {
8392 { WM_NCPAINT, sent },
8393 { WM_GETTEXT, sent|defwinproc|optional },
8394 { WM_GETTEXT, sent|defwinproc|optional },
8395 { WM_ERASEBKGND, sent },
8396 { 0 }
8397 };
8398
8399 static LRESULT WINAPI DispatchMessageCheckProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8400 {
8401 if (message == WM_PAINT) return 0;
8402 return MsgCheckProcA( hwnd, message, wParam, lParam );
8403 }
8404
8405 static void test_DispatchMessage(void)
8406 {
8407 RECT rect;
8408 MSG msg;
8409 int count;
8410 HWND hwnd = CreateWindowA( "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
8411 100, 100, 200, 200, 0, 0, 0, NULL);
8412 ShowWindow( hwnd, SW_SHOW );
8413 UpdateWindow( hwnd );
8414 flush_events();
8415 flush_sequence();
8416 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)DispatchMessageCheckProc );
8417
8418 SetRect( &rect, -5, -5, 5, 5 );
8419 RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
8420 count = 0;
8421 while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
8422 {
8423 if (msg.message != WM_PAINT) DispatchMessage( &msg );
8424 else
8425 {
8426 flush_sequence();
8427 DispatchMessage( &msg );
8428 /* DispatchMessage will send WM_NCPAINT if non client area is still invalid after WM_PAINT */
8429 if (!count) ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
8430 else ok_sequence( WmEmptySeq, "WmEmpty", FALSE );
8431 if (++count > 10) break;
8432 }
8433 }
8434 ok( msg.message == WM_PAINT && count > 10, "WM_PAINT messages stopped\n" );
8435
8436 trace("now without DispatchMessage\n");
8437 flush_sequence();
8438 RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
8439 count = 0;
8440 while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
8441 {
8442 if (msg.message != WM_PAINT) DispatchMessage( &msg );
8443 else
8444 {
8445 HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
8446 flush_sequence();
8447 /* this will send WM_NCCPAINT just like DispatchMessage does */
8448 GetUpdateRgn( hwnd, hrgn, TRUE );
8449 ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
8450 DeleteObject( hrgn );
8451 GetClientRect( hwnd, &rect );
8452 ValidateRect( hwnd, &rect ); /* this will stop WM_PAINTs */
8453 ok( !count, "Got multiple WM_PAINTs\n" );
8454 if (++count > 10) break;
8455 }
8456 }
8457 DestroyWindow(hwnd);
8458 }
8459
8460
8461 static const struct message WmUser[] = {
8462 { WM_USER, sent },
8463 { 0 }
8464 };
8465
8466 struct sendmsg_info
8467 {
8468 HWND hwnd;
8469 DWORD timeout;
8470 DWORD ret;
8471 };
8472
8473 static DWORD CALLBACK send_msg_thread( LPVOID arg )
8474 {
8475 struct sendmsg_info *info = arg;
8476 SetLastError( 0xdeadbeef );
8477 info->ret = SendMessageTimeoutA( info->hwnd, WM_USER, 0, 0, 0, info->timeout, NULL );
8478 if (!info->ret) ok( GetLastError() == ERROR_TIMEOUT ||
8479 broken(GetLastError() == 0), /* win9x */
8480 "unexpected error %d\n", GetLastError());
8481 return 0;
8482 }
8483
8484 static void wait_for_thread( HANDLE thread )
8485 {
8486 while (MsgWaitForMultipleObjects(1, &thread, FALSE, INFINITE, QS_SENDMESSAGE) != WAIT_OBJECT_0)
8487 {
8488 MSG msg;
8489 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage(&msg);
8490 }
8491 }
8492
8493 static LRESULT WINAPI send_msg_delay_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8494 {
8495 if (message == WM_USER) Sleep(200);
8496 return MsgCheckProcA( hwnd, message, wParam, lParam );
8497 }
8498
8499 static void test_SendMessageTimeout(void)
8500 {
8501 HANDLE thread;
8502 struct sendmsg_info info;
8503 DWORD tid;
8504 BOOL is_win9x;
8505
8506 info.hwnd = CreateWindowA( "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
8507 100, 100, 200, 200, 0, 0, 0, NULL);
8508 flush_events();
8509 flush_sequence();
8510
8511 info.timeout = 1000;
8512 info.ret = 0xdeadbeef;
8513 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
8514 wait_for_thread( thread );
8515 CloseHandle( thread );
8516 ok( info.ret == 1, "SendMessageTimeout failed\n" );
8517 ok_sequence( WmUser, "WmUser", FALSE );
8518
8519 info.timeout = 1;
8520 info.ret = 0xdeadbeef;
8521 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
8522 Sleep(100); /* SendMessageTimeout should time out here */
8523 wait_for_thread( thread );
8524 CloseHandle( thread );
8525 ok( info.ret == 0, "SendMessageTimeout succeeded\n" );
8526 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
8527
8528 /* 0 means infinite timeout (but not on win9x) */
8529 info.timeout = 0;
8530 info.ret = 0xdeadbeef;
8531 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
8532 Sleep(100);
8533 wait_for_thread( thread );
8534 CloseHandle( thread );
8535 is_win9x = !info.ret;
8536 if (is_win9x) ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
8537 else ok_sequence( WmUser, "WmUser", FALSE );
8538
8539 /* timeout is treated as signed despite the prototype (but not on win9x) */
8540 info.timeout = 0x7fffffff;
8541 info.ret = 0xdeadbeef;
8542 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
8543 Sleep(100);
8544 wait_for_thread( thread );
8545 CloseHandle( thread );
8546 ok( info.ret == 1, "SendMessageTimeout failed\n" );
8547 ok_sequence( WmUser, "WmUser", FALSE );
8548
8549 info.timeout = 0x80000000;
8550 info.ret = 0xdeadbeef;
8551 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
8552 Sleep(100);
8553 wait_for_thread( thread );
8554 CloseHandle( thread );
8555 if (is_win9x)
8556 {
8557 ok( info.ret == 1, "SendMessageTimeout failed\n" );
8558 ok_sequence( WmUser, "WmUser", FALSE );
8559 }
8560 else
8561 {
8562 ok( info.ret == 0, "SendMessageTimeout succeeded\n" );
8563 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
8564 }
8565
8566 /* now check for timeout during message processing */
8567 SetWindowLongPtrA( info.hwnd, GWLP_WNDPROC, (LONG_PTR)send_msg_delay_proc );
8568 info.timeout = 100;
8569 info.ret = 0xdeadbeef;
8570 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
8571 wait_for_thread( thread );
8572 CloseHandle( thread );
8573 /* we should time out but still get the message */
8574 ok( info.ret == 0, "SendMessageTimeout failed\n" );
8575 ok_sequence( WmUser, "WmUser", FALSE );
8576
8577 DestroyWindow( info.hwnd );
8578 }
8579
8580
8581 /****************** edit message test *************************/
8582 #define ID_EDIT 0x1234
8583 static const struct message sl_edit_setfocus[] =
8584 {
8585 { HCBT_SETFOCUS, hook },
8586 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
8587 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
8588 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
8589 { WM_SETFOCUS, sent|wparam, 0 },
8590 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
8591 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 15 },
8592 { WM_CTLCOLOREDIT, sent|parent },
8593 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
8594 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8595 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8596 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
8597 { 0 }
8598 };
8599 static const struct message ml_edit_setfocus[] =
8600 {
8601 { HCBT_SETFOCUS, hook },
8602 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
8603 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
8604 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
8605 { WM_SETFOCUS, sent|wparam, 0 },
8606 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
8607 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
8608 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8609 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8610 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
8611 { 0 }
8612 };
8613 static const struct message sl_edit_killfocus[] =
8614 {
8615 { HCBT_SETFOCUS, hook },
8616 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
8617 { WM_KILLFOCUS, sent|wparam, 0 },
8618 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8619 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8620 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_KILLFOCUS) },
8621 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
8622 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
8623 { 0 }
8624 };
8625 static const struct message sl_edit_lbutton_dblclk[] =
8626 {
8627 { WM_LBUTTONDBLCLK, sent },
8628 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
8629 { 0 }
8630 };
8631 static const struct message sl_edit_lbutton_down[] =
8632 {
8633 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
8634 { HCBT_SETFOCUS, hook },
8635 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
8636 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
8637 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
8638 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
8639 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
8640 { WM_CTLCOLOREDIT, sent|parent },
8641 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
8642 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8643 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8644 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8645 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
8646 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
8647 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8648 { WM_CTLCOLOREDIT, sent|parent|optional },
8649 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
8650 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8651 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8652 { 0 }
8653 };
8654 static const struct message ml_edit_lbutton_down[] =
8655 {
8656 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
8657 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
8658 { HCBT_SETFOCUS, hook },
8659 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
8660 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
8661 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
8662 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
8663 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
8664 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
8665 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8666 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8667 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
8668 { 0 }
8669 };
8670 static const struct message sl_edit_lbutton_up[] =
8671 {
8672 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
8673 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8674 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
8675 { WM_CAPTURECHANGED, sent|defwinproc },
8676 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8677 { 0 }
8678 };
8679 static const struct message ml_edit_lbutton_up[] =
8680 {
8681 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
8682 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
8683 { WM_CAPTURECHANGED, sent|defwinproc },
8684 { 0 }
8685 };
8686
8687 static WNDPROC old_edit_proc;
8688
8689 static LRESULT CALLBACK edit_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8690 {
8691 static long defwndproc_counter = 0;
8692 LRESULT ret;
8693 struct recvd_message msg;
8694
8695 if (message == WM_GETICON || message == WM_GETOBJECT) return 0; /* ignore them */
8696
8697 msg.hwnd = hwnd;
8698 msg.message = message;
8699 msg.flags = sent|wparam|lparam;
8700 if (defwndproc_counter) msg.flags |= defwinproc;
8701 msg.wParam = wParam;
8702 msg.lParam = lParam;
8703 msg.descr = "edit";
8704 add_message(&msg);
8705
8706 defwndproc_counter++;
8707 ret = CallWindowProcA(old_edit_proc, hwnd, message, wParam, lParam);
8708 defwndproc_counter--;
8709
8710 return ret;
8711 }
8712
8713 static void subclass_edit(void)
8714 {
8715 WNDCLASSA cls;
8716
8717 if (!GetClassInfoA(0, "edit", &cls)) assert(0);
8718
8719 old_edit_proc = cls.lpfnWndProc;
8720
8721 cls.hInstance = GetModuleHandle(0);
8722 cls.lpfnWndProc = edit_hook_proc;
8723 cls.lpszClassName = "my_edit_class";
8724 UnregisterClass(cls.lpszClassName, cls.hInstance);
8725 if (!RegisterClassA(&cls)) assert(0);
8726 }
8727
8728 static void test_edit_messages(void)
8729 {
8730 HWND hwnd, parent;
8731 DWORD dlg_code;
8732
8733 subclass_edit();
8734 log_all_parent_messages++;
8735
8736 parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
8737 100, 100, 200, 200, 0, 0, 0, NULL);
8738 ok (parent != 0, "Failed to create parent window\n");
8739
8740 /* test single line edit */
8741 hwnd = CreateWindowExA(0, "my_edit_class", "test", WS_CHILD,
8742 0, 0, 80, 20, parent, (HMENU)ID_EDIT, 0, NULL);
8743 ok(hwnd != 0, "Failed to create edit window\n");
8744
8745 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
8746 ok(dlg_code == (DLGC_WANTCHARS|DLGC_HASSETSEL|DLGC_WANTARROWS), "wrong dlg_code %08x\n", dlg_code);
8747
8748 ShowWindow(hwnd, SW_SHOW);
8749 UpdateWindow(hwnd);
8750 SetFocus(0);
8751 flush_sequence();
8752
8753 SetFocus(hwnd);
8754 ok_sequence(sl_edit_setfocus, "SetFocus(hwnd) on an edit", FALSE);
8755
8756 SetFocus(0);
8757 ok_sequence(sl_edit_killfocus, "SetFocus(0) on an edit", FALSE);
8758
8759 SetFocus(0);
8760 ReleaseCapture();
8761 flush_sequence();
8762
8763 SendMessageA(hwnd, WM_LBUTTONDBLCLK, 0, 0);
8764 ok_sequence(sl_edit_lbutton_dblclk, "WM_LBUTTONDBLCLK on an edit", FALSE);
8765
8766 SetFocus(0);
8767 ReleaseCapture();
8768 flush_sequence();
8769
8770 SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
8771 ok_sequence(sl_edit_lbutton_down, "WM_LBUTTONDOWN on an edit", FALSE);
8772
8773 SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
8774 ok_sequence(sl_edit_lbutton_up, "WM_LBUTTONUP on an edit", FALSE);
8775
8776 DestroyWindow(hwnd);
8777
8778 /* test multiline edit */
8779 hwnd = CreateWindowExA(0, "my_edit_class", "test", WS_CHILD | ES_MULTILINE,
8780 0, 0, 80, 20, parent, (HMENU)ID_EDIT, 0, NULL);
8781 ok(hwnd != 0, "Failed to create edit window\n");
8782
8783 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
8784 ok(dlg_code == (DLGC_WANTCHARS|DLGC_HASSETSEL|DLGC_WANTARROWS|DLGC_WANTALLKEYS),
8785 "wrong dlg_code %08x\n", dlg_code);
8786
8787 ShowWindow(hwnd, SW_SHOW);
8788 UpdateWindow(hwnd);
8789 SetFocus(0);
8790 flush_sequence();
8791
8792 SetFocus(hwnd);
8793 ok_sequence(ml_edit_setfocus, "SetFocus(hwnd) on multiline edit", FALSE);
8794
8795 SetFocus(0);
8796 ok_sequence(sl_edit_killfocus, "SetFocus(0) on multiline edit", FALSE);
8797
8798 SetFocus(0);
8799 ReleaseCapture();
8800 flush_sequence();
8801
8802 SendMessageA(hwnd, WM_LBUTTONDBLCLK, 0, 0);
8803 ok_sequence(sl_edit_lbutton_dblclk, "WM_LBUTTONDBLCLK on multiline edit", FALSE);
8804
8805 SetFocus(0);
8806 ReleaseCapture();
8807 flush_sequence();
8808
8809 SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
8810 ok_sequence(ml_edit_lbutton_down, "WM_LBUTTONDOWN on multiline edit", FALSE);
8811
8812 SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
8813 ok_sequence(ml_edit_lbutton_up, "WM_LBUTTONUP on multiline edit", FALSE);
8814
8815 DestroyWindow(hwnd);
8816 DestroyWindow(parent);
8817
8818 log_all_parent_messages--;
8819 }
8820
8821 /**************************** End of Edit test ******************************/
8822
8823 static const struct message WmKeyDownSkippedSeq[] =
8824 {
8825 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
8826 { 0 }
8827 };
8828 static const struct message WmKeyDownWasDownSkippedSeq[] =
8829 {
8830 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x40000001 }, /* XP */
8831 { 0 }
8832 };
8833 static const struct message WmKeyUpSkippedSeq[] =
8834 {
8835 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
8836 { 0 }
8837 };
8838 static const struct message WmUserKeyUpSkippedSeq[] =
8839 {
8840 { WM_USER, sent },
8841 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
8842 { 0 }
8843 };
8844
8845 #define EV_STOP 0
8846 #define EV_SENDMSG 1
8847 #define EV_ACK 2
8848
8849 struct peekmsg_info
8850 {
8851 HWND hwnd;
8852 HANDLE hevent[3]; /* 0 - start/stop, 1 - SendMessage, 2 - ack */
8853 };
8854
8855 static DWORD CALLBACK send_msg_thread_2(void *param)
8856 {
8857 DWORD ret;
8858 struct peekmsg_info *info = param;
8859
8860 trace("thread: looping\n");
8861 SetEvent(info->hevent[EV_ACK]);
8862
8863 while (1)
8864 {
8865 ret = WaitForMultipleObjects(2, info->hevent, FALSE, INFINITE);
8866
8867 switch (ret)
8868 {
8869 case WAIT_OBJECT_0 + EV_STOP:
8870 trace("thread: exiting\n");
8871 return 0;
8872
8873 case WAIT_OBJECT_0 + EV_SENDMSG:
8874 trace("thread: sending message\n");
8875 ok( SendNotifyMessageA(info->hwnd, WM_USER, 0, 0),
8876 "SendNotifyMessageA failed error %u\n", GetLastError());
8877 SetEvent(info->hevent[EV_ACK]);
8878 break;
8879
8880 default:
8881 trace("unexpected return: %04x\n", ret);
8882 assert(0);
8883 break;
8884 }
8885 }
8886 return 0;
8887 }
8888
8889 static void test_PeekMessage(void)
8890 {
8891 MSG msg;
8892 HANDLE hthread;
8893 DWORD tid, qstatus;
8894 UINT qs_all_input = QS_ALLINPUT;
8895 UINT qs_input = QS_INPUT;
8896 BOOL ret;
8897 struct peekmsg_info info;
8898
8899 info.hwnd = CreateWindowA("TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
8900 100, 100, 200, 200, 0, 0, 0, NULL);
8901 assert(info.hwnd);
8902 ShowWindow(info.hwnd, SW_SHOW);
8903 UpdateWindow(info.hwnd);
8904 SetFocus(info.hwnd);
8905
8906 info.hevent[EV_STOP] = CreateEventA(NULL, 0, 0, NULL);
8907 info.hevent[EV_SENDMSG] = CreateEventA(NULL, 0, 0, NULL);
8908 info.hevent[EV_ACK] = CreateEventA(NULL, 0, 0, NULL);
8909
8910 hthread = CreateThread(NULL, 0, send_msg_thread_2, &info, 0, &tid);
8911 WaitForSingleObject(info.hevent[EV_ACK], 10000);
8912
8913 flush_events();
8914 flush_sequence();
8915
8916 SetLastError(0xdeadbeef);
8917 qstatus = GetQueueStatus(qs_all_input);
8918 if (GetLastError() == ERROR_INVALID_FLAGS)
8919 {
8920 trace("QS_RAWINPUT not supported on this platform\n");
8921 qs_all_input &= ~QS_RAWINPUT;
8922 qs_input &= ~QS_RAWINPUT;
8923 }
8924 if (qstatus & QS_POSTMESSAGE)
8925 {
8926 while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) /* nothing */ ;
8927 qstatus = GetQueueStatus(qs_all_input);
8928 }
8929 ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
8930
8931 trace("signalling to send message\n");
8932 SetEvent(info.hevent[EV_SENDMSG]);
8933 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
8934
8935 /* pass invalid QS_xxxx flags */
8936 SetLastError(0xdeadbeef);
8937 qstatus = GetQueueStatus(0xffffffff);
8938 ok(qstatus == 0 || broken(qstatus) /* win9x */, "GetQueueStatus should fail: %08x\n", qstatus);
8939 if (!qstatus)
8940 {
8941 ok(GetLastError() == ERROR_INVALID_FLAGS, "wrong error %d\n", GetLastError());
8942 qstatus = GetQueueStatus(qs_all_input);
8943 }
8944 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE),
8945 "wrong qstatus %08x\n", qstatus);
8946
8947 msg.message = 0;
8948 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
8949 ok(!ret,
8950 "PeekMessageA should have returned FALSE instead of msg %04x\n",
8951 msg.message);
8952 ok_sequence(WmUser, "WmUser", FALSE);
8953
8954 qstatus = GetQueueStatus(qs_all_input);
8955 ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
8956
8957 keybd_event('N', 0, 0, 0);
8958 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
8959 qstatus = GetQueueStatus(qs_all_input);
8960 ok(qstatus == MAKELONG(QS_KEY, QS_KEY),
8961 "wrong qstatus %08x\n", qstatus);
8962
8963 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
8964 qstatus = GetQueueStatus(qs_all_input);
8965 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY),
8966 "wrong qstatus %08x\n", qstatus);
8967
8968 InvalidateRect(info.hwnd, NULL, FALSE);
8969 qstatus = GetQueueStatus(qs_all_input);
8970 ok(qstatus == MAKELONG(QS_PAINT, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
8971 "wrong qstatus %08x\n", qstatus);
8972
8973 trace("signalling to send message\n");
8974 SetEvent(info.hevent[EV_SENDMSG]);
8975 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
8976
8977 qstatus = GetQueueStatus(qs_all_input);
8978 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_PAINT|QS_POSTMESSAGE|QS_KEY),
8979 "wrong qstatus %08x\n", qstatus);
8980
8981 msg.message = 0;
8982 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (qs_input << 16));
8983 if (ret && msg.message == WM_CHAR)
8984 {
8985 win_skip( "PM_QS_* flags not supported in PeekMessage\n" );
8986 goto done;
8987 }
8988 ok(!ret,
8989 "PeekMessageA should have returned FALSE instead of msg %04x\n",
8990 msg.message);
8991 if (!sequence_cnt) /* nt4 doesn't fetch anything with PM_QS_* flags */
8992 {
8993 win_skip( "PM_QS_* flags not supported in PeekMessage\n" );
8994 goto done;
8995 }
8996 ok_sequence(WmUser, "WmUser", FALSE);
8997
8998 qstatus = GetQueueStatus(qs_all_input);
8999 ok(qstatus == MAKELONG(0, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
9000 "wrong qstatus %08x\n", qstatus);
9001
9002 trace("signalling to send message\n");
9003 SetEvent(info.hevent[EV_SENDMSG]);
9004 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
9005
9006 qstatus = GetQueueStatus(qs_all_input);
9007 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_PAINT|QS_POSTMESSAGE|QS_KEY),
9008 "wrong qstatus %08x\n", qstatus);
9009
9010 msg.message = 0;
9011 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE );
9012 ok(!ret,
9013 "PeekMessageA should have returned FALSE instead of msg %04x\n",
9014 msg.message);
9015 ok_sequence(WmUser, "WmUser", FALSE);
9016
9017 qstatus = GetQueueStatus(qs_all_input);
9018 ok(qstatus == MAKELONG(0, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
9019 "wrong qstatus %08x\n", qstatus);
9020
9021 msg.message = 0;
9022 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE);
9023 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
9024 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
9025 ret, msg.message, msg.wParam);
9026 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
9027
9028 qstatus = GetQueueStatus(qs_all_input);
9029 ok(qstatus == MAKELONG(0, QS_PAINT|QS_KEY),
9030 "wrong qstatus %08x\n", qstatus);
9031
9032 msg.message = 0;
9033 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE);
9034 ok(!ret,
9035 "PeekMessageA should have returned FALSE instead of msg %04x\n",
9036 msg.message);
9037 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
9038
9039 qstatus = GetQueueStatus(qs_all_input);
9040 ok(qstatus == MAKELONG(0, QS_PAINT|QS_KEY),
9041 "wrong qstatus %08x\n", qstatus);
9042
9043 msg.message = 0;
9044 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_PAINT);
9045 ok(ret && msg.message == WM_PAINT,
9046 "got %d and %04x instead of TRUE and WM_PAINT\n", ret, msg.message);
9047 DispatchMessageA(&msg);
9048 ok_sequence(WmPaint, "WmPaint", FALSE);
9049
9050 qstatus = GetQueueStatus(qs_all_input);
9051 ok(qstatus == MAKELONG(0, QS_KEY),
9052 "wrong qstatus %08x\n", qstatus);
9053
9054 msg.message = 0;
9055 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_PAINT);
9056 ok(!ret,
9057 "PeekMessageA should have returned FALSE instead of msg %04x\n",
9058 msg.message);
9059 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
9060
9061 qstatus = GetQueueStatus(qs_all_input);
9062 ok(qstatus == MAKELONG(0, QS_KEY),
9063 "wrong qstatus %08x\n", qstatus);
9064
9065 trace("signalling to send message\n");
9066 SetEvent(info.hevent[EV_SENDMSG]);
9067 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
9068
9069 qstatus = GetQueueStatus(qs_all_input);
9070 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_KEY),
9071 "wrong qstatus %08x\n", qstatus);
9072
9073 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
9074
9075 qstatus = GetQueueStatus(qs_all_input);
9076 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
9077 "wrong qstatus %08x\n", qstatus);
9078
9079 msg.message = 0;
9080 ret = PeekMessageA(&msg, 0, WM_CHAR, WM_CHAR, PM_REMOVE);
9081 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
9082 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
9083 ret, msg.message, msg.wParam);
9084 ok_sequence(WmUser, "WmUser", FALSE);
9085
9086 qstatus = GetQueueStatus(qs_all_input);
9087 ok(qstatus == MAKELONG(0, QS_KEY),
9088 "wrong qstatus %08x\n", qstatus);
9089
9090 msg.message = 0;
9091 ret = PeekMessageA(&msg, 0, WM_CHAR, WM_CHAR, PM_REMOVE);
9092 ok(!ret,
9093 "PeekMessageA should have returned FALSE instead of msg %04x\n",
9094 msg.message);
9095 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
9096
9097 qstatus = GetQueueStatus(qs_all_input);
9098 ok(qstatus == MAKELONG(0, QS_KEY),
9099 "wrong qstatus %08x\n", qstatus);
9100
9101 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
9102
9103 qstatus = GetQueueStatus(qs_all_input);
9104 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY),
9105 "wrong qstatus %08x\n", qstatus);
9106
9107 trace("signalling to send message\n");
9108 SetEvent(info.hevent[EV_SENDMSG]);
9109 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
9110
9111 qstatus = GetQueueStatus(qs_all_input);
9112 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
9113 "wrong qstatus %08x\n", qstatus);
9114
9115 msg.message = 0;
9116 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_KEY << 16));
9117 ok(!ret,
9118 "PeekMessageA should have returned FALSE instead of msg %04x\n",
9119 msg.message);
9120 ok_sequence(WmUser, "WmUser", FALSE);
9121
9122 qstatus = GetQueueStatus(qs_all_input);
9123 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE|QS_KEY),
9124 "wrong qstatus %08x\n", qstatus);
9125
9126 msg.message = 0;
9127 if (qs_all_input & QS_RAWINPUT) /* use QS_RAWINPUT only if supported */
9128 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_RAWINPUT << 16));
9129 else /* workaround for a missing QS_RAWINPUT support */
9130 ret = PeekMessageA(&msg, 0, WM_KEYDOWN, WM_KEYDOWN, PM_REMOVE);
9131 ok(ret && msg.message == WM_KEYDOWN && msg.wParam == 'N',
9132 "got %d and %04x wParam %08lx instead of TRUE and WM_KEYDOWN wParam 'N'\n",
9133 ret, msg.message, msg.wParam);
9134 ok_sequence(WmKeyDownSkippedSeq, "WmKeyDownSkippedSeq", FALSE);
9135
9136 qstatus = GetQueueStatus(qs_all_input);
9137 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE|QS_KEY),
9138 "wrong qstatus %08x\n", qstatus);
9139
9140 msg.message = 0;
9141 if (qs_all_input & QS_RAWINPUT) /* use QS_RAWINPUT only if supported */
9142 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_RAWINPUT << 16));
9143 else /* workaround for a missing QS_RAWINPUT support */
9144 ret = PeekMessageA(&msg, 0, WM_KEYUP, WM_KEYUP, PM_REMOVE);
9145 ok(ret && msg.message == WM_KEYUP && msg.wParam == 'N',
9146 "got %d and %04x wParam %08lx instead of TRUE and WM_KEYUP wParam 'N'\n",
9147 ret, msg.message, msg.wParam);
9148 ok_sequence(WmKeyUpSkippedSeq, "WmKeyUpSkippedSeq", FALSE);
9149
9150 qstatus = GetQueueStatus(qs_all_input);
9151 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
9152 "wrong qstatus %08x\n", qstatus);
9153
9154 msg.message = 0;
9155 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE);
9156 ok(!ret,
9157 "PeekMessageA should have returned FALSE instead of msg %04x\n",
9158 msg.message);
9159 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
9160
9161 qstatus = GetQueueStatus(qs_all_input);
9162 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
9163 "wrong qstatus %08x\n", qstatus);
9164
9165 msg.message = 0;
9166 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
9167 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
9168 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
9169 ret, msg.message, msg.wParam);
9170 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
9171
9172 qstatus = GetQueueStatus(qs_all_input);
9173 ok(qstatus == 0,
9174 "wrong qstatus %08x\n", qstatus);
9175
9176 msg.message = 0;
9177 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
9178 ok(!ret,
9179 "PeekMessageA should have returned FALSE instead of msg %04x\n",
9180 msg.message);
9181 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
9182
9183 qstatus = GetQueueStatus(qs_all_input);
9184 ok(qstatus == 0,
9185 "wrong qstatus %08x\n", qstatus);
9186
9187 /* test whether presence of the quit flag in the queue affects
9188 * the queue state
9189 */
9190 PostQuitMessage(0x1234abcd);
9191
9192 qstatus = GetQueueStatus(qs_all_input);
9193 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE),
9194 "wrong qstatus %08x\n", qstatus);
9195
9196 PostMessageA(info.hwnd, WM_USER, 0, 0);
9197
9198 qstatus = GetQueueStatus(qs_all_input);
9199 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE),
9200 "wrong qstatus %08x\n", qstatus);
9201
9202 msg.message = 0;
9203 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
9204 ok(ret && msg.message == WM_USER,
9205 "got %d and %04x instead of TRUE and WM_USER\n", ret, msg.message);
9206 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
9207
9208 qstatus = GetQueueStatus(qs_all_input);
9209 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
9210 "wrong qstatus %08x\n", qstatus);
9211
9212 msg.message = 0;
9213 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
9214 ok(ret && msg.message == WM_QUIT,
9215 "got %d and %04x instead of TRUE and WM_QUIT\n", ret, msg.message);
9216 ok(msg.wParam == 0x1234abcd, "got wParam %08lx instead of 0x1234abcd\n", msg.wParam);
9217 ok(msg.lParam == 0, "got lParam %08lx instead of 0\n", msg.lParam);
9218 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
9219
9220 qstatus = GetQueueStatus(qs_all_input);
9221 todo_wine {
9222 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
9223 "wrong qstatus %08x\n", qstatus);
9224 }
9225
9226 msg.message = 0;
9227 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
9228 ok(!ret,
9229 "PeekMessageA should have returned FALSE instead of msg %04x\n",
9230 msg.message);
9231 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
9232
9233 qstatus = GetQueueStatus(qs_all_input);
9234 ok(qstatus == 0,
9235 "wrong qstatus %08x\n", qstatus);
9236
9237 /* some GetMessage tests */
9238
9239 keybd_event('N', 0, 0, 0);
9240 qstatus = GetQueueStatus(qs_all_input);
9241 ok(qstatus == MAKELONG(QS_KEY, QS_KEY), "wrong qstatus %08x\n", qstatus);
9242
9243 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
9244 qstatus = GetQueueStatus(qs_all_input);
9245 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY), "wrong qstatus %08x\n", qstatus);
9246
9247 if (qstatus)
9248 {
9249 ret = GetMessageA( &msg, 0, 0, 0 );
9250 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
9251 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
9252 ret, msg.message, msg.wParam);
9253 qstatus = GetQueueStatus(qs_all_input);
9254 ok(qstatus == MAKELONG(0, QS_KEY), "wrong qstatus %08x\n", qstatus);
9255 }
9256
9257 if (qstatus)
9258 {
9259 ret = GetMessageA( &msg, 0, 0, 0 );
9260 ok(ret && msg.message == WM_KEYDOWN && msg.wParam == 'N',
9261 "got %d and %04x wParam %08lx instead of TRUE and WM_KEYDOWN wParam 'N'\n",
9262 ret, msg.message, msg.wParam);
9263 ok_sequence(WmKeyDownSkippedSeq, "WmKeyDownSkippedSeq", FALSE);
9264 qstatus = GetQueueStatus(qs_all_input);
9265 ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
9266 }
9267
9268 keybd_event('N', 0, 0, 0);
9269 qstatus = GetQueueStatus(qs_all_input);
9270 ok(qstatus == MAKELONG(QS_KEY, QS_KEY), "wrong qstatus %08x\n", qstatus);
9271
9272 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
9273 qstatus = GetQueueStatus(qs_all_input);
9274 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY), "wrong qstatus %08x\n", qstatus);
9275
9276 if (qstatus & (QS_KEY << 16))
9277 {
9278 ret = GetMessageA( &msg, 0, WM_KEYDOWN, WM_KEYUP );
9279 ok(ret && msg.message == WM_KEYDOWN && msg.wParam == 'N',
9280 "got %d and %04x wParam %08lx instead of TRUE and WM_KEYDOWN wParam 'N'\n",
9281 ret, msg.message, msg.wParam);
9282 ok_sequence(WmKeyDownWasDownSkippedSeq, "WmKeyDownWasDownSkippedSeq", FALSE);
9283 qstatus = GetQueueStatus(qs_all_input);
9284 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE), "wrong qstatus %08x\n", qstatus);
9285 }
9286
9287 if (qstatus)
9288 {
9289 ret = GetMessageA( &msg, 0, WM_CHAR, WM_CHAR );
9290 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
9291 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
9292 ret, msg.message, msg.wParam);
9293 qstatus = GetQueueStatus(qs_all_input);
9294 ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
9295 }
9296
9297 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
9298 qstatus = GetQueueStatus(qs_all_input);
9299 ok(qstatus == MAKELONG(QS_KEY, QS_KEY), "wrong qstatus %08x\n", qstatus);
9300
9301 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
9302 qstatus = GetQueueStatus(qs_all_input);
9303 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY), "wrong qstatus %08x\n", qstatus);
9304
9305 trace("signalling to send message\n");
9306 SetEvent(info.hevent[EV_SENDMSG]);
9307 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
9308 qstatus = GetQueueStatus(qs_all_input);
9309 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
9310 "wrong qstatus %08x\n", qstatus);
9311
9312 if (qstatus & (QS_KEY << 16))
9313 {
9314 ret = GetMessageA( &msg, 0, WM_KEYDOWN, WM_KEYUP );
9315 ok(ret && msg.message == WM_KEYUP && msg.wParam == 'N',
9316 "got %d and %04x wParam %08lx instead of TRUE and WM_KEYDOWN wParam 'N'\n",
9317 ret, msg.message, msg.wParam);
9318 ok_sequence(WmUserKeyUpSkippedSeq, "WmUserKeyUpSkippedSeq", FALSE);
9319 qstatus = GetQueueStatus(qs_all_input);
9320 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE), "wrong qstatus %08x\n", qstatus);
9321 }
9322
9323 if (qstatus)
9324 {
9325 ret = GetMessageA( &msg, 0, WM_CHAR, WM_CHAR );
9326 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
9327 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
9328 ret, msg.message, msg.wParam);
9329 qstatus = GetQueueStatus(qs_all_input);
9330 ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
9331 }
9332 done:
9333 trace("signalling to exit\n");
9334 SetEvent(info.hevent[EV_STOP]);
9335
9336 WaitForSingleObject(hthread, INFINITE);
9337
9338 CloseHandle(hthread);
9339 CloseHandle(info.hevent[0]);
9340 CloseHandle(info.hevent[1]);
9341 CloseHandle(info.hevent[2]);
9342
9343 DestroyWindow(info.hwnd);
9344 }
9345
9346 static void wait_move_event(HWND hwnd, int x, int y)
9347 {
9348 MSG msg;
9349 DWORD time;
9350 BOOL ret;
9351 int go = 0;
9352
9353 time = GetTickCount();
9354 while (GetTickCount() - time < 200 && !go) {
9355 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
9356 go = ret && msg.pt.x > x && msg.pt.y > y;
9357 if (!ret) MsgWaitForMultipleObjects( 0, NULL, FALSE, GetTickCount() - time, QS_ALLINPUT );
9358 }
9359 }
9360
9361 #define STEP 5
9362 static void test_PeekMessage2(void)
9363 {
9364 HWND hwnd;
9365 BOOL ret;
9366 MSG msg;
9367 UINT message;
9368 DWORD time1, time2, time3;
9369 int x1, y1, x2, y2, x3, y3;
9370 POINT pos;
9371
9372 time1 = time2 = time3 = 0;
9373 x1 = y1 = x2 = y2 = x3 = y3 = 0;
9374
9375 /* Initialise window and make sure it is ready for events */
9376 hwnd = CreateWindow("TestWindowClass", "PeekMessage2", WS_OVERLAPPEDWINDOW,
9377 10, 10, 800, 800, NULL, NULL, NULL, NULL);
9378 assert(hwnd);
9379 trace("Window for test_PeekMessage2 %p\n", hwnd);
9380 ShowWindow(hwnd, SW_SHOW);
9381 UpdateWindow(hwnd);
9382 SetFocus(hwnd);
9383 GetCursorPos(&pos);
9384 SetCursorPos(100, 100);
9385 mouse_event(MOUSEEVENTF_MOVE, -STEP, -STEP, 0, 0);
9386 flush_events();
9387
9388 /* Do initial mousemove, wait until we can see it
9389 and then do our test peek with PM_NOREMOVE. */
9390 mouse_event(MOUSEEVENTF_MOVE, STEP, STEP, 0, 0);
9391 wait_move_event(hwnd, 100-STEP, 100-STEP);
9392
9393 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
9394 ok(ret, "no message available\n");
9395 if (ret) {
9396 trace("1st move event: %04x %x %d %d\n", msg.message, msg.time, msg.pt.x, msg.pt.y);
9397 message = msg.message;
9398 time1 = msg.time;
9399 x1 = msg.pt.x;
9400 y1 = msg.pt.y;
9401 ok(message == WM_MOUSEMOVE, "message not WM_MOUSEMOVE, %04x instead\n", message);
9402 }
9403
9404 /* Allow time to advance a bit, and then simulate the user moving their
9405 * mouse around. After that we peek again with PM_NOREMOVE.
9406 * Although the previous mousemove message was never removed, the
9407 * mousemove we now peek should reflect the recent mouse movements
9408 * because the input queue will merge the move events. */
9409 Sleep(100);
9410 mouse_event(MOUSEEVENTF_MOVE, STEP, STEP, 0, 0);
9411 wait_move_event(hwnd, x1, y1);
9412
9413 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
9414 ok(ret, "no message available\n");
9415 if (ret) {
9416 trace("2nd move event: %04x %x %d %d\n", msg.message, msg.time, msg.pt.x, msg.pt.y);
9417 message = msg.message;
9418 time2 = msg.time;
9419 x2 = msg.pt.x;
9420 y2 = msg.pt.y;
9421 ok(message == WM_MOUSEMOVE, "message not WM_MOUSEMOVE, %04x instead\n", message);
9422 ok(time2 > time1, "message time not advanced: %x %x\n", time1, time2);
9423 ok(x2 != x1 && y2 != y1, "coords not changed: (%d %d) (%d %d)\n", x1, y1, x2, y2);
9424 }
9425
9426 /* Have another go, to drive the point home */
9427 Sleep(100);
9428 mouse_event(MOUSEEVENTF_MOVE, STEP, STEP, 0, 0);
9429 wait_move_event(hwnd, x2, y2);
9430
9431 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
9432 ok(ret, "no message available\n");
9433 if (ret) {
9434 trace("3rd move event: %04x %x %d %d\n", msg.message, msg.time, msg.pt.x, msg.pt.y);
9435 message = msg.message;
9436 time3 = msg.time;
9437 x3 = msg.pt.x;
9438 y3 = msg.pt.y;
9439 ok(message == WM_MOUSEMOVE, "message not WM_MOUSEMOVE, %04x instead\n", message);
9440 ok(time3 > time2, "message time not advanced: %x %x\n", time2, time3);
9441 ok(x3 != x2 && y3 != y2, "coords not changed: (%d %d) (%d %d)\n", x2, y2, x3, y3);
9442 }
9443
9444 DestroyWindow(hwnd);
9445 SetCursorPos(pos.x, pos.y);
9446 flush_events();
9447 }
9448
9449 static void test_quit_message(void)
9450 {
9451 MSG msg;
9452 BOOL ret;
9453
9454 /* test using PostQuitMessage */
9455 flush_events();
9456 PostQuitMessage(0xbeef);
9457
9458 ret = PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
9459 ok(ret, "PeekMessage failed with error %d\n", GetLastError());
9460 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
9461 ok(msg.wParam == 0xbeef, "wParam was 0x%lx instead of 0xbeef\n", msg.wParam);
9462
9463 ret = PostThreadMessage(GetCurrentThreadId(), WM_USER, 0, 0);
9464 ok(ret, "PostMessage failed with error %d\n", GetLastError());
9465
9466 ret = GetMessage(&msg, NULL, 0, 0);
9467 ok(ret > 0, "GetMessage failed with error %d\n", GetLastError());
9468 ok(msg.message == WM_USER, "Received message 0x%04x instead of WM_USER\n", msg.message);
9469
9470 /* note: WM_QUIT message received after WM_USER message */
9471 ret = GetMessage(&msg, NULL, 0, 0);
9472 ok(!ret, "GetMessage return %d with error %d instead of FALSE\n", ret, GetLastError());
9473 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
9474 ok(msg.wParam == 0xbeef, "wParam was 0x%lx instead of 0xbeef\n", msg.wParam);
9475
9476 ret = PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
9477 ok( !ret || msg.message != WM_QUIT, "Received WM_QUIT again\n" );
9478
9479 /* now test with PostThreadMessage - different behaviour! */
9480 PostThreadMessage(GetCurrentThreadId(), WM_QUIT, 0xdead, 0);
9481
9482 ret = PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
9483 ok(ret, "PeekMessage failed with error %d\n", GetLastError());
9484 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
9485 ok(msg.wParam == 0xdead, "wParam was 0x%lx instead of 0xdead\n", msg.wParam);
9486
9487 ret = PostThreadMessage(GetCurrentThreadId(), WM_USER, 0, 0);
9488 ok(ret, "PostMessage failed with error %d\n", GetLastError());
9489
9490 /* note: we receive the WM_QUIT message first this time */
9491 ret = GetMessage(&msg, NULL, 0, 0);
9492 ok(!ret, "GetMessage return %d with error %d instead of FALSE\n", ret, GetLastError());
9493 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
9494 ok(msg.wParam == 0xdead, "wParam was 0x%lx instead of 0xdead\n", msg.wParam);
9495
9496 ret = GetMessage(&msg, NULL, 0, 0);
9497 ok(ret > 0, "GetMessage failed with error %d\n", GetLastError());
9498 ok(msg.message == WM_USER, "Received message 0x%04x instead of WM_USER\n", msg.message);
9499 }
9500
9501 static const struct message WmMouseHoverSeq[] = {
9502 { WM_MOUSEACTIVATE, sent|optional }, /* we can get those when moving the mouse in focus-follow-mouse mode under X11 */
9503 { WM_MOUSEACTIVATE, sent|optional },
9504 { WM_TIMER, sent|optional }, /* XP sends it */
9505 { WM_SYSTIMER, sent },
9506 { WM_MOUSEHOVER, sent|wparam, 0 },
9507 { 0 }
9508 };
9509
9510 static void pump_msg_loop_timeout(DWORD timeout, BOOL inject_mouse_move)
9511 {
9512 MSG msg;
9513 DWORD start_ticks, end_ticks;
9514
9515 start_ticks = GetTickCount();
9516 /* add some deviation (50%) to cover not expected delays */
9517 start_ticks += timeout / 2;
9518
9519 do
9520 {
9521 while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
9522 {
9523 /* Timer proc messages are not dispatched to the window proc,
9524 * and therefore not logged.
9525 */
9526 if (msg.message == WM_TIMER || msg.message == WM_SYSTIMER)
9527 {
9528 struct recvd_message s_msg;
9529
9530 s_msg.hwnd = msg.hwnd;
9531 s_msg.message = msg.message;
9532 s_msg.flags = sent|wparam|lparam;
9533 s_msg.wParam = msg.wParam;
9534 s_msg.lParam = msg.lParam;
9535 s_msg.descr = "msg_loop";
9536 add_message(&s_msg);
9537 }
9538 DispatchMessage(&msg);
9539 }
9540
9541 end_ticks = GetTickCount();
9542
9543 /* inject WM_MOUSEMOVE to see how it changes tracking */
9544 if (inject_mouse_move && start_ticks + timeout / 2 >= end_ticks)
9545 {
9546 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
9547 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
9548
9549 inject_mouse_move = FALSE;
9550 }
9551 } while (start_ticks + timeout >= end_ticks);
9552 }
9553
9554 static void test_TrackMouseEvent(void)
9555 {
9556 TRACKMOUSEEVENT tme;
9557 BOOL ret;
9558 HWND hwnd, hchild;
9559 RECT rc_parent, rc_child;
9560 UINT default_hover_time, hover_width = 0, hover_height = 0;
9561
9562 #define track_hover(track_hwnd, track_hover_time) \
9563 tme.cbSize = sizeof(tme); \
9564 tme.dwFlags = TME_HOVER; \
9565 tme.hwndTrack = track_hwnd; \
9566 tme.dwHoverTime = track_hover_time; \
9567 SetLastError(0xdeadbeef); \
9568 ret = pTrackMouseEvent(&tme); \
9569 ok(ret, "TrackMouseEvent(TME_HOVER) error %d\n", GetLastError())
9570
9571 #define track_query(expected_track_flags, expected_track_hwnd, expected_hover_time) \
9572 tme.cbSize = sizeof(tme); \
9573 tme.dwFlags = TME_QUERY; \
9574 tme.hwndTrack = (HWND)0xdeadbeef; \
9575 tme.dwHoverTime = 0xdeadbeef; \
9576 SetLastError(0xdeadbeef); \
9577 ret = pTrackMouseEvent(&tme); \
9578 ok(ret, "TrackMouseEvent(TME_QUERY) error %d\n", GetLastError());\
9579 ok(tme.cbSize == sizeof(tme), "wrong tme.cbSize %u\n", tme.cbSize); \
9580 ok(tme.dwFlags == (expected_track_flags), \
9581 "wrong tme.dwFlags %08x, expected %08x\n", tme.dwFlags, (expected_track_flags)); \
9582 ok(tme.hwndTrack == (expected_track_hwnd), \
9583 "wrong tme.hwndTrack %p, expected %p\n", tme.hwndTrack, (expected_track_hwnd)); \
9584 ok(tme.dwHoverTime == (expected_hover_time), \
9585 "wrong tme.dwHoverTime %u, expected %u\n", tme.dwHoverTime, (expected_hover_time))
9586
9587 #define track_hover_cancel(track_hwnd) \
9588 tme.cbSize = sizeof(tme); \
9589 tme.dwFlags = TME_HOVER | TME_CANCEL; \
9590 tme.hwndTrack = track_hwnd; \
9591 tme.dwHoverTime = 0xdeadbeef; \
9592 SetLastError(0xdeadbeef); \
9593 ret = pTrackMouseEvent(&tme); \
9594 ok(ret, "TrackMouseEvent(TME_HOVER | TME_CANCEL) error %d\n", GetLastError())
9595
9596 default_hover_time = 0xdeadbeef;
9597 SetLastError(0xdeadbeef);
9598 ret = SystemParametersInfo(SPI_GETMOUSEHOVERTIME, 0, &default_hover_time, 0);
9599 ok(ret || broken(GetLastError() == 0xdeadbeef), /* win9x */
9600 "SystemParametersInfo(SPI_GETMOUSEHOVERTIME) error %u\n", GetLastError());
9601 if (!ret) default_hover_time = 400;
9602 trace("SPI_GETMOUSEHOVERTIME returned %u ms\n", default_hover_time);
9603
9604 SetLastError(0xdeadbeef);
9605 ret = SystemParametersInfo(SPI_GETMOUSEHOVERWIDTH, 0, &hover_width, 0);
9606 ok(ret || broken(GetLastError() == 0xdeadbeef), /* win9x */
9607 "SystemParametersInfo(SPI_GETMOUSEHOVERWIDTH) error %u\n", GetLastError());
9608 if (!ret) hover_width = 4;
9609 SetLastError(0xdeadbeef);
9610 ret = SystemParametersInfo(SPI_GETMOUSEHOVERHEIGHT, 0, &hover_height, 0);
9611 ok(ret || broken(GetLastError() == 0xdeadbeef), /* win9x */
9612 "SystemParametersInfo(SPI_GETMOUSEHOVERHEIGHT) error %u\n", GetLastError());
9613 if (!ret) hover_height = 4;
9614 trace("hover rect is %u x %d\n", hover_width, hover_height);
9615
9616 hwnd = CreateWindowEx(0, "TestWindowClass", NULL,
9617 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
9618 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
9619 NULL, NULL, 0);
9620 assert(hwnd);
9621
9622 hchild = CreateWindowEx(0, "TestWindowClass", NULL,
9623 WS_CHILD | WS_BORDER | WS_VISIBLE,
9624 50, 50, 200, 200, hwnd,
9625 NULL, NULL, 0);
9626 assert(hchild);
9627
9628 SetWindowPos( hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE );
9629 flush_events();
9630 flush_sequence();
9631
9632 tme.cbSize = 0;
9633 tme.dwFlags = TME_QUERY;
9634 tme.hwndTrack = (HWND)0xdeadbeef;
9635 tme.dwHoverTime = 0xdeadbeef;
9636 SetLastError(0xdeadbeef);
9637 ret = pTrackMouseEvent(&tme);
9638 ok(!ret, "TrackMouseEvent should fail\n");
9639 ok(GetLastError() == ERROR_INVALID_PARAMETER || broken(GetLastError() == 0xdeadbeef),
9640 "not expected error %u\n", GetLastError());
9641
9642 tme.cbSize = sizeof(tme);
9643 tme.dwFlags = TME_HOVER;
9644 tme.hwndTrack = (HWND)0xdeadbeef;
9645 tme.dwHoverTime = 0xdeadbeef;
9646 SetLastError(0xdeadbeef);
9647 ret = pTrackMouseEvent(&tme);
9648 ok(!ret, "TrackMouseEvent should fail\n");
9649 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || broken(GetLastError() == 0xdeadbeef),
9650 "not expected error %u\n", GetLastError());
9651
9652 tme.cbSize = sizeof(tme);
9653 tme.dwFlags = TME_HOVER | TME_CANCEL;
9654 tme.hwndTrack = (HWND)0xdeadbeef;
9655 tme.dwHoverTime = 0xdeadbeef;
9656 SetLastError(0xdeadbeef);
9657 ret = pTrackMouseEvent(&tme);
9658 ok(!ret, "TrackMouseEvent should fail\n");
9659 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || broken(GetLastError() == 0xdeadbeef),
9660 "not expected error %u\n", GetLastError());
9661
9662 GetWindowRect(hwnd, &rc_parent);
9663 GetWindowRect(hchild, &rc_child);
9664 SetCursorPos(rc_child.left - 10, rc_child.top - 10);
9665
9666 /* Process messages so that the system updates its internal current
9667 * window and hittest, otherwise TrackMouseEvent calls don't have any
9668 * effect.
9669 */
9670 flush_events();
9671 flush_sequence();
9672
9673 track_query(0, NULL, 0);
9674 track_hover(hchild, 0);
9675 track_query(0, NULL, 0);
9676
9677 flush_events();
9678 flush_sequence();
9679
9680 track_hover(hwnd, 0);
9681 tme.cbSize = sizeof(tme);
9682 tme.dwFlags = TME_QUERY;
9683 tme.hwndTrack = (HWND)0xdeadbeef;
9684 tme.dwHoverTime = 0xdeadbeef;
9685 SetLastError(0xdeadbeef);
9686 ret = pTrackMouseEvent(&tme);
9687 ok(ret, "TrackMouseEvent(TME_QUERY) error %d\n", GetLastError());
9688 ok(tme.cbSize == sizeof(tme), "wrong tme.cbSize %u\n", tme.cbSize);
9689 if (!tme.dwFlags)
9690 {
9691 skip( "Cursor not inside window, skipping TrackMouseEvent tests\n" );
9692 DestroyWindow( hwnd );
9693 return;
9694 }
9695 ok(tme.dwFlags == TME_HOVER, "wrong tme.dwFlags %08x, expected TME_HOVER\n", tme.dwFlags);
9696 ok(tme.hwndTrack == hwnd, "wrong tme.hwndTrack %p, expected %p\n", tme.hwndTrack, hwnd);
9697 ok(tme.dwHoverTime == default_hover_time, "wrong tme.dwHoverTime %u, expected %u\n",
9698 tme.dwHoverTime, default_hover_time);
9699
9700 pump_msg_loop_timeout(default_hover_time, FALSE);
9701 ok_sequence(WmMouseHoverSeq, "WmMouseHoverSeq", FALSE);
9702
9703 track_query(0, NULL, 0);
9704
9705 track_hover(hwnd, HOVER_DEFAULT);
9706 track_query(TME_HOVER, hwnd, default_hover_time);
9707
9708 Sleep(default_hover_time / 2);
9709 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
9710 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
9711
9712 track_query(TME_HOVER, hwnd, default_hover_time);
9713
9714 pump_msg_loop_timeout(default_hover_time, FALSE);
9715 ok_sequence(WmMouseHoverSeq, "WmMouseHoverSeq", FALSE);
9716
9717 track_query(0, NULL, 0);
9718
9719 track_hover(hwnd, HOVER_DEFAULT);
9720 track_query(TME_HOVER, hwnd, default_hover_time);
9721
9722 pump_msg_loop_timeout(default_hover_time, TRUE);
9723 ok_sequence(WmMouseHoverSeq, "WmMouseHoverSeq", FALSE);
9724
9725 track_query(0, NULL, 0);
9726
9727 track_hover(hwnd, HOVER_DEFAULT);
9728 track_query(TME_HOVER, hwnd, default_hover_time);
9729 track_hover_cancel(hwnd);
9730
9731 DestroyWindow(hwnd);
9732
9733 #undef track_hover
9734 #undef track_query
9735 #undef track_hover_cancel
9736 }
9737
9738
9739 static const struct message WmSetWindowRgn[] = {
9740 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
9741 { WM_NCCALCSIZE, sent|wparam, 1 },
9742 { WM_NCPAINT, sent|optional }, /* wparam != 1 */
9743 { WM_GETTEXT, sent|defwinproc|optional },
9744 { WM_ERASEBKGND, sent|optional },
9745 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
9746 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
9747 { 0 }
9748 };
9749
9750 static const struct message WmSetWindowRgn_no_redraw[] = {
9751 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW },
9752 { WM_NCCALCSIZE, sent|wparam, 1 },
9753 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW },
9754 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
9755 { 0 }
9756 };
9757
9758 static const struct message WmSetWindowRgn_clear[] = {
9759 { WM_WINDOWPOSCHANGING, sent/*|wparam*/, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE/*|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE only on some Windows versions */ },
9760 { WM_NCCALCSIZE, sent|wparam, 1 },
9761 { WM_NCPAINT, sent|optional },
9762 { WM_GETTEXT, sent|defwinproc|optional },
9763 { WM_ERASEBKGND, sent|optional }, /* FIXME: remove optional once Wine is fixed */
9764 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
9765 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
9766 { WM_NCPAINT, sent|optional },
9767 { WM_GETTEXT, sent|defwinproc|optional },
9768 { WM_ERASEBKGND, sent|optional },
9769 { WM_WINDOWPOSCHANGING, sent|optional },
9770 { WM_NCCALCSIZE, sent|optional|wparam, 1 },
9771 { WM_NCPAINT, sent|optional },
9772 { WM_GETTEXT, sent|defwinproc|optional },
9773 { WM_ERASEBKGND, sent|optional },
9774 { WM_WINDOWPOSCHANGED, sent|optional|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
9775 { WM_NCCALCSIZE, sent|optional|wparam, 1 },
9776 { WM_NCPAINT, sent|optional },
9777 { WM_GETTEXT, sent|defwinproc|optional },
9778 { WM_ERASEBKGND, sent|optional },
9779 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
9780 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
9781 { 0 }
9782 };
9783
9784 static void test_SetWindowRgn(void)
9785 {
9786 HRGN hrgn;
9787 HWND hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
9788 100, 100, 200, 200, 0, 0, 0, NULL);
9789 ok( hwnd != 0, "Failed to create overlapped window\n" );
9790
9791 ShowWindow( hwnd, SW_SHOW );
9792 UpdateWindow( hwnd );
9793 flush_events();
9794 flush_sequence();
9795
9796 trace("testing SetWindowRgn\n");
9797 hrgn = CreateRectRgn( 0, 0, 150, 150 );
9798 SetWindowRgn( hwnd, hrgn, TRUE );
9799 ok_sequence( WmSetWindowRgn, "WmSetWindowRgn", FALSE );
9800
9801 hrgn = CreateRectRgn( 30, 30, 160, 160 );
9802 SetWindowRgn( hwnd, hrgn, FALSE );
9803 ok_sequence( WmSetWindowRgn_no_redraw, "WmSetWindowRgn_no_redraw", FALSE );
9804
9805 hrgn = CreateRectRgn( 0, 0, 180, 180 );
9806 SetWindowRgn( hwnd, hrgn, TRUE );
9807 ok_sequence( WmSetWindowRgn, "WmSetWindowRgn2", FALSE );
9808
9809 SetWindowRgn( hwnd, 0, TRUE );
9810 ok_sequence( WmSetWindowRgn_clear, "WmSetWindowRgn_clear", FALSE );
9811
9812 DestroyWindow( hwnd );
9813 }
9814
9815 /*************************** ShowWindow() test ******************************/
9816 static const struct message WmShowNormal[] = {
9817 { WM_SHOWWINDOW, sent|wparam, 1 },
9818 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
9819 { HCBT_ACTIVATE, hook },
9820 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2003 doesn't send it */
9821 { HCBT_SETFOCUS, hook },
9822 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
9823 { 0 }
9824 };
9825 static const struct message WmShow[] = {
9826 { WM_SHOWWINDOW, sent|wparam, 1 },
9827 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
9828 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
9829 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
9830 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
9831 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
9832 { 0 }
9833 };
9834 static const struct message WmShowNoActivate_1[] = {
9835 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNOACTIVATE },
9836 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
9837 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
9838 { WM_MOVE, sent|defwinproc|optional },
9839 { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
9840 { 0 }
9841 };
9842 static const struct message WmShowNoActivate_2[] = {
9843 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNOACTIVATE },
9844 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9845 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9846 { WM_MOVE, sent|defwinproc },
9847 { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
9848 { HCBT_SETFOCUS, hook|optional },
9849 { HCBT_ACTIVATE, hook|optional }, /* win2003 doesn't send it */
9850 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2003 doesn't send it */
9851 { HCBT_SETFOCUS, hook|optional }, /* win2003 doesn't send it */
9852 { 0 }
9853 };
9854 static const struct message WmShowNA_1[] = {
9855 { WM_SHOWWINDOW, sent|wparam, 1 },
9856 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
9857 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
9858 { 0 }
9859 };
9860 static const struct message WmShowNA_2[] = {
9861 { WM_SHOWWINDOW, sent|wparam, 1 },
9862 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
9863 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
9864 { 0 }
9865 };
9866 static const struct message WmRestore_1[] = {
9867 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
9868 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9869 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
9870 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
9871 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
9872 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9873 { WM_MOVE, sent|defwinproc },
9874 { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
9875 { HCBT_SETFOCUS, hook|optional }, /* win2000 sends it */
9876 { 0 }
9877 };
9878 static const struct message WmRestore_2[] = {
9879 { WM_SHOWWINDOW, sent|wparam, 1 },
9880 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
9881 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
9882 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
9883 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
9884 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
9885 { 0 }
9886 };
9887 static const struct message WmRestore_3[] = {
9888 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
9889 { WM_GETMINMAXINFO, sent },
9890 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9891 { HCBT_ACTIVATE, hook|optional }, /* win2003 doesn't send it */
9892 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2003 doesn't send it */
9893 { HCBT_SETFOCUS, hook|optional }, /* win2003 doesn't send it */
9894 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9895 { WM_MOVE, sent|defwinproc },
9896 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
9897 { HCBT_SETFOCUS, hook|optional }, /* win2003 sends it */
9898 { 0 }
9899 };
9900 static const struct message WmRestore_4[] = {
9901 { HCBT_MINMAX, hook|lparam|optional, 0, SW_RESTORE },
9902 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
9903 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
9904 { WM_MOVE, sent|defwinproc|optional },
9905 { WM_SIZE, sent|wparam|defwinproc|optional, SIZE_RESTORED },
9906 { 0 }
9907 };
9908 static const struct message WmRestore_5[] = {
9909 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNORMAL },
9910 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
9911 { HCBT_ACTIVATE, hook|optional },
9912 { HCBT_SETFOCUS, hook|optional },
9913 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
9914 { WM_MOVE, sent|defwinproc|optional },
9915 { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
9916 { 0 }
9917 };
9918 static const struct message WmHide_1[] = {
9919 { WM_SHOWWINDOW, sent|wparam, 0 },
9920 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
9921 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
9922 { HCBT_ACTIVATE, hook|optional },
9923 { HCBT_SETFOCUS, hook|optional }, /* win2000 sends it */
9924 { 0 }
9925 };
9926 static const struct message WmHide_2[] = {
9927 { WM_SHOWWINDOW, sent|wparam, 0 },
9928 { WM_WINDOWPOSCHANGING, sent /*|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE*/ }, /* win2000 doesn't add SWP_NOACTIVATE */
9929 { WM_WINDOWPOSCHANGED, sent /*|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ }, /* win2000 doesn't add SWP_NOACTIVATE */
9930 { HCBT_ACTIVATE, hook|optional },
9931 { 0 }
9932 };
9933 static const struct message WmHide_3[] = {
9934 { WM_SHOWWINDOW, sent|wparam, 0 },
9935 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
9936 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
9937 { HCBT_SETFOCUS, hook|optional },
9938 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
9939 { 0 }
9940 };
9941 static const struct message WmShowMinimized_1[] = {
9942 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
9943 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9944 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
9945 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
9946 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9947 { WM_MOVE, sent|defwinproc },
9948 { WM_SIZE, sent|wparam|defwinproc, SIZE_MINIMIZED },
9949 { 0 }
9950 };
9951 static const struct message WmMinimize_1[] = {
9952 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
9953 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
9954 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
9955 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9956 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9957 { WM_MOVE, sent|defwinproc },
9958 { WM_SIZE, sent|wparam|defwinproc, SIZE_MINIMIZED },
9959 { 0 }
9960 };
9961 static const struct message WmMinimize_2[] = {
9962 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
9963 { HCBT_SETFOCUS, hook|optional },
9964 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9965 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9966 { WM_MOVE, sent|defwinproc },
9967 { WM_SIZE, sent|wparam|defwinproc, SIZE_MINIMIZED },
9968 { 0 }
9969 };
9970 static const struct message WmMinimize_3[] = {
9971 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
9972 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9973 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9974 { WM_MOVE, sent|defwinproc },
9975 { WM_SIZE, sent|wparam|defwinproc, SIZE_MINIMIZED },
9976 { 0 }
9977 };
9978 static const struct message WmShowMinNoActivate[] = {
9979 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
9980 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
9981 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
9982 { 0 }
9983 };
9984 static const struct message WmMinMax_1[] = {
9985 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
9986 { 0 }
9987 };
9988 static const struct message WmMinMax_2[] = {
9989 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
9990 { WM_GETMINMAXINFO, sent|optional },
9991 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED },
9992 { HCBT_ACTIVATE, hook|optional },
9993 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
9994 { HCBT_SETFOCUS, hook|optional },
9995 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
9996 { WM_MOVE, sent|defwinproc|optional },
9997 { WM_SIZE, sent|wparam|defwinproc|optional, SIZE_MAXIMIZED },
9998 { HCBT_SETFOCUS, hook|optional },
9999 { 0 }
10000 };
10001 static const struct message WmMinMax_3[] = {
10002 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
10003 { HCBT_SETFOCUS, hook|optional },
10004 { 0 }
10005 };
10006 static const struct message WmMinMax_4[] = {
10007 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
10008 { 0 }
10009 };
10010 static const struct message WmShowMaximized_1[] = {
10011 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
10012 { WM_GETMINMAXINFO, sent },
10013 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
10014 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
10015 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
10016 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
10017 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
10018 { WM_MOVE, sent|defwinproc },
10019 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
10020 { HCBT_SETFOCUS, hook|optional }, /* win2003 sends it */
10021 { 0 }
10022 };
10023 static const struct message WmShowMaximized_2[] = {
10024 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
10025 { WM_GETMINMAXINFO, sent },
10026 { WM_WINDOWPOSCHANGING, sent|optional },
10027 { HCBT_ACTIVATE, hook|optional },
10028 { WM_WINDOWPOSCHANGED, sent|optional },
10029 { WM_MOVE, sent|optional }, /* Win9x doesn't send it */
10030 { WM_SIZE, sent|wparam|optional, SIZE_MAXIMIZED }, /* Win9x doesn't send it */
10031 { WM_WINDOWPOSCHANGING, sent|optional },
10032 { HCBT_SETFOCUS, hook|optional },
10033 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
10034 { WM_MOVE, sent|defwinproc },
10035 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
10036 { HCBT_SETFOCUS, hook|optional },
10037 { 0 }
10038 };
10039 static const struct message WmShowMaximized_3[] = {
10040 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
10041 { WM_GETMINMAXINFO, sent },
10042 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
10043 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
10044 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
10045 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
10046 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
10047 { WM_MOVE, sent|defwinproc|optional },
10048 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
10049 { 0 }
10050 };
10051
10052 static void test_ShowWindow(void)
10053 {
10054 /* ShowWindow commands in random order */
10055 static const struct
10056 {
10057 INT cmd; /* ShowWindow command */
10058 LPARAM ret; /* ShowWindow return value */
10059 DWORD style; /* window style after the command */
10060 const struct message *msg; /* message sequence the command produces */
10061 BOOL todo_msg; /* message sequence doesn't match what Wine does */
10062 } sw[] =
10063 {
10064 /* 1 */ { SW_SHOWNORMAL, FALSE, WS_VISIBLE, WmShowNormal, FALSE },
10065 /* 2 */ { SW_SHOWNORMAL, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
10066 /* 3 */ { SW_HIDE, TRUE, 0, WmHide_1, FALSE },
10067 /* 4 */ { SW_HIDE, FALSE, 0, WmEmptySeq, FALSE },
10068 /* 5 */ { SW_SHOWMINIMIZED, FALSE, WS_VISIBLE|WS_MINIMIZE, WmShowMinimized_1, FALSE },
10069 /* 6 */ { SW_SHOWMINIMIZED, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_1, FALSE },
10070 /* 7 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_1, FALSE },
10071 /* 8 */ { SW_HIDE, FALSE, WS_MINIMIZE, WmEmptySeq, FALSE },
10072 /* 9 */ { SW_SHOWMAXIMIZED, FALSE, WS_VISIBLE|WS_MAXIMIZE, WmShowMaximized_1, FALSE },
10073 /* 10 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmMinMax_2, FALSE },
10074 /* 11 */ { SW_HIDE, TRUE, WS_MAXIMIZE, WmHide_1, FALSE },
10075 /* 12 */ { SW_HIDE, FALSE, WS_MAXIMIZE, WmEmptySeq, FALSE },
10076 /* 13 */ { SW_SHOWNOACTIVATE, FALSE, WS_VISIBLE, WmShowNoActivate_1, FALSE },
10077 /* 14 */ { SW_SHOWNOACTIVATE, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
10078 /* 15 */ { SW_HIDE, TRUE, 0, WmHide_2, FALSE },
10079 /* 16 */ { SW_HIDE, FALSE, 0, WmEmptySeq, FALSE },
10080 /* 17 */ { SW_SHOW, FALSE, WS_VISIBLE, WmShow, FALSE },
10081 /* 18 */ { SW_SHOW, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
10082 /* 19 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_1, FALSE },
10083 /* 20 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_3, FALSE },
10084 /* 21 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2, FALSE },
10085 /* 22 */ { SW_SHOWMINNOACTIVE, FALSE, WS_VISIBLE|WS_MINIMIZE, WmShowMinNoActivate, TRUE },
10086 /* 23 */ { SW_SHOWMINNOACTIVE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_4, FALSE },
10087 /* 24 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2, FALSE },
10088 /* 25 */ { SW_HIDE, FALSE, WS_MINIMIZE, WmEmptySeq, FALSE },
10089 /* 26 */ { SW_SHOWNA, FALSE, WS_VISIBLE|WS_MINIMIZE, WmShowNA_1, FALSE },
10090 /* 27 */ { SW_SHOWNA, TRUE, WS_VISIBLE|WS_MINIMIZE, WmShowNA_2, FALSE },
10091 /* 28 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2, FALSE },
10092 /* 29 */ { SW_HIDE, FALSE, WS_MINIMIZE, WmEmptySeq, FALSE },
10093 /* 30 */ { SW_RESTORE, FALSE, WS_VISIBLE, WmRestore_1, FALSE },
10094 /* 31 */ { SW_RESTORE, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
10095 /* 32 */ { SW_HIDE, TRUE, 0, WmHide_3, FALSE },
10096 /* 33 */ { SW_HIDE, FALSE, 0, WmEmptySeq, FALSE },
10097 /* 34 */ { SW_NORMALNA, FALSE, 0, WmEmptySeq, FALSE }, /* what does this mean?! */
10098 /* 35 */ { SW_NORMALNA, FALSE, 0, WmEmptySeq, FALSE },
10099 /* 36 */ { SW_HIDE, FALSE, 0, WmEmptySeq, FALSE },
10100 /* 37 */ { SW_RESTORE, FALSE, WS_VISIBLE, WmRestore_2, FALSE },
10101 /* 38 */ { SW_RESTORE, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
10102 /* 39 */ { SW_SHOWNOACTIVATE, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
10103 /* 40 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_2, FALSE },
10104 /* 41 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_3, FALSE },
10105 /* 42 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmShowMaximized_2, FALSE },
10106 /* 43 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmMinMax_2, FALSE },
10107 /* 44 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_1, FALSE },
10108 /* 45 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_3, FALSE },
10109 /* 46 */ { SW_RESTORE, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmRestore_3, FALSE },
10110 /* 47 */ { SW_RESTORE, TRUE, WS_VISIBLE, WmRestore_4, FALSE },
10111 /* 48 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmShowMaximized_3, FALSE },
10112 /* 49 */ { SW_SHOW, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmEmptySeq, FALSE },
10113 /* 50 */ { SW_SHOWNORMAL, TRUE, WS_VISIBLE, WmRestore_5, FALSE },
10114 /* 51 */ { SW_SHOWNORMAL, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
10115 /* 52 */ { SW_HIDE, TRUE, 0, WmHide_1, FALSE },
10116 /* 53 */ { SW_HIDE, FALSE, 0, WmEmptySeq, FALSE },
10117 /* 54 */ { SW_MINIMIZE, FALSE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_3, FALSE },
10118 /* 55 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2, FALSE },
10119 /* 56 */ { SW_SHOWNOACTIVATE, FALSE, WS_VISIBLE, WmShowNoActivate_2, FALSE },
10120 /* 57 */ { SW_SHOW, TRUE, WS_VISIBLE, WmEmptySeq, FALSE }
10121 };
10122 HWND hwnd;
10123 DWORD style;
10124 LPARAM ret;
10125 INT i;
10126
10127 #define WS_BASE (WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_POPUP|WS_CLIPSIBLINGS)
10128 hwnd = CreateWindowEx(0, "ShowWindowClass", NULL, WS_BASE,
10129 120, 120, 90, 90,
10130 0, 0, 0, NULL);
10131 assert(hwnd);
10132
10133 style = GetWindowLong(hwnd, GWL_STYLE) & ~WS_BASE;
10134 ok(style == 0, "expected style 0, got %08x\n", style);
10135
10136 flush_events();
10137 flush_sequence();
10138
10139 for (i = 0; i < sizeof(sw)/sizeof(sw[0]); i++)
10140 {
10141 static const char * const sw_cmd_name[13] =
10142 {
10143 "SW_HIDE", "SW_SHOWNORMAL", "SW_SHOWMINIMIZED", "SW_SHOWMAXIMIZED",
10144 "SW_SHOWNOACTIVATE", "SW_SHOW", "SW_MINIMIZE", "SW_SHOWMINNOACTIVE",
10145 "SW_SHOWNA", "SW_RESTORE", "SW_SHOWDEFAULT", "SW_FORCEMINIMIZE",
10146 "SW_NORMALNA" /* 0xCC */
10147 };
10148 char comment[64];
10149 INT idx; /* index into the above array of names */
10150
10151 idx = (sw[i].cmd == SW_NORMALNA) ? 12 : sw[i].cmd;
10152
10153 style = GetWindowLong(hwnd, GWL_STYLE);
10154 trace("%d: sending %s, current window style %08x\n", i+1, sw_cmd_name[idx], style);
10155 ret = ShowWindow(hwnd, sw[i].cmd);
10156 ok(!ret == !sw[i].ret, "%d: cmd %s: expected ret %lu, got %lu\n", i+1, sw_cmd_name[idx], sw[i].ret, ret);
10157 style = GetWindowLong(hwnd, GWL_STYLE) & ~WS_BASE;
10158 ok(style == sw[i].style, "%d: expected style %08x, got %08x\n", i+1, sw[i].style, style);
10159
10160 sprintf(comment, "%d: ShowWindow(%s)", i+1, sw_cmd_name[idx]);
10161 ok_sequence(sw[i].msg, comment, sw[i].todo_msg);
10162
10163 flush_events();
10164 flush_sequence();
10165 }
10166
10167 DestroyWindow(hwnd);
10168 }
10169
10170 static INT_PTR WINAPI test_dlg_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
10171 {
10172 struct recvd_message msg;
10173
10174 switch (message)
10175 {
10176 case WM_GETICON:
10177 case WM_GETOBJECT:
10178 return 0; /* ignore them */
10179 }
10180
10181 msg.hwnd = hwnd;
10182 msg.message = message;
10183 msg.flags = sent|wparam|lparam;
10184 msg.wParam = wParam;
10185 msg.lParam = lParam;
10186 msg.descr = "dialog";
10187 add_message(&msg);
10188
10189 /* calling DefDlgProc leads to a recursion under XP */
10190
10191 switch (message)
10192 {
10193 case WM_INITDIALOG:
10194 case WM_GETDLGCODE:
10195 return 0;
10196 }
10197 return 1;
10198 }
10199
10200 static const struct message WmDefDlgSetFocus_1[] = {
10201 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
10202 { WM_GETTEXTLENGTH, sent|wparam|lparam|optional, 0, 0 }, /* XP */
10203 { WM_GETTEXT, sent|wparam|optional, 6 }, /* XP */
10204 { WM_GETTEXT, sent|wparam|optional, 12 }, /* XP */
10205 { EM_SETSEL, sent|wparam, 0 }, /* XP sets lparam to text length, Win9x to -2 */
10206 { HCBT_SETFOCUS, hook },
10207 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
10208 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10209 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
10210 { WM_SETFOCUS, sent|wparam, 0 },
10211 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
10212 { WM_CTLCOLOREDIT, sent },
10213 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
10214 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10215 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10216 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10217 { WM_COMMAND, sent|wparam, MAKEWPARAM(1, EN_SETFOCUS) },
10218 { 0 }
10219 };
10220 static const struct message WmDefDlgSetFocus_2[] = {
10221 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
10222 { WM_GETTEXTLENGTH, sent|wparam|lparam|optional, 0, 0 }, /* XP */
10223 { WM_GETTEXT, sent|wparam|optional, 6 }, /* XP */
10224 { WM_GETTEXT, sent|wparam|optional, 12 }, /* XP */
10225 { EM_SETSEL, sent|wparam, 0 }, /* XP sets lparam to text length, Win9x to -2 */
10226 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10227 { WM_CTLCOLOREDIT, sent|optional }, /* XP */
10228 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10229 { 0 }
10230 };
10231 /* Creation of a dialog */
10232 static const struct message WmCreateDialogParamSeq_1[] = {
10233 { HCBT_CREATEWND, hook },
10234 { WM_NCCREATE, sent },
10235 { WM_NCCALCSIZE, sent|wparam, 0 },
10236 { WM_CREATE, sent },
10237 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
10238 { WM_SIZE, sent|wparam, SIZE_RESTORED },
10239 { WM_MOVE, sent },
10240 { WM_SETFONT, sent },
10241 { WM_INITDIALOG, sent },
10242 { WM_CHANGEUISTATE, sent|optional },
10243 { 0 }
10244 };
10245 /* Creation of a dialog */
10246 static const struct message WmCreateDialogParamSeq_2[] = {
10247 { HCBT_CREATEWND, hook },
10248 { WM_NCCREATE, sent },
10249 { WM_NCCALCSIZE, sent|wparam, 0 },
10250 { WM_CREATE, sent },
10251 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
10252 { WM_SIZE, sent|wparam, SIZE_RESTORED },
10253 { WM_MOVE, sent },
10254 { WM_CHANGEUISTATE, sent|optional },
10255 { 0 }
10256 };
10257
10258 static void test_dialog_messages(void)
10259 {
10260 WNDCLASS cls;
10261 HWND hdlg, hedit1, hedit2, hfocus;
10262 LRESULT ret;
10263
10264 #define set_selection(hctl, start, end) \
10265 ret = SendMessage(hctl, EM_SETSEL, start, end); \
10266 ok(ret == 1, "EM_SETSEL returned %ld\n", ret);
10267
10268 #define check_selection(hctl, start, end) \
10269 ret = SendMessage(hctl, EM_GETSEL, 0, 0); \
10270 ok(ret == MAKELRESULT(start, end), "wrong selection (%d - %d)\n", LOWORD(ret), HIWORD(ret));
10271
10272 subclass_edit();
10273
10274 hdlg = CreateWindowEx(WS_EX_DLGMODALFRAME, "TestDialogClass", NULL,
10275 WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
10276 0, 0, 100, 100, 0, 0, 0, NULL);
10277 ok(hdlg != 0, "Failed to create custom dialog window\n");
10278
10279 hedit1 = CreateWindowEx(0, "my_edit_class", NULL,
10280 WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP,
10281 0, 0, 80, 20, hdlg, (HMENU)1, 0, NULL);
10282 ok(hedit1 != 0, "Failed to create edit control\n");
10283 hedit2 = CreateWindowEx(0, "my_edit_class", NULL,
10284 WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP,
10285 0, 40, 80, 20, hdlg, (HMENU)2, 0, NULL);
10286 ok(hedit2 != 0, "Failed to create edit control\n");
10287
10288 SendMessage(hedit1, WM_SETTEXT, 0, (LPARAM)"hello");
10289 SendMessage(hedit2, WM_SETTEXT, 0, (LPARAM)"bye");
10290
10291 hfocus = GetFocus();
10292 ok(hfocus == hdlg, "wrong focus %p\n", hfocus);
10293
10294 SetFocus(hedit2);
10295 hfocus = GetFocus();
10296 ok(hfocus == hedit2, "wrong focus %p\n", hfocus);
10297
10298 check_selection(hedit1, 0, 0);
10299 check_selection(hedit2, 0, 0);
10300
10301 set_selection(hedit2, 0, -1);
10302 check_selection(hedit2, 0, 3);
10303
10304 SetFocus(0);
10305 hfocus = GetFocus();
10306 ok(hfocus == 0, "wrong focus %p\n", hfocus);
10307
10308 flush_sequence();
10309 ret = DefDlgProc(hdlg, WM_SETFOCUS, 0, 0);
10310 ok(ret == 0, "WM_SETFOCUS returned %ld\n", ret);
10311 ok_sequence(WmDefDlgSetFocus_1, "DefDlgProc(WM_SETFOCUS) 1", FALSE);
10312
10313 hfocus = GetFocus();
10314 ok(hfocus == hedit1, "wrong focus %p\n", hfocus);
10315
10316 check_selection(hedit1, 0, 5);
10317 check_selection(hedit2, 0, 3);
10318
10319 flush_sequence();
10320 ret = DefDlgProc(hdlg, WM_SETFOCUS, 0, 0);
10321 ok(ret == 0, "WM_SETFOCUS returned %ld\n", ret);
10322 ok_sequence(WmDefDlgSetFocus_2, "DefDlgProc(WM_SETFOCUS) 2", FALSE);
10323
10324 hfocus = GetFocus();
10325 ok(hfocus == hedit1, "wrong focus %p\n", hfocus);
10326
10327 check_selection(hedit1, 0, 5);
10328 check_selection(hedit2, 0, 3);
10329
10330 EndDialog(hdlg, 0);
10331 DestroyWindow(hedit1);
10332 DestroyWindow(hedit2);
10333 DestroyWindow(hdlg);
10334 flush_sequence();
10335
10336 #undef set_selection
10337 #undef check_selection
10338
10339 ok(GetClassInfo(0, "#32770", &cls), "GetClassInfo failed\n");
10340 cls.lpszClassName = "MyDialogClass";
10341 cls.hInstance = GetModuleHandle(0);
10342 /* need a cast since a dlgproc is used as a wndproc */
10343 cls.lpfnWndProc = (WNDPROC)test_dlg_proc;
10344 if (!RegisterClass(&cls)) assert(0);
10345
10346 hdlg = CreateDialogParam(0, "CLASS_TEST_DIALOG_2", 0, test_dlg_proc, 0);
10347 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
10348 ok_sequence(WmCreateDialogParamSeq_1, "CreateDialogParam_1", FALSE);
10349 EndDialog(hdlg, 0);
10350 DestroyWindow(hdlg);
10351 flush_sequence();
10352
10353 hdlg = CreateDialogParam(0, "CLASS_TEST_DIALOG_2", 0, NULL, 0);
10354 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
10355 ok_sequence(WmCreateDialogParamSeq_2, "CreateDialogParam_2", FALSE);
10356 EndDialog(hdlg, 0);
10357 DestroyWindow(hdlg);
10358 flush_sequence();
10359
10360 UnregisterClass(cls.lpszClassName, cls.hInstance);
10361 }
10362
10363 static void test_nullCallback(void)
10364 {
10365 HWND hwnd;
10366
10367 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
10368 100, 100, 200, 200, 0, 0, 0, NULL);
10369 ok (hwnd != 0, "Failed to create overlapped window\n");
10370
10371 SendMessageCallbackA(hwnd,WM_NULL,0,0,NULL,0);
10372 flush_events();
10373 DestroyWindow(hwnd);
10374 }
10375
10376 /* SetActiveWindow( 0 ) hwnd visible */
10377 static const struct message SetActiveWindowSeq0[] =
10378 {
10379 { HCBT_ACTIVATE, hook|optional },
10380 { WM_NCACTIVATE, sent|wparam, 0 },
10381 { WM_GETTEXT, sent|defwinproc|optional },
10382 { WM_ACTIVATE, sent|wparam, 0 },
10383 { WM_ACTIVATEAPP, sent|wparam|optional, 0 },
10384 { WM_ACTIVATEAPP, sent|wparam|optional, 0 },
10385 { WM_KILLFOCUS, sent|wparam|optional, 0 },
10386 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
10387 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
10388 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
10389 { WM_NCACTIVATE, sent|wparam, 1 },
10390 { WM_GETTEXT, sent|defwinproc|optional },
10391 { WM_ACTIVATE, sent|wparam, 1 },
10392 { HCBT_SETFOCUS, hook },
10393 { WM_KILLFOCUS, sent|defwinproc },
10394 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
10395 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
10396 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
10397 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10398 { WM_SETFOCUS, sent|defwinproc },
10399 { WM_GETTEXT, sent|optional },
10400 { 0 }
10401 };
10402 /* SetActiveWindow( hwnd ) hwnd visible */
10403 static const struct message SetActiveWindowSeq1[] =
10404 {
10405 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
10406 { 0 }
10407 };
10408 /* SetActiveWindow( popup ) hwnd visible, popup visible */
10409 static const struct message SetActiveWindowSeq2[] =
10410 {
10411 { HCBT_ACTIVATE, hook },
10412 { WM_NCACTIVATE, sent|wparam, 0 },
10413 { WM_GETTEXT, sent|defwinproc|optional },
10414 { WM_ACTIVATE, sent|wparam, 0 },
10415 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
10416 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
10417 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
10418 { WM_NCPAINT, sent|optional },
10419 { WM_GETTEXT, sent|defwinproc|optional },
10420 { WM_ERASEBKGND, sent|optional },
10421 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
10422 { WM_NCACTIVATE, sent|wparam, 1 },
10423 { WM_GETTEXT, sent|defwinproc|optional },
10424 { WM_ACTIVATE, sent|wparam, 1 },
10425 { HCBT_SETFOCUS, hook },
10426 { WM_KILLFOCUS, sent|defwinproc },
10427 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
10428 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
10429 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
10430 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10431 { WM_SETFOCUS, sent|defwinproc },
10432 { WM_GETTEXT, sent|optional },
10433 { 0 }
10434 };
10435
10436 /* SetActiveWindow( hwnd ) hwnd not visible */
10437 static const struct message SetActiveWindowSeq3[] =
10438 {
10439 { HCBT_ACTIVATE, hook },
10440 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
10441 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
10442 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
10443 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
10444 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
10445 { WM_ACTIVATEAPP, sent|wparam, 1 },
10446 { WM_ACTIVATEAPP, sent|wparam, 1 },
10447 { WM_NCACTIVATE, sent|wparam, 1 },
10448 { WM_ACTIVATE, sent|wparam, 1 },
10449 { HCBT_SETFOCUS, hook },
10450 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
10451 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10452 { WM_SETFOCUS, sent|defwinproc },
10453 { 0 }
10454 };
10455 /* SetActiveWindow( popup ) hwnd not visible, popup not visible */
10456 static const struct message SetActiveWindowSeq4[] =
10457 {
10458 { HCBT_ACTIVATE, hook },
10459 { WM_NCACTIVATE, sent|wparam, 0 },
10460 { WM_GETTEXT, sent|defwinproc|optional },
10461 { WM_ACTIVATE, sent|wparam, 0 },
10462 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
10463 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
10464 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
10465 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
10466 { WM_NCACTIVATE, sent|wparam, 1 },
10467 { WM_GETTEXT, sent|defwinproc|optional },
10468 { WM_ACTIVATE, sent|wparam, 1 },
10469 { HCBT_SETFOCUS, hook },
10470 { WM_KILLFOCUS, sent|defwinproc },
10471 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
10472 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
10473 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
10474 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10475 { WM_SETFOCUS, sent|defwinproc },
10476 { 0 }
10477 };
10478
10479
10480 static void test_SetActiveWindow(void)
10481 {
10482 HWND hwnd, popup, ret;
10483
10484 hwnd = CreateWindowExA(0, "TestWindowClass", "Test SetActiveWindow",
10485 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
10486 100, 100, 200, 200, 0, 0, 0, NULL);
10487
10488 popup = CreateWindowExA(0, "TestWindowClass", "Test SetActiveWindow",
10489 WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_POPUP,
10490 100, 100, 200, 200, hwnd, 0, 0, NULL);
10491
10492 ok(hwnd != 0, "Failed to create overlapped window\n");
10493 ok(popup != 0, "Failed to create popup window\n");
10494 SetForegroundWindow( popup );
10495 flush_sequence();
10496
10497 trace("SetActiveWindow(0)\n");
10498 ret = SetActiveWindow(0);
10499 ok( ret == popup, "Failed to SetActiveWindow(0)\n");
10500 ok_sequence(SetActiveWindowSeq0, "SetActiveWindow(0)", TRUE);
10501 flush_sequence();
10502
10503 trace("SetActiveWindow(hwnd), hwnd visible\n");
10504 ret = SetActiveWindow(hwnd);
10505 if (ret == hwnd) ok_sequence(SetActiveWindowSeq1, "SetActiveWindow(hwnd), hwnd visible", TRUE);
10506 flush_sequence();
10507
10508 trace("SetActiveWindow(popup), hwnd visible, popup visible\n");
10509 ret = SetActiveWindow(popup);
10510 ok( ret == hwnd, "Failed to SetActiveWindow(popup), popup visible\n");
10511 ok_sequence(SetActiveWindowSeq2, "SetActiveWindow(popup), hwnd visible, popup visible", FALSE);
10512 flush_sequence();
10513
10514 ShowWindow(hwnd, SW_HIDE);
10515 ShowWindow(popup, SW_HIDE);
10516 flush_sequence();
10517
10518 trace("SetActiveWindow(hwnd), hwnd not visible\n");
10519 ret = SetActiveWindow(hwnd);
10520 ok( ret == NULL, "SetActiveWindow(hwnd), hwnd not visible, previous is %p\n", ret );
10521 ok_sequence(SetActiveWindowSeq3, "SetActiveWindow(hwnd), hwnd not visible", TRUE);
10522 flush_sequence();
10523
10524 trace("SetActiveWindow(popup), hwnd not visible, popup not visible\n");
10525 ret = SetActiveWindow(popup);
10526 ok( ret == hwnd, "Failed to SetActiveWindow(popup)\n");
10527 ok_sequence(SetActiveWindowSeq4, "SetActiveWindow(popup), hwnd not visible, popup not visible", TRUE);
10528 flush_sequence();
10529
10530 trace("done\n");
10531
10532 DestroyWindow(hwnd);
10533 }
10534
10535 static const struct message SetForegroundWindowSeq[] =
10536 {
10537 { WM_NCACTIVATE, sent|wparam, 0 },
10538 { WM_GETTEXT, sent|defwinproc|optional },
10539 { WM_ACTIVATE, sent|wparam, 0 },
10540 { WM_ACTIVATEAPP, sent|wparam, 0 },
10541 { WM_KILLFOCUS, sent },
10542 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
10543 { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
10544 { 0 }
10545 };
10546
10547 static void test_SetForegroundWindow(void)
10548 {
10549 HWND hwnd;
10550
10551 hwnd = CreateWindowExA(0, "TestWindowClass", "Test SetForegroundWindow",
10552 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
10553 100, 100, 200, 200, 0, 0, 0, NULL);
10554 ok (hwnd != 0, "Failed to create overlapped window\n");
10555 SetForegroundWindow( hwnd );
10556 flush_sequence();
10557
10558 trace("SetForegroundWindow( 0 )\n");
10559 SetForegroundWindow( 0 );
10560 ok_sequence(WmEmptySeq, "SetForegroundWindow( 0 ) away from foreground top level window", FALSE);
10561 trace("SetForegroundWindow( GetDesktopWindow() )\n");
10562 SetForegroundWindow( GetDesktopWindow() );
10563 ok_sequence(SetForegroundWindowSeq, "SetForegroundWindow( desktop ) away from "
10564 "foreground top level window", FALSE);
10565 trace("done\n");
10566
10567 DestroyWindow(hwnd);
10568 }
10569
10570 static void test_dbcs_wm_char(void)
10571 {
10572 BYTE dbch[2];
10573 WCHAR wch, bad_wch;
10574 HWND hwnd, hwnd2;
10575 MSG msg;
10576 DWORD time;
10577 POINT pt;
10578 DWORD_PTR res;
10579 CPINFOEXA cpinfo;
10580 UINT i, j, k;
10581 struct message wmCharSeq[2];
10582
10583 if (!pGetCPInfoExA)
10584 {
10585 skip("GetCPInfoExA is not available\n");
10586 return;
10587 }
10588
10589 pGetCPInfoExA( CP_ACP, 0, &cpinfo );
10590 if (cpinfo.MaxCharSize != 2)
10591 {
10592 skip( "Skipping DBCS WM_CHAR test in SBCS codepage '%s'\n", cpinfo.CodePageName );
10593 return;
10594 }
10595
10596 dbch[0] = dbch[1] = 0;
10597 wch = 0;
10598 bad_wch = cpinfo.UnicodeDefaultChar;
10599 for (i = 0; !wch && i < MAX_LEADBYTES && cpinfo.LeadByte[i]; i += 2)
10600 for (j = cpinfo.LeadByte[i]; !wch && j <= cpinfo.LeadByte[i+1]; j++)
10601 for (k = 128; k <= 255; k++)
10602 {
10603 char str[2];
10604 WCHAR wstr[2];
10605 str[0] = j;
10606 str[1] = k;
10607 if (MultiByteToWideChar( CP_ACP, 0, str, 2, wstr, 2 ) == 1 &&
10608 WideCharToMultiByte( CP_ACP, 0, wstr, 1, str, 2, NULL, NULL ) == 2 &&
10609 (BYTE)str[0] == j && (BYTE)str[1] == k &&
10610 HIBYTE(wstr[0]) && HIBYTE(wstr[0]) != 0xff)
10611 {
10612 dbch[0] = j;
10613 dbch[1] = k;
10614 wch = wstr[0];
10615 break;
10616 }
10617 }
10618
10619 if (!wch)
10620 {
10621 skip( "Skipping DBCS WM_CHAR test, no appropriate char found\n" );
10622 return;
10623 }
10624 trace( "using dbcs char %02x,%02x wchar %04x bad wchar %04x codepage '%s'\n",
10625 dbch[0], dbch[1], wch, bad_wch, cpinfo.CodePageName );
10626
10627 hwnd = CreateWindowExW(0, testWindowClassW, NULL,
10628 WS_OVERLAPPEDWINDOW, 100, 100, 200, 200, 0, 0, 0, NULL);
10629 hwnd2 = CreateWindowExW(0, testWindowClassW, NULL,
10630 WS_OVERLAPPEDWINDOW, 100, 100, 200, 200, 0, 0, 0, NULL);
10631 ok (hwnd != 0, "Failed to create overlapped window\n");
10632 ok (hwnd2 != 0, "Failed to create overlapped window\n");
10633 flush_sequence();
10634
10635 memset( wmCharSeq, 0, sizeof(wmCharSeq) );
10636 wmCharSeq[0].message = WM_CHAR;
10637 wmCharSeq[0].flags = sent|wparam;
10638 wmCharSeq[0].wParam = wch;
10639
10640 /* posted message */
10641 PostMessageA( hwnd, WM_CHAR, dbch[0], 0 );
10642 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10643 PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
10644 ok( PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
10645 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10646 ok( msg.wParam == wch, "bad wparam %lx/%x\n", msg.wParam, wch );
10647 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10648
10649 /* posted thread message */
10650 PostThreadMessageA( GetCurrentThreadId(), WM_CHAR, dbch[0], 0 );
10651 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10652 PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
10653 ok( PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
10654 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10655 ok( msg.wParam == wch, "bad wparam %lx/%x\n", msg.wParam, wch );
10656 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10657
10658 /* sent message */
10659 flush_sequence();
10660 SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
10661 ok_sequence( WmEmptySeq, "no messages", FALSE );
10662 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
10663 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10664 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10665
10666 /* sent message with timeout */
10667 flush_sequence();
10668 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[0], 0, SMTO_NORMAL, 0, &res );
10669 ok_sequence( WmEmptySeq, "no messages", FALSE );
10670 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[1], 0, SMTO_NORMAL, 0, &res );
10671 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10672 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10673
10674 /* sent message with timeout and callback */
10675 flush_sequence();
10676 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[0], 0, SMTO_NORMAL, 0, &res );
10677 ok_sequence( WmEmptySeq, "no messages", FALSE );
10678 SendMessageCallbackA( hwnd, WM_CHAR, dbch[1], 0, NULL, 0 );
10679 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10680 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10681
10682 /* sent message with callback */
10683 flush_sequence();
10684 SendNotifyMessageA( hwnd, WM_CHAR, dbch[0], 0 );
10685 ok_sequence( WmEmptySeq, "no messages", FALSE );
10686 SendMessageCallbackA( hwnd, WM_CHAR, dbch[1], 0, NULL, 0 );
10687 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10688 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10689
10690 /* direct window proc call */
10691 flush_sequence();
10692 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
10693 ok_sequence( WmEmptySeq, "no messages", FALSE );
10694 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
10695 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10696
10697 /* dispatch message */
10698 msg.hwnd = hwnd;
10699 msg.message = WM_CHAR;
10700 msg.wParam = dbch[0];
10701 msg.lParam = 0;
10702 DispatchMessageA( &msg );
10703 ok_sequence( WmEmptySeq, "no messages", FALSE );
10704 msg.wParam = dbch[1];
10705 DispatchMessageA( &msg );
10706 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10707
10708 /* window handle is irrelevant */
10709 flush_sequence();
10710 SendMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
10711 ok_sequence( WmEmptySeq, "no messages", FALSE );
10712 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
10713 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10714 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10715
10716 /* interleaved post and send */
10717 flush_sequence();
10718 PostMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
10719 SendMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
10720 ok_sequence( WmEmptySeq, "no messages", FALSE );
10721 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10722 PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
10723 ok_sequence( WmEmptySeq, "no messages", FALSE );
10724 ok( PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
10725 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10726 ok( msg.wParam == wch, "bad wparam %lx/%x\n", msg.wParam, wch );
10727 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10728 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
10729 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10730 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10731
10732 /* interleaved sent message and winproc */
10733 flush_sequence();
10734 SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
10735 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
10736 ok_sequence( WmEmptySeq, "no messages", FALSE );
10737 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
10738 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10739 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
10740 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10741
10742 /* interleaved winproc and dispatch */
10743 msg.hwnd = hwnd;
10744 msg.message = WM_CHAR;
10745 msg.wParam = dbch[0];
10746 msg.lParam = 0;
10747 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
10748 DispatchMessageA( &msg );
10749 ok_sequence( WmEmptySeq, "no messages", FALSE );
10750 msg.wParam = dbch[1];
10751 DispatchMessageA( &msg );
10752 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10753 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
10754 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10755
10756 /* interleaved sends */
10757 flush_sequence();
10758 SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
10759 SendMessageCallbackA( hwnd, WM_CHAR, dbch[0], 0, NULL, 0 );
10760 ok_sequence( WmEmptySeq, "no messages", FALSE );
10761 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[1], 0, SMTO_NORMAL, 0, &res );
10762 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10763 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
10764 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10765
10766 /* dbcs WM_CHAR */
10767 flush_sequence();
10768 SendMessageA( hwnd2, WM_CHAR, (dbch[1] << 8) | dbch[0], 0 );
10769 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10770 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10771
10772 /* other char messages are not magic */
10773 PostMessageA( hwnd, WM_SYSCHAR, dbch[0], 0 );
10774 ok( PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
10775 ok( msg.message == WM_SYSCHAR, "unexpected message %x\n", msg.message );
10776 ok( msg.wParam == bad_wch, "bad wparam %lx/%x\n", msg.wParam, bad_wch );
10777 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10778 PostMessageA( hwnd, WM_DEADCHAR, dbch[0], 0 );
10779 ok( PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
10780 ok( msg.message == WM_DEADCHAR, "unexpected message %x\n", msg.message );
10781 ok( msg.wParam == bad_wch, "bad wparam %lx/%x\n", msg.wParam, bad_wch );
10782 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10783
10784 /* test retrieving messages */
10785
10786 PostMessageW( hwnd, WM_CHAR, wch, 0 );
10787 ok( PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
10788 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10789 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10790 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10791 ok( PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
10792 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10793 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10794 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10795 ok( !PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10796
10797 /* message filters */
10798 PostMessageW( hwnd, WM_CHAR, wch, 0 );
10799 ok( PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
10800 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10801 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10802 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10803 /* message id is filtered, hwnd is not */
10804 ok( !PeekMessageA( &msg, hwnd, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE ), "no message\n" );
10805 ok( PeekMessageA( &msg, hwnd2, 0, 0, PM_REMOVE ), "no message\n" );
10806 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10807 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10808 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10809 ok( !PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10810
10811 /* mixing GetMessage and PostMessage */
10812 PostMessageW( hwnd, WM_CHAR, wch, 0xbeef );
10813 ok( GetMessageA( &msg, hwnd, 0, 0 ), "no message\n" );
10814 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10815 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10816 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10817 ok( msg.lParam == 0xbeef, "bad lparam %lx\n", msg.lParam );
10818 time = msg.time;
10819 pt = msg.pt;
10820 ok( time - GetTickCount() <= 100, "bad time %x\n", msg.time );
10821 ok( PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "no message\n" );
10822 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10823 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10824 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10825 ok( msg.lParam == 0xbeef, "bad lparam %lx\n", msg.lParam );
10826 ok( msg.time == time, "bad time %x/%x\n", msg.time, time );
10827 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 );
10828 ok( !PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10829
10830 /* without PM_REMOVE */
10831 PostMessageW( hwnd, WM_CHAR, wch, 0 );
10832 ok( PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ), "no message\n" );
10833 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10834 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10835 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10836 ok( PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "no message\n" );
10837 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10838 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10839 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10840 ok( PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ), "no message\n" );
10841 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10842 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10843 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10844 ok( PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "no message\n" );
10845 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10846 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10847 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10848 ok( !PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10849
10850 DestroyWindow(hwnd);
10851 }
10852
10853 #define ID_LISTBOX 0x000f
10854
10855 static const struct message wm_lb_setcursel_0[] =
10856 {
10857 { LB_SETCURSEL, sent|wparam|lparam, 0, 0 },
10858 { WM_CTLCOLORLISTBOX, sent|parent },
10859 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000120f2 },
10860 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 1 },
10861 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam, OBJID_CLIENT, 1 },
10862 { 0 }
10863 };
10864 static const struct message wm_lb_setcursel_1[] =
10865 {
10866 { LB_SETCURSEL, sent|wparam|lparam, 1, 0 },
10867 { WM_CTLCOLORLISTBOX, sent|parent },
10868 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000020f2 },
10869 { WM_CTLCOLORLISTBOX, sent|parent },
10870 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000121f2 },
10871 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 2 },
10872 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam, OBJID_CLIENT, 2 },
10873 { 0 }
10874 };
10875 static const struct message wm_lb_setcursel_2[] =
10876 {
10877 { LB_SETCURSEL, sent|wparam|lparam, 2, 0 },
10878 { WM_CTLCOLORLISTBOX, sent|parent },
10879 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000021f2 },
10880 { WM_CTLCOLORLISTBOX, sent|parent },
10881 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000122f2 },
10882 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 3 },
10883 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam, OBJID_CLIENT, 3 },
10884 { 0 }
10885 };
10886 static const struct message wm_lb_click_0[] =
10887 {
10888 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, MAKELPARAM(1,1) },
10889 { HCBT_SETFOCUS, hook },
10890 { WM_KILLFOCUS, sent|parent },
10891 { WM_IME_SETCONTEXT, sent|wparam|optional|parent, 0 },
10892 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
10893 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
10894 { WM_SETFOCUS, sent|defwinproc },
10895
10896 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x001142f2 },
10897 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_LISTBOX, LBN_SETFOCUS) },
10898 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 3 },
10899 { WM_LBTRACKPOINT, sent|wparam|lparam|parent, 0, MAKELPARAM(1,1) },
10900 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
10901
10902 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000142f2 },
10903 { WM_CTLCOLORLISTBOX, sent|parent },
10904 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000022f2 },
10905 { WM_CTLCOLORLISTBOX, sent|parent },
10906 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000120f2 },
10907 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x001140f2 },
10908
10909 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 1 },
10910 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam, OBJID_CLIENT, 1 },
10911
10912 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
10913 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
10914 { WM_CAPTURECHANGED, sent|wparam|lparam|defwinproc, 0, 0 },
10915 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_LISTBOX, LBN_SELCHANGE) },
10916 { 0 }
10917 };
10918
10919 #define check_lb_state(a1, a2, a3, a4, a5) check_lb_state_dbg(a1, a2, a3, a4, a5, __LINE__)
10920
10921 static LRESULT (WINAPI *listbox_orig_proc)(HWND, UINT, WPARAM, LPARAM);
10922
10923 static LRESULT WINAPI listbox_hook_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
10924 {
10925 static long defwndproc_counter = 0;
10926 LRESULT ret;
10927 struct recvd_message msg;
10928
10929 /* do not log painting messages */
10930 if (message != WM_PAINT &&
10931 message != WM_NCPAINT &&
10932 message != WM_SYNCPAINT &&
10933 message != WM_ERASEBKGND &&
10934 message != WM_NCHITTEST &&
10935 message != WM_GETTEXT &&
10936 message != WM_GETOBJECT &&
10937 message != WM_GETICON &&
10938 message != WM_DEVICECHANGE)
10939 {
10940 msg.hwnd = hwnd;
10941 msg.message = message;
10942 msg.flags = sent|wparam|lparam;
10943 if (defwndproc_counter) msg.flags |= defwinproc;
10944 msg.wParam = wp;
10945 msg.lParam = lp;
10946 msg.descr = "listbox";
10947 add_message(&msg);
10948 }
10949
10950 defwndproc_counter++;
10951 ret = CallWindowProcA(listbox_orig_proc, hwnd, message, wp, lp);
10952 defwndproc_counter--;
10953
10954 return ret;
10955 }
10956
10957 static void check_lb_state_dbg(HWND listbox, int count, int cur_sel,
10958 int caret_index, int top_index, int line)
10959 {
10960 LRESULT ret;
10961
10962 /* calling an orig proc helps to avoid unnecessary message logging */
10963 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETCOUNT, 0, 0);
10964 ok_(__FILE__, line)(ret == count, "expected count %d, got %ld\n", count, ret);
10965 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETCURSEL, 0, 0);
10966 ok_(__FILE__, line)(ret == cur_sel, "expected cur sel %d, got %ld\n", cur_sel, ret);
10967 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETCARETINDEX, 0, 0);
10968 ok_(__FILE__, line)(ret == caret_index, "expected caret index %d, got %ld\n", caret_index, ret);
10969 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETTOPINDEX, 0, 0);
10970 ok_(__FILE__, line)(ret == top_index, "expected top index %d, got %ld\n", top_index, ret);
10971 }
10972
10973 static void test_listbox_messages(void)
10974 {
10975 HWND parent, listbox;
10976 LRESULT ret;
10977
10978 parent = CreateWindowExA(0, "TestParentClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
10979 100, 100, 200, 200, 0, 0, 0, NULL);
10980 listbox = CreateWindowExA(WS_EX_NOPARENTNOTIFY, "ListBox", NULL,
10981 WS_CHILD | LBS_NOTIFY | LBS_OWNERDRAWVARIABLE | LBS_HASSTRINGS | WS_VISIBLE,
10982 10, 10, 80, 80, parent, (HMENU)ID_LISTBOX, 0, NULL);
10983 listbox_orig_proc = (WNDPROC)SetWindowLongPtrA(listbox, GWLP_WNDPROC, (ULONG_PTR)listbox_hook_proc);
10984
10985 check_lb_state(listbox, 0, LB_ERR, 0, 0);
10986
10987 ret = SendMessage(listbox, LB_ADDSTRING, 0, (LPARAM)"item 0");
10988 ok(ret == 0, "expected 0, got %ld\n", ret);
10989 ret = SendMessage(listbox, LB_ADDSTRING, 0, (LPARAM)"item 1");
10990 ok(ret == 1, "expected 1, got %ld\n", ret);
10991 ret = SendMessage(listbox, LB_ADDSTRING, 0, (LPARAM)"item 2");
10992 ok(ret == 2, "expected 2, got %ld\n", ret);
10993
10994 check_lb_state(listbox, 3, LB_ERR, 0, 0);
10995
10996 flush_sequence();
10997
10998 log_all_parent_messages++;
10999
11000 trace("selecting item 0\n");
11001 ret = SendMessage(listbox, LB_SETCURSEL, 0, 0);
11002 ok(ret == 0, "expected 0, got %ld\n", ret);
11003 ok_sequence(wm_lb_setcursel_0, "LB_SETCURSEL 0", FALSE );
11004 check_lb_state(listbox, 3, 0, 0, 0);
11005 flush_sequence();
11006
11007 trace("selecting item 1\n");
11008 ret = SendMessage(listbox, LB_SETCURSEL, 1, 0);
11009 ok(ret == 1, "expected 1, got %ld\n", ret);
11010 ok_sequence(wm_lb_setcursel_1, "LB_SETCURSEL 1", FALSE );
11011 check_lb_state(listbox, 3, 1, 1, 0);
11012
11013 trace("selecting item 2\n");
11014 ret = SendMessage(listbox, LB_SETCURSEL, 2, 0);
11015 ok(ret == 2, "expected 2, got %ld\n", ret);
11016 ok_sequence(wm_lb_setcursel_2, "LB_SETCURSEL 2", FALSE );
11017 check_lb_state(listbox, 3, 2, 2, 0);
11018
11019 trace("clicking on item 0\n");
11020 ret = SendMessage(listbox, WM_LBUTTONDOWN, 0, MAKELPARAM(1, 1));
11021 ok(ret == LB_OKAY, "expected LB_OKAY, got %ld\n", ret);
11022 ret = SendMessage(listbox, WM_LBUTTONUP, 0, 0);
11023 ok(ret == LB_OKAY, "expected LB_OKAY, got %ld\n", ret);
11024 ok_sequence(wm_lb_click_0, "WM_LBUTTONDOWN 0", FALSE );
11025 check_lb_state(listbox, 3, 0, 0, 0);
11026 flush_sequence();
11027
11028 log_all_parent_messages--;
11029
11030 DestroyWindow(listbox);
11031 DestroyWindow(parent);
11032 }
11033
11034 /*************************** Menu test ******************************/
11035 static const struct message wm_popup_menu_1[] =
11036 {
11037 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
11038 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
11039 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'E', 0x20000001 },
11040 { WM_SYSKEYDOWN, sent|wparam|lparam, 'E', 0x20000001 },
11041 { WM_SYSCHAR, sent|wparam|lparam, 'e', 0x20000001 },
11042 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_KEYMENU, 'e' },
11043 { WM_ENTERMENULOOP, sent|wparam|lparam, 0, 0 },
11044 { WM_INITMENU, sent|lparam, 0, 0 },
11045 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(1,MF_HILITE|MF_POPUP) },
11046 { WM_INITMENUPOPUP, sent|lparam, 0, 1 },
11047 { HCBT_CREATEWND, hook|optional }, /* Win9x doesn't create a window */
11048 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(200,MF_HILITE) },
11049 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'E', 0xf0000001 },
11050 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xd0000001 },
11051 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0x10000001 },
11052 { HCBT_DESTROYWND, hook|optional }, /* Win9x doesn't create a window */
11053 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
11054 { WM_MENUSELECT, sent|wparam|lparam, MAKEWPARAM(0,0xffff), 0 },
11055 { WM_EXITMENULOOP, sent|wparam|lparam, 0, 0 },
11056 { WM_MENUCOMMAND, sent }, /* |wparam, 200 - Win9x */
11057 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0xc0000001 },
11058 { WM_KEYUP, sent|wparam|lparam, VK_RETURN, 0xc0000001 },
11059 { 0 }
11060 };
11061 static const struct message wm_popup_menu_2[] =
11062 {
11063 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
11064 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
11065 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0x20000001 },
11066 { WM_SYSKEYDOWN, sent|wparam|lparam, 'F', 0x20000001 },
11067 { WM_SYSCHAR, sent|wparam|lparam, 'f', 0x20000001 },
11068 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_KEYMENU, 'f' },
11069 { WM_ENTERMENULOOP, sent|wparam|lparam, 0, 0 },
11070 { WM_INITMENU, sent|lparam, 0, 0 },
11071 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) },
11072 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
11073 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(0,MF_HILITE|MF_POPUP) }, /* Win9x */
11074 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x */
11075 { HCBT_CREATEWND, hook },
11076 { WM_MENUSELECT, sent }, /*|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) - XP
11077 |wparam, MAKEWPARAM(100,MF_HILITE) - Win9x */
11078 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0xf0000001 },
11079 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xd0000001 },
11080 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0x10000001 },
11081 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x doesn't send it */
11082 { HCBT_CREATEWND, hook|optional }, /* Win9x doesn't send it */
11083 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(100,MF_HILITE) },
11084 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0xd0000001 },
11085 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0x10000001 },
11086 { HCBT_DESTROYWND, hook },
11087 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
11088 { HCBT_DESTROYWND, hook|optional }, /* Win9x doesn't send it */
11089 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
11090 { WM_MENUSELECT, sent|wparam|lparam, MAKEWPARAM(0,0xffff), 0 },
11091 { WM_EXITMENULOOP, sent|wparam|lparam, 0, 0 },
11092 { WM_MENUCOMMAND, sent }, /* |wparam, 100 - Win9x */
11093 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0xc0000001 },
11094 { WM_KEYUP, sent|wparam|lparam, VK_RETURN, 0xc0000001 },
11095 { 0 }
11096 };
11097 static const struct message wm_popup_menu_3[] =
11098 {
11099 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
11100 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
11101 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0x20000001 },
11102 { WM_SYSKEYDOWN, sent|wparam|lparam, 'F', 0x20000001 },
11103 { WM_SYSCHAR, sent|wparam|lparam, 'f', 0x20000001 },
11104 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_KEYMENU, 'f' },
11105 { WM_ENTERMENULOOP, sent|wparam|lparam, 0, 0 },
11106 { WM_INITMENU, sent|lparam, 0, 0 },
11107 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) },
11108 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
11109 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(0,MF_HILITE|MF_POPUP) }, /* Win9x */
11110 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x */
11111 { HCBT_CREATEWND, hook },
11112 { WM_MENUSELECT, sent }, /*|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) - XP
11113 |wparam, MAKEWPARAM(100,MF_HILITE) - Win9x */
11114 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0xf0000001 },
11115 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xd0000001 },
11116 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0x10000001 },
11117 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x doesn't send it */
11118 { HCBT_CREATEWND, hook|optional }, /* Win9x doesn't send it */
11119 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(100,MF_HILITE) },
11120 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0xd0000001 },
11121 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0x10000001 },
11122 { HCBT_DESTROYWND, hook },
11123 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
11124 { HCBT_DESTROYWND, hook|optional }, /* Win9x doesn't send it */
11125 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
11126 { WM_MENUSELECT, sent|wparam|lparam, MAKEWPARAM(0,0xffff), 0 },
11127 { WM_EXITMENULOOP, sent|wparam|lparam, 0, 0 },
11128 { WM_COMMAND, sent|wparam|lparam, 100, 0 },
11129 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0xc0000001 },
11130 { WM_KEYUP, sent|wparam|lparam, VK_RETURN, 0xc0000001 },
11131 { 0 }
11132 };
11133
11134 static LRESULT WINAPI parent_menu_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
11135 {
11136 if (message == WM_ENTERIDLE ||
11137 message == WM_INITMENU ||
11138 message == WM_INITMENUPOPUP ||
11139 message == WM_MENUSELECT ||
11140 message == WM_PARENTNOTIFY ||
11141 message == WM_ENTERMENULOOP ||
11142 message == WM_EXITMENULOOP ||
11143 message == WM_UNINITMENUPOPUP ||
11144 message == WM_KEYDOWN ||
11145 message == WM_KEYUP ||
11146 message == WM_CHAR ||
11147 message == WM_SYSKEYDOWN ||
11148 message == WM_SYSKEYUP ||
11149 message == WM_SYSCHAR ||
11150 message == WM_COMMAND ||
11151 message == WM_MENUCOMMAND)
11152 {
11153 struct recvd_message msg;
11154
11155 msg.hwnd = hwnd;
11156 msg.message = message;
11157 msg.flags = sent|wparam|lparam;
11158 msg.wParam = wp;
11159 msg.lParam = lp;
11160 msg.descr = "parent_menu_proc";
11161 add_message(&msg);
11162 }
11163
11164 return DefWindowProcA(hwnd, message, wp, lp);
11165 }
11166
11167 static void set_menu_style(HMENU hmenu, DWORD style)
11168 {
11169 MENUINFO mi;
11170 BOOL ret;
11171
11172 mi.cbSize = sizeof(mi);
11173 mi.fMask = MIM_STYLE;
11174 mi.dwStyle = style;
11175 SetLastError(0xdeadbeef);
11176 ret = pSetMenuInfo(hmenu, &mi);
11177 ok(ret, "SetMenuInfo error %u\n", GetLastError());
11178 }
11179
11180 static DWORD get_menu_style(HMENU hmenu)
11181 {
11182 MENUINFO mi;
11183 BOOL ret;
11184
11185 mi.cbSize = sizeof(mi);
11186 mi.fMask = MIM_STYLE;
11187 mi.dwStyle = 0;
11188 SetLastError(0xdeadbeef);
11189 ret = pGetMenuInfo(hmenu, &mi);
11190 ok(ret, "GetMenuInfo error %u\n", GetLastError());
11191
11192 return mi.dwStyle;
11193 }
11194
11195 static void test_menu_messages(void)
11196 {
11197 MSG msg;
11198 WNDCLASSA cls;
11199 HMENU hmenu, hmenu_popup;
11200 HWND hwnd;
11201 DWORD style;
11202
11203 if (!pGetMenuInfo || !pSetMenuInfo)
11204 {
11205 skip("GetMenuInfo and/or SetMenuInfo are not available\n");
11206 return;
11207 }
11208 cls.style = 0;
11209 cls.lpfnWndProc = parent_menu_proc;
11210 cls.cbClsExtra = 0;
11211 cls.cbWndExtra = 0;
11212 cls.hInstance = GetModuleHandleA(0);
11213 cls.hIcon = 0;
11214 cls.hCursor = LoadCursorA(0, IDC_ARROW);
11215 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
11216 cls.lpszMenuName = NULL;
11217 cls.lpszClassName = "TestMenuClass";
11218 UnregisterClass(cls.lpszClassName, cls.hInstance);
11219 if (!RegisterClassA(&cls)) assert(0);
11220
11221 SetLastError(0xdeadbeef);
11222 hwnd = CreateWindowExA(0, "TestMenuClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
11223 100, 100, 200, 200, 0, 0, 0, NULL);
11224 ok(hwnd != 0, "LoadMenuA error %u\n", GetLastError());
11225
11226 SetLastError(0xdeadbeef);
11227 hmenu = LoadMenuA(GetModuleHandle(0), MAKEINTRESOURCE(1));
11228 ok(hmenu != 0, "LoadMenuA error %u\n", GetLastError());
11229
11230 SetMenu(hwnd, hmenu);
11231 SetForegroundWindow( hwnd );
11232
11233 set_menu_style(hmenu, MNS_NOTIFYBYPOS);
11234 style = get_menu_style(hmenu);
11235 ok(style == MNS_NOTIFYBYPOS, "expected MNS_NOTIFYBYPOS, got %u\n", style);
11236
11237 hmenu_popup = GetSubMenu(hmenu, 0);
11238 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
11239 style = get_menu_style(hmenu_popup);
11240 ok(style == 0, "expected 0, got %u\n", style);
11241
11242 hmenu_popup = GetSubMenu(hmenu_popup, 0);
11243 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
11244 style = get_menu_style(hmenu_popup);
11245 ok(style == 0, "expected 0, got %u\n", style);
11246
11247 /* Alt+E, Enter */
11248 trace("testing a popup menu command\n");
11249 flush_sequence();
11250 keybd_event(VK_MENU, 0, 0, 0);
11251 keybd_event('E', 0, 0, 0);
11252 keybd_event('E', 0, KEYEVENTF_KEYUP, 0);
11253 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
11254 keybd_event(VK_RETURN, 0, 0, 0);
11255 keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
11256 while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
11257 {
11258 TranslateMessage(&msg);
11259 DispatchMessage(&msg);
11260 }
11261 ok_sequence(wm_popup_menu_1, "popup menu command", FALSE);
11262
11263 /* Alt+F, Right, Enter */
11264 trace("testing submenu of a popup menu command\n");
11265 flush_sequence();
11266 keybd_event(VK_MENU, 0, 0, 0);
11267 keybd_event('F', 0, 0, 0);
11268 keybd_event('F', 0, KEYEVENTF_KEYUP, 0);
11269 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
11270 keybd_event(VK_RIGHT, 0, 0, 0);
11271 keybd_event(VK_RIGHT, 0, KEYEVENTF_KEYUP, 0);
11272 keybd_event(VK_RETURN, 0, 0, 0);
11273 keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
11274 while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
11275 {
11276 TranslateMessage(&msg);
11277 DispatchMessage(&msg);
11278 }
11279 ok_sequence(wm_popup_menu_2, "submenu of a popup menu command", FALSE);
11280
11281 set_menu_style(hmenu, 0);
11282 style = get_menu_style(hmenu);
11283 ok(style == 0, "expected 0, got %u\n", style);
11284
11285 hmenu_popup = GetSubMenu(hmenu, 0);
11286 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
11287 set_menu_style(hmenu_popup, MNS_NOTIFYBYPOS);
11288 style = get_menu_style(hmenu_popup);
11289 ok(style == MNS_NOTIFYBYPOS, "expected MNS_NOTIFYBYPOS, got %u\n", style);
11290
11291 hmenu_popup = GetSubMenu(hmenu_popup, 0);
11292 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
11293 style = get_menu_style(hmenu_popup);
11294 ok(style == 0, "expected 0, got %u\n", style);
11295
11296 /* Alt+F, Right, Enter */
11297 trace("testing submenu of a popup menu command\n");
11298 flush_sequence();
11299 keybd_event(VK_MENU, 0, 0, 0);
11300 keybd_event('F', 0, 0, 0);
11301 keybd_event('F', 0, KEYEVENTF_KEYUP, 0);
11302 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
11303 keybd_event(VK_RIGHT, 0, 0, 0);
11304 keybd_event(VK_RIGHT, 0, KEYEVENTF_KEYUP, 0);
11305 keybd_event(VK_RETURN, 0, 0, 0);
11306 keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
11307 while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
11308 {
11309 TranslateMessage(&msg);
11310 DispatchMessage(&msg);
11311 }
11312 ok_sequence(wm_popup_menu_3, "submenu of a popup menu command", FALSE);
11313
11314 DestroyWindow(hwnd);
11315 DestroyMenu(hmenu);
11316 }
11317
11318
11319 static void test_paintingloop(void)
11320 {
11321 HWND hwnd;
11322
11323 paint_loop_done = 0;
11324 hwnd = CreateWindowExA(0x0,"PaintLoopWindowClass",
11325 "PaintLoopWindowClass",WS_OVERLAPPEDWINDOW,
11326 100, 100, 100, 100, 0, 0, 0, NULL );
11327 ok(hwnd != 0, "PaintLoop window error %u\n", GetLastError());
11328 ShowWindow(hwnd,SW_NORMAL);
11329 SetFocus(hwnd);
11330
11331 while (!paint_loop_done)
11332 {
11333 MSG msg;
11334 if (PeekMessageA(&msg, 0, 0, 0, 1))
11335 {
11336 TranslateMessage(&msg);
11337 DispatchMessage(&msg);
11338 }
11339 }
11340 DestroyWindow(hwnd);
11341 }
11342
11343 START_TEST(msg)
11344 {
11345 BOOL ret;
11346 FARPROC pIsWinEventHookInstalled = 0;/*GetProcAddress(user32, "IsWinEventHookInstalled");*/
11347
11348 init_procs();
11349
11350 if (!RegisterWindowClasses()) assert(0);
11351
11352 if (pSetWinEventHook)
11353 {
11354 hEvent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX,
11355 GetModuleHandleA(0), win_event_proc,
11356 0, GetCurrentThreadId(),
11357 WINEVENT_INCONTEXT);
11358 assert(hEvent_hook);
11359
11360 if (pIsWinEventHookInstalled)
11361 {
11362 UINT event;
11363 for (event = EVENT_MIN; event <= EVENT_MAX; event++)
11364 ok(pIsWinEventHookInstalled(event), "IsWinEventHookInstalled(%u) failed\n", event);
11365 }
11366 }
11367
11368 cbt_hook_thread_id = GetCurrentThreadId();
11369 hCBT_hook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, GetCurrentThreadId());
11370 if (!hCBT_hook) skip( "cannot set global hook, will skip hook tests\n" );
11371
11372 test_winevents();
11373
11374 /* Fix message sequences before removing 4 lines below */
11375 #if 1
11376 if (pUnhookWinEvent && hEvent_hook)
11377 {
11378 ret = pUnhookWinEvent(hEvent_hook);
11379 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
11380 pUnhookWinEvent = 0;
11381 }
11382 hEvent_hook = 0;
11383 #endif
11384
11385 test_ShowWindow();
11386 test_PeekMessage();
11387 test_PeekMessage2();
11388 test_scrollwindowex();
11389 test_messages();
11390 test_setwindowpos();
11391 test_showwindow();
11392 invisible_parent_tests();
11393 test_mdi_messages();
11394 test_button_messages();
11395 test_static_messages();
11396 test_listbox_messages();
11397 test_combobox_messages();
11398 test_wmime_keydown_message();
11399 test_paint_messages();
11400 test_interthread_messages();
11401 test_message_conversion();
11402 test_accelerators();
11403 test_timers();
11404 test_timers_no_wnd();
11405 if (hCBT_hook) test_set_hook();
11406 test_DestroyWindow();
11407 test_DispatchMessage();
11408 test_SendMessageTimeout();
11409 test_edit_messages();
11410 test_quit_message();
11411 test_SetActiveWindow();
11412
11413 if (!pTrackMouseEvent)
11414 skip("TrackMouseEvent is not available\n");
11415 else
11416 test_TrackMouseEvent();
11417
11418 test_SetWindowRgn();
11419 test_sys_menu();
11420 test_dialog_messages();
11421 test_nullCallback();
11422 test_dbcs_wm_char();
11423 test_menu_messages();
11424 test_paintingloop();
11425 /* keep it the last test, under Windows it tends to break the tests
11426 * which rely on active/foreground windows being correct.
11427 */
11428 test_SetForegroundWindow();
11429
11430 UnhookWindowsHookEx(hCBT_hook);
11431 if (pUnhookWinEvent)
11432 {
11433 ret = pUnhookWinEvent(hEvent_hook);
11434 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
11435 SetLastError(0xdeadbeef);
11436 ok(!pUnhookWinEvent(hEvent_hook), "UnhookWinEvent succeeded\n");
11437 ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
11438 GetLastError() == 0xdeadbeef, /* Win9x */
11439 "unexpected error %d\n", GetLastError());
11440 }
11441 else
11442 skip("UnhookWinEvent is not available\n");
11443 }
useful hacks and other patches not (yet) suitable for mainline