?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
user32/tests: Use EqualRect() instead of open coding it.
[wine.git] / dlls / user32 / tests / msg.c
blob5ab639b51512c92f5a5fcbcf292bcf5916e7241a
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 0x0600 /* For WM_CHANGEUISTATE,QS_RAWINPUT,WM_DWMxxxx */
24 #define WINVER 0x0600 /* for WM_GETTITLEBARINFOEX */
25
26 #include <assert.h>
27 #include <limits.h>
28 #include <stdarg.h>
29 #include <stdio.h>
30
31 #include "windef.h"
32 #include "winbase.h"
33 #include "wingdi.h"
34 #include "winuser.h"
35 #include "winnls.h"
36 #include "dbt.h"
37
38 #include "wine/test.h"
39
40 #define MDI_FIRST_CHILD_ID 2004
41
42 /* undocumented SWP flags - from SDK 3.1 */
43 #define SWP_NOCLIENTSIZE 0x0800
44 #define SWP_NOCLIENTMOVE 0x1000
45 #define SWP_STATECHANGED 0x8000
46
47 #define SW_NORMALNA 0xCC /* undoc. flag in MinMaximize */
48
49 #ifndef WM_KEYF1
50 #define WM_KEYF1 0x004d
51 #endif
52
53 #ifndef WM_SYSTIMER
54 #define WM_SYSTIMER 0x0118
55 #endif
56
57 #define WND_PARENT_ID 1
58 #define WND_POPUP_ID 2
59 #define WND_CHILD_ID 3
60
61 #ifndef WM_LBTRACKPOINT
62 #define WM_LBTRACKPOINT 0x0131
63 #endif
64
65 #ifdef __i386__
66 #define ARCH "x86"
67 #elif defined __x86_64__
68 #define ARCH "amd64"
69 #elif defined __arm__
70 #define ARCH "arm"
71 #elif defined __aarch64__
72 #define ARCH "arm64"
73 #else
74 #define ARCH "none"
75 #endif
76
77 static BOOL (WINAPI *pActivateActCtx)(HANDLE,ULONG_PTR*);
78 static HANDLE (WINAPI *pCreateActCtxW)(PCACTCTXW);
79 static BOOL (WINAPI *pDeactivateActCtx)(DWORD,ULONG_PTR);
80 static BOOL (WINAPI *pGetCurrentActCtx)(HANDLE *);
81 static BOOL (WINAPI *pQueryActCtxW)(DWORD,HANDLE,void*,ULONG,void*,SIZE_T,SIZE_T*);
82 static void (WINAPI *pReleaseActCtx)(HANDLE);
83
84 /* encoded DRAWITEMSTRUCT into an LPARAM */
85 typedef struct
86 {
87 union
88 {
89 struct
90 {
91 UINT type : 4; /* ODT_* flags */
92 UINT ctl_id : 4; /* Control ID */
93 UINT item_id : 4; /* Menu item ID */
94 UINT action : 4; /* ODA_* flags */
95 UINT state : 16; /* ODS_* flags */
96 } item;
97 LPARAM lp;
98 } u;
99 } DRAW_ITEM_STRUCT;
100
101 static BOOL test_DestroyWindow_flag;
102 static HWINEVENTHOOK hEvent_hook;
103 static HHOOK hKBD_hook;
104 static HHOOK hCBT_hook;
105 static DWORD cbt_hook_thread_id;
106
107 static const WCHAR testWindowClassW[] =
108 { 'T','e','s','t','W','i','n','d','o','w','C','l','a','s','s','W',0 };
109
110 /*
111 FIXME: add tests for these
112 Window Edge Styles (Win31/Win95/98 look), in order of precedence:
113 WS_EX_DLGMODALFRAME: double border, WS_CAPTION allowed
114 WS_THICKFRAME: thick border
115 WS_DLGFRAME: double border, WS_CAPTION not allowed (but possibly shown anyway)
116 WS_BORDER (default for overlapped windows): single black border
117 none (default for child (and popup?) windows): no border
118 */
119
120 typedef enum {
121 sent=0x1,
122 posted=0x2,
123 parent=0x4,
124 wparam=0x8,
125 lparam=0x10,
126 defwinproc=0x20,
127 beginpaint=0x40,
128 optional=0x80,
129 hook=0x100,
130 winevent_hook=0x200,
131 kbd_hook=0x400
132 } msg_flags_t;
133
134 struct message {
135 UINT message; /* the WM_* code */
136 msg_flags_t flags; /* message props */
137 WPARAM wParam; /* expected value of wParam */
138 LPARAM lParam; /* expected value of lParam */
139 WPARAM wp_mask; /* mask for wParam checks */
140 LPARAM lp_mask; /* mask for lParam checks */
141 };
142
143 struct recvd_message {
144 UINT message; /* the WM_* code */
145 msg_flags_t flags; /* message props */
146 HWND hwnd; /* window that received the message */
147 WPARAM wParam; /* expected value of wParam */
148 LPARAM lParam; /* expected value of lParam */
149 int line; /* source line where logged */
150 const char *descr; /* description for trace output */
151 char output[512]; /* trace output */
152 };
153
154 /* Empty message sequence */
155 static const struct message WmEmptySeq[] =
156 {
157 { 0 }
158 };
159 /* CreateWindow (for overlapped window, not initially visible) (16/32) */
160 static const struct message WmCreateOverlappedSeq[] = {
161 { HCBT_CREATEWND, hook },
162 { WM_GETMINMAXINFO, sent },
163 { WM_NCCREATE, sent },
164 { WM_NCCALCSIZE, sent|wparam, 0 },
165 { 0x0093, sent|defwinproc|optional },
166 { 0x0094, sent|defwinproc|optional },
167 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
168 { WM_CREATE, sent },
169 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
170 { 0 }
171 };
172 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
173 * for a not visible overlapped window.
174 */
175 static const struct message WmSWP_ShowOverlappedSeq[] = {
176 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
177 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
178 { WM_NCPAINT, sent|wparam|optional, 1 },
179 { WM_GETTEXT, sent|defwinproc|optional },
180 { WM_ERASEBKGND, sent|optional },
181 { HCBT_ACTIVATE, hook },
182 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
183 { WM_NOTIFYFORMAT, sent|optional },
184 { WM_QUERYUISTATE, sent|optional },
185 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
186 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* Win9x: SWP_NOSENDCHANGING */
187 { WM_ACTIVATEAPP, sent|wparam, 1 },
188 { WM_NCACTIVATE, sent },
189 { WM_GETTEXT, sent|defwinproc|optional },
190 { WM_ACTIVATE, sent|wparam, 1 },
191 { HCBT_SETFOCUS, hook },
192 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
193 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
194 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
195 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
196 { WM_GETTEXT, sent|optional },
197 { WM_NCPAINT, sent|wparam|optional, 1 },
198 { WM_GETTEXT, sent|defwinproc|optional },
199 { WM_ERASEBKGND, sent|optional },
200 /* Win9x adds SWP_NOZORDER below */
201 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
202 { WM_GETTEXT, sent|optional },
203 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
204 { WM_NCPAINT, sent|wparam|optional, 1 },
205 { WM_ERASEBKGND, sent|optional },
206 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
207 { WM_SYNCPAINT, sent|optional },
208 { WM_GETTITLEBARINFOEX, sent|optional },
209 { WM_PAINT, sent|optional },
210 { WM_NCPAINT, sent|beginpaint|optional },
211 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
212 { WM_ERASEBKGND, sent|beginpaint|optional },
213 { 0 }
214 };
215 /* SetWindowPos(SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE)
216 * for a visible overlapped window.
217 */
218 static const struct message WmSWP_HideOverlappedSeq[] = {
219 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
220 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
221 { HCBT_ACTIVATE, hook|optional },
222 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
223 { WM_ACTIVATEAPP, sent|wparam|optional, 1 },
224 { WM_NCACTIVATE, sent|optional },
225 { WM_ACTIVATE, sent|optional },
226 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
227 { 0 }
228 };
229
230 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE)
231 * for a visible overlapped window.
232 */
233 static const struct message WmSWP_ResizeSeq[] = {
234 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE },
235 { WM_GETMINMAXINFO, sent|defwinproc },
236 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
237 { WM_NCPAINT, sent|optional },
238 { WM_GETTEXT, sent|defwinproc|optional },
239 { WM_ERASEBKGND, sent|optional },
240 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
241 { WM_SIZE, sent|defwinproc|optional },
242 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
243 { WM_NCPAINT, sent|optional },
244 { WM_GETTEXT, sent|defwinproc|optional },
245 { WM_ERASEBKGND, sent|optional },
246 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
247 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
248 { 0 }
249 };
250
251 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE)
252 * for a visible popup window.
253 */
254 static const struct message WmSWP_ResizePopupSeq[] = {
255 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE },
256 { WM_GETMINMAXINFO, sent|defwinproc|optional }, /* Win9x */
257 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
258 { WM_NCPAINT, sent|optional },
259 { WM_GETTEXT, sent|defwinproc|optional },
260 { WM_ERASEBKGND, sent|optional },
261 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
262 { WM_SIZE, sent|defwinproc|wparam|optional, SIZE_RESTORED },
263 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
264 { WM_NCPAINT, sent|optional },
265 { WM_GETTEXT, sent|defwinproc|optional },
266 { WM_ERASEBKGND, sent|optional },
267 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
268 { 0 }
269 };
270
271 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE)
272 * for a visible overlapped window.
273 */
274 static const struct message WmSWP_MoveSeq[] = {
275 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOSIZE },
276 { WM_NCPAINT, sent|optional },
277 { WM_GETTEXT, sent|defwinproc|optional },
278 { WM_ERASEBKGND, sent|optional },
279 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOCLIENTSIZE },
280 { WM_MOVE, sent|defwinproc|wparam, 0 },
281 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
282 { 0 }
283 };
284 /* Resize with SetWindowPos(SWP_NOZORDER)
285 * for a visible overlapped window
286 * SWP_NOZORDER is stripped by the logging code
287 */
288 static const struct message WmSWP_ResizeNoZOrder[] = {
289 { WM_WINDOWPOSCHANGING, sent|wparam, /*SWP_NOZORDER|*/SWP_NOACTIVATE },
290 { WM_GETMINMAXINFO, sent|defwinproc },
291 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
292 { WM_NCPAINT, sent|optional },
293 { WM_GETTEXT, sent|defwinproc|optional },
294 { WM_ERASEBKGND, sent|optional },
295 { WM_WINDOWPOSCHANGED, sent|wparam|optional, /*SWP_NOZORDER|*/SWP_NOACTIVATE, 0,
296 SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOCLIENTSIZE },
297 { WM_MOVE, sent|defwinproc|optional },
298 { WM_SIZE, sent|defwinproc|optional },
299 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* Win9x doesn't send it */
300 { WM_NCPAINT, sent|optional }, /* Win9x doesn't send it */
301 { WM_GETTEXT, sent|defwinproc|optional }, /* Win9x doesn't send it */
302 { WM_ERASEBKGND, sent|optional }, /* Win9x doesn't send it */
303 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
304 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
305 { 0 }
306 };
307
308 /* Switch visible mdi children */
309 static const struct message WmSwitchChild[] = {
310 /* Switch MDI child */
311 { WM_MDIACTIVATE, sent },/* in the MDI client */
312 { WM_WINDOWPOSCHANGING, sent|wparam,SWP_NOSIZE|SWP_NOMOVE },/* in the 1st MDI child */
313 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
314 { WM_CHILDACTIVATE, sent },/* in the 1st MDI child */
315 /* Deactivate 2nd MDI child */
316 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 2nd MDI child */
317 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 2nd MDI child */
318 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
319 /* Preparing for maximize and maximize the 1st MDI child */
320 { WM_GETMINMAXINFO, sent|defwinproc }, /* in the 1st MDI child */
321 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_STATECHANGED }, /* in the 1st MDI child */
322 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 }, /* in the 1st MDI child */
323 { WM_CHILDACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
324 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED }, /* in the 1st MDI child */
325 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED }, /* in the 1st MDI child */
326 /* Lock redraw 2nd MDI child */
327 { WM_SETREDRAW, sent|wparam|defwinproc, 0 }, /* in the 2nd MDI child */
328 { HCBT_MINMAX, hook|lparam, 0, SW_NORMALNA },
329 /* Restore 2nd MDI child */
330 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED },/* in the 2nd MDI child */
331 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },/* in the 2nd MDI child */
332 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 }, /* in the 2nd MDI child */
333 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED }, /* in the 2nd MDI child */
334 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED }, /* in the 2nd MDI child */
335 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* in the 2nd MDI child */
336 /* Redraw 2nd MDI child */
337 { WM_SETREDRAW, sent|wparam|defwinproc, 1 },/* in the 2nd MDI child */
338 /* Redraw MDI frame */
339 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },/* in MDI frame */
340 { WM_NCCALCSIZE, sent|wparam, 1 },/* in MDI frame */
341 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE}, /* in MDI frame */
342 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* in MDI frame */
343 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* in the 1st MDI child */
344 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE }, /* in the 1st MDI child */
345 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 }, /* in the 1st MDI child */
346 { HCBT_SETFOCUS, hook },
347 { WM_KILLFOCUS, sent|defwinproc }, /* in the 2nd MDI child */
348 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },/* in the 1st MDI child */
349 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
350 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
351 { WM_SETFOCUS, sent },/* in the MDI client */
352 { HCBT_SETFOCUS, hook },
353 { WM_KILLFOCUS, sent },/* in the MDI client */
354 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
355 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 }, /* in the 1st MDI child */
356 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
357 { WM_SETFOCUS, sent|defwinproc }, /* in the 1st MDI child */
358 { WM_MDIACTIVATE, sent|defwinproc },/* in the 1st MDI child */
359 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE }, /* in the 1st MDI child */
360 { 0 }
361 };
362
363 /* Switch visible not maximized mdi children */
364 static const struct message WmSwitchNotMaximizedChild[] = {
365 /* Switch not maximized MDI child */
366 { WM_MDIACTIVATE, sent },/* in the MDI client */
367 { WM_WINDOWPOSCHANGING, sent|wparam,SWP_NOSIZE|SWP_NOMOVE },/* in the 2nd MDI child */
368 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
369 { WM_CHILDACTIVATE, sent },/* in the 2nd MDI child */
370 /* Deactivate 1st MDI child */
371 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
372 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
373 /* Activate 2nd MDI child */
374 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE}, /* in the 2nd MDI child */
375 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 }, /* in the 2nd MDI child */
376 { HCBT_SETFOCUS, hook }, /* in the 1st MDI child */
377 { WM_KILLFOCUS, sent|defwinproc }, /* in the 1st MDI child */
378 { WM_IME_SETCONTEXT, sent|defwinproc|optional }, /* in the 1st MDI child */
379 { WM_IME_SETCONTEXT, sent|optional }, /* in the MDI client */
380 { WM_SETFOCUS, sent, 0 }, /* in the MDI client */
381 { HCBT_SETFOCUS, hook },
382 { WM_KILLFOCUS, sent }, /* in the MDI client */
383 { WM_IME_SETCONTEXT, sent|optional }, /* in the MDI client */
384 { WM_IME_SETCONTEXT, sent|defwinproc|optional }, /* in the 1st MDI child */
385 { WM_SETFOCUS, sent|defwinproc }, /* in the 2nd MDI child */
386 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 2nd MDI child */
387 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE}, /* in the 2nd MDI child */
388 { 0 }
389 };
390
391
392 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|
393 SWP_NOZORDER|SWP_FRAMECHANGED)
394 * for a visible overlapped window with WS_CLIPCHILDREN style set.
395 */
396 static const struct message WmSWP_FrameChanged_clip[] = {
397 { WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED },
398 { WM_NCCALCSIZE, sent|wparam|parent, 1 },
399 { WM_NCPAINT, sent|parent|optional }, /* wparam != 1 */
400 { WM_GETTEXT, sent|parent|defwinproc|optional },
401 { WM_ERASEBKGND, sent|parent|optional }, /* FIXME: remove optional once Wine is fixed */
402 { WM_NCPAINT, sent }, /* wparam != 1 */
403 { WM_ERASEBKGND, sent },
404 { WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
405 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
406 { WM_PAINT, sent },
407 { 0 }
408 };
409 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|
410 SWP_NOZORDER|SWP_FRAMECHANGED)
411 * for a visible overlapped window.
412 */
413 static const struct message WmSWP_FrameChangedDeferErase[] = {
414 { WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|SWP_FRAMECHANGED },
415 { WM_NCCALCSIZE, sent|wparam|parent, 1 },
416 { WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
417 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
418 { WM_PAINT, sent|parent|optional },
419 { WM_NCPAINT, sent|beginpaint|parent|optional }, /* wparam != 1 */
420 { WM_GETTEXT, sent|beginpaint|parent|defwinproc|optional },
421 { WM_PAINT, sent },
422 { WM_NCPAINT, sent|beginpaint }, /* wparam != 1 */
423 { WM_ERASEBKGND, sent|beginpaint|optional },
424 { 0 }
425 };
426
427 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|
428 SWP_NOZORDER|SWP_FRAMECHANGED)
429 * for a visible overlapped window without WS_CLIPCHILDREN style set.
430 */
431 static const struct message WmSWP_FrameChanged_noclip[] = {
432 { WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED },
433 { WM_NCCALCSIZE, sent|wparam|parent, 1 },
434 { WM_NCPAINT, sent|parent|optional }, /* wparam != 1 */
435 { WM_GETTEXT, sent|parent|defwinproc|optional },
436 { WM_ERASEBKGND, sent|parent|optional },
437 { WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
438 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
439 { WM_PAINT, sent },
440 { WM_NCPAINT, sent|beginpaint }, /* wparam != 1 */
441 { WM_ERASEBKGND, sent|beginpaint|optional },
442 { 0 }
443 };
444
445 /* ShowWindow(SW_SHOW) for a not visible overlapped window */
446 static const struct message WmShowOverlappedSeq[] = {
447 { WM_SHOWWINDOW, sent|wparam, 1 },
448 { WM_NCPAINT, sent|wparam|optional, 1 },
449 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
450 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
451 { WM_NCPAINT, sent|wparam|optional, 1 },
452 { WM_GETTEXT, sent|defwinproc|optional },
453 { WM_ERASEBKGND, sent|optional },
454 { HCBT_ACTIVATE, hook|optional },
455 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
456 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
457 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
458 { WM_NCPAINT, sent|wparam|optional, 1 },
459 { WM_ACTIVATEAPP, sent|wparam|optional, 1 },
460 { WM_NCACTIVATE, sent|wparam|optional, 1 },
461 { WM_GETTEXT, sent|defwinproc|optional },
462 { WM_ACTIVATE, sent|wparam|optional, 1 },
463 { HCBT_SETFOCUS, hook|optional },
464 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
465 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
466 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
467 { WM_SETFOCUS, sent|wparam|defwinproc|optional, 0 },
468 { WM_GETTEXT, sent|optional },
469 { WM_NCPAINT, sent|wparam|optional, 1 },
470 { WM_GETTEXT, sent|defwinproc|optional },
471 { WM_ERASEBKGND, sent|optional },
472 /* Win9x adds SWP_NOZORDER below */
473 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
474 { WM_NCCALCSIZE, sent|optional },
475 { WM_GETTEXT, sent|optional },
476 { WM_NCPAINT, sent|optional },
477 { WM_ERASEBKGND, sent|optional },
478 { WM_SYNCPAINT, sent|optional },
479 #if 0 /* CreateWindow/ShowWindow(SW_SHOW) also generates WM_SIZE/WM_MOVE
480 * messages. Does that mean that CreateWindow doesn't set initial
481 * window dimensions for overlapped windows?
482 */
483 { WM_SIZE, sent },
484 { WM_MOVE, sent },
485 #endif
486 { WM_PAINT, sent|optional },
487 { WM_NCPAINT, sent|beginpaint|optional },
488 { 0 }
489 };
490 /* ShowWindow(SW_SHOWMAXIMIZED) for a not visible overlapped window */
491 static const struct message WmShowMaxOverlappedSeq[] = {
492 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
493 { WM_GETMINMAXINFO, sent },
494 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
495 { WM_GETMINMAXINFO, sent|defwinproc },
496 { WM_NCCALCSIZE, sent|wparam, TRUE },
497 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
498 { HCBT_ACTIVATE, hook|optional },
499 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
500 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
501 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
502 { WM_ACTIVATEAPP, sent|wparam|optional, 1 },
503 { WM_NCACTIVATE, sent|wparam|optional, 1 },
504 { WM_GETTEXT, sent|defwinproc|optional },
505 { WM_ACTIVATE, sent|wparam|optional, 1 },
506 { HCBT_SETFOCUS, hook|optional },
507 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
508 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
509 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
510 { WM_SETFOCUS, sent|wparam|defwinproc|optional, 0 },
511 { WM_GETTEXT, sent|optional },
512 { WM_NCPAINT, sent|wparam|optional, 1 },
513 { WM_GETTEXT, sent|defwinproc|optional },
514 { WM_ERASEBKGND, sent|optional },
515 /* Win9x adds SWP_NOZORDER below */
516 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
517 { WM_MOVE, sent|defwinproc },
518 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
519 { WM_GETTEXT, sent|optional },
520 { WM_NCCALCSIZE, sent|optional },
521 { WM_NCPAINT, sent|optional },
522 { WM_ERASEBKGND, sent|optional },
523 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
524 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
525 { WM_SYNCPAINT, sent|optional },
526 { WM_GETTITLEBARINFOEX, sent|optional },
527 { WM_PAINT, sent|optional },
528 { WM_NCPAINT, sent|beginpaint|optional },
529 { WM_ERASEBKGND, sent|beginpaint|optional },
530 { 0 }
531 };
532 /* ShowWindow(SW_RESTORE) for a not visible maximized overlapped window */
533 static const struct message WmShowRestoreMaxOverlappedSeq[] = {
534 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
535 { WM_GETTEXT, sent|optional },
536 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
537 { WM_GETMINMAXINFO, sent|defwinproc },
538 { WM_NCCALCSIZE, sent|wparam, TRUE },
539 { WM_NCPAINT, sent|optional },
540 { WM_GETTEXT, sent|defwinproc|optional },
541 { WM_ERASEBKGND, sent|optional },
542 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
543 { WM_MOVE, sent|defwinproc|optional },
544 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
545 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
546 { WM_NCPAINT, sent|optional },
547 { WM_ERASEBKGND, sent|optional },
548 { WM_PAINT, sent|optional },
549 { WM_GETTITLEBARINFOEX, sent|optional },
550 { WM_NCPAINT, sent|beginpaint|optional },
551 { WM_ERASEBKGND, sent|beginpaint|optional },
552 { 0 }
553 };
554 /* ShowWindow(SW_RESTORE) for a not visible minimized overlapped window */
555 static const struct message WmShowRestoreMinOverlappedSeq[] = {
556 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
557 { WM_QUERYOPEN, sent|optional },
558 { WM_GETTEXT, sent|optional },
559 { WM_NCACTIVATE, sent|wparam|optional, 1 },
560 { WM_WINDOWPOSCHANGING, sent|optional }, /* SWP_NOSIZE|SWP_NOMOVE */
561 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
562 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
563 { WM_MOVE, sent|optional },
564 { WM_SIZE, sent|wparam|optional, SIZE_RESTORED },
565 { WM_GETTEXT, sent|optional },
566 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED|SWP_NOCOPYBITS },
567 { WM_GETMINMAXINFO, sent|defwinproc|optional },
568 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
569 { HCBT_ACTIVATE, hook|optional },
570 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
571 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
572 { WM_ACTIVATEAPP, sent|wparam|optional, 1 },
573 { WM_NCACTIVATE, sent|wparam|optional, 1 },
574 { WM_GETTEXT, sent|defwinproc|optional },
575 { WM_ACTIVATE, sent|wparam|optional, 1 },
576 { HCBT_SETFOCUS, hook|optional },
577 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
578 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
579 { WM_SETFOCUS, sent|wparam|defwinproc|optional, 0 },
580 { WM_GETTEXT, sent|optional },
581 { WM_NCPAINT, sent|wparam|optional, 1 },
582 { WM_GETTEXT, sent|defwinproc|optional },
583 { WM_ERASEBKGND, sent },
584 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_STATECHANGED|SWP_FRAMECHANGED|SWP_NOCOPYBITS },
585 { WM_MOVE, sent|defwinproc },
586 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
587 { HCBT_SETFOCUS, hook|optional },
588 { WM_SETFOCUS, sent|wparam|optional, 0 },
589 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
590 { WM_NCPAINT, sent|wparam|optional, 1 },
591 { WM_ERASEBKGND, sent|optional },
592 { HCBT_SETFOCUS, hook|optional },
593 { WM_SETFOCUS, sent|wparam|optional, 0 },
594 { WM_ACTIVATE, sent|wparam, 1 },
595 { WM_GETTEXT, sent|optional },
596 { WM_PAINT, sent|optional },
597 { WM_GETTITLEBARINFOEX, sent|optional },
598 { WM_NCPAINT, sent|beginpaint|optional },
599 { WM_ERASEBKGND, sent|beginpaint|optional },
600 { 0 }
601 };
602 /* ShowWindow(SW_SHOWMINIMIZED) for a not visible overlapped window */
603 static const struct message WmShowMinOverlappedSeq[] = {
604 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
605 { HCBT_SETFOCUS, hook|optional },
606 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
607 { WM_KILLFOCUS, sent|optional },
608 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
609 { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
610 { WM_GETTEXT, sent|optional },
611 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOCOPYBITS|SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
612 { WM_GETMINMAXINFO, sent|defwinproc },
613 { WM_NCCALCSIZE, sent|wparam, TRUE },
614 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
615 { WM_NCPAINT, sent|optional },
616 { WM_GETTEXT, sent|defwinproc|optional },
617 { WM_WINDOWPOSCHANGED, sent },
618 { WM_MOVE, sent|defwinproc },
619 { WM_SIZE, sent|defwinproc|wparam|lparam, SIZE_MINIMIZED, 0 },
620 { WM_NCCALCSIZE, sent|optional },
621 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
622 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
623 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, 0, 0 },
624 { WM_NCACTIVATE, sent|wparam|optional, 0 },
625 { WM_GETTEXT, sent|defwinproc|optional },
626 { WM_ACTIVATE, sent|optional },
627 { WM_ACTIVATEAPP, sent|wparam|optional, 0 },
628
629 /* Vista sometimes restores the window right away... */
630 { WM_SYSCOMMAND, sent|optional|wparam, SC_RESTORE },
631 { HCBT_SYSCOMMAND, hook|optional|wparam, SC_RESTORE },
632 { HCBT_MINMAX, hook|optional|lparam, 0, SW_RESTORE },
633 { WM_QUERYOPEN, sent|optional },
634 { WM_WINDOWPOSCHANGING, sent|optional|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
635 { WM_GETMINMAXINFO, sent|optional|defwinproc },
636 { WM_NCCALCSIZE, sent|optional|wparam, TRUE },
637 { HCBT_ACTIVATE, hook|optional },
638 { WM_ACTIVATEAPP, sent|optional|wparam, 1 },
639 { WM_NCACTIVATE, sent|optional },
640 { WM_GETTEXT, sent|optional },
641 { WM_ACTIVATE, sent|optional|wparam, 1 },
642 { HCBT_SETFOCUS, hook|optional },
643 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
644 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
645 { WM_SETFOCUS, sent|optional },
646 { WM_NCPAINT, sent|optional },
647 { WM_GETTEXT, sent|defwinproc|optional },
648 { WM_ERASEBKGND, sent|optional },
649 { WM_WINDOWPOSCHANGED, sent|optional|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
650 { WM_MOVE, sent|defwinproc|optional },
651 { WM_SIZE, sent|defwinproc|optional|wparam, SIZE_RESTORED },
652 { WM_ACTIVATE, sent|optional|wparam, 1 },
653 { WM_SYSCOMMAND, sent|optional|wparam, SC_RESTORE },
654 { HCBT_SYSCOMMAND, hook|optional|wparam, SC_RESTORE },
655
656 { WM_PAINT, sent|optional },
657 { WM_NCPAINT, sent|beginpaint|optional },
658 { WM_ERASEBKGND, sent|beginpaint|optional },
659 { 0 }
660 };
661 /* ShowWindow(SW_HIDE) for a visible overlapped window */
662 static const struct message WmHideOverlappedSeq[] = {
663 { WM_SHOWWINDOW, sent|wparam, 0 },
664 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
665 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
666 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
667 { WM_SIZE, sent|optional }, /* XP doesn't send it */
668 { WM_MOVE, sent|optional }, /* XP doesn't send it */
669 { WM_NCACTIVATE, sent|wparam|optional, 0 },
670 { WM_ACTIVATE, sent|wparam|optional, 0 },
671 { WM_ACTIVATEAPP, sent|wparam|optional, 0 },
672 { HCBT_SETFOCUS, hook|optional },
673 { WM_KILLFOCUS, sent|wparam|optional, 0 },
674 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
675 { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
676 { 0 }
677 };
678 /* DestroyWindow for a visible overlapped window */
679 static const struct message WmDestroyOverlappedSeq[] = {
680 { HCBT_DESTROYWND, hook },
681 { 0x0090, sent|optional },
682 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
683 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
684 { 0x0090, sent|optional },
685 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
686 { WM_NCACTIVATE, sent|optional|wparam, 0 },
687 { WM_ACTIVATE, sent|optional },
688 { WM_ACTIVATEAPP, sent|optional|wparam, 0 },
689 { WM_KILLFOCUS, sent|optional|wparam, 0 },
690 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
691 { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
692 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
693 { WM_DESTROY, sent },
694 { WM_NCDESTROY, sent },
695 { 0 }
696 };
697 /* CreateWindow(WS_MAXIMIZE|WS_VISIBLE) for popup window */
698 static const struct message WmCreateMaxPopupSeq[] = {
699 { HCBT_CREATEWND, hook },
700 { WM_NCCREATE, sent },
701 { WM_NCCALCSIZE, sent|wparam, 0 },
702 { WM_CREATE, sent },
703 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
704 { WM_SIZE, sent|wparam, SIZE_RESTORED },
705 { WM_MOVE, sent },
706 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
707 { WM_GETMINMAXINFO, sent },
708 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED },
709 { WM_NCCALCSIZE, sent|wparam, TRUE },
710 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_STATECHANGED },
711 { WM_MOVE, sent|defwinproc },
712 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
713 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
714 { WM_SHOWWINDOW, sent|wparam, 1 },
715 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
716 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
717 { HCBT_ACTIVATE, hook },
718 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
719 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
720 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
721 { WM_NCPAINT, sent|wparam|optional, 1 },
722 { WM_ERASEBKGND, sent|optional },
723 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOCLIENTMOVE|SWP_NOCLIENTSIZE|SWP_NOMOVE|SWP_NOSIZE },
724 { WM_ACTIVATEAPP, sent|wparam, 1 },
725 { WM_NCACTIVATE, sent },
726 { WM_ACTIVATE, sent|wparam, 1 },
727 { HCBT_SETFOCUS, hook },
728 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
729 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
730 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
731 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
732 { WM_GETTEXT, sent|optional },
733 { WM_SYNCPAINT, sent|wparam|optional, 4 },
734 { WM_NCPAINT, sent|wparam|optional, 1 },
735 { WM_ERASEBKGND, sent|optional },
736 { WM_NCPAINT, sent|wparam|defwinproc|optional, 1 },
737 { WM_ERASEBKGND, sent|defwinproc|optional },
738 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTMOVE|SWP_NOCLIENTSIZE|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOSIZE },
739 { 0 }
740 };
741 /* CreateWindow(WS_MAXIMIZE) for popup window, not initially visible */
742 static const struct message WmCreateInvisibleMaxPopupSeq[] = {
743 { HCBT_CREATEWND, hook },
744 { WM_NCCREATE, sent },
745 { WM_NCCALCSIZE, sent|wparam, 0 },
746 { WM_CREATE, sent },
747 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
748 { WM_SIZE, sent|wparam, SIZE_RESTORED },
749 { WM_MOVE, sent },
750 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
751 { WM_GETMINMAXINFO, sent },
752 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED },
753 { WM_NCCALCSIZE, sent|wparam, TRUE },
754 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_STATECHANGED },
755 { WM_MOVE, sent|defwinproc },
756 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
757 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
758 { 0 }
759 };
760 /* ShowWindow(SW_SHOWMAXIMIZED) for a resized not visible popup window */
761 static const struct message WmShowMaxPopupResizedSeq[] = {
762 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
763 { WM_GETMINMAXINFO, sent },
764 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED },
765 { WM_NCCALCSIZE, sent|wparam, TRUE },
766 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
767 { HCBT_ACTIVATE, hook },
768 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
769 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
770 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
771 { WM_NCPAINT, sent|wparam|optional, 1 },
772 { WM_ERASEBKGND, sent|optional },
773 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
774 { WM_ACTIVATEAPP, sent|wparam, 1 },
775 { WM_NCACTIVATE, sent },
776 { WM_ACTIVATE, sent|wparam, 1 },
777 { HCBT_SETFOCUS, hook },
778 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
779 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
780 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
781 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
782 { WM_GETTEXT, sent|optional },
783 { WM_NCPAINT, sent|wparam|optional, 1 },
784 { WM_ERASEBKGND, sent|optional },
785 { WM_WINDOWPOSCHANGED, sent },
786 /* WinNT4.0 sends WM_MOVE */
787 { WM_MOVE, sent|defwinproc|optional },
788 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
789 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
790 { 0 }
791 };
792 /* ShowWindow(SW_SHOWMAXIMIZED) for a not visible popup window */
793 static const struct message WmShowMaxPopupSeq[] = {
794 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
795 { WM_GETMINMAXINFO, sent },
796 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED },
797 { WM_NCCALCSIZE, sent|wparam, TRUE },
798 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
799 { HCBT_ACTIVATE, hook },
800 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
801 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
802 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
803 { WM_NCPAINT, sent|wparam|optional, 1 },
804 { WM_ERASEBKGND, sent|optional },
805 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOMOVE|SWP_NOSIZE },
806 { WM_ACTIVATEAPP, sent|wparam, 1 },
807 { WM_NCACTIVATE, sent },
808 { WM_ACTIVATE, sent|wparam, 1 },
809 { HCBT_SETFOCUS, hook },
810 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
811 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
812 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
813 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
814 { WM_GETTEXT, sent|optional },
815 { WM_SYNCPAINT, sent|wparam|optional, 4 },
816 { WM_NCPAINT, sent|wparam|optional, 1 },
817 { WM_ERASEBKGND, sent|optional },
818 { WM_NCPAINT, sent|wparam|defwinproc|optional, 1 },
819 { WM_ERASEBKGND, sent|defwinproc|optional },
820 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOSIZE },
821 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
822 { 0 }
823 };
824 /* CreateWindow(WS_VISIBLE) for popup window */
825 static const struct message WmCreatePopupSeq[] = {
826 { HCBT_CREATEWND, hook },
827 { WM_NCCREATE, sent },
828 { WM_NCCALCSIZE, sent|wparam, 0 },
829 { WM_CREATE, sent },
830 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
831 { WM_SIZE, sent|wparam, SIZE_RESTORED },
832 { WM_MOVE, sent },
833 { WM_SHOWWINDOW, sent|wparam, 1 },
834 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
835 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
836 { HCBT_ACTIVATE, hook },
837 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
838 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
839 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
840 { WM_NCPAINT, sent|wparam|optional, 1 },
841 { WM_ERASEBKGND, sent|optional },
842 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
843 { WM_ACTIVATEAPP, sent|wparam, 1 },
844 { WM_NCACTIVATE, sent },
845 { WM_ACTIVATE, sent|wparam, 1 },
846 { HCBT_SETFOCUS, hook },
847 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
848 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
849 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
850 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
851 { WM_GETTEXT, sent|optional },
852 { WM_SYNCPAINT, sent|wparam|optional, 4 },
853 { WM_NCPAINT, sent|wparam|optional, 1 },
854 { WM_ERASEBKGND, sent|optional },
855 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTMOVE|SWP_NOCLIENTSIZE|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOSIZE },
856 { 0 }
857 };
858 /* ShowWindow(SW_SHOWMAXIMIZED) for a visible popup window */
859 static const struct message WmShowVisMaxPopupSeq[] = {
860 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
861 { WM_GETMINMAXINFO, sent },
862 { WM_GETTEXT, sent|optional },
863 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
864 { WM_GETTEXT, sent|optional },
865 { WM_NCCALCSIZE, sent|wparam, TRUE },
866 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
867 { WM_NCPAINT, sent|wparam|optional, 1 },
868 { WM_ERASEBKGND, sent|optional },
869 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
870 { WM_MOVE, sent|defwinproc },
871 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
872 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
873 { 0 }
874 };
875 /* CreateWindow (for a child popup window, not initially visible) */
876 static const struct message WmCreateChildPopupSeq[] = {
877 { HCBT_CREATEWND, hook },
878 { WM_NCCREATE, sent },
879 { WM_NCCALCSIZE, sent|wparam, 0 },
880 { WM_CREATE, sent },
881 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
882 { WM_SIZE, sent|wparam, SIZE_RESTORED },
883 { WM_MOVE, sent },
884 { 0 }
885 };
886 /* CreateWindow (for a popup window, not initially visible,
887 * which sets WS_VISIBLE in WM_CREATE handler)
888 */
889 static const struct message WmCreateInvisiblePopupSeq[] = {
890 { HCBT_CREATEWND, hook },
891 { WM_NCCREATE, sent },
892 { WM_NCCALCSIZE, sent|wparam, 0 },
893 { WM_CREATE, sent },
894 { WM_STYLECHANGING, sent },
895 { WM_STYLECHANGED, sent },
896 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
897 { WM_SIZE, sent|wparam, SIZE_RESTORED },
898 { WM_MOVE, sent },
899 { 0 }
900 };
901 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER)
902 * for a popup window with WS_VISIBLE style set
903 */
904 static const struct message WmShowVisiblePopupSeq_2[] = {
905 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
906 { 0 }
907 };
908 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
909 * for a popup window with WS_VISIBLE style set
910 */
911 static const struct message WmShowVisiblePopupSeq_3[] = {
912 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
913 { HCBT_ACTIVATE, hook },
914 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
915 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
916 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
917 { WM_NCACTIVATE, sent },
918 { WM_ACTIVATE, sent|wparam, 1 },
919 { HCBT_SETFOCUS, hook },
920 { WM_KILLFOCUS, sent|parent },
921 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
922 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
923 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
924 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
925 { WM_SETFOCUS, sent|defwinproc },
926 { WM_GETTEXT, sent|optional },
927 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE, 0, SWP_SHOWWINDOW },
928 { 0 }
929 };
930 /* CreateWindow (for child window, not initially visible) */
931 static const struct message WmCreateChildSeq[] = {
932 { HCBT_CREATEWND, hook },
933 { WM_NCCREATE, sent },
934 /* child is inserted into parent's child list after WM_NCCREATE returns */
935 { WM_NCCALCSIZE, sent|wparam, 0 },
936 { WM_CREATE, sent },
937 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
938 { WM_SIZE, sent|wparam, SIZE_RESTORED },
939 { WM_MOVE, sent },
940 { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
941 { 0 }
942 };
943 /* CreateWindow (for maximized child window, not initially visible) */
944 static const struct message WmCreateMaximizedChildSeq[] = {
945 { HCBT_CREATEWND, hook },
946 { WM_NCCREATE, sent },
947 { WM_NCCALCSIZE, sent|wparam, 0 },
948 { WM_CREATE, sent },
949 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
950 { WM_SIZE, sent|wparam, SIZE_RESTORED },
951 { WM_MOVE, sent },
952 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
953 { WM_GETMINMAXINFO, sent },
954 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
955 { WM_NCCALCSIZE, sent|wparam, 1 },
956 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
957 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
958 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
959 { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
960 { 0 }
961 };
962 /* CreateWindow (for a child window, initially visible) */
963 static const struct message WmCreateVisibleChildSeq[] = {
964 { HCBT_CREATEWND, hook },
965 { WM_NCCREATE, sent },
966 /* child is inserted into parent's child list after WM_NCCREATE returns */
967 { WM_NCCALCSIZE, sent|wparam, 0 },
968 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
969 { WM_CREATE, sent },
970 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
971 { WM_SIZE, sent|wparam, SIZE_RESTORED },
972 { WM_MOVE, sent },
973 { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
974 { WM_SHOWWINDOW, sent|wparam, 1 },
975 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
976 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
977 { WM_ERASEBKGND, sent|parent|optional },
978 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
979 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* WinXP */
980 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
981 { 0 }
982 };
983 /* ShowWindow(SW_SHOW) for a not visible child window */
984 static const struct message WmShowChildSeq[] = {
985 { WM_SHOWWINDOW, sent|wparam, 1 },
986 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
987 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
988 { WM_ERASEBKGND, sent|parent|optional },
989 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
990 { 0 }
991 };
992 /* ShowWindow(SW_HIDE) for a visible child window */
993 static const struct message WmHideChildSeq[] = {
994 { WM_SHOWWINDOW, sent|wparam, 0 },
995 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
996 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
997 { WM_ERASEBKGND, sent|parent|optional },
998 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
999 { 0 }
1000 };
1001 /* ShowWindow(SW_HIDE) for a visible child window checking all parent events*/
1002 static const struct message WmHideChildSeq2[] = {
1003 { WM_SHOWWINDOW, sent|wparam, 0 },
1004 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1005 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1006 { WM_ERASEBKGND, sent|parent|optional },
1007 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1008 { 0 }
1009 };
1010 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
1011 * for a not visible child window
1012 */
1013 static const struct message WmShowChildSeq_2[] = {
1014 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1015 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1016 { WM_CHILDACTIVATE, sent },
1017 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1018 { 0 }
1019 };
1020 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE)
1021 * for a not visible child window
1022 */
1023 static const struct message WmShowChildSeq_3[] = {
1024 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1025 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1026 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1027 { 0 }
1028 };
1029 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
1030 * for a visible child window with a caption
1031 */
1032 static const struct message WmShowChildSeq_4[] = {
1033 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1034 { WM_CHILDACTIVATE, sent },
1035 { 0 }
1036 };
1037 /* ShowWindow(SW_MINIMIZE) for child with invisible parent */
1038 static const struct message WmShowChildInvisibleParentSeq_1[] = {
1039 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
1040 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
1041 { WM_NCCALCSIZE, sent|wparam, 1 },
1042 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1043 { WM_CHILDACTIVATE, sent|optional },
1044 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
1045 { WM_MOVE, sent|defwinproc },
1046 { WM_SIZE, sent|defwinproc|wparam|lparam, SIZE_MINIMIZED, 0 },
1047 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1048 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, 0, 0 },
1049 /* FIXME: Wine creates an icon/title window while Windows doesn't */
1050 { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE },
1051 { WM_GETTEXT, sent|optional },
1052 { 0 }
1053 };
1054 /* repeated ShowWindow(SW_MINIMIZE) for child with invisible parent */
1055 static const struct message WmShowChildInvisibleParentSeq_1r[] = {
1056 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
1057 { 0 }
1058 };
1059 /* ShowWindow(SW_MAXIMIZE) for child with invisible parent */
1060 static const struct message WmShowChildInvisibleParentSeq_2[] = {
1061 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
1062 { WM_GETMINMAXINFO, sent },
1063 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
1064 { WM_NCCALCSIZE, sent|wparam, 1 },
1065 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1066 { WM_CHILDACTIVATE, sent },
1067 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
1068 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
1069 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1070 { 0 }
1071 };
1072 /* repeated ShowWindow(SW_MAXIMIZE) for child with invisible parent */
1073 static const struct message WmShowChildInvisibleParentSeq_2r[] = {
1074 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
1075 { 0 }
1076 };
1077 /* ShowWindow(SW_SHOWMINIMIZED) for child with invisible parent */
1078 static const struct message WmShowChildInvisibleParentSeq_3[] = {
1079 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
1080 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
1081 { WM_NCCALCSIZE, sent|wparam, 1 },
1082 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1083 { WM_CHILDACTIVATE, sent },
1084 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_NOCOPYBITS|SWP_STATECHANGED },
1085 { WM_MOVE, sent|defwinproc },
1086 { WM_SIZE, sent|defwinproc|wparam|lparam, SIZE_MINIMIZED, 0 },
1087 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1088 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, 0, 0 },
1089 /* FIXME: Wine creates an icon/title window while Windows doesn't */
1090 { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE },
1091 { WM_GETTEXT, sent|optional },
1092 { 0 }
1093 };
1094 /* repeated ShowWindow(SW_SHOWMINIMIZED) for child with invisible parent */
1095 static const struct message WmShowChildInvisibleParentSeq_3r[] = {
1096 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
1097 { 0 }
1098 };
1099 /* ShowWindow(SW_SHOWMINNOACTIVE) for child with invisible parent */
1100 static const struct message WmShowChildInvisibleParentSeq_4[] = {
1101 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
1102 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_STATECHANGED },
1103 { WM_NCCALCSIZE, sent|wparam, 1 },
1104 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1105 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_NOCOPYBITS|SWP_STATECHANGED },
1106 { WM_MOVE, sent|defwinproc },
1107 { WM_SIZE, sent|defwinproc|wparam|lparam, SIZE_MINIMIZED, 0 },
1108 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1109 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, 0, 0 },
1110 /* FIXME: Wine creates an icon/title window while Windows doesn't */
1111 { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE },
1112 { WM_GETTEXT, sent|optional },
1113 { 0 }
1114 };
1115 /* repeated ShowWindow(SW_SHOWMINNOACTIVE) for child with invisible parent */
1116 static const struct message WmShowChildInvisibleParentSeq_4r[] = {
1117 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
1118 { 0 }
1119 };
1120 /* ShowWindow(SW_SHOW) for child with invisible parent */
1121 static const struct message WmShowChildInvisibleParentSeq_5[] = {
1122 { WM_SHOWWINDOW, sent|wparam, 1 },
1123 { 0 }
1124 };
1125 /* ShowWindow(SW_HIDE) for child with invisible parent */
1126 static const struct message WmHideChildInvisibleParentSeq[] = {
1127 { WM_SHOWWINDOW, sent|wparam, 0 },
1128 { 0 }
1129 };
1130 /* SetWindowPos(SWP_SHOWWINDOW) for child with invisible parent */
1131 static const struct message WmShowChildInvisibleParentSeq_6[] = {
1132 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1133 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1134 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1135 { 0 }
1136 };
1137 /* SetWindowPos(SWP_HIDEWINDOW) for child with invisible parent */
1138 static const struct message WmHideChildInvisibleParentSeq_2[] = {
1139 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1140 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1141 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1142 { 0 }
1143 };
1144 /* DestroyWindow for a visible child window */
1145 static const struct message WmDestroyChildSeq[] = {
1146 { HCBT_DESTROYWND, hook },
1147 { 0x0090, sent|optional },
1148 { WM_PARENTNOTIFY, sent|parent|wparam, WM_DESTROY },
1149 { WM_SHOWWINDOW, sent|wparam, 0 },
1150 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1151 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1152 { WM_ERASEBKGND, sent|parent|optional },
1153 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1154 { HCBT_SETFOCUS, hook }, /* set focus to a parent */
1155 { WM_KILLFOCUS, sent },
1156 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1157 { WM_IME_SETCONTEXT, sent|wparam|parent|optional, 1 },
1158 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1159 { WM_SETFOCUS, sent|parent },
1160 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1161 { WM_DESTROY, sent },
1162 { WM_DESTROY, sent|optional }, /* some other (IME?) window */
1163 { WM_NCDESTROY, sent|optional }, /* some other (IME?) window */
1164 { WM_NCDESTROY, sent },
1165 { 0 }
1166 };
1167 /* visible child window destroyed by thread exit */
1168 static const struct message WmExitThreadSeq[] = {
1169 { WM_NCDESTROY, sent }, /* actually in grandchild */
1170 { WM_PAINT, sent|parent },
1171 { WM_ERASEBKGND, sent|parent|beginpaint },
1172 { 0 }
1173 };
1174 /* DestroyWindow for a visible child window with invisible parent */
1175 static const struct message WmDestroyInvisibleChildSeq[] = {
1176 { HCBT_DESTROYWND, hook },
1177 { 0x0090, sent|optional },
1178 { WM_PARENTNOTIFY, sent|parent|wparam, WM_DESTROY },
1179 { WM_SHOWWINDOW, sent|wparam, 0 },
1180 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1181 { WM_DESTROY, sent },
1182 { WM_NCDESTROY, sent },
1183 { 0 }
1184 };
1185 /* Resizing child window with MoveWindow (32) */
1186 static const struct message WmResizingChildWithMoveWindowSeq[] = {
1187 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
1188 { WM_NCCALCSIZE, sent|wparam, 1 },
1189 { WM_ERASEBKGND, sent|parent|optional },
1190 { WM_ERASEBKGND, sent|optional },
1191 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE },
1192 { WM_MOVE, sent|defwinproc },
1193 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1194 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1195 { 0 }
1196 };
1197 /* Creation of a custom dialog (32) */
1198 static const struct message WmCreateCustomDialogSeq[] = {
1199 { HCBT_CREATEWND, hook },
1200 { WM_GETMINMAXINFO, sent },
1201 { WM_NCCREATE, sent },
1202 { WM_NCCALCSIZE, sent|wparam, 0 },
1203 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1204 { WM_CREATE, sent },
1205 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1206 { WM_NOTIFYFORMAT, sent|optional },
1207 { WM_QUERYUISTATE, sent|optional },
1208 { WM_WINDOWPOSCHANGING, sent|optional },
1209 { WM_GETMINMAXINFO, sent|optional },
1210 { WM_NCCALCSIZE, sent|optional },
1211 { WM_WINDOWPOSCHANGED, sent|optional },
1212 { WM_SHOWWINDOW, sent|wparam, 1 },
1213 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1214 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1215 { HCBT_ACTIVATE, hook },
1216 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1217
1218
1219 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1220
1221 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
1222
1223 { WM_NCACTIVATE, sent },
1224 { WM_GETTEXT, sent|optional|defwinproc },
1225 { WM_GETTEXT, sent|optional|defwinproc },
1226 { WM_GETTEXT, sent|optional|defwinproc },
1227 { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
1228 { WM_ACTIVATE, sent|wparam, 1 },
1229 { WM_GETTEXT, sent|optional },
1230 { WM_KILLFOCUS, sent|parent },
1231 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1232 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1233 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1234 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1235 { WM_SETFOCUS, sent },
1236 { WM_GETDLGCODE, sent|defwinproc|wparam, 0 },
1237 { WM_NCPAINT, sent|wparam, 1 },
1238 { WM_GETTEXT, sent|optional|defwinproc },
1239 { WM_GETTEXT, sent|optional|defwinproc },
1240 { WM_ERASEBKGND, sent },
1241 { WM_CTLCOLORDLG, sent|optional|defwinproc },
1242 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1243 { WM_GETTEXT, sent|optional },
1244 { WM_GETTEXT, sent|optional },
1245 { WM_NCCALCSIZE, sent|optional },
1246 { WM_NCPAINT, sent|optional },
1247 { WM_GETTEXT, sent|optional|defwinproc },
1248 { WM_GETTEXT, sent|optional|defwinproc },
1249 { WM_ERASEBKGND, sent|optional },
1250 { WM_CTLCOLORDLG, sent|optional|defwinproc },
1251 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1252 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1253 { WM_MOVE, sent },
1254 { 0 }
1255 };
1256 /* Calling EndDialog for a custom dialog (32) */
1257 static const struct message WmEndCustomDialogSeq[] = {
1258 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1259 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1260 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1261 { WM_GETTEXT, sent|optional },
1262 { HCBT_ACTIVATE, hook },
1263 { WM_NCACTIVATE, sent|wparam, 0 },
1264 { WM_GETTEXT, sent|optional|defwinproc },
1265 { WM_GETTEXT, sent|optional|defwinproc },
1266 { WM_ACTIVATE, sent|wparam, 0 },
1267 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1268 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1269 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOACTIVATE|SWP_NOREDRAW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1270 { WM_GETTEXT, sent|optional|defwinproc },
1271 { WM_GETTEXT, sent|optional|defwinproc },
1272 { HCBT_SETFOCUS, hook },
1273 { WM_KILLFOCUS, sent },
1274 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1275 { WM_IME_SETCONTEXT, sent|parent|wparam|defwinproc|optional, 1 },
1276 { WM_IME_NOTIFY, sent|wparam|optional, 1 },
1277 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1278 { WM_SETFOCUS, sent|parent|defwinproc },
1279 { 0 }
1280 };
1281 /* ShowWindow(SW_SHOW) for a custom dialog (initially invisible) */
1282 static const struct message WmShowCustomDialogSeq[] = {
1283 { WM_SHOWWINDOW, sent|wparam, 1 },
1284 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1285 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1286 { HCBT_ACTIVATE, hook },
1287 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1288
1289 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1290
1291 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
1292 { WM_ACTIVATEAPP, sent|wparam|optional, 1 },
1293 { WM_NCACTIVATE, sent },
1294 { WM_ACTIVATE, sent|wparam, 1 },
1295 { WM_GETTEXT, sent|optional },
1296
1297 { WM_KILLFOCUS, sent|parent },
1298 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1299 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1300 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1301 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1302 { WM_SETFOCUS, sent },
1303 { WM_GETDLGCODE, sent|defwinproc|wparam, 0 },
1304 { WM_NCPAINT, sent|wparam, 1 },
1305 { WM_ERASEBKGND, sent },
1306 { WM_CTLCOLORDLG, sent|defwinproc },
1307 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1308 { 0 }
1309 };
1310 /* Creation and destruction of a modal dialog (32) */
1311 static const struct message WmModalDialogSeq[] = {
1312 { WM_CANCELMODE, sent|parent },
1313 { HCBT_SETFOCUS, hook },
1314 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1315 { WM_KILLFOCUS, sent|parent },
1316 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1317 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1318 { WM_ENABLE, sent|parent|wparam, 0 },
1319 { HCBT_CREATEWND, hook },
1320 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1321 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1322 { WM_SETFONT, sent },
1323 { WM_INITDIALOG, sent },
1324 { WM_CHANGEUISTATE, sent|optional },
1325 { WM_UPDATEUISTATE, sent|optional },
1326 { WM_SHOWWINDOW, sent },
1327 { HCBT_ACTIVATE, hook },
1328 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1329 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1330 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
1331 { WM_NCACTIVATE, sent },
1332 { WM_GETTEXT, sent|optional },
1333 { WM_ACTIVATE, sent|wparam, 1 },
1334 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1335 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1336 { WM_NCPAINT, sent|optional },
1337 { WM_GETTEXT, sent|optional },
1338 { WM_ERASEBKGND, sent|optional },
1339 { WM_CTLCOLORDLG, sent|optional },
1340 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1341 { WM_GETTEXT, sent|optional },
1342 { WM_NCCALCSIZE, sent|optional },
1343 { WM_NCPAINT, sent|optional },
1344 { WM_GETTEXT, sent|optional },
1345 { WM_ERASEBKGND, sent|optional },
1346 { WM_CTLCOLORDLG, sent|optional },
1347 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1348 { WM_PAINT, sent|optional },
1349 { WM_CTLCOLORBTN, sent|optional },
1350 { WM_GETTITLEBARINFOEX, sent|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_ENTERIDLE, sent|parent|optional },
1361 { WM_ENTERIDLE, sent|parent|optional },
1362 { WM_ENTERIDLE, sent|parent|optional },
1363 { WM_ENTERIDLE, sent|parent|optional },
1364 { WM_ENTERIDLE, sent|parent|optional },
1365 { WM_ENTERIDLE, sent|parent|optional },
1366 { WM_ENTERIDLE, sent|parent|optional },
1367 { WM_ENTERIDLE, sent|parent|optional },
1368 { WM_ENTERIDLE, sent|parent|optional },
1369 { WM_ENTERIDLE, sent|parent|optional },
1370 { WM_ENTERIDLE, sent|parent|optional },
1371 { WM_TIMER, sent },
1372 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1373 { WM_ENABLE, sent|parent|wparam, 1 },
1374 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1375 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1376 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1377 { WM_GETTEXT, sent|optional },
1378 { HCBT_ACTIVATE, hook },
1379 { WM_NCACTIVATE, sent|wparam, 0 },
1380 { WM_GETTEXT, sent|optional },
1381 { WM_ACTIVATE, sent|wparam, 0 },
1382 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1383 { WM_WINDOWPOSCHANGING, sent|optional },
1384 { WM_WINDOWPOSCHANGED, sent|optional },
1385 { HCBT_SETFOCUS, hook },
1386 { WM_IME_SETCONTEXT, sent|parent|wparam|defwinproc|optional, 1 },
1387 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1388 { WM_SETFOCUS, sent|parent|defwinproc },
1389 { EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam, 0, 0 },
1390 { HCBT_DESTROYWND, hook },
1391 { 0x0090, sent|optional },
1392 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1393 { WM_DESTROY, sent },
1394 { WM_NCDESTROY, sent },
1395 { 0 }
1396 };
1397 static const struct message WmModalDialogSeq_2[] = {
1398 { WM_CANCELMODE, sent },
1399 { HCBT_SETFOCUS, hook },
1400 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1401 { WM_KILLFOCUS, sent },
1402 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1403 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1404 { WM_ENABLE, sent|wparam, 0 },
1405 { HCBT_CREATEWND, hook },
1406 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1407 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1408 { WM_SETFONT, sent },
1409 { WM_INITDIALOG, sent },
1410 { WM_CHANGEUISTATE, sent|optional },
1411 { WM_UPDATEUISTATE, sent|optional },
1412 { WM_ENABLE, sent|wparam, 1 },
1413 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1414 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1415 { WM_CHANGEUISTATE, sent|optional },
1416 { WM_UPDATEUISTATE, sent|optional },
1417 { HCBT_DESTROYWND, hook },
1418 { 0x0090, sent|optional },
1419 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1420 { WM_DESTROY, sent },
1421 { WM_NCDESTROY, sent },
1422 { 0 }
1423 };
1424 /* SetMenu for NonVisible windows with size change*/
1425 static const struct message WmSetMenuNonVisibleSizeChangeSeq[] = {
1426 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1427 { WM_NCCALCSIZE, sent|wparam, 1 },
1428 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1429 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW },
1430 { WM_MOVE, sent|defwinproc },
1431 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1432 { WM_NCCALCSIZE,sent|wparam|optional, 1 }, /* XP */
1433 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1434 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
1435 { WM_GETTEXT, sent|optional },
1436 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
1437 { 0 }
1438 };
1439 /* SetMenu for NonVisible windows with no size change */
1440 static const struct message WmSetMenuNonVisibleNoSizeChangeSeq[] = {
1441 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1442 { WM_NCCALCSIZE, sent|wparam, 1 },
1443 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1444 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1445 { 0 }
1446 };
1447 /* SetMenu for Visible windows with size change */
1448 static const struct message WmSetMenuVisibleSizeChangeSeq[] = {
1449 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1450 { WM_NCCALCSIZE, sent|wparam, 1 },
1451 { 0x0093, sent|defwinproc|optional },
1452 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1453 { WM_NCPAINT, sent|optional }, /* wparam != 1 */
1454 { 0x0093, sent|defwinproc|optional },
1455 { 0x0093, sent|defwinproc|optional },
1456 { 0x0091, sent|defwinproc|optional },
1457 { 0x0092, sent|defwinproc|optional },
1458 { WM_GETTEXT, sent|defwinproc|optional },
1459 { WM_ERASEBKGND, sent|optional },
1460 { WM_ACTIVATE, sent|optional },
1461 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1462 { WM_MOVE, sent|defwinproc },
1463 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1464 { 0x0093, sent|optional },
1465 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
1466 { 0x0093, sent|defwinproc|optional },
1467 { WM_NCPAINT, sent|optional }, /* wparam != 1 */
1468 { 0x0093, sent|defwinproc|optional },
1469 { 0x0093, sent|defwinproc|optional },
1470 { 0x0091, sent|defwinproc|optional },
1471 { 0x0092, sent|defwinproc|optional },
1472 { WM_ERASEBKGND, sent|optional },
1473 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1474 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
1475 { 0 }
1476 };
1477 /* SetMenu for Visible windows with no size change */
1478 static const struct message WmSetMenuVisibleNoSizeChangeSeq[] = {
1479 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1480 { WM_NCCALCSIZE, sent|wparam, 1 },
1481 { WM_NCPAINT, sent|optional }, /* wparam != 1 */
1482 { WM_GETTEXT, sent|defwinproc|optional },
1483 { WM_ERASEBKGND, sent|optional },
1484 { WM_ACTIVATE, sent|optional },
1485 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1486 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1487 { 0 }
1488 };
1489 /* DrawMenuBar for a visible window */
1490 static const struct message WmDrawMenuBarSeq[] =
1491 {
1492 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1493 { WM_NCCALCSIZE, sent|wparam, 1 },
1494 { 0x0093, sent|defwinproc|optional },
1495 { WM_NCPAINT, sent|optional }, /* wparam != 1 */
1496 { 0x0093, sent|defwinproc|optional },
1497 { 0x0093, sent|defwinproc|optional },
1498 { 0x0091, sent|defwinproc|optional },
1499 { 0x0092, sent|defwinproc|optional },
1500 { WM_GETTEXT, sent|defwinproc|optional },
1501 { WM_ERASEBKGND, sent|optional },
1502 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1503 { 0x0093, sent|optional },
1504 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1505 { 0 }
1506 };
1507
1508 static const struct message WmSetRedrawFalseSeq[] =
1509 {
1510 { WM_SETREDRAW, sent|wparam, 0 },
1511 { 0 }
1512 };
1513
1514 static const struct message WmSetRedrawTrueSeq[] =
1515 {
1516 { WM_SETREDRAW, sent|wparam, 1 },
1517 { 0 }
1518 };
1519
1520 static const struct message WmEnableWindowSeq_1[] =
1521 {
1522 { WM_CANCELMODE, sent|wparam|lparam, 0, 0 },
1523 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1524 { HCBT_SETFOCUS, hook|optional },
1525 { WM_KILLFOCUS, sent|optional },
1526 { WM_ENABLE, sent|wparam|lparam, FALSE, 0 },
1527 { 0 }
1528 };
1529
1530 static const struct message WmEnableWindowSeq_2[] =
1531 {
1532 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1533 { WM_ENABLE, sent|wparam|lparam, TRUE, 0 },
1534 { 0 }
1535 };
1536
1537 static const struct message WmGetScrollRangeSeq[] =
1538 {
1539 { SBM_GETRANGE, sent },
1540 { 0 }
1541 };
1542 static const struct message WmGetScrollInfoSeq[] =
1543 {
1544 { SBM_GETSCROLLINFO, sent },
1545 { 0 }
1546 };
1547 static const struct message WmSetScrollRangeSeq[] =
1548 {
1549 /* MSDN claims that Windows sends SBM_SETRANGE message, but win2k SP4
1550 sends SBM_SETSCROLLINFO.
1551 */
1552 { SBM_SETSCROLLINFO, sent },
1553 { 0 }
1554 };
1555 /* SetScrollRange for a window without a non-client area */
1556 static const struct message WmSetScrollRangeHSeq_empty[] =
1557 {
1558 { EVENT_OBJECT_VALUECHANGE, winevent_hook|wparam|lparam, OBJID_HSCROLL, 0 },
1559 { 0 }
1560 };
1561 static const struct message WmSetScrollRangeVSeq_empty[] =
1562 {
1563 { EVENT_OBJECT_VALUECHANGE, winevent_hook|wparam|lparam, OBJID_VSCROLL, 0 },
1564 { 0 }
1565 };
1566 static const struct message WmSetScrollRangeHVSeq[] =
1567 {
1568 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE },
1569 { WM_NCCALCSIZE, sent|wparam, 1 },
1570 { WM_GETTEXT, sent|defwinproc|optional },
1571 { WM_ERASEBKGND, sent|optional },
1572 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1573 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1574 { EVENT_OBJECT_VALUECHANGE, winevent_hook|lparam|optional, 0/*OBJID_HSCROLL or OBJID_VSCROLL*/, 0 },
1575 { 0 }
1576 };
1577 /* SetScrollRange for a window with a non-client area */
1578 static const struct message WmSetScrollRangeHV_NC_Seq[] =
1579 {
1580 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE },
1581 { WM_NCCALCSIZE, sent|wparam, 1 },
1582 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1583 { WM_NCPAINT, sent|optional },
1584 { WM_STYLECHANGING, sent|defwinproc|optional },
1585 { WM_STYLECHANGED, sent|defwinproc|optional },
1586 { WM_STYLECHANGING, sent|defwinproc|optional },
1587 { WM_STYLECHANGED, sent|defwinproc|optional },
1588 { WM_STYLECHANGING, sent|defwinproc|optional },
1589 { WM_STYLECHANGED, sent|defwinproc|optional },
1590 { WM_STYLECHANGING, sent|defwinproc|optional },
1591 { WM_STYLECHANGED, sent|defwinproc|optional },
1592 { WM_GETTEXT, sent|defwinproc|optional },
1593 { WM_GETTEXT, sent|defwinproc|optional },
1594 { WM_ERASEBKGND, sent|optional },
1595 { WM_CTLCOLORDLG, sent|defwinproc|optional }, /* sent to a parent of the dialog */
1596 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOCLIENTMOVE, 0, SWP_NOCLIENTSIZE },
1597 { WM_SIZE, sent|defwinproc|optional },
1598 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1599 { EVENT_OBJECT_VALUECHANGE, winevent_hook|lparam|optional, 0/*OBJID_HSCROLL or OBJID_VSCROLL*/, 0 },
1600 { WM_GETTEXT, sent|optional },
1601 { WM_GETTEXT, sent|optional },
1602 { WM_GETTEXT, sent|optional },
1603 { WM_GETTEXT, sent|optional },
1604 { 0 }
1605 };
1606 /* test if we receive the right sequence of messages */
1607 /* after calling ShowWindow( SW_SHOWNA) */
1608 static const struct message WmSHOWNAChildInvisParInvis[] = {
1609 { WM_SHOWWINDOW, sent|wparam, 1 },
1610 { 0 }
1611 };
1612 static const struct message WmSHOWNAChildVisParInvis[] = {
1613 { WM_SHOWWINDOW, sent|wparam, 1 },
1614 { 0 }
1615 };
1616 static const struct message WmSHOWNAChildVisParVis[] = {
1617 { WM_SHOWWINDOW, sent|wparam, 1 },
1618 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1619 { 0 }
1620 };
1621 static const struct message WmSHOWNAChildInvisParVis[] = {
1622 { WM_SHOWWINDOW, sent|wparam, 1 },
1623 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1624 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1625 { WM_ERASEBKGND, sent|optional },
1626 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOACTIVATE|SWP_NOCLIENTMOVE },
1627 { 0 }
1628 };
1629 static const struct message WmSHOWNATopVisible[] = {
1630 { WM_SHOWWINDOW, sent|wparam, 1 },
1631 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1632 { WM_NCPAINT, sent|wparam|optional, 1 },
1633 { WM_GETTEXT, sent|defwinproc|optional },
1634 { WM_ERASEBKGND, sent|optional },
1635 { WM_WINDOWPOSCHANGED, sent|optional },
1636 { 0 }
1637 };
1638 static const struct message WmSHOWNATopInvisible[] = {
1639 { WM_NOTIFYFORMAT, sent|optional },
1640 { WM_QUERYUISTATE, sent|optional },
1641 { WM_WINDOWPOSCHANGING, sent|optional },
1642 { WM_GETMINMAXINFO, sent|optional },
1643 { WM_NCCALCSIZE, sent|optional },
1644 { WM_WINDOWPOSCHANGED, sent|optional },
1645 { WM_SHOWWINDOW, sent|wparam, 1 },
1646 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1647 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1648 { WM_NCPAINT, sent|wparam|optional, 1 },
1649 { WM_GETTEXT, sent|defwinproc|optional },
1650 { WM_ERASEBKGND, sent|optional },
1651 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1652 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
1653 { WM_NCPAINT, sent|wparam|optional, 1 },
1654 { WM_ERASEBKGND, sent|optional },
1655 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1656 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1657 { WM_MOVE, sent },
1658 { 0 }
1659 };
1660
1661 static const struct message WmTrackPopupMenu[] = {
1662 { HCBT_CREATEWND, hook },
1663 { WM_ENTERMENULOOP, sent|wparam|lparam, TRUE, 0 },
1664 { WM_INITMENU, sent|lparam, 0, 0 },
1665 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
1666 { 0x0093, sent|optional },
1667 { 0x0094, sent|optional },
1668 { 0x0094, sent|optional },
1669 { WM_ENTERIDLE, sent|wparam, 2 },
1670 { WM_CAPTURECHANGED, sent },
1671 { HCBT_DESTROYWND, hook },
1672 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
1673 { WM_MENUSELECT, sent|wparam|lparam, 0xffff0000, 0 },
1674 { WM_EXITMENULOOP, sent|wparam|lparam, 1, 0 },
1675 { 0 }
1676 };
1677
1678 static const struct message WmTrackPopupMenuCapture[] = {
1679 { HCBT_CREATEWND, hook },
1680 { WM_ENTERMENULOOP, sent|wparam|lparam, TRUE, 0 },
1681 { WM_CAPTURECHANGED, sent },
1682 { WM_INITMENU, sent|lparam, 0, 0 },
1683 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
1684 { 0x0093, sent|optional },
1685 { 0x0094, sent|optional },
1686 { 0x0094, sent|optional },
1687 { WM_ENTERIDLE, sent|wparam, 2 },
1688 { WM_CAPTURECHANGED, sent },
1689 { HCBT_DESTROYWND, hook },
1690 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
1691 { WM_MENUSELECT, sent|wparam|lparam, 0xffff0000, 0 },
1692 { WM_EXITMENULOOP, sent|wparam|lparam, 1, 0 },
1693 { 0 }
1694 };
1695
1696 static const struct message WmTrackPopupMenuEmpty[] = {
1697 { HCBT_CREATEWND, hook },
1698 { WM_ENTERMENULOOP, sent|wparam|lparam, TRUE, 0 },
1699 { WM_INITMENU, sent|lparam, 0, 0 },
1700 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
1701 { 0x0093, sent|optional },
1702 { 0x0094, sent|optional },
1703 { 0x0094, sent|optional },
1704 { WM_CAPTURECHANGED, sent },
1705 { WM_EXITMENULOOP, sent|wparam|lparam, 1, 0 },
1706 { HCBT_DESTROYWND, hook },
1707 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
1708 { 0 }
1709 };
1710
1711 static const struct message WmTrackPopupMenuAbort[] = {
1712 { HCBT_CREATEWND, hook },
1713 { WM_ENTERMENULOOP, sent|wparam|lparam, TRUE, 0 },
1714 { WM_INITMENU, sent|lparam, 0, 0 },
1715 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
1716 { 0x0093, sent|optional },
1717 { 0x0094, sent|optional },
1718 { 0x0094, sent|optional },
1719 { WM_CAPTURECHANGED, sent },
1720 { HCBT_DESTROYWND, hook },
1721 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
1722 { WM_MENUSELECT, sent|wparam|lparam, 0xffff0000, 0 },
1723 { WM_EXITMENULOOP, sent|wparam|lparam, 1, 0 },
1724 { 0 }
1725 };
1726
1727 static BOOL after_end_dialog, test_def_id, paint_loop_done;
1728 static int sequence_cnt, sequence_size;
1729 static struct recvd_message* sequence;
1730 static int log_all_parent_messages;
1731 static CRITICAL_SECTION sequence_cs;
1732
1733 /* user32 functions */
1734 static HWND (WINAPI *pGetAncestor)(HWND,UINT);
1735 static BOOL (WINAPI *pGetMenuInfo)(HMENU,LPCMENUINFO);
1736 static void (WINAPI *pNotifyWinEvent)(DWORD, HWND, LONG, LONG);
1737 static BOOL (WINAPI *pSetMenuInfo)(HMENU,LPCMENUINFO);
1738 static HWINEVENTHOOK (WINAPI *pSetWinEventHook)(DWORD, DWORD, HMODULE, WINEVENTPROC, DWORD, DWORD, DWORD);
1739 static BOOL (WINAPI *pTrackMouseEvent)(TRACKMOUSEEVENT*);
1740 static BOOL (WINAPI *pUnhookWinEvent)(HWINEVENTHOOK);
1741 static BOOL (WINAPI *pGetMonitorInfoA)(HMONITOR,LPMONITORINFO);
1742 static HMONITOR (WINAPI *pMonitorFromPoint)(POINT,DWORD);
1743 static BOOL (WINAPI *pUpdateLayeredWindow)(HWND,HDC,POINT*,SIZE*,HDC,POINT*,COLORREF,BLENDFUNCTION*,DWORD);
1744 static UINT_PTR (WINAPI *pSetSystemTimer)(HWND, UINT_PTR, UINT, TIMERPROC);
1745 static UINT_PTR (WINAPI *pKillSystemTimer)(HWND, UINT_PTR);
1746 static UINT_PTR (WINAPI *pSetCoalescableTimer)(HWND, UINT_PTR, UINT, TIMERPROC, ULONG);
1747 /* kernel32 functions */
1748 static BOOL (WINAPI *pGetCPInfoExA)(UINT, DWORD, LPCPINFOEXA);
1749
1750 static void init_procs(void)
1751 {
1752 HMODULE user32 = GetModuleHandleA("user32.dll");
1753 HMODULE kernel32 = GetModuleHandleA("kernel32.dll");
1754
1755 #define GET_PROC(dll, func) \
1756 p ## func = (void*)GetProcAddress(dll, #func); \
1757 if(!p ## func) { \
1758 trace("GetProcAddress(%s) failed\n", #func); \
1759 }
1760
1761 GET_PROC(user32, GetAncestor)
1762 GET_PROC(user32, GetMenuInfo)
1763 GET_PROC(user32, NotifyWinEvent)
1764 GET_PROC(user32, SetMenuInfo)
1765 GET_PROC(user32, SetWinEventHook)
1766 GET_PROC(user32, TrackMouseEvent)
1767 GET_PROC(user32, UnhookWinEvent)
1768 GET_PROC(user32, GetMonitorInfoA)
1769 GET_PROC(user32, MonitorFromPoint)
1770 GET_PROC(user32, UpdateLayeredWindow)
1771 GET_PROC(user32, SetSystemTimer)
1772 GET_PROC(user32, KillSystemTimer)
1773 GET_PROC(user32, SetCoalescableTimer)
1774
1775 GET_PROC(kernel32, GetCPInfoExA)
1776
1777 #undef GET_PROC
1778 }
1779
1780 static const char *get_winpos_flags(UINT flags)
1781 {
1782 static char buffer[300];
1783
1784 buffer[0] = 0;
1785 #define DUMP(flag) do { if (flags & flag) { strcat( buffer, "|" #flag ); flags &= ~flag; } } while(0)
1786 DUMP( SWP_SHOWWINDOW );
1787 DUMP( SWP_HIDEWINDOW );
1788 DUMP( SWP_NOACTIVATE );
1789 DUMP( SWP_FRAMECHANGED );
1790 DUMP( SWP_NOCOPYBITS );
1791 DUMP( SWP_NOOWNERZORDER );
1792 DUMP( SWP_NOSENDCHANGING );
1793 DUMP( SWP_DEFERERASE );
1794 DUMP( SWP_ASYNCWINDOWPOS );
1795 DUMP( SWP_NOZORDER );
1796 DUMP( SWP_NOREDRAW );
1797 DUMP( SWP_NOSIZE );
1798 DUMP( SWP_NOMOVE );
1799 DUMP( SWP_NOCLIENTSIZE );
1800 DUMP( SWP_NOCLIENTMOVE );
1801 if (flags) sprintf(buffer + strlen(buffer),"|0x%04x", flags);
1802 return buffer + 1;
1803 #undef DUMP
1804 }
1805
1806 static BOOL ignore_message( UINT message )
1807 {
1808 /* these are always ignored */
1809 return (message >= 0xc000 ||
1810 message == WM_GETICON ||
1811 message == WM_GETOBJECT ||
1812 message == WM_TIMECHANGE ||
1813 message == WM_DISPLAYCHANGE ||
1814 message == WM_DEVICECHANGE ||
1815 message == WM_DWMNCRENDERINGCHANGED);
1816 }
1817
1818
1819 #define add_message(msg) add_message_(__LINE__,msg);
1820 static void add_message_(int line, const struct recvd_message *msg)
1821 {
1822 struct recvd_message *seq;
1823
1824 EnterCriticalSection( &sequence_cs );
1825 if (!sequence)
1826 {
1827 sequence_size = 10;
1828 sequence = HeapAlloc( GetProcessHeap(), 0, sequence_size * sizeof(*sequence) );
1829 }
1830 if (sequence_cnt == sequence_size)
1831 {
1832 sequence_size *= 2;
1833 sequence = HeapReAlloc( GetProcessHeap(), 0, sequence, sequence_size * sizeof(*sequence) );
1834 }
1835 assert(sequence);
1836
1837 seq = &sequence[sequence_cnt++];
1838 seq->hwnd = msg->hwnd;
1839 seq->message = msg->message;
1840 seq->flags = msg->flags;
1841 seq->wParam = msg->wParam;
1842 seq->lParam = msg->lParam;
1843 seq->line = line;
1844 seq->descr = msg->descr;
1845 seq->output[0] = 0;
1846 LeaveCriticalSection( &sequence_cs );
1847
1848 if (msg->descr)
1849 {
1850 if (msg->flags & hook)
1851 {
1852 static const char * const CBT_code_name[10] =
1853 {
1854 "HCBT_MOVESIZE",
1855 "HCBT_MINMAX",
1856 "HCBT_QS",
1857 "HCBT_CREATEWND",
1858 "HCBT_DESTROYWND",
1859 "HCBT_ACTIVATE",
1860 "HCBT_CLICKSKIPPED",
1861 "HCBT_KEYSKIPPED",
1862 "HCBT_SYSCOMMAND",
1863 "HCBT_SETFOCUS"
1864 };
1865 const char *code_name = (msg->message <= HCBT_SETFOCUS) ? CBT_code_name[msg->message] : "Unknown";
1866
1867 sprintf( seq->output, "%s: hook %d (%s) wp %08lx lp %08lx",
1868 msg->descr, msg->message, code_name, msg->wParam, msg->lParam );
1869 }
1870 else if (msg->flags & winevent_hook)
1871 {
1872 sprintf( seq->output, "%s: winevent %p %08x %08lx %08lx",
1873 msg->descr, msg->hwnd, msg->message, msg->wParam, msg->lParam );
1874 }
1875 else
1876 {
1877 switch (msg->message)
1878 {
1879 case WM_WINDOWPOSCHANGING:
1880 case WM_WINDOWPOSCHANGED:
1881 {
1882 WINDOWPOS *winpos = (WINDOWPOS *)msg->lParam;
1883
1884 sprintf( seq->output, "%s: %p WM_WINDOWPOS%s wp %08lx lp %08lx after %p x %d y %d cx %d cy %d flags %s",
1885 msg->descr, msg->hwnd,
1886 (msg->message == WM_WINDOWPOSCHANGING) ? "CHANGING" : "CHANGED",
1887 msg->wParam, msg->lParam, winpos->hwndInsertAfter,
1888 winpos->x, winpos->y, winpos->cx, winpos->cy,
1889 get_winpos_flags(winpos->flags) );
1890
1891 /* Log only documented flags, win2k uses 0x1000 and 0x2000
1892 * in the high word for internal purposes
1893 */
1894 seq->wParam = winpos->flags & 0xffff;
1895 /* We are not interested in the flags that don't match under XP and Win9x */
1896 seq->wParam &= ~SWP_NOZORDER;
1897 break;
1898 }
1899
1900 case WM_DRAWITEM:
1901 {
1902 DRAW_ITEM_STRUCT di;
1903 DRAWITEMSTRUCT *dis = (DRAWITEMSTRUCT *)msg->lParam;
1904
1905 sprintf( seq->output, "%s: %p WM_DRAWITEM: type %x, ctl_id %x, item_id %x, action %x, state %x",
1906 msg->descr, msg->hwnd, dis->CtlType, dis->CtlID,
1907 dis->itemID, dis->itemAction, dis->itemState);
1908
1909 di.u.lp = 0;
1910 di.u.item.type = dis->CtlType;
1911 di.u.item.ctl_id = dis->CtlID;
1912 if (dis->CtlType == ODT_LISTBOX ||
1913 dis->CtlType == ODT_COMBOBOX ||
1914 dis->CtlType == ODT_MENU)
1915 di.u.item.item_id = dis->itemID;
1916 di.u.item.action = dis->itemAction;
1917 di.u.item.state = dis->itemState;
1918
1919 seq->lParam = di.u.lp;
1920 break;
1921 }
1922 default:
1923 if (msg->message >= 0xc000) return; /* ignore registered messages */
1924 sprintf( seq->output, "%s: %p %04x wp %08lx lp %08lx",
1925 msg->descr, msg->hwnd, msg->message, msg->wParam, msg->lParam );
1926 }
1927 if (msg->flags & (sent|posted|parent|defwinproc|beginpaint))
1928 sprintf( seq->output + strlen(seq->output), " (flags %x)", msg->flags );
1929 }
1930 }
1931 }
1932
1933 /* try to make sure pending X events have been processed before continuing */
1934 static void flush_events(void)
1935 {
1936 MSG msg;
1937 int diff = 200;
1938 int min_timeout = 100;
1939 DWORD time = GetTickCount() + diff;
1940
1941 while (diff > 0)
1942 {
1943 if (MsgWaitForMultipleObjects( 0, NULL, FALSE, min_timeout, QS_ALLINPUT ) == WAIT_TIMEOUT) break;
1944 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
1945 diff = time - GetTickCount();
1946 }
1947 }
1948
1949 static void flush_sequence(void)
1950 {
1951 EnterCriticalSection( &sequence_cs );
1952 HeapFree(GetProcessHeap(), 0, sequence);
1953 sequence = 0;
1954 sequence_cnt = sequence_size = 0;
1955 LeaveCriticalSection( &sequence_cs );
1956 }
1957
1958 static void dump_sequence(const struct message *expected, const char *context, const char *file, int line)
1959 {
1960 const struct recvd_message *actual = sequence;
1961 unsigned int count = 0;
1962
1963 trace_(file, line)("Failed sequence %s:\n", context );
1964 while (expected->message && actual->message)
1965 {
1966 if (actual->output[0])
1967 {
1968 if (expected->flags & hook)
1969 {
1970 trace_(file, line)( " %u: expected: hook %04x - actual: %s\n",
1971 count, expected->message, actual->output );
1972 }
1973 else if (expected->flags & winevent_hook)
1974 {
1975 trace_(file, line)( " %u: expected: winevent %04x - actual: %s\n",
1976 count, expected->message, actual->output );
1977 }
1978 else if (expected->flags & kbd_hook)
1979 {
1980 trace_(file, line)( " %u: expected: kbd %04x - actual: %s\n",
1981 count, expected->message, actual->output );
1982 }
1983 else
1984 {
1985 trace_(file, line)( " %u: expected: msg %04x - actual: %s\n",
1986 count, expected->message, actual->output );
1987 }
1988 }
1989
1990 if (expected->message == actual->message)
1991 {
1992 if ((expected->flags & defwinproc) != (actual->flags & defwinproc) &&
1993 (expected->flags & optional))
1994 {
1995 /* don't match messages if their defwinproc status differs */
1996 expected++;
1997 }
1998 else
1999 {
2000 expected++;
2001 actual++;
2002 }
2003 }
2004 /* silently drop winevent messages if there is no support for them */
2005 else if ((expected->flags & optional) || ((expected->flags & winevent_hook) && !hEvent_hook))
2006 expected++;
2007 else
2008 {
2009 expected++;
2010 actual++;
2011 }
2012 count++;
2013 }
2014
2015 /* optional trailing messages */
2016 while (expected->message && ((expected->flags & optional) ||
2017 ((expected->flags & winevent_hook) && !hEvent_hook)))
2018 {
2019 trace_(file, line)( " %u: expected: msg %04x - actual: nothing\n", count, expected->message );
2020 expected++;
2021 count++;
2022 }
2023
2024 if (expected->message)
2025 {
2026 trace_(file, line)( " %u: expected: msg %04x - actual: nothing\n", count, expected->message );
2027 return;
2028 }
2029
2030 while (actual->message && actual->output[0])
2031 {
2032 trace_(file, line)( " %u: expected: nothing - actual: %s\n", count, actual->output );
2033 actual++;
2034 count++;
2035 }
2036 }
2037
2038 #define ok_sequence( exp, contx, todo) \
2039 ok_sequence_( (exp), (contx), (todo), __FILE__, __LINE__)
2040
2041
2042 static void ok_sequence_(const struct message *expected_list, const char *context, BOOL todo,
2043 const char *file, int line)
2044 {
2045 static const struct recvd_message end_of_sequence;
2046 const struct message *expected = expected_list;
2047 const struct recvd_message *actual;
2048 int failcount = 0, dump = 0;
2049 unsigned int count = 0;
2050
2051 add_message(&end_of_sequence);
2052
2053 actual = sequence;
2054
2055 while (expected->message && actual->message)
2056 {
2057 if (expected->message == actual->message &&
2058 !((expected->flags ^ actual->flags) & (hook|winevent_hook|kbd_hook)))
2059 {
2060 if (expected->flags & wparam)
2061 {
2062 if (((expected->wParam ^ actual->wParam) & ~expected->wp_mask) && todo)
2063 {
2064 todo_wine {
2065 failcount ++;
2066 if (strcmp(winetest_platform, "wine")) dump++;
2067 ok_( file, line) (FALSE,
2068 "%s: %u: in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
2069 context, count, expected->message, expected->wParam, actual->wParam);
2070 }
2071 }
2072 else
2073 {
2074 ok_( file, line)( ((expected->wParam ^ actual->wParam) & ~expected->wp_mask) == 0,
2075 "%s: %u: in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
2076 context, count, expected->message, expected->wParam, actual->wParam);
2077 if ((expected->wParam ^ actual->wParam) & ~expected->wp_mask) dump++;
2078 }
2079
2080 }
2081 if (expected->flags & lparam)
2082 {
2083 if (((expected->lParam ^ actual->lParam) & ~expected->lp_mask) && todo)
2084 {
2085 todo_wine {
2086 failcount ++;
2087 if (strcmp(winetest_platform, "wine")) dump++;
2088 ok_( file, line) (FALSE,
2089 "%s: %u: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
2090 context, count, expected->message, expected->lParam, actual->lParam);
2091 }
2092 }
2093 else
2094 {
2095 ok_( file, line)(((expected->lParam ^ actual->lParam) & ~expected->lp_mask) == 0,
2096 "%s: %u: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
2097 context, count, expected->message, expected->lParam, actual->lParam);
2098 if ((expected->lParam ^ actual->lParam) & ~expected->lp_mask) dump++;
2099 }
2100 }
2101 if ((expected->flags & optional) &&
2102 ((expected->flags ^ actual->flags) & (defwinproc|parent)))
2103 {
2104 /* don't match optional messages if their defwinproc or parent status differs */
2105 expected++;
2106 count++;
2107 continue;
2108 }
2109 if ((expected->flags & defwinproc) != (actual->flags & defwinproc) && todo)
2110 {
2111 todo_wine {
2112 failcount ++;
2113 if (strcmp(winetest_platform, "wine")) dump++;
2114 ok_( file, line) (FALSE,
2115 "%s: %u: the msg 0x%04x should %shave been sent by DefWindowProc\n",
2116 context, count, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
2117 }
2118 }
2119 else
2120 {
2121 ok_( file, line) ((expected->flags & defwinproc) == (actual->flags & defwinproc),
2122 "%s: %u: the msg 0x%04x should %shave been sent by DefWindowProc\n",
2123 context, count, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
2124 if ((expected->flags & defwinproc) != (actual->flags & defwinproc)) dump++;
2125 }
2126
2127 ok_( file, line) ((expected->flags & beginpaint) == (actual->flags & beginpaint),
2128 "%s: %u: the msg 0x%04x should %shave been sent by BeginPaint\n",
2129 context, count, expected->message, (expected->flags & beginpaint) ? "" : "NOT ");
2130 if ((expected->flags & beginpaint) != (actual->flags & beginpaint)) dump++;
2131
2132 ok_( file, line) ((expected->flags & (sent|posted)) == (actual->flags & (sent|posted)),
2133 "%s: %u: the msg 0x%04x should have been %s\n",
2134 context, count, expected->message, (expected->flags & posted) ? "posted" : "sent");
2135 if ((expected->flags & (sent|posted)) != (actual->flags & (sent|posted))) dump++;
2136
2137 ok_( file, line) ((expected->flags & parent) == (actual->flags & parent),
2138 "%s: %u: the msg 0x%04x was expected in %s\n",
2139 context, count, expected->message, (expected->flags & parent) ? "parent" : "child");
2140 if ((expected->flags & parent) != (actual->flags & parent)) dump++;
2141
2142 ok_( file, line) ((expected->flags & hook) == (actual->flags & hook),
2143 "%s: %u: the msg 0x%04x should have been sent by a hook\n",
2144 context, count, expected->message);
2145 if ((expected->flags & hook) != (actual->flags & hook)) dump++;
2146
2147 ok_( file, line) ((expected->flags & winevent_hook) == (actual->flags & winevent_hook),
2148 "%s: %u: the msg 0x%04x should have been sent by a winevent hook\n",
2149 context, count, expected->message);
2150 if ((expected->flags & winevent_hook) != (actual->flags & winevent_hook)) dump++;
2151
2152 ok_( file, line) ((expected->flags & kbd_hook) == (actual->flags & kbd_hook),
2153 "%s: %u: the msg 0x%04x should have been sent by a keyboard hook\n",
2154 context, count, expected->message);
2155 if ((expected->flags & kbd_hook) != (actual->flags & kbd_hook)) dump++;
2156
2157 expected++;
2158 actual++;
2159 }
2160 /* silently drop hook messages if there is no support for them */
2161 else if ((expected->flags & optional) ||
2162 ((expected->flags & hook) && !hCBT_hook) ||
2163 ((expected->flags & winevent_hook) && !hEvent_hook) ||
2164 ((expected->flags & kbd_hook) && !hKBD_hook))
2165 expected++;
2166 else if (todo)
2167 {
2168 failcount++;
2169 todo_wine {
2170 if (strcmp(winetest_platform, "wine")) dump++;
2171 ok_( file, line) (FALSE, "%s: %u: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
2172 context, count, expected->message, actual->message);
2173 }
2174 goto done;
2175 }
2176 else
2177 {
2178 ok_( file, line) (FALSE, "%s: %u: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
2179 context, count, expected->message, actual->message);
2180 dump++;
2181 expected++;
2182 actual++;
2183 }
2184 count++;
2185 }
2186
2187 /* skip all optional trailing messages */
2188 while (expected->message && ((expected->flags & optional) ||
2189 ((expected->flags & hook) && !hCBT_hook) ||
2190 ((expected->flags & winevent_hook) && !hEvent_hook)))
2191 expected++;
2192
2193 if (todo)
2194 {
2195 todo_wine {
2196 if (expected->message || actual->message) {
2197 failcount++;
2198 if (strcmp(winetest_platform, "wine")) dump++;
2199 ok_( file, line) (FALSE, "%s: %u: the msg sequence is not complete: expected %04x - actual %04x\n",
2200 context, count, expected->message, actual->message);
2201 }
2202 }
2203 }
2204 else
2205 {
2206 if (expected->message || actual->message)
2207 {
2208 dump++;
2209 ok_( file, line) (FALSE, "%s: %u: the msg sequence is not complete: expected %04x - actual %04x\n",
2210 context, count, expected->message, actual->message);
2211 }
2212 }
2213 if( todo && !failcount) /* succeeded yet marked todo */
2214 todo_wine {
2215 if (!strcmp(winetest_platform, "wine")) dump++;
2216 ok_( file, line)( TRUE, "%s: marked \"todo_wine\" but succeeds\n", context);
2217 }
2218
2219 done:
2220 if (dump) dump_sequence(expected_list, context, file, line);
2221 flush_sequence();
2222 }
2223
2224 #define expect(EXPECTED,GOT) ok((GOT)==(EXPECTED), "Expected %d, got %d\n", (EXPECTED), (GOT))
2225
2226 /******************************** MDI test **********************************/
2227
2228 /* CreateWindow for MDI frame window, initially visible */
2229 static const struct message WmCreateMDIframeSeq[] = {
2230 { HCBT_CREATEWND, hook },
2231 { WM_GETMINMAXINFO, sent },
2232 { WM_NCCREATE, sent },
2233 { WM_NCCALCSIZE, sent|wparam, 0 },
2234 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
2235 { WM_CREATE, sent },
2236 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2237 { WM_NOTIFYFORMAT, sent|optional },
2238 { WM_QUERYUISTATE, sent|optional },
2239 { WM_WINDOWPOSCHANGING, sent|optional },
2240 { WM_GETMINMAXINFO, sent|optional },
2241 { WM_NCCALCSIZE, sent|optional },
2242 { WM_WINDOWPOSCHANGED, sent|optional },
2243 { WM_SHOWWINDOW, sent|wparam, 1 },
2244 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2245 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2246 { HCBT_ACTIVATE, hook },
2247 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
2248 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
2249 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* XP */
2250 { WM_ACTIVATEAPP, sent|wparam|optional, 1 }, /* Win9x doesn't send it */
2251 { WM_NCACTIVATE, sent },
2252 { WM_GETTEXT, sent|defwinproc|optional },
2253 { WM_ACTIVATE, sent|wparam, 1 },
2254 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* Win9x */
2255 { HCBT_SETFOCUS, hook },
2256 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2257 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
2258 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2259 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
2260 /* Win9x adds SWP_NOZORDER below */
2261 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2262 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP */
2263 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
2264 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2265 { WM_MOVE, sent },
2266 { 0 }
2267 };
2268 /* DestroyWindow for MDI frame window, initially visible */
2269 static const struct message WmDestroyMDIframeSeq[] = {
2270 { HCBT_DESTROYWND, hook },
2271 { 0x0090, sent|optional },
2272 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2273 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2274 { WM_NCACTIVATE, sent|wparam|optional, 0 }, /* Win9x */
2275 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2276 { WM_NCACTIVATE, sent|wparam|optional, 0 }, /* XP */
2277 { WM_ACTIVATE, sent|wparam|optional, 0 }, /* Win9x */
2278 { WM_ACTIVATEAPP, sent|wparam|optional, 0 }, /* Win9x */
2279 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
2280 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2281 { WM_DESTROY, sent },
2282 { WM_NCDESTROY, sent },
2283 { 0 }
2284 };
2285 /* CreateWindow for MDI client window, initially visible */
2286 static const struct message WmCreateMDIclientSeq[] = {
2287 { HCBT_CREATEWND, hook },
2288 { WM_NCCREATE, sent },
2289 { WM_NCCALCSIZE, sent|wparam, 0 },
2290 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
2291 { WM_CREATE, sent },
2292 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
2293 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2294 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2295 { WM_MOVE, sent },
2296 { WM_PARENTNOTIFY, sent|wparam, WM_CREATE }, /* in MDI frame */
2297 { WM_SHOWWINDOW, sent|wparam, 1 },
2298 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2299 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2300 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2301 { 0 }
2302 };
2303 /* ShowWindow(SW_SHOW) for MDI client window */
2304 static const struct message WmShowMDIclientSeq[] = {
2305 { WM_SHOWWINDOW, sent|wparam, 1 },
2306 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2307 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2308 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2309 { 0 }
2310 };
2311 /* ShowWindow(SW_HIDE) for MDI client window */
2312 static const struct message WmHideMDIclientSeq[] = {
2313 { WM_SHOWWINDOW, sent|wparam, 0 },
2314 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2315 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|optional, 0, 0 }, /* win2000 */
2316 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP */
2317 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2318 { 0 }
2319 };
2320 /* DestroyWindow for MDI client window, initially visible */
2321 static const struct message WmDestroyMDIclientSeq[] = {
2322 { HCBT_DESTROYWND, hook },
2323 { 0x0090, sent|optional },
2324 { WM_PARENTNOTIFY, sent|wparam, WM_DESTROY }, /* in MDI frame */
2325 { WM_SHOWWINDOW, sent|wparam, 0 },
2326 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2327 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2328 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2329 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2330 { WM_DESTROY, sent },
2331 { WM_NCDESTROY, sent },
2332 { 0 }
2333 };
2334 /* CreateWindow for MDI child window, initially visible */
2335 static const struct message WmCreateMDIchildVisibleSeq[] = {
2336 { HCBT_CREATEWND, hook },
2337 { WM_NCCREATE, sent },
2338 { WM_NCCALCSIZE, sent|wparam, 0 },
2339 { WM_CREATE, sent },
2340 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2341 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2342 { WM_MOVE, sent },
2343 /* Win2k sends wparam set to
2344 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2345 * while Win9x doesn't bother to set child window id according to
2346 * CLIENTCREATESTRUCT.idFirstChild
2347 */
2348 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2349 { WM_SHOWWINDOW, sent|wparam, 1 },
2350 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2351 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2352 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2353 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
2354 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2355 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2356 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2357
2358 /* Win9x: message sequence terminates here. */
2359
2360 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2361 { HCBT_SETFOCUS, hook }, /* in MDI client */
2362 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2363 { WM_IME_NOTIFY, sent|wparam|optional, 2 }, /* in MDI client */
2364 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2365 { WM_SETFOCUS, sent }, /* in MDI client */
2366 { HCBT_SETFOCUS, hook },
2367 { WM_KILLFOCUS, sent }, /* in MDI client */
2368 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2369 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2370 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2371 { WM_SETFOCUS, sent|defwinproc },
2372 { WM_MDIACTIVATE, sent|defwinproc },
2373 { 0 }
2374 };
2375 /* WM_CHILDACTIVATE sent to disabled window */
2376 static const struct message WmChildActivateDisabledWindowSeq[] = {
2377 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2378 { 0 }
2379 };
2380 /* WM_CHILDACTIVATE sent to enabled window */
2381 static const struct message WmChildActivateWindowSeq[] = {
2382 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2383 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 },
2384 { WM_MDIACTIVATE, sent|defwinproc },
2385 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2386 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2387 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2388 { HCBT_SETFOCUS, hook },
2389 { WM_KILLFOCUS, sent|defwinproc },
2390 { WM_SETFOCUS, sent },
2391 { HCBT_SETFOCUS, hook },
2392 { WM_KILLFOCUS, sent },
2393 { WM_SETFOCUS, sent|defwinproc },
2394 { WM_MDIACTIVATE, sent|defwinproc },
2395 { 0 }
2396 };
2397 /* CreateWindow for MDI child window with invisible parent */
2398 static const struct message WmCreateMDIchildInvisibleParentSeq[] = {
2399 { HCBT_CREATEWND, hook },
2400 { WM_GETMINMAXINFO, sent },
2401 { WM_NCCREATE, sent },
2402 { WM_NCCALCSIZE, sent|wparam, 0 },
2403 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
2404 { WM_CREATE, sent },
2405 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2406 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2407 { WM_MOVE, sent },
2408 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2409 { WM_SHOWWINDOW, sent|wparam, 1 },
2410 { WM_MDIREFRESHMENU, sent }, /* in MDI client */
2411 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2412 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2413 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2414
2415 /* Win9x: message sequence terminates here. */
2416
2417 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2418 { HCBT_SETFOCUS, hook }, /* in MDI client */
2419 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2420 { WM_IME_NOTIFY, sent|wparam|optional, 2 }, /* in MDI client */
2421 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2422 { WM_SETFOCUS, sent }, /* in MDI client */
2423 { HCBT_SETFOCUS, hook },
2424 { WM_KILLFOCUS, sent }, /* in MDI client */
2425 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2426 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2427 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2428 { WM_SETFOCUS, sent|defwinproc },
2429 { WM_MDIACTIVATE, sent|defwinproc },
2430 { 0 }
2431 };
2432 /* DestroyWindow for MDI child window, initially visible */
2433 static const struct message WmDestroyMDIchildVisibleSeq[] = {
2434 { HCBT_DESTROYWND, hook },
2435 /* Win2k sends wparam set to
2436 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
2437 * while Win9x doesn't bother to set child window id according to
2438 * CLIENTCREATESTRUCT.idFirstChild
2439 */
2440 { 0x0090, sent|optional },
2441 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
2442 { WM_SHOWWINDOW, sent|wparam, 0 },
2443 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2444 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2445 { WM_ERASEBKGND, sent|parent|optional },
2446 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2447
2448 /* { WM_DESTROY, sent }
2449 * Win9x: message sequence terminates here.
2450 */
2451
2452 { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
2453 { WM_KILLFOCUS, sent },
2454 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2455 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2456 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2457 { WM_SETFOCUS, sent }, /* in MDI client */
2458
2459 { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
2460 { WM_KILLFOCUS, sent }, /* in MDI client */
2461 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2462 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2463 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2464 { WM_SETFOCUS, sent }, /* in MDI client */
2465
2466 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2467
2468 { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
2469 { WM_KILLFOCUS, sent },
2470 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2471 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2472 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2473 { WM_SETFOCUS, sent }, /* in MDI client */
2474
2475 { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
2476 { WM_KILLFOCUS, sent }, /* in MDI client */
2477 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2478 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2479 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2480 { WM_SETFOCUS, sent }, /* in MDI client */
2481
2482 { WM_DESTROY, sent },
2483
2484 { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
2485 { WM_KILLFOCUS, sent },
2486 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2487 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2488 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2489 { WM_SETFOCUS, sent }, /* in MDI client */
2490
2491 { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
2492 { WM_KILLFOCUS, sent }, /* in MDI client */
2493 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2494 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2495 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2496 { WM_SETFOCUS, sent }, /* in MDI client */
2497
2498 { WM_NCDESTROY, sent },
2499 { 0 }
2500 };
2501 /* CreateWindow for MDI child window, initially invisible */
2502 static const struct message WmCreateMDIchildInvisibleSeq[] = {
2503 { HCBT_CREATEWND, hook },
2504 { WM_NCCREATE, sent },
2505 { WM_NCCALCSIZE, sent|wparam, 0 },
2506 { WM_CREATE, sent },
2507 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2508 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2509 { WM_MOVE, sent },
2510 /* Win2k sends wparam set to
2511 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2512 * while Win9x doesn't bother to set child window id according to
2513 * CLIENTCREATESTRUCT.idFirstChild
2514 */
2515 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2516 { 0 }
2517 };
2518 /* DestroyWindow for MDI child window, initially invisible */
2519 static const struct message WmDestroyMDIchildInvisibleSeq[] = {
2520 { HCBT_DESTROYWND, hook },
2521 /* Win2k sends wparam set to
2522 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
2523 * while Win9x doesn't bother to set child window id according to
2524 * CLIENTCREATESTRUCT.idFirstChild
2525 */
2526 { 0x0090, sent|optional },
2527 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
2528 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2529 { WM_DESTROY, sent },
2530 { WM_NCDESTROY, sent },
2531 /* FIXME: Wine destroys an icon/title window while Windows doesn't */
2532 { WM_PARENTNOTIFY, sent|wparam|optional, WM_DESTROY }, /* MDI client */
2533 { 0 }
2534 };
2535 /* CreateWindow for the 1st MDI child window, initially visible and maximized */
2536 static const struct message WmCreateMDIchildVisibleMaxSeq1[] = {
2537 { HCBT_CREATEWND, hook },
2538 { WM_NCCREATE, sent },
2539 { WM_NCCALCSIZE, sent|wparam, 0 },
2540 { WM_CREATE, sent },
2541 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2542 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2543 { WM_MOVE, sent },
2544 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2545 { WM_GETMINMAXINFO, sent },
2546 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
2547 { WM_NCCALCSIZE, sent|wparam, 1 },
2548 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2549 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2550 /* in MDI frame */
2551 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2552 { WM_NCCALCSIZE, sent|wparam, 1 },
2553 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2554 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2555 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2556 /* Win2k sends wparam set to
2557 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2558 * while Win9x doesn't bother to set child window id according to
2559 * CLIENTCREATESTRUCT.idFirstChild
2560 */
2561 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2562 { WM_SHOWWINDOW, sent|wparam, 1 },
2563 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2564 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2565 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2566 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
2567 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2568 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2569 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE, 0, SWP_FRAMECHANGED },
2570
2571 /* Win9x: message sequence terminates here. */
2572
2573 { WM_NCACTIVATE, sent|wparam|defwinproc|optional, 1 },
2574 { HCBT_SETFOCUS, hook|optional }, /* in MDI client */
2575 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2576 { WM_IME_NOTIFY, sent|wparam|optional, 2 }, /* in MDI client */
2577 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2578 { WM_SETFOCUS, sent|optional }, /* in MDI client */
2579 { HCBT_SETFOCUS, hook|optional },
2580 { WM_KILLFOCUS, sent|optional }, /* in MDI client */
2581 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2582 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2583 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2584 { WM_SETFOCUS, sent|defwinproc|optional },
2585 { WM_MDIACTIVATE, sent|defwinproc|optional },
2586 /* in MDI frame */
2587 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2588 { WM_NCCALCSIZE, sent|wparam, 1 },
2589 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2590 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2591 { 0 }
2592 };
2593 /* CreateWindow for the 2nd MDI child window, initially visible and maximized */
2594 static const struct message WmCreateMDIchildVisibleMaxSeq2[] = {
2595 /* restore the 1st MDI child */
2596 { WM_SETREDRAW, sent|wparam, 0 },
2597 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNORMAL },
2598 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
2599 { WM_NCCALCSIZE, sent|wparam, 1 },
2600 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2601 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2602 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2603 /* in MDI frame */
2604 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2605 { WM_NCCALCSIZE, sent|wparam, 1 },
2606 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2607 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2608 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2609 { WM_SETREDRAW, sent|wparam, 1 }, /* in the 1st MDI child */
2610 /* create the 2nd MDI child */
2611 { HCBT_CREATEWND, hook },
2612 { WM_NCCREATE, sent },
2613 { WM_NCCALCSIZE, sent|wparam, 0 },
2614 { WM_CREATE, sent },
2615 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2616 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2617 { WM_MOVE, sent },
2618 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2619 { WM_GETMINMAXINFO, sent },
2620 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
2621 { WM_NCCALCSIZE, sent|wparam, 1 },
2622 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2623 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2624 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2625 /* in MDI frame */
2626 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2627 { WM_NCCALCSIZE, sent|wparam, 1 },
2628 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2629 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2630 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2631 /* Win2k sends wparam set to
2632 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2633 * while Win9x doesn't bother to set child window id according to
2634 * CLIENTCREATESTRUCT.idFirstChild
2635 */
2636 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2637 { WM_SHOWWINDOW, sent|wparam, 1 },
2638 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2639 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2640 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2641 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
2642 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2643 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2644
2645 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
2646 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
2647
2648 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2649
2650 /* Win9x: message sequence terminates here. */
2651
2652 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2653 { HCBT_SETFOCUS, hook },
2654 { WM_KILLFOCUS, sent|defwinproc|optional }, /* in the 1st MDI child */
2655 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 }, /* in the 1st MDI child */
2656 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2657 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2658 { WM_SETFOCUS, sent }, /* in MDI client */
2659 { HCBT_SETFOCUS, hook },
2660 { WM_KILLFOCUS, sent }, /* in MDI client */
2661 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2662 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2663 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2664 { WM_SETFOCUS, sent|defwinproc },
2665
2666 { WM_MDIACTIVATE, sent|defwinproc },
2667 /* in MDI frame */
2668 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2669 { WM_NCCALCSIZE, sent|wparam, 1 },
2670 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2671 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2672 { 0 }
2673 };
2674 /* WM_MDICREATE MDI child window, initially visible and maximized */
2675 static const struct message WmCreateMDIchildVisibleMaxSeq3[] = {
2676 { WM_MDICREATE, sent },
2677 { HCBT_CREATEWND, hook },
2678 { WM_NCCREATE, sent },
2679 { WM_NCCALCSIZE, sent|wparam, 0 },
2680 { WM_CREATE, sent },
2681 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2682 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2683 { WM_MOVE, sent },
2684 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2685 { WM_GETMINMAXINFO, sent },
2686 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
2687 { WM_NCCALCSIZE, sent|wparam, 1 },
2688 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2689 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2690
2691 /* in MDI frame */
2692 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2693 { WM_NCCALCSIZE, sent|wparam, 1 },
2694 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2695 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2696 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2697
2698 /* Win2k sends wparam set to
2699 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2700 * while Win9x doesn't bother to set child window id according to
2701 * CLIENTCREATESTRUCT.idFirstChild
2702 */
2703 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2704 { WM_SHOWWINDOW, sent|wparam, 1 },
2705 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2706
2707 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2708
2709 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2710 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
2711 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2712
2713 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2714 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2715
2716 /* Win9x: message sequence terminates here. */
2717
2718 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2719 { WM_SETFOCUS, sent|optional }, /* in MDI client */
2720 { HCBT_SETFOCUS, hook }, /* in MDI client */
2721 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2722 { WM_IME_NOTIFY, sent|wparam|optional, 2 },
2723 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
2724 { WM_SETFOCUS, sent|optional }, /* in MDI client */
2725 { HCBT_SETFOCUS, hook|optional },
2726 { WM_KILLFOCUS, sent }, /* in MDI client */
2727 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2728 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2729 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2730 { WM_SETFOCUS, sent|defwinproc },
2731
2732 { WM_MDIACTIVATE, sent|defwinproc },
2733
2734 /* in MDI child */
2735 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2736 { WM_NCCALCSIZE, sent|wparam, 1 },
2737 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2738 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
2739
2740 /* in MDI frame */
2741 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2742 { WM_NCCALCSIZE, sent|wparam, 1 },
2743 { 0x0093, sent|defwinproc|optional },
2744 { 0x0093, sent|defwinproc|optional },
2745 { 0x0093, sent|defwinproc|optional },
2746 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2747 { WM_MOVE, sent|defwinproc },
2748 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2749
2750 /* in MDI client */
2751 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2752 { WM_NCCALCSIZE, sent|wparam, 1 },
2753 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2754 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2755
2756 /* in MDI child */
2757 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2758 { WM_NCCALCSIZE, sent|wparam, 1 },
2759 { 0x0093, sent|optional },
2760 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2761 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2762
2763 { 0x0093, sent|optional },
2764 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2765 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2766 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP sends it to MDI frame */
2767 { 0x0093, sent|defwinproc|optional },
2768 { 0x0093, sent|defwinproc|optional },
2769 { 0x0093, sent|defwinproc|optional },
2770 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2771 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
2772
2773 { 0 }
2774 };
2775 /* CreateWindow for the 1st MDI child window, initially invisible and maximized */
2776 static const struct message WmCreateMDIchildInvisibleMaxSeq4[] = {
2777 { HCBT_CREATEWND, hook },
2778 { WM_GETMINMAXINFO, sent },
2779 { WM_NCCREATE, sent },
2780 { WM_NCCALCSIZE, sent|wparam, 0 },
2781 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
2782 { WM_CREATE, sent },
2783 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2784 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2785 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE, 0, SWP_NOZORDER }, /* MDI frame */
2786 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* MDI frame */
2787 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE, 0, SWP_NOZORDER }, /* MDI frame */
2788 { WM_MOVE, sent },
2789 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2790 { WM_GETMINMAXINFO, sent },
2791 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
2792 { WM_GETMINMAXINFO, sent|defwinproc },
2793 { WM_NCCALCSIZE, sent|wparam, 1 },
2794 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_STATECHANGED },
2795 { WM_MOVE, sent|defwinproc },
2796 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2797 /* in MDI frame */
2798 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2799 { WM_NCCALCSIZE, sent|wparam, 1 },
2800 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2801 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2802 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* MDI child */
2803 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2804 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2805 /* Win2k sends wparam set to
2806 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2807 * while Win9x doesn't bother to set child window id according to
2808 * CLIENTCREATESTRUCT.idFirstChild
2809 */
2810 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2811 { 0 }
2812 };
2813 /* WM_SYSCOMMAND/SC_CLOSE for the 2nd MDI child window, initially visible and maximized */
2814 static const struct message WmDestroyMDIchildVisibleMaxSeq2[] = {
2815 { WM_SYSCOMMAND, sent|wparam, SC_CLOSE },
2816 { HCBT_SYSCOMMAND, hook },
2817 { WM_CLOSE, sent|defwinproc },
2818 { WM_MDIDESTROY, sent }, /* in MDI client */
2819
2820 /* bring the 1st MDI child to top */
2821 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE }, /* in the 1st MDI child */
2822 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE }, /* in the 2nd MDI child */
2823
2824 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2825
2826 { WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 }, /* in the 1st MDI child */
2827 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
2828 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
2829
2830 /* maximize the 1st MDI child */
2831 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2832 { WM_GETMINMAXINFO, sent|defwinproc },
2833 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_STATECHANGED },
2834 { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
2835 { WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 },
2836 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2837 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2838
2839 /* restore the 2nd MDI child */
2840 { WM_SETREDRAW, sent|defwinproc|wparam, 0 },
2841 { HCBT_MINMAX, hook|lparam, 0, SW_NORMALNA },
2842 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_STATECHANGED },
2843 { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
2844
2845 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2846
2847 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2848 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2849
2850 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2851
2852 { WM_SETREDRAW, sent|defwinproc|wparam, 1 },
2853 /* in MDI frame */
2854 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2855 { WM_NCCALCSIZE, sent|wparam, 1 },
2856 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2857 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2858 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2859
2860 /* bring the 1st MDI child to top */
2861 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2862 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2863 { HCBT_SETFOCUS, hook },
2864 { WM_KILLFOCUS, sent|defwinproc },
2865 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
2866 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2867 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2868 { WM_SETFOCUS, sent }, /* in MDI client */
2869 { HCBT_SETFOCUS, hook },
2870 { WM_KILLFOCUS, sent }, /* in MDI client */
2871 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2872 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2873 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2874 { WM_SETFOCUS, sent|defwinproc },
2875 { WM_MDIACTIVATE, sent|defwinproc },
2876 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2877
2878 /* apparently ShowWindow(SW_SHOW) on an MDI client */
2879 { WM_SHOWWINDOW, sent|wparam, 1 },
2880 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2881 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2882 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2883 { WM_MDIREFRESHMENU, sent },
2884
2885 { HCBT_DESTROYWND, hook },
2886 /* Win2k sends wparam set to
2887 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
2888 * while Win9x doesn't bother to set child window id according to
2889 * CLIENTCREATESTRUCT.idFirstChild
2890 */
2891 { 0x0090, sent|defwinproc|optional },
2892 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
2893 { WM_SHOWWINDOW, sent|defwinproc|wparam, 0 },
2894 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2895 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2896 { WM_ERASEBKGND, sent|parent|optional },
2897 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2898
2899 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2900 { WM_DESTROY, sent|defwinproc },
2901 { WM_NCDESTROY, sent|defwinproc },
2902 { 0 }
2903 };
2904 /* WM_MDIDESTROY for the single MDI child window, initially visible and maximized */
2905 static const struct message WmDestroyMDIchildVisibleMaxSeq1[] = {
2906 { WM_MDIDESTROY, sent }, /* in MDI client */
2907 { WM_SHOWWINDOW, sent|wparam, 0 },
2908 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2909 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2910 { WM_ERASEBKGND, sent|parent|optional },
2911 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2912
2913 { HCBT_SETFOCUS, hook },
2914 { WM_KILLFOCUS, sent },
2915 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2916 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2917 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2918 { WM_SETFOCUS, sent }, /* in MDI client */
2919 { HCBT_SETFOCUS, hook },
2920 { WM_KILLFOCUS, sent }, /* in MDI client */
2921 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2922 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2923 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2924 { WM_SETFOCUS, sent },
2925
2926 /* in MDI child */
2927 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2928 { WM_NCCALCSIZE, sent|wparam, 1 },
2929 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2930 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2931
2932 /* in MDI frame */
2933 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2934 { WM_NCCALCSIZE, sent|wparam, 1 },
2935 { 0x0093, sent|defwinproc|optional },
2936 { 0x0093, sent|defwinproc|optional },
2937 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2938 { WM_MOVE, sent|defwinproc },
2939 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2940
2941 /* in MDI client */
2942 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2943 { WM_NCCALCSIZE, sent|wparam, 1 },
2944 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2945 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2946
2947 /* in MDI child */
2948 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2949 { WM_NCCALCSIZE, sent|wparam, 1 },
2950 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
2951 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2952
2953 /* in MDI child */
2954 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2955 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2956 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2957 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2958
2959 /* in MDI frame */
2960 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2961 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2962 { 0x0093, sent|defwinproc|optional },
2963 { 0x0093, sent|defwinproc|optional },
2964 { 0x0093, sent|defwinproc|optional },
2965 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2966 { WM_MOVE, sent|defwinproc },
2967 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2968
2969 /* in MDI client */
2970 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2971 { WM_NCCALCSIZE, sent|wparam, 1 },
2972 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2973 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2974
2975 /* in MDI child */
2976 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE },
2977 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2978 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
2979 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2980 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2981 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2982
2983 { 0x0093, sent|defwinproc|optional },
2984 { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 }, /* XP sends it to MDI frame */
2985 { 0x0093, sent|defwinproc|optional },
2986 { 0x0093, sent|defwinproc|optional },
2987 { 0x0093, sent|defwinproc|optional },
2988 { 0x0093, sent|optional },
2989
2990 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2991 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2992 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2993 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2994 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
2995
2996 /* in MDI frame */
2997 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2998 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
2999 { 0x0093, sent|defwinproc|optional },
3000 { 0x0093, sent|defwinproc|optional },
3001 { 0x0093, sent|defwinproc|optional },
3002 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3003 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
3004 { 0x0093, sent|optional },
3005
3006 { WM_NCACTIVATE, sent|wparam, 0 },
3007 { WM_MDIACTIVATE, sent },
3008
3009 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNORMAL },
3010 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_STATECHANGED },
3011 { WM_NCCALCSIZE, sent|wparam, 1 },
3012
3013 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
3014
3015 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3016 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3017 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3018
3019 /* in MDI child */
3020 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3021 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
3022 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3023 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3024
3025 /* in MDI frame */
3026 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3027 { WM_NCCALCSIZE, sent|wparam, 1 },
3028 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3029 { WM_MOVE, sent|defwinproc },
3030 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3031
3032 /* in MDI client */
3033 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
3034 { WM_NCCALCSIZE, sent|wparam, 1 },
3035 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
3036 { WM_SIZE, sent|wparam, SIZE_RESTORED },
3037 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3038 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP */
3039 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
3040 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
3041 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
3042
3043 { HCBT_SETFOCUS, hook },
3044 { WM_KILLFOCUS, sent },
3045 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
3046 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3047 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3048 { WM_SETFOCUS, sent }, /* in MDI client */
3049
3050 { WM_MDIREFRESHMENU, sent }, /* in MDI client */
3051
3052 { HCBT_DESTROYWND, hook },
3053 /* Win2k sends wparam set to
3054 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
3055 * while Win9x doesn't bother to set child window id according to
3056 * CLIENTCREATESTRUCT.idFirstChild
3057 */
3058 { 0x0090, sent|optional },
3059 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
3060
3061 { WM_SHOWWINDOW, sent|wparam, 0 },
3062 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3063 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
3064 { WM_ERASEBKGND, sent|parent|optional },
3065 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3066
3067 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
3068 { WM_DESTROY, sent },
3069 { WM_NCDESTROY, sent },
3070 { 0 }
3071 };
3072 /* ShowWindow(SW_MAXIMIZE) for a not visible MDI child window */
3073 static const struct message WmMaximizeMDIchildInvisibleSeq[] = {
3074 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
3075 { WM_GETMINMAXINFO, sent },
3076 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
3077 { WM_NCCALCSIZE, sent|wparam, 1 },
3078 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
3079 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3080
3081 { WM_WINDOWPOSCHANGING, sent|wparam|optional|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3082 { WM_NCACTIVATE, sent|wparam|optional|defwinproc, 1 },
3083 { HCBT_SETFOCUS, hook|optional },
3084 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3085 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3086 { WM_SETFOCUS, sent|optional }, /* in MDI client */
3087 { HCBT_SETFOCUS, hook|optional },
3088 { WM_KILLFOCUS, sent|optional }, /* in MDI client */
3089 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
3090 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
3091 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3092 { WM_SETFOCUS, sent|optional|defwinproc },
3093 { WM_MDIACTIVATE, sent|optional|defwinproc },
3094 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3095 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3096 /* in MDI frame */
3097 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3098 { WM_NCCALCSIZE, sent|wparam, 1 },
3099 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3100 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
3101 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3102 { 0 }
3103 };
3104 /* ShowWindow(SW_MAXIMIZE) for a not visible maximized MDI child window */
3105 static const struct message WmMaximizeMDIchildInvisibleSeq2[] = {
3106 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
3107 { WM_GETMINMAXINFO, sent },
3108 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED },
3109 { WM_GETMINMAXINFO, sent|defwinproc },
3110 { WM_NCCALCSIZE, sent|wparam, 1 },
3111 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
3112 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3113
3114 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3115 { WM_NCACTIVATE, sent|wparam|defwinproc|optional, 1 },
3116 { HCBT_SETFOCUS, hook|optional },
3117 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3118 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3119 { WM_SETFOCUS, sent|optional }, /* in MDI client */
3120 { HCBT_SETFOCUS, hook|optional },
3121 { WM_KILLFOCUS, sent|optional }, /* in MDI client */
3122 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
3123 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
3124 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3125 { WM_SETFOCUS, sent|defwinproc|optional },
3126 { WM_MDIACTIVATE, sent|defwinproc|optional },
3127 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3128 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3129 { 0 }
3130 };
3131 /* WM_MDIMAXIMIZE for an MDI child window with invisible parent */
3132 static const struct message WmMaximizeMDIchildInvisibleParentSeq[] = {
3133 { WM_MDIMAXIMIZE, sent }, /* in MDI client */
3134 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
3135 { WM_GETMINMAXINFO, sent },
3136 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
3137 { WM_GETMINMAXINFO, sent|defwinproc },
3138 { WM_NCCALCSIZE, sent|wparam, 1 },
3139 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP doesn't send it */
3140 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3141 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_STATECHANGED },
3142 { WM_MOVE, sent|defwinproc },
3143 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3144
3145 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3146 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
3147 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3148 { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 },
3149 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
3150 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI client XP */
3151 /* in MDI frame */
3152 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3153 { WM_NCCALCSIZE, sent|wparam, 1 },
3154 { 0x0093, sent|defwinproc|optional },
3155 { 0x0094, sent|defwinproc|optional },
3156 { 0x0094, sent|defwinproc|optional },
3157 { 0x0094, sent|defwinproc|optional },
3158 { 0x0094, sent|defwinproc|optional },
3159 { 0x0093, sent|defwinproc|optional },
3160 { 0x0093, sent|defwinproc|optional },
3161 { 0x0091, sent|defwinproc|optional },
3162 { 0x0092, sent|defwinproc|optional },
3163 { 0x0092, sent|defwinproc|optional },
3164 { 0x0092, sent|defwinproc|optional },
3165 { 0x0092, sent|defwinproc|optional },
3166 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3167 { WM_MOVE, sent|defwinproc },
3168 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3169 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame win2000 */
3170 /* in MDI client */
3171 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
3172 { WM_NCCALCSIZE, sent|wparam, 1 },
3173 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
3174 { WM_SIZE, sent|wparam, SIZE_RESTORED },
3175 /* in MDI child */
3176 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE },
3177 { WM_GETMINMAXINFO, sent|defwinproc },
3178 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
3179 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
3180 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3181 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child win2000 */
3182 { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 },
3183 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
3184 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
3185 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI client XP */
3186 /* in MDI frame */
3187 { 0x0093, sent|optional },
3188 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
3189 { 0x0093, sent|defwinproc|optional },
3190 { 0x0093, sent|defwinproc|optional },
3191 { 0x0093, sent|defwinproc|optional },
3192 { 0x0091, sent|defwinproc|optional },
3193 { 0x0092, sent|defwinproc|optional },
3194 { 0x0092, sent|defwinproc|optional },
3195 { 0x0092, sent|defwinproc|optional },
3196 { 0x0092, sent|defwinproc|optional },
3197 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame XP */
3198 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame XP */
3199 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
3200 { 0 }
3201 };
3202 /* ShowWindow(SW_MAXIMIZE) for a visible MDI child window */
3203 static const struct message WmMaximizeMDIchildVisibleSeq[] = {
3204 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
3205 { WM_GETMINMAXINFO, sent },
3206 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
3207 { WM_NCCALCSIZE, sent|wparam, 1 },
3208 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3209 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3210 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3211 /* in MDI frame */
3212 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3213 { WM_NCCALCSIZE, sent|wparam, 1 },
3214 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3215 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
3216 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3217 { 0 }
3218 };
3219 /* ShowWindow(SW_RESTORE) for a visible maximized MDI child window */
3220 static const struct message WmRestoreMDIchildVisibleSeq[] = {
3221 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
3222 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
3223 { WM_NCCALCSIZE, sent|wparam, 1 },
3224 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3225 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3226 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3227 /* in MDI frame */
3228 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3229 { WM_NCCALCSIZE, sent|wparam, 1 },
3230 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3231 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
3232 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3233 { 0 }
3234 };
3235 /* ShowWindow(SW_RESTORE) for a visible minimized MDI child window */
3236 static const struct message WmRestoreMDIchildVisibleSeq_2[] = {
3237 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
3238 { WM_QUERYOPEN, sent|wparam|lparam, 0, 0 },
3239 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
3240 { WM_NCCALCSIZE, sent|wparam, 1 },
3241 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3242 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
3243 { WM_MOVE, sent|defwinproc },
3244 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3245 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3246 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3247 { HCBT_SETFOCUS, hook },
3248 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
3249 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
3250 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3251 { WM_SETFOCUS, sent },
3252 { 0 }
3253 };
3254 /* ShowWindow(SW_MINIMIZE) for a visible restored MDI child window */
3255 static const struct message WmMinimizeMDIchildVisibleSeq[] = {
3256 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
3257 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_STATECHANGED },
3258 { WM_NCCALCSIZE, sent|wparam, 1 },
3259 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_STATECHANGED },
3260 { WM_MOVE, sent|defwinproc },
3261 { WM_SIZE, sent|defwinproc|wparam|lparam, SIZE_MINIMIZED, 0 },
3262 { WM_CHILDACTIVATE, sent|wparam|lparam|defwinproc, 0, 0 },
3263 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3264 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3265 /* FIXME: Wine creates an icon/title window while Windows doesn't */
3266 { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE }, /* MDI client */
3267 { 0 }
3268 };
3269 /* ShowWindow(SW_RESTORE) for a not visible MDI child window */
3270 static const struct message WmRestoreMDIchildInvisibleSeq[] = {
3271 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
3272 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
3273 { WM_NCCALCSIZE, sent|wparam, 1 },
3274 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
3275 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3276 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3277 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3278 /* in MDI frame */
3279 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3280 { WM_NCCALCSIZE, sent|wparam, 1 },
3281 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3282 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
3283 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3284 { 0 }
3285 };
3286
3287 static HWND mdi_client;
3288 static WNDPROC old_mdi_client_proc;
3289
3290 static LRESULT WINAPI mdi_client_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3291 {
3292 struct recvd_message msg;
3293
3294 /* do not log painting messages */
3295 if (message != WM_PAINT &&
3296 message != WM_NCPAINT &&
3297 message != WM_SYNCPAINT &&
3298 message != WM_ERASEBKGND &&
3299 message != WM_NCHITTEST &&
3300 message != WM_GETTEXT &&
3301 message != WM_MDIGETACTIVE &&
3302 !ignore_message( message ))
3303 {
3304 msg.hwnd = hwnd;
3305 msg.message = message;
3306 msg.flags = sent|wparam|lparam;
3307 msg.wParam = wParam;
3308 msg.lParam = lParam;
3309 msg.descr = "mdi client";
3310 add_message(&msg);
3311 }
3312
3313 return CallWindowProcA(old_mdi_client_proc, hwnd, message, wParam, lParam);
3314 }
3315
3316 static LRESULT WINAPI mdi_child_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3317 {
3318 static LONG defwndproc_counter = 0;
3319 LRESULT ret;
3320 struct recvd_message msg;
3321
3322 /* do not log painting messages */
3323 if (message != WM_PAINT &&
3324 message != WM_NCPAINT &&
3325 message != WM_SYNCPAINT &&
3326 message != WM_ERASEBKGND &&
3327 message != WM_NCHITTEST &&
3328 message != WM_GETTEXT &&
3329 !ignore_message( message ))
3330 {
3331 switch (message)
3332 {
3333 case WM_MDIACTIVATE:
3334 {
3335 HWND active, client = GetParent(hwnd);
3336
3337 active = (HWND)SendMessageA(client, WM_MDIGETACTIVE, 0, 0);
3338
3339 if (hwnd == (HWND)lParam) /* if we are being activated */
3340 ok (active == (HWND)lParam, "new active %p != active %p\n", (HWND)lParam, active);
3341 else
3342 ok (active == (HWND)wParam, "old active %p != active %p\n", (HWND)wParam, active);
3343 break;
3344 }
3345 }
3346
3347 msg.hwnd = hwnd;
3348 msg.message = message;
3349 msg.flags = sent|wparam|lparam;
3350 if (defwndproc_counter) msg.flags |= defwinproc;
3351 msg.wParam = wParam;
3352 msg.lParam = lParam;
3353 msg.descr = "mdi child";
3354 add_message(&msg);
3355 }
3356
3357 defwndproc_counter++;
3358 ret = DefMDIChildProcA(hwnd, message, wParam, lParam);
3359 defwndproc_counter--;
3360
3361 return ret;
3362 }
3363
3364 static LRESULT WINAPI mdi_frame_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3365 {
3366 static LONG defwndproc_counter = 0;
3367 LRESULT ret;
3368 struct recvd_message msg;
3369
3370 /* do not log painting messages */
3371 if (message != WM_PAINT &&
3372 message != WM_NCPAINT &&
3373 message != WM_SYNCPAINT &&
3374 message != WM_ERASEBKGND &&
3375 message != WM_NCHITTEST &&
3376 message != WM_GETTEXT &&
3377 !ignore_message( message ))
3378 {
3379 msg.hwnd = hwnd;
3380 msg.message = message;
3381 msg.flags = sent|wparam|lparam;
3382 if (defwndproc_counter) msg.flags |= defwinproc;
3383 msg.wParam = wParam;
3384 msg.lParam = lParam;
3385 msg.descr = "mdi frame";
3386 add_message(&msg);
3387 }
3388
3389 defwndproc_counter++;
3390 ret = DefFrameProcA(hwnd, mdi_client, message, wParam, lParam);
3391 defwndproc_counter--;
3392
3393 return ret;
3394 }
3395
3396 static BOOL mdi_RegisterWindowClasses(void)
3397 {
3398 WNDCLASSA cls;
3399
3400 cls.style = 0;
3401 cls.lpfnWndProc = mdi_frame_wnd_proc;
3402 cls.cbClsExtra = 0;
3403 cls.cbWndExtra = 0;
3404 cls.hInstance = GetModuleHandleA(0);
3405 cls.hIcon = 0;
3406 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
3407 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
3408 cls.lpszMenuName = NULL;
3409 cls.lpszClassName = "MDI_frame_class";
3410 if (!RegisterClassA(&cls)) return FALSE;
3411
3412 cls.lpfnWndProc = mdi_child_wnd_proc;
3413 cls.lpszClassName = "MDI_child_class";
3414 if (!RegisterClassA(&cls)) return FALSE;
3415
3416 if (!GetClassInfoA(0, "MDIClient", &cls)) assert(0);
3417 old_mdi_client_proc = cls.lpfnWndProc;
3418 cls.hInstance = GetModuleHandleA(0);
3419 cls.lpfnWndProc = mdi_client_hook_proc;
3420 cls.lpszClassName = "MDI_client_class";
3421 if (!RegisterClassA(&cls)) assert(0);
3422
3423 return TRUE;
3424 }
3425
3426 static void test_mdi_messages(void)
3427 {
3428 MDICREATESTRUCTA mdi_cs;
3429 CLIENTCREATESTRUCT client_cs;
3430 HWND mdi_frame, mdi_child, mdi_child2, active_child;
3431 BOOL zoomed;
3432 RECT rc;
3433 HMENU hMenu = CreateMenu();
3434 LONG val;
3435
3436 if (!mdi_RegisterWindowClasses()) assert(0);
3437
3438 flush_sequence();
3439
3440 trace("creating MDI frame window\n");
3441 mdi_frame = CreateWindowExA(0, "MDI_frame_class", "MDI frame window",
3442 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
3443 WS_MAXIMIZEBOX | WS_VISIBLE,
3444 100, 100, CW_USEDEFAULT, CW_USEDEFAULT,
3445 GetDesktopWindow(), hMenu,
3446 GetModuleHandleA(0), NULL);
3447 assert(mdi_frame);
3448 ok_sequence(WmCreateMDIframeSeq, "Create MDI frame window", FALSE);
3449
3450 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3451 ok(GetFocus() == mdi_frame, "wrong focus window %p\n", GetFocus());
3452
3453 trace("creating MDI client window\n");
3454 GetClientRect(mdi_frame, &rc);
3455 client_cs.hWindowMenu = 0;
3456 client_cs.idFirstChild = MDI_FIRST_CHILD_ID;
3457 mdi_client = CreateWindowExA(0, "MDI_client_class",
3458 NULL,
3459 WS_CHILD | WS_VISIBLE | MDIS_ALLCHILDSTYLES,
3460 rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top,
3461 mdi_frame, 0, GetModuleHandleA(0), &client_cs);
3462 assert(mdi_client);
3463 SetWindowLongA(mdi_client, 0, 0xdeadbeef);
3464
3465 ok_sequence(WmCreateMDIclientSeq, "Create visible MDI client window", FALSE);
3466 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3467 ok(GetFocus() == mdi_frame, "input focus should be on MDI frame not on %p\n", GetFocus());
3468
3469 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3470 ok(!active_child, "wrong active MDI child %p\n", active_child);
3471 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3472
3473 SetFocus(0);
3474 flush_sequence();
3475
3476 trace("creating invisible MDI child window\n");
3477 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3478 WS_CHILD,
3479 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3480 mdi_client, 0, GetModuleHandleA(0), NULL);
3481 assert(mdi_child);
3482
3483 flush_sequence();
3484 ShowWindow(mdi_child, SW_SHOWNORMAL);
3485 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOWNORMAL) MDI child window", FALSE);
3486
3487 ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3488 ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
3489
3490 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3491 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3492
3493 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3494 ok(!active_child, "wrong active MDI child %p\n", active_child);
3495 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3496
3497 ShowWindow(mdi_child, SW_HIDE);
3498 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE) MDI child window", FALSE);
3499 flush_sequence();
3500
3501 ShowWindow(mdi_child, SW_SHOW);
3502 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW) MDI child window", FALSE);
3503
3504 ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3505 ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
3506
3507 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3508 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3509
3510 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3511 ok(!active_child, "wrong active MDI child %p\n", active_child);
3512 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3513
3514 DestroyWindow(mdi_child);
3515 flush_sequence();
3516
3517 trace("creating visible MDI child window\n");
3518 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3519 WS_CHILD | WS_VISIBLE,
3520 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3521 mdi_client, 0, GetModuleHandleA(0), NULL);
3522 assert(mdi_child);
3523 ok_sequence(WmCreateMDIchildVisibleSeq, "Create visible MDI child window", FALSE);
3524
3525 ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3526 ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
3527
3528 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3529 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3530
3531 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3532 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3533 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3534 flush_sequence();
3535
3536 DestroyWindow(mdi_child);
3537 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
3538
3539 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3540 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3541
3542 /* Win2k: MDI client still returns a just destroyed child as active
3543 * Win9x: MDI client returns 0
3544 */
3545 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3546 ok(active_child == mdi_child || /* win2k */
3547 !active_child, /* win9x */
3548 "wrong active MDI child %p\n", active_child);
3549 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3550
3551 flush_sequence();
3552
3553 trace("creating invisible MDI child window\n");
3554 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3555 WS_CHILD,
3556 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3557 mdi_client, 0, GetModuleHandleA(0), NULL);
3558 assert(mdi_child2);
3559 ok_sequence(WmCreateMDIchildInvisibleSeq, "Create invisible MDI child window", FALSE);
3560
3561 ok(!(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE), "MDI child should not be visible\n");
3562 ok(!IsWindowVisible(mdi_child2), "MDI child should not be visible\n");
3563
3564 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3565 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3566
3567 /* Win2k: MDI client still returns a just destroyed child as active
3568 * Win9x: MDI client returns mdi_child2
3569 */
3570 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3571 ok(active_child == mdi_child || /* win2k */
3572 active_child == mdi_child2, /* win9x */
3573 "wrong active MDI child %p\n", active_child);
3574 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3575 flush_sequence();
3576
3577 ShowWindow(mdi_child2, SW_MAXIMIZE);
3578 ok_sequence(WmMaximizeMDIchildInvisibleSeq, "ShowWindow(SW_MAXIMIZE):invisible MDI child", FALSE);
3579
3580 ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3581 ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
3582
3583 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3584 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3585 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3586 flush_sequence();
3587
3588 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3589 ok(GetFocus() == mdi_child2 || /* win2k */
3590 GetFocus() == 0, /* win9x */
3591 "wrong focus window %p\n", GetFocus());
3592
3593 SetFocus(0);
3594 flush_sequence();
3595
3596 ShowWindow(mdi_child2, SW_HIDE);
3597 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
3598
3599 ShowWindow(mdi_child2, SW_RESTORE);
3600 ok_sequence(WmRestoreMDIchildInvisibleSeq, "ShowWindow(SW_RESTORE):invisible MDI child", FALSE);
3601 flush_sequence();
3602
3603 ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3604 ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
3605
3606 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3607 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3608 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3609 flush_sequence();
3610
3611 SetFocus(0);
3612 flush_sequence();
3613
3614 ShowWindow(mdi_child2, SW_HIDE);
3615 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
3616
3617 ShowWindow(mdi_child2, SW_SHOW);
3618 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):MDI child", FALSE);
3619
3620 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3621 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3622
3623 ShowWindow(mdi_child2, SW_MAXIMIZE);
3624 ok_sequence(WmMaximizeMDIchildVisibleSeq, "ShowWindow(SW_MAXIMIZE):MDI child", FALSE);
3625
3626 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3627 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3628
3629 ShowWindow(mdi_child2, SW_RESTORE);
3630 ok_sequence(WmRestoreMDIchildVisibleSeq, "ShowWindow(SW_RESTORE):maximized MDI child", FALSE);
3631
3632 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3633 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3634
3635 ShowWindow(mdi_child2, SW_MINIMIZE);
3636 ok_sequence(WmMinimizeMDIchildVisibleSeq, "ShowWindow(SW_MINIMIZE):MDI child", TRUE);
3637
3638 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3639 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3640
3641 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3642 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3643 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3644 flush_sequence();
3645
3646 ShowWindow(mdi_child2, SW_RESTORE);
3647 ok_sequence(WmRestoreMDIchildVisibleSeq_2, "ShowWindow(SW_RESTORE):minimized MDI child", FALSE);
3648
3649 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3650 ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
3651
3652 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3653 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3654 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3655 flush_sequence();
3656
3657 SetFocus(0);
3658 flush_sequence();
3659
3660 ShowWindow(mdi_child2, SW_HIDE);
3661 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
3662
3663 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3664 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3665
3666 DestroyWindow(mdi_child2);
3667 ok_sequence(WmDestroyMDIchildInvisibleSeq, "Destroy invisible MDI child window", FALSE);
3668
3669 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3670 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3671
3672 trace("Testing WM_CHILDACTIVATE\n");
3673
3674 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3675 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_DISABLED,
3676 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3677 mdi_client, 0, GetModuleHandleA(0), NULL);
3678
3679 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3680 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX,
3681 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3682 mdi_client, 0, GetModuleHandleA(0), NULL);
3683
3684 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3685 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3686 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3687
3688 flush_sequence();
3689 SendMessageW(mdi_child, WM_CHILDACTIVATE, 0, 0);
3690 ok_sequence(WmChildActivateDisabledWindowSeq, "WM_CHILDACTIVATE sent to disabled window", FALSE);
3691
3692 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3693 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3694 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3695 flush_sequence();
3696
3697 EnableWindow(mdi_child, TRUE);
3698
3699 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3700 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3701 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3702
3703 flush_sequence();
3704 SendMessageW(mdi_child, WM_CHILDACTIVATE, 0, 0);
3705 ok_sequence(WmChildActivateWindowSeq, "WM_CHILDACTIVATE sent to enabled window", FALSE);
3706
3707 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3708 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3709 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3710 flush_sequence();
3711
3712 DestroyWindow(mdi_child);
3713 DestroyWindow(mdi_child2);
3714 flush_sequence();
3715
3716 /* test for maximized MDI children */
3717 trace("creating maximized visible MDI child window 1\n");
3718 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3719 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3720 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3721 mdi_client, 0, GetModuleHandleA(0), NULL);
3722 assert(mdi_child);
3723 ok_sequence(WmCreateMDIchildVisibleMaxSeq1, "Create maximized visible 1st MDI child window", TRUE);
3724 ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
3725
3726 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3727 ok(GetFocus() == mdi_child || /* win2k */
3728 GetFocus() == 0, /* win9x */
3729 "wrong focus window %p\n", GetFocus());
3730
3731 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3732 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3733 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3734 flush_sequence();
3735
3736 trace("creating maximized visible MDI child window 2\n");
3737 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3738 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3739 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3740 mdi_client, 0, GetModuleHandleA(0), NULL);
3741 assert(mdi_child2);
3742 ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
3743 ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
3744 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
3745
3746 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3747 ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
3748
3749 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3750 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3751 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3752 flush_sequence();
3753
3754 trace("destroying maximized visible MDI child window 2\n");
3755 DestroyWindow(mdi_child2);
3756 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
3757
3758 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
3759
3760 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3761 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3762
3763 /* Win2k: MDI client still returns a just destroyed child as active
3764 * Win9x: MDI client returns 0
3765 */
3766 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3767 ok(active_child == mdi_child2 || /* win2k */
3768 !active_child, /* win9x */
3769 "wrong active MDI child %p\n", active_child);
3770 flush_sequence();
3771
3772 ShowWindow(mdi_child, SW_MAXIMIZE);
3773 ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
3774 flush_sequence();
3775
3776 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3777 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3778
3779 trace("re-creating maximized visible MDI child window 2\n");
3780 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3781 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3782 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3783 mdi_client, 0, GetModuleHandleA(0), NULL);
3784 assert(mdi_child2);
3785 ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
3786 ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
3787 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
3788
3789 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3790 ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
3791
3792 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3793 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3794 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3795 flush_sequence();
3796
3797 SendMessageA(mdi_child2, WM_SYSCOMMAND, SC_CLOSE, 0);
3798 ok_sequence(WmDestroyMDIchildVisibleMaxSeq2, "WM_SYSCOMMAND/SC_CLOSE on a visible maximized MDI child window", TRUE);
3799 ok(!IsWindow(mdi_child2), "MDI child 2 should be destroyed\n");
3800
3801 ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
3802 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3803 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3804
3805 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3806 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3807 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3808 flush_sequence();
3809
3810 DestroyWindow(mdi_child);
3811 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
3812
3813 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3814 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3815
3816 /* Win2k: MDI client still returns a just destroyed child as active
3817 * Win9x: MDI client returns 0
3818 */
3819 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3820 ok(active_child == mdi_child || /* win2k */
3821 !active_child, /* win9x */
3822 "wrong active MDI child %p\n", active_child);
3823 flush_sequence();
3824
3825 trace("creating maximized invisible MDI child window\n");
3826 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3827 WS_CHILD | WS_MAXIMIZE | WS_CAPTION | WS_THICKFRAME,
3828 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3829 mdi_client, 0, GetModuleHandleA(0), NULL);
3830 assert(mdi_child2);
3831 ok_sequence(WmCreateMDIchildInvisibleMaxSeq4, "Create maximized invisible MDI child window", FALSE);
3832 ok(IsZoomed(mdi_child2), "MDI child should be maximized\n");
3833 ok(!(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE), "MDI child should be not visible\n");
3834 ok(!IsWindowVisible(mdi_child2), "MDI child should be not visible\n");
3835
3836 /* Win2k: MDI client still returns a just destroyed child as active
3837 * Win9x: MDI client returns 0
3838 */
3839 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3840 ok(active_child == mdi_child || /* win2k */
3841 !active_child || active_child == mdi_child2, /* win9x */
3842 "wrong active MDI child %p\n", active_child);
3843 flush_sequence();
3844
3845 trace("call ShowWindow(mdi_child, SW_MAXIMIZE)\n");
3846 ShowWindow(mdi_child2, SW_MAXIMIZE);
3847 ok_sequence(WmMaximizeMDIchildInvisibleSeq2, "ShowWindow(SW_MAXIMIZE):invisible maximized MDI child", FALSE);
3848 ok(IsZoomed(mdi_child2), "MDI child should be maximized\n");
3849 ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3850 ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
3851
3852 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3853 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3854 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3855 flush_sequence();
3856
3857 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child2, 0);
3858 flush_sequence();
3859
3860 /* end of test for maximized MDI children */
3861 SetFocus(0);
3862 flush_sequence();
3863 trace("creating maximized visible MDI child window 1(Switch test)\n");
3864 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3865 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3866 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3867 mdi_client, 0, GetModuleHandleA(0), NULL);
3868 assert(mdi_child);
3869 ok_sequence(WmCreateMDIchildVisibleMaxSeq1, "Create maximized visible 1st MDI child window(Switch test)", TRUE);
3870 ok(IsZoomed(mdi_child), "1st MDI child should be maximized(Switch test)\n");
3871
3872 ok(GetActiveWindow() == mdi_frame, "wrong active window %p(Switch test)\n", GetActiveWindow());
3873 ok(GetFocus() == mdi_child || /* win2k */
3874 GetFocus() == 0, /* win9x */
3875 "wrong focus window %p(Switch test)\n", GetFocus());
3876
3877 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3878 ok(active_child == mdi_child, "wrong active MDI child %p(Switch test)\n", active_child);
3879 ok(zoomed, "wrong zoomed state %d(Switch test)\n", zoomed);
3880 flush_sequence();
3881
3882 trace("creating maximized visible MDI child window 2(Switch test)\n");
3883 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3884 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3885 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3886 mdi_client, 0, GetModuleHandleA(0), NULL);
3887 assert(mdi_child2);
3888 ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child window (Switch test)", TRUE);
3889
3890 ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized(Switch test)\n");
3891 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized(Switch test)\n");
3892
3893 ok(GetActiveWindow() == mdi_frame, "wrong active window %p(Switch test)\n", GetActiveWindow());
3894 ok(GetFocus() == mdi_child2, "wrong focus window %p(Switch test)\n", GetFocus());
3895
3896 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3897 ok(active_child == mdi_child2, "wrong active MDI child %p(Switch test)\n", active_child);
3898 ok(zoomed, "wrong zoomed state %d(Switch test)\n", zoomed);
3899 flush_sequence();
3900
3901 trace("Switch child window.\n");
3902 SendMessageA(mdi_client, WM_MDIACTIVATE, (WPARAM)mdi_child, 0);
3903 ok_sequence(WmSwitchChild, "Child did not switch correctly", TRUE);
3904 trace("end of test for switch maximized MDI children\n");
3905 flush_sequence();
3906
3907 /* Prepare for switching test of not maximized MDI children */
3908 ShowWindow( mdi_child, SW_NORMAL );
3909 ok(!IsZoomed(mdi_child), "wrong zoomed state for %p(Switch test)\n", mdi_child);
3910 ok(!IsZoomed(mdi_child2), "wrong zoomed state for %p(Switch test)\n", mdi_child2);
3911 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, 0);
3912 ok(active_child == mdi_child, "wrong active MDI child %p(Switch test)\n", active_child);
3913 flush_sequence();
3914
3915 SendMessageA(mdi_client, WM_MDIACTIVATE, (WPARAM)mdi_child2, 0);
3916 ok_sequence(WmSwitchNotMaximizedChild, "Not maximized child did not switch correctly", FALSE);
3917 trace("end of test for switch not maximized MDI children\n");
3918 flush_sequence();
3919
3920 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child, 0);
3921 flush_sequence();
3922
3923 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child2, 0);
3924 flush_sequence();
3925
3926 SetFocus(0);
3927 flush_sequence();
3928 /* end of tests for switch maximized/not maximized MDI children */
3929
3930 mdi_cs.szClass = "MDI_child_Class";
3931 mdi_cs.szTitle = "MDI child";
3932 mdi_cs.hOwner = GetModuleHandleA(0);
3933 mdi_cs.x = 0;
3934 mdi_cs.y = 0;
3935 mdi_cs.cx = CW_USEDEFAULT;
3936 mdi_cs.cy = CW_USEDEFAULT;
3937 mdi_cs.style = WS_CHILD | WS_SYSMENU | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE;
3938 mdi_cs.lParam = 0;
3939 mdi_child = (HWND)SendMessageA(mdi_client, WM_MDICREATE, 0, (LPARAM)&mdi_cs);
3940 ok(mdi_child != 0, "MDI child creation failed\n");
3941 ok_sequence(WmCreateMDIchildVisibleMaxSeq3, "WM_MDICREATE for maximized visible MDI child window", TRUE);
3942
3943 ok(GetMenuItemID(hMenu, GetMenuItemCount(hMenu) - 1) == SC_CLOSE, "SC_CLOSE menu item not found\n");
3944
3945 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3946 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3947
3948 ok(IsZoomed(mdi_child), "MDI child should be maximized\n");
3949 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3950 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3951
3952 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3953 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3954 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3955 flush_sequence();
3956
3957 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child, 0);
3958 ok_sequence(WmDestroyMDIchildVisibleMaxSeq1, "Destroy visible maximized MDI child window", TRUE);
3959
3960 ok(!IsWindow(mdi_child), "MDI child should be destroyed\n");
3961 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3962 ok(!active_child, "wrong active MDI child %p\n", active_child);
3963
3964 SetFocus(0);
3965 flush_sequence();
3966
3967 val = GetWindowLongA(mdi_client, 0);
3968 ok(val == 0xdeadbeef || broken(val == 0) /* >= Win Vista */, "Expected 0xdeadbeef, got 0x%x\n", val);
3969 DestroyWindow(mdi_client);
3970 ok_sequence(WmDestroyMDIclientSeq, "Destroy MDI client window", FALSE);
3971
3972 /* test maximization of MDI child with invisible parent */
3973 client_cs.hWindowMenu = 0;
3974 mdi_client = CreateWindowA("MDI_client_class",
3975 NULL,
3976 WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL | WS_VISIBLE,
3977 0, 0, 660, 430,
3978 mdi_frame, 0, GetModuleHandleA(0), &client_cs);
3979 ok_sequence(WmCreateMDIclientSeq, "Create MDI client window", FALSE);
3980
3981 ShowWindow(mdi_client, SW_HIDE);
3982 ok_sequence(WmHideMDIclientSeq, "Hide MDI client window", FALSE);
3983
3984 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3985 WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL,
3986 0, 0, 650, 440,
3987 mdi_client, 0, GetModuleHandleA(0), NULL);
3988 ok_sequence(WmCreateMDIchildInvisibleParentSeq, "Create MDI child window with invisible parent", FALSE);
3989
3990 SendMessageA(mdi_client, WM_MDIMAXIMIZE, (WPARAM) mdi_child, 0);
3991 ok_sequence(WmMaximizeMDIchildInvisibleParentSeq, "Maximize MDI child window with invisible parent", TRUE);
3992 zoomed = IsZoomed(mdi_child);
3993 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3994
3995 ShowWindow(mdi_client, SW_SHOW);
3996 ok_sequence(WmShowMDIclientSeq, "Show MDI client window", FALSE);
3997
3998 DestroyWindow(mdi_child);
3999 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible maximized MDI child window", TRUE);
4000
4001 /* end of test for maximization of MDI child with invisible parent */
4002
4003 DestroyWindow(mdi_client);
4004 ok_sequence(WmDestroyMDIclientSeq, "Destroy MDI client window", FALSE);
4005
4006 DestroyWindow(mdi_frame);
4007 ok_sequence(WmDestroyMDIframeSeq, "Destroy MDI frame window", FALSE);
4008 }
4009 /************************* End of MDI test **********************************/
4010
4011 static void test_WM_SETREDRAW(HWND hwnd)
4012 {
4013 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
4014
4015 flush_events();
4016 flush_sequence();
4017
4018 SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
4019 ok_sequence(WmSetRedrawFalseSeq, "SetRedraw:FALSE", FALSE);
4020
4021 ok(!(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should NOT be set\n");
4022 ok(!IsWindowVisible(hwnd), "IsWindowVisible() should return FALSE\n");
4023
4024 flush_sequence();
4025 SendMessageA(hwnd, WM_SETREDRAW, TRUE, 0);
4026 ok_sequence(WmSetRedrawTrueSeq, "SetRedraw:TRUE", FALSE);
4027
4028 ok(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4029 ok(IsWindowVisible(hwnd), "IsWindowVisible() should return TRUE\n");
4030
4031 /* restore original WS_VISIBLE state */
4032 SetWindowLongA(hwnd, GWL_STYLE, style);
4033
4034 flush_events();
4035 flush_sequence();
4036 }
4037
4038 static INT_PTR CALLBACK TestModalDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
4039 {
4040 struct recvd_message msg;
4041
4042 if (ignore_message( message )) return 0;
4043
4044 switch (message)
4045 {
4046 /* ignore */
4047 case WM_MOUSEMOVE:
4048 case WM_NCMOUSEMOVE:
4049 case WM_NCMOUSELEAVE:
4050 case WM_SETCURSOR:
4051 return 0;
4052 case WM_NCHITTEST:
4053 return HTCLIENT;
4054 }
4055
4056 msg.hwnd = hwnd;
4057 msg.message = message;
4058 msg.flags = sent|wparam|lparam;
4059 msg.wParam = wParam;
4060 msg.lParam = lParam;
4061 msg.descr = "dialog";
4062 add_message(&msg);
4063
4064 if (message == WM_INITDIALOG) SetTimer( hwnd, 1, 100, NULL );
4065 if (message == WM_TIMER) EndDialog( hwnd, 0 );
4066 return 0;
4067 }
4068
4069 static INT_PTR CALLBACK TestModalDlgProc2(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
4070 {
4071 struct recvd_message msg;
4072
4073 if (ignore_message( message )) return 0;
4074
4075 switch (message)
4076 {
4077 /* ignore */
4078 case WM_MOUSEMOVE:
4079 case WM_NCMOUSEMOVE:
4080 case WM_NCMOUSELEAVE:
4081 case WM_SETCURSOR:
4082 return 0;
4083 case WM_NCHITTEST:
4084 return HTCLIENT;
4085 }
4086
4087 msg.hwnd = hwnd;
4088 msg.message = message;
4089 msg.flags = sent|wparam|lparam;
4090 msg.wParam = wParam;
4091 msg.lParam = lParam;
4092 msg.descr = "dialog";
4093 add_message(&msg);
4094
4095 if (message == WM_INITDIALOG) EndDialog( hwnd, 0 );
4096 return 0;
4097 }
4098
4099 static void test_hv_scroll_1(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
4100 {
4101 DWORD style, exstyle;
4102 INT xmin, xmax;
4103 BOOL ret;
4104
4105 exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
4106 style = GetWindowLongA(hwnd, GWL_STYLE);
4107 /* do not be confused by WS_DLGFRAME set */
4108 if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
4109
4110 if (clear) ok(style & clear, "style %08x should be set\n", clear);
4111 if (set) ok(!(style & set), "style %08x should not be set\n", set);
4112
4113 ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
4114 ok( ret, "SetScrollRange(%d) error %d\n", ctl, GetLastError());
4115 if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
4116 ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollRange(SB_HORZ/SB_VERT) NC", FALSE);
4117 else
4118 ok_sequence(WmSetScrollRangeHVSeq, "SetScrollRange(SB_HORZ/SB_VERT)", FALSE);
4119
4120 style = GetWindowLongA(hwnd, GWL_STYLE);
4121 if (set) ok(style & set, "style %08x should be set\n", set);
4122 if (clear) ok(!(style & clear), "style %08x should not be set\n", clear);
4123
4124 /* a subsequent call should do nothing */
4125 ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
4126 ok( ret, "SetScrollRange(%d) error %d\n", ctl, GetLastError());
4127 ok_sequence(WmEmptySeq, "SetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
4128
4129 xmin = 0xdeadbeef;
4130 xmax = 0xdeadbeef;
4131 ret = GetScrollRange(hwnd, ctl, &xmin, &xmax);
4132 ok( ret, "GetScrollRange(%d) error %d\n", ctl, GetLastError());
4133 ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
4134 ok(xmin == min, "unexpected min scroll value %d\n", xmin);
4135 ok(xmax == max, "unexpected max scroll value %d\n", xmax);
4136 }
4137
4138 static void test_hv_scroll_2(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
4139 {
4140 DWORD style, exstyle;
4141 SCROLLINFO si;
4142 BOOL ret;
4143
4144 exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
4145 style = GetWindowLongA(hwnd, GWL_STYLE);
4146 /* do not be confused by WS_DLGFRAME set */
4147 if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
4148
4149 if (clear) ok(style & clear, "style %08x should be set\n", clear);
4150 if (set) ok(!(style & set), "style %08x should not be set\n", set);
4151
4152 si.cbSize = sizeof(si);
4153 si.fMask = SIF_RANGE;
4154 si.nMin = min;
4155 si.nMax = max;
4156 SetScrollInfo(hwnd, ctl, &si, TRUE);
4157 if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
4158 ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollInfo(SB_HORZ/SB_VERT) NC", FALSE);
4159 else
4160 ok_sequence(WmSetScrollRangeHVSeq, "SetScrollInfo(SB_HORZ/SB_VERT)", FALSE);
4161
4162 style = GetWindowLongA(hwnd, GWL_STYLE);
4163 if (set) ok(style & set, "style %08x should be set\n", set);
4164 if (clear) ok(!(style & clear), "style %08x should not be set\n", clear);
4165
4166 /* a subsequent call should do nothing */
4167 SetScrollInfo(hwnd, ctl, &si, TRUE);
4168 if (style & WS_HSCROLL)
4169 ok_sequence(WmSetScrollRangeHSeq_empty, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
4170 else if (style & WS_VSCROLL)
4171 ok_sequence(WmSetScrollRangeVSeq_empty, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
4172 else
4173 ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
4174
4175 si.fMask = SIF_PAGE;
4176 si.nPage = 5;
4177 SetScrollInfo(hwnd, ctl, &si, FALSE);
4178 ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
4179
4180 si.fMask = SIF_POS;
4181 si.nPos = max - 1;
4182 SetScrollInfo(hwnd, ctl, &si, FALSE);
4183 ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
4184
4185 si.fMask = SIF_RANGE;
4186 si.nMin = 0xdeadbeef;
4187 si.nMax = 0xdeadbeef;
4188 ret = GetScrollInfo(hwnd, ctl, &si);
4189 ok( ret, "GetScrollInfo error %d\n", GetLastError());
4190 ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
4191 ok(si.nMin == min, "unexpected min scroll value %d\n", si.nMin);
4192 ok(si.nMax == max, "unexpected max scroll value %d\n", si.nMax);
4193 }
4194
4195 /* Win9x sends WM_USER+xxx while and NT versions send SBM_xxx messages */
4196 static void test_scroll_messages(HWND hwnd)
4197 {
4198 SCROLLINFO si;
4199 INT min, max;
4200 BOOL ret;
4201
4202 flush_events();
4203 flush_sequence();
4204
4205 min = 0xdeadbeef;
4206 max = 0xdeadbeef;
4207 ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
4208 ok( ret, "GetScrollRange error %d\n", GetLastError());
4209 if (sequence->message != WmGetScrollRangeSeq[0].message)
4210 trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
4211 /* values of min and max are undefined */
4212 flush_sequence();
4213
4214 ret = SetScrollRange(hwnd, SB_CTL, 10, 150, FALSE);
4215 ok( ret, "SetScrollRange error %d\n", GetLastError());
4216 if (sequence->message != WmSetScrollRangeSeq[0].message)
4217 trace("SetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
4218 flush_sequence();
4219
4220 min = 0xdeadbeef;
4221 max = 0xdeadbeef;
4222 ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
4223 ok( ret, "GetScrollRange error %d\n", GetLastError());
4224 if (sequence->message != WmGetScrollRangeSeq[0].message)
4225 trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
4226 /* values of min and max are undefined */
4227 flush_sequence();
4228
4229 si.cbSize = sizeof(si);
4230 si.fMask = SIF_RANGE;
4231 si.nMin = 20;
4232 si.nMax = 160;
4233 SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
4234 if (sequence->message != WmSetScrollRangeSeq[0].message)
4235 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
4236 flush_sequence();
4237
4238 si.fMask = SIF_PAGE;
4239 si.nPage = 10;
4240 SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
4241 if (sequence->message != WmSetScrollRangeSeq[0].message)
4242 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
4243 flush_sequence();
4244
4245 si.fMask = SIF_POS;
4246 si.nPos = 20;
4247 SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
4248 if (sequence->message != WmSetScrollRangeSeq[0].message)
4249 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
4250 flush_sequence();
4251
4252 si.fMask = SIF_RANGE;
4253 si.nMin = 0xdeadbeef;
4254 si.nMax = 0xdeadbeef;
4255 ret = GetScrollInfo(hwnd, SB_CTL, &si);
4256 ok( ret, "GetScrollInfo error %d\n", GetLastError());
4257 if (sequence->message != WmGetScrollInfoSeq[0].message)
4258 trace("GetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
4259 /* values of min and max are undefined */
4260 flush_sequence();
4261
4262 /* set WS_HSCROLL */
4263 test_hv_scroll_1(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
4264 /* clear WS_HSCROLL */
4265 test_hv_scroll_1(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
4266
4267 /* set WS_HSCROLL */
4268 test_hv_scroll_2(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
4269 /* clear WS_HSCROLL */
4270 test_hv_scroll_2(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
4271
4272 /* set WS_VSCROLL */
4273 test_hv_scroll_1(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
4274 /* clear WS_VSCROLL */
4275 test_hv_scroll_1(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
4276
4277 /* set WS_VSCROLL */
4278 test_hv_scroll_2(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
4279 /* clear WS_VSCROLL */
4280 test_hv_scroll_2(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
4281 }
4282
4283 static void test_showwindow(void)
4284 {
4285 HWND hwnd, hchild;
4286 RECT rc;
4287
4288 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
4289 100, 100, 200, 200, 0, 0, 0, NULL);
4290 ok (hwnd != 0, "Failed to create overlapped window\n");
4291 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4292 0, 0, 10, 10, hwnd, 0, 0, NULL);
4293 ok (hchild != 0, "Failed to create child\n");
4294 flush_sequence();
4295
4296 /* ShowWindow( SW_SHOWNA) for invisible top level window */
4297 trace("calling ShowWindow( SW_SHOWNA) for invisible top level window\n");
4298 ok( ShowWindow(hwnd, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
4299 ok_sequence(WmSHOWNATopInvisible, "ShowWindow(SW_SHOWNA) on invisible top level window", FALSE);
4300
4301 /* ShowWindow( SW_SHOWNA) for now visible top level window */
4302 trace("calling ShowWindow( SW_SHOWNA) for now visible top level window\n");
4303 ok( ShowWindow(hwnd, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
4304 ok_sequence(WmSHOWNATopVisible, "ShowWindow(SW_SHOWNA) on visible top level window", FALSE);
4305 /* back to invisible */
4306 ShowWindow(hchild, SW_HIDE);
4307 ShowWindow(hwnd, SW_HIDE);
4308 flush_sequence();
4309 /* ShowWindow(SW_SHOWNA) with child and parent invisible */
4310 trace("calling ShowWindow( SW_SHOWNA) for invisible child with invisible parent\n");
4311 ok( ShowWindow(hchild, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
4312 ok_sequence(WmSHOWNAChildInvisParInvis, "ShowWindow(SW_SHOWNA) invisible child and parent", FALSE);
4313 /* ShowWindow(SW_SHOWNA) with child visible and parent invisible */
4314 ok( ShowWindow(hchild, SW_SHOW) != FALSE, "ShowWindow: window was invisible\n" );
4315 flush_sequence();
4316 trace("calling ShowWindow( SW_SHOWNA) for the visible child and invisible parent\n");
4317 ok( ShowWindow(hchild, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
4318 ok_sequence(WmSHOWNAChildVisParInvis, "ShowWindow(SW_SHOWNA) visible child and invisible parent", FALSE);
4319 /* ShowWindow(SW_SHOWNA) with child visible and parent visible */
4320 ShowWindow( hwnd, SW_SHOW);
4321 flush_sequence();
4322 trace("calling ShowWindow( SW_SHOWNA) for the visible child and parent\n");
4323 ok( ShowWindow(hchild, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
4324 ok_sequence(WmSHOWNAChildVisParVis, "ShowWindow(SW_SHOWNA) for the visible child and parent", FALSE);
4325
4326 /* ShowWindow(SW_SHOWNA) with child invisible and parent visible */
4327 ShowWindow( hchild, SW_HIDE);
4328 flush_sequence();
4329 trace("calling ShowWindow( SW_SHOWNA) for the invisible child and visible parent\n");
4330 ok( ShowWindow(hchild, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
4331 ok_sequence(WmSHOWNAChildInvisParVis, "ShowWindow(SW_SHOWNA) for the invisible child and visible parent", FALSE);
4332
4333 SetCapture(hchild);
4334 ok(GetCapture() == hchild, "wrong capture window %p\n", GetCapture());
4335 DestroyWindow(hchild);
4336 ok(!GetCapture(), "wrong capture window %p\n", GetCapture());
4337
4338 DestroyWindow(hwnd);
4339 flush_sequence();
4340
4341 /* Popup windows */
4342 /* Test 1:
4343 * 1. Create invisible maximized popup window.
4344 * 2. Move and resize it.
4345 * 3. Show it maximized.
4346 */
4347 trace("calling CreateWindowExA( WS_MAXIMIZE ) for invisible maximized popup window\n");
4348 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE,
4349 100, 100, 200, 200, 0, 0, 0, NULL);
4350 ok (hwnd != 0, "Failed to create popup window\n");
4351 ok(IsZoomed(hwnd), "window should be maximized\n");
4352 ok_sequence(WmCreateInvisibleMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
4353
4354 GetWindowRect(hwnd, &rc);
4355 ok( rc.right-rc.left == GetSystemMetrics(SM_CXSCREEN) &&
4356 rc.bottom-rc.top == GetSystemMetrics(SM_CYSCREEN),
4357 "Invalid maximized size before ShowWindow (%d,%d)-(%d,%d)\n",
4358 rc.left, rc.top, rc.right, rc.bottom);
4359 /* Reset window's size & position */
4360 SetWindowPos(hwnd, 0, 10, 10, 200, 200, SWP_NOZORDER | SWP_NOACTIVATE);
4361 ok(IsZoomed(hwnd), "window should be maximized\n");
4362 flush_sequence();
4363
4364 trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for invisible maximized popup window\n");
4365 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
4366 ok(IsZoomed(hwnd), "window should be maximized\n");
4367 ok_sequence(WmShowMaxPopupResizedSeq, "ShowWindow(SW_SHOWMAXIMIZED):invisible maximized and resized popup", FALSE);
4368
4369 GetWindowRect(hwnd, &rc);
4370 ok( rc.right-rc.left == GetSystemMetrics(SM_CXSCREEN) &&
4371 rc.bottom-rc.top == GetSystemMetrics(SM_CYSCREEN),
4372 "Invalid maximized size after ShowWindow (%d,%d)-(%d,%d)\n",
4373 rc.left, rc.top, rc.right, rc.bottom);
4374 DestroyWindow(hwnd);
4375 flush_sequence();
4376
4377 /* Test 2:
4378 * 1. Create invisible maximized popup window.
4379 * 2. Show it maximized.
4380 */
4381 trace("calling CreateWindowExA( WS_MAXIMIZE ) for invisible maximized popup window\n");
4382 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE,
4383 100, 100, 200, 200, 0, 0, 0, NULL);
4384 ok (hwnd != 0, "Failed to create popup window\n");
4385 ok(IsZoomed(hwnd), "window should be maximized\n");
4386 ok_sequence(WmCreateInvisibleMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
4387
4388 trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for invisible maximized popup window\n");
4389 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
4390 ok(IsZoomed(hwnd), "window should be maximized\n");
4391 ok_sequence(WmShowMaxPopupSeq, "ShowWindow(SW_SHOWMAXIMIZED):invisible maximized popup", FALSE);
4392 DestroyWindow(hwnd);
4393 flush_sequence();
4394
4395 /* Test 3:
4396 * 1. Create visible maximized popup window.
4397 */
4398 trace("calling CreateWindowExA( WS_MAXIMIZE ) for maximized popup window\n");
4399 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE | WS_VISIBLE,
4400 100, 100, 200, 200, 0, 0, 0, NULL);
4401 ok (hwnd != 0, "Failed to create popup window\n");
4402 ok(IsZoomed(hwnd), "window should be maximized\n");
4403 ok_sequence(WmCreateMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
4404 DestroyWindow(hwnd);
4405 flush_sequence();
4406
4407 /* Test 4:
4408 * 1. Create visible popup window.
4409 * 2. Maximize it.
4410 */
4411 trace("calling CreateWindowExA( WS_VISIBLE ) for popup window\n");
4412 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_VISIBLE,
4413 100, 100, 200, 200, 0, 0, 0, NULL);
4414 ok (hwnd != 0, "Failed to create popup window\n");
4415 ok(!IsZoomed(hwnd), "window should NOT be maximized\n");
4416 ok_sequence(WmCreatePopupSeq, "CreateWindow(WS_VISIBLE):popup", FALSE);
4417
4418 trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for visible popup window\n");
4419 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
4420 ok(IsZoomed(hwnd), "window should be maximized\n");
4421 ok_sequence(WmShowVisMaxPopupSeq, "ShowWindow(SW_SHOWMAXIMIZED):popup", FALSE);
4422 DestroyWindow(hwnd);
4423 flush_sequence();
4424 }
4425
4426 static void test_sys_menu(void)
4427 {
4428 HWND hwnd;
4429 HMENU hmenu;
4430 UINT state;
4431
4432 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
4433 100, 100, 200, 200, 0, 0, 0, NULL);
4434 ok (hwnd != 0, "Failed to create overlapped window\n");
4435
4436 flush_sequence();
4437
4438 /* test existing window without CS_NOCLOSE style */
4439 hmenu = GetSystemMenu(hwnd, FALSE);
4440 ok(hmenu != 0, "GetSystemMenu error %d\n", GetLastError());
4441
4442 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
4443 ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
4444 ok(!(state & (MF_DISABLED | MF_GRAYED)), "wrong SC_CLOSE state %x\n", state);
4445
4446 EnableMenuItem(hmenu, SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
4447 ok_sequence(WmEmptySeq, "WmEnableMenuItem", FALSE);
4448
4449 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
4450 ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
4451 ok((state & (MF_DISABLED | MF_GRAYED)) == MF_GRAYED, "wrong SC_CLOSE state %x\n", state);
4452
4453 EnableMenuItem(hmenu, SC_CLOSE, 0);
4454 ok_sequence(WmEmptySeq, "WmEnableMenuItem", FALSE);
4455
4456 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
4457 ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
4458 ok(!(state & (MF_DISABLED | MF_GRAYED)), "wrong SC_CLOSE state %x\n", state);
4459
4460 /* test whether removing WS_SYSMENU destroys a system menu */
4461 SetWindowLongW(hwnd, GWL_STYLE, WS_POPUP);
4462 SetWindowPos(hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_FRAMECHANGED);
4463 flush_sequence();
4464 hmenu = GetSystemMenu(hwnd, FALSE);
4465 ok(hmenu != 0, "GetSystemMenu error %d\n", GetLastError());
4466
4467 DestroyWindow(hwnd);
4468
4469 /* test new window with CS_NOCLOSE style */
4470 hwnd = CreateWindowExA(0, "NoCloseWindowClass", NULL, WS_OVERLAPPEDWINDOW,
4471 100, 100, 200, 200, 0, 0, 0, NULL);
4472 ok (hwnd != 0, "Failed to create overlapped window\n");
4473
4474 hmenu = GetSystemMenu(hwnd, FALSE);
4475 ok(hmenu != 0, "GetSystemMenu error %d\n", GetLastError());
4476
4477 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
4478 ok(state == 0xffffffff, "wrong SC_CLOSE state %x\n", state);
4479
4480 DestroyWindow(hwnd);
4481
4482 /* test new window without WS_SYSMENU style */
4483 hwnd = CreateWindowExA(0, "NoCloseWindowClass", NULL, WS_OVERLAPPEDWINDOW & ~WS_SYSMENU,
4484 100, 100, 200, 200, 0, 0, 0, NULL);
4485 ok(hwnd != 0, "Failed to create overlapped window\n");
4486
4487 hmenu = GetSystemMenu(hwnd, FALSE);
4488 ok(!hmenu, "GetSystemMenu error %d\n", GetLastError());
4489
4490 DestroyWindow(hwnd);
4491 }
4492
4493 /* For shown WS_OVERLAPPEDWINDOW */
4494 static const struct message WmSetIcon_1[] = {
4495 { WM_SETICON, sent },
4496 { 0x00AE, sent|defwinproc|optional }, /* XP */
4497 { WM_GETTEXT, sent|defwinproc|optional },
4498 { WM_GETTEXT, sent|defwinproc|optional }, /* XP sends a duplicate */
4499 { 0 }
4500 };
4501
4502 /* For WS_POPUP and hidden WS_OVERLAPPEDWINDOW */
4503 static const struct message WmSetIcon_2[] = {
4504 { WM_SETICON, sent },
4505 { 0 }
4506 };
4507
4508 /* Sending undocumented 0x3B message with wparam = 0x8000000b */
4509 static const struct message WmInitEndSession[] = {
4510 { 0x003B, sent },
4511 { WM_QUERYENDSESSION, sent|defwinproc|wparam|lparam, 0, ENDSESSION_LOGOFF },
4512 { 0 }
4513 };
4514
4515 /* Sending undocumented 0x3B message with wparam = 0x0000000b */
4516 static const struct message WmInitEndSession_2[] = {
4517 { 0x003B, sent },
4518 { WM_QUERYENDSESSION, sent|defwinproc|wparam|lparam, 0, 0 },
4519 { 0 }
4520 };
4521
4522 /* Sending undocumented 0x3B message with wparam = 0x80000008 */
4523 static const struct message WmInitEndSession_3[] = {
4524 { 0x003B, sent },
4525 { WM_ENDSESSION, sent|defwinproc|wparam|lparam, 0, ENDSESSION_LOGOFF },
4526 { 0 }
4527 };
4528
4529 /* Sending undocumented 0x3B message with wparam = 0x00000008 */
4530 static const struct message WmInitEndSession_4[] = {
4531 { 0x003B, sent },
4532 { WM_ENDSESSION, sent|defwinproc|wparam|lparam, 0, 0 },
4533 { 0 }
4534 };
4535
4536 /* Sending undocumented 0x3B message with wparam = 0x80000001 */
4537 static const struct message WmInitEndSession_5[] = {
4538 { 0x003B, sent },
4539 { WM_ENDSESSION, sent|defwinproc/*|wparam*/|lparam, 1, ENDSESSION_LOGOFF },
4540 { 0 }
4541 };
4542
4543 static const struct message WmOptionalPaint[] = {
4544 { WM_PAINT, sent|optional },
4545 { WM_NCPAINT, sent|beginpaint|optional },
4546 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
4547 { WM_ERASEBKGND, sent|beginpaint|optional },
4548 { 0 }
4549 };
4550
4551 static const struct message WmZOrder[] = {
4552 { WM_WINDOWPOSCHANGING, sent|wparam, 0, 0 },
4553 { WM_GETMINMAXINFO, sent|defwinproc|wparam, 0, 0 },
4554 { HCBT_ACTIVATE, hook },
4555 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
4556 { WM_WINDOWPOSCHANGING, sent|wparam, 3, 0 },
4557 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOREDRAW|SWP_NOMOVE|SWP_NOSIZE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE, 0 },
4558 { WM_GETTEXT, sent|optional },
4559 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
4560 { WM_ACTIVATEAPP, sent|wparam, 1, 0 },
4561 { WM_NCACTIVATE, sent|lparam, 1, 0 },
4562 { WM_GETTEXT, sent|defwinproc|optional },
4563 { WM_GETTEXT, sent|defwinproc|optional },
4564 { WM_ACTIVATE, sent|wparam|lparam, 1, 0 },
4565 { HCBT_SETFOCUS, hook },
4566 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
4567 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
4568 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
4569 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
4570 { WM_GETTEXT, sent|optional },
4571 { WM_NCCALCSIZE, sent|optional },
4572 { 0 }
4573 };
4574
4575 static void CALLBACK apc_test_proc(ULONG_PTR param)
4576 {
4577 /* nothing */
4578 }
4579
4580 static void test_MsgWaitForMultipleObjects(HWND hwnd)
4581 {
4582 DWORD ret;
4583 MSG msg;
4584
4585 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4586 ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %x\n", ret);
4587
4588 PostMessageA(hwnd, WM_USER, 0, 0);
4589
4590 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4591 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %x\n", ret);
4592
4593 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
4594 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4595
4596 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4597 ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %x\n", ret);
4598
4599 PostMessageA(hwnd, WM_USER, 0, 0);
4600
4601 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4602 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %x\n", ret);
4603
4604 ok(PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ), "PeekMessage should succeed\n");
4605 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4606
4607 /* shows QS_POSTMESSAGE flag is cleared in the PeekMessage call */
4608 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4609 ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %x\n", ret);
4610
4611 PostMessageA(hwnd, WM_USER, 0, 0);
4612
4613 /* new incoming message causes it to become signaled again */
4614 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4615 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %x\n", ret);
4616
4617 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
4618 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4619 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
4620 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4621
4622 /* MWMO_INPUTAVAILABLE should succeed even if the message was already seen */
4623 PostMessageA( hwnd, WM_USER, 0, 0 );
4624 ok(PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ), "PeekMessage should succeed\n");
4625 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4626
4627 ret = MsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_POSTMESSAGE, MWMO_INPUTAVAILABLE );
4628 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjectsEx returned %x\n", ret);
4629
4630 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
4631 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4632
4633 /* without MWMO_ALERTABLE the result is never WAIT_IO_COMPLETION */
4634 ret = QueueUserAPC( apc_test_proc, GetCurrentThread(), 0 );
4635 ok(ret, "QueueUserAPC failed %u\n", GetLastError());
4636
4637 ret = MsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_POSTMESSAGE, 0 );
4638 ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjectsEx returned %x\n", ret);
4639
4640 /* but even with MWMO_ALERTABLE window events are preferred */
4641 PostMessageA( hwnd, WM_USER, 0, 0 );
4642
4643 ret = MsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_POSTMESSAGE, MWMO_ALERTABLE );
4644 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjectsEx returned %x\n", ret);
4645
4646 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
4647 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4648
4649 /* the APC call is still queued */
4650 ret = MsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_POSTMESSAGE, MWMO_ALERTABLE );
4651 ok(ret == WAIT_IO_COMPLETION, "MsgWaitForMultipleObjectsEx returned %x\n", ret);
4652 }
4653
4654 static void test_WM_DEVICECHANGE(HWND hwnd)
4655 {
4656 DWORD ret;
4657 MSG msg;
4658 int i;
4659 static const WPARAM wparams[] = {0,
4660 DBT_DEVNODES_CHANGED,
4661 DBT_QUERYCHANGECONFIG,
4662 DBT_CONFIGCHANGED,
4663 DBT_CONFIGCHANGECANCELED,
4664 DBT_NO_DISK_SPACE,
4665 DBT_LOW_DISK_SPACE,
4666 DBT_CONFIGMGPRIVATE, /* 0x7fff */
4667 DBT_DEVICEARRIVAL, /* 0x8000 */
4668 DBT_DEVICEQUERYREMOVE,
4669 DBT_DEVICEQUERYREMOVEFAILED,
4670 DBT_DEVICEREMOVEPENDING,
4671 DBT_DEVICEREMOVECOMPLETE,
4672 DBT_DEVICETYPESPECIFIC,
4673 DBT_CUSTOMEVENT};
4674
4675 for (i = 0; i < sizeof(wparams)/sizeof(wparams[0]); i++)
4676 {
4677 SetLastError(0xdeadbeef);
4678 ret = PostMessageA(hwnd, WM_DEVICECHANGE, wparams[i], 0);
4679 if (wparams[i] & 0x8000)
4680 {
4681 ok(ret == FALSE, "PostMessage should returned %d\n", ret);
4682 ok(GetLastError() == ERROR_MESSAGE_SYNC_ONLY, "PostMessage error %08x\n", GetLastError());
4683 }
4684 else
4685 {
4686 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4687 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %x\n", ret);
4688 memset(&msg, 0, sizeof(msg));
4689 ok(PeekMessageA(&msg, 0, 0, 0, PM_REMOVE), "PeekMessage should succeed\n");
4690 ok(msg.message == WM_DEVICECHANGE, "got %04x instead of WM_DEVICECHANGE\n", msg.message);
4691 }
4692 }
4693 }
4694
4695 static DWORD CALLBACK show_window_thread(LPVOID arg)
4696 {
4697 HWND hwnd = arg;
4698
4699 /* function will not return if ShowWindow(SW_HIDE) calls SendMessage() */
4700 ok(ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow(SW_HIDE) expected FALSE\n");
4701
4702 return 0;
4703 }
4704
4705 /* test if we receive the right sequence of messages */
4706 static void test_messages(void)
4707 {
4708 DWORD tid;
4709 HANDLE hthread;
4710 HWND hwnd, hparent, hchild;
4711 HWND hchild2, hbutton;
4712 HMENU hmenu;
4713 MSG msg;
4714 LRESULT res;
4715 POINT pos;
4716 BOOL ret;
4717
4718 flush_sequence();
4719
4720 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
4721 100, 100, 200, 200, 0, 0, 0, NULL);
4722 ok (hwnd != 0, "Failed to create overlapped window\n");
4723 ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
4724
4725 /* test ShowWindow(SW_HIDE) on a newly created invisible window */
4726 ok( ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow: window was visible\n" );
4727 ok_sequence(WmEmptySeq, "ShowWindow(SW_HIDE):overlapped, invisible", FALSE);
4728
4729 /* test WM_SETREDRAW on a not visible top level window */
4730 test_WM_SETREDRAW(hwnd);
4731
4732 SetWindowPos(hwnd, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4733 flush_events();
4734 ok_sequence(WmSWP_ShowOverlappedSeq, "SetWindowPos:SWP_SHOWWINDOW:overlapped", FALSE);
4735 ok(IsWindowVisible(hwnd), "window should be visible at this point\n");
4736
4737 ok(GetActiveWindow() == hwnd, "window should be active\n");
4738 ok(GetFocus() == hwnd, "window should have input focus\n");
4739 ShowWindow(hwnd, SW_HIDE);
4740 flush_events();
4741 ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
4742
4743 /* test ShowWindow(SW_HIDE) on a hidden window - single threaded */
4744 ok(ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow(SW_HIDE) expected FALSE\n");
4745 flush_events();
4746 ok_sequence(WmEmptySeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
4747
4748 /* test ShowWindow(SW_HIDE) on a hidden window - multi-threaded */
4749 hthread = CreateThread(NULL, 0, show_window_thread, hwnd, 0, &tid);
4750 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
4751 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
4752 CloseHandle(hthread);
4753 flush_events();
4754 ok_sequence(WmEmptySeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
4755
4756 ShowWindow(hwnd, SW_SHOW);
4757 flush_events();
4758 ok_sequence(WmShowOverlappedSeq, "ShowWindow(SW_SHOW):overlapped", TRUE);
4759
4760 ShowWindow(hwnd, SW_HIDE);
4761 flush_events();
4762 ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
4763
4764 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
4765 flush_events();
4766 ok_sequence(WmShowMaxOverlappedSeq, "ShowWindow(SW_SHOWMAXIMIZED):overlapped", TRUE);
4767 flush_sequence();
4768
4769 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_MAXIMIZE)
4770 {
4771 ShowWindow(hwnd, SW_RESTORE);
4772 flush_events();
4773 ok_sequence(WmShowRestoreMaxOverlappedSeq, "ShowWindow(SW_RESTORE):overlapped", TRUE);
4774 flush_sequence();
4775 }
4776
4777 ShowWindow(hwnd, SW_MINIMIZE);
4778 flush_events();
4779 ok_sequence(WmShowMinOverlappedSeq, "ShowWindow(SW_SHOWMINIMIZED):overlapped", TRUE);
4780 flush_sequence();
4781
4782 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_MINIMIZE)
4783 {
4784 ShowWindow(hwnd, SW_RESTORE);
4785 flush_events();
4786 ok_sequence(WmShowRestoreMinOverlappedSeq, "ShowWindow(SW_RESTORE):overlapped", TRUE);
4787 flush_sequence();
4788 }
4789
4790 ShowWindow(hwnd, SW_SHOW);
4791 flush_events();
4792 ok_sequence(WmOptionalPaint, "ShowWindow(SW_SHOW):overlapped already visible", FALSE);
4793
4794 SetWindowPos(hwnd, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4795 ok_sequence(WmSWP_HideOverlappedSeq, "SetWindowPos:SWP_HIDEWINDOW:overlapped", FALSE);
4796 ok(!IsWindowVisible(hwnd), "window should not be visible at this point\n");
4797 ok(GetActiveWindow() == hwnd, "window should still be active\n");
4798
4799 /* test WM_SETREDRAW on a visible top level window */
4800 ShowWindow(hwnd, SW_SHOW);
4801 flush_events();
4802 test_WM_SETREDRAW(hwnd);
4803
4804 trace("testing scroll APIs on a visible top level window %p\n", hwnd);
4805 test_scroll_messages(hwnd);
4806
4807 /* test resizing and moving */
4808 SetWindowPos( hwnd, 0, 0, 0, 300, 300, SWP_NOMOVE|SWP_NOACTIVATE );
4809 ok_sequence(WmSWP_ResizeSeq, "SetWindowPos:Resize", FALSE );
4810 flush_events();
4811 flush_sequence();
4812 SetWindowPos( hwnd, 0, 200, 200, 0, 0, SWP_NOSIZE|SWP_NOACTIVATE );
4813 ok_sequence(WmSWP_MoveSeq, "SetWindowPos:Move", FALSE );
4814 flush_events();
4815 flush_sequence();
4816 SetWindowPos( hwnd, 0, 200, 200, 250, 250, SWP_NOZORDER|SWP_NOACTIVATE );
4817 ok_sequence(WmSWP_ResizeNoZOrder, "SetWindowPos:WmSWP_ResizeNoZOrder", FALSE );
4818 flush_events();
4819 flush_sequence();
4820
4821 /* popups don't get WM_GETMINMAXINFO */
4822 SetWindowLongW( hwnd, GWL_STYLE, WS_VISIBLE|WS_POPUP );
4823 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_FRAMECHANGED);
4824 flush_sequence();
4825 SetWindowPos( hwnd, 0, 0, 0, 200, 200, SWP_NOMOVE|SWP_NOACTIVATE );
4826 ok_sequence(WmSWP_ResizePopupSeq, "SetWindowPos:ResizePopup", FALSE );
4827
4828 DestroyWindow(hwnd);
4829 ok_sequence(WmDestroyOverlappedSeq, "DestroyWindow:overlapped", FALSE);
4830
4831 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
4832 100, 100, 200, 200, 0, 0, 0, NULL);
4833 ok (hparent != 0, "Failed to create parent window\n");
4834 flush_sequence();
4835
4836 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_MAXIMIZE,
4837 0, 0, 10, 10, hparent, 0, 0, NULL);
4838 ok (hchild != 0, "Failed to create child window\n");
4839 ok_sequence(WmCreateMaximizedChildSeq, "CreateWindow:maximized child", FALSE);
4840 DestroyWindow(hchild);
4841 flush_sequence();
4842
4843 /* visible child window with a caption */
4844 hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
4845 WS_CHILD | WS_VISIBLE | WS_CAPTION,
4846 0, 0, 10, 10, hparent, 0, 0, NULL);
4847 ok (hchild != 0, "Failed to create child window\n");
4848 ok_sequence(WmCreateVisibleChildSeq, "CreateWindow:visible child", FALSE);
4849
4850 trace("testing scroll APIs on a visible child window %p\n", hchild);
4851 test_scroll_messages(hchild);
4852
4853 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4854 ok_sequence(WmShowChildSeq_4, "SetWindowPos(SWP_SHOWWINDOW):child with a caption", FALSE);
4855
4856 DestroyWindow(hchild);
4857 flush_sequence();
4858
4859 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4860 0, 0, 10, 10, hparent, 0, 0, NULL);
4861 ok (hchild != 0, "Failed to create child window\n");
4862 ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
4863
4864 hchild2 = CreateWindowExA(0, "SimpleWindowClass", "Test child2", WS_CHILD,
4865 100, 100, 50, 50, hparent, 0, 0, NULL);
4866 ok (hchild2 != 0, "Failed to create child2 window\n");
4867 flush_sequence();
4868
4869 hbutton = CreateWindowExA(0, "TestWindowClass", "Test button", WS_CHILD,
4870 0, 100, 50, 50, hchild, 0, 0, NULL);
4871 ok (hbutton != 0, "Failed to create button window\n");
4872
4873 /* test WM_SETREDRAW on a not visible child window */
4874 test_WM_SETREDRAW(hchild);
4875
4876 ShowWindow(hchild, SW_SHOW);
4877 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
4878
4879 /* check parent messages too */
4880 log_all_parent_messages++;
4881 ShowWindow(hchild, SW_HIDE);
4882 ok_sequence(WmHideChildSeq2, "ShowWindow(SW_HIDE):child", FALSE);
4883 log_all_parent_messages--;
4884
4885 ShowWindow(hchild, SW_SHOW);
4886 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
4887
4888 ShowWindow(hchild, SW_HIDE);
4889 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):child", FALSE);
4890
4891 ShowWindow(hchild, SW_SHOW);
4892 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
4893
4894 /* test WM_SETREDRAW on a visible child window */
4895 test_WM_SETREDRAW(hchild);
4896
4897 log_all_parent_messages++;
4898 MoveWindow(hchild, 10, 10, 20, 20, TRUE);
4899 ok_sequence(WmResizingChildWithMoveWindowSeq, "MoveWindow:child", FALSE);
4900 log_all_parent_messages--;
4901
4902 ShowWindow(hchild, SW_HIDE);
4903 flush_sequence();
4904 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4905 ok_sequence(WmShowChildSeq_2, "SetWindowPos:show_child_2", FALSE);
4906
4907 ShowWindow(hchild, SW_HIDE);
4908 flush_sequence();
4909 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE);
4910 ok_sequence(WmShowChildSeq_3, "SetWindowPos:show_child_3", FALSE);
4911
4912 /* DestroyWindow sequence below expects that a child has focus */
4913 SetFocus(hchild);
4914 flush_sequence();
4915
4916 DestroyWindow(hchild);
4917 ok_sequence(WmDestroyChildSeq, "DestroyWindow:child", FALSE);
4918 DestroyWindow(hchild2);
4919 DestroyWindow(hbutton);
4920
4921 flush_sequence();
4922 hchild = CreateWindowExA(0, "TestWindowClass", "Test Child Popup", WS_CHILD | WS_POPUP,
4923 0, 0, 100, 100, hparent, 0, 0, NULL);
4924 ok (hchild != 0, "Failed to create child popup window\n");
4925 ok_sequence(WmCreateChildPopupSeq, "CreateWindow:child_popup", FALSE);
4926 DestroyWindow(hchild);
4927
4928 /* test what happens to a window which sets WS_VISIBLE in WM_CREATE */
4929 flush_sequence();
4930 hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP,
4931 0, 0, 100, 100, hparent, 0, 0, NULL);
4932 ok (hchild != 0, "Failed to create popup window\n");
4933 ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
4934 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4935 ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
4936 flush_sequence();
4937 ShowWindow(hchild, SW_SHOW);
4938 ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
4939 flush_sequence();
4940 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
4941 ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
4942 flush_sequence();
4943 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4944 ok_sequence(WmShowVisiblePopupSeq_3, "SetWindowPos:show_visible_popup_3", FALSE);
4945 DestroyWindow(hchild);
4946
4947 /* this time add WS_VISIBLE for CreateWindowEx, but this fact actually
4948 * changes nothing in message sequences.
4949 */
4950 flush_sequence();
4951 hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP | WS_VISIBLE,
4952 0, 0, 100, 100, hparent, 0, 0, NULL);
4953 ok (hchild != 0, "Failed to create popup window\n");
4954 ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
4955 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4956 ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
4957 flush_sequence();
4958 ShowWindow(hchild, SW_SHOW);
4959 ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
4960 flush_sequence();
4961 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
4962 ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
4963 DestroyWindow(hchild);
4964
4965 flush_sequence();
4966 hwnd = CreateWindowExA(WS_EX_DLGMODALFRAME, "TestDialogClass", NULL, WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
4967 0, 0, 100, 100, hparent, 0, 0, NULL);
4968 ok(hwnd != 0, "Failed to create custom dialog window\n");
4969 ok_sequence(WmCreateCustomDialogSeq, "CreateCustomDialog", TRUE);
4970
4971 if(0) {
4972 trace("testing scroll APIs on a visible dialog %p\n", hwnd);
4973 test_scroll_messages(hwnd);
4974 }
4975
4976 flush_sequence();
4977
4978 test_def_id = TRUE;
4979 SendMessageA(hwnd, WM_NULL, 0, 0);
4980
4981 flush_sequence();
4982 after_end_dialog = TRUE;
4983 EndDialog( hwnd, 0 );
4984 ok_sequence(WmEndCustomDialogSeq, "EndCustomDialog", FALSE);
4985
4986 DestroyWindow(hwnd);
4987 after_end_dialog = FALSE;
4988 test_def_id = FALSE;
4989
4990 ok(GetCursorPos(&pos), "GetCursorPos failed\n");
4991 ok(SetCursorPos(109, 109), "SetCursorPos failed\n");
4992
4993 hwnd = CreateWindowExA(0, "TestDialogClass", NULL, WS_POPUP|WS_CHILD,
4994 0, 0, 100, 100, 0, 0, GetModuleHandleA(0), NULL);
4995 ok(hwnd != 0, "Failed to create custom dialog window\n");
4996 flush_sequence();
4997 trace("call ShowWindow(%p, SW_SHOW)\n", hwnd);
4998 ShowWindow(hwnd, SW_SHOW);
4999 ok_sequence(WmShowCustomDialogSeq, "ShowCustomDialog", TRUE);
5000
5001 flush_events();
5002 flush_sequence();
5003 ret = DrawMenuBar(hwnd);
5004 ok(ret, "DrawMenuBar failed: %d\n", GetLastError());
5005 flush_events();
5006 ok_sequence(WmDrawMenuBarSeq, "DrawMenuBar", FALSE);
5007 ok(SetCursorPos(pos.x, pos.y), "SetCursorPos failed\n");
5008
5009 DestroyWindow(hwnd);
5010
5011 hwnd = CreateWindowExA(0, "TestDialogClass", NULL, WS_CHILD|WS_VISIBLE,
5012 0, 0, 100, 100, hparent, 0, GetModuleHandleA(0), NULL);
5013 ok(hwnd != 0, "Failed to create custom dialog window\n");
5014 flush_events();
5015 flush_sequence();
5016 ret = DrawMenuBar(hwnd);
5017 ok(ret, "DrawMenuBar failed: %d\n", GetLastError());
5018 flush_events();
5019 ok_sequence(WmEmptySeq, "DrawMenuBar for a child window", FALSE);
5020
5021 DestroyWindow(hwnd);
5022
5023 flush_sequence();
5024 DialogBoxA( 0, "TEST_DIALOG", hparent, TestModalDlgProcA );
5025 ok_sequence(WmModalDialogSeq, "ModalDialog", TRUE);
5026
5027 DestroyWindow(hparent);
5028 flush_sequence();
5029
5030 /* Message sequence for SetMenu */
5031 ok(!DrawMenuBar(hwnd), "DrawMenuBar should return FALSE for a destroyed window\n");
5032 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "last error is %d\n", GetLastError());
5033 ok_sequence(WmEmptySeq, "DrawMenuBar for a window without a menu", FALSE);
5034
5035 hmenu = CreateMenu();
5036 ok (hmenu != 0, "Failed to create menu\n");
5037 ok (InsertMenuA(hmenu, -1, MF_BYPOSITION, 0x1000, "foo"), "InsertMenu failed\n");
5038 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
5039 100, 100, 200, 200, 0, hmenu, 0, NULL);
5040 ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
5041 ok (SetMenu(hwnd, 0), "SetMenu\n");
5042 ok_sequence(WmSetMenuNonVisibleSizeChangeSeq, "SetMenu:NonVisibleSizeChange", FALSE);
5043 ok (SetMenu(hwnd, 0), "SetMenu\n");
5044 ok_sequence(WmSetMenuNonVisibleNoSizeChangeSeq, "SetMenu:NonVisibleNoSizeChange", FALSE);
5045 ShowWindow(hwnd, SW_SHOW);
5046 UpdateWindow( hwnd );
5047 flush_events();
5048 flush_sequence();
5049 ok (SetMenu(hwnd, 0), "SetMenu\n");
5050 ok_sequence(WmSetMenuVisibleNoSizeChangeSeq, "SetMenu:VisibleNoSizeChange", FALSE);
5051 ok (SetMenu(hwnd, hmenu), "SetMenu\n");
5052 ok_sequence(WmSetMenuVisibleSizeChangeSeq, "SetMenu:VisibleSizeChange", FALSE);
5053
5054 UpdateWindow( hwnd );
5055 flush_events();
5056 flush_sequence();
5057 ok(DrawMenuBar(hwnd), "DrawMenuBar\n");
5058 flush_events();
5059 ok_sequence(WmDrawMenuBarSeq, "DrawMenuBar", FALSE);
5060
5061 DestroyWindow(hwnd);
5062 flush_sequence();
5063
5064 /* Message sequence for EnableWindow */
5065 hparent = CreateWindowExA(0, "TestWindowClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
5066 100, 100, 200, 200, 0, 0, 0, NULL);
5067 ok (hparent != 0, "Failed to create parent window\n");
5068 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
5069 0, 0, 10, 10, hparent, 0, 0, NULL);
5070 ok (hchild != 0, "Failed to create child window\n");
5071
5072 SetFocus(hchild);
5073 flush_events();
5074 flush_sequence();
5075
5076 EnableWindow(hparent, FALSE);
5077 ok_sequence(WmEnableWindowSeq_1, "EnableWindow(FALSE)", FALSE);
5078
5079 EnableWindow(hparent, TRUE);
5080 ok_sequence(WmEnableWindowSeq_2, "EnableWindow(TRUE)", FALSE);
5081
5082 flush_events();
5083 flush_sequence();
5084
5085 test_MsgWaitForMultipleObjects(hparent);
5086 test_WM_DEVICECHANGE(hparent);
5087
5088 /* the following test causes an exception in user.exe under win9x */
5089 if (!PostMessageW( hparent, WM_USER, 0, 0 ))
5090 {
5091 DestroyWindow(hparent);
5092 flush_sequence();
5093 return;
5094 }
5095 PostMessageW( hparent, WM_USER+1, 0, 0 );
5096 /* PeekMessage(NULL) fails, but still removes the message */
5097 SetLastError(0xdeadbeef);
5098 ok( !PeekMessageW( NULL, 0, 0, 0, PM_REMOVE ), "PeekMessage(NULL) should fail\n" );
5099 ok( GetLastError() == ERROR_NOACCESS || /* Win2k */
5100 GetLastError() == 0xdeadbeef, /* NT4 */
5101 "last error is %d\n", GetLastError() );
5102 ok( PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n" );
5103 ok( msg.message == WM_USER+1, "got %x instead of WM_USER+1\n", msg.message );
5104
5105 DestroyWindow(hchild);
5106 DestroyWindow(hparent);
5107 flush_sequence();
5108
5109 /* Message sequences for WM_SETICON */
5110 trace("testing WM_SETICON\n");
5111 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
5112 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
5113 NULL, NULL, 0);
5114 ShowWindow(hwnd, SW_SHOW);
5115 UpdateWindow(hwnd);
5116 flush_events();
5117 flush_sequence();
5118 SendMessageA(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIconA(0, (LPCSTR)IDI_APPLICATION));
5119 ok_sequence(WmSetIcon_1, "WM_SETICON for shown window with caption", FALSE);
5120
5121 ShowWindow(hwnd, SW_HIDE);
5122 flush_events();
5123 flush_sequence();
5124 SendMessageA(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIconA(0, (LPCSTR)IDI_APPLICATION));
5125 ok_sequence(WmSetIcon_2, "WM_SETICON for hidden window with caption", FALSE);
5126 DestroyWindow(hwnd);
5127 flush_sequence();
5128
5129 hwnd = CreateWindowExA(0, "TestPopupClass", NULL, WS_POPUP,
5130 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
5131 NULL, NULL, 0);
5132 ShowWindow(hwnd, SW_SHOW);
5133 UpdateWindow(hwnd);
5134 flush_events();
5135 flush_sequence();
5136 SendMessageA(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIconA(0, (LPCSTR)IDI_APPLICATION));
5137 ok_sequence(WmSetIcon_2, "WM_SETICON for shown window without caption", FALSE);
5138
5139 ShowWindow(hwnd, SW_HIDE);
5140 flush_events();
5141 flush_sequence();
5142 SendMessageA(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIconA(0, (LPCSTR)IDI_APPLICATION));
5143 ok_sequence(WmSetIcon_2, "WM_SETICON for hidden window without caption", FALSE);
5144
5145 flush_sequence();
5146 res = SendMessageA(hwnd, 0x3B, 0x8000000b, 0);
5147 if (!res)
5148 {
5149 todo_wine win_skip( "Message 0x3b not supported\n" );
5150 goto done;
5151 }
5152 ok_sequence(WmInitEndSession, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x8000000b", TRUE);
5153 ok(res == 1, "SendMessage(hwnd, 0x3B, 0x8000000b, 0) should have returned 1 instead of %ld\n", res);
5154 res = SendMessageA(hwnd, 0x3B, 0x0000000b, 0);
5155 ok_sequence(WmInitEndSession_2, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x0000000b", TRUE);
5156 ok(res == 1, "SendMessage(hwnd, 0x3B, 0x0000000b, 0) should have returned 1 instead of %ld\n", res);
5157 res = SendMessageA(hwnd, 0x3B, 0x0000000f, 0);
5158 ok_sequence(WmInitEndSession_2, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x0000000f", TRUE);
5159 ok(res == 1, "SendMessage(hwnd, 0x3B, 0x0000000f, 0) should have returned 1 instead of %ld\n", res);
5160
5161 flush_sequence();
5162 res = SendMessageA(hwnd, 0x3B, 0x80000008, 0);
5163 ok_sequence(WmInitEndSession_3, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x80000008", TRUE);
5164 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x80000008, 0) should have returned 2 instead of %ld\n", res);
5165 res = SendMessageA(hwnd, 0x3B, 0x00000008, 0);
5166 ok_sequence(WmInitEndSession_4, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x00000008", TRUE);
5167 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x00000008, 0) should have returned 2 instead of %ld\n", res);
5168
5169 res = SendMessageA(hwnd, 0x3B, 0x80000004, 0);
5170 ok_sequence(WmInitEndSession_3, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x80000004", TRUE);
5171 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x80000004, 0) should have returned 2 instead of %ld\n", res);
5172
5173 res = SendMessageA(hwnd, 0x3B, 0x80000001, 0);
5174 ok_sequence(WmInitEndSession_5, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x80000001", TRUE);
5175 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x80000001, 0) should have returned 2 instead of %ld\n", res);
5176
5177 done:
5178 DestroyWindow(hwnd);
5179 flush_sequence();
5180 }
5181
5182 static void test_setwindowpos(void)
5183 {
5184 HWND hwnd;
5185 RECT rc;
5186 LRESULT res;
5187 const INT winX = 100;
5188 const INT winY = 100;
5189 const INT sysX = GetSystemMetrics(SM_CXMINTRACK);
5190
5191 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, 0,
5192 0, 0, winX, winY, 0,
5193 NULL, NULL, 0);
5194
5195 GetWindowRect(hwnd, &rc);
5196 expect(sysX, rc.right);
5197 expect(winY, rc.bottom);
5198
5199 flush_events();
5200 flush_sequence();
5201 res = SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, winX, winY, 0);
5202 ok_sequence(WmZOrder, "Z-Order", TRUE);
5203 ok(res == TRUE, "SetWindowPos expected TRUE, got %ld\n", res);
5204
5205 GetWindowRect(hwnd, &rc);
5206 expect(sysX, rc.right);
5207 expect(winY, rc.bottom);
5208 DestroyWindow(hwnd);
5209 }
5210
5211 static void invisible_parent_tests(void)
5212 {
5213 HWND hparent, hchild;
5214
5215 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW,
5216 100, 100, 200, 200, 0, 0, 0, NULL);
5217 ok (hparent != 0, "Failed to create parent window\n");
5218 flush_sequence();
5219
5220 /* test showing child with hidden parent */
5221
5222 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5223 0, 0, 10, 10, hparent, 0, 0, NULL);
5224 ok (hchild != 0, "Failed to create child window\n");
5225 ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
5226
5227 ShowWindow( hchild, SW_MINIMIZE );
5228 ok_sequence(WmShowChildInvisibleParentSeq_1, "ShowWindow(SW_MINIMIZE) child with invisible parent", FALSE);
5229 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5230 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5231
5232 /* repeat */
5233 flush_events();
5234 flush_sequence();
5235 ShowWindow( hchild, SW_MINIMIZE );
5236 ok_sequence(WmShowChildInvisibleParentSeq_1r, "ShowWindow(SW_MINIMIZE) child with invisible parent", FALSE);
5237
5238 DestroyWindow(hchild);
5239 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5240 0, 0, 10, 10, hparent, 0, 0, NULL);
5241 flush_sequence();
5242
5243 ShowWindow( hchild, SW_MAXIMIZE );
5244 ok_sequence(WmShowChildInvisibleParentSeq_2, "ShowWindow(SW_MAXIMIZE) child with invisible parent", FALSE);
5245 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5246 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5247
5248 /* repeat */
5249 flush_events();
5250 flush_sequence();
5251 ShowWindow( hchild, SW_MAXIMIZE );
5252 ok_sequence(WmShowChildInvisibleParentSeq_2r, "ShowWindow(SW_MAXIMIZE) child with invisible parent", FALSE);
5253
5254 DestroyWindow(hchild);
5255 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5256 0, 0, 10, 10, hparent, 0, 0, NULL);
5257 flush_sequence();
5258
5259 ShowWindow( hchild, SW_RESTORE );
5260 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_RESTORE) child with invisible parent", FALSE);
5261 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5262 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5263
5264 DestroyWindow(hchild);
5265 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5266 0, 0, 10, 10, hparent, 0, 0, NULL);
5267 flush_sequence();
5268
5269 ShowWindow( hchild, SW_SHOWMINIMIZED );
5270 ok_sequence(WmShowChildInvisibleParentSeq_3, "ShowWindow(SW_SHOWMINIMIZED) child with invisible parent", FALSE);
5271 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5272 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5273
5274 /* repeat */
5275 flush_events();
5276 flush_sequence();
5277 ShowWindow( hchild, SW_SHOWMINIMIZED );
5278 ok_sequence(WmShowChildInvisibleParentSeq_3r, "ShowWindow(SW_SHOWMINIMIZED) child with invisible parent", FALSE);
5279
5280 DestroyWindow(hchild);
5281 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5282 0, 0, 10, 10, hparent, 0, 0, NULL);
5283 flush_sequence();
5284
5285 /* same as ShowWindow( hchild, SW_MAXIMIZE ); */
5286 ShowWindow( hchild, SW_SHOWMAXIMIZED );
5287 ok_sequence(WmShowChildInvisibleParentSeq_2, "ShowWindow(SW_SHOWMAXIMIZED) child with invisible parent", FALSE);
5288 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5289 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5290
5291 DestroyWindow(hchild);
5292 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5293 0, 0, 10, 10, hparent, 0, 0, NULL);
5294 flush_sequence();
5295
5296 ShowWindow( hchild, SW_SHOWMINNOACTIVE );
5297 ok_sequence(WmShowChildInvisibleParentSeq_4, "ShowWindow(SW_SHOWMINNOACTIVE) child with invisible parent", FALSE);
5298 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5299 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5300
5301 /* repeat */
5302 flush_events();
5303 flush_sequence();
5304 ShowWindow( hchild, SW_SHOWMINNOACTIVE );
5305 ok_sequence(WmShowChildInvisibleParentSeq_4r, "ShowWindow(SW_SHOWMINNOACTIVE) child with invisible parent", FALSE);
5306
5307 DestroyWindow(hchild);
5308 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5309 0, 0, 10, 10, hparent, 0, 0, NULL);
5310 flush_sequence();
5311
5312 /* FIXME: looks like XP SP2 doesn't know about SW_FORCEMINIMIZE at all */
5313 ShowWindow( hchild, SW_FORCEMINIMIZE );
5314 ok_sequence(WmEmptySeq, "ShowWindow(SW_FORCEMINIMIZE) child with invisible parent", TRUE);
5315 todo_wine {
5316 ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should be not set\n");
5317 }
5318 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5319
5320 DestroyWindow(hchild);
5321 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5322 0, 0, 10, 10, hparent, 0, 0, NULL);
5323 flush_sequence();
5324
5325 ShowWindow( hchild, SW_SHOWNA );
5326 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOWNA) child with invisible parent", FALSE);
5327 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5328 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5329
5330 /* repeat */
5331 flush_events();
5332 flush_sequence();
5333 ShowWindow( hchild, SW_SHOWNA );
5334 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOWNA) child with invisible parent", FALSE);
5335
5336 DestroyWindow(hchild);
5337 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5338 0, 0, 10, 10, hparent, 0, 0, NULL);
5339 flush_sequence();
5340
5341 ShowWindow( hchild, SW_SHOW );
5342 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOW) child with invisible parent", FALSE);
5343 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5344 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5345
5346 /* repeat */
5347 flush_events();
5348 flush_sequence();
5349 ShowWindow( hchild, SW_SHOW );
5350 ok_sequence(WmEmptySeq, "ShowWindow(SW_SHOW) child with invisible parent", FALSE);
5351
5352 ShowWindow( hchild, SW_HIDE );
5353 ok_sequence(WmHideChildInvisibleParentSeq, "ShowWindow:hide child with invisible parent", FALSE);
5354 ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should be not set\n");
5355 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5356
5357 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
5358 ok_sequence(WmShowChildInvisibleParentSeq_6, "SetWindowPos:show child with invisible parent", FALSE);
5359 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5360 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5361
5362 SetWindowPos(hchild, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
5363 ok_sequence(WmHideChildInvisibleParentSeq_2, "SetWindowPos:hide child with invisible parent", FALSE);
5364 ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should not be set\n");
5365 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5366
5367 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
5368 flush_sequence();
5369 DestroyWindow(hchild);
5370 ok_sequence(WmDestroyInvisibleChildSeq, "DestroyInvisibleChildSeq", FALSE);
5371
5372 DestroyWindow(hparent);
5373 flush_sequence();
5374 }
5375
5376 /****************** button message test *************************/
5377 #define ID_BUTTON 0x000e
5378
5379 static const struct message WmSetFocusButtonSeq[] =
5380 {
5381 { HCBT_SETFOCUS, hook },
5382 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
5383 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
5384 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5385 { WM_SETFOCUS, sent|wparam, 0 },
5386 { WM_CTLCOLORBTN, sent|parent },
5387 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_SETFOCUS) },
5388 { WM_APP, sent|wparam|lparam, 0, 0 },
5389 { 0 }
5390 };
5391 static const struct message WmKillFocusButtonSeq[] =
5392 {
5393 { HCBT_SETFOCUS, hook },
5394 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5395 { WM_KILLFOCUS, sent|wparam, 0 },
5396 { WM_CTLCOLORBTN, sent|parent },
5397 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_KILLFOCUS) },
5398 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
5399 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
5400 { WM_APP, sent|wparam|lparam, 0, 0 },
5401 { WM_PAINT, sent },
5402 { WM_CTLCOLORBTN, sent|parent },
5403 { 0 }
5404 };
5405 static const struct message WmSetFocusStaticSeq[] =
5406 {
5407 { HCBT_SETFOCUS, hook },
5408 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
5409 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
5410 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5411 { WM_SETFOCUS, sent|wparam, 0 },
5412 { WM_CTLCOLORSTATIC, sent|parent },
5413 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_SETFOCUS) },
5414 { WM_COMMAND, sent|wparam|parent|optional, MAKEWPARAM(ID_BUTTON, BN_CLICKED) }, /* radio button */
5415 { WM_APP, sent|wparam|lparam, 0, 0 },
5416 { 0 }
5417 };
5418 static const struct message WmKillFocusStaticSeq[] =
5419 {
5420 { HCBT_SETFOCUS, hook },
5421 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5422 { WM_KILLFOCUS, sent|wparam, 0 },
5423 { WM_CTLCOLORSTATIC, sent|parent },
5424 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_KILLFOCUS) },
5425 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
5426 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
5427 { WM_APP, sent|wparam|lparam, 0, 0 },
5428 { WM_PAINT, sent },
5429 { WM_CTLCOLORSTATIC, sent|parent },
5430 { 0 }
5431 };
5432 static const struct message WmSetFocusOwnerdrawSeq[] =
5433 {
5434 { HCBT_SETFOCUS, hook },
5435 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
5436 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
5437 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5438 { WM_SETFOCUS, sent|wparam, 0 },
5439 { WM_CTLCOLORBTN, sent|parent },
5440 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_BUTTON, 0x001040e4 },
5441 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_SETFOCUS) },
5442 { WM_APP, sent|wparam|lparam, 0, 0 },
5443 { 0 }
5444 };
5445 static const struct message WmKillFocusOwnerdrawSeq[] =
5446 {
5447 { HCBT_SETFOCUS, hook },
5448 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5449 { WM_KILLFOCUS, sent|wparam, 0 },
5450 { WM_CTLCOLORBTN, sent|parent },
5451 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_BUTTON, 0x000040e4 },
5452 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_KILLFOCUS) },
5453 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
5454 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
5455 { WM_APP, sent|wparam|lparam, 0, 0 },
5456 { WM_PAINT, sent },
5457 { WM_CTLCOLORBTN, sent|parent },
5458 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_BUTTON, 0x000010e4 },
5459 { 0 }
5460 };
5461 static const struct message WmLButtonDownSeq[] =
5462 {
5463 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
5464 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
5465 { HCBT_SETFOCUS, hook },
5466 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
5467 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
5468 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5469 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
5470 { WM_CTLCOLORBTN, sent|defwinproc },
5471 { BM_SETSTATE, sent|wparam|defwinproc, TRUE },
5472 { WM_CTLCOLORBTN, sent|defwinproc },
5473 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5474 { 0 }
5475 };
5476 static const struct message WmLButtonDownStaticSeq[] =
5477 {
5478 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
5479 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
5480 { HCBT_SETFOCUS, hook },
5481 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
5482 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
5483 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5484 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
5485 { WM_CTLCOLORSTATIC, sent|defwinproc },
5486 { BM_SETSTATE, sent|wparam|defwinproc, TRUE },
5487 { WM_CTLCOLORSTATIC, sent|defwinproc },
5488 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5489 { 0 }
5490 };
5491 static const struct message WmLButtonUpSeq[] =
5492 {
5493 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
5494 { BM_SETSTATE, sent|wparam|defwinproc, FALSE },
5495 { WM_CTLCOLORBTN, sent|defwinproc },
5496 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5497 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
5498 { WM_CAPTURECHANGED, sent|wparam|defwinproc, 0 },
5499 { 0 }
5500 };
5501 static const struct message WmLButtonUpStaticSeq[] =
5502 {
5503 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
5504 { BM_SETSTATE, sent|wparam|defwinproc, FALSE },
5505 { WM_CTLCOLORSTATIC, sent|defwinproc },
5506 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5507 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
5508 { WM_CAPTURECHANGED, sent|wparam|defwinproc, 0 },
5509 { 0 }
5510 };
5511 static const struct message WmLButtonUpAutoSeq[] =
5512 {
5513 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
5514 { BM_SETSTATE, sent|wparam|defwinproc, FALSE },
5515 { WM_CTLCOLORSTATIC, sent|defwinproc },
5516 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5517 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
5518 { BM_SETCHECK, sent|defwinproc },
5519 { WM_CTLCOLORSTATIC, sent|defwinproc, 0, 0 },
5520 { WM_CAPTURECHANGED, sent|wparam|defwinproc, 0 },
5521 { 0 }
5522 };
5523 static const struct message WmLButtonUpBrokenSeq[] =
5524 {
5525 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
5526 { 0 }
5527 };
5528 static const struct message WmSetFontButtonSeq[] =
5529 {
5530 { WM_SETFONT, sent },
5531 { WM_PAINT, sent },
5532 { WM_ERASEBKGND, sent|defwinproc|optional },
5533 { WM_CTLCOLORBTN, sent|defwinproc },
5534 { WM_CTLCOLORBTN, sent|defwinproc|optional }, /* FIXME: Wine sends it twice for BS_OWNERDRAW */
5535 { 0 }
5536 };
5537 static const struct message WmSetFontStaticSeq[] =
5538 {
5539 { WM_SETFONT, sent },
5540 { WM_PAINT, sent },
5541 { WM_ERASEBKGND, sent|defwinproc|optional },
5542 { WM_CTLCOLORSTATIC, sent|defwinproc },
5543 { 0 }
5544 };
5545 static const struct message WmSetTextButtonSeq[] =
5546 {
5547 { WM_SETTEXT, sent },
5548 { WM_CTLCOLORBTN, sent|parent },
5549 { WM_CTLCOLORBTN, sent|parent },
5550 { WM_COMMAND, sent|parent|optional },
5551 { WM_DRAWITEM, sent|parent|optional },
5552 { 0 }
5553 };
5554 static const struct message WmSetTextStaticSeq[] =
5555 {
5556 { WM_SETTEXT, sent },
5557 { WM_CTLCOLORSTATIC, sent|parent },
5558 { WM_CTLCOLORSTATIC, sent|parent },
5559 { 0 }
5560 };
5561 static const struct message WmSetTextGroupSeq[] =
5562 {
5563 { WM_SETTEXT, sent },
5564 { WM_CTLCOLORSTATIC, sent|parent },
5565 { WM_CTLCOLORSTATIC, sent|parent|optional }, /* FIXME: Missing in Wine */
5566 { WM_CTLCOLORSTATIC, sent|parent|optional }, /* FIXME: Missing in Wine */
5567 { 0 }
5568 };
5569 static const struct message WmSetTextInvisibleSeq[] =
5570 {
5571 { WM_SETTEXT, sent },
5572 { 0 }
5573 };
5574 static const struct message WmSetStyleButtonSeq[] =
5575 {
5576 { BM_SETSTYLE, sent },
5577 { WM_APP, sent|wparam|lparam, 0, 0 },
5578 { WM_PAINT, sent },
5579 { WM_NCPAINT, sent|defwinproc|optional }, /* FIXME: Wine sends it */
5580 { WM_ERASEBKGND, sent|defwinproc|optional }, /* Win9x doesn't send it */
5581 { WM_CTLCOLORBTN, sent|parent },
5582 { 0 }
5583 };
5584 static const struct message WmSetStyleStaticSeq[] =
5585 {
5586 { BM_SETSTYLE, sent },
5587 { WM_APP, sent|wparam|lparam, 0, 0 },
5588 { WM_PAINT, sent },
5589 { WM_NCPAINT, sent|defwinproc|optional }, /* FIXME: Wine sends it */
5590 { WM_ERASEBKGND, sent|defwinproc|optional }, /* Win9x doesn't send it */
5591 { WM_CTLCOLORSTATIC, sent|parent },
5592 { 0 }
5593 };
5594 static const struct message WmSetStyleUserSeq[] =
5595 {
5596 { BM_SETSTYLE, sent },
5597 { WM_APP, sent|wparam|lparam, 0, 0 },
5598 { WM_PAINT, sent },
5599 { WM_NCPAINT, sent|defwinproc|optional }, /* FIXME: Wine sends it */
5600 { WM_ERASEBKGND, sent|defwinproc|optional }, /* Win9x doesn't send it */
5601 { WM_CTLCOLORBTN, sent|parent },
5602 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_PAINT) },
5603 { 0 }
5604 };
5605 static const struct message WmSetStyleOwnerdrawSeq[] =
5606 {
5607 { BM_SETSTYLE, sent },
5608 { WM_APP, sent|wparam|lparam, 0, 0 },
5609 { WM_PAINT, sent },
5610 { WM_NCPAINT, sent|optional }, /* FIXME: Wine sends it */
5611 { WM_ERASEBKGND, sent|defwinproc|optional }, /* Win9x doesn't send it */
5612 { WM_CTLCOLORBTN, sent|parent },
5613 { WM_CTLCOLORBTN, sent|parent|optional }, /* Win9x doesn't send it */
5614 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_BUTTON, 0x000010e4 },
5615 { 0 }
5616 };
5617 static const struct message WmSetStateButtonSeq[] =
5618 {
5619 { BM_SETSTATE, sent },
5620 { WM_CTLCOLORBTN, sent|parent },
5621 { WM_APP, sent|wparam|lparam, 0, 0 },
5622 { 0 }
5623 };
5624 static const struct message WmSetStateStaticSeq[] =
5625 {
5626 { BM_SETSTATE, sent },
5627 { WM_CTLCOLORSTATIC, sent|parent },
5628 { WM_APP, sent|wparam|lparam, 0, 0 },
5629 { 0 }
5630 };
5631 static const struct message WmSetStateUserSeq[] =
5632 {
5633 { BM_SETSTATE, sent },
5634 { WM_CTLCOLORBTN, sent|parent },
5635 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_HILITE) },
5636 { WM_APP, sent|wparam|lparam, 0, 0 },
5637 { 0 }
5638 };
5639 static const struct message WmSetStateOwnerdrawSeq[] =
5640 {
5641 { BM_SETSTATE, sent },
5642 { WM_CTLCOLORBTN, sent|parent },
5643 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_BUTTON, 0x000120e4 },
5644 { WM_APP, sent|wparam|lparam, 0, 0 },
5645 { 0 }
5646 };
5647 static const struct message WmClearStateButtonSeq[] =
5648 {
5649 { BM_SETSTATE, sent },
5650 { WM_CTLCOLORBTN, sent|parent },
5651 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_UNHILITE) },
5652 { WM_APP, sent|wparam|lparam, 0, 0 },
5653 { 0 }
5654 };
5655 static const struct message WmClearStateOwnerdrawSeq[] =
5656 {
5657 { BM_SETSTATE, sent },
5658 { WM_CTLCOLORBTN, sent|parent },
5659 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_BUTTON, 0x000020e4 },
5660 { WM_APP, sent|wparam|lparam, 0, 0 },
5661 { 0 }
5662 };
5663 static const struct message WmSetCheckIgnoredSeq[] =
5664 {
5665 { BM_SETCHECK, sent },
5666 { WM_APP, sent|wparam|lparam, 0, 0 },
5667 { 0 }
5668 };
5669 static const struct message WmSetCheckStaticSeq[] =
5670 {
5671 { BM_SETCHECK, sent },
5672 { WM_CTLCOLORSTATIC, sent|parent },
5673 { WM_APP, sent|wparam|lparam, 0, 0 },
5674 { 0 }
5675 };
5676
5677 static WNDPROC old_button_proc;
5678
5679 static LRESULT CALLBACK button_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
5680 {
5681 static LONG defwndproc_counter = 0;
5682 LRESULT ret;
5683 struct recvd_message msg;
5684
5685 if (ignore_message( message )) return 0;
5686
5687 switch (message)
5688 {
5689 case WM_SYNCPAINT:
5690 break;
5691 case BM_SETSTATE:
5692 if (GetCapture())
5693 ok(GetCapture() == hwnd, "GetCapture() = %p\n", GetCapture());
5694 /* fall through */
5695 default:
5696 msg.hwnd = hwnd;
5697 msg.message = message;
5698 msg.flags = sent|wparam|lparam;
5699 if (defwndproc_counter) msg.flags |= defwinproc;
5700 msg.wParam = wParam;
5701 msg.lParam = lParam;
5702 msg.descr = "button";
5703 add_message(&msg);
5704 }
5705
5706 defwndproc_counter++;
5707 ret = CallWindowProcA(old_button_proc, hwnd, message, wParam, lParam);
5708 defwndproc_counter--;
5709
5710 return ret;
5711 }
5712
5713 static void subclass_button(void)
5714 {
5715 WNDCLASSA cls;
5716
5717 if (!GetClassInfoA(0, "button", &cls)) assert(0);
5718
5719 old_button_proc = cls.lpfnWndProc;
5720
5721 cls.hInstance = GetModuleHandleA(NULL);
5722 cls.lpfnWndProc = button_hook_proc;
5723 cls.lpszClassName = "my_button_class";
5724 UnregisterClassA(cls.lpszClassName, cls.hInstance);
5725 if (!RegisterClassA(&cls)) assert(0);
5726 }
5727
5728 static void test_button_messages(void)
5729 {
5730 static const struct
5731 {
5732 DWORD style;
5733 DWORD dlg_code;
5734 const struct message *setfocus;
5735 const struct message *killfocus;
5736 const struct message *setstyle;
5737 const struct message *setstate;
5738 const struct message *clearstate;
5739 const struct message *setcheck;
5740 const struct message *lbuttondown;
5741 const struct message *lbuttonup;
5742 const struct message *setfont;
5743 const struct message *settext;
5744 } button[] = {
5745 { BS_PUSHBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
5746 WmSetFocusButtonSeq, WmKillFocusButtonSeq, WmSetStyleButtonSeq,
5747 WmSetStateButtonSeq, WmSetStateButtonSeq, WmSetCheckIgnoredSeq,
5748 WmLButtonDownSeq, WmLButtonUpSeq, WmSetFontButtonSeq,
5749 WmSetTextButtonSeq },
5750 { BS_DEFPUSHBUTTON, DLGC_BUTTON | DLGC_DEFPUSHBUTTON,
5751 WmSetFocusButtonSeq, WmKillFocusButtonSeq, WmSetStyleButtonSeq,
5752 WmSetStateButtonSeq, WmSetStateButtonSeq, WmSetCheckIgnoredSeq,
5753 WmLButtonDownSeq, WmLButtonUpSeq, WmSetFontButtonSeq,
5754 WmSetTextButtonSeq },
5755 { BS_CHECKBOX, DLGC_BUTTON,
5756 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
5757 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
5758 WmLButtonDownStaticSeq, WmLButtonUpStaticSeq, WmSetFontStaticSeq,
5759 WmSetTextStaticSeq },
5760 { BS_AUTOCHECKBOX, DLGC_BUTTON,
5761 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
5762 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
5763 WmLButtonDownStaticSeq, WmLButtonUpAutoSeq, WmSetFontStaticSeq,
5764 WmSetTextStaticSeq },
5765 { BS_RADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
5766 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
5767 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
5768 WmLButtonDownStaticSeq, WmLButtonUpStaticSeq, WmSetFontStaticSeq,
5769 WmSetTextStaticSeq },
5770 { BS_3STATE, DLGC_BUTTON,
5771 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
5772 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
5773 WmLButtonDownStaticSeq, WmLButtonUpStaticSeq, WmSetFontStaticSeq,
5774 WmSetTextStaticSeq },
5775 { BS_AUTO3STATE, DLGC_BUTTON,
5776 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
5777 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
5778 WmLButtonDownStaticSeq, WmLButtonUpAutoSeq, WmSetFontStaticSeq,
5779 WmSetTextStaticSeq },
5780 { BS_GROUPBOX, DLGC_STATIC,
5781 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
5782 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckIgnoredSeq,
5783 WmLButtonDownStaticSeq, WmLButtonUpStaticSeq, WmSetFontStaticSeq,
5784 WmSetTextGroupSeq },
5785 { BS_USERBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
5786 WmSetFocusButtonSeq, WmKillFocusButtonSeq, WmSetStyleUserSeq,
5787 WmSetStateUserSeq, WmClearStateButtonSeq, WmSetCheckIgnoredSeq,
5788 WmLButtonDownSeq, WmLButtonUpSeq, WmSetFontButtonSeq,
5789 WmSetTextButtonSeq },
5790 { BS_AUTORADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
5791 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
5792 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
5793 NULL /* avoid infinite loop */, WmLButtonUpBrokenSeq, WmSetFontStaticSeq,
5794 WmSetTextStaticSeq },
5795 { BS_OWNERDRAW, DLGC_BUTTON,
5796 WmSetFocusOwnerdrawSeq, WmKillFocusOwnerdrawSeq, WmSetStyleOwnerdrawSeq,
5797 WmSetStateOwnerdrawSeq, WmClearStateOwnerdrawSeq, WmSetCheckIgnoredSeq,
5798 WmLButtonDownSeq, WmLButtonUpSeq, WmSetFontButtonSeq,
5799 WmSetTextButtonSeq },
5800 };
5801 unsigned int i;
5802 HWND hwnd, parent;
5803 DWORD dlg_code;
5804 HFONT zfont;
5805
5806 /* selection with VK_SPACE should capture button window */
5807 hwnd = CreateWindowExA(0, "button", "test", BS_CHECKBOX | WS_VISIBLE | WS_POPUP,
5808 0, 0, 50, 14, 0, 0, 0, NULL);
5809 ok(hwnd != 0, "Failed to create button window\n");
5810 ReleaseCapture();
5811 SetFocus(hwnd);
5812 SendMessageA(hwnd, WM_KEYDOWN, VK_SPACE, 0);
5813 ok(GetCapture() == hwnd, "Should be captured on VK_SPACE WM_KEYDOWN\n");
5814 SendMessageA(hwnd, WM_KEYUP, VK_SPACE, 0);
5815 DestroyWindow(hwnd);
5816
5817 subclass_button();
5818
5819 parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
5820 100, 100, 200, 200, 0, 0, 0, NULL);
5821 ok(parent != 0, "Failed to create parent window\n");
5822
5823 for (i = 0; i < sizeof(button)/sizeof(button[0]); i++)
5824 {
5825 MSG msg;
5826 DWORD style, state;
5827 char desc[64];
5828
5829 trace("button style %08x\n", button[i].style);
5830
5831 hwnd = CreateWindowExA(0, "my_button_class", "test", button[i].style | WS_CHILD | BS_NOTIFY,
5832 0, 0, 50, 14, parent, (HMENU)ID_BUTTON, 0, NULL);
5833 ok(hwnd != 0, "Failed to create button window\n");
5834
5835 style = GetWindowLongA(hwnd, GWL_STYLE);
5836 style &= ~(WS_CHILD | BS_NOTIFY);
5837 /* XP turns a BS_USERBUTTON into BS_PUSHBUTTON */
5838 if (button[i].style == BS_USERBUTTON)
5839 ok(style == BS_PUSHBUTTON, "expected style BS_PUSHBUTTON got %x\n", style);
5840 else
5841 ok(style == button[i].style, "expected style %x got %x\n", button[i].style, style);
5842
5843 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
5844 ok(dlg_code == button[i].dlg_code, "%u: wrong dlg_code %08x\n", i, dlg_code);
5845
5846 ShowWindow(hwnd, SW_SHOW);
5847 UpdateWindow(hwnd);
5848 SetFocus(0);
5849 flush_events();
5850 SetFocus(0);
5851 flush_sequence();
5852
5853 log_all_parent_messages++;
5854
5855 ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
5856 SetFocus(hwnd);
5857 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
5858 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
5859 ok_sequence(button[i].setfocus, "SetFocus(hwnd) on a button", FALSE);
5860
5861 SetFocus(0);
5862 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
5863 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
5864 ok_sequence(button[i].killfocus, "SetFocus(0) on a button", FALSE);
5865
5866 ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
5867
5868 SendMessageA(hwnd, BM_SETSTYLE, button[i].style | BS_BOTTOM, TRUE);
5869 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
5870 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
5871 ok_sequence(button[i].setstyle, "BM_SETSTYLE on a button", FALSE);
5872
5873 style = GetWindowLongA(hwnd, GWL_STYLE);
5874 style &= ~(WS_VISIBLE | WS_CHILD | BS_NOTIFY);
5875 /* XP doesn't turn a BS_USERBUTTON into BS_PUSHBUTTON here! */
5876 ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style);
5877
5878 state = SendMessageA(hwnd, BM_GETSTATE, 0, 0);
5879 ok(state == 0, "expected state 0, got %04x\n", state);
5880
5881 flush_sequence();
5882
5883 SendMessageA(hwnd, BM_SETSTATE, TRUE, 0);
5884 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
5885 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
5886 ok_sequence(button[i].setstate, "BM_SETSTATE/TRUE on a button", FALSE);
5887
5888 state = SendMessageA(hwnd, BM_GETSTATE, 0, 0);
5889 ok(state == 0x0004, "expected state 0x0004, got %04x\n", state);
5890
5891 style = GetWindowLongA(hwnd, GWL_STYLE);
5892 style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
5893 ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style);
5894
5895 flush_sequence();
5896
5897 SendMessageA(hwnd, BM_SETSTATE, FALSE, 0);
5898 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
5899 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
5900 ok_sequence(button[i].clearstate, "BM_SETSTATE/FALSE on a button", FALSE);
5901
5902 state = SendMessageA(hwnd, BM_GETSTATE, 0, 0);
5903 ok(state == 0, "expected state 0, got %04x\n", state);
5904
5905 style = GetWindowLongA(hwnd, GWL_STYLE);
5906 style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
5907 ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style);
5908
5909 state = SendMessageA(hwnd, BM_GETCHECK, 0, 0);
5910 ok(state == BST_UNCHECKED, "expected BST_UNCHECKED, got %04x\n", state);
5911
5912 flush_sequence();
5913
5914 SendMessageA(hwnd, BM_SETCHECK, BST_UNCHECKED, 0);
5915 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
5916 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
5917 ok_sequence(WmSetCheckIgnoredSeq, "BM_SETCHECK on a button", FALSE);
5918
5919 state = SendMessageA(hwnd, BM_GETCHECK, 0, 0);
5920 ok(state == BST_UNCHECKED, "expected BST_UNCHECKED, got %04x\n", state);
5921
5922 style = GetWindowLongA(hwnd, GWL_STYLE);
5923 style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
5924 ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style);
5925
5926 flush_sequence();
5927
5928 SendMessageA(hwnd, BM_SETCHECK, BST_CHECKED, 0);
5929 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
5930 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
5931 ok_sequence(button[i].setcheck, "BM_SETCHECK on a button", FALSE);
5932
5933 SendMessageA(hwnd, WM_SETTEXT, 0, (LPARAM)"Text 1");
5934 sprintf(desc, "button[%i]: WM_SETTEXT on a visible button", i);
5935 ok_sequence(button[i].settext, desc, FALSE);
5936
5937 ShowWindow(hwnd, SW_HIDE);
5938 flush_events();
5939 flush_sequence();
5940
5941 SendMessageA(hwnd, WM_SETTEXT, 0, (LPARAM)"Text 2");
5942 sprintf(desc, "button[%i]: WM_SETTEXT on an invisible button", i);
5943 ok_sequence(WmSetTextInvisibleSeq, desc, FALSE);
5944
5945 ShowWindow(hwnd, SW_SHOW);
5946 ShowWindow(parent, SW_HIDE);
5947 flush_events();
5948 flush_sequence();
5949
5950 SendMessageA(hwnd, WM_SETTEXT, 0, (LPARAM)"Text 3");
5951 sprintf(desc, "button[%i]: WM_SETTEXT on an invisible button", i);
5952 ok_sequence(WmSetTextInvisibleSeq, desc, FALSE);
5953
5954 ShowWindow(parent, SW_SHOW);
5955 flush_events();
5956
5957 state = SendMessageA(hwnd, BM_GETCHECK, 0, 0);
5958 if (button[i].style == BS_PUSHBUTTON ||
5959 button[i].style == BS_DEFPUSHBUTTON ||
5960 button[i].style == BS_GROUPBOX ||
5961 button[i].style == BS_USERBUTTON ||
5962 button[i].style == BS_OWNERDRAW)
5963 ok(state == BST_UNCHECKED, "expected check 0, got %04x\n", state);
5964 else
5965 ok(state == BST_CHECKED, "expected check 1, got %04x\n", state);
5966
5967 style = GetWindowLongA(hwnd, GWL_STYLE);
5968 style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
5969 if (button[i].style == BS_RADIOBUTTON ||
5970 button[i].style == BS_AUTORADIOBUTTON)
5971 ok(style == (button[i].style | WS_TABSTOP), "expected style %04x | WS_TABSTOP got %04x\n", button[i].style, style);
5972 else
5973 ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style);
5974
5975 log_all_parent_messages--;
5976
5977 DestroyWindow(hwnd);
5978
5979 hwnd = CreateWindowExA(0, "my_button_class", "test", button[i].style | WS_POPUP | WS_VISIBLE,
5980 0, 0, 50, 14, 0, 0, 0, NULL);
5981 ok(hwnd != 0, "Failed to create button window\n");
5982
5983 SetForegroundWindow(hwnd);
5984 flush_events();
5985
5986 SetActiveWindow(hwnd);
5987 SetFocus(0);
5988 flush_sequence();
5989
5990 if (button[i].lbuttondown)
5991 {
5992 SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
5993 sprintf(desc, "button[%i]: WM_LBUTTONDOWN on a button", i);
5994 ok_sequence(button[i].lbuttondown, desc, FALSE);
5995 }
5996
5997 SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
5998 sprintf(desc, "button[%i]: WM_LBUTTONUP on a button", i);
5999 ok_sequence(button[i].lbuttonup, desc, FALSE);
6000
6001 flush_sequence();
6002 zfont = GetStockObject(SYSTEM_FONT);
6003 SendMessageA(hwnd, WM_SETFONT, (WPARAM)zfont, TRUE);
6004 UpdateWindow(hwnd);
6005 sprintf(desc, "button[%i]: WM_SETFONT on a button", i);
6006 ok_sequence(button[i].setfont, desc, FALSE);
6007
6008 DestroyWindow(hwnd);
6009 }
6010
6011 DestroyWindow(parent);
6012 }
6013
6014 /****************** static message test *************************/
6015 static const struct message WmSetFontStaticSeq2[] =
6016 {
6017 { WM_SETFONT, sent },
6018 { WM_PAINT, sent|defwinproc|optional },
6019 { WM_ERASEBKGND, sent|defwinproc|optional },
6020 { WM_CTLCOLORSTATIC, sent|defwinproc|optional },
6021 { 0 }
6022 };
6023
6024 static WNDPROC old_static_proc;
6025
6026 static LRESULT CALLBACK static_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6027 {
6028 static LONG defwndproc_counter = 0;
6029 LRESULT ret;
6030 struct recvd_message msg;
6031
6032 if (ignore_message( message )) return 0;
6033
6034 msg.hwnd = hwnd;
6035 msg.message = message;
6036 msg.flags = sent|wparam|lparam;
6037 if (defwndproc_counter) msg.flags |= defwinproc;
6038 msg.wParam = wParam;
6039 msg.lParam = lParam;
6040 msg.descr = "static";
6041 add_message(&msg);
6042
6043 defwndproc_counter++;
6044 ret = CallWindowProcA(old_static_proc, hwnd, message, wParam, lParam);
6045 defwndproc_counter--;
6046
6047 return ret;
6048 }
6049
6050 static void subclass_static(void)
6051 {
6052 WNDCLASSA cls;
6053
6054 if (!GetClassInfoA(0, "static", &cls)) assert(0);
6055
6056 old_static_proc = cls.lpfnWndProc;
6057
6058 cls.hInstance = GetModuleHandleA(NULL);
6059 cls.lpfnWndProc = static_hook_proc;
6060 cls.lpszClassName = "my_static_class";
6061 UnregisterClassA(cls.lpszClassName, cls.hInstance);
6062 if (!RegisterClassA(&cls)) assert(0);
6063 }
6064
6065 static void test_static_messages(void)
6066 {
6067 /* FIXME: make as comprehensive as the button message test */
6068 static const struct
6069 {
6070 DWORD style;
6071 DWORD dlg_code;
6072 const struct message *setfont;
6073 } static_ctrl[] = {
6074 { SS_LEFT, DLGC_STATIC,
6075 WmSetFontStaticSeq2 }
6076 };
6077 unsigned int i;
6078 HWND hwnd;
6079 DWORD dlg_code;
6080
6081 subclass_static();
6082
6083 for (i = 0; i < sizeof(static_ctrl)/sizeof(static_ctrl[0]); i++)
6084 {
6085 hwnd = CreateWindowExA(0, "my_static_class", "test", static_ctrl[i].style | WS_POPUP,
6086 0, 0, 50, 14, 0, 0, 0, NULL);
6087 ok(hwnd != 0, "Failed to create static window\n");
6088
6089 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
6090 ok(dlg_code == static_ctrl[i].dlg_code, "%u: wrong dlg_code %08x\n", i, dlg_code);
6091
6092 ShowWindow(hwnd, SW_SHOW);
6093 UpdateWindow(hwnd);
6094 SetFocus(0);
6095 flush_sequence();
6096
6097 trace("static style %08x\n", static_ctrl[i].style);
6098 SendMessageA(hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
6099 ok_sequence(static_ctrl[i].setfont, "WM_SETFONT on a static", FALSE);
6100
6101 DestroyWindow(hwnd);
6102 }
6103 }
6104
6105 /****************** ComboBox message test *************************/
6106 #define ID_COMBOBOX 0x000f
6107
6108 static const struct message WmKeyDownComboSeq[] =
6109 {
6110 { WM_KEYDOWN, sent|wparam|lparam, VK_DOWN, 0 },
6111 { WM_COMMAND, sent|wparam|defwinproc, MAKEWPARAM(1000, LBN_SELCHANGE) },
6112 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_COMBOBOX, CBN_SELENDOK) },
6113 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_COMBOBOX, CBN_SELCHANGE) },
6114 { WM_CTLCOLOREDIT, sent|parent },
6115 { WM_KEYUP, sent|wparam|lparam, VK_DOWN, 0 },
6116 { 0 }
6117 };
6118
6119 static const struct message WmSetPosComboSeq[] =
6120 {
6121 { WM_WINDOWPOSCHANGING, sent },
6122 { WM_NCCALCSIZE, sent|wparam, TRUE },
6123 { WM_CHILDACTIVATE, sent },
6124 { WM_WINDOWPOSCHANGED, sent },
6125 { WM_MOVE, sent|defwinproc },
6126 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
6127 { WM_WINDOWPOSCHANGING, sent|defwinproc },
6128 { WM_NCCALCSIZE, sent|defwinproc|wparam, TRUE },
6129 { WM_WINDOWPOSCHANGED, sent|defwinproc },
6130 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
6131 { 0 }
6132 };
6133
6134 static const struct message WMSetFocusComboBoxSeq[] =
6135 {
6136 { WM_SETFOCUS, sent },
6137 { WM_KILLFOCUS, sent|parent },
6138 { WM_SETFOCUS, sent },
6139 { WM_COMMAND, sent|defwinproc|wparam, MAKEWPARAM(1001, EN_SETFOCUS) },
6140 { EM_SETSEL, sent|defwinproc|wparam|lparam, 0, INT_MAX },
6141 { WM_CTLCOLOREDIT, sent|defwinproc|optional },/* Not sent on W2000, XP or Server 2003 */
6142 { WM_CTLCOLOREDIT, sent|parent|optional },/* Not sent on W2000, XP or Server 2003 */
6143 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_COMBOBOX, CBN_SETFOCUS) },
6144 { 0 }
6145 };
6146
6147 static const struct message SetFocusButtonSeq[] =
6148 {
6149 { WM_KILLFOCUS, sent },
6150 { CB_GETCOMBOBOXINFO, sent|optional },/* Windows 2000 */
6151 { 0x0167, sent|optional },/* Undocumented message. Sent on all versions except Windows 2000 */
6152 { WM_LBUTTONUP, sent|defwinproc },
6153 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_COMBOBOX, CBN_SELENDCANCEL) },
6154 { EM_SETSEL, sent|defwinproc|wparam|lparam, 0, 0 },
6155 { WM_CTLCOLOREDIT, sent|defwinproc|optional },/* Not sent on W2000, XP or Server 2003 */
6156 { WM_CTLCOLOREDIT, sent|parent|optional },/* Not sent on W2000, XP or Server 2003 */
6157 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_COMBOBOX, CBN_KILLFOCUS) },
6158 { WM_CTLCOLORBTN, sent|parent },
6159 { 0 }
6160 };
6161
6162 static const struct message SetFocusComboBoxSeq[] =
6163 {
6164 { WM_CTLCOLORBTN, sent|parent },
6165 { WM_SETFOCUS, sent },
6166 { WM_KILLFOCUS, sent|defwinproc },
6167 { WM_SETFOCUS, sent },
6168 { WM_COMMAND, sent|defwinproc|wparam, MAKEWPARAM(1001, EN_SETFOCUS) },
6169 { EM_SETSEL, sent|defwinproc|wparam|lparam, 0, INT_MAX },
6170 { WM_CTLCOLOREDIT, sent|defwinproc|optional },/* Not sent on W2000, XP or Server 2003 */
6171 { WM_CTLCOLOREDIT, sent|parent|optional },/* Not sent on W2000, XP or Server 2003 */
6172 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_COMBOBOX, CBN_SETFOCUS) },
6173 { 0 }
6174 };
6175
6176 static const struct message SetFocusButtonSeq2[] =
6177 {
6178 { WM_KILLFOCUS, sent },
6179 { CB_GETCOMBOBOXINFO, sent|optional },/* Windows 2000 */
6180 { 0x0167, sent|optional },/* Undocumented message. Sent on all versions except Windows 2000 */
6181 { WM_LBUTTONUP, sent|defwinproc },
6182 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_COMBOBOX, CBN_SELENDCANCEL) },
6183 { EM_SETSEL, sent|defwinproc|wparam|lparam, 0, 0 },
6184 { WM_CTLCOLOREDIT, sent|defwinproc },
6185 { WM_CTLCOLOREDIT, sent|parent },
6186 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_COMBOBOX, CBN_KILLFOCUS) },
6187 { WM_CTLCOLORBTN, sent|parent },
6188 { 0 }
6189 };
6190
6191 static WNDPROC old_combobox_proc, edit_window_proc;
6192
6193 static LRESULT CALLBACK combobox_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6194 {
6195 static LONG defwndproc_counter = 0;
6196 LRESULT ret;
6197 struct recvd_message msg;
6198
6199 /* do not log painting messages */
6200 if (message != WM_PAINT &&
6201 message != WM_NCPAINT &&
6202 message != WM_SYNCPAINT &&
6203 message != WM_ERASEBKGND &&
6204 message != WM_NCHITTEST &&
6205 message != WM_GETTEXT &&
6206 !ignore_message( message ))
6207 {
6208 msg.hwnd = hwnd;
6209 msg.message = message;
6210 msg.flags = sent|wparam|lparam;
6211 if (defwndproc_counter) msg.flags |= defwinproc;
6212 msg.wParam = wParam;
6213 msg.lParam = lParam;
6214 msg.descr = "combo";
6215 add_message(&msg);
6216 }
6217
6218 defwndproc_counter++;
6219 ret = CallWindowProcA(edit_window_proc, hwnd, message, wParam, lParam);
6220 defwndproc_counter--;
6221
6222 return ret;
6223 }
6224
6225 static LRESULT CALLBACK combobox_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6226 {
6227 static LONG defwndproc_counter = 0;
6228 LRESULT ret;
6229 struct recvd_message msg;
6230
6231 /* do not log painting messages */
6232 if (message != WM_PAINT &&
6233 message != WM_NCPAINT &&
6234 message != WM_SYNCPAINT &&
6235 message != WM_ERASEBKGND &&
6236 message != WM_NCHITTEST &&
6237 message != WM_GETTEXT &&
6238 !ignore_message( message ))
6239 {
6240 msg.hwnd = hwnd;
6241 msg.message = message;
6242 msg.flags = sent|wparam|lparam;
6243 if (defwndproc_counter) msg.flags |= defwinproc;
6244 msg.wParam = wParam;
6245 msg.lParam = lParam;
6246 msg.descr = "combo";
6247 add_message(&msg);
6248 }
6249
6250 defwndproc_counter++;
6251 ret = CallWindowProcA(old_combobox_proc, hwnd, message, wParam, lParam);
6252 defwndproc_counter--;
6253
6254 return ret;
6255 }
6256
6257 static void subclass_combobox(void)
6258 {
6259 WNDCLASSA cls;
6260
6261 if (!GetClassInfoA(0, "ComboBox", &cls)) assert(0);
6262
6263 old_combobox_proc = cls.lpfnWndProc;
6264
6265 cls.hInstance = GetModuleHandleA(NULL);
6266 cls.lpfnWndProc = combobox_hook_proc;
6267 cls.lpszClassName = "my_combobox_class";
6268 UnregisterClassA(cls.lpszClassName, cls.hInstance);
6269 if (!RegisterClassA(&cls)) assert(0);
6270 }
6271
6272 static void test_combobox_messages(void)
6273 {
6274 HWND parent, combo, button, edit;
6275 LRESULT ret;
6276 BOOL (WINAPI *pGetComboBoxInfo)(HWND, PCOMBOBOXINFO);
6277 COMBOBOXINFO cbInfo;
6278 BOOL res;
6279
6280 subclass_combobox();
6281
6282 parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
6283 100, 100, 200, 200, 0, 0, 0, NULL);
6284 ok(parent != 0, "Failed to create parent window\n");
6285 flush_sequence();
6286
6287 combo = CreateWindowExA(0, "my_combobox_class", "test", WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | CBS_HASSTRINGS,
6288 0, 0, 100, 150, parent, (HMENU)ID_COMBOBOX, 0, NULL);
6289 ok(combo != 0, "Failed to create combobox window\n");
6290
6291 UpdateWindow(combo);
6292
6293 ret = SendMessageA(combo, WM_GETDLGCODE, 0, 0);
6294 ok(ret == (DLGC_WANTCHARS | DLGC_WANTARROWS), "wrong dlg_code %08lx\n", ret);
6295
6296 ret = SendMessageA(combo, CB_ADDSTRING, 0, (LPARAM)"item 0");
6297 ok(ret == 0, "expected 0, got %ld\n", ret);
6298 ret = SendMessageA(combo, CB_ADDSTRING, 0, (LPARAM)"item 1");
6299 ok(ret == 1, "expected 1, got %ld\n", ret);
6300 ret = SendMessageA(combo, CB_ADDSTRING, 0, (LPARAM)"item 2");
6301 ok(ret == 2, "expected 2, got %ld\n", ret);
6302
6303 SendMessageA(combo, CB_SETCURSEL, 0, 0);
6304 SetFocus(combo);
6305 flush_sequence();
6306
6307 log_all_parent_messages++;
6308 SendMessageA(combo, WM_KEYDOWN, VK_DOWN, 0);
6309 SendMessageA(combo, WM_KEYUP, VK_DOWN, 0);
6310 log_all_parent_messages--;
6311 ok_sequence(WmKeyDownComboSeq, "WM_KEYDOWN/VK_DOWN on a ComboBox", FALSE);
6312
6313 flush_sequence();
6314 SetWindowPos(combo, 0, 10, 10, 120, 130, SWP_NOZORDER);
6315 ok_sequence(WmSetPosComboSeq, "repositioning messages on a ComboBox", FALSE);
6316
6317 DestroyWindow(combo);
6318 DestroyWindow(parent);
6319
6320 /* Start again. Test combobox text selection when getting and losing focus */
6321 pGetComboBoxInfo = (void *)GetProcAddress(GetModuleHandleA("user32.dll"), "GetComboBoxInfo");
6322 if (!pGetComboBoxInfo)
6323 {
6324 win_skip("GetComboBoxInfo is not available\n");
6325 return;
6326 }
6327
6328 parent = CreateWindowExA(0, "TestParentClass", "Parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
6329 10, 10, 300, 300, NULL, NULL, NULL, NULL);
6330 ok(parent != 0, "Failed to create parent window\n");
6331
6332 combo = CreateWindowExA(0, "my_combobox_class", "test", WS_CHILD | WS_VISIBLE | CBS_DROPDOWN,
6333 5, 5, 100, 100, parent, (HMENU)ID_COMBOBOX, NULL, NULL);
6334 ok(combo != 0, "Failed to create combobox window\n");
6335
6336 cbInfo.cbSize = sizeof(COMBOBOXINFO);
6337 SetLastError(0xdeadbeef);
6338 res = pGetComboBoxInfo(combo, &cbInfo);
6339 ok(res, "Failed to get COMBOBOXINFO structure; LastError: %u\n", GetLastError());
6340 edit = cbInfo.hwndItem;
6341
6342 edit_window_proc = (WNDPROC)SetWindowLongPtrA(edit, GWLP_WNDPROC, (ULONG_PTR)combobox_subclass_proc);
6343
6344 button = CreateWindowExA(0, "Button", "OK", WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON,
6345 5, 50, 100, 20, parent, NULL,
6346 (HINSTANCE)GetWindowLongPtrA(parent, GWLP_HINSTANCE), NULL);
6347 ok(button != 0, "Failed to create button window\n");
6348
6349 flush_sequence();
6350 log_all_parent_messages++;
6351 SendMessageA(combo, WM_SETFOCUS, 0, (LPARAM)edit);
6352 log_all_parent_messages--;
6353 ok_sequence(WMSetFocusComboBoxSeq, "WM_SETFOCUS on a ComboBox", TRUE);
6354
6355 flush_sequence();
6356 log_all_parent_messages++;
6357 SetFocus(button);
6358 log_all_parent_messages--;
6359 ok_sequence(SetFocusButtonSeq, "SetFocus on a Button", TRUE);
6360
6361 SendMessageA(combo, WM_SETTEXT, 0, (LPARAM)"Wine Test");
6362
6363 flush_sequence();
6364 log_all_parent_messages++;
6365 SetFocus(combo);
6366 log_all_parent_messages--;
6367 ok_sequence(SetFocusComboBoxSeq, "SetFocus on a ComboBox", TRUE);
6368
6369 flush_sequence();
6370 log_all_parent_messages++;
6371 SetFocus(button);
6372 log_all_parent_messages--;
6373 ok_sequence(SetFocusButtonSeq2, "SetFocus on a Button (2)", TRUE);
6374
6375 DestroyWindow(button);
6376 DestroyWindow(combo);
6377 DestroyWindow(parent);
6378 }
6379
6380 /****************** WM_IME_KEYDOWN message test *******************/
6381
6382 static const struct message WmImeKeydownMsgSeq_0[] =
6383 {
6384 { WM_IME_KEYDOWN, wparam, VK_RETURN },
6385 { WM_CHAR, wparam, 'A' },
6386 { 0 }
6387 };
6388
6389 static const struct message WmImeKeydownMsgSeq_1[] =
6390 {
6391 { WM_KEYDOWN, optional|wparam, VK_RETURN },
6392 { WM_CHAR, optional|wparam, VK_RETURN },
6393 { 0 }
6394 };
6395
6396 static LRESULT WINAPI wmime_keydown_procA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6397 {
6398 struct recvd_message msg;
6399
6400 msg.hwnd = hwnd;
6401 msg.message = message;
6402 msg.flags = wparam|lparam;
6403 msg.wParam = wParam;
6404 msg.lParam = lParam;
6405 msg.descr = "wmime_keydown";
6406 add_message(&msg);
6407
6408 return DefWindowProcA(hwnd, message, wParam, lParam);
6409 }
6410
6411 static void register_wmime_keydown_class(void)
6412 {
6413 WNDCLASSA cls;
6414
6415 ZeroMemory(&cls, sizeof(WNDCLASSA));
6416 cls.lpfnWndProc = wmime_keydown_procA;
6417 cls.hInstance = GetModuleHandleA(0);
6418 cls.lpszClassName = "wmime_keydown_class";
6419 if (!RegisterClassA(&cls)) assert(0);
6420 }
6421
6422 static void test_wmime_keydown_message(void)
6423 {
6424 HWND hwnd;
6425 MSG msg;
6426
6427 trace("Message sequences by WM_IME_KEYDOWN\n");
6428
6429 register_wmime_keydown_class();
6430 hwnd = CreateWindowExA(0, "wmime_keydown_class", NULL, WS_OVERLAPPEDWINDOW,
6431 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
6432 NULL, NULL, 0);
6433 flush_events();
6434 flush_sequence();
6435
6436 SendMessageA(hwnd, WM_IME_KEYDOWN, VK_RETURN, 0x1c0001);
6437 SendMessageA(hwnd, WM_CHAR, 'A', 1);
6438 ok_sequence(WmImeKeydownMsgSeq_0, "WM_IME_KEYDOWN 0", FALSE);
6439
6440 while ( PeekMessageA(&msg, 0, 0, 0, PM_REMOVE) )
6441 {
6442 TranslateMessage(&msg);
6443 DispatchMessageA(&msg);
6444 }
6445 ok_sequence(WmImeKeydownMsgSeq_1, "WM_IME_KEYDOWN 1", FALSE);
6446
6447 DestroyWindow(hwnd);
6448 }
6449
6450 /************* painting message test ********************/
6451
6452 void dump_region(HRGN hrgn)
6453 {
6454 DWORD i, size;
6455 RGNDATA *data = NULL;
6456 RECT *rect;
6457
6458 if (!hrgn)
6459 {
6460 printf( "null region\n" );
6461 return;
6462 }
6463 if (!(size = GetRegionData( hrgn, 0, NULL ))) return;
6464 if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return;
6465 GetRegionData( hrgn, size, data );
6466 printf("%d rects:", data->rdh.nCount );
6467 for (i = 0, rect = (RECT *)data->Buffer; i < data->rdh.nCount; i++, rect++)
6468 printf( " (%d,%d)-(%d,%d)", rect->left, rect->top, rect->right, rect->bottom );
6469 printf("\n");
6470 HeapFree( GetProcessHeap(), 0, data );
6471 }
6472
6473 static void check_update_rgn( HWND hwnd, HRGN hrgn )
6474 {
6475 INT ret;
6476 RECT r1, r2;
6477 HRGN tmp = CreateRectRgn( 0, 0, 0, 0 );
6478 HRGN update = CreateRectRgn( 0, 0, 0, 0 );
6479
6480 ret = GetUpdateRgn( hwnd, update, FALSE );
6481 ok( ret != ERROR, "GetUpdateRgn failed\n" );
6482 if (ret == NULLREGION)
6483 {
6484 ok( !hrgn, "Update region shouldn't be empty\n" );
6485 }
6486 else
6487 {
6488 if (CombineRgn( tmp, hrgn, update, RGN_XOR ) != NULLREGION)
6489 {
6490 ok( 0, "Regions are different\n" );
6491 if (winetest_debug > 0)
6492 {
6493 printf( "Update region: " );
6494 dump_region( update );
6495 printf( "Wanted region: " );
6496 dump_region( hrgn );
6497 }
6498 }
6499 }
6500 GetRgnBox( update, &r1 );
6501 GetUpdateRect( hwnd, &r2, FALSE );
6502 ok( EqualRect( &r1, &r2 ), "Rectangles are different: %d,%d-%d,%d / %d,%d-%d,%d\n",
6503 r1.left, r1.top, r1.right, r1.bottom, r2.left, r2.top, r2.right, r2.bottom );
6504
6505 DeleteObject( tmp );
6506 DeleteObject( update );
6507 }
6508
6509 static const struct message WmInvalidateRgn[] = {
6510 { WM_NCPAINT, sent },
6511 { WM_GETTEXT, sent|defwinproc|optional },
6512 { 0 }
6513 };
6514
6515 static const struct message WmGetUpdateRect[] = {
6516 { WM_NCPAINT, sent },
6517 { WM_GETTEXT, sent|defwinproc|optional },
6518 { WM_PAINT, sent },
6519 { 0 }
6520 };
6521
6522 static const struct message WmInvalidateFull[] = {
6523 { WM_NCPAINT, sent|wparam, 1 },
6524 { WM_GETTEXT, sent|defwinproc|optional },
6525 { 0 }
6526 };
6527
6528 static const struct message WmInvalidateErase[] = {
6529 { WM_NCPAINT, sent|wparam, 1 },
6530 { WM_GETTEXT, sent|defwinproc|optional },
6531 { WM_ERASEBKGND, sent },
6532 { 0 }
6533 };
6534
6535 static const struct message WmInvalidatePaint[] = {
6536 { WM_PAINT, sent },
6537 { WM_NCPAINT, sent|wparam|beginpaint, 1 },
6538 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
6539 { 0 }
6540 };
6541
6542 static const struct message WmInvalidateErasePaint[] = {
6543 { WM_PAINT, sent },
6544 { WM_NCPAINT, sent|wparam|beginpaint, 1 },
6545 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
6546 { WM_ERASEBKGND, sent|beginpaint|optional },
6547 { 0 }
6548 };
6549
6550 static const struct message WmInvalidateErasePaint2[] = {
6551 { WM_PAINT, sent },
6552 { WM_NCPAINT, sent|beginpaint },
6553 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
6554 { WM_ERASEBKGND, sent|beginpaint|optional },
6555 { 0 }
6556 };
6557
6558 static const struct message WmErase[] = {
6559 { WM_ERASEBKGND, sent },
6560 { 0 }
6561 };
6562
6563 static const struct message WmPaint[] = {
6564 { WM_PAINT, sent },
6565 { 0 }
6566 };
6567
6568 static const struct message WmParentOnlyPaint[] = {
6569 { WM_PAINT, sent|parent },
6570 { 0 }
6571 };
6572
6573 static const struct message WmInvalidateParent[] = {
6574 { WM_NCPAINT, sent|parent },
6575 { WM_GETTEXT, sent|defwinproc|parent|optional },
6576 { WM_ERASEBKGND, sent|parent },
6577 { 0 }
6578 };
6579
6580 static const struct message WmInvalidateParentChild[] = {
6581 { WM_NCPAINT, sent|parent },
6582 { WM_GETTEXT, sent|defwinproc|parent|optional },
6583 { WM_ERASEBKGND, sent|parent },
6584 { WM_NCPAINT, sent },
6585 { WM_GETTEXT, sent|defwinproc|optional },
6586 { WM_ERASEBKGND, sent },
6587 { 0 }
6588 };
6589
6590 static const struct message WmInvalidateParentChild2[] = {
6591 { WM_ERASEBKGND, sent|parent },
6592 { WM_NCPAINT, sent },
6593 { WM_GETTEXT, sent|defwinproc|optional },
6594 { WM_ERASEBKGND, sent },
6595 { 0 }
6596 };
6597
6598 static const struct message WmParentPaint[] = {
6599 { WM_PAINT, sent|parent },
6600 { WM_PAINT, sent },
6601 { 0 }
6602 };
6603
6604 static const struct message WmParentPaintNc[] = {
6605 { WM_PAINT, sent|parent },
6606 { WM_PAINT, sent },
6607 { WM_NCPAINT, sent|beginpaint },
6608 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
6609 { WM_ERASEBKGND, sent|beginpaint|optional },
6610 { 0 }
6611 };
6612
6613 static const struct message WmChildPaintNc[] = {
6614 { WM_PAINT, sent },
6615 { WM_NCPAINT, sent|beginpaint },
6616 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
6617 { WM_ERASEBKGND, sent|beginpaint|optional },
6618 { 0 }
6619 };
6620
6621 static const struct message WmParentErasePaint[] = {
6622 { WM_PAINT, sent|parent },
6623 { WM_NCPAINT, sent|parent|beginpaint },
6624 { WM_GETTEXT, sent|parent|beginpaint|defwinproc|optional },
6625 { WM_ERASEBKGND, sent|parent|beginpaint|optional },
6626 { WM_PAINT, sent },
6627 { WM_NCPAINT, sent|beginpaint },
6628 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
6629 { WM_ERASEBKGND, sent|beginpaint|optional },
6630 { 0 }
6631 };
6632
6633 static const struct message WmParentOnlyNcPaint[] = {
6634 { WM_PAINT, sent|parent },
6635 { WM_NCPAINT, sent|parent|beginpaint },
6636 { WM_GETTEXT, sent|parent|beginpaint|defwinproc|optional },
6637 { 0 }
6638 };
6639
6640 static const struct message WmSetParentStyle[] = {
6641 { WM_STYLECHANGING, sent|parent },
6642 { WM_STYLECHANGED, sent|parent },
6643 { 0 }
6644 };
6645
6646 static void test_paint_messages(void)
6647 {
6648 BOOL ret;
6649 RECT rect;
6650 POINT pt;
6651 MSG msg;
6652 HWND hparent, hchild;
6653 HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
6654 HRGN hrgn2 = CreateRectRgn( 0, 0, 0, 0 );
6655 HWND hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
6656 100, 100, 200, 200, 0, 0, 0, NULL);
6657 ok (hwnd != 0, "Failed to create overlapped window\n");
6658
6659 ShowWindow( hwnd, SW_SHOW );
6660 UpdateWindow( hwnd );
6661 flush_events();
6662 flush_sequence();
6663
6664 check_update_rgn( hwnd, 0 );
6665 SetRectRgn( hrgn, 10, 10, 20, 20 );
6666 ret = RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
6667 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
6668 check_update_rgn( hwnd, hrgn );
6669 SetRectRgn( hrgn2, 20, 20, 30, 30 );
6670 ret = RedrawWindow( hwnd, NULL, hrgn2, RDW_INVALIDATE );
6671 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
6672 CombineRgn( hrgn, hrgn, hrgn2, RGN_OR );
6673 check_update_rgn( hwnd, hrgn );
6674 /* validate everything */
6675 ret = RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
6676 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
6677 check_update_rgn( hwnd, 0 );
6678
6679 /* test empty region */
6680 SetRectRgn( hrgn, 10, 10, 10, 15 );
6681 ret = RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
6682 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
6683 check_update_rgn( hwnd, 0 );
6684 /* test empty rect */
6685 SetRect( &rect, 10, 10, 10, 15 );
6686 ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
6687 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
6688 check_update_rgn( hwnd, 0 );
6689
6690 /* flush pending messages */
6691 flush_events();
6692 flush_sequence();
6693
6694 GetClientRect( hwnd, &rect );
6695 SetRectRgn( hrgn, 0, 0, rect.right - rect.left, rect.bottom - rect.top );
6696 /* MSDN: if hwnd parameter is NULL, InvalidateRect invalidates and redraws
6697 * all windows and sends WM_ERASEBKGND and WM_NCPAINT.
6698 */
6699 trace("testing InvalidateRect(0, NULL, FALSE)\n");
6700 SetRectEmpty( &rect );
6701 ok(InvalidateRect(0, &rect, FALSE), "InvalidateRect(0, &rc, FALSE) should fail\n");
6702 check_update_rgn( hwnd, hrgn );
6703 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
6704 flush_events();
6705 ok_sequence( WmPaint, "Paint", FALSE );
6706 RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
6707 check_update_rgn( hwnd, 0 );
6708
6709 /* MSDN: if hwnd parameter is NULL, ValidateRect invalidates and redraws
6710 * all windows and sends WM_ERASEBKGND and WM_NCPAINT.
6711 */
6712 trace("testing ValidateRect(0, NULL)\n");
6713 SetRectEmpty( &rect );
6714 if (ValidateRect(0, &rect)) /* not supported on Win9x */
6715 {
6716 check_update_rgn( hwnd, hrgn );
6717 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
6718 flush_events();
6719 ok_sequence( WmPaint, "Paint", FALSE );
6720 RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
6721 check_update_rgn( hwnd, 0 );
6722 }
6723
6724 trace("testing InvalidateRgn(0, NULL, FALSE)\n");
6725 SetLastError(0xdeadbeef);
6726 ok(!InvalidateRgn(0, NULL, FALSE), "InvalidateRgn(0, NULL, FALSE) should fail\n");
6727 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || GetLastError() == 0xdeadbeef,
6728 "wrong error code %d\n", GetLastError());
6729 check_update_rgn( hwnd, 0 );
6730 flush_events();
6731 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
6732
6733 trace("testing ValidateRgn(0, NULL)\n");
6734 SetLastError(0xdeadbeef);
6735 ok(!ValidateRgn(0, NULL), "ValidateRgn(0, NULL) should fail\n");
6736 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE ||
6737 broken( GetLastError() == 0xdeadbeef ) /* win9x */,
6738 "wrong error code %d\n", GetLastError());
6739 check_update_rgn( hwnd, 0 );
6740 flush_events();
6741 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
6742
6743 trace("testing UpdateWindow(NULL)\n");
6744 SetLastError(0xdeadbeef);
6745 ok(!UpdateWindow(NULL), "UpdateWindow(NULL) should fail\n");
6746 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE ||
6747 broken( GetLastError() == 0xdeadbeef ) /* win9x */,
6748 "wrong error code %d\n", GetLastError());
6749 check_update_rgn( hwnd, 0 );
6750 flush_events();
6751 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
6752
6753 /* now with frame */
6754 SetRectRgn( hrgn, -5, -5, 20, 20 );
6755
6756 /* flush pending messages */
6757 flush_events();
6758 flush_sequence();
6759 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
6760 ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
6761
6762 SetRectRgn( hrgn, 0, 0, 20, 20 ); /* GetUpdateRgn clips to client area */
6763 check_update_rgn( hwnd, hrgn );
6764
6765 flush_sequence();
6766 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
6767 ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
6768
6769 flush_sequence();
6770 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
6771 ok_sequence( WmInvalidateFull, "InvalidateFull", FALSE );
6772
6773 GetClientRect( hwnd, &rect );
6774 SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
6775 check_update_rgn( hwnd, hrgn );
6776
6777 flush_sequence();
6778 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW );
6779 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
6780
6781 flush_sequence();
6782 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW | RDW_UPDATENOW );
6783 ok_sequence( WmInvalidatePaint, "InvalidatePaint", FALSE );
6784 check_update_rgn( hwnd, 0 );
6785
6786 flush_sequence();
6787 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_UPDATENOW );
6788 ok_sequence( WmInvalidateErasePaint, "InvalidateErasePaint", FALSE );
6789 check_update_rgn( hwnd, 0 );
6790
6791 flush_sequence();
6792 SetRectRgn( hrgn, 0, 0, 100, 100 );
6793 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
6794 SetRectRgn( hrgn, 0, 0, 50, 100 );
6795 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE );
6796 SetRectRgn( hrgn, 50, 0, 100, 100 );
6797 check_update_rgn( hwnd, hrgn );
6798 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
6799 ok_sequence( WmEmptySeq, "EmptySeq", FALSE ); /* must not generate messages, everything is valid */
6800 check_update_rgn( hwnd, 0 );
6801
6802 flush_sequence();
6803 SetRectRgn( hrgn, 0, 0, 100, 100 );
6804 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
6805 SetRectRgn( hrgn, 0, 0, 100, 50 );
6806 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
6807 ok_sequence( WmErase, "Erase", FALSE );
6808 SetRectRgn( hrgn, 0, 50, 100, 100 );
6809 check_update_rgn( hwnd, hrgn );
6810
6811 flush_sequence();
6812 SetRectRgn( hrgn, 0, 0, 100, 100 );
6813 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
6814 SetRectRgn( hrgn, 0, 0, 50, 50 );
6815 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOERASE | RDW_UPDATENOW );
6816 ok_sequence( WmPaint, "Paint", FALSE );
6817
6818 flush_sequence();
6819 SetRectRgn( hrgn, -4, -4, -2, -2 );
6820 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
6821 SetRectRgn( hrgn, -200, -200, -198, -198 );
6822 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME | RDW_ERASENOW );
6823 ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
6824
6825 flush_sequence();
6826 SetRectRgn( hrgn, -4, -4, -2, -2 );
6827 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
6828 SetRectRgn( hrgn, -4, -4, -3, -3 );
6829 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME );
6830 SetRectRgn( hrgn, 0, 0, 1, 1 );
6831 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_UPDATENOW );
6832 ok_sequence( WmPaint, "Paint", FALSE );
6833
6834 flush_sequence();
6835 SetRectRgn( hrgn, -4, -4, -1, -1 );
6836 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
6837 RedrawWindow( hwnd, NULL, 0, RDW_ERASENOW );
6838 /* make sure no WM_PAINT was generated */
6839 flush_events();
6840 ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
6841
6842 flush_sequence();
6843 SetRectRgn( hrgn, -4, -4, -1, -1 );
6844 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
6845 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
6846 {
6847 if (msg.hwnd == hwnd && msg.message == WM_PAINT)
6848 {
6849 /* GetUpdateRgn must return empty region since only nonclient area is invalidated */
6850 INT ret = GetUpdateRgn( hwnd, hrgn, FALSE );
6851 ok( ret == NULLREGION, "Invalid GetUpdateRgn result %d\n", ret );
6852 ret = GetUpdateRect( hwnd, &rect, FALSE );
6853 ok( ret, "Invalid GetUpdateRect result %d\n", ret );
6854 /* this will send WM_NCPAINT and validate the non client area */
6855 ret = GetUpdateRect( hwnd, &rect, TRUE );
6856 ok( !ret, "Invalid GetUpdateRect result %d\n", ret );
6857 }
6858 DispatchMessageA( &msg );
6859 }
6860 ok_sequence( WmGetUpdateRect, "GetUpdateRect", FALSE );
6861
6862 DestroyWindow( hwnd );
6863
6864 /* now test with a child window */
6865
6866 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW,
6867 100, 100, 200, 200, 0, 0, 0, NULL);
6868 ok (hparent != 0, "Failed to create parent window\n");
6869
6870 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE | WS_BORDER,
6871 10, 10, 100, 100, hparent, 0, 0, NULL);
6872 ok (hchild != 0, "Failed to create child window\n");
6873
6874 ShowWindow( hparent, SW_SHOW );
6875 UpdateWindow( hparent );
6876 UpdateWindow( hchild );
6877 flush_events();
6878 flush_sequence();
6879 log_all_parent_messages++;
6880
6881 SetRect( &rect, 0, 0, 50, 50 );
6882 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6883 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW | RDW_ALLCHILDREN );
6884 ok_sequence( WmInvalidateParentChild, "InvalidateParentChild", FALSE );
6885
6886 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6887 pt.x = pt.y = 0;
6888 MapWindowPoints( hchild, hparent, &pt, 1 );
6889 SetRectRgn( hrgn, 0, 0, 50 - pt.x, 50 - pt.y );
6890 check_update_rgn( hchild, hrgn );
6891 SetRectRgn( hrgn, 0, 0, 50, 50 );
6892 check_update_rgn( hparent, hrgn );
6893 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
6894 ok_sequence( WmInvalidateParent, "InvalidateParent", FALSE );
6895 RedrawWindow( hchild, NULL, 0, RDW_ERASENOW );
6896 ok_sequence( WmEmptySeq, "EraseNow child", FALSE );
6897
6898 flush_events();
6899 ok_sequence( WmParentPaintNc, "WmParentPaintNc", FALSE );
6900
6901 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
6902 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
6903 ok_sequence( WmInvalidateParent, "InvalidateParent2", FALSE );
6904 RedrawWindow( hchild, NULL, 0, RDW_ERASENOW );
6905 ok_sequence( WmEmptySeq, "EraseNow child", FALSE );
6906
6907 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
6908 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW | RDW_ALLCHILDREN );
6909 ok_sequence( WmInvalidateParentChild2, "InvalidateParentChild2", FALSE );
6910
6911 SetWindowLongA( hparent, GWL_STYLE, GetWindowLongA(hparent,GWL_STYLE) | WS_CLIPCHILDREN );
6912 flush_sequence();
6913 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
6914 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
6915 ok_sequence( WmInvalidateParentChild, "InvalidateParentChild3", FALSE );
6916
6917 /* flush all paint messages */
6918 flush_events();
6919 flush_sequence();
6920
6921 /* RDW_UPDATENOW on child with WS_CLIPCHILDREN doesn't change corresponding parent area */
6922 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
6923 SetRectRgn( hrgn, 0, 0, 50, 50 );
6924 check_update_rgn( hparent, hrgn );
6925 RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
6926 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
6927 SetRectRgn( hrgn, 0, 0, 50, 50 );
6928 check_update_rgn( hparent, hrgn );
6929
6930 /* flush all paint messages */
6931 flush_events();
6932 SetWindowLongA( hparent, GWL_STYLE, GetWindowLongA(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
6933 flush_sequence();
6934
6935 /* RDW_UPDATENOW on child without WS_CLIPCHILDREN will validate corresponding parent area */
6936 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6937 SetRectRgn( hrgn, 0, 0, 50, 50 );
6938 check_update_rgn( hparent, hrgn );
6939 RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
6940 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
6941 SetRectRgn( hrgn2, 10, 10, 50, 50 );
6942 CombineRgn( hrgn, hrgn, hrgn2, RGN_DIFF );
6943 check_update_rgn( hparent, hrgn );
6944 /* flush all paint messages */
6945 flush_events();
6946 flush_sequence();
6947
6948 /* same as above but parent gets completely validated */
6949 SetRect( &rect, 20, 20, 30, 30 );
6950 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6951 SetRectRgn( hrgn, 20, 20, 30, 30 );
6952 check_update_rgn( hparent, hrgn );
6953 RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
6954 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
6955 check_update_rgn( hparent, 0 ); /* no update region */
6956 flush_events();
6957 ok_sequence( WmEmptySeq, "WmEmpty", FALSE ); /* and no paint messages */
6958
6959 /* make sure RDW_VALIDATE on child doesn't have the same effect */
6960 flush_sequence();
6961 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6962 SetRectRgn( hrgn, 20, 20, 30, 30 );
6963 check_update_rgn( hparent, hrgn );
6964 RedrawWindow( hchild, NULL, 0, RDW_VALIDATE | RDW_NOERASE );
6965 SetRectRgn( hrgn, 20, 20, 30, 30 );
6966 check_update_rgn( hparent, hrgn );
6967
6968 /* same as above but normal WM_PAINT doesn't validate parent */
6969 flush_sequence();
6970 SetRect( &rect, 20, 20, 30, 30 );
6971 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6972 SetRectRgn( hrgn, 20, 20, 30, 30 );
6973 check_update_rgn( hparent, hrgn );
6974 /* no WM_PAINT in child while parent still pending */
6975 while (PeekMessageA( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
6976 ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
6977 while (PeekMessageA( &msg, hparent, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
6978 ok_sequence( WmParentErasePaint, "WmParentErasePaint", FALSE );
6979
6980 flush_sequence();
6981 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6982 /* no WM_PAINT in child while parent still pending */
6983 while (PeekMessageA( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
6984 ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
6985 RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_NOERASE | RDW_NOCHILDREN );
6986 /* now that parent is valid child should get WM_PAINT */
6987 while (PeekMessageA( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
6988 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
6989 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
6990 ok_sequence( WmEmptySeq, "No other message", FALSE );
6991
6992 /* same thing with WS_CLIPCHILDREN in parent */
6993 flush_sequence();
6994 SetWindowLongA( hparent, GWL_STYLE, GetWindowLongA(hparent,GWL_STYLE) | WS_CLIPCHILDREN );
6995 ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
6996 /* changing style invalidates non client area, but we need to invalidate something else to see it */
6997 RedrawWindow( hparent, &rect, 0, RDW_UPDATENOW );
6998 ok_sequence( WmEmptySeq, "No message", FALSE );
6999 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_UPDATENOW );
7000 ok_sequence( WmParentOnlyNcPaint, "WmParentOnlyNcPaint", FALSE );
7001
7002 flush_sequence();
7003 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN );
7004 SetRectRgn( hrgn, 20, 20, 30, 30 );
7005 check_update_rgn( hparent, hrgn );
7006 /* no WM_PAINT in child while parent still pending */
7007 while (PeekMessageA( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
7008 ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
7009 /* WM_PAINT in parent first */
7010 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
7011 ok_sequence( WmParentPaintNc, "WmParentPaintNc2", FALSE );
7012
7013 /* no RDW_ERASE in parent still causes RDW_ERASE and RDW_FRAME in child */
7014 flush_sequence();
7015 SetRect( &rect, 0, 0, 30, 30 );
7016 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ALLCHILDREN );
7017 SetRectRgn( hrgn, 0, 0, 30, 30 );
7018 check_update_rgn( hparent, hrgn );
7019 flush_events();
7020 ok_sequence( WmParentPaintNc, "WmParentPaintNc3", FALSE );
7021
7022 /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
7023 flush_sequence();
7024 SetRect( &rect, -10, 0, 30, 30 );
7025 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE );
7026 SetRect( &rect, 0, 0, 20, 20 );
7027 RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_ALLCHILDREN );
7028 RedrawWindow( hparent, NULL, 0, RDW_UPDATENOW );
7029 ok_sequence( WmChildPaintNc, "WmChildPaintNc", FALSE );
7030
7031 /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
7032 flush_sequence();
7033 SetRect( &rect, -10, 0, 30, 30 );
7034 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE );
7035 SetRect( &rect, 0, 0, 100, 100 );
7036 RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_ALLCHILDREN );
7037 RedrawWindow( hparent, NULL, 0, RDW_UPDATENOW );
7038 ok_sequence( WmEmptySeq, "WmChildPaintNc2", FALSE );
7039 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
7040 ok_sequence( WmEmptySeq, "WmChildPaintNc3", FALSE );
7041
7042 /* WS_CLIPCHILDREN doesn't exclude children from update region */
7043 flush_sequence();
7044 RedrawWindow( hparent, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_NOCHILDREN );
7045 GetClientRect( hparent, &rect );
7046 SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
7047 check_update_rgn( hparent, hrgn );
7048 flush_events();
7049
7050 RedrawWindow( hparent, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN );
7051 GetClientRect( hparent, &rect );
7052 SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
7053 check_update_rgn( hparent, hrgn );
7054 flush_events();
7055
7056 /* test RDW_INTERNALPAINT behavior */
7057
7058 flush_sequence();
7059 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_NOCHILDREN );
7060 flush_events();
7061 ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
7062
7063 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_ALLCHILDREN );
7064 flush_events();
7065 ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
7066
7067 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
7068 flush_events();
7069 ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
7070
7071 assert( GetWindowLongA(hparent, GWL_STYLE) & WS_CLIPCHILDREN );
7072 UpdateWindow( hparent );
7073 flush_events();
7074 flush_sequence();
7075 trace("testing SWP_FRAMECHANGED on parent with WS_CLIPCHILDREN\n");
7076 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
7077 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
7078 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
7079 flush_events();
7080 ok_sequence(WmSWP_FrameChanged_clip, "SetWindowPos:FrameChanged_clip", FALSE );
7081
7082 UpdateWindow( hparent );
7083 flush_events();
7084 flush_sequence();
7085 trace("testing SWP_FRAMECHANGED|SWP_DEFERERASE on parent with WS_CLIPCHILDREN\n");
7086 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
7087 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_DEFERERASE |
7088 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
7089 flush_events();
7090 ok_sequence(WmSWP_FrameChangedDeferErase, "SetWindowPos:FrameChangedDeferErase", FALSE );
7091
7092 SetWindowLongA( hparent, GWL_STYLE, GetWindowLongA(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
7093 ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
7094 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
7095 flush_events();
7096 ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
7097
7098 assert( !(GetWindowLongA(hparent, GWL_STYLE) & WS_CLIPCHILDREN) );
7099 UpdateWindow( hparent );
7100 flush_events();
7101 flush_sequence();
7102 trace("testing SWP_FRAMECHANGED on parent without WS_CLIPCHILDREN\n");
7103 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
7104 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
7105 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
7106 flush_events();
7107 ok_sequence(WmSWP_FrameChanged_noclip, "SetWindowPos:FrameChanged_noclip", FALSE );
7108
7109 UpdateWindow( hparent );
7110 flush_events();
7111 flush_sequence();
7112 trace("testing SWP_FRAMECHANGED|SWP_DEFERERASE on parent without WS_CLIPCHILDREN\n");
7113 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
7114 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_DEFERERASE |
7115 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
7116 flush_events();
7117 ok_sequence(WmSWP_FrameChangedDeferErase, "SetWindowPos:FrameChangedDeferErase", FALSE );
7118
7119 ok(GetWindowLongA( hparent, GWL_STYLE ) & WS_VISIBLE, "parent should be visible\n");
7120 ok(GetWindowLongA( hchild, GWL_STYLE ) & WS_VISIBLE, "child should be visible\n");
7121
7122 UpdateWindow( hparent );
7123 flush_events();
7124 flush_sequence();
7125 trace("testing SetWindowPos(-10000, -10000) on child\n");
7126 SetWindowPos( hchild, 0, -10000, -10000, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER );
7127 check_update_rgn( hchild, 0 );
7128 flush_events();
7129
7130 #if 0 /* this one doesn't pass under Wine yet */
7131 UpdateWindow( hparent );
7132 flush_events();
7133 flush_sequence();
7134 trace("testing ShowWindow(SW_MINIMIZE) on child\n");
7135 ShowWindow( hchild, SW_MINIMIZE );
7136 check_update_rgn( hchild, 0 );
7137 flush_events();
7138 #endif
7139
7140 UpdateWindow( hparent );
7141 flush_events();
7142 flush_sequence();
7143 trace("testing SetWindowPos(-10000, -10000) on parent\n");
7144 SetWindowPos( hparent, 0, -10000, -10000, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER );
7145 check_update_rgn( hparent, 0 );
7146 flush_events();
7147
7148 log_all_parent_messages--;
7149 DestroyWindow( hparent );
7150 ok(!IsWindow(hchild), "child must be destroyed with its parent\n");
7151
7152 /* tests for moving windows off-screen (needs simple WS_POPUP windows) */
7153
7154 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_POPUP | WS_VISIBLE,
7155 100, 100, 200, 200, 0, 0, 0, NULL);
7156 ok (hparent != 0, "Failed to create parent window\n");
7157
7158 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
7159 10, 10, 100, 100, hparent, 0, 0, NULL);
7160 ok (hchild != 0, "Failed to create child window\n");
7161
7162 ShowWindow( hparent, SW_SHOW );
7163 UpdateWindow( hparent );
7164 UpdateWindow( hchild );
7165 flush_events();
7166 flush_sequence();
7167
7168 /* moving child outside of parent boundaries changes update region */
7169 SetRect( &rect, 0, 0, 40, 40 );
7170 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
7171 SetRectRgn( hrgn, 0, 0, 40, 40 );
7172 check_update_rgn( hchild, hrgn );
7173 MoveWindow( hchild, -10, 10, 100, 100, FALSE );
7174 SetRectRgn( hrgn, 10, 0, 40, 40 );
7175 check_update_rgn( hchild, hrgn );
7176 MoveWindow( hchild, -10, -10, 100, 100, FALSE );
7177 SetRectRgn( hrgn, 10, 10, 40, 40 );
7178 check_update_rgn( hchild, hrgn );
7179
7180 /* moving parent off-screen does too */
7181 SetRect( &rect, 0, 0, 100, 100 );
7182 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_NOCHILDREN );
7183 SetRectRgn( hrgn, 0, 0, 100, 100 );
7184 check_update_rgn( hparent, hrgn );
7185 SetRectRgn( hrgn, 10, 10, 40, 40 );
7186 check_update_rgn( hchild, hrgn );
7187 MoveWindow( hparent, -20, -20, 200, 200, FALSE );
7188 SetRectRgn( hrgn, 20, 20, 100, 100 );
7189 check_update_rgn( hparent, hrgn );
7190 SetRectRgn( hrgn, 30, 30, 40, 40 );
7191 check_update_rgn( hchild, hrgn );
7192
7193 /* invalidated region is cropped by the parent rects */
7194 SetRect( &rect, 0, 0, 50, 50 );
7195 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
7196 SetRectRgn( hrgn, 30, 30, 50, 50 );
7197 check_update_rgn( hchild, hrgn );
7198
7199 DestroyWindow( hparent );
7200 ok(!IsWindow(hchild), "child must be destroyed with its parent\n");
7201 flush_sequence();
7202
7203 DeleteObject( hrgn );
7204 DeleteObject( hrgn2 );
7205 }
7206
7207 struct wnd_event
7208 {
7209 HWND hwnd;
7210 HANDLE grand_child;
7211 HANDLE start_event;
7212 HANDLE stop_event;
7213 };
7214
7215 static DWORD WINAPI thread_proc(void *param)
7216 {
7217 MSG msg;
7218 struct wnd_event *wnd_event = param;
7219
7220 wnd_event->hwnd = CreateWindowExA(0, "TestWindowClass", "window caption text", WS_OVERLAPPEDWINDOW,
7221 100, 100, 200, 200, 0, 0, 0, NULL);
7222 ok(wnd_event->hwnd != 0, "Failed to create overlapped window\n");
7223
7224 SetEvent(wnd_event->start_event);
7225
7226 while (GetMessageA(&msg, 0, 0, 0))
7227 {
7228 TranslateMessage(&msg);
7229 DispatchMessageA(&msg);
7230 }
7231
7232 ok(IsWindow(wnd_event->hwnd), "window should still exist\n");
7233
7234 return 0;
7235 }
7236
7237 static DWORD CALLBACK create_grand_child_thread( void *param )
7238 {
7239 struct wnd_event *wnd_event = param;
7240 HWND hchild;
7241 MSG msg;
7242
7243 hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
7244 WS_CHILD | WS_VISIBLE, 0, 0, 10, 10, wnd_event->hwnd, 0, 0, NULL);
7245 ok (hchild != 0, "Failed to create child window\n");
7246 flush_events();
7247 flush_sequence();
7248 SetEvent( wnd_event->start_event );
7249
7250 for (;;)
7251 {
7252 MsgWaitForMultipleObjects(0, NULL, FALSE, 1000, QS_ALLINPUT);
7253 if (!IsWindow( hchild )) break; /* will be destroyed when parent thread exits */
7254 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
7255 }
7256 return 0;
7257 }
7258
7259 static DWORD CALLBACK create_child_thread( void *param )
7260 {
7261 struct wnd_event *wnd_event = param;
7262 struct wnd_event child_event;
7263 DWORD ret, tid;
7264 MSG msg;
7265
7266 child_event.hwnd = CreateWindowExA(0, "TestWindowClass", "Test child",
7267 WS_CHILD | WS_VISIBLE, 0, 0, 10, 10, wnd_event->hwnd, 0, 0, NULL);
7268 ok (child_event.hwnd != 0, "Failed to create child window\n");
7269 SetFocus( child_event.hwnd );
7270 flush_events();
7271 flush_sequence();
7272 child_event.start_event = wnd_event->start_event;
7273 wnd_event->grand_child = CreateThread(NULL, 0, create_grand_child_thread, &child_event, 0, &tid);
7274 for (;;)
7275 {
7276 DWORD ret = MsgWaitForMultipleObjects(1, &child_event.start_event, FALSE, 1000, QS_SENDMESSAGE);
7277 if (ret != 1) break;
7278 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
7279 }
7280 ret = WaitForSingleObject( wnd_event->stop_event, 5000 );
7281 ok( !ret, "WaitForSingleObject failed %x\n", ret );
7282 return 0;
7283 }
7284
7285 static const char manifest_dep[] =
7286 "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
7287 "<assemblyIdentity version=\"1.2.3.4\" name=\"testdep1\" type=\"win32\" processorArchitecture=\"" ARCH "\"/>"
7288 " <file name=\"testdep.dll\" />"
7289 "</assembly>";
7290
7291 static const char manifest_main[] =
7292 "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
7293 "<assemblyIdentity version=\"1.2.3.4\" name=\"Wine.Test\" type=\"win32\" />"
7294 "<dependency>"
7295 " <dependentAssembly>"
7296 " <assemblyIdentity type=\"win32\" name=\"testdep1\" version=\"1.2.3.4\" processorArchitecture=\"" ARCH "\" />"
7297 " </dependentAssembly>"
7298 "</dependency>"
7299 "</assembly>";
7300
7301 static void create_manifest_file(const char *filename, const char *manifest)
7302 {
7303 WCHAR path[MAX_PATH];
7304 HANDLE file;
7305 DWORD size;
7306
7307 MultiByteToWideChar( CP_ACP, 0, filename, -1, path, MAX_PATH );
7308 file = CreateFileW(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
7309 ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %u\n", GetLastError());
7310 WriteFile(file, manifest, strlen(manifest), &size, NULL);
7311 CloseHandle(file);
7312 }
7313
7314 static HANDLE test_create(const char *file)
7315 {
7316 WCHAR path[MAX_PATH];
7317 ACTCTXW actctx;
7318 HANDLE handle;
7319
7320 MultiByteToWideChar(CP_ACP, 0, file, -1, path, MAX_PATH);
7321 memset(&actctx, 0, sizeof(ACTCTXW));
7322 actctx.cbSize = sizeof(ACTCTXW);
7323 actctx.lpSource = path;
7324
7325 handle = pCreateActCtxW(&actctx);
7326 ok(handle != INVALID_HANDLE_VALUE, "failed to create context, error %u\n", GetLastError());
7327
7328 ok(actctx.cbSize == sizeof(actctx), "cbSize=%d\n", actctx.cbSize);
7329 ok(actctx.dwFlags == 0, "dwFlags=%d\n", actctx.dwFlags);
7330 ok(actctx.lpSource == path, "lpSource=%p\n", actctx.lpSource);
7331 ok(actctx.wProcessorArchitecture == 0, "wProcessorArchitecture=%d\n", actctx.wProcessorArchitecture);
7332 ok(actctx.wLangId == 0, "wLangId=%d\n", actctx.wLangId);
7333 ok(actctx.lpAssemblyDirectory == NULL, "lpAssemblyDirectory=%p\n", actctx.lpAssemblyDirectory);
7334 ok(actctx.lpResourceName == NULL, "lpResourceName=%p\n", actctx.lpResourceName);
7335 ok(actctx.lpApplicationName == NULL, "lpApplicationName=%p\n", actctx.lpApplicationName);
7336 ok(actctx.hModule == NULL, "hModule=%p\n", actctx.hModule);
7337
7338 return handle;
7339 }
7340
7341 static void test_interthread_messages(void)
7342 {
7343 HANDLE hThread, context, handle, event;
7344 ULONG_PTR cookie;
7345 DWORD tid;
7346 WNDPROC proc;
7347 MSG msg;
7348 char buf[256];
7349 int len, expected_len;
7350 struct wnd_event wnd_event;
7351 BOOL ret;
7352
7353 wnd_event.start_event = CreateEventW(NULL, 0, 0, NULL);
7354 if (!wnd_event.start_event)
7355 {
7356 win_skip("skipping interthread message test under win9x\n");
7357 return;
7358 }
7359
7360 hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
7361 ok(hThread != NULL, "CreateThread failed, error %d\n", GetLastError());
7362
7363 ok(WaitForSingleObject(wnd_event.start_event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7364
7365 CloseHandle(wnd_event.start_event);
7366
7367 SetLastError(0xdeadbeef);
7368 ok(!DestroyWindow(wnd_event.hwnd), "DestroyWindow succeeded\n");
7369 ok(GetLastError() == ERROR_ACCESS_DENIED || GetLastError() == 0xdeadbeef,
7370 "wrong error code %d\n", GetLastError());
7371
7372 proc = (WNDPROC)GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
7373 ok(proc != NULL, "GetWindowLongPtrA(GWLP_WNDPROC) error %d\n", GetLastError());
7374
7375 expected_len = lstrlenA("window caption text");
7376 memset(buf, 0, sizeof(buf));
7377 SetLastError(0xdeadbeef);
7378 len = CallWindowProcA(proc, wnd_event.hwnd, WM_GETTEXT, sizeof(buf), (LPARAM)buf);
7379 ok(len == expected_len, "CallWindowProcA(WM_GETTEXT) error %d, len %d, expected len %d\n", GetLastError(), len, expected_len);
7380 ok(!lstrcmpA(buf, "window caption text"), "window text mismatch\n");
7381
7382 msg.hwnd = wnd_event.hwnd;
7383 msg.message = WM_GETTEXT;
7384 msg.wParam = sizeof(buf);
7385 msg.lParam = (LPARAM)buf;
7386 memset(buf, 0, sizeof(buf));
7387 SetLastError(0xdeadbeef);
7388 len = DispatchMessageA(&msg);
7389 ok((!len && GetLastError() == ERROR_MESSAGE_SYNC_ONLY) || broken(len), /* nt4 */
7390 "DispatchMessageA(WM_GETTEXT) succeeded on another thread window: ret %d, error %d\n", len, GetLastError());
7391
7392 /* the following test causes an exception in user.exe under win9x */
7393 msg.hwnd = wnd_event.hwnd;
7394 msg.message = WM_TIMER;
7395 msg.wParam = 0;
7396 msg.lParam = GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
7397 SetLastError(0xdeadbeef);
7398 len = DispatchMessageA(&msg);
7399 ok(!len && GetLastError() == 0xdeadbeef,
7400 "DispatchMessageA(WM_TIMER) failed on another thread window: ret %d, error %d\n", len, GetLastError());
7401
7402 ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
7403 ok( ret, "PostMessageA(WM_QUIT) error %d\n", GetLastError());
7404
7405 ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7406 CloseHandle(hThread);
7407
7408 ok(!IsWindow(wnd_event.hwnd), "window should be destroyed on thread exit\n");
7409
7410 wnd_event.hwnd = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
7411 100, 100, 200, 200, 0, 0, 0, NULL);
7412 ok (wnd_event.hwnd != 0, "Failed to create parent window\n");
7413 flush_events();
7414 flush_sequence();
7415 log_all_parent_messages++;
7416 wnd_event.start_event = CreateEventA( NULL, TRUE, FALSE, NULL );
7417 wnd_event.stop_event = CreateEventA( NULL, TRUE, FALSE, NULL );
7418 hThread = CreateThread( NULL, 0, create_child_thread, &wnd_event, 0, &tid );
7419 for (;;)
7420 {
7421 ret = MsgWaitForMultipleObjects(1, &wnd_event.start_event, FALSE, 1000, QS_SENDMESSAGE);
7422 if (ret != 1) break;
7423 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
7424 }
7425 ok( !ret, "MsgWaitForMultipleObjects failed %x\n", ret );
7426 /* now wait for the thread without processing messages; this shouldn't deadlock */
7427 SetEvent( wnd_event.stop_event );
7428 ret = WaitForSingleObject( hThread, 5000 );
7429 ok( !ret, "WaitForSingleObject failed %x\n", ret );
7430 CloseHandle( hThread );
7431
7432 ret = WaitForSingleObject( wnd_event.grand_child, 5000 );
7433 ok( !ret, "WaitForSingleObject failed %x\n", ret );
7434 CloseHandle( wnd_event.grand_child );
7435
7436 CloseHandle( wnd_event.start_event );
7437 CloseHandle( wnd_event.stop_event );
7438 flush_events();
7439 ok_sequence(WmExitThreadSeq, "destroy child on thread exit", FALSE);
7440 log_all_parent_messages--;
7441 DestroyWindow( wnd_event.hwnd );
7442
7443 /* activation context tests */
7444 if (!pActivateActCtx)
7445 {
7446 win_skip("Activation contexts are not supported, skipping\n");
7447 return;
7448 }
7449
7450 create_manifest_file("testdep1.manifest", manifest_dep);
7451 create_manifest_file("main.manifest", manifest_main);
7452
7453 context = test_create("main.manifest");
7454 DeleteFileA("testdep1.manifest");
7455 DeleteFileA("main.manifest");
7456
7457 handle = (void*)0xdeadbeef;
7458 ret = pGetCurrentActCtx(&handle);
7459 ok(ret, "GetCurrentActCtx failed: %u\n", GetLastError());
7460 ok(handle == 0, "active context %p\n", handle);
7461
7462 wnd_event.start_event = CreateEventW(NULL, 0, 0, NULL);
7463 hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
7464 ok(hThread != NULL, "CreateThread failed, error %d\n", GetLastError());
7465 ok(WaitForSingleObject(wnd_event.start_event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7466 CloseHandle(wnd_event.start_event);
7467
7468 /* context is activated after thread creation, so it doesn't inherit it by default */
7469 ret = pActivateActCtx(context, &cookie);
7470 ok(ret, "activation failed: %u\n", GetLastError());
7471
7472 handle = 0;
7473 ret = pGetCurrentActCtx(&handle);
7474 ok(ret, "GetCurrentActCtx failed: %u\n", GetLastError());
7475 ok(handle != 0, "active context %p\n", handle);
7476 pReleaseActCtx(handle);
7477
7478 /* destination window will test for active context */
7479 ret = SendMessageA(wnd_event.hwnd, WM_USER+10, 0, 0);
7480 ok(ret, "thread window returned %d\n", ret);
7481
7482 event = CreateEventW(NULL, 0, 0, NULL);
7483 ret = PostMessageA(wnd_event.hwnd, WM_USER+10, 0, (LPARAM)event);
7484 ok(ret, "thread window returned %d\n", ret);
7485 ok(WaitForSingleObject(event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7486 CloseHandle(event);
7487
7488 ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
7489 ok(ret, "PostMessageA(WM_QUIT) error %d\n", GetLastError());
7490
7491 ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7492 CloseHandle(hThread);
7493
7494 ret = pDeactivateActCtx(0, cookie);
7495 ok(ret, "DeactivateActCtx failed: %u\n", GetLastError());
7496 pReleaseActCtx(context);
7497 }
7498
7499
7500 static const struct message WmVkN[] = {
7501 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
7502 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
7503 { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
7504 { WM_CHAR, wparam|lparam, 'n', 1 },
7505 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1002,1), 0 },
7506 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
7507 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
7508 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
7509 { 0 }
7510 };
7511 static const struct message WmShiftVkN[] = {
7512 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
7513 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
7514 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
7515 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
7516 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
7517 { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
7518 { WM_CHAR, wparam|lparam, 'N', 1 },
7519 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1001,1), 0 },
7520 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
7521 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
7522 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
7523 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xc0000001 }, /* XP */
7524 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
7525 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
7526 { 0 }
7527 };
7528 static const struct message WmCtrlVkN[] = {
7529 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
7530 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
7531 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
7532 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
7533 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
7534 { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
7535 { WM_CHAR, wparam|lparam, 0x000e, 1 },
7536 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
7537 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
7538 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
7539 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
7540 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
7541 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
7542 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
7543 { 0 }
7544 };
7545 static const struct message WmCtrlVkN_2[] = {
7546 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
7547 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
7548 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
7549 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
7550 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
7551 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
7552 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
7553 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
7554 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
7555 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
7556 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
7557 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
7558 { 0 }
7559 };
7560 static const struct message WmAltVkN[] = {
7561 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
7562 { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
7563 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
7564 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
7565 { WM_SYSKEYDOWN, wparam|lparam, 'N', 0x20000001 },
7566 { WM_SYSKEYDOWN, sent|wparam|lparam, 'N', 0x20000001 },
7567 { WM_SYSCHAR, wparam|lparam, 'n', 0x20000001 },
7568 { WM_SYSCHAR, sent|wparam|lparam, 'n', 0x20000001 },
7569 { WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 'n' },
7570 { HCBT_SYSCOMMAND, hook },
7571 { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
7572 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
7573 { 0x00AE, sent|defwinproc|optional }, /* XP */
7574 { WM_GETTEXT, sent|defwinproc|optional }, /* XP */
7575 { WM_INITMENU, sent|defwinproc },
7576 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
7577 { WM_MENUCHAR, sent|defwinproc|wparam, MAKEWPARAM('n',MF_SYSMENU) },
7578 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
7579 { WM_CAPTURECHANGED, sent|defwinproc },
7580 { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,0xffff) },
7581 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
7582 { WM_EXITMENULOOP, sent|defwinproc },
7583 { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) }, /* Win95 bug */
7584 { WM_EXITMENULOOP, sent|defwinproc|optional }, /* Win95 bug */
7585 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
7586 { WM_SYSKEYUP, wparam|lparam, 'N', 0xe0000001 },
7587 { WM_SYSKEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
7588 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
7589 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
7590 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
7591 { 0 }
7592 };
7593 static const struct message WmAltVkN_2[] = {
7594 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
7595 { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
7596 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
7597 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
7598 { WM_SYSKEYDOWN, wparam|lparam, 'N', 0x20000001 },
7599 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1003,1), 0 },
7600 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
7601 { WM_SYSKEYUP, wparam|lparam, 'N', 0xe0000001 },
7602 { WM_SYSKEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
7603 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
7604 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
7605 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
7606 { 0 }
7607 };
7608 static const struct message WmCtrlAltVkN[] = {
7609 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
7610 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
7611 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
7612 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
7613 { WM_KEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
7614 { WM_KEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
7615 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
7616 { WM_KEYDOWN, wparam|lparam, 'N', 0x20000001 },
7617 { WM_KEYDOWN, sent|wparam|lparam, 'N', 0x20000001 },
7618 { WM_CHAR, optional },
7619 { WM_CHAR, sent|optional },
7620 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
7621 { WM_KEYUP, wparam|lparam, 'N', 0xe0000001 },
7622 { WM_KEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
7623 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
7624 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
7625 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
7626 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
7627 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
7628 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
7629 { 0 }
7630 };
7631 static const struct message WmCtrlShiftVkN[] = {
7632 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
7633 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
7634 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
7635 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
7636 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
7637 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
7638 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
7639 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
7640 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1004,1), 0 },
7641 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
7642 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
7643 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
7644 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xc0000001 }, /* XP */
7645 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
7646 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
7647 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
7648 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
7649 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
7650 { 0 }
7651 };
7652 static const struct message WmCtrlAltShiftVkN[] = {
7653 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
7654 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
7655 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
7656 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
7657 { WM_KEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
7658 { WM_KEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
7659 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0x20000001 }, /* XP */
7660 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0x20000001 },
7661 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 0x20000001 },
7662 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
7663 { WM_KEYDOWN, wparam|lparam, 'N', 0x20000001 },
7664 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1005,1), 0 },
7665 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
7666 { WM_KEYUP, wparam|lparam, 'N', 0xe0000001 },
7667 { WM_KEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
7668 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xe0000001 }, /* XP */
7669 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xe0000001 },
7670 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xe0000001 },
7671 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
7672 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
7673 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
7674 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
7675 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
7676 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
7677 { 0 }
7678 };
7679 static const struct message WmAltPressRelease[] = {
7680 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
7681 { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
7682 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
7683 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
7684 { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
7685 { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
7686 { WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 0 },
7687 { HCBT_SYSCOMMAND, hook },
7688 { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
7689 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
7690 { WM_INITMENU, sent|defwinproc },
7691 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
7692 { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,MF_SYSMENU|MF_POPUP|MF_HILITE), 0, MAKEWPARAM(0,MF_RIGHTJUSTIFY) },
7693 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
7694
7695 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x30000001 }, /* XP */
7696
7697 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
7698 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0, },
7699 { WM_CAPTURECHANGED, sent|defwinproc },
7700 { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) },
7701 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
7702 { WM_EXITMENULOOP, sent|defwinproc },
7703 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
7704 { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
7705 { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
7706 { 0 }
7707 };
7708 static const struct message WmShiftMouseButton[] = {
7709 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
7710 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
7711 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
7712 { WM_MOUSEMOVE, wparam|optional, 0, 0 },
7713 { WM_MOUSEMOVE, sent|wparam|optional, 0, 0 },
7714 { WM_LBUTTONDOWN, wparam, MK_LBUTTON|MK_SHIFT, 0 },
7715 { WM_LBUTTONDOWN, sent|wparam, MK_LBUTTON|MK_SHIFT, 0 },
7716 { WM_LBUTTONUP, wparam, MK_SHIFT, 0 },
7717 { WM_LBUTTONUP, sent|wparam, MK_SHIFT, 0 },
7718 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xc0000001 }, /* XP */
7719 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
7720 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
7721 { 0 }
7722 };
7723 static const struct message WmF1Seq[] = {
7724 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F1, 1 }, /* XP */
7725 { WM_KEYDOWN, wparam|lparam, VK_F1, 1 },
7726 { WM_KEYDOWN, sent|wparam|lparam, VK_F1, 0x00000001 },
7727 { WM_KEYF1, wparam|lparam, 0, 0 },
7728 { WM_KEYF1, sent|wparam|lparam, 0, 0 },
7729 { WM_HELP, sent|defwinproc },
7730 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F1, 0xc0000001 }, /* XP */
7731 { WM_KEYUP, wparam|lparam, VK_F1, 0xc0000001 },
7732 { WM_KEYUP, sent|wparam|lparam, VK_F1, 0xc0000001 },
7733 { 0 }
7734 };
7735 static const struct message WmVkAppsSeq[] = {
7736 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_APPS, 1 }, /* XP */
7737 { WM_KEYDOWN, wparam|lparam, VK_APPS, 1 },
7738 { WM_KEYDOWN, sent|wparam|lparam, VK_APPS, 0x00000001 },
7739 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_APPS, 0xc0000001 }, /* XP */
7740 { WM_KEYUP, wparam|lparam, VK_APPS, 0xc0000001 },
7741 { WM_KEYUP, sent|wparam|lparam, VK_APPS, 0xc0000001 },
7742 { WM_CONTEXTMENU, lparam, /*hwnd*/0, -1 },
7743 { WM_CONTEXTMENU, sent|lparam, /*hwnd*/0, -1 },
7744 { 0 }
7745 };
7746 static const struct message WmVkF10Seq[] = {
7747 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 1 }, /* XP */
7748 { WM_SYSKEYDOWN, wparam|lparam, VK_F10, 1 },
7749 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_F10, 0x00000001 },
7750 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 0xc0000001 }, /* XP */
7751 { WM_SYSKEYUP, wparam|lparam, VK_F10, 0xc0000001 },
7752 { WM_SYSKEYUP, sent|wparam|lparam, VK_F10, 0xc0000001 },
7753 { WM_SYSCOMMAND, sent|defwinproc|wparam, SC_KEYMENU },
7754 { HCBT_SYSCOMMAND, hook },
7755 { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
7756 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
7757 { WM_INITMENU, sent|defwinproc },
7758 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
7759 { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,MF_SYSMENU|MF_POPUP|MF_HILITE), 0, MAKEWPARAM(0,MF_RIGHTJUSTIFY) },
7760 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
7761
7762 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 0x10000001 }, /* XP */
7763
7764 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 1 }, /* XP */
7765 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
7766 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0, },
7767 { WM_CAPTURECHANGED, sent|defwinproc },
7768 { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) },
7769 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
7770 { WM_EXITMENULOOP, sent|defwinproc },
7771 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 0xc0000001 }, /* XP */
7772 { WM_SYSKEYUP, wparam|lparam, VK_F10, 0xc0000001 },
7773 { WM_SYSKEYUP, sent|wparam|lparam, VK_F10, 0xc0000001 },
7774 { 0 }
7775 };
7776 static const struct message WmShiftF10Seq[] = {
7777 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
7778 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
7779 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 0x00000001 },
7780 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 1 }, /* XP */
7781 { WM_SYSKEYDOWN, wparam|lparam, VK_F10, 1 },
7782 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_F10, 0x00000001 },
7783 { WM_CONTEXTMENU, sent|defwinproc|lparam, /*hwnd*/0, -1 },
7784 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 0xc0000001 }, /* XP */
7785 { WM_SYSKEYUP, wparam|lparam, VK_F10, 0xc0000001 },
7786 { WM_SYSKEYUP, sent|wparam|lparam, VK_F10, 0xc0000001 },
7787 { WM_SYSCOMMAND, sent|defwinproc|wparam, SC_KEYMENU },
7788 { HCBT_SYSCOMMAND, hook },
7789 { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
7790 { WM_INITMENU, sent|defwinproc },
7791 { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,MF_SYSMENU|MF_POPUP|MF_HILITE), 0, MAKEWPARAM(0,MF_RIGHTJUSTIFY) },
7792 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xd0000001 }, /* XP */
7793 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_ESCAPE, 0x10000001 }, /* XP */
7794 { WM_CAPTURECHANGED, sent|defwinproc|wparam|lparam, 0, 0 },
7795 { WM_MENUSELECT, sent|defwinproc|wparam|lparam, 0xffff0000, 0 },
7796 { WM_EXITMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
7797 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_ESCAPE, 0xc0000001 }, /* XP */
7798 { WM_KEYUP, wparam|lparam, VK_ESCAPE, 0xc0000001 },
7799 { WM_KEYUP, sent|wparam|lparam, VK_ESCAPE, 0xc0000001 },
7800 { 0 }
7801 };
7802
7803 static void pump_msg_loop(HWND hwnd, HACCEL hAccel)
7804 {
7805 MSG msg;
7806
7807 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
7808 {
7809 struct recvd_message log_msg;
7810
7811 /* ignore some unwanted messages */
7812 if (msg.message == WM_MOUSEMOVE ||
7813 msg.message == WM_TIMER ||
7814 ignore_message( msg.message ))
7815 continue;
7816
7817 log_msg.hwnd = msg.hwnd;
7818 log_msg.message = msg.message;
7819 log_msg.flags = wparam|lparam;
7820 log_msg.wParam = msg.wParam;
7821 log_msg.lParam = msg.lParam;
7822 log_msg.descr = "accel";
7823 add_message(&log_msg);
7824
7825 if (!hAccel || !TranslateAcceleratorA(hwnd, hAccel, &msg))
7826 {
7827 TranslateMessage(&msg);
7828 DispatchMessageA(&msg);
7829 }
7830 }
7831 }
7832
7833 static void test_accelerators(void)
7834 {
7835 RECT rc;
7836 POINT pt;
7837 SHORT state;
7838 HACCEL hAccel;
7839 HWND hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
7840 100, 100, 200, 200, 0, 0, 0, NULL);
7841 BOOL ret;
7842
7843 assert(hwnd != 0);
7844 UpdateWindow(hwnd);
7845 flush_events();
7846 flush_sequence();
7847
7848 SetFocus(hwnd);
7849 ok(GetFocus() == hwnd, "wrong focus window %p\n", GetFocus());
7850
7851 state = GetKeyState(VK_SHIFT);
7852 ok(!(state & 0x8000), "wrong Shift state %04x\n", state);
7853 state = GetKeyState(VK_CAPITAL);
7854 ok(state == 0, "wrong CapsLock state %04x\n", state);
7855
7856 hAccel = LoadAcceleratorsA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(1));
7857 assert(hAccel != 0);
7858
7859 flush_events();
7860 pump_msg_loop(hwnd, 0);
7861 flush_sequence();
7862
7863 trace("testing VK_N press/release\n");
7864 flush_sequence();
7865 keybd_event('N', 0, 0, 0);
7866 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7867 pump_msg_loop(hwnd, hAccel);
7868 if (!sequence_cnt) /* we didn't get any message */
7869 {
7870 skip( "queuing key events not supported\n" );
7871 goto done;
7872 }
7873 ok_sequence(WmVkN, "VK_N press/release", FALSE);
7874
7875 trace("testing Shift+VK_N press/release\n");
7876 flush_sequence();
7877 keybd_event(VK_SHIFT, 0, 0, 0);
7878 keybd_event('N', 0, 0, 0);
7879 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7880 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
7881 pump_msg_loop(hwnd, hAccel);
7882 ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
7883
7884 trace("testing Ctrl+VK_N press/release\n");
7885 flush_sequence();
7886 keybd_event(VK_CONTROL, 0, 0, 0);
7887 keybd_event('N', 0, 0, 0);
7888 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7889 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
7890 pump_msg_loop(hwnd, hAccel);
7891 ok_sequence(WmCtrlVkN, "Ctrl+VK_N press/release", FALSE);
7892
7893 trace("testing Alt+VK_N press/release\n");
7894 flush_sequence();
7895 keybd_event(VK_MENU, 0, 0, 0);
7896 keybd_event('N', 0, 0, 0);
7897 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7898 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
7899 pump_msg_loop(hwnd, hAccel);
7900 ok_sequence(WmAltVkN, "Alt+VK_N press/release", FALSE);
7901
7902 trace("testing Ctrl+Alt+VK_N press/release 1\n");
7903 flush_sequence();
7904 keybd_event(VK_CONTROL, 0, 0, 0);
7905 keybd_event(VK_MENU, 0, 0, 0);
7906 keybd_event('N', 0, 0, 0);
7907 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7908 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
7909 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
7910 pump_msg_loop(hwnd, hAccel);
7911 ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 1", FALSE);
7912
7913 ret = DestroyAcceleratorTable(hAccel);
7914 ok( ret, "DestroyAcceleratorTable error %d\n", GetLastError());
7915
7916 hAccel = LoadAcceleratorsA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(2));
7917 assert(hAccel != 0);
7918
7919 trace("testing VK_N press/release\n");
7920 flush_sequence();
7921 keybd_event('N', 0, 0, 0);
7922 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7923 pump_msg_loop(hwnd, hAccel);
7924 ok_sequence(WmVkN, "VK_N press/release", FALSE);
7925
7926 trace("testing Shift+VK_N press/release\n");
7927 flush_sequence();
7928 keybd_event(VK_SHIFT, 0, 0, 0);
7929 keybd_event('N', 0, 0, 0);
7930 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7931 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
7932 pump_msg_loop(hwnd, hAccel);
7933 ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
7934
7935 trace("testing Ctrl+VK_N press/release 2\n");
7936 flush_sequence();
7937 keybd_event(VK_CONTROL, 0, 0, 0);
7938 keybd_event('N', 0, 0, 0);
7939 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7940 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
7941 pump_msg_loop(hwnd, hAccel);
7942 ok_sequence(WmCtrlVkN_2, "Ctrl+VK_N press/release 2", FALSE);
7943
7944 trace("testing Alt+VK_N press/release 2\n");
7945 flush_sequence();
7946 keybd_event(VK_MENU, 0, 0, 0);
7947 keybd_event('N', 0, 0, 0);
7948 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7949 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
7950 pump_msg_loop(hwnd, hAccel);
7951 ok_sequence(WmAltVkN_2, "Alt+VK_N press/release 2", FALSE);
7952
7953 trace("testing Ctrl+Alt+VK_N press/release 2\n");
7954 flush_sequence();
7955 keybd_event(VK_CONTROL, 0, 0, 0);
7956 keybd_event(VK_MENU, 0, 0, 0);
7957 keybd_event('N', 0, 0, 0);
7958 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7959 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
7960 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
7961 pump_msg_loop(hwnd, hAccel);
7962 ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 2", FALSE);
7963
7964 trace("testing Ctrl+Shift+VK_N press/release\n");
7965 flush_sequence();
7966 keybd_event(VK_CONTROL, 0, 0, 0);
7967 keybd_event(VK_SHIFT, 0, 0, 0);
7968 keybd_event('N', 0, 0, 0);
7969 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7970 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
7971 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
7972 pump_msg_loop(hwnd, hAccel);
7973 ok_sequence(WmCtrlShiftVkN, "Ctrl+Shift+VK_N press/release", FALSE);
7974
7975 trace("testing Ctrl+Alt+Shift+VK_N press/release\n");
7976 flush_sequence();
7977 keybd_event(VK_CONTROL, 0, 0, 0);
7978 keybd_event(VK_MENU, 0, 0, 0);
7979 keybd_event(VK_SHIFT, 0, 0, 0);
7980 keybd_event('N', 0, 0, 0);
7981 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7982 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
7983 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
7984 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
7985 pump_msg_loop(hwnd, hAccel);
7986 ok_sequence(WmCtrlAltShiftVkN, "Ctrl+Alt+Shift+VK_N press/release", FALSE);
7987
7988 ret = DestroyAcceleratorTable(hAccel);
7989 ok( ret, "DestroyAcceleratorTable error %d\n", GetLastError());
7990 hAccel = 0;
7991
7992 trace("testing Alt press/release\n");
7993 flush_sequence();
7994 keybd_event(VK_MENU, 0, 0, 0);
7995 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
7996 keybd_event(VK_MENU, 0, 0, 0);
7997 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
7998 pump_msg_loop(hwnd, 0);
7999 /* this test doesn't pass in Wine for managed windows */
8000 ok_sequence(WmAltPressRelease, "Alt press/release", TRUE);
8001
8002 trace("testing VK_F1 press/release\n");
8003 keybd_event(VK_F1, 0, 0, 0);
8004 keybd_event(VK_F1, 0, KEYEVENTF_KEYUP, 0);
8005 pump_msg_loop(hwnd, 0);
8006 ok_sequence(WmF1Seq, "F1 press/release", FALSE);
8007
8008 trace("testing VK_APPS press/release\n");
8009 keybd_event(VK_APPS, 0, 0, 0);
8010 keybd_event(VK_APPS, 0, KEYEVENTF_KEYUP, 0);
8011 pump_msg_loop(hwnd, 0);
8012 ok_sequence(WmVkAppsSeq, "VK_APPS press/release", FALSE);
8013
8014 trace("testing VK_F10 press/release\n");
8015 keybd_event(VK_F10, 0, 0, 0);
8016 keybd_event(VK_F10, 0, KEYEVENTF_KEYUP, 0);
8017 keybd_event(VK_F10, 0, 0, 0);
8018 keybd_event(VK_F10, 0, KEYEVENTF_KEYUP, 0);
8019 pump_msg_loop(hwnd, 0);
8020 ok_sequence(WmVkF10Seq, "VK_F10 press/release", TRUE);
8021
8022 trace("testing SHIFT+F10 press/release\n");
8023 keybd_event(VK_SHIFT, 0, 0, 0);
8024 keybd_event(VK_F10, 0, 0, 0);
8025 keybd_event(VK_F10, 0, KEYEVENTF_KEYUP, 0);
8026 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
8027 keybd_event(VK_ESCAPE, 0, 0, 0);
8028 keybd_event(VK_ESCAPE, 0, KEYEVENTF_KEYUP, 0);
8029 pump_msg_loop(hwnd, 0);
8030 ok_sequence(WmShiftF10Seq, "SHIFT+F10 press/release", TRUE);
8031
8032 trace("testing Shift+MouseButton press/release\n");
8033 /* first, move mouse pointer inside of the window client area */
8034 GetClientRect(hwnd, &rc);
8035 MapWindowPoints(hwnd, 0, (LPPOINT)&rc, 2);
8036 rc.left += (rc.right - rc.left)/2;
8037 rc.top += (rc.bottom - rc.top)/2;
8038 SetCursorPos(rc.left, rc.top);
8039 SetActiveWindow(hwnd);
8040
8041 flush_events();
8042 flush_sequence();
8043 GetCursorPos(&pt);
8044 if (pt.x == rc.left && pt.y == rc.top)
8045 {
8046 int i;
8047 keybd_event(VK_SHIFT, 0, 0, 0);
8048 mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
8049 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
8050 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
8051 pump_msg_loop(hwnd, 0);
8052 for (i = 0; i < sequence_cnt; i++) if (sequence[i].message == WM_LBUTTONDOWN) break;
8053 if (i < sequence_cnt)
8054 ok_sequence(WmShiftMouseButton, "Shift+MouseButton press/release", FALSE);
8055 else
8056 skip( "Shift+MouseButton event didn't get to the window\n" );
8057 }
8058
8059 done:
8060 if (hAccel) DestroyAcceleratorTable(hAccel);
8061 DestroyWindow(hwnd);
8062 }
8063
8064 /************* window procedures ********************/
8065
8066 static LRESULT MsgCheckProc (BOOL unicode, HWND hwnd, UINT message,
8067 WPARAM wParam, LPARAM lParam)
8068 {
8069 static LONG defwndproc_counter = 0;
8070 static LONG beginpaint_counter = 0;
8071 LRESULT ret;
8072 struct recvd_message msg;
8073
8074 if (ignore_message( message )) return 0;
8075
8076 switch (message)
8077 {
8078 case WM_ENABLE:
8079 {
8080 LONG style = GetWindowLongA(hwnd, GWL_STYLE);
8081 ok((BOOL)wParam == !(style & WS_DISABLED),
8082 "wrong WS_DISABLED state: %ld != %d\n", wParam, !(style & WS_DISABLED));
8083 break;
8084 }
8085
8086 case WM_CAPTURECHANGED:
8087 if (test_DestroyWindow_flag)
8088 {
8089 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
8090 if (style & WS_CHILD)
8091 lParam = GetWindowLongPtrA(hwnd, GWLP_ID);
8092 else if (style & WS_POPUP)
8093 lParam = WND_POPUP_ID;
8094 else
8095 lParam = WND_PARENT_ID;
8096 }
8097 break;
8098
8099 case WM_NCDESTROY:
8100 {
8101 HWND capture;
8102
8103 ok(!GetWindow(hwnd, GW_CHILD), "children should be unlinked at this point\n");
8104 capture = GetCapture();
8105 if (capture)
8106 {
8107 ok(capture == hwnd, "capture should NOT be released at this point (capture %p)\n", capture);
8108 trace("current capture %p, releasing...\n", capture);
8109 ReleaseCapture();
8110 }
8111 }
8112 /* fall through */
8113 case WM_DESTROY:
8114 if (pGetAncestor)
8115 ok(pGetAncestor(hwnd, GA_PARENT) != 0, "parent should NOT be unlinked at this point\n");
8116 if (test_DestroyWindow_flag)
8117 {
8118 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
8119 if (style & WS_CHILD)
8120 lParam = GetWindowLongPtrA(hwnd, GWLP_ID);
8121 else if (style & WS_POPUP)
8122 lParam = WND_POPUP_ID;
8123 else
8124 lParam = WND_PARENT_ID;
8125 }
8126 break;
8127
8128 /* test_accelerators() depends on this */
8129 case WM_NCHITTEST:
8130 return HTCLIENT;
8131
8132 case WM_USER+10:
8133 {
8134 ACTIVATION_CONTEXT_BASIC_INFORMATION basicinfo;
8135 HANDLE handle, event = (HANDLE)lParam;
8136 BOOL ret;
8137
8138 handle = (void*)0xdeadbeef;
8139 ret = pGetCurrentActCtx(&handle);
8140 ok(ret, "failed to get current context, %u\n", GetLastError());
8141 ok(handle == 0, "got active context %p\n", handle);
8142
8143 memset(&basicinfo, 0xff, sizeof(basicinfo));
8144 ret = pQueryActCtxW(QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX, handle, 0, ActivationContextBasicInformation,
8145 &basicinfo, sizeof(basicinfo), NULL);
8146 ok(ret, "got %d, error %d\n", ret, GetLastError());
8147 ok(basicinfo.hActCtx == NULL, "got %p\n", basicinfo.hActCtx);
8148 ok(basicinfo.dwFlags == 0, "got %x\n", basicinfo.dwFlags);
8149
8150 if (event) SetEvent(event);
8151 return 1;
8152 }
8153
8154 /* ignore */
8155 case WM_MOUSEMOVE:
8156 case WM_MOUSEACTIVATE:
8157 case WM_NCMOUSEMOVE:
8158 case WM_SETCURSOR:
8159 case WM_IME_SELECT:
8160 return 0;
8161 }
8162
8163 msg.hwnd = hwnd;
8164 msg.message = message;
8165 msg.flags = sent|wparam|lparam;
8166 if (defwndproc_counter) msg.flags |= defwinproc;
8167 if (beginpaint_counter) msg.flags |= beginpaint;
8168 msg.wParam = wParam;
8169 msg.lParam = lParam;
8170 msg.descr = "MsgCheckProc";
8171 add_message(&msg);
8172
8173 if (message == WM_GETMINMAXINFO && (GetWindowLongA(hwnd, GWL_STYLE) & WS_CHILD))
8174 {
8175 HWND parent = GetParent(hwnd);
8176 RECT rc;
8177 MINMAXINFO *minmax = (MINMAXINFO *)lParam;
8178
8179 GetClientRect(parent, &rc);
8180 trace("parent %p client size = (%d x %d)\n", parent, rc.right, rc.bottom);
8181 trace("Reserved=%d,%d MaxSize=%d,%d MaxPos=%d,%d MinTrack=%d,%d MaxTrack=%d,%d\n",
8182 minmax->ptReserved.x, minmax->ptReserved.y,
8183 minmax->ptMaxSize.x, minmax->ptMaxSize.y,
8184 minmax->ptMaxPosition.x, minmax->ptMaxPosition.y,
8185 minmax->ptMinTrackSize.x, minmax->ptMinTrackSize.y,
8186 minmax->ptMaxTrackSize.x, minmax->ptMaxTrackSize.y);
8187
8188 ok(minmax->ptMaxSize.x == rc.right, "default width of maximized child %d != %d\n",
8189 minmax->ptMaxSize.x, rc.right);
8190 ok(minmax->ptMaxSize.y == rc.bottom, "default height of maximized child %d != %d\n",
8191 minmax->ptMaxSize.y, rc.bottom);
8192 }
8193
8194 if (message == WM_PAINT)
8195 {
8196 PAINTSTRUCT ps;
8197 beginpaint_counter++;
8198 BeginPaint( hwnd, &ps );
8199 beginpaint_counter--;
8200 EndPaint( hwnd, &ps );
8201 return 0;
8202 }
8203
8204 defwndproc_counter++;
8205 ret = unicode ? DefWindowProcW(hwnd, message, wParam, lParam)
8206 : DefWindowProcA(hwnd, message, wParam, lParam);
8207 defwndproc_counter--;
8208
8209 return ret;
8210 }
8211
8212 static LRESULT WINAPI MsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8213 {
8214 return MsgCheckProc (FALSE, hwnd, message, wParam, lParam);
8215 }
8216
8217 static LRESULT WINAPI MsgCheckProcW(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8218 {
8219 return MsgCheckProc (TRUE, hwnd, message, wParam, lParam);
8220 }
8221
8222 static LRESULT WINAPI PopupMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8223 {
8224 static LONG defwndproc_counter = 0;
8225 LRESULT ret;
8226 struct recvd_message msg;
8227
8228 if (ignore_message( message )) return 0;
8229
8230 switch (message)
8231 {
8232 case WM_QUERYENDSESSION:
8233 case WM_ENDSESSION:
8234 lParam &= ~0x01; /* Vista adds a 0x01 flag */
8235 break;
8236 }
8237
8238 msg.hwnd = hwnd;
8239 msg.message = message;
8240 msg.flags = sent|wparam|lparam;
8241 if (defwndproc_counter) msg.flags |= defwinproc;
8242 msg.wParam = wParam;
8243 msg.lParam = lParam;
8244 msg.descr = "popup";
8245 add_message(&msg);
8246
8247 if (message == WM_CREATE)
8248 {
8249 DWORD style = GetWindowLongA(hwnd, GWL_STYLE) | WS_VISIBLE;
8250 SetWindowLongA(hwnd, GWL_STYLE, style);
8251 }
8252
8253 defwndproc_counter++;
8254 ret = DefWindowProcA(hwnd, message, wParam, lParam);
8255 defwndproc_counter--;
8256
8257 return ret;
8258 }
8259
8260 static LRESULT WINAPI ParentMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8261 {
8262 static LONG defwndproc_counter = 0;
8263 static LONG beginpaint_counter = 0;
8264 LRESULT ret;
8265 struct recvd_message msg;
8266
8267 if (ignore_message( message )) return 0;
8268
8269 if (log_all_parent_messages ||
8270 message == WM_PARENTNOTIFY || message == WM_CANCELMODE ||
8271 message == WM_SETFOCUS || message == WM_KILLFOCUS ||
8272 message == WM_ENABLE || message == WM_ENTERIDLE ||
8273 message == WM_DRAWITEM || message == WM_COMMAND ||
8274 message == WM_IME_SETCONTEXT)
8275 {
8276 switch (message)
8277 {
8278 /* ignore */
8279 case WM_NCHITTEST:
8280 return HTCLIENT;
8281 case WM_SETCURSOR:
8282 case WM_MOUSEMOVE:
8283 case WM_NCMOUSEMOVE:
8284 return 0;
8285
8286 case WM_ERASEBKGND:
8287 {
8288 RECT rc;
8289 INT ret = GetClipBox((HDC)wParam, &rc);
8290
8291 trace("WM_ERASEBKGND: GetClipBox()=%d, (%d,%d-%d,%d)\n",
8292 ret, rc.left, rc.top, rc.right, rc.bottom);
8293 break;
8294 }
8295 }
8296
8297 msg.hwnd = hwnd;
8298 msg.message = message;
8299 msg.flags = sent|parent|wparam|lparam;
8300 if (defwndproc_counter) msg.flags |= defwinproc;
8301 if (beginpaint_counter) msg.flags |= beginpaint;
8302 msg.wParam = wParam;
8303 msg.lParam = lParam;
8304 msg.descr = "parent";
8305 add_message(&msg);
8306 }
8307
8308 if (message == WM_PAINT)
8309 {
8310 PAINTSTRUCT ps;
8311 beginpaint_counter++;
8312 BeginPaint( hwnd, &ps );
8313 beginpaint_counter--;
8314 EndPaint( hwnd, &ps );
8315 return 0;
8316 }
8317
8318 defwndproc_counter++;
8319 ret = DefWindowProcA(hwnd, message, wParam, lParam);
8320 defwndproc_counter--;
8321
8322 return ret;
8323 }
8324
8325 static INT_PTR CALLBACK StopQuitMsgCheckProcA(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
8326 {
8327 if (message == WM_CREATE)
8328 PostMessageA(hwnd, WM_CLOSE, 0, 0);
8329 else if (message == WM_CLOSE)
8330 {
8331 /* Only the first WM_QUIT will survive the window destruction */
8332 PostMessageA(hwnd, WM_USER, 0x1234, 0x5678);
8333 PostMessageA(hwnd, WM_QUIT, 0x1234, 0x5678);
8334 PostMessageA(hwnd, WM_QUIT, 0x4321, 0x8765);
8335 }
8336
8337 return DefWindowProcA(hwnd, message, wp, lp);
8338 }
8339
8340 static LRESULT WINAPI TestDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8341 {
8342 static LONG defwndproc_counter = 0;
8343 LRESULT ret;
8344 struct recvd_message msg;
8345
8346 if (ignore_message( message )) return 0;
8347
8348 if (test_def_id)
8349 {
8350 DefDlgProcA(hwnd, DM_SETDEFID, 1, 0);
8351 ret = DefDlgProcA(hwnd, DM_GETDEFID, 0, 0);
8352 if (after_end_dialog)
8353 ok( ret == 0, "DM_GETDEFID should return 0 after EndDialog, got %lx\n", ret );
8354 else
8355 ok(HIWORD(ret) == DC_HASDEFID, "DM_GETDEFID should return DC_HASDEFID, got %lx\n", ret);
8356 }
8357
8358 msg.hwnd = hwnd;
8359 msg.message = message;
8360 msg.flags = sent|wparam|lparam;
8361 if (defwndproc_counter) msg.flags |= defwinproc;
8362 msg.wParam = wParam;
8363 msg.lParam = lParam;
8364 msg.descr = "dialog";
8365 add_message(&msg);
8366
8367 defwndproc_counter++;
8368 ret = DefDlgProcA(hwnd, message, wParam, lParam);
8369 defwndproc_counter--;
8370
8371 return ret;
8372 }
8373
8374 static LRESULT WINAPI ShowWindowProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8375 {
8376 static LONG defwndproc_counter = 0;
8377 LRESULT ret;
8378 struct recvd_message msg;
8379
8380 /* log only specific messages we are interested in */
8381 switch (message)
8382 {
8383 #if 0 /* probably log these as well */
8384 case WM_ACTIVATE:
8385 case WM_SETFOCUS:
8386 case WM_KILLFOCUS:
8387 #endif
8388 case WM_SHOWWINDOW:
8389 case WM_SIZE:
8390 case WM_MOVE:
8391 case WM_GETMINMAXINFO:
8392 case WM_WINDOWPOSCHANGING:
8393 case WM_WINDOWPOSCHANGED:
8394 break;
8395
8396 default: /* ignore */
8397 /*trace("showwindow: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);*/
8398 return DefWindowProcA(hwnd, message, wParam, lParam);
8399 }
8400
8401 msg.hwnd = hwnd;
8402 msg.message = message;
8403 msg.flags = sent|wparam|lparam;
8404 if (defwndproc_counter) msg.flags |= defwinproc;
8405 msg.wParam = wParam;
8406 msg.lParam = lParam;
8407 msg.descr = "show";
8408 add_message(&msg);
8409
8410 defwndproc_counter++;
8411 ret = DefWindowProcA(hwnd, message, wParam, lParam);
8412 defwndproc_counter--;
8413
8414 return ret;
8415 }
8416
8417 static LRESULT WINAPI PaintLoopProcA(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
8418 {
8419 switch (msg)
8420 {
8421 case WM_CREATE: return 0;
8422 case WM_PAINT:
8423 {
8424 MSG msg2;
8425 static int i = 0;
8426
8427 if (i < 256)
8428 {
8429 i++;
8430 if (PeekMessageA(&msg2, 0, 0, 0, 1))
8431 {
8432 TranslateMessage(&msg2);
8433 DispatchMessageA(&msg2);
8434 }
8435 i--;
8436 }
8437 else ok(broken(1), "infinite loop\n");
8438 if ( i == 0)
8439 paint_loop_done = TRUE;
8440 return DefWindowProcA(hWnd,msg,wParam,lParam);
8441 }
8442 }
8443 return DefWindowProcA(hWnd,msg,wParam,lParam);
8444 }
8445
8446 static LRESULT WINAPI HotkeyMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8447 {
8448 static LONG defwndproc_counter = 0;
8449 LRESULT ret;
8450 struct recvd_message msg;
8451 DWORD queue_status;
8452
8453 if (ignore_message( message )) return 0;
8454
8455 if ((message >= WM_KEYFIRST && message <= WM_KEYLAST) ||
8456 message == WM_HOTKEY || message >= WM_APP)
8457 {
8458 msg.hwnd = hwnd;
8459 msg.message = message;
8460 msg.flags = sent|wparam|lparam;
8461 if (defwndproc_counter) msg.flags |= defwinproc;
8462 msg.wParam = wParam;
8463 msg.lParam = lParam;
8464 msg.descr = "HotkeyMsgCheckProcA";
8465 add_message(&msg);
8466 }
8467
8468 defwndproc_counter++;
8469 ret = DefWindowProcA(hwnd, message, wParam, lParam);
8470 defwndproc_counter--;
8471
8472 if (message == WM_APP)
8473 {
8474 queue_status = GetQueueStatus(QS_HOTKEY);
8475 ok((queue_status & (QS_HOTKEY << 16)) == QS_HOTKEY << 16, "expected QS_HOTKEY << 16 set, got %x\n", queue_status);
8476 queue_status = GetQueueStatus(QS_POSTMESSAGE);
8477 ok((queue_status & (QS_POSTMESSAGE << 16)) == QS_POSTMESSAGE << 16, "expected QS_POSTMESSAGE << 16 set, got %x\n", queue_status);
8478 PostMessageA(hwnd, WM_APP+1, 0, 0);
8479 }
8480 else if (message == WM_APP+1)
8481 {
8482 queue_status = GetQueueStatus(QS_HOTKEY);
8483 ok((queue_status & (QS_HOTKEY << 16)) == 0, "expected QS_HOTKEY << 16 cleared, got %x\n", queue_status);
8484 }
8485
8486 return ret;
8487 }
8488
8489 static BOOL RegisterWindowClasses(void)
8490 {
8491 WNDCLASSA cls;
8492 WNDCLASSW clsW;
8493
8494 cls.style = 0;
8495 cls.lpfnWndProc = MsgCheckProcA;
8496 cls.cbClsExtra = 0;
8497 cls.cbWndExtra = 0;
8498 cls.hInstance = GetModuleHandleA(0);
8499 cls.hIcon = 0;
8500 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
8501 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
8502 cls.lpszMenuName = NULL;
8503 cls.lpszClassName = "TestWindowClass";
8504 if(!RegisterClassA(&cls)) return FALSE;
8505
8506 cls.lpfnWndProc = HotkeyMsgCheckProcA;
8507 cls.lpszClassName = "HotkeyWindowClass";
8508 if(!RegisterClassA(&cls)) return FALSE;
8509
8510 cls.lpfnWndProc = ShowWindowProcA;
8511 cls.lpszClassName = "ShowWindowClass";
8512 if(!RegisterClassA(&cls)) return FALSE;
8513
8514 cls.lpfnWndProc = PopupMsgCheckProcA;
8515 cls.lpszClassName = "TestPopupClass";
8516 if(!RegisterClassA(&cls)) return FALSE;
8517
8518 cls.lpfnWndProc = ParentMsgCheckProcA;
8519 cls.lpszClassName = "TestParentClass";
8520 if(!RegisterClassA(&cls)) return FALSE;
8521
8522 cls.lpfnWndProc = StopQuitMsgCheckProcA;
8523 cls.lpszClassName = "StopQuitClass";
8524 if(!RegisterClassA(&cls)) return FALSE;
8525
8526 cls.lpfnWndProc = DefWindowProcA;
8527 cls.lpszClassName = "SimpleWindowClass";
8528 if(!RegisterClassA(&cls)) return FALSE;
8529
8530 cls.lpfnWndProc = PaintLoopProcA;
8531 cls.lpszClassName = "PaintLoopWindowClass";
8532 if(!RegisterClassA(&cls)) return FALSE;
8533
8534 cls.style = CS_NOCLOSE;
8535 cls.lpszClassName = "NoCloseWindowClass";
8536 if(!RegisterClassA(&cls)) return FALSE;
8537
8538 ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
8539 cls.style = 0;
8540 cls.hInstance = GetModuleHandleA(0);
8541 cls.hbrBackground = 0;
8542 cls.lpfnWndProc = TestDlgProcA;
8543 cls.lpszClassName = "TestDialogClass";
8544 if(!RegisterClassA(&cls)) return FALSE;
8545
8546 clsW.style = 0;
8547 clsW.lpfnWndProc = MsgCheckProcW;
8548 clsW.cbClsExtra = 0;
8549 clsW.cbWndExtra = 0;
8550 clsW.hInstance = GetModuleHandleW(0);
8551 clsW.hIcon = 0;
8552 clsW.hCursor = LoadCursorW(0, (LPWSTR)IDC_ARROW);
8553 clsW.hbrBackground = GetStockObject(WHITE_BRUSH);
8554 clsW.lpszMenuName = NULL;
8555 clsW.lpszClassName = testWindowClassW;
8556 RegisterClassW(&clsW); /* ignore error, this fails on Win9x */
8557
8558 return TRUE;
8559 }
8560
8561 static BOOL is_our_logged_class(HWND hwnd)
8562 {
8563 char buf[256];
8564
8565 if (GetClassNameA(hwnd, buf, sizeof(buf)))
8566 {
8567 if (!lstrcmpiA(buf, "TestWindowClass") ||
8568 !lstrcmpiA(buf, "ShowWindowClass") ||
8569 !lstrcmpiA(buf, "TestParentClass") ||
8570 !lstrcmpiA(buf, "TestPopupClass") ||
8571 !lstrcmpiA(buf, "SimpleWindowClass") ||
8572 !lstrcmpiA(buf, "TestDialogClass") ||
8573 !lstrcmpiA(buf, "MDI_frame_class") ||
8574 !lstrcmpiA(buf, "MDI_client_class") ||
8575 !lstrcmpiA(buf, "MDI_child_class") ||
8576 !lstrcmpiA(buf, "my_button_class") ||
8577 !lstrcmpiA(buf, "my_edit_class") ||
8578 !lstrcmpiA(buf, "static") ||
8579 !lstrcmpiA(buf, "ListBox") ||
8580 !lstrcmpiA(buf, "ComboBox") ||
8581 !lstrcmpiA(buf, "MyDialogClass") ||
8582 !lstrcmpiA(buf, "#32770") ||
8583 !lstrcmpiA(buf, "#32768"))
8584 return TRUE;
8585 }
8586 return FALSE;
8587 }
8588
8589 static LRESULT CALLBACK cbt_hook_proc(int nCode, WPARAM wParam, LPARAM lParam)
8590 {
8591 HWND hwnd;
8592
8593 ok(cbt_hook_thread_id == GetCurrentThreadId(), "we didn't ask for events from other threads\n");
8594
8595 if (nCode == HCBT_CLICKSKIPPED)
8596 {
8597 /* ignore this event, XP sends it a lot when switching focus between windows */
8598 return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
8599 }
8600
8601 if (nCode == HCBT_SYSCOMMAND || nCode == HCBT_KEYSKIPPED)
8602 {
8603 struct recvd_message msg;
8604
8605 msg.hwnd = 0;
8606 msg.message = nCode;
8607 msg.flags = hook|wparam|lparam;
8608 msg.wParam = wParam;
8609 msg.lParam = lParam;
8610 msg.descr = "CBT";
8611 add_message(&msg);
8612
8613 return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
8614 }
8615
8616 if (nCode == HCBT_DESTROYWND)
8617 {
8618 if (test_DestroyWindow_flag)
8619 {
8620 DWORD style = GetWindowLongA((HWND)wParam, GWL_STYLE);
8621 if (style & WS_CHILD)
8622 lParam = GetWindowLongPtrA((HWND)wParam, GWLP_ID);
8623 else if (style & WS_POPUP)
8624 lParam = WND_POPUP_ID;
8625 else
8626 lParam = WND_PARENT_ID;
8627 }
8628 }
8629
8630 /* Log also SetFocus(0) calls */
8631 hwnd = wParam ? (HWND)wParam : (HWND)lParam;
8632
8633 if (is_our_logged_class(hwnd))
8634 {
8635 struct recvd_message msg;
8636
8637 msg.hwnd = hwnd;
8638 msg.message = nCode;
8639 msg.flags = hook|wparam|lparam;
8640 msg.wParam = wParam;
8641 msg.lParam = lParam;
8642 msg.descr = "CBT";
8643 add_message(&msg);
8644 }
8645 return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
8646 }
8647
8648 static void CALLBACK win_event_proc(HWINEVENTHOOK hevent,
8649 DWORD event,
8650 HWND hwnd,
8651 LONG object_id,
8652 LONG child_id,
8653 DWORD thread_id,
8654 DWORD event_time)
8655 {
8656 ok(thread_id == GetCurrentThreadId(), "we didn't ask for events from other threads\n");
8657
8658 /* ignore mouse cursor events */
8659 if (object_id == OBJID_CURSOR) return;
8660
8661 if (!hwnd || is_our_logged_class(hwnd))
8662 {
8663 struct recvd_message msg;
8664
8665 msg.hwnd = hwnd;
8666 msg.message = event;
8667 msg.flags = winevent_hook|wparam|lparam;
8668 msg.wParam = object_id;
8669 msg.lParam = child_id;
8670 msg.descr = "WEH";
8671 add_message(&msg);
8672 }
8673 }
8674
8675 static const WCHAR wszUnicode[] = {'U','n','i','c','o','d','e',0};
8676 static const WCHAR wszAnsi[] = {'U',0};
8677
8678 static LRESULT CALLBACK MsgConversionProcW(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
8679 {
8680 switch (uMsg)
8681 {
8682 case CB_FINDSTRINGEXACT:
8683 trace("String: %p\n", (LPCWSTR)lParam);
8684 if (!lstrcmpW((LPCWSTR)lParam, wszUnicode))
8685 return 1;
8686 if (!lstrcmpW((LPCWSTR)lParam, wszAnsi))
8687 return 0;
8688 return -1;
8689 }
8690 return DefWindowProcW(hwnd, uMsg, wParam, lParam);
8691 }
8692
8693 static const struct message WmGetTextLengthAfromW[] = {
8694 { WM_GETTEXTLENGTH, sent },
8695 { WM_GETTEXT, sent|optional },
8696 { 0 }
8697 };
8698
8699 static const WCHAR dummy_window_text[] = {'d','u','m','m','y',' ','t','e','x','t',0};
8700
8701 /* dummy window proc for WM_GETTEXTLENGTH test */
8702 static LRESULT CALLBACK get_text_len_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
8703 {
8704 switch(msg)
8705 {
8706 case WM_GETTEXTLENGTH:
8707 return lstrlenW(dummy_window_text) + 37; /* some random length */
8708 case WM_GETTEXT:
8709 lstrcpynW( (LPWSTR)lp, dummy_window_text, wp );
8710 return lstrlenW( (LPWSTR)lp );
8711 default:
8712 return DefWindowProcW( hwnd, msg, wp, lp );
8713 }
8714 }
8715
8716 static void test_message_conversion(void)
8717 {
8718 static const WCHAR wszMsgConversionClass[] =
8719 {'M','s','g','C','o','n','v','e','r','s','i','o','n','C','l','a','s','s',0};
8720 WNDCLASSW cls;
8721 LRESULT lRes;
8722 HWND hwnd;
8723 WNDPROC wndproc, newproc;
8724 BOOL ret;
8725
8726 cls.style = 0;
8727 cls.lpfnWndProc = MsgConversionProcW;
8728 cls.cbClsExtra = 0;
8729 cls.cbWndExtra = 0;
8730 cls.hInstance = GetModuleHandleW(NULL);
8731 cls.hIcon = NULL;
8732 cls.hCursor = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
8733 cls.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
8734 cls.lpszMenuName = NULL;
8735 cls.lpszClassName = wszMsgConversionClass;
8736 /* this call will fail on Win9x, but that doesn't matter as this test is
8737 * meaningless on those platforms */
8738 if(!RegisterClassW(&cls)) return;
8739
8740 hwnd = CreateWindowExW(0, wszMsgConversionClass, NULL, WS_OVERLAPPED,
8741 100, 100, 200, 200, 0, 0, 0, NULL);
8742 ok(hwnd != NULL, "Window creation failed\n");
8743
8744 /* {W, A} -> A */
8745
8746 wndproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC);
8747 lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8748 ok(lRes == 0, "String should have been converted\n");
8749 lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8750 ok(lRes == 1, "String shouldn't have been converted\n");
8751
8752 /* {W, A} -> W */
8753
8754 wndproc = (WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC);
8755 lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8756 ok(lRes == 1, "String shouldn't have been converted\n");
8757 lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8758 ok(lRes == 1, "String shouldn't have been converted\n");
8759
8760 /* Synchronous messages */
8761
8762 lRes = SendMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8763 ok(lRes == 0, "String should have been converted\n");
8764 lRes = SendMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8765 ok(lRes == 1, "String shouldn't have been converted\n");
8766
8767 /* Asynchronous messages */
8768
8769 SetLastError(0);
8770 lRes = PostMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8771 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
8772 "PostMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
8773 SetLastError(0);
8774 lRes = PostMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8775 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
8776 "PostMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
8777 SetLastError(0);
8778 lRes = PostThreadMessageA(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8779 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
8780 "PosThreadtMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
8781 SetLastError(0);
8782 lRes = PostThreadMessageW(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8783 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
8784 "PosThreadtMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
8785 SetLastError(0);
8786 lRes = SendNotifyMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8787 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
8788 "SendNotifyMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
8789 SetLastError(0);
8790 lRes = SendNotifyMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8791 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
8792 "SendNotifyMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
8793 SetLastError(0);
8794 lRes = SendMessageCallbackA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
8795 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
8796 "SendMessageCallback on sync only message returned %ld, last error %d\n", lRes, GetLastError());
8797 SetLastError(0);
8798 lRes = SendMessageCallbackW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
8799 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
8800 "SendMessageCallback on sync only message returned %ld, last error %d\n", lRes, GetLastError());
8801
8802 /* Check WM_GETTEXTLENGTH A->W behaviour, whether WM_GETTEXT is also sent or not */
8803
8804 hwnd = CreateWindowW (testWindowClassW, wszUnicode,
8805 WS_OVERLAPPEDWINDOW,
8806 100, 100, 200, 200, 0, 0, 0, NULL);
8807 assert(hwnd);
8808 flush_sequence();
8809 lRes = SendMessageA (hwnd, WM_GETTEXTLENGTH, 0, 0);
8810 ok_sequence(WmGetTextLengthAfromW, "ANSI WM_GETTEXTLENGTH to Unicode window", FALSE);
8811 ok( lRes == WideCharToMultiByte( CP_ACP, 0, wszUnicode, lstrlenW(wszUnicode), NULL, 0, NULL, NULL ),
8812 "got bad length %ld\n", lRes );
8813
8814 flush_sequence();
8815 lRes = CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ),
8816 hwnd, WM_GETTEXTLENGTH, 0, 0);
8817 ok_sequence(WmGetTextLengthAfromW, "ANSI WM_GETTEXTLENGTH to Unicode window", FALSE);
8818 ok( lRes == WideCharToMultiByte( CP_ACP, 0, wszUnicode, lstrlenW(wszUnicode), NULL, 0, NULL, NULL ),
8819 "got bad length %ld\n", lRes );
8820
8821 wndproc = (WNDPROC)SetWindowLongPtrW( hwnd, GWLP_WNDPROC, (LONG_PTR)get_text_len_proc );
8822 newproc = (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC );
8823 lRes = CallWindowProcA( newproc, hwnd, WM_GETTEXTLENGTH, 0, 0 );
8824 ok( lRes == WideCharToMultiByte( CP_ACP, 0, dummy_window_text, lstrlenW(dummy_window_text),
8825 NULL, 0, NULL, NULL ) ||
8826 broken(lRes == lstrlenW(dummy_window_text) + 37),
8827 "got bad length %ld\n", lRes );
8828
8829 SetWindowLongPtrW( hwnd, GWLP_WNDPROC, (LONG_PTR)wndproc ); /* restore old wnd proc */
8830 lRes = CallWindowProcA( newproc, hwnd, WM_GETTEXTLENGTH, 0, 0 );
8831 ok( lRes == WideCharToMultiByte( CP_ACP, 0, dummy_window_text, lstrlenW(dummy_window_text),
8832 NULL, 0, NULL, NULL ) ||
8833 broken(lRes == lstrlenW(dummy_window_text) + 37),
8834 "got bad length %ld\n", lRes );
8835
8836 ret = DestroyWindow(hwnd);
8837 ok( ret, "DestroyWindow() error %d\n", GetLastError());
8838 }
8839
8840 struct timer_info
8841 {
8842 HWND hWnd;
8843 HANDLE handles[2];
8844 DWORD id;
8845 };
8846
8847 static VOID CALLBACK tfunc(HWND hwnd, UINT uMsg, UINT_PTR id, DWORD dwTime)
8848 {
8849 }
8850
8851 #define TIMER_ID 0x19
8852 #define TIMER_COUNT_EXPECTED 100
8853 #define TIMER_COUNT_TOLERANCE 10
8854
8855 static int count = 0;
8856 static void CALLBACK callback_count(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
8857 {
8858 count++;
8859 }
8860
8861 static DWORD exception;
8862 static void CALLBACK callback_exception(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
8863 {
8864 count++;
8865 RaiseException(exception, 0, 0, NULL);
8866 }
8867
8868 static DWORD WINAPI timer_thread_proc(LPVOID x)
8869 {
8870 struct timer_info *info = x;
8871 DWORD r;
8872
8873 r = KillTimer(info->hWnd, 0x19);
8874 ok(r,"KillTimer failed in thread\n");
8875 r = SetTimer(info->hWnd,TIMER_ID,10000,tfunc);
8876 ok(r,"SetTimer failed in thread\n");
8877 ok(r==TIMER_ID,"SetTimer id different\n");
8878 r = SetEvent(info->handles[0]);
8879 ok(r,"SetEvent failed in thread\n");
8880 return 0;
8881 }
8882
8883 static void test_timers(void)
8884 {
8885 struct timer_info info;
8886 DWORD start;
8887 DWORD id;
8888 MSG msg;
8889
8890 info.hWnd = CreateWindowA("TestWindowClass", NULL,
8891 WS_OVERLAPPEDWINDOW ,
8892 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
8893 NULL, NULL, 0);
8894
8895 info.id = SetTimer(info.hWnd,TIMER_ID,10000,tfunc);
8896 ok(info.id, "SetTimer failed\n");
8897 ok(info.id==TIMER_ID, "SetTimer timer ID different\n");
8898 info.handles[0] = CreateEventW(NULL,0,0,NULL);
8899 info.handles[1] = CreateThread(NULL,0,timer_thread_proc,&info,0,&id);
8900
8901 WaitForMultipleObjects(2, info.handles, FALSE, INFINITE);
8902
8903 WaitForSingleObject(info.handles[1], INFINITE);
8904
8905 CloseHandle(info.handles[0]);
8906 CloseHandle(info.handles[1]);
8907
8908 ok( KillTimer(info.hWnd, TIMER_ID), "KillTimer failed\n");
8909
8910 /* Check the minimum allowed timeout for a timer. MSDN indicates that it should be 10.0 ms,
8911 * which occurs sometimes, but most testing on the VMs indicates a minimum timeout closer to
8912 * 15.6 ms. Since there is some measurement error between test runs we are allowing for
8913 * ±9 counts (~4 ms) around the expected value.
8914 */
8915 count = 0;
8916 id = SetTimer(info.hWnd, TIMER_ID, 0, callback_count);
8917 ok(id != 0, "did not get id from SetTimer.\n");
8918 ok(id==TIMER_ID, "SetTimer timer ID different\n");
8919 start = GetTickCount();
8920 while (GetTickCount()-start < 1001 && GetMessageA(&msg, info.hWnd, 0, 0))
8921 DispatchMessageA(&msg);
8922 ok(abs(count-TIMER_COUNT_EXPECTED) < TIMER_COUNT_TOLERANCE /* xp */
8923 || broken(abs(count-64) < TIMER_COUNT_TOLERANCE) /* most common */
8924 || broken(abs(count-43) < TIMER_COUNT_TOLERANCE) /* w2k3, win8 */,
8925 "did not get expected count for minimum timeout (%d != ~%d).\n",
8926 count, TIMER_COUNT_EXPECTED);
8927 ok(KillTimer(info.hWnd, id), "KillTimer failed\n");
8928 /* Perform the same check on SetSystemTimer (only available on w2k3 and older) */
8929 if (pSetSystemTimer)
8930 {
8931 int syscount = 0;
8932
8933 count = 0;
8934 id = pSetSystemTimer(info.hWnd, TIMER_ID, 0, callback_count);
8935 ok(id != 0, "did not get id from SetSystemTimer.\n");
8936 ok(id==TIMER_ID, "SetTimer timer ID different\n");
8937 start = GetTickCount();
8938 while (GetTickCount()-start < 1001 && GetMessageA(&msg, info.hWnd, 0, 0))
8939 {
8940 if (msg.message == WM_SYSTIMER)
8941 syscount++;
8942 DispatchMessageA(&msg);
8943 }
8944 ok(abs(syscount-TIMER_COUNT_EXPECTED) < TIMER_COUNT_TOLERANCE
8945 || broken(abs(syscount-64) < TIMER_COUNT_TOLERANCE) /* most common */
8946 || broken(syscount > 4000 && syscount < 12000) /* win2k3sp0 */,
8947 "did not get expected count for minimum timeout (%d != ~%d).\n",
8948 syscount, TIMER_COUNT_EXPECTED);
8949 todo_wine ok(count == 0, "did not get expected count for callback timeout (%d != 0).\n",
8950 count);
8951 ok(pKillSystemTimer(info.hWnd, id), "KillSystemTimer failed\n");
8952 }
8953
8954 ok(DestroyWindow(info.hWnd), "failed to destroy window\n");
8955 }
8956
8957 static void test_timers_no_wnd(void)
8958 {
8959 static UINT_PTR ids[0xffff];
8960 UINT_PTR id, id2;
8961 DWORD start;
8962 MSG msg;
8963 int i;
8964
8965 count = 0;
8966 id = SetTimer(NULL, 0, 100, callback_count);
8967 ok(id != 0, "did not get id from SetTimer.\n");
8968 id2 = SetTimer(NULL, id, 200, callback_count);
8969 ok(id2 == id, "did not get same id from SetTimer when replacing (%li expected %li).\n", id2, id);
8970 Sleep(150);
8971 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
8972 ok(count == 0, "did not get zero count as expected (%i).\n", count);
8973 Sleep(150);
8974 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
8975 ok(count == 1, "did not get one count as expected (%i).\n", count);
8976 KillTimer(NULL, id);
8977 Sleep(250);
8978 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
8979 ok(count == 1, "killing replaced timer did not work (%i).\n", count);
8980
8981 /* Check the minimum allowed timeout for a timer. MSDN indicates that it should be 10.0 ms,
8982 * which occurs sometimes, but most testing on the VMs indicates a minimum timeout closer to
8983 * 15.6 ms. Since there is some measurement error between test runs we are allowing for
8984 * ±9 counts (~4 ms) around the expected value.
8985 */
8986 count = 0;
8987 id = SetTimer(NULL, 0, 0, callback_count);
8988 ok(id != 0, "did not get id from SetTimer.\n");
8989 start = GetTickCount();
8990 while (GetTickCount()-start < 1001 && GetMessageA(&msg, NULL, 0, 0))
8991 DispatchMessageA(&msg);
8992 ok(abs(count-TIMER_COUNT_EXPECTED) < TIMER_COUNT_TOLERANCE /* xp */
8993 || broken(abs(count-64) < TIMER_COUNT_TOLERANCE) /* most common */,
8994 "did not get expected count for minimum timeout (%d != ~%d).\n",
8995 count, TIMER_COUNT_EXPECTED);
8996 KillTimer(NULL, id);
8997 /* Note: SetSystemTimer doesn't support a NULL window, see test_timers */
8998
8999 if (pSetCoalescableTimer)
9000 {
9001 count = 0;
9002 id = pSetCoalescableTimer(NULL, 0, 0, callback_count, 0);
9003 ok(id != 0, "SetCoalescableTimer failed with %u.\n", GetLastError());
9004 start = GetTickCount();
9005 while (GetTickCount()-start < 100 && GetMessageA(&msg, NULL, 0, 0))
9006 DispatchMessageA(&msg);
9007 ok(count > 1, "expected count > 1, got %d.\n", count);
9008 KillTimer(NULL, id);
9009 }
9010 else
9011 win_skip("SetCoalescableTimer not available.\n");
9012
9013 /* Check what happens when we're running out of timers */
9014 for (i=0; i<sizeof(ids)/sizeof(ids[0]); i++)
9015 {
9016 SetLastError(0xdeadbeef);
9017 ids[i] = SetTimer(NULL, 0, USER_TIMER_MAXIMUM, tfunc);
9018 if (!ids[i]) break;
9019 }
9020 ok(i != sizeof(ids)/sizeof(ids[0]), "all timers were created successfully\n");
9021 ok(GetLastError()==ERROR_NO_MORE_USER_HANDLES || broken(GetLastError()==0xdeadbeef),
9022 "GetLastError() = %d\n", GetLastError());
9023 while (i > 0) KillTimer(NULL, ids[--i]);
9024 }
9025
9026 static void test_timers_exception(DWORD code)
9027 {
9028 UINT_PTR id;
9029 MSG msg;
9030
9031 exception = code;
9032 id = SetTimer(NULL, 0, 1000, callback_exception);
9033 ok(id != 0, "did not get id from SetTimer.\n");
9034
9035 memset(&msg, 0, sizeof(msg));
9036 msg.message = WM_TIMER;
9037 msg.wParam = id;
9038 msg.lParam = (LPARAM)callback_exception;
9039
9040 count = 0;
9041 DispatchMessageA(&msg);
9042 ok(count == 1, "did not get one count as expected (%i).\n", count);
9043
9044 KillTimer(NULL, id);
9045 }
9046
9047 static void test_timers_exceptions(void)
9048 {
9049 test_timers_exception(EXCEPTION_ACCESS_VIOLATION);
9050 test_timers_exception(EXCEPTION_DATATYPE_MISALIGNMENT);
9051 test_timers_exception(EXCEPTION_BREAKPOINT);
9052 test_timers_exception(EXCEPTION_SINGLE_STEP);
9053 test_timers_exception(EXCEPTION_ARRAY_BOUNDS_EXCEEDED);
9054 test_timers_exception(EXCEPTION_FLT_DENORMAL_OPERAND);
9055 test_timers_exception(EXCEPTION_FLT_DIVIDE_BY_ZERO);
9056 test_timers_exception(EXCEPTION_FLT_INEXACT_RESULT);
9057 test_timers_exception(EXCEPTION_ILLEGAL_INSTRUCTION);
9058 test_timers_exception(0xE000BEEF); /* customer exception */
9059 }
9060
9061 /* Various win events with arbitrary parameters */
9062 static const struct message WmWinEventsSeq[] = {
9063 { EVENT_SYSTEM_SOUND, winevent_hook|wparam|lparam, OBJID_WINDOW, 0 },
9064 { EVENT_SYSTEM_ALERT, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
9065 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, OBJID_TITLEBAR, 2 },
9066 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_MENU, 3 },
9067 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_CLIENT, 4 },
9068 { EVENT_SYSTEM_MENUPOPUPSTART, winevent_hook|wparam|lparam, OBJID_VSCROLL, 5 },
9069 { EVENT_SYSTEM_MENUPOPUPEND, winevent_hook|wparam|lparam, OBJID_HSCROLL, 6 },
9070 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, OBJID_SIZEGRIP, 7 },
9071 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, OBJID_CARET, 8 },
9072 /* our win event hook ignores OBJID_CURSOR events */
9073 /*{ EVENT_SYSTEM_MOVESIZESTART, winevent_hook|wparam|lparam, OBJID_CURSOR, 9 },*/
9074 { EVENT_SYSTEM_MOVESIZEEND, winevent_hook|wparam|lparam, OBJID_ALERT, 10 },
9075 { EVENT_SYSTEM_CONTEXTHELPSTART, winevent_hook|wparam|lparam, OBJID_SOUND, 11 },
9076 { EVENT_SYSTEM_CONTEXTHELPEND, winevent_hook|wparam|lparam, OBJID_QUERYCLASSNAMEIDX, 12 },
9077 { EVENT_SYSTEM_DRAGDROPSTART, winevent_hook|wparam|lparam, OBJID_NATIVEOM, 13 },
9078 { EVENT_SYSTEM_DRAGDROPEND, winevent_hook|wparam|lparam, OBJID_WINDOW, 0 },
9079 { EVENT_SYSTEM_DIALOGSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
9080 { EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam, OBJID_TITLEBAR, 2 },
9081 { EVENT_SYSTEM_SCROLLINGSTART, winevent_hook|wparam|lparam, OBJID_MENU, 3 },
9082 { EVENT_SYSTEM_SCROLLINGEND, winevent_hook|wparam|lparam, OBJID_CLIENT, 4 },
9083 { EVENT_SYSTEM_SWITCHSTART, winevent_hook|wparam|lparam, OBJID_VSCROLL, 5 },
9084 { EVENT_SYSTEM_SWITCHEND, winevent_hook|wparam|lparam, OBJID_HSCROLL, 6 },
9085 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, OBJID_SIZEGRIP, 7 },
9086 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam, OBJID_CARET, 8 },
9087 { 0 }
9088 };
9089 static const struct message WmWinEventCaretSeq[] = {
9090 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
9091 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
9092 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 2 */
9093 { EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
9094 { 0 }
9095 };
9096 static const struct message WmWinEventCaretSeq_2[] = {
9097 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
9098 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
9099 { EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
9100 { 0 }
9101 };
9102 static const struct message WmWinEventAlertSeq[] = {
9103 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_ALERT, 0 },
9104 { 0 }
9105 };
9106 static const struct message WmWinEventAlertSeq_2[] = {
9107 /* create window in the thread proc */
9108 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_WINDOW, 2 },
9109 /* our test event */
9110 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_ALERT, 2 },
9111 { 0 }
9112 };
9113 static const struct message WmGlobalHookSeq_1[] = {
9114 /* create window in the thread proc */
9115 { HCBT_CREATEWND, hook|lparam, 0, 2 },
9116 /* our test events */
9117 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 2 },
9118 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 2 },
9119 { 0 }
9120 };
9121 static const struct message WmGlobalHookSeq_2[] = {
9122 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 0 }, /* old local hook */
9123 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 2 }, /* new global hook */
9124 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 0 }, /* old local hook */
9125 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 2 }, /* new global hook */
9126 { 0 }
9127 };
9128
9129 static const struct message WmMouseLLHookSeq[] = {
9130 { WM_MOUSEMOVE, hook },
9131 { WM_LBUTTONUP, hook },
9132 { WM_MOUSEMOVE, hook },
9133 { 0 }
9134 };
9135
9136 static void CALLBACK win_event_global_hook_proc(HWINEVENTHOOK hevent,
9137 DWORD event,
9138 HWND hwnd,
9139 LONG object_id,
9140 LONG child_id,
9141 DWORD thread_id,
9142 DWORD event_time)
9143 {
9144 char buf[256];
9145
9146 if (GetClassNameA(hwnd, buf, sizeof(buf)))
9147 {
9148 if (!lstrcmpiA(buf, "TestWindowClass") ||
9149 !lstrcmpiA(buf, "static"))
9150 {
9151 struct recvd_message msg;
9152
9153 msg.hwnd = hwnd;
9154 msg.message = event;
9155 msg.flags = winevent_hook|wparam|lparam;
9156 msg.wParam = object_id;
9157 msg.lParam = (thread_id == GetCurrentThreadId()) ? child_id : (child_id + 2);
9158 msg.descr = "WEH_2";
9159 add_message(&msg);
9160 }
9161 }
9162 }
9163
9164 static HHOOK hCBT_global_hook;
9165 static DWORD cbt_global_hook_thread_id;
9166
9167 static LRESULT CALLBACK cbt_global_hook_proc(int nCode, WPARAM wParam, LPARAM lParam)
9168 {
9169 HWND hwnd;
9170 char buf[256];
9171
9172 if (nCode == HCBT_SYSCOMMAND)
9173 {
9174 struct recvd_message msg;
9175
9176 msg.hwnd = 0;
9177 msg.message = nCode;
9178 msg.flags = hook|wparam|lparam;
9179 msg.wParam = wParam;
9180 msg.lParam = (cbt_global_hook_thread_id == GetCurrentThreadId()) ? 1 : 2;
9181 msg.descr = "CBT_2";
9182 add_message(&msg);
9183
9184 return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
9185 }
9186 /* WH_MOUSE_LL hook */
9187 if (nCode == HC_ACTION)
9188 {
9189 MSLLHOOKSTRUCT *mhll = (MSLLHOOKSTRUCT *)lParam;
9190
9191 /* we can't test for real mouse events */
9192 if (mhll->flags & LLMHF_INJECTED)
9193 {
9194 struct recvd_message msg;
9195
9196 memset (&msg, 0, sizeof (msg));
9197 msg.message = wParam;
9198 msg.flags = hook;
9199 msg.descr = "CBT_2";
9200 add_message(&msg);
9201 }
9202 return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
9203 }
9204
9205 /* Log also SetFocus(0) calls */
9206 hwnd = wParam ? (HWND)wParam : (HWND)lParam;
9207
9208 if (GetClassNameA(hwnd, buf, sizeof(buf)))
9209 {
9210 if (!lstrcmpiA(buf, "TestWindowClass") ||
9211 !lstrcmpiA(buf, "static"))
9212 {
9213 struct recvd_message msg;
9214
9215 msg.hwnd = hwnd;
9216 msg.message = nCode;
9217 msg.flags = hook|wparam|lparam;
9218 msg.wParam = wParam;
9219 msg.lParam = (cbt_global_hook_thread_id == GetCurrentThreadId()) ? 1 : 2;
9220 msg.descr = "CBT_2";
9221 add_message(&msg);
9222 }
9223 }
9224 return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
9225 }
9226
9227 static DWORD WINAPI win_event_global_thread_proc(void *param)
9228 {
9229 HWND hwnd;
9230 MSG msg;
9231 HANDLE hevent = *(HANDLE *)param;
9232
9233 assert(pNotifyWinEvent);
9234
9235 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
9236 assert(hwnd);
9237 trace("created thread window %p\n", hwnd);
9238
9239 *(HWND *)param = hwnd;
9240
9241 flush_sequence();
9242 /* this event should be received only by our new hook proc,
9243 * an old one does not expect an event from another thread.
9244 */
9245 pNotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE, hwnd, OBJID_ALERT, 0);
9246 SetEvent(hevent);
9247
9248 while (GetMessageA(&msg, 0, 0, 0))
9249 {
9250 TranslateMessage(&msg);
9251 DispatchMessageA(&msg);
9252 }
9253 return 0;
9254 }
9255
9256 static DWORD WINAPI cbt_global_hook_thread_proc(void *param)
9257 {
9258 HWND hwnd;
9259 MSG msg;
9260 HANDLE hevent = *(HANDLE *)param;
9261
9262 flush_sequence();
9263 /* these events should be received only by our new hook proc,
9264 * an old one does not expect an event from another thread.
9265 */
9266
9267 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
9268 assert(hwnd);
9269 trace("created thread window %p\n", hwnd);
9270
9271 *(HWND *)param = hwnd;
9272
9273 /* Windows doesn't like when a thread plays games with the focus,
9274 that leads to all kinds of misbehaviours and failures to activate
9275 a window. So, better keep next lines commented out.
9276 SetFocus(0);
9277 SetFocus(hwnd);*/
9278
9279 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_PREVWINDOW, 0);
9280 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0);
9281
9282 SetEvent(hevent);
9283
9284 while (GetMessageA(&msg, 0, 0, 0))
9285 {
9286 TranslateMessage(&msg);
9287 DispatchMessageA(&msg);
9288 }
9289 return 0;
9290 }
9291
9292 static DWORD WINAPI mouse_ll_global_thread_proc(void *param)
9293 {
9294 HWND hwnd;
9295 MSG msg;
9296 HANDLE hevent = *(HANDLE *)param;
9297
9298 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
9299 assert(hwnd);
9300 trace("created thread window %p\n", hwnd);
9301
9302 *(HWND *)param = hwnd;
9303
9304 flush_sequence();
9305
9306 /* Windows doesn't like when a thread plays games with the focus,
9307 * that leads to all kinds of misbehaviours and failures to activate
9308 * a window. So, better don't generate a mouse click message below.
9309 */
9310 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
9311 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
9312 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
9313
9314 SetEvent(hevent);
9315 while (GetMessageA(&msg, 0, 0, 0))
9316 {
9317 TranslateMessage(&msg);
9318 DispatchMessageA(&msg);
9319 }
9320 return 0;
9321 }
9322
9323 static void test_winevents(void)
9324 {
9325 BOOL ret;
9326 MSG msg;
9327 HWND hwnd, hwnd2;
9328 UINT i;
9329 HANDLE hthread, hevent;
9330 DWORD tid;
9331 HWINEVENTHOOK hhook;
9332 const struct message *events = WmWinEventsSeq;
9333
9334 hwnd = CreateWindowExA(0, "TestWindowClass", NULL,
9335 WS_OVERLAPPEDWINDOW,
9336 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
9337 NULL, NULL, 0);
9338 assert(hwnd);
9339
9340 /****** start of global hook test *************/
9341 hCBT_global_hook = SetWindowsHookExA(WH_CBT, cbt_global_hook_proc, GetModuleHandleA(0), 0);
9342 if (!hCBT_global_hook)
9343 {
9344 ok(DestroyWindow(hwnd), "failed to destroy window\n");
9345 skip( "cannot set global hook\n" );
9346 return;
9347 }
9348
9349 hevent = CreateEventA(NULL, 0, 0, NULL);
9350 assert(hevent);
9351 hwnd2 = hevent;
9352
9353 hthread = CreateThread(NULL, 0, cbt_global_hook_thread_proc, &hwnd2, 0, &tid);
9354 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
9355
9356 ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9357
9358 ok_sequence(WmGlobalHookSeq_1, "global hook 1", FALSE);
9359
9360 flush_sequence();
9361 /* this one should be received only by old hook proc */
9362 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0);
9363 /* this one should be received only by old hook proc */
9364 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_PREVWINDOW, 0);
9365
9366 ok_sequence(WmGlobalHookSeq_2, "global hook 2", FALSE);
9367
9368 ret = UnhookWindowsHookEx(hCBT_global_hook);
9369 ok( ret, "UnhookWindowsHookEx error %d\n", GetLastError());
9370
9371 PostThreadMessageA(tid, WM_QUIT, 0, 0);
9372 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9373 CloseHandle(hthread);
9374 CloseHandle(hevent);
9375 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
9376 /****** end of global hook test *************/
9377
9378 if (!pSetWinEventHook || !pNotifyWinEvent || !pUnhookWinEvent)
9379 {
9380 ok(DestroyWindow(hwnd), "failed to destroy window\n");
9381 return;
9382 }
9383
9384 flush_sequence();
9385
9386 if (0)
9387 {
9388 /* this test doesn't pass under Win9x */
9389 /* win2k ignores events with hwnd == 0 */
9390 SetLastError(0xdeadbeef);
9391 pNotifyWinEvent(events[0].message, 0, events[0].wParam, events[0].lParam);
9392 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || /* Win2k */
9393 GetLastError() == 0xdeadbeef, /* Win9x */
9394 "unexpected error %d\n", GetLastError());
9395 ok_sequence(WmEmptySeq, "empty notify winevents", FALSE);
9396 }
9397
9398 for (i = 0; i < sizeof(WmWinEventsSeq)/sizeof(WmWinEventsSeq[0]); i++)
9399 pNotifyWinEvent(events[i].message, hwnd, events[i].wParam, events[i].lParam);
9400
9401 ok_sequence(WmWinEventsSeq, "notify winevents", FALSE);
9402
9403 /****** start of event filtering test *************/
9404 hhook = pSetWinEventHook(
9405 EVENT_OBJECT_SHOW, /* 0x8002 */
9406 EVENT_OBJECT_LOCATIONCHANGE, /* 0x800B */
9407 GetModuleHandleA(0), win_event_global_hook_proc,
9408 GetCurrentProcessId(), 0,
9409 WINEVENT_INCONTEXT);
9410 ok(hhook != 0, "SetWinEventHook error %d\n", GetLastError());
9411
9412 hevent = CreateEventA(NULL, 0, 0, NULL);
9413 assert(hevent);
9414 hwnd2 = hevent;
9415
9416 hthread = CreateThread(NULL, 0, win_event_global_thread_proc, &hwnd2, 0, &tid);
9417 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
9418
9419 ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9420
9421 ok_sequence(WmWinEventAlertSeq, "alert winevent", FALSE);
9422
9423 flush_sequence();
9424 /* this one should be received only by old hook proc */
9425 pNotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_CARET, 0); /* 0x8000 */
9426 pNotifyWinEvent(EVENT_OBJECT_SHOW, hwnd, OBJID_CARET, 0); /* 0x8002 */
9427 /* this one should be received only by old hook proc */
9428 pNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, hwnd, OBJID_CARET, 0); /* 0x800C */
9429
9430 ok_sequence(WmWinEventCaretSeq, "caret winevent", FALSE);
9431
9432 ret = pUnhookWinEvent(hhook);
9433 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
9434
9435 PostThreadMessageA(tid, WM_QUIT, 0, 0);
9436 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9437 CloseHandle(hthread);
9438 CloseHandle(hevent);
9439 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
9440 /****** end of event filtering test *************/
9441
9442 /****** start of out of context event test *************/
9443 hhook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0,
9444 win_event_global_hook_proc, GetCurrentProcessId(), 0,
9445 WINEVENT_OUTOFCONTEXT);
9446 ok(hhook != 0, "SetWinEventHook error %d\n", GetLastError());
9447
9448 hevent = CreateEventA(NULL, 0, 0, NULL);
9449 assert(hevent);
9450 hwnd2 = hevent;
9451
9452 flush_sequence();
9453
9454 hthread = CreateThread(NULL, 0, win_event_global_thread_proc, &hwnd2, 0, &tid);
9455 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
9456
9457 ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9458
9459 ok_sequence(WmEmptySeq, "empty notify winevents", FALSE);
9460 /* process pending winevent messages */
9461 ok(!PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE), "msg queue should be empty\n");
9462 ok_sequence(WmWinEventAlertSeq_2, "alert winevent for out of context proc", FALSE);
9463
9464 flush_sequence();
9465 /* this one should be received only by old hook proc */
9466 pNotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_CARET, 0); /* 0x8000 */
9467 pNotifyWinEvent(EVENT_OBJECT_SHOW, hwnd, OBJID_CARET, 0); /* 0x8002 */
9468 /* this one should be received only by old hook proc */
9469 pNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, hwnd, OBJID_CARET, 0); /* 0x800C */
9470
9471 ok_sequence(WmWinEventCaretSeq_2, "caret winevent for incontext proc", FALSE);
9472 /* process pending winevent messages */
9473 ok(!PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE), "msg queue should be empty\n");
9474 ok_sequence(WmWinEventCaretSeq_2, "caret winevent for out of context proc", FALSE);
9475
9476 ret = pUnhookWinEvent(hhook);
9477 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
9478
9479 PostThreadMessageA(tid, WM_QUIT, 0, 0);
9480 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9481 CloseHandle(hthread);
9482 CloseHandle(hevent);
9483 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
9484 /****** end of out of context event test *************/
9485
9486 /****** start of MOUSE_LL hook test *************/
9487 hCBT_global_hook = SetWindowsHookExA(WH_MOUSE_LL, cbt_global_hook_proc, GetModuleHandleA(0), 0);
9488 /* WH_MOUSE_LL is not supported on Win9x platforms */
9489 if (!hCBT_global_hook)
9490 {
9491 win_skip("Skipping WH_MOUSE_LL test on this platform\n");
9492 goto skip_mouse_ll_hook_test;
9493 }
9494
9495 hevent = CreateEventA(NULL, 0, 0, NULL);
9496 assert(hevent);
9497 hwnd2 = hevent;
9498
9499 hthread = CreateThread(NULL, 0, mouse_ll_global_thread_proc, &hwnd2, 0, &tid);
9500 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
9501
9502 while (WaitForSingleObject(hevent, 100) == WAIT_TIMEOUT)
9503 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
9504
9505 ok_sequence(WmMouseLLHookSeq, "MOUSE_LL hook other thread", FALSE);
9506 flush_sequence();
9507
9508 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
9509 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
9510 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
9511
9512 ok_sequence(WmMouseLLHookSeq, "MOUSE_LL hook same thread", FALSE);
9513
9514 ret = UnhookWindowsHookEx(hCBT_global_hook);
9515 ok( ret, "UnhookWindowsHookEx error %d\n", GetLastError());
9516
9517 PostThreadMessageA(tid, WM_QUIT, 0, 0);
9518 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9519 CloseHandle(hthread);
9520 CloseHandle(hevent);
9521 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
9522 /****** end of MOUSE_LL hook test *************/
9523 skip_mouse_ll_hook_test:
9524
9525 ok(DestroyWindow(hwnd), "failed to destroy window\n");
9526 }
9527
9528 static void test_set_hook(void)
9529 {
9530 BOOL ret;
9531 HHOOK hhook;
9532 HWINEVENTHOOK hwinevent_hook;
9533
9534 hhook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, GetModuleHandleA(0), GetCurrentThreadId());
9535 ok(hhook != 0, "local hook does not require hModule set to 0\n");
9536 UnhookWindowsHookEx(hhook);
9537
9538 if (0)
9539 {
9540 /* this test doesn't pass under Win9x: BUG! */
9541 SetLastError(0xdeadbeef);
9542 hhook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, 0);
9543 ok(!hhook, "global hook requires hModule != 0\n");
9544 ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD, "unexpected error %d\n", GetLastError());
9545 }
9546
9547 SetLastError(0xdeadbeef);
9548 hhook = SetWindowsHookExA(WH_CBT, 0, GetModuleHandleA(0), GetCurrentThreadId());
9549 ok(!hhook, "SetWinEventHook with invalid proc should fail\n");
9550 ok(GetLastError() == ERROR_INVALID_FILTER_PROC || /* Win2k */
9551 GetLastError() == 0xdeadbeef, /* Win9x */
9552 "unexpected error %d\n", GetLastError());
9553
9554 SetLastError(0xdeadbeef);
9555 ok(!UnhookWindowsHookEx((HHOOK)0xdeadbeef), "UnhookWindowsHookEx succeeded\n");
9556 ok(GetLastError() == ERROR_INVALID_HOOK_HANDLE || /* Win2k */
9557 GetLastError() == 0xdeadbeef, /* Win9x */
9558 "unexpected error %d\n", GetLastError());
9559
9560 if (!pSetWinEventHook || !pUnhookWinEvent) return;
9561
9562 /* even process local incontext hooks require hmodule */
9563 SetLastError(0xdeadbeef);
9564 hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
9565 GetCurrentProcessId(), 0, WINEVENT_INCONTEXT);
9566 ok(!hwinevent_hook, "WINEVENT_INCONTEXT requires hModule != 0\n");
9567 ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD || /* Win2k */
9568 GetLastError() == 0xdeadbeef, /* Win9x */
9569 "unexpected error %d\n", GetLastError());
9570
9571 /* even thread local incontext hooks require hmodule */
9572 SetLastError(0xdeadbeef);
9573 hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
9574 GetCurrentProcessId(), GetCurrentThreadId(), WINEVENT_INCONTEXT);
9575 ok(!hwinevent_hook, "WINEVENT_INCONTEXT requires hModule != 0\n");
9576 ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD || /* Win2k */
9577 GetLastError() == 0xdeadbeef, /* Win9x */
9578 "unexpected error %d\n", GetLastError());
9579
9580 if (0)
9581 {
9582 /* these 3 tests don't pass under Win9x */
9583 SetLastError(0xdeadbeef);
9584 hwinevent_hook = pSetWinEventHook(1, 0, 0, win_event_proc,
9585 GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
9586 ok(!hwinevent_hook, "SetWinEventHook with invalid event range should fail\n");
9587 ok(GetLastError() == ERROR_INVALID_HOOK_FILTER, "unexpected error %d\n", GetLastError());
9588
9589 SetLastError(0xdeadbeef);
9590 hwinevent_hook = pSetWinEventHook(-1, 1, 0, win_event_proc,
9591 GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
9592 ok(!hwinevent_hook, "SetWinEventHook with invalid event range should fail\n");
9593 ok(GetLastError() == ERROR_INVALID_HOOK_FILTER, "unexpected error %d\n", GetLastError());
9594
9595 SetLastError(0xdeadbeef);
9596 hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
9597 0, 0xdeadbeef, WINEVENT_OUTOFCONTEXT);
9598 ok(!hwinevent_hook, "SetWinEventHook with invalid tid should fail\n");
9599 ok(GetLastError() == ERROR_INVALID_THREAD_ID, "unexpected error %d\n", GetLastError());
9600 }
9601
9602 SetLastError(0xdeadbeef);
9603 hwinevent_hook = pSetWinEventHook(0, 0, 0, win_event_proc,
9604 GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
9605 ok(hwinevent_hook != 0, "SetWinEventHook error %d\n", GetLastError());
9606 ok(GetLastError() == 0xdeadbeef, "unexpected error %d\n", GetLastError());
9607 ret = pUnhookWinEvent(hwinevent_hook);
9608 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
9609
9610 todo_wine {
9611 /* This call succeeds under win2k SP4, but fails under Wine.
9612 Does win2k test/use passed process id? */
9613 SetLastError(0xdeadbeef);
9614 hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
9615 0xdeadbeef, 0, WINEVENT_OUTOFCONTEXT);
9616 ok(hwinevent_hook != 0, "SetWinEventHook error %d\n", GetLastError());
9617 ok(GetLastError() == 0xdeadbeef, "unexpected error %d\n", GetLastError());
9618 ret = pUnhookWinEvent(hwinevent_hook);
9619 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
9620 }
9621
9622 SetLastError(0xdeadbeef);
9623 ok(!pUnhookWinEvent((HWINEVENTHOOK)0xdeadbeef), "UnhookWinEvent succeeded\n");
9624 ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
9625 GetLastError() == 0xdeadbeef, /* Win9x */
9626 "unexpected error %d\n", GetLastError());
9627 }
9628
9629 static HWND hook_hwnd;
9630 static HHOOK recursive_hook;
9631 static int hook_depth, max_hook_depth;
9632
9633 static LRESULT WINAPI rec_get_message_hook(int code, WPARAM w, LPARAM l)
9634 {
9635 LRESULT res;
9636 MSG msg;
9637 BOOL b;
9638
9639 hook_depth++;
9640 if(hook_depth > max_hook_depth)
9641 max_hook_depth = hook_depth;
9642
9643 b = PeekMessageW(&msg, hook_hwnd, 0, 0, PM_NOREMOVE);
9644 ok(b, "PeekMessage failed\n");
9645
9646 res = CallNextHookEx(recursive_hook, code, w, l);
9647
9648 hook_depth--;
9649 return res;
9650 }
9651
9652 static void test_recursive_hook(void)
9653 {
9654 MSG msg;
9655 BOOL b;
9656
9657 hook_hwnd = CreateWindowA("Static", NULL, WS_POPUP, 0, 0, 200, 60, NULL, NULL, NULL, NULL);
9658 ok(hook_hwnd != NULL, "CreateWindow failed\n");
9659
9660 recursive_hook = SetWindowsHookExW(WH_GETMESSAGE, rec_get_message_hook, NULL, GetCurrentThreadId());
9661 ok(recursive_hook != NULL, "SetWindowsHookEx failed\n");
9662
9663 PostMessageW(hook_hwnd, WM_USER, 0, 0);
9664 PostMessageW(hook_hwnd, WM_USER+1, 0, 0);
9665
9666 hook_depth = 0;
9667 GetMessageW(&msg, hook_hwnd, 0, 0);
9668 ok(15 <= max_hook_depth && max_hook_depth < 45, "max_hook_depth = %d\n", max_hook_depth);
9669 trace("max_hook_depth = %d\n", max_hook_depth);
9670
9671 b = UnhookWindowsHookEx(recursive_hook);
9672 ok(b, "UnhokWindowsHookEx failed\n");
9673
9674 DestroyWindow(hook_hwnd);
9675 }
9676
9677 static const struct message ScrollWindowPaint1[] = {
9678 { WM_PAINT, sent },
9679 { WM_ERASEBKGND, sent|beginpaint },
9680 { WM_GETTEXTLENGTH, sent|optional },
9681 { WM_PAINT, sent|optional },
9682 { WM_NCPAINT, sent|beginpaint|optional },
9683 { WM_GETTEXT, sent|beginpaint|optional },
9684 { WM_GETTEXT, sent|beginpaint|optional },
9685 { WM_GETTEXT, sent|beginpaint|optional },
9686 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
9687 { WM_ERASEBKGND, sent|beginpaint|optional },
9688 { 0 }
9689 };
9690
9691 static const struct message ScrollWindowPaint2[] = {
9692 { WM_PAINT, sent },
9693 { 0 }
9694 };
9695
9696 static void test_scrollwindowex(void)
9697 {
9698 HWND hwnd, hchild;
9699 RECT rect={0,0,130,130};
9700
9701 hwnd = CreateWindowExA(0, "TestWindowClass", "Test Scroll",
9702 WS_VISIBLE|WS_OVERLAPPEDWINDOW,
9703 100, 100, 200, 200, 0, 0, 0, NULL);
9704 ok (hwnd != 0, "Failed to create overlapped window\n");
9705 hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
9706 WS_VISIBLE|WS_CAPTION|WS_CHILD,
9707 10, 10, 150, 150, hwnd, 0, 0, NULL);
9708 ok (hchild != 0, "Failed to create child\n");
9709 UpdateWindow(hwnd);
9710 flush_events();
9711 flush_sequence();
9712
9713 /* scroll without the child window */
9714 trace("start scroll\n");
9715 ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL,
9716 SW_ERASE|SW_INVALIDATE);
9717 ok_sequence(WmEmptySeq, "ScrollWindowEx", FALSE);
9718 trace("end scroll\n");
9719 flush_sequence();
9720 flush_events();
9721 ok_sequence(ScrollWindowPaint1, "ScrollWindowEx", FALSE);
9722 flush_events();
9723 flush_sequence();
9724
9725 /* Now without the SW_ERASE flag */
9726 trace("start scroll\n");
9727 ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL, SW_INVALIDATE);
9728 ok_sequence(WmEmptySeq, "ScrollWindowEx", FALSE);
9729 trace("end scroll\n");
9730 flush_sequence();
9731 flush_events();
9732 ok_sequence(ScrollWindowPaint2, "ScrollWindowEx", FALSE);
9733 flush_events();
9734 flush_sequence();
9735
9736 /* now scroll the child window as well */
9737 trace("start scroll\n");
9738 ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL,
9739 SW_SCROLLCHILDREN|SW_ERASE|SW_INVALIDATE);
9740 /* wine sends WM_POSCHANGING, WM_POSCHANGED messages */
9741 /* windows sometimes a WM_MOVE */
9742 ok_sequence(WmEmptySeq, "ScrollWindowEx", TRUE);
9743 trace("end scroll\n");
9744 flush_sequence();
9745 flush_events();
9746 ok_sequence(ScrollWindowPaint1, "ScrollWindowEx", FALSE);
9747 flush_events();
9748 flush_sequence();
9749
9750 /* now scroll with ScrollWindow() */
9751 trace("start scroll with ScrollWindow\n");
9752 ScrollWindow( hwnd, 5, 5, NULL, NULL);
9753 trace("end scroll\n");
9754 flush_sequence();
9755 flush_events();
9756 ok_sequence(ScrollWindowPaint1, "ScrollWindow", FALSE);
9757
9758 ok(DestroyWindow(hchild), "failed to destroy window\n");
9759 ok(DestroyWindow(hwnd), "failed to destroy window\n");
9760 flush_sequence();
9761 }
9762
9763 static const struct message destroy_window_with_children[] = {
9764 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 }, /* popup */
9765 { HCBT_DESTROYWND, hook|lparam, 0, WND_PARENT_ID }, /* parent */
9766 { 0x0090, sent|optional },
9767 { HCBT_DESTROYWND, hook|lparam, 0, WND_POPUP_ID }, /* popup */
9768 { 0x0090, sent|optional },
9769 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 }, /* popup */
9770 { WM_DESTROY, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
9771 { WM_CAPTURECHANGED, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
9772 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
9773 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 }, /* parent */
9774 { WM_DESTROY, sent|wparam|lparam, 0, WND_PARENT_ID }, /* parent */
9775 { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 2 }, /* child2 */
9776 { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 1 }, /* child1 */
9777 { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 3 }, /* child3 */
9778 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 2 }, /* child2 */
9779 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 3 }, /* child3 */
9780 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 1 }, /* child1 */
9781 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_PARENT_ID }, /* parent */
9782 { 0 }
9783 };
9784
9785 static void test_DestroyWindow(void)
9786 {
9787 BOOL ret;
9788 HWND parent, child1, child2, child3, child4, test;
9789 UINT_PTR child_id = WND_CHILD_ID + 1;
9790
9791 parent = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
9792 100, 100, 200, 200, 0, 0, 0, NULL);
9793 assert(parent != 0);
9794 child1 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
9795 0, 0, 50, 50, parent, (HMENU)child_id++, 0, NULL);
9796 assert(child1 != 0);
9797 child2 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
9798 0, 0, 50, 50, GetDesktopWindow(), (HMENU)child_id++, 0, NULL);
9799 assert(child2 != 0);
9800 child3 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
9801 0, 0, 50, 50, child1, (HMENU)child_id++, 0, NULL);
9802 assert(child3 != 0);
9803 child4 = CreateWindowExA(0, "TestWindowClass", NULL, WS_POPUP,
9804 0, 0, 50, 50, parent, 0, 0, NULL);
9805 assert(child4 != 0);
9806
9807 /* test owner/parent of child2 */
9808 test = GetParent(child2);
9809 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
9810 ok(!IsChild(parent, child2), "wrong parent/child %p/%p\n", parent, child2);
9811 if(pGetAncestor) {
9812 test = pGetAncestor(child2, GA_PARENT);
9813 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
9814 }
9815 test = GetWindow(child2, GW_OWNER);
9816 ok(!test, "wrong owner %p\n", test);
9817
9818 test = SetParent(child2, parent);
9819 ok(test == GetDesktopWindow(), "wrong old parent %p\n", test);
9820
9821 /* test owner/parent of the parent */
9822 test = GetParent(parent);
9823 ok(!test, "wrong parent %p\n", test);
9824 ok(!IsChild(GetDesktopWindow(), parent), "wrong parent/child %p/%p\n", GetDesktopWindow(), parent);
9825 if(pGetAncestor) {
9826 test = pGetAncestor(parent, GA_PARENT);
9827 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
9828 }
9829 test = GetWindow(parent, GW_OWNER);
9830 ok(!test, "wrong owner %p\n", test);
9831
9832 /* test owner/parent of child1 */
9833 test = GetParent(child1);
9834 ok(test == parent, "wrong parent %p\n", test);
9835 ok(IsChild(parent, child1), "wrong parent/child %p/%p\n", parent, child1);
9836 if(pGetAncestor) {
9837 test = pGetAncestor(child1, GA_PARENT);
9838 ok(test == parent, "wrong parent %p\n", test);
9839 }
9840 test = GetWindow(child1, GW_OWNER);
9841 ok(!test, "wrong owner %p\n", test);
9842
9843 /* test owner/parent of child2 */
9844 test = GetParent(child2);
9845 ok(test == parent, "wrong parent %p\n", test);
9846 ok(IsChild(parent, child2), "wrong parent/child %p/%p\n", parent, child2);
9847 if(pGetAncestor) {
9848 test = pGetAncestor(child2, GA_PARENT);
9849 ok(test == parent, "wrong parent %p\n", test);
9850 }
9851 test = GetWindow(child2, GW_OWNER);
9852 ok(!test, "wrong owner %p\n", test);
9853
9854 /* test owner/parent of child3 */
9855 test = GetParent(child3);
9856 ok(test == child1, "wrong parent %p\n", test);
9857 ok(IsChild(parent, child3), "wrong parent/child %p/%p\n", parent, child3);
9858 if(pGetAncestor) {
9859 test = pGetAncestor(child3, GA_PARENT);
9860 ok(test == child1, "wrong parent %p\n", test);
9861 }
9862 test = GetWindow(child3, GW_OWNER);
9863 ok(!test, "wrong owner %p\n", test);
9864
9865 /* test owner/parent of child4 */
9866 test = GetParent(child4);
9867 ok(test == parent, "wrong parent %p\n", test);
9868 ok(!IsChild(parent, child4), "wrong parent/child %p/%p\n", parent, child4);
9869 if(pGetAncestor) {
9870 test = pGetAncestor(child4, GA_PARENT);
9871 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
9872 }
9873 test = GetWindow(child4, GW_OWNER);
9874 ok(test == parent, "wrong owner %p\n", test);
9875
9876 flush_sequence();
9877
9878 trace("parent %p, child1 %p, child2 %p, child3 %p, child4 %p\n",
9879 parent, child1, child2, child3, child4);
9880
9881 SetCapture(child4);
9882 test = GetCapture();
9883 ok(test == child4, "wrong capture window %p\n", test);
9884
9885 test_DestroyWindow_flag = TRUE;
9886 ret = DestroyWindow(parent);
9887 ok( ret, "DestroyWindow() error %d\n", GetLastError());
9888 test_DestroyWindow_flag = FALSE;
9889 ok_sequence(destroy_window_with_children, "destroy window with children", FALSE);
9890
9891 ok(!IsWindow(parent), "parent still exists\n");
9892 ok(!IsWindow(child1), "child1 still exists\n");
9893 ok(!IsWindow(child2), "child2 still exists\n");
9894 ok(!IsWindow(child3), "child3 still exists\n");
9895 ok(!IsWindow(child4), "child4 still exists\n");
9896
9897 test = GetCapture();
9898 ok(!test, "wrong capture window %p\n", test);
9899 }
9900
9901
9902 static const struct message WmDispatchPaint[] = {
9903 { WM_NCPAINT, sent },
9904 { WM_GETTEXT, sent|defwinproc|optional },
9905 { WM_GETTEXT, sent|defwinproc|optional },
9906 { WM_ERASEBKGND, sent },
9907 { 0 }
9908 };
9909
9910 static LRESULT WINAPI DispatchMessageCheckProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
9911 {
9912 if (message == WM_PAINT) return 0;
9913 return MsgCheckProcA( hwnd, message, wParam, lParam );
9914 }
9915
9916 static void test_DispatchMessage(void)
9917 {
9918 RECT rect;
9919 MSG msg;
9920 int count;
9921 HWND hwnd = CreateWindowA( "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
9922 100, 100, 200, 200, 0, 0, 0, NULL);
9923 ShowWindow( hwnd, SW_SHOW );
9924 UpdateWindow( hwnd );
9925 flush_events();
9926 flush_sequence();
9927 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)DispatchMessageCheckProc );
9928
9929 SetRect( &rect, -5, -5, 5, 5 );
9930 RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
9931 count = 0;
9932 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
9933 {
9934 if (msg.message != WM_PAINT) DispatchMessageA( &msg );
9935 else
9936 {
9937 flush_sequence();
9938 DispatchMessageA( &msg );
9939 /* DispatchMessage will send WM_NCPAINT if non client area is still invalid after WM_PAINT */
9940 if (!count) ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
9941 else ok_sequence( WmEmptySeq, "WmEmpty", FALSE );
9942 if (++count > 10) break;
9943 }
9944 }
9945 ok( msg.message == WM_PAINT && count > 10, "WM_PAINT messages stopped\n" );
9946
9947 trace("now without DispatchMessage\n");
9948 flush_sequence();
9949 RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
9950 count = 0;
9951 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
9952 {
9953 if (msg.message != WM_PAINT) DispatchMessageA( &msg );
9954 else
9955 {
9956 HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
9957 flush_sequence();
9958 /* this will send WM_NCCPAINT just like DispatchMessage does */
9959 GetUpdateRgn( hwnd, hrgn, TRUE );
9960 ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
9961 DeleteObject( hrgn );
9962 GetClientRect( hwnd, &rect );
9963 ValidateRect( hwnd, &rect ); /* this will stop WM_PAINTs */
9964 ok( !count, "Got multiple WM_PAINTs\n" );
9965 if (++count > 10) break;
9966 }
9967 }
9968
9969 flush_sequence();
9970 RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
9971 count = 0;
9972 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
9973 {
9974 if (msg.message != WM_PAINT) DispatchMessageA( &msg );
9975 else
9976 {
9977 HDC hdc;
9978
9979 flush_sequence();
9980 hdc = BeginPaint( hwnd, NULL );
9981 ok( !hdc, "got valid hdc %p from BeginPaint\n", hdc );
9982 ok( !EndPaint( hwnd, NULL ), "EndPaint succeeded\n" );
9983 ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
9984 ok( !count, "Got multiple WM_PAINTs\n" );
9985 if (++count > 10) break;
9986 }
9987 }
9988 DestroyWindow(hwnd);
9989 }
9990
9991
9992 static const struct message WmUser[] = {
9993 { WM_USER, sent },
9994 { 0 }
9995 };
9996
9997 struct sendmsg_info
9998 {
9999 HWND hwnd;
10000 DWORD timeout;
10001 DWORD ret;
10002 };
10003
10004 static DWORD CALLBACK send_msg_thread( LPVOID arg )
10005 {
10006 struct sendmsg_info *info = arg;
10007 SetLastError( 0xdeadbeef );
10008 info->ret = SendMessageTimeoutA( info->hwnd, WM_USER, 0, 0, 0, info->timeout, NULL );
10009 if (!info->ret) ok( GetLastError() == ERROR_TIMEOUT ||
10010 broken(GetLastError() == 0), /* win9x */
10011 "unexpected error %d\n", GetLastError());
10012 return 0;
10013 }
10014
10015 static void wait_for_thread( HANDLE thread )
10016 {
10017 while (MsgWaitForMultipleObjects(1, &thread, FALSE, INFINITE, QS_SENDMESSAGE) != WAIT_OBJECT_0)
10018 {
10019 MSG msg;
10020 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA(&msg);
10021 }
10022 }
10023
10024 static LRESULT WINAPI send_msg_delay_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
10025 {
10026 if (message == WM_USER) Sleep(200);
10027 return MsgCheckProcA( hwnd, message, wParam, lParam );
10028 }
10029
10030 static void test_SendMessageTimeout(void)
10031 {
10032 HANDLE thread;
10033 struct sendmsg_info info;
10034 DWORD tid;
10035 BOOL is_win9x;
10036
10037 info.hwnd = CreateWindowA( "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
10038 100, 100, 200, 200, 0, 0, 0, NULL);
10039 flush_events();
10040 flush_sequence();
10041
10042 info.timeout = 1000;
10043 info.ret = 0xdeadbeef;
10044 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
10045 wait_for_thread( thread );
10046 CloseHandle( thread );
10047 ok( info.ret == 1, "SendMessageTimeout failed\n" );
10048 ok_sequence( WmUser, "WmUser", FALSE );
10049
10050 info.timeout = 1;
10051 info.ret = 0xdeadbeef;
10052 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
10053 Sleep(100); /* SendMessageTimeout should time out here */
10054 wait_for_thread( thread );
10055 CloseHandle( thread );
10056 ok( info.ret == 0, "SendMessageTimeout succeeded\n" );
10057 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
10058
10059 /* 0 means infinite timeout (but not on win9x) */
10060 info.timeout = 0;
10061 info.ret = 0xdeadbeef;
10062 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
10063 Sleep(100);
10064 wait_for_thread( thread );
10065 CloseHandle( thread );
10066 is_win9x = !info.ret;
10067 if (is_win9x) ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
10068 else ok_sequence( WmUser, "WmUser", FALSE );
10069
10070 /* timeout is treated as signed despite the prototype (but not on win9x) */
10071 info.timeout = 0x7fffffff;
10072 info.ret = 0xdeadbeef;
10073 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
10074 Sleep(100);
10075 wait_for_thread( thread );
10076 CloseHandle( thread );
10077 ok( info.ret == 1, "SendMessageTimeout failed\n" );
10078 ok_sequence( WmUser, "WmUser", FALSE );
10079
10080 info.timeout = 0x80000000;
10081 info.ret = 0xdeadbeef;
10082 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
10083 Sleep(100);
10084 wait_for_thread( thread );
10085 CloseHandle( thread );
10086 if (is_win9x)
10087 {
10088 ok( info.ret == 1, "SendMessageTimeout failed\n" );
10089 ok_sequence( WmUser, "WmUser", FALSE );
10090 }
10091 else
10092 {
10093 ok( info.ret == 0, "SendMessageTimeout succeeded\n" );
10094 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
10095 }
10096
10097 /* now check for timeout during message processing */
10098 SetWindowLongPtrA( info.hwnd, GWLP_WNDPROC, (LONG_PTR)send_msg_delay_proc );
10099 info.timeout = 100;
10100 info.ret = 0xdeadbeef;
10101 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
10102 wait_for_thread( thread );
10103 CloseHandle( thread );
10104 /* we should time out but still get the message */
10105 ok( info.ret == 0, "SendMessageTimeout failed\n" );
10106 ok_sequence( WmUser, "WmUser", FALSE );
10107
10108 DestroyWindow( info.hwnd );
10109 }
10110
10111
10112 /****************** edit message test *************************/
10113 #define ID_EDIT 0x1234
10114 static const struct message sl_edit_setfocus[] =
10115 {
10116 { HCBT_SETFOCUS, hook },
10117 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
10118 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10119 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
10120 { WM_SETFOCUS, sent|wparam, 0 },
10121 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
10122 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 15 },
10123 { WM_CTLCOLOREDIT, sent|parent },
10124 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
10125 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10126 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10127 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
10128 { 0 }
10129 };
10130 static const struct message sl_edit_invisible[] =
10131 {
10132 { HCBT_SETFOCUS, hook },
10133 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
10134 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10135 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
10136 { WM_KILLFOCUS, sent|parent },
10137 { WM_SETFOCUS, sent },
10138 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
10139 { 0 }
10140 };
10141 static const struct message ml_edit_setfocus[] =
10142 {
10143 { HCBT_SETFOCUS, hook },
10144 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
10145 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10146 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
10147 { WM_SETFOCUS, sent|wparam, 0 },
10148 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
10149 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
10150 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10151 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10152 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
10153 { 0 }
10154 };
10155 static const struct message sl_edit_killfocus[] =
10156 {
10157 { HCBT_SETFOCUS, hook },
10158 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
10159 { WM_KILLFOCUS, sent|wparam, 0 },
10160 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10161 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10162 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_KILLFOCUS) },
10163 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
10164 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
10165 { 0 }
10166 };
10167 static const struct message sl_edit_lbutton_dblclk[] =
10168 {
10169 { WM_LBUTTONDBLCLK, sent },
10170 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
10171 { 0 }
10172 };
10173 static const struct message sl_edit_lbutton_down[] =
10174 {
10175 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
10176 { HCBT_SETFOCUS, hook },
10177 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
10178 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10179 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
10180 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
10181 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
10182 { WM_CTLCOLOREDIT, sent|parent },
10183 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
10184 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10185 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10186 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10187 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
10188 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
10189 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10190 { WM_CTLCOLOREDIT, sent|parent|optional },
10191 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
10192 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10193 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10194 { 0 }
10195 };
10196 static const struct message ml_edit_lbutton_down[] =
10197 {
10198 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
10199 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
10200 { HCBT_SETFOCUS, hook },
10201 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
10202 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10203 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
10204 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
10205 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
10206 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
10207 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10208 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10209 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
10210 { 0 }
10211 };
10212 static const struct message sl_edit_lbutton_up[] =
10213 {
10214 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
10215 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10216 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
10217 { WM_CAPTURECHANGED, sent|defwinproc },
10218 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10219 { 0 }
10220 };
10221 static const struct message ml_edit_lbutton_up[] =
10222 {
10223 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
10224 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
10225 { WM_CAPTURECHANGED, sent|defwinproc },
10226 { 0 }
10227 };
10228
10229 static WNDPROC old_edit_proc;
10230
10231 static LRESULT CALLBACK edit_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
10232 {
10233 static LONG defwndproc_counter = 0;
10234 LRESULT ret;
10235 struct recvd_message msg;
10236
10237 if (ignore_message( message )) return 0;
10238
10239 msg.hwnd = hwnd;
10240 msg.message = message;
10241 msg.flags = sent|wparam|lparam;
10242 if (defwndproc_counter) msg.flags |= defwinproc;
10243 msg.wParam = wParam;
10244 msg.lParam = lParam;
10245 msg.descr = "edit";
10246 add_message(&msg);
10247
10248 defwndproc_counter++;
10249 ret = CallWindowProcA(old_edit_proc, hwnd, message, wParam, lParam);
10250 defwndproc_counter--;
10251
10252 return ret;
10253 }
10254
10255 static void subclass_edit(void)
10256 {
10257 WNDCLASSA cls;
10258
10259 if (!GetClassInfoA(0, "edit", &cls)) assert(0);
10260
10261 old_edit_proc = cls.lpfnWndProc;
10262
10263 cls.hInstance = GetModuleHandleA(NULL);
10264 cls.lpfnWndProc = edit_hook_proc;
10265 cls.lpszClassName = "my_edit_class";
10266 UnregisterClassA(cls.lpszClassName, cls.hInstance);
10267 if (!RegisterClassA(&cls)) assert(0);
10268 }
10269
10270 static void test_edit_messages(void)
10271 {
10272 HWND hwnd, parent;
10273 DWORD dlg_code;
10274
10275 subclass_edit();
10276 log_all_parent_messages++;
10277
10278 parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
10279 100, 100, 200, 200, 0, 0, 0, NULL);
10280 ok (parent != 0, "Failed to create parent window\n");
10281
10282 /* test single line edit */
10283 hwnd = CreateWindowExA(0, "my_edit_class", "test", WS_CHILD,
10284 0, 0, 80, 20, parent, (HMENU)ID_EDIT, 0, NULL);
10285 ok(hwnd != 0, "Failed to create edit window\n");
10286
10287 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
10288 ok(dlg_code == (DLGC_WANTCHARS|DLGC_HASSETSEL|DLGC_WANTARROWS), "wrong dlg_code %08x\n", dlg_code);
10289
10290 flush_sequence();
10291 SetFocus(hwnd);
10292 ok_sequence(sl_edit_invisible, "SetFocus(hwnd) on an invisible edit", FALSE);
10293
10294 ShowWindow(hwnd, SW_SHOW);
10295 UpdateWindow(hwnd);
10296 SetFocus(0);
10297 flush_sequence();
10298
10299 SetFocus(hwnd);
10300 ok_sequence(sl_edit_setfocus, "SetFocus(hwnd) on an edit", FALSE);
10301
10302 SetFocus(0);
10303 ok_sequence(sl_edit_killfocus, "SetFocus(0) on an edit", FALSE);
10304
10305 SetFocus(0);
10306 ReleaseCapture();
10307 flush_sequence();
10308
10309 SendMessageA(hwnd, WM_LBUTTONDBLCLK, 0, 0);
10310 ok_sequence(sl_edit_lbutton_dblclk, "WM_LBUTTONDBLCLK on an edit", FALSE);
10311
10312 SetFocus(0);
10313 ReleaseCapture();
10314 flush_sequence();
10315
10316 SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
10317 ok_sequence(sl_edit_lbutton_down, "WM_LBUTTONDOWN on an edit", FALSE);
10318
10319 SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
10320 ok_sequence(sl_edit_lbutton_up, "WM_LBUTTONUP on an edit", FALSE);
10321
10322 DestroyWindow(hwnd);
10323
10324 /* test multiline edit */
10325 hwnd = CreateWindowExA(0, "my_edit_class", "test", WS_CHILD | ES_MULTILINE,
10326 0, 0, 80, 20, parent, (HMENU)ID_EDIT, 0, NULL);
10327 ok(hwnd != 0, "Failed to create edit window\n");
10328
10329 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
10330 ok(dlg_code == (DLGC_WANTCHARS|DLGC_HASSETSEL|DLGC_WANTARROWS|DLGC_WANTALLKEYS),
10331 "wrong dlg_code %08x\n", dlg_code);
10332
10333 ShowWindow(hwnd, SW_SHOW);
10334 UpdateWindow(hwnd);
10335 SetFocus(0);
10336 flush_sequence();
10337
10338 SetFocus(hwnd);
10339 ok_sequence(ml_edit_setfocus, "SetFocus(hwnd) on multiline edit", FALSE);
10340
10341 SetFocus(0);
10342 ok_sequence(sl_edit_killfocus, "SetFocus(0) on multiline edit", FALSE);
10343
10344 SetFocus(0);
10345 ReleaseCapture();
10346 flush_sequence();
10347
10348 SendMessageA(hwnd, WM_LBUTTONDBLCLK, 0, 0);
10349 ok_sequence(sl_edit_lbutton_dblclk, "WM_LBUTTONDBLCLK on multiline edit", FALSE);
10350
10351 SetFocus(0);
10352 ReleaseCapture();
10353 flush_sequence();
10354
10355 SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
10356 ok_sequence(ml_edit_lbutton_down, "WM_LBUTTONDOWN on multiline edit", FALSE);
10357
10358 SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
10359 ok_sequence(ml_edit_lbutton_up, "WM_LBUTTONUP on multiline edit", FALSE);
10360
10361 DestroyWindow(hwnd);
10362 DestroyWindow(parent);
10363
10364 log_all_parent_messages--;
10365 }
10366
10367 /**************************** End of Edit test ******************************/
10368
10369 static const struct message WmKeyDownSkippedSeq[] =
10370 {
10371 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
10372 { 0 }
10373 };
10374 static const struct message WmKeyDownWasDownSkippedSeq[] =
10375 {
10376 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x40000001 }, /* XP */
10377 { 0 }
10378 };
10379 static const struct message WmKeyUpSkippedSeq[] =
10380 {
10381 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
10382 { 0 }
10383 };
10384 static const struct message WmUserKeyUpSkippedSeq[] =
10385 {
10386 { WM_USER, sent },
10387 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
10388 { 0 }
10389 };
10390
10391 #define EV_STOP 0
10392 #define EV_SENDMSG 1
10393 #define EV_ACK 2
10394
10395 struct peekmsg_info
10396 {
10397 HWND hwnd;
10398 HANDLE hevent[3]; /* 0 - start/stop, 1 - SendMessage, 2 - ack */
10399 };
10400
10401 static DWORD CALLBACK send_msg_thread_2(void *param)
10402 {
10403 DWORD ret;
10404 struct peekmsg_info *info = param;
10405
10406 trace("thread: looping\n");
10407 SetEvent(info->hevent[EV_ACK]);
10408
10409 while (1)
10410 {
10411 ret = WaitForMultipleObjects(2, info->hevent, FALSE, INFINITE);
10412
10413 switch (ret)
10414 {
10415 case WAIT_OBJECT_0 + EV_STOP:
10416 trace("thread: exiting\n");
10417 return 0;
10418
10419 case WAIT_OBJECT_0 + EV_SENDMSG:
10420 trace("thread: sending message\n");
10421 ret = SendNotifyMessageA(info->hwnd, WM_USER, 0, 0);
10422 ok(ret, "SendNotifyMessageA failed error %u\n", GetLastError());
10423 SetEvent(info->hevent[EV_ACK]);
10424 break;
10425
10426 default:
10427 trace("unexpected return: %04x\n", ret);
10428 assert(0);
10429 break;
10430 }
10431 }
10432 return 0;
10433 }
10434
10435 static void test_PeekMessage(void)
10436 {
10437 MSG msg;
10438 HANDLE hthread;
10439 DWORD tid, qstatus;
10440 UINT qs_all_input = QS_ALLINPUT;
10441 UINT qs_input = QS_INPUT;
10442 BOOL ret;
10443 struct peekmsg_info info;
10444
10445 info.hwnd = CreateWindowA("TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
10446 100, 100, 200, 200, 0, 0, 0, NULL);
10447 assert(info.hwnd);
10448 ShowWindow(info.hwnd, SW_SHOW);
10449 UpdateWindow(info.hwnd);
10450 SetFocus(info.hwnd);
10451
10452 info.hevent[EV_STOP] = CreateEventA(NULL, 0, 0, NULL);
10453 info.hevent[EV_SENDMSG] = CreateEventA(NULL, 0, 0, NULL);
10454 info.hevent[EV_ACK] = CreateEventA(NULL, 0, 0, NULL);
10455
10456 hthread = CreateThread(NULL, 0, send_msg_thread_2, &info, 0, &tid);
10457 WaitForSingleObject(info.hevent[EV_ACK], 10000);
10458
10459 flush_events();
10460 flush_sequence();
10461
10462 SetLastError(0xdeadbeef);
10463 qstatus = GetQueueStatus(qs_all_input);
10464 if (GetLastError() == ERROR_INVALID_FLAGS)
10465 {
10466 trace("QS_RAWINPUT not supported on this platform\n");
10467 qs_all_input &= ~QS_RAWINPUT;
10468 qs_input &= ~QS_RAWINPUT;
10469 }
10470 if (qstatus & QS_POSTMESSAGE)
10471 {
10472 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) /* nothing */ ;
10473 qstatus = GetQueueStatus(qs_all_input);
10474 }
10475 ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
10476
10477 trace("signalling to send message\n");
10478 SetEvent(info.hevent[EV_SENDMSG]);
10479 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
10480
10481 /* pass invalid QS_xxxx flags */
10482 SetLastError(0xdeadbeef);
10483 qstatus = GetQueueStatus(0xffffffff);
10484 ok(qstatus == 0 || broken(qstatus) /* win9x */, "GetQueueStatus should fail: %08x\n", qstatus);
10485 if (!qstatus)
10486 {
10487 ok(GetLastError() == ERROR_INVALID_FLAGS, "wrong error %d\n", GetLastError());
10488 qstatus = GetQueueStatus(qs_all_input);
10489 }
10490 qstatus &= ~MAKELONG( 0x4000, 0x4000 ); /* sometimes set on Win95 */
10491 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE),
10492 "wrong qstatus %08x\n", qstatus);
10493
10494 msg.message = 0;
10495 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
10496 ok(!ret,
10497 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10498 msg.message);
10499 ok_sequence(WmUser, "WmUser", FALSE);
10500
10501 qstatus = GetQueueStatus(qs_all_input);
10502 ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
10503
10504 keybd_event('N', 0, 0, 0);
10505 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
10506 qstatus = GetQueueStatus(qs_all_input);
10507 if (!(qstatus & MAKELONG(QS_KEY, QS_KEY)))
10508 {
10509 skip( "queuing key events not supported\n" );
10510 goto done;
10511 }
10512 ok(qstatus == MAKELONG(QS_KEY, QS_KEY) ||
10513 /* keybd_event seems to trigger a sent message on NT4 */
10514 qstatus == MAKELONG(QS_KEY|QS_SENDMESSAGE, QS_KEY|QS_SENDMESSAGE),
10515 "wrong qstatus %08x\n", qstatus);
10516
10517 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
10518 qstatus = GetQueueStatus(qs_all_input);
10519 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY) ||
10520 qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY|QS_SENDMESSAGE),
10521 "wrong qstatus %08x\n", qstatus);
10522
10523 InvalidateRect(info.hwnd, NULL, FALSE);
10524 qstatus = GetQueueStatus(qs_all_input);
10525 ok(qstatus == MAKELONG(QS_PAINT, QS_PAINT|QS_POSTMESSAGE|QS_KEY) ||
10526 qstatus == MAKELONG(QS_PAINT, QS_PAINT|QS_POSTMESSAGE|QS_KEY|QS_SENDMESSAGE),
10527 "wrong qstatus %08x\n", qstatus);
10528
10529 trace("signalling to send message\n");
10530 SetEvent(info.hevent[EV_SENDMSG]);
10531 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
10532
10533 qstatus = GetQueueStatus(qs_all_input);
10534 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_PAINT|QS_POSTMESSAGE|QS_KEY),
10535 "wrong qstatus %08x\n", qstatus);
10536
10537 msg.message = 0;
10538 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (qs_input << 16));
10539 if (ret && msg.message == WM_CHAR)
10540 {
10541 win_skip( "PM_QS_* flags not supported in PeekMessage\n" );
10542 goto done;
10543 }
10544 ok(!ret,
10545 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10546 msg.message);
10547 if (!sequence_cnt) /* nt4 doesn't fetch anything with PM_QS_* flags */
10548 {
10549 win_skip( "PM_QS_* flags not supported in PeekMessage\n" );
10550 goto done;
10551 }
10552 ok_sequence(WmUser, "WmUser", FALSE);
10553
10554 qstatus = GetQueueStatus(qs_all_input);
10555 ok(qstatus == MAKELONG(0, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
10556 "wrong qstatus %08x\n", qstatus);
10557
10558 trace("signalling to send message\n");
10559 SetEvent(info.hevent[EV_SENDMSG]);
10560 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
10561
10562 qstatus = GetQueueStatus(qs_all_input);
10563 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_PAINT|QS_POSTMESSAGE|QS_KEY),
10564 "wrong qstatus %08x\n", qstatus);
10565
10566 msg.message = 0;
10567 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE );
10568 ok(!ret,
10569 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10570 msg.message);
10571 ok_sequence(WmUser, "WmUser", FALSE);
10572
10573 qstatus = GetQueueStatus(qs_all_input);
10574 ok(qstatus == MAKELONG(0, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
10575 "wrong qstatus %08x\n", qstatus);
10576
10577 msg.message = 0;
10578 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE);
10579 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
10580 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
10581 ret, msg.message, msg.wParam);
10582 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10583
10584 qstatus = GetQueueStatus(qs_all_input);
10585 ok(qstatus == MAKELONG(0, QS_PAINT|QS_KEY),
10586 "wrong qstatus %08x\n", qstatus);
10587
10588 msg.message = 0;
10589 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE);
10590 ok(!ret,
10591 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10592 msg.message);
10593 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10594
10595 qstatus = GetQueueStatus(qs_all_input);
10596 ok(qstatus == MAKELONG(0, QS_PAINT|QS_KEY),
10597 "wrong qstatus %08x\n", qstatus);
10598
10599 msg.message = 0;
10600 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_PAINT);
10601 ok(ret && msg.message == WM_PAINT,
10602 "got %d and %04x instead of TRUE and WM_PAINT\n", ret, msg.message);
10603 DispatchMessageA(&msg);
10604 ok_sequence(WmPaint, "WmPaint", FALSE);
10605
10606 qstatus = GetQueueStatus(qs_all_input);
10607 ok(qstatus == MAKELONG(0, QS_KEY),
10608 "wrong qstatus %08x\n", qstatus);
10609
10610 msg.message = 0;
10611 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_PAINT);
10612 ok(!ret,
10613 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10614 msg.message);
10615 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10616
10617 qstatus = GetQueueStatus(qs_all_input);
10618 ok(qstatus == MAKELONG(0, QS_KEY),
10619 "wrong qstatus %08x\n", qstatus);
10620
10621 trace("signalling to send message\n");
10622 SetEvent(info.hevent[EV_SENDMSG]);
10623 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
10624
10625 qstatus = GetQueueStatus(qs_all_input);
10626 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_KEY),
10627 "wrong qstatus %08x\n", qstatus);
10628
10629 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
10630
10631 qstatus = GetQueueStatus(qs_all_input);
10632 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
10633 "wrong qstatus %08x\n", qstatus);
10634
10635 msg.message = 0;
10636 ret = PeekMessageA(&msg, 0, WM_CHAR, WM_CHAR, PM_REMOVE);
10637 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
10638 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
10639 ret, msg.message, msg.wParam);
10640 ok_sequence(WmUser, "WmUser", FALSE);
10641
10642 qstatus = GetQueueStatus(qs_all_input);
10643 ok(qstatus == MAKELONG(0, QS_KEY),
10644 "wrong qstatus %08x\n", qstatus);
10645
10646 msg.message = 0;
10647 ret = PeekMessageA(&msg, 0, WM_CHAR, WM_CHAR, PM_REMOVE);
10648 ok(!ret,
10649 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10650 msg.message);
10651 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10652
10653 qstatus = GetQueueStatus(qs_all_input);
10654 ok(qstatus == MAKELONG(0, QS_KEY),
10655 "wrong qstatus %08x\n", qstatus);
10656
10657 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
10658
10659 qstatus = GetQueueStatus(qs_all_input);
10660 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY),
10661 "wrong qstatus %08x\n", qstatus);
10662
10663 trace("signalling to send message\n");
10664 SetEvent(info.hevent[EV_SENDMSG]);
10665 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
10666
10667 qstatus = GetQueueStatus(qs_all_input);
10668 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
10669 "wrong qstatus %08x\n", qstatus);
10670
10671 msg.message = 0;
10672 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_KEY << 16));
10673 ok(!ret,
10674 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10675 msg.message);
10676 ok_sequence(WmUser, "WmUser", FALSE);
10677
10678 qstatus = GetQueueStatus(qs_all_input);
10679 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE|QS_KEY),
10680 "wrong qstatus %08x\n", qstatus);
10681
10682 msg.message = 0;
10683 if (qs_all_input & QS_RAWINPUT) /* use QS_RAWINPUT only if supported */
10684 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_RAWINPUT << 16));
10685 else /* workaround for a missing QS_RAWINPUT support */
10686 ret = PeekMessageA(&msg, 0, WM_KEYDOWN, WM_KEYDOWN, PM_REMOVE);
10687 ok(ret && msg.message == WM_KEYDOWN && msg.wParam == 'N',
10688 "got %d and %04x wParam %08lx instead of TRUE and WM_KEYDOWN wParam 'N'\n",
10689 ret, msg.message, msg.wParam);
10690 ok_sequence(WmKeyDownSkippedSeq, "WmKeyDownSkippedSeq", FALSE);
10691
10692 qstatus = GetQueueStatus(qs_all_input);
10693 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE|QS_KEY),
10694 "wrong qstatus %08x\n", qstatus);
10695
10696 msg.message = 0;
10697 if (qs_all_input & QS_RAWINPUT) /* use QS_RAWINPUT only if supported */
10698 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_RAWINPUT << 16));
10699 else /* workaround for a missing QS_RAWINPUT support */
10700 ret = PeekMessageA(&msg, 0, WM_KEYUP, WM_KEYUP, PM_REMOVE);
10701 ok(ret && msg.message == WM_KEYUP && msg.wParam == 'N',
10702 "got %d and %04x wParam %08lx instead of TRUE and WM_KEYUP wParam 'N'\n",
10703 ret, msg.message, msg.wParam);
10704 ok_sequence(WmKeyUpSkippedSeq, "WmKeyUpSkippedSeq", FALSE);
10705
10706 qstatus = GetQueueStatus(qs_all_input);
10707 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
10708 "wrong qstatus %08x\n", qstatus);
10709
10710 msg.message = 0;
10711 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE);
10712 ok(!ret,
10713 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10714 msg.message);
10715 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10716
10717 qstatus = GetQueueStatus(qs_all_input);
10718 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
10719 "wrong qstatus %08x\n", qstatus);
10720
10721 msg.message = 0;
10722 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
10723 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
10724 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
10725 ret, msg.message, msg.wParam);
10726 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10727
10728 qstatus = GetQueueStatus(qs_all_input);
10729 ok(qstatus == 0,
10730 "wrong qstatus %08x\n", qstatus);
10731
10732 msg.message = 0;
10733 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
10734 ok(!ret,
10735 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10736 msg.message);
10737 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10738
10739 qstatus = GetQueueStatus(qs_all_input);
10740 ok(qstatus == 0,
10741 "wrong qstatus %08x\n", qstatus);
10742
10743 /* test whether presence of the quit flag in the queue affects
10744 * the queue state
10745 */
10746 PostQuitMessage(0x1234abcd);
10747
10748 qstatus = GetQueueStatus(qs_all_input);
10749 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE),
10750 "wrong qstatus %08x\n", qstatus);
10751
10752 PostMessageA(info.hwnd, WM_USER, 0, 0);
10753
10754 qstatus = GetQueueStatus(qs_all_input);
10755 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE),
10756 "wrong qstatus %08x\n", qstatus);
10757
10758 msg.message = 0;
10759 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
10760 ok(ret && msg.message == WM_USER,
10761 "got %d and %04x instead of TRUE and WM_USER\n", ret, msg.message);
10762 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10763
10764 qstatus = GetQueueStatus(qs_all_input);
10765 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
10766 "wrong qstatus %08x\n", qstatus);
10767
10768 msg.message = 0;
10769 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
10770 ok(ret && msg.message == WM_QUIT,
10771 "got %d and %04x instead of TRUE and WM_QUIT\n", ret, msg.message);
10772 ok(msg.wParam == 0x1234abcd, "got wParam %08lx instead of 0x1234abcd\n", msg.wParam);
10773 ok(msg.lParam == 0, "got lParam %08lx instead of 0\n", msg.lParam);
10774 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10775
10776 qstatus = GetQueueStatus(qs_all_input);
10777 todo_wine {
10778 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
10779 "wrong qstatus %08x\n", qstatus);
10780 }
10781
10782 msg.message = 0;
10783 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
10784 ok(!ret,
10785 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10786 msg.message);
10787 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10788
10789 qstatus = GetQueueStatus(qs_all_input);
10790 ok(qstatus == 0,
10791 "wrong qstatus %08x\n", qstatus);
10792
10793 /* some GetMessage tests */
10794
10795 keybd_event('N', 0, 0, 0);
10796 qstatus = GetQueueStatus(qs_all_input);
10797 ok(qstatus == MAKELONG(QS_KEY, QS_KEY), "wrong qstatus %08x\n", qstatus);
10798
10799 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
10800 qstatus = GetQueueStatus(qs_all_input);
10801 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY), "wrong qstatus %08x\n", qstatus);
10802
10803 if (qstatus)
10804 {
10805 ret = GetMessageA( &msg, 0, 0, 0 );
10806 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
10807 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
10808 ret, msg.message, msg.wParam);
10809 qstatus = GetQueueStatus(qs_all_input);
10810 ok(qstatus == MAKELONG(0, QS_KEY), "wrong qstatus %08x\n", qstatus);
10811 }
10812
10813 if (qstatus)
10814 {
10815 ret = GetMessageA( &msg, 0, 0, 0 );
10816 ok(ret && msg.message == WM_KEYDOWN && msg.wParam == 'N',
10817 "got %d and %04x wParam %08lx instead of TRUE and WM_KEYDOWN wParam 'N'\n",
10818 ret, msg.message, msg.wParam);
10819 ok_sequence(WmKeyDownSkippedSeq, "WmKeyDownSkippedSeq", FALSE);
10820 qstatus = GetQueueStatus(qs_all_input);
10821 ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
10822 }
10823
10824 keybd_event('N', 0, 0, 0);
10825 qstatus = GetQueueStatus(qs_all_input);
10826 ok(qstatus == MAKELONG(QS_KEY, QS_KEY), "wrong qstatus %08x\n", qstatus);
10827
10828 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
10829 qstatus = GetQueueStatus(qs_all_input);
10830 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY), "wrong qstatus %08x\n", qstatus);
10831
10832 if (qstatus & (QS_KEY << 16))
10833 {
10834 ret = GetMessageA( &msg, 0, WM_KEYDOWN, WM_KEYUP );
10835 ok(ret && msg.message == WM_KEYDOWN && msg.wParam == 'N',
10836 "got %d and %04x wParam %08lx instead of TRUE and WM_KEYDOWN wParam 'N'\n",
10837 ret, msg.message, msg.wParam);
10838 ok_sequence(WmKeyDownWasDownSkippedSeq, "WmKeyDownWasDownSkippedSeq", FALSE);
10839 qstatus = GetQueueStatus(qs_all_input);
10840 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE), "wrong qstatus %08x\n", qstatus);
10841 }
10842
10843 if (qstatus)
10844 {
10845 ret = GetMessageA( &msg, 0, WM_CHAR, WM_CHAR );
10846 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
10847 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
10848 ret, msg.message, msg.wParam);
10849 qstatus = GetQueueStatus(qs_all_input);
10850 ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
10851 }
10852
10853 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
10854 qstatus = GetQueueStatus(qs_all_input);
10855 ok(qstatus == MAKELONG(QS_KEY, QS_KEY), "wrong qstatus %08x\n", qstatus);
10856
10857 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
10858 qstatus = GetQueueStatus(qs_all_input);
10859 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY), "wrong qstatus %08x\n", qstatus);
10860
10861 trace("signalling to send message\n");
10862 SetEvent(info.hevent[EV_SENDMSG]);
10863 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
10864 qstatus = GetQueueStatus(qs_all_input);
10865 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
10866 "wrong qstatus %08x\n", qstatus);
10867
10868 if (qstatus & (QS_KEY << 16))
10869 {
10870 ret = GetMessageA( &msg, 0, WM_KEYDOWN, WM_KEYUP );
10871 ok(ret && msg.message == WM_KEYUP && msg.wParam == 'N',
10872 "got %d and %04x wParam %08lx instead of TRUE and WM_KEYDOWN wParam 'N'\n",
10873 ret, msg.message, msg.wParam);
10874 ok_sequence(WmUserKeyUpSkippedSeq, "WmUserKeyUpSkippedSeq", FALSE);
10875 qstatus = GetQueueStatus(qs_all_input);
10876 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE), "wrong qstatus %08x\n", qstatus);
10877 }
10878
10879 if (qstatus)
10880 {
10881 ret = GetMessageA( &msg, 0, WM_CHAR, WM_CHAR );
10882 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
10883 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
10884 ret, msg.message, msg.wParam);
10885 qstatus = GetQueueStatus(qs_all_input);
10886 ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
10887 }
10888 done:
10889 trace("signalling to exit\n");
10890 SetEvent(info.hevent[EV_STOP]);
10891
10892 WaitForSingleObject(hthread, INFINITE);
10893
10894 CloseHandle(hthread);
10895 CloseHandle(info.hevent[0]);
10896 CloseHandle(info.hevent[1]);
10897 CloseHandle(info.hevent[2]);
10898
10899 DestroyWindow(info.hwnd);
10900 }
10901
10902 static void wait_move_event(HWND hwnd, int x, int y)
10903 {
10904 MSG msg;
10905 DWORD time;
10906 BOOL ret;
10907
10908 time = GetTickCount();
10909 while (GetTickCount() - time < 200) {
10910 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
10911 if (ret && msg.pt.x > x && msg.pt.y > y) break;
10912 if (!ret) MsgWaitForMultipleObjects( 0, NULL, FALSE, GetTickCount() - time, QS_ALLINPUT );
10913 else Sleep( GetTickCount() - time );
10914 }
10915 }
10916
10917 #define STEP 5
10918 static void test_PeekMessage2(void)
10919 {
10920 HWND hwnd;
10921 BOOL ret;
10922 MSG msg;
10923 UINT message;
10924 DWORD time1, time2, time3;
10925 int x1, y1, x2, y2, x3, y3;
10926 POINT pos;
10927
10928 time1 = time2 = time3 = 0;
10929 x1 = y1 = x2 = y2 = x3 = y3 = 0;
10930
10931 /* Initialise window and make sure it is ready for events */
10932 hwnd = CreateWindowA("TestWindowClass", "PeekMessage2", WS_OVERLAPPEDWINDOW,
10933 10, 10, 800, 800, NULL, NULL, NULL, NULL);
10934 assert(hwnd);
10935 trace("Window for test_PeekMessage2 %p\n", hwnd);
10936 ShowWindow(hwnd, SW_SHOW);
10937 UpdateWindow(hwnd);
10938 SetFocus(hwnd);
10939 GetCursorPos(&pos);
10940 SetCursorPos(100, 100);
10941 mouse_event(MOUSEEVENTF_MOVE, -STEP, -STEP, 0, 0);
10942 flush_events();
10943
10944 /* Do initial mousemove, wait until we can see it
10945 and then do our test peek with PM_NOREMOVE. */
10946 mouse_event(MOUSEEVENTF_MOVE, STEP, STEP, 0, 0);
10947 wait_move_event(hwnd, 100-STEP, 100-STEP);
10948
10949 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
10950 if (!ret)
10951 {
10952 skip( "queuing mouse events not supported\n" );
10953 goto done;
10954 }
10955 else
10956 {
10957 trace("1st move event: %04x %x %d %d\n", msg.message, msg.time, msg.pt.x, msg.pt.y);
10958 message = msg.message;
10959 time1 = msg.time;
10960 x1 = msg.pt.x;
10961 y1 = msg.pt.y;
10962 ok(message == WM_MOUSEMOVE, "message not WM_MOUSEMOVE, %04x instead\n", message);
10963 }
10964
10965 /* Allow time to advance a bit, and then simulate the user moving their
10966 * mouse around. After that we peek again with PM_NOREMOVE.
10967 * Although the previous mousemove message was never removed, the
10968 * mousemove we now peek should reflect the recent mouse movements
10969 * because the input queue will merge the move events. */
10970 Sleep(100);
10971 mouse_event(MOUSEEVENTF_MOVE, STEP, STEP, 0, 0);
10972 wait_move_event(hwnd, x1, y1);
10973
10974 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
10975 ok(ret, "no message available\n");
10976 if (ret) {
10977 trace("2nd move event: %04x %x %d %d\n", msg.message, msg.time, msg.pt.x, msg.pt.y);
10978 message = msg.message;
10979 time2 = msg.time;
10980 x2 = msg.pt.x;
10981 y2 = msg.pt.y;
10982 ok(message == WM_MOUSEMOVE, "message not WM_MOUSEMOVE, %04x instead\n", message);
10983 ok(time2 > time1, "message time not advanced: %x %x\n", time1, time2);
10984 ok(x2 != x1 && y2 != y1, "coords not changed: (%d %d) (%d %d)\n", x1, y1, x2, y2);
10985 }
10986
10987 /* Have another go, to drive the point home */
10988 Sleep(100);
10989 mouse_event(MOUSEEVENTF_MOVE, STEP, STEP, 0, 0);
10990 wait_move_event(hwnd, x2, y2);
10991
10992 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
10993 ok(ret, "no message available\n");
10994 if (ret) {
10995 trace("3rd move event: %04x %x %d %d\n", msg.message, msg.time, msg.pt.x, msg.pt.y);
10996 message = msg.message;
10997 time3 = msg.time;
10998 x3 = msg.pt.x;
10999 y3 = msg.pt.y;
11000 ok(message == WM_MOUSEMOVE, "message not WM_MOUSEMOVE, %04x instead\n", message);
11001 ok(time3 > time2, "message time not advanced: %x %x\n", time2, time3);
11002 ok(x3 != x2 && y3 != y2, "coords not changed: (%d %d) (%d %d)\n", x2, y2, x3, y3);
11003 }
11004
11005 done:
11006 DestroyWindow(hwnd);
11007 SetCursorPos(pos.x, pos.y);
11008 flush_events();
11009 }
11010
11011 static void test_PeekMessage3(void)
11012 {
11013 HWND hwnd;
11014 BOOL ret;
11015 MSG msg;
11016
11017 hwnd = CreateWindowA("TestWindowClass", "PeekMessage3", WS_OVERLAPPEDWINDOW,
11018 10, 10, 800, 800, NULL, NULL, NULL, NULL);
11019 ok(hwnd != NULL, "expected hwnd != NULL\n");
11020 flush_events();
11021
11022 /* GetMessage() and PeekMessage(..., PM_REMOVE) should prefer messages which
11023 * were already seen. */
11024
11025 SetTimer(hwnd, 1, 0, NULL);
11026 while (!PeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE));
11027 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11028 PostMessageA(hwnd, WM_USER, 0, 0);
11029 ret = PeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE);
11030 todo_wine
11031 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11032 ret = GetMessageA(&msg, NULL, 0, 0);
11033 todo_wine
11034 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11035 ret = GetMessageA(&msg, NULL, 0, 0);
11036 todo_wine
11037 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
11038 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
11039 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
11040
11041 SetTimer(hwnd, 1, 0, NULL);
11042 while (!PeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE));
11043 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11044 PostMessageA(hwnd, WM_USER, 0, 0);
11045 ret = PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE);
11046 todo_wine
11047 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11048 ret = PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE);
11049 todo_wine
11050 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
11051 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
11052 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
11053
11054 /* It doesn't matter if a message range is specified or not. */
11055
11056 SetTimer(hwnd, 1, 0, NULL);
11057 while (!PeekMessageA(&msg, NULL, WM_TIMER, WM_TIMER, PM_NOREMOVE));
11058 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11059 PostMessageA(hwnd, WM_USER, 0, 0);
11060 ret = GetMessageA(&msg, NULL, 0, 0);
11061 todo_wine
11062 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11063 ret = GetMessageA(&msg, NULL, 0, 0);
11064 todo_wine
11065 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
11066 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
11067 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
11068
11069 /* But not if the post messages were added before the PeekMessage() call. */
11070
11071 PostMessageA(hwnd, WM_USER, 0, 0);
11072 SetTimer(hwnd, 1, 0, NULL);
11073 while (!PeekMessageA(&msg, NULL, WM_TIMER, WM_TIMER, PM_NOREMOVE));
11074 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11075 ret = GetMessageA(&msg, NULL, 0, 0);
11076 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
11077 ret = GetMessageA(&msg, NULL, 0, 0);
11078 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11079 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
11080 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
11081
11082 /* More complicated test with multiple messages. */
11083
11084 PostMessageA(hwnd, WM_USER, 0, 0);
11085 SetTimer(hwnd, 1, 0, NULL);
11086 while (!PeekMessageA(&msg, NULL, WM_TIMER, WM_TIMER, PM_NOREMOVE));
11087 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11088 PostMessageA(hwnd, WM_USER + 1, 0, 0);
11089 ret = GetMessageA(&msg, NULL, 0, 0);
11090 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
11091 ret = GetMessageA(&msg, NULL, 0, 0);
11092 todo_wine
11093 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11094 ret = GetMessageA(&msg, NULL, 0, 0);
11095 todo_wine
11096 ok(ret && msg.message == WM_USER + 1, "msg.message = %u instead of WM_USER + 1\n", msg.message);
11097 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
11098 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
11099
11100 /* Also works for posted messages, but the situation is a bit different,
11101 * because both messages are in the same queue. */
11102
11103 PostMessageA(hwnd, WM_TIMER, 0, 0);
11104 while (!PeekMessageA(&msg, NULL, WM_TIMER, WM_TIMER, PM_NOREMOVE));
11105 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11106 PostMessageA(hwnd, WM_USER, 0, 0);
11107 ret = GetMessageA(&msg, NULL, 0, 0);
11108 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11109 ret = GetMessageA(&msg, NULL, 0, 0);
11110 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
11111 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
11112 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
11113
11114 PostMessageA(hwnd, WM_USER, 0, 0);
11115 PostMessageA(hwnd, WM_TIMER, 0, 0);
11116 while (!PeekMessageA(&msg, NULL, WM_TIMER, WM_TIMER, PM_NOREMOVE));
11117 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11118 ret = GetMessageA(&msg, NULL, 0, 0);
11119 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
11120 ret = GetMessageA(&msg, NULL, 0, 0);
11121 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11122 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
11123 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
11124
11125 DestroyWindow(hwnd);
11126 flush_events();
11127 }
11128
11129 static INT_PTR CALLBACK wm_quit_dlg_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
11130 {
11131 struct recvd_message msg;
11132
11133 if (ignore_message( message )) return 0;
11134
11135 msg.hwnd = hwnd;
11136 msg.message = message;
11137 msg.flags = sent|wparam|lparam;
11138 msg.wParam = wp;
11139 msg.lParam = lp;
11140 msg.descr = "dialog";
11141 add_message(&msg);
11142
11143 switch (message)
11144 {
11145 case WM_INITDIALOG:
11146 PostMessageA(hwnd, WM_QUIT, 0x1234, 0x5678);
11147 PostMessageA(hwnd, WM_USER, 0xdead, 0xbeef);
11148 return 0;
11149
11150 case WM_GETDLGCODE:
11151 return 0;
11152
11153 case WM_USER:
11154 EndDialog(hwnd, 0);
11155 break;
11156 }
11157
11158 return 1;
11159 }
11160
11161 static const struct message WmQuitDialogSeq[] = {
11162 { HCBT_CREATEWND, hook },
11163 { WM_SETFONT, sent },
11164 { WM_INITDIALOG, sent },
11165 { WM_CHANGEUISTATE, sent|optional },
11166 { HCBT_DESTROYWND, hook },
11167 { 0x0090, sent|optional }, /* Vista */
11168 { WM_DESTROY, sent },
11169 { WM_NCDESTROY, sent },
11170 { 0 }
11171 };
11172
11173 static const struct message WmStopQuitSeq[] = {
11174 { WM_DWMNCRENDERINGCHANGED, posted|optional },
11175 { WM_CLOSE, posted },
11176 { WM_QUIT, posted|wparam|lparam, 0x1234, 0 },
11177 { 0 }
11178 };
11179
11180 static void test_quit_message(void)
11181 {
11182 MSG msg;
11183 BOOL ret;
11184
11185 /* test using PostQuitMessage */
11186 flush_events();
11187 PostQuitMessage(0xbeef);
11188
11189 msg.message = 0;
11190 ret = PeekMessageA(&msg, 0, 0, 0, PM_QS_SENDMESSAGE);
11191 ok(!ret, "got %x message\n", msg.message);
11192
11193 ret = PeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE);
11194 ok(ret, "PeekMessage failed with error %d\n", GetLastError());
11195 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
11196 ok(msg.wParam == 0xbeef, "wParam was 0x%lx instead of 0xbeef\n", msg.wParam);
11197
11198 ret = PostThreadMessageA(GetCurrentThreadId(), WM_USER, 0, 0);
11199 ok(ret, "PostMessage failed with error %d\n", GetLastError());
11200
11201 ret = GetMessageA(&msg, NULL, 0, 0);
11202 ok(ret > 0, "GetMessage failed with error %d\n", GetLastError());
11203 ok(msg.message == WM_USER, "Received message 0x%04x instead of WM_USER\n", msg.message);
11204
11205 /* note: WM_QUIT message received after WM_USER message */
11206 ret = GetMessageA(&msg, NULL, 0, 0);
11207 ok(!ret, "GetMessage return %d with error %d instead of FALSE\n", ret, GetLastError());
11208 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
11209 ok(msg.wParam == 0xbeef, "wParam was 0x%lx instead of 0xbeef\n", msg.wParam);
11210
11211 ret = PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE);
11212 ok( !ret || msg.message != WM_QUIT, "Received WM_QUIT again\n" );
11213
11214 /* now test with PostThreadMessage - different behaviour! */
11215 PostThreadMessageA(GetCurrentThreadId(), WM_QUIT, 0xdead, 0);
11216
11217 ret = PeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE);
11218 ok(ret, "PeekMessage failed with error %d\n", GetLastError());
11219 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
11220 ok(msg.wParam == 0xdead, "wParam was 0x%lx instead of 0xdead\n", msg.wParam);
11221
11222 ret = PostThreadMessageA(GetCurrentThreadId(), WM_USER, 0, 0);
11223 ok(ret, "PostMessage failed with error %d\n", GetLastError());
11224
11225 /* note: we receive the WM_QUIT message first this time */
11226 ret = GetMessageA(&msg, NULL, 0, 0);
11227 ok(!ret, "GetMessage return %d with error %d instead of FALSE\n", ret, GetLastError());
11228 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
11229 ok(msg.wParam == 0xdead, "wParam was 0x%lx instead of 0xdead\n", msg.wParam);
11230
11231 ret = GetMessageA(&msg, NULL, 0, 0);
11232 ok(ret > 0, "GetMessage failed with error %d\n", GetLastError());
11233 ok(msg.message == WM_USER, "Received message 0x%04x instead of WM_USER\n", msg.message);
11234
11235 flush_events();
11236 flush_sequence();
11237 ret = DialogBoxParamA(GetModuleHandleA(NULL), "TEST_EMPTY_DIALOG", 0, wm_quit_dlg_proc, 0);
11238 ok(ret == 1, "expected 1, got %d\n", ret);
11239 ok_sequence(WmQuitDialogSeq, "WmQuitDialogSeq", FALSE);
11240 memset(&msg, 0xab, sizeof(msg));
11241 ret = PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE);
11242 ok(ret, "PeekMessage failed\n");
11243 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
11244 ok(msg.wParam == 0x1234, "wParam was 0x%lx instead of 0x1234\n", msg.wParam);
11245 ok(msg.lParam == 0, "lParam was 0x%lx instead of 0\n", msg.lParam);
11246
11247 /* Check what happens to a WM_QUIT message posted to a window that gets
11248 * destroyed.
11249 */
11250 CreateWindowExA(0, "StopQuitClass", "Stop Quit Test", WS_OVERLAPPEDWINDOW,
11251 0, 0, 100, 100, NULL, NULL, NULL, NULL);
11252 flush_sequence();
11253 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
11254 {
11255 struct recvd_message rmsg;
11256 rmsg.hwnd = msg.hwnd;
11257 rmsg.message = msg.message;
11258 rmsg.flags = posted|wparam|lparam;
11259 rmsg.wParam = msg.wParam;
11260 rmsg.lParam = msg.lParam;
11261 rmsg.descr = "stop/quit";
11262 if (msg.message == WM_QUIT)
11263 /* The hwnd can only be checked here */
11264 ok(!msg.hwnd, "The WM_QUIT hwnd was %p instead of NULL\n", msg.hwnd);
11265 add_message(&rmsg);
11266 DispatchMessageA(&msg);
11267 }
11268 ok_sequence(WmStopQuitSeq, "WmStopQuitSeq", FALSE);
11269 }
11270
11271 static const struct message WmNotifySeq[] = {
11272 { WM_NOTIFY, sent|wparam|lparam, 0x1234, 0xdeadbeef },
11273 { 0 }
11274 };
11275
11276 static void test_notify_message(void)
11277 {
11278 HWND hwnd;
11279 BOOL ret;
11280 MSG msg;
11281
11282 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
11283 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0, NULL, NULL, 0);
11284 ok(hwnd != 0, "Failed to create window\n");
11285 flush_events();
11286 flush_sequence();
11287
11288 ret = SendNotifyMessageA(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef);
11289 ok(ret == TRUE, "SendNotifyMessageA failed with error %u\n", GetLastError());
11290 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
11291
11292 ret = SendNotifyMessageW(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef);
11293 ok(ret == TRUE, "SendNotifyMessageW failed with error %u\n", GetLastError());
11294 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
11295
11296 ret = SendMessageCallbackA(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef, NULL, 0);
11297 ok(ret == TRUE, "SendMessageCallbackA failed with error %u\n", GetLastError());
11298 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
11299
11300 ret = SendMessageCallbackW(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef, NULL, 0);
11301 ok(ret == TRUE, "SendMessageCallbackW failed with error %u\n", GetLastError());
11302 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
11303
11304 ret = PostMessageA(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef);
11305 ok(ret == TRUE, "PostMessageA failed with error %u\n", GetLastError());
11306 flush_events();
11307 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
11308
11309 ret = PostMessageW(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef);
11310 ok(ret == TRUE, "PostMessageW failed with error %u\n", GetLastError());
11311 flush_events();
11312 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
11313
11314 ret = PostThreadMessageA(GetCurrentThreadId(), WM_NOTIFY, 0x1234, 0xdeadbeef);
11315 ok(ret == TRUE, "PostThreadMessageA failed with error %u\n", GetLastError());
11316 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
11317 {
11318 msg.hwnd = hwnd;
11319 DispatchMessageA(&msg);
11320 }
11321 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
11322
11323 ret = PostThreadMessageW(GetCurrentThreadId(), WM_NOTIFY, 0x1234, 0xdeadbeef);
11324 ok(ret == TRUE, "PostThreadMessageW failed with error %u\n", GetLastError());
11325 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
11326 {
11327 msg.hwnd = hwnd;
11328 DispatchMessageA(&msg);
11329 }
11330 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
11331
11332 DestroyWindow(hwnd);
11333 }
11334
11335 static const struct message WmMouseHoverSeq[] = {
11336 { WM_MOUSEACTIVATE, sent|optional }, /* we can get those when moving the mouse in focus-follow-mouse mode under X11 */
11337 { WM_MOUSEACTIVATE, sent|optional },
11338 { WM_TIMER, sent|optional }, /* XP sends it */
11339 { WM_SYSTIMER, sent },
11340 { WM_MOUSEHOVER, sent|wparam, 0 },
11341 { 0 }
11342 };
11343
11344 static void pump_msg_loop_timeout(DWORD timeout, BOOL inject_mouse_move)
11345 {
11346 MSG msg;
11347 DWORD start_ticks, end_ticks;
11348
11349 start_ticks = GetTickCount();
11350 /* add some deviation (50%) to cover not expected delays */
11351 start_ticks += timeout / 2;
11352
11353 do
11354 {
11355 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
11356 {
11357 /* Timer proc messages are not dispatched to the window proc,
11358 * and therefore not logged.
11359 */
11360 if ((msg.message == WM_TIMER || msg.message == WM_SYSTIMER) && msg.hwnd)
11361 {
11362 struct recvd_message s_msg;
11363
11364 s_msg.hwnd = msg.hwnd;
11365 s_msg.message = msg.message;
11366 s_msg.flags = sent|wparam|lparam;
11367 s_msg.wParam = msg.wParam;
11368 s_msg.lParam = msg.lParam;
11369 s_msg.descr = "msg_loop";
11370 add_message(&s_msg);
11371 }
11372 DispatchMessageA(&msg);
11373 }
11374
11375 end_ticks = GetTickCount();
11376
11377 /* inject WM_MOUSEMOVE to see how it changes tracking */
11378 if (inject_mouse_move && start_ticks + timeout / 2 >= end_ticks)
11379 {
11380 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
11381 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
11382
11383 inject_mouse_move = FALSE;
11384 }
11385 } while (start_ticks + timeout >= end_ticks);
11386 }
11387
11388 static void test_TrackMouseEvent(void)
11389 {
11390 TRACKMOUSEEVENT tme;
11391 BOOL ret;
11392 HWND hwnd, hchild;
11393 RECT rc_parent, rc_child;
11394 UINT default_hover_time, hover_width = 0, hover_height = 0;
11395
11396 #define track_hover(track_hwnd, track_hover_time) \
11397 tme.cbSize = sizeof(tme); \
11398 tme.dwFlags = TME_HOVER; \
11399 tme.hwndTrack = track_hwnd; \
11400 tme.dwHoverTime = track_hover_time; \
11401 SetLastError(0xdeadbeef); \
11402 ret = pTrackMouseEvent(&tme); \
11403 ok(ret, "TrackMouseEvent(TME_HOVER) error %d\n", GetLastError())
11404
11405 #define track_query(expected_track_flags, expected_track_hwnd, expected_hover_time) \
11406 tme.cbSize = sizeof(tme); \
11407 tme.dwFlags = TME_QUERY; \
11408 tme.hwndTrack = (HWND)0xdeadbeef; \
11409 tme.dwHoverTime = 0xdeadbeef; \
11410 SetLastError(0xdeadbeef); \
11411 ret = pTrackMouseEvent(&tme); \
11412 ok(ret, "TrackMouseEvent(TME_QUERY) error %d\n", GetLastError());\
11413 ok(tme.cbSize == sizeof(tme), "wrong tme.cbSize %u\n", tme.cbSize); \
11414 ok(tme.dwFlags == (expected_track_flags), \
11415 "wrong tme.dwFlags %08x, expected %08x\n", tme.dwFlags, (expected_track_flags)); \
11416 ok(tme.hwndTrack == (expected_track_hwnd), \
11417 "wrong tme.hwndTrack %p, expected %p\n", tme.hwndTrack, (expected_track_hwnd)); \
11418 ok(tme.dwHoverTime == (expected_hover_time), \
11419 "wrong tme.dwHoverTime %u, expected %u\n", tme.dwHoverTime, (expected_hover_time))
11420
11421 #define track_hover_cancel(track_hwnd) \
11422 tme.cbSize = sizeof(tme); \
11423 tme.dwFlags = TME_HOVER | TME_CANCEL; \
11424 tme.hwndTrack = track_hwnd; \
11425 tme.dwHoverTime = 0xdeadbeef; \
11426 SetLastError(0xdeadbeef); \
11427 ret = pTrackMouseEvent(&tme); \
11428 ok(ret, "TrackMouseEvent(TME_HOVER | TME_CANCEL) error %d\n", GetLastError())
11429
11430 default_hover_time = 0xdeadbeef;
11431 SetLastError(0xdeadbeef);
11432 ret = SystemParametersInfoA(SPI_GETMOUSEHOVERTIME, 0, &default_hover_time, 0);
11433 ok(ret || broken(GetLastError() == 0xdeadbeef), /* win9x */
11434 "SystemParametersInfo(SPI_GETMOUSEHOVERTIME) error %u\n", GetLastError());
11435 if (!ret) default_hover_time = 400;
11436 trace("SPI_GETMOUSEHOVERTIME returned %u ms\n", default_hover_time);
11437
11438 SetLastError(0xdeadbeef);
11439 ret = SystemParametersInfoA(SPI_GETMOUSEHOVERWIDTH, 0, &hover_width, 0);
11440 ok(ret || broken(GetLastError() == 0xdeadbeef), /* win9x */
11441 "SystemParametersInfo(SPI_GETMOUSEHOVERWIDTH) error %u\n", GetLastError());
11442 if (!ret) hover_width = 4;
11443 SetLastError(0xdeadbeef);
11444 ret = SystemParametersInfoA(SPI_GETMOUSEHOVERHEIGHT, 0, &hover_height, 0);
11445 ok(ret || broken(GetLastError() == 0xdeadbeef), /* win9x */
11446 "SystemParametersInfo(SPI_GETMOUSEHOVERHEIGHT) error %u\n", GetLastError());
11447 if (!ret) hover_height = 4;
11448 trace("hover rect is %u x %d\n", hover_width, hover_height);
11449
11450 hwnd = CreateWindowExA(0, "TestWindowClass", NULL,
11451 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
11452 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
11453 NULL, NULL, 0);
11454 assert(hwnd);
11455
11456 hchild = CreateWindowExA(0, "TestWindowClass", NULL,
11457 WS_CHILD | WS_BORDER | WS_VISIBLE,
11458 50, 50, 200, 200, hwnd,
11459 NULL, NULL, 0);
11460 assert(hchild);
11461
11462 SetWindowPos( hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE );
11463 flush_events();
11464 flush_sequence();
11465
11466 tme.cbSize = 0;
11467 tme.dwFlags = TME_QUERY;
11468 tme.hwndTrack = (HWND)0xdeadbeef;
11469 tme.dwHoverTime = 0xdeadbeef;
11470 SetLastError(0xdeadbeef);
11471 ret = pTrackMouseEvent(&tme);
11472 ok(!ret, "TrackMouseEvent should fail\n");
11473 ok(GetLastError() == ERROR_INVALID_PARAMETER || broken(GetLastError() == 0xdeadbeef),
11474 "not expected error %u\n", GetLastError());
11475
11476 tme.cbSize = sizeof(tme);
11477 tme.dwFlags = TME_HOVER;
11478 tme.hwndTrack = (HWND)0xdeadbeef;
11479 tme.dwHoverTime = 0xdeadbeef;
11480 SetLastError(0xdeadbeef);
11481 ret = pTrackMouseEvent(&tme);
11482 ok(!ret, "TrackMouseEvent should fail\n");
11483 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || broken(GetLastError() == 0xdeadbeef),
11484 "not expected error %u\n", GetLastError());
11485
11486 tme.cbSize = sizeof(tme);
11487 tme.dwFlags = TME_HOVER | TME_CANCEL;
11488 tme.hwndTrack = (HWND)0xdeadbeef;
11489 tme.dwHoverTime = 0xdeadbeef;
11490 SetLastError(0xdeadbeef);
11491 ret = pTrackMouseEvent(&tme);
11492 ok(!ret, "TrackMouseEvent should fail\n");
11493 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || broken(GetLastError() == 0xdeadbeef),
11494 "not expected error %u\n", GetLastError());
11495
11496 GetWindowRect(hwnd, &rc_parent);
11497 GetWindowRect(hchild, &rc_child);
11498 SetCursorPos(rc_child.left - 10, rc_child.top - 10);
11499
11500 /* Process messages so that the system updates its internal current
11501 * window and hittest, otherwise TrackMouseEvent calls don't have any
11502 * effect.
11503 */
11504 flush_events();
11505 flush_sequence();
11506
11507 track_query(0, NULL, 0);
11508 track_hover(hchild, 0);
11509 track_query(0, NULL, 0);
11510
11511 flush_events();
11512 flush_sequence();
11513
11514 track_hover(hwnd, 0);
11515 tme.cbSize = sizeof(tme);
11516 tme.dwFlags = TME_QUERY;
11517 tme.hwndTrack = (HWND)0xdeadbeef;
11518 tme.dwHoverTime = 0xdeadbeef;
11519 SetLastError(0xdeadbeef);
11520 ret = pTrackMouseEvent(&tme);
11521 ok(ret, "TrackMouseEvent(TME_QUERY) error %d\n", GetLastError());
11522 ok(tme.cbSize == sizeof(tme), "wrong tme.cbSize %u\n", tme.cbSize);
11523 if (!tme.dwFlags)
11524 {
11525 skip( "Cursor not inside window, skipping TrackMouseEvent tests\n" );
11526 DestroyWindow( hwnd );
11527 return;
11528 }
11529 ok(tme.dwFlags == TME_HOVER, "wrong tme.dwFlags %08x, expected TME_HOVER\n", tme.dwFlags);
11530 ok(tme.hwndTrack == hwnd, "wrong tme.hwndTrack %p, expected %p\n", tme.hwndTrack, hwnd);
11531 ok(tme.dwHoverTime == default_hover_time, "wrong tme.dwHoverTime %u, expected %u\n",
11532 tme.dwHoverTime, default_hover_time);
11533
11534 pump_msg_loop_timeout(default_hover_time, FALSE);
11535 ok_sequence(WmMouseHoverSeq, "WmMouseHoverSeq", FALSE);
11536
11537 track_query(0, NULL, 0);
11538
11539 track_hover(hwnd, HOVER_DEFAULT);
11540 track_query(TME_HOVER, hwnd, default_hover_time);
11541
11542 Sleep(default_hover_time / 2);
11543 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
11544 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
11545
11546 track_query(TME_HOVER, hwnd, default_hover_time);
11547
11548 pump_msg_loop_timeout(default_hover_time, FALSE);
11549 ok_sequence(WmMouseHoverSeq, "WmMouseHoverSeq", FALSE);
11550
11551 track_query(0, NULL, 0);
11552
11553 track_hover(hwnd, HOVER_DEFAULT);
11554 track_query(TME_HOVER, hwnd, default_hover_time);
11555
11556 pump_msg_loop_timeout(default_hover_time, TRUE);
11557 ok_sequence(WmMouseHoverSeq, "WmMouseHoverSeq", FALSE);
11558
11559 track_query(0, NULL, 0);
11560
11561 track_hover(hwnd, HOVER_DEFAULT);
11562 track_query(TME_HOVER, hwnd, default_hover_time);
11563 track_hover_cancel(hwnd);
11564
11565 DestroyWindow(hwnd);
11566
11567 #undef track_hover
11568 #undef track_query
11569 #undef track_hover_cancel
11570 }
11571
11572
11573 static const struct message WmSetWindowRgn[] = {
11574 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
11575 { WM_NCCALCSIZE, sent|wparam, 1 },
11576 { WM_NCPAINT, sent|optional }, /* wparam != 1 */
11577 { WM_GETTEXT, sent|defwinproc|optional },
11578 { WM_ERASEBKGND, sent|optional },
11579 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
11580 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
11581 { 0 }
11582 };
11583
11584 static const struct message WmSetWindowRgn_no_redraw[] = {
11585 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW },
11586 { WM_NCCALCSIZE, sent|wparam, 1 },
11587 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW },
11588 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
11589 { 0 }
11590 };
11591
11592 static const struct message WmSetWindowRgn_clear[] = {
11593 { WM_WINDOWPOSCHANGING, sent/*|wparam*/, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE/*|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE only on some Windows versions */ },
11594 { WM_NCCALCSIZE, sent|wparam, 1 },
11595 { WM_NCPAINT, sent|optional },
11596 { WM_GETTEXT, sent|defwinproc|optional },
11597 { WM_ERASEBKGND, sent|optional }, /* FIXME: remove optional once Wine is fixed */
11598 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
11599 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
11600 { WM_NCPAINT, sent|optional },
11601 { WM_GETTEXT, sent|defwinproc|optional },
11602 { WM_ERASEBKGND, sent|optional },
11603 { WM_WINDOWPOSCHANGING, sent|optional },
11604 { WM_NCCALCSIZE, sent|optional|wparam, 1 },
11605 { WM_NCPAINT, sent|optional },
11606 { WM_GETTEXT, sent|defwinproc|optional },
11607 { WM_ERASEBKGND, sent|optional },
11608 { WM_WINDOWPOSCHANGED, sent|optional|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
11609 { WM_NCCALCSIZE, sent|optional|wparam, 1 },
11610 { WM_NCPAINT, sent|optional },
11611 { WM_GETTEXT, sent|defwinproc|optional },
11612 { WM_ERASEBKGND, sent|optional },
11613 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
11614 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
11615 { 0 }
11616 };
11617
11618 static void test_SetWindowRgn(void)
11619 {
11620 HRGN hrgn;
11621 HWND hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
11622 100, 100, 200, 200, 0, 0, 0, NULL);
11623 ok( hwnd != 0, "Failed to create overlapped window\n" );
11624
11625 ShowWindow( hwnd, SW_SHOW );
11626 UpdateWindow( hwnd );
11627 flush_events();
11628 flush_sequence();
11629
11630 trace("testing SetWindowRgn\n");
11631 hrgn = CreateRectRgn( 0, 0, 150, 150 );
11632 SetWindowRgn( hwnd, hrgn, TRUE );
11633 ok_sequence( WmSetWindowRgn, "WmSetWindowRgn", FALSE );
11634
11635 hrgn = CreateRectRgn( 30, 30, 160, 160 );
11636 SetWindowRgn( hwnd, hrgn, FALSE );
11637 ok_sequence( WmSetWindowRgn_no_redraw, "WmSetWindowRgn_no_redraw", FALSE );
11638
11639 hrgn = CreateRectRgn( 0, 0, 180, 180 );
11640 SetWindowRgn( hwnd, hrgn, TRUE );
11641 ok_sequence( WmSetWindowRgn, "WmSetWindowRgn2", FALSE );
11642
11643 SetWindowRgn( hwnd, 0, TRUE );
11644 ok_sequence( WmSetWindowRgn_clear, "WmSetWindowRgn_clear", FALSE );
11645
11646 DestroyWindow( hwnd );
11647 }
11648
11649 /*************************** ShowWindow() test ******************************/
11650 static const struct message WmShowNormal[] = {
11651 { WM_SHOWWINDOW, sent|wparam, 1 },
11652 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
11653 { HCBT_ACTIVATE, hook },
11654 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2003 doesn't send it */
11655 { HCBT_SETFOCUS, hook },
11656 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
11657 { 0 }
11658 };
11659 static const struct message WmShow[] = {
11660 { WM_SHOWWINDOW, sent|wparam, 1 },
11661 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
11662 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
11663 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
11664 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
11665 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
11666 { 0 }
11667 };
11668 static const struct message WmShowNoActivate_1[] = {
11669 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNOACTIVATE },
11670 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
11671 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
11672 { WM_MOVE, sent|defwinproc|optional },
11673 { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
11674 { 0 }
11675 };
11676 static const struct message WmShowNoActivate_2[] = {
11677 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNOACTIVATE },
11678 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
11679 { HCBT_ACTIVATE, hook|optional },
11680 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
11681 { HCBT_SETFOCUS, hook|optional },
11682 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
11683 { WM_MOVE, sent|defwinproc },
11684 { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
11685 { HCBT_SETFOCUS, hook|optional },
11686 { HCBT_ACTIVATE, hook|optional }, /* win2003 doesn't send it */
11687 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2003 doesn't send it */
11688 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
11689 { HCBT_SETFOCUS, hook|optional }, /* win2003 doesn't send it */
11690 { 0 }
11691 };
11692 static const struct message WmShowNA_1[] = {
11693 { WM_SHOWWINDOW, sent|wparam, 1 },
11694 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
11695 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
11696 { 0 }
11697 };
11698 static const struct message WmShowNA_2[] = {
11699 { WM_SHOWWINDOW, sent|wparam, 1 },
11700 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
11701 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
11702 { 0 }
11703 };
11704 static const struct message WmRestore_1[] = {
11705 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
11706 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11707 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
11708 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
11709 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
11710 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11711 { WM_MOVE, sent|defwinproc },
11712 { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
11713 { HCBT_SETFOCUS, hook|optional }, /* win2000 sends it */
11714 { 0 }
11715 };
11716 static const struct message WmRestore_2[] = {
11717 { WM_SHOWWINDOW, sent|wparam, 1 },
11718 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
11719 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
11720 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
11721 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
11722 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
11723 { 0 }
11724 };
11725 static const struct message WmRestore_3[] = {
11726 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
11727 { WM_GETMINMAXINFO, sent },
11728 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11729 { HCBT_ACTIVATE, hook|optional }, /* win2003 doesn't send it */
11730 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2003 doesn't send it */
11731 { HCBT_SETFOCUS, hook|optional }, /* win2003 doesn't send it */
11732 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11733 { WM_MOVE, sent|defwinproc },
11734 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
11735 { HCBT_SETFOCUS, hook|optional }, /* win2003 sends it */
11736 { 0 }
11737 };
11738 static const struct message WmRestore_4[] = {
11739 { HCBT_MINMAX, hook|lparam|optional, 0, SW_RESTORE },
11740 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
11741 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
11742 { WM_MOVE, sent|defwinproc|optional },
11743 { WM_SIZE, sent|wparam|defwinproc|optional, SIZE_RESTORED },
11744 { 0 }
11745 };
11746 static const struct message WmRestore_5[] = {
11747 { HCBT_MINMAX, hook|lparam|optional, 0, SW_SHOWNORMAL },
11748 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
11749 { HCBT_ACTIVATE, hook|optional },
11750 { HCBT_SETFOCUS, hook|optional },
11751 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
11752 { WM_MOVE, sent|defwinproc|optional },
11753 { WM_SIZE, sent|wparam|defwinproc|optional, SIZE_RESTORED },
11754 { 0 }
11755 };
11756 static const struct message WmHide_1[] = {
11757 { WM_SHOWWINDOW, sent|wparam, 0 },
11758 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE, 0, SWP_NOACTIVATE },
11759 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE, 0, SWP_NOACTIVATE },
11760 { HCBT_ACTIVATE, hook|optional },
11761 { HCBT_SETFOCUS, hook|optional }, /* win2000 sends it */
11762 { 0 }
11763 };
11764 static const struct message WmHide_2[] = {
11765 { WM_SHOWWINDOW, sent|wparam, 0 },
11766 { WM_WINDOWPOSCHANGING, sent /*|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE*/ }, /* win2000 doesn't add SWP_NOACTIVATE */
11767 { WM_WINDOWPOSCHANGED, sent /*|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ }, /* win2000 doesn't add SWP_NOACTIVATE */
11768 { HCBT_ACTIVATE, hook|optional },
11769 { 0 }
11770 };
11771 static const struct message WmHide_3[] = {
11772 { WM_SHOWWINDOW, sent|wparam, 0 },
11773 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
11774 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
11775 { HCBT_SETFOCUS, hook|optional },
11776 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
11777 { 0 }
11778 };
11779 static const struct message WmShowMinimized_1[] = {
11780 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
11781 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11782 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
11783 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
11784 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11785 { WM_MOVE, sent|defwinproc },
11786 { WM_SIZE, sent|wparam|lparam|defwinproc, SIZE_MINIMIZED, 0 },
11787 { 0 }
11788 };
11789 static const struct message WmMinimize_1[] = {
11790 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
11791 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
11792 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
11793 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11794 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11795 { WM_MOVE, sent|defwinproc },
11796 { WM_SIZE, sent|wparam|lparam|defwinproc, SIZE_MINIMIZED, 0 },
11797 { 0 }
11798 };
11799 static const struct message WmMinimize_2[] = {
11800 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
11801 { HCBT_SETFOCUS, hook|optional },
11802 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
11803 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
11804 { WM_MOVE, sent|defwinproc },
11805 { WM_SIZE, sent|wparam|lparam|defwinproc, SIZE_MINIMIZED, 0 },
11806 { 0 }
11807 };
11808 static const struct message WmMinimize_3[] = {
11809 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
11810 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
11811 { HCBT_ACTIVATE, hook|optional },
11812 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
11813 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
11814 { WM_MOVE, sent|defwinproc },
11815 { WM_SIZE, sent|wparam|lparam|defwinproc, SIZE_MINIMIZED, 0 },
11816 { 0 }
11817 };
11818 static const struct message WmShowMinNoActivate[] = {
11819 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
11820 { WM_WINDOWPOSCHANGING, sent },
11821 { WM_WINDOWPOSCHANGED, sent },
11822 { WM_MOVE, sent|defwinproc|optional },
11823 { WM_SIZE, sent|wparam|lparam|defwinproc|optional, SIZE_MINIMIZED, 0 },
11824 { 0 }
11825 };
11826 static const struct message WmMinMax_1[] = {
11827 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
11828 { 0 }
11829 };
11830 static const struct message WmMinMax_2[] = {
11831 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
11832 { WM_GETMINMAXINFO, sent|optional },
11833 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED },
11834 { HCBT_ACTIVATE, hook|optional },
11835 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
11836 { HCBT_SETFOCUS, hook|optional },
11837 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
11838 { WM_MOVE, sent|defwinproc|optional },
11839 { WM_SIZE, sent|wparam|defwinproc|optional, SIZE_MAXIMIZED },
11840 { HCBT_SETFOCUS, hook|optional },
11841 { 0 }
11842 };
11843 static const struct message WmMinMax_3[] = {
11844 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
11845 { HCBT_SETFOCUS, hook|optional },
11846 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11847 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11848 { WM_MOVE, sent|defwinproc|optional },
11849 { WM_SIZE, sent|wparam|lparam|defwinproc|optional, SIZE_MINIMIZED, 0 },
11850 { 0 }
11851 };
11852 static const struct message WmMinMax_4[] = {
11853 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
11854 { 0 }
11855 };
11856 static const struct message WmShowMaximized_1[] = {
11857 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
11858 { WM_GETMINMAXINFO, sent },
11859 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11860 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
11861 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
11862 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
11863 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11864 { WM_MOVE, sent|defwinproc },
11865 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
11866 { HCBT_SETFOCUS, hook|optional }, /* win2003 sends it */
11867 { 0 }
11868 };
11869 static const struct message WmShowMaximized_2[] = {
11870 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
11871 { WM_GETMINMAXINFO, sent },
11872 { WM_WINDOWPOSCHANGING, sent|optional },
11873 { HCBT_ACTIVATE, hook|optional },
11874 { WM_WINDOWPOSCHANGED, sent|optional },
11875 { WM_MOVE, sent|optional }, /* Win9x doesn't send it */
11876 { WM_SIZE, sent|wparam|optional, SIZE_MAXIMIZED }, /* Win9x doesn't send it */
11877 { WM_WINDOWPOSCHANGING, sent|optional },
11878 { HCBT_SETFOCUS, hook|optional },
11879 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11880 { WM_MOVE, sent|defwinproc },
11881 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
11882 { HCBT_SETFOCUS, hook|optional },
11883 { 0 }
11884 };
11885 static const struct message WmShowMaximized_3[] = {
11886 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
11887 { WM_GETMINMAXINFO, sent|optional },
11888 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
11889 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
11890 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
11891 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
11892 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
11893 { WM_MOVE, sent|defwinproc|optional },
11894 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
11895 { 0 }
11896 };
11897
11898 static void test_ShowWindow(void)
11899 {
11900 /* ShowWindow commands in random order */
11901 static const struct
11902 {
11903 INT cmd; /* ShowWindow command */
11904 LPARAM ret; /* ShowWindow return value */
11905 DWORD style; /* window style after the command */
11906 const struct message *msg; /* message sequence the command produces */
11907 INT wp_cmd, wp_flags; /* window placement after the command */
11908 POINT wp_min, wp_max; /* window placement after the command */
11909 BOOL todo_msg; /* message sequence doesn't match what Wine does */
11910 } sw[] =
11911 {
11912 /* 1 */ { SW_SHOWNORMAL, FALSE, WS_VISIBLE, WmShowNormal,
11913 SW_SHOWNORMAL, 0, {-1,-1}, {-1,-1}, FALSE },
11914 /* 2 */ { SW_SHOWNORMAL, TRUE, WS_VISIBLE, WmEmptySeq,
11915 SW_SHOWNORMAL, 0, {-1,-1}, {-1,-1}, FALSE },
11916 /* 3 */ { SW_HIDE, TRUE, 0, WmHide_1,
11917 SW_SHOWNORMAL, 0, {-1,-1}, {-1,-1}, FALSE },
11918 /* 4 */ { SW_HIDE, FALSE, 0, WmEmptySeq,
11919 SW_SHOWNORMAL, 0, {-1,-1}, {-1,-1}, FALSE },
11920 /* 5 */ { SW_SHOWMINIMIZED, FALSE, WS_VISIBLE|WS_MINIMIZE, WmShowMinimized_1,
11921 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11922 /* 6 */ { SW_SHOWMINIMIZED, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_1,
11923 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11924 /* 7 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_1,
11925 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11926 /* 8 */ { SW_HIDE, FALSE, WS_MINIMIZE, WmEmptySeq,
11927 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11928 /* 9 */ { SW_SHOWMAXIMIZED, FALSE, WS_VISIBLE|WS_MAXIMIZE, WmShowMaximized_1,
11929 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11930 /* 10 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmMinMax_2,
11931 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11932 /* 11 */ { SW_HIDE, TRUE, WS_MAXIMIZE, WmHide_1,
11933 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11934 /* 12 */ { SW_HIDE, FALSE, WS_MAXIMIZE, WmEmptySeq,
11935 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11936 /* 13 */ { SW_SHOWNOACTIVATE, FALSE, WS_VISIBLE, WmShowNoActivate_1,
11937 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11938 /* 14 */ { SW_SHOWNOACTIVATE, TRUE, WS_VISIBLE, WmEmptySeq,
11939 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11940 /* 15 */ { SW_HIDE, TRUE, 0, WmHide_2,
11941 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11942 /* 16 */ { SW_HIDE, FALSE, 0, WmEmptySeq,
11943 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11944 /* 17 */ { SW_SHOW, FALSE, WS_VISIBLE, WmShow,
11945 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11946 /* 18 */ { SW_SHOW, TRUE, WS_VISIBLE, WmEmptySeq,
11947 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11948 /* 19 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_1,
11949 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11950 /* 20 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_3,
11951 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11952 /* 21 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2,
11953 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11954 /* 22 */ { SW_SHOWMINNOACTIVE, FALSE, WS_VISIBLE|WS_MINIMIZE, WmShowMinNoActivate,
11955 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, TRUE },
11956 /* 23 */ { SW_SHOWMINNOACTIVE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_4,
11957 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11958 /* 24 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2,
11959 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11960 /* 25 */ { SW_HIDE, FALSE, WS_MINIMIZE, WmEmptySeq,
11961 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11962 /* 26 */ { SW_SHOWNA, FALSE, WS_VISIBLE|WS_MINIMIZE, WmShowNA_1,
11963 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11964 /* 27 */ { SW_SHOWNA, TRUE, WS_VISIBLE|WS_MINIMIZE, WmShowNA_2,
11965 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11966 /* 28 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2,
11967 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11968 /* 29 */ { SW_HIDE, FALSE, WS_MINIMIZE, WmEmptySeq,
11969 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11970 /* 30 */ { SW_RESTORE, FALSE, WS_VISIBLE, WmRestore_1,
11971 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11972 /* 31 */ { SW_RESTORE, TRUE, WS_VISIBLE, WmEmptySeq,
11973 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11974 /* 32 */ { SW_HIDE, TRUE, 0, WmHide_3,
11975 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11976 /* 33 */ { SW_HIDE, FALSE, 0, WmEmptySeq,
11977 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11978 /* 34 */ { SW_NORMALNA, FALSE, 0, WmEmptySeq, /* what does this mean?! */
11979 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11980 /* 35 */ { SW_NORMALNA, FALSE, 0, WmEmptySeq,
11981 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11982 /* 36 */ { SW_HIDE, FALSE, 0, WmEmptySeq,
11983 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11984 /* 37 */ { SW_RESTORE, FALSE, WS_VISIBLE, WmRestore_2,
11985 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11986 /* 38 */ { SW_RESTORE, TRUE, WS_VISIBLE, WmEmptySeq,
11987 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11988 /* 39 */ { SW_SHOWNOACTIVATE, TRUE, WS_VISIBLE, WmEmptySeq,
11989 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11990 /* 40 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_2,
11991 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11992 /* 41 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_3,
11993 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11994 /* 42 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmShowMaximized_2,
11995 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11996 /* 43 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmMinMax_2,
11997 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11998 /* 44 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_1,
11999 SW_SHOWMINIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
12000 /* 45 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_3,
12001 SW_SHOWMINIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
12002 /* 46 */ { SW_RESTORE, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmRestore_3,
12003 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
12004 /* 47 */ { SW_RESTORE, TRUE, WS_VISIBLE, WmRestore_4,
12005 SW_SHOWNORMAL, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
12006 /* 48 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmShowMaximized_3,
12007 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
12008 /* 49 */ { SW_SHOW, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmEmptySeq,
12009 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
12010 /* 50 */ { SW_SHOWNORMAL, TRUE, WS_VISIBLE, WmRestore_5,
12011 SW_SHOWNORMAL, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
12012 /* 51 */ { SW_SHOWNORMAL, TRUE, WS_VISIBLE, WmRestore_5,
12013 SW_SHOWNORMAL, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
12014 /* 52 */ { SW_HIDE, TRUE, 0, WmHide_1,
12015 SW_SHOWNORMAL, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
12016 /* 53 */ { SW_HIDE, FALSE, 0, WmEmptySeq,
12017 SW_SHOWNORMAL, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
12018 /* 54 */ { SW_MINIMIZE, FALSE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_3,
12019 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
12020 /* 55 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2,
12021 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
12022 /* 56 */ { SW_SHOWNOACTIVATE, FALSE, WS_VISIBLE, WmShowNoActivate_2,
12023 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
12024 /* 57 */ { SW_SHOW, TRUE, WS_VISIBLE, WmEmptySeq,
12025 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE }
12026 };
12027 HWND hwnd;
12028 DWORD style;
12029 LPARAM ret;
12030 INT i;
12031 WINDOWPLACEMENT wp;
12032 RECT win_rc, work_rc = {0, 0, 0, 0};
12033
12034 #define WS_BASE (WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_POPUP|WS_CLIPSIBLINGS)
12035 hwnd = CreateWindowExA(0, "ShowWindowClass", NULL, WS_BASE,
12036 120, 120, 90, 90,
12037 0, 0, 0, NULL);
12038 assert(hwnd);
12039
12040 style = GetWindowLongA(hwnd, GWL_STYLE) & ~WS_BASE;
12041 ok(style == 0, "expected style 0, got %08x\n", style);
12042
12043 flush_events();
12044 flush_sequence();
12045
12046 if (pGetMonitorInfoA && pMonitorFromPoint)
12047 {
12048 HMONITOR hmon;
12049 MONITORINFO mi;
12050 POINT pt = {0, 0};
12051
12052 SetLastError(0xdeadbeef);
12053 hmon = pMonitorFromPoint(pt, MONITOR_DEFAULTTOPRIMARY);
12054 ok(hmon != 0, "MonitorFromPoint error %u\n", GetLastError());
12055
12056 mi.cbSize = sizeof(mi);
12057 SetLastError(0xdeadbeef);
12058 ret = pGetMonitorInfoA(hmon, &mi);
12059 ok(ret, "GetMonitorInfo error %u\n", GetLastError());
12060 trace("monitor (%d,%d-%d,%d), work (%d,%d-%d,%d)\n",
12061 mi.rcMonitor.left, mi.rcMonitor.top, mi.rcMonitor.right, mi.rcMonitor.bottom,
12062 mi.rcWork.left, mi.rcWork.top, mi.rcWork.right, mi.rcWork.bottom);
12063 work_rc = mi.rcWork;
12064 }
12065
12066 GetWindowRect(hwnd, &win_rc);
12067 OffsetRect(&win_rc, -work_rc.left, -work_rc.top);
12068
12069 wp.length = sizeof(wp);
12070 SetLastError(0xdeadbeaf);
12071 ret = GetWindowPlacement(hwnd, &wp);
12072 ok(ret, "GetWindowPlacement error %u\n", GetLastError());
12073 ok(wp.flags == 0, "expected 0, got %#x\n", wp.flags);
12074 ok(wp.showCmd == SW_SHOWNORMAL, "expected SW_SHOWNORMAL, got %d\n", wp.showCmd);
12075 ok(wp.ptMinPosition.x == -1 && wp.ptMinPosition.y == -1,
12076 "expected -1,-1 got %d,%d\n", wp.ptMinPosition.x, wp.ptMinPosition.y);
12077 ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1,
12078 "expected -1,-1 got %d,%d\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y);
12079 todo_wine_if (work_rc.left || work_rc.top) /* FIXME: remove once Wine is fixed */
12080 ok(EqualRect(&win_rc, &wp.rcNormalPosition),
12081 "expected %d,%d-%d,%d got %d,%d-%d,%d\n",
12082 win_rc.left, win_rc.top, win_rc.right, win_rc.bottom,
12083 wp.rcNormalPosition.left, wp.rcNormalPosition.top,
12084 wp.rcNormalPosition.right, wp.rcNormalPosition.bottom);
12085
12086 for (i = 0; i < sizeof(sw)/sizeof(sw[0]); i++)
12087 {
12088 static const char * const sw_cmd_name[13] =
12089 {
12090 "SW_HIDE", "SW_SHOWNORMAL", "SW_SHOWMINIMIZED", "SW_SHOWMAXIMIZED",
12091 "SW_SHOWNOACTIVATE", "SW_SHOW", "SW_MINIMIZE", "SW_SHOWMINNOACTIVE",
12092 "SW_SHOWNA", "SW_RESTORE", "SW_SHOWDEFAULT", "SW_FORCEMINIMIZE",
12093 "SW_NORMALNA" /* 0xCC */
12094 };
12095 char comment[64];
12096 INT idx; /* index into the above array of names */
12097
12098 idx = (sw[i].cmd == SW_NORMALNA) ? 12 : sw[i].cmd;
12099
12100 style = GetWindowLongA(hwnd, GWL_STYLE);
12101 trace("%d: sending %s, current window style %08x\n", i+1, sw_cmd_name[idx], style);
12102 ret = ShowWindow(hwnd, sw[i].cmd);
12103 ok(!ret == !sw[i].ret, "%d: cmd %s: expected ret %lu, got %lu\n", i+1, sw_cmd_name[idx], sw[i].ret, ret);
12104 style = GetWindowLongA(hwnd, GWL_STYLE) & ~WS_BASE;
12105 ok(style == sw[i].style, "%d: expected style %08x, got %08x\n", i+1, sw[i].style, style);
12106
12107 sprintf(comment, "%d: ShowWindow(%s)", i+1, sw_cmd_name[idx]);
12108 ok_sequence(sw[i].msg, comment, sw[i].todo_msg);
12109
12110 wp.length = sizeof(wp);
12111 SetLastError(0xdeadbeaf);
12112 ret = GetWindowPlacement(hwnd, &wp);
12113 ok(ret, "GetWindowPlacement error %u\n", GetLastError());
12114 ok(wp.flags == sw[i].wp_flags, "expected %#x, got %#x\n", sw[i].wp_flags, wp.flags);
12115 ok(wp.showCmd == sw[i].wp_cmd, "expected %d, got %d\n", sw[i].wp_cmd, wp.showCmd);
12116
12117 /* NT moves the minimized window to -32000,-32000, win9x to 3000,3000 */
12118 if ((wp.ptMinPosition.x + work_rc.left == -32000 && wp.ptMinPosition.y + work_rc.top == -32000) ||
12119 (wp.ptMinPosition.x + work_rc.left == 3000 && wp.ptMinPosition.y + work_rc.top == 3000))
12120 {
12121 ok((wp.ptMinPosition.x + work_rc.left == sw[i].wp_min.x && wp.ptMinPosition.y + work_rc.top == sw[i].wp_min.y) ||
12122 (wp.ptMinPosition.x + work_rc.left == 3000 && wp.ptMinPosition.y + work_rc.top == 3000),
12123 "expected %d,%d got %d,%d\n", sw[i].wp_min.x, sw[i].wp_min.y, wp.ptMinPosition.x, wp.ptMinPosition.y);
12124 }
12125 else
12126 {
12127 ok(wp.ptMinPosition.x == sw[i].wp_min.x && wp.ptMinPosition.y == sw[i].wp_min.y,
12128 "expected %d,%d got %d,%d\n", sw[i].wp_min.x, sw[i].wp_min.y, wp.ptMinPosition.x, wp.ptMinPosition.y);
12129 }
12130
12131 if (wp.ptMaxPosition.x != sw[i].wp_max.x || wp.ptMaxPosition.y != sw[i].wp_max.y)
12132 todo_wine
12133 ok(wp.ptMaxPosition.x == sw[i].wp_max.x && wp.ptMaxPosition.y == sw[i].wp_max.y,
12134 "expected %d,%d got %d,%d\n", sw[i].wp_max.x, sw[i].wp_max.y, wp.ptMaxPosition.x, wp.ptMaxPosition.y);
12135 else
12136 ok(wp.ptMaxPosition.x == sw[i].wp_max.x && wp.ptMaxPosition.y == sw[i].wp_max.y,
12137 "expected %d,%d got %d,%d\n", sw[i].wp_max.x, sw[i].wp_max.y, wp.ptMaxPosition.x, wp.ptMaxPosition.y);
12138
12139 if (0) /* FIXME: Wine behaves completely different here */
12140 ok(EqualRect(&win_rc, &wp.rcNormalPosition),
12141 "expected %d,%d-%d,%d got %d,%d-%d,%d\n",
12142 win_rc.left, win_rc.top, win_rc.right, win_rc.bottom,
12143 wp.rcNormalPosition.left, wp.rcNormalPosition.top,
12144 wp.rcNormalPosition.right, wp.rcNormalPosition.bottom);
12145 }
12146 DestroyWindow(hwnd);
12147 flush_events();
12148 }
12149
12150 static INT_PTR WINAPI test_dlg_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
12151 {
12152 struct recvd_message msg;
12153
12154 if (ignore_message( message )) return 0;
12155
12156 msg.hwnd = hwnd;
12157 msg.message = message;
12158 msg.flags = sent|wparam|lparam;
12159 msg.wParam = wParam;
12160 msg.lParam = lParam;
12161 msg.descr = "dialog";
12162 add_message(&msg);
12163
12164 /* calling DefDlgProc leads to a recursion under XP */
12165
12166 switch (message)
12167 {
12168 case WM_INITDIALOG:
12169 case WM_GETDLGCODE:
12170 return 0;
12171 }
12172 return 1;
12173 }
12174
12175 static WNDPROC orig_edit_proc;
12176 static LRESULT WINAPI dlg_creation_edit_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
12177 {
12178 struct recvd_message msg;
12179
12180 if (ignore_message( message )) return 0;
12181
12182 msg.hwnd = hwnd;
12183 msg.message = message;
12184 msg.flags = sent|wparam|lparam;
12185 msg.wParam = wp;
12186 msg.lParam = lp;
12187 msg.descr = "edit";
12188 add_message(&msg);
12189
12190 return CallWindowProcW(orig_edit_proc, hwnd, message, wp, lp);
12191 }
12192
12193 static INT_PTR WINAPI test_dlg_proc2(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
12194 {
12195 struct recvd_message msg;
12196
12197 if (ignore_message( message )) return 0;
12198
12199 msg.hwnd = hwnd;
12200 msg.message = message;
12201 msg.flags = sent|wparam|lparam|parent;
12202 msg.wParam = wParam;
12203 msg.lParam = lParam;
12204 msg.descr = "dialog";
12205 add_message(&msg);
12206
12207 if (message == WM_INITDIALOG)
12208 {
12209 orig_edit_proc = (WNDPROC)SetWindowLongPtrW(GetDlgItem(hwnd, 200),
12210 GWLP_WNDPROC, (LONG_PTR)dlg_creation_edit_proc);
12211 }
12212
12213 return 1;
12214 }
12215
12216 static INT_PTR WINAPI test_dlg_proc3(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
12217 {
12218 ok( 0, "should not be called since DefDlgProc is not used\n" );
12219 return 0;
12220 }
12221
12222 static LRESULT WINAPI test_dlg_proc4(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
12223 {
12224 struct recvd_message msg;
12225
12226 if (!ignore_message( message ))
12227 {
12228 msg.hwnd = hwnd;
12229 msg.message = message;
12230 msg.flags = sent|wparam|lparam|parent;
12231 msg.wParam = wParam;
12232 msg.lParam = lParam;
12233 msg.descr = "dialog";
12234 add_message(&msg);
12235 }
12236 if (message == WM_INITDIALOG)
12237 {
12238 orig_edit_proc = (WNDPROC)SetWindowLongPtrW(GetDlgItem(hwnd, 200),
12239 GWLP_WNDPROC, (LONG_PTR)dlg_creation_edit_proc);
12240 return 1;
12241 }
12242 return DefWindowProcW( hwnd, message, wParam, lParam );
12243 }
12244
12245 static const struct message WmDefDlgSetFocus_1[] = {
12246 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
12247 { WM_GETTEXTLENGTH, sent|wparam|lparam|optional, 0, 0 }, /* XP */
12248 { WM_GETTEXT, sent|wparam|optional, 6 }, /* XP */
12249 { WM_GETTEXT, sent|wparam|optional, 12 }, /* XP */
12250 { EM_SETSEL, sent|wparam, 0 }, /* XP sets lparam to text length, Win9x to -2 */
12251 { HCBT_SETFOCUS, hook },
12252 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
12253 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
12254 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
12255 { WM_SETFOCUS, sent|wparam, 0 },
12256 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
12257 { WM_CTLCOLOREDIT, sent },
12258 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
12259 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
12260 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
12261 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
12262 { WM_COMMAND, sent|wparam, MAKEWPARAM(1, EN_SETFOCUS) },
12263 { 0 }
12264 };
12265 static const struct message WmDefDlgSetFocus_2[] = {
12266 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
12267 { WM_GETTEXTLENGTH, sent|wparam|lparam|optional, 0, 0 }, /* XP */
12268 { WM_GETTEXT, sent|wparam|optional, 6 }, /* XP */
12269 { WM_GETTEXT, sent|wparam|optional, 12 }, /* XP */
12270 { EM_SETSEL, sent|wparam, 0 }, /* XP sets lparam to text length, Win9x to -2 */
12271 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
12272 { WM_CTLCOLOREDIT, sent|optional }, /* XP */
12273 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
12274 { 0 }
12275 };
12276 /* Creation of a dialog */
12277 static const struct message WmCreateDialogParamSeq_1[] = {
12278 { HCBT_CREATEWND, hook },
12279 { WM_NCCREATE, sent },
12280 { WM_NCCALCSIZE, sent|wparam, 0 },
12281 { WM_CREATE, sent },
12282 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
12283 { WM_SIZE, sent|wparam, SIZE_RESTORED },
12284 { WM_MOVE, sent },
12285 { WM_SETFONT, sent },
12286 { WM_INITDIALOG, sent },
12287 { WM_CHANGEUISTATE, sent|optional },
12288 { 0 }
12289 };
12290 /* Creation of a dialog */
12291 static const struct message WmCreateDialogParamSeq_2[] = {
12292 { HCBT_CREATEWND, hook },
12293 { WM_NCCREATE, sent },
12294 { WM_NCCALCSIZE, sent|wparam, 0 },
12295 { WM_CREATE, sent },
12296 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
12297 { WM_SIZE, sent|wparam, SIZE_RESTORED },
12298 { WM_MOVE, sent },
12299 { WM_CHANGEUISTATE, sent|optional },
12300 { 0 }
12301 };
12302
12303 static const struct message WmCreateDialogParamSeq_3[] = {
12304 { HCBT_CREATEWND, hook },
12305 { WM_SETFONT, sent|parent },
12306 { WM_INITDIALOG, sent|parent },
12307 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
12308 { EM_SETSEL, sent|wparam|lparam, 0, INT_MAX },
12309 { EM_SETSEL, sent|wparam|lparam|optional, 0, INT_MAX },
12310 { EM_SETSEL, sent|wparam|lparam|optional, 0, INT_MAX },
12311 { EM_SETSEL, sent|wparam|lparam|optional, 0, INT_MAX },
12312 { HCBT_ACTIVATE, hook },
12313 { WM_QUERYNEWPALETTE, sent|parent|optional }, /* TODO: this message should not be sent */
12314 { WM_WINDOWPOSCHANGING, sent|parent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
12315 { WM_WINDOWPOSCHANGING, sent|parent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
12316 { WM_ACTIVATEAPP, sent|parent|wparam, 1 },
12317 { WM_NCACTIVATE, sent|parent },
12318 { WM_ACTIVATE, sent|parent|wparam, 1 },
12319 { WM_SETFOCUS, sent },
12320 { WM_COMMAND, sent|parent|wparam, MAKELONG(200, EN_SETFOCUS) },
12321 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
12322 { WM_USER, sent|parent },
12323 { WM_CHANGEUISTATE, sent|parent|optional },
12324 { 0 }
12325 };
12326
12327 static const struct message WmCreateDialogParamSeq_4[] = {
12328 { HCBT_CREATEWND, hook },
12329 { WM_NCCREATE, sent|parent },
12330 { WM_NCCALCSIZE, sent|parent|wparam, 0 },
12331 { WM_CREATE, sent|parent },
12332 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
12333 { WM_SIZE, sent|parent|wparam, SIZE_RESTORED },
12334 { WM_MOVE, sent|parent },
12335 { WM_SETFONT, sent|parent },
12336 { WM_INITDIALOG, sent|parent },
12337 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
12338 { EM_SETSEL, sent|wparam|lparam, 0, INT_MAX },
12339 { EM_SETSEL, sent|wparam|lparam|optional, 0, INT_MAX },
12340 { EM_SETSEL, sent|wparam|lparam|optional, 0, INT_MAX },
12341 { EM_SETSEL, sent|wparam|lparam|optional, 0, INT_MAX },
12342 { HCBT_ACTIVATE, hook },
12343 { WM_QUERYNEWPALETTE, sent|parent|optional }, /* TODO: this message should not be sent */
12344 { WM_WINDOWPOSCHANGING, sent|parent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
12345 { WM_WINDOWPOSCHANGING, sent|parent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
12346 { WM_ACTIVATEAPP, sent|parent|wparam, 1 },
12347 { WM_NCACTIVATE, sent|parent },
12348 { WM_ACTIVATE, sent|parent|wparam, 1 },
12349 { HCBT_SETFOCUS, hook },
12350 { WM_SETFOCUS, sent|parent },
12351 { WM_KILLFOCUS, sent|parent },
12352 { WM_SETFOCUS, sent },
12353 { WM_COMMAND, sent|parent|wparam, MAKELONG(200, EN_SETFOCUS) },
12354 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
12355 { WM_USER, sent|parent },
12356 { WM_CHANGEUISTATE, sent|parent|optional },
12357 { WM_UPDATEUISTATE, sent|parent|optional },
12358 { WM_UPDATEUISTATE, sent|optional },
12359 { 0 }
12360 };
12361
12362 static void test_dialog_messages(void)
12363 {
12364 WNDCLASSA cls;
12365 HWND hdlg, hedit1, hedit2, hfocus, parent, child, child2;
12366 LRESULT ret;
12367
12368 #define set_selection(hctl, start, end) \
12369 ret = SendMessageA(hctl, EM_SETSEL, start, end); \
12370 ok(ret == 1, "EM_SETSEL returned %ld\n", ret);
12371
12372 #define check_selection(hctl, start, end) \
12373 ret = SendMessageA(hctl, EM_GETSEL, 0, 0); \
12374 ok(ret == MAKELRESULT(start, end), "wrong selection (%d - %d)\n", LOWORD(ret), HIWORD(ret));
12375
12376 subclass_edit();
12377
12378 hdlg = CreateWindowExA(WS_EX_DLGMODALFRAME, "TestDialogClass", NULL,
12379 WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
12380 0, 0, 100, 100, 0, 0, 0, NULL);
12381 ok(hdlg != 0, "Failed to create custom dialog window\n");
12382
12383 hedit1 = CreateWindowExA(0, "my_edit_class", NULL,
12384 WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP,
12385 0, 0, 80, 20, hdlg, (HMENU)1, 0, NULL);
12386 ok(hedit1 != 0, "Failed to create edit control\n");
12387 hedit2 = CreateWindowExA(0, "my_edit_class", NULL,
12388 WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP,
12389 0, 40, 80, 20, hdlg, (HMENU)2, 0, NULL);
12390 ok(hedit2 != 0, "Failed to create edit control\n");
12391
12392 SendMessageA(hedit1, WM_SETTEXT, 0, (LPARAM)"hello");
12393 SendMessageA(hedit2, WM_SETTEXT, 0, (LPARAM)"bye");
12394
12395 hfocus = GetFocus();
12396 ok(hfocus == hdlg, "wrong focus %p\n", hfocus);
12397
12398 SetFocus(hedit2);
12399 hfocus = GetFocus();
12400 ok(hfocus == hedit2, "wrong focus %p\n", hfocus);
12401
12402 check_selection(hedit1, 0, 0);
12403 check_selection(hedit2, 0, 0);
12404
12405 set_selection(hedit2, 0, -1);
12406 check_selection(hedit2, 0, 3);
12407
12408 SetFocus(0);
12409 hfocus = GetFocus();
12410 ok(hfocus == 0, "wrong focus %p\n", hfocus);
12411
12412 flush_sequence();
12413 ret = DefDlgProcA(hdlg, WM_SETFOCUS, 0, 0);
12414 ok(ret == 0, "WM_SETFOCUS returned %ld\n", ret);
12415 ok_sequence(WmDefDlgSetFocus_1, "DefDlgProc(WM_SETFOCUS) 1", FALSE);
12416
12417 hfocus = GetFocus();
12418 ok(hfocus == hedit1, "wrong focus %p\n", hfocus);
12419
12420 check_selection(hedit1, 0, 5);
12421 check_selection(hedit2, 0, 3);
12422
12423 flush_sequence();
12424 ret = DefDlgProcA(hdlg, WM_SETFOCUS, 0, 0);
12425 ok(ret == 0, "WM_SETFOCUS returned %ld\n", ret);
12426 ok_sequence(WmDefDlgSetFocus_2, "DefDlgProc(WM_SETFOCUS) 2", FALSE);
12427
12428 hfocus = GetFocus();
12429 ok(hfocus == hedit1, "wrong focus %p\n", hfocus);
12430
12431 check_selection(hedit1, 0, 5);
12432 check_selection(hedit2, 0, 3);
12433
12434 EndDialog(hdlg, 0);
12435 DestroyWindow(hedit1);
12436 DestroyWindow(hedit2);
12437 DestroyWindow(hdlg);
12438 flush_sequence();
12439
12440 #undef set_selection
12441 #undef check_selection
12442
12443 ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
12444 cls.lpszClassName = "MyDialogClass";
12445 cls.hInstance = GetModuleHandleA(NULL);
12446 /* need a cast since a dlgproc is used as a wndproc */
12447 cls.lpfnWndProc = test_dlg_proc;
12448 if (!RegisterClassA(&cls)) assert(0);
12449
12450 hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", 0, test_dlg_proc, 0);
12451 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
12452 ok_sequence(WmCreateDialogParamSeq_1, "CreateDialogParam_1", FALSE);
12453 EndDialog(hdlg, 0);
12454 DestroyWindow(hdlg);
12455 flush_sequence();
12456
12457 hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", 0, NULL, 0);
12458 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
12459 ok_sequence(WmCreateDialogParamSeq_2, "CreateDialogParam_2", FALSE);
12460 EndDialog(hdlg, 0);
12461 DestroyWindow(hdlg);
12462 flush_sequence();
12463
12464 hdlg = CreateDialogParamA(0, "FOCUS_TEST_DIALOG_3", 0, test_dlg_proc2, 0);
12465 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
12466 ok_sequence(WmCreateDialogParamSeq_3, "CreateDialogParam_3", TRUE);
12467 EndDialog(hdlg, 0);
12468 DestroyWindow(hdlg);
12469 flush_sequence();
12470
12471 UnregisterClassA( cls.lpszClassName, cls.hInstance );
12472 cls.lpfnWndProc = test_dlg_proc4;
12473 ok( RegisterClassA(&cls), "failed to register class again\n" );
12474 hdlg = CreateDialogParamA(0, "FOCUS_TEST_DIALOG_4", 0, test_dlg_proc3, 0);
12475 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
12476 ok_sequence(WmCreateDialogParamSeq_4, "CreateDialogParam_4", TRUE);
12477 EndDialog(hdlg, 0);
12478 DestroyWindow(hdlg);
12479 flush_sequence();
12480
12481 UnregisterClassA(cls.lpszClassName, cls.hInstance);
12482
12483 parent = CreateWindowExA(0, "TestParentClass", "Test parent",
12484 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
12485 100, 100, 200, 200, 0, 0, 0, NULL);
12486 ok (parent != 0, "Failed to create parent window\n");
12487
12488 /* This child has no parent set. We will later call SetParent on it,
12489 * so that it will have a parent set, but no WS_CHILD style. */
12490 child = CreateWindowExA(0, "TestWindowClass", "Test child",
12491 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
12492 100, 100, 200, 200, 0, 0, 0, NULL);
12493 ok (child != 0, "Failed to create child window\n");
12494
12495 /* This is a regular child window. When used as an owner, the other
12496 * child window will be used. */
12497 child2 = CreateWindowExA(0, "SimpleWindowClass", "Test child2",
12498 WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_CHILD,
12499 100, 100, 200, 200, child, 0, 0, NULL);
12500 ok (child2 != 0, "Failed to create child window\n");
12501
12502 SetParent(child, parent);
12503 SetFocus(child);
12504
12505 flush_sequence();
12506 DialogBoxA( 0, "TEST_DIALOG", child2, TestModalDlgProc2 );
12507 ok_sequence(WmModalDialogSeq_2, "ModalDialog2", TRUE);
12508
12509 DestroyWindow(child2);
12510 DestroyWindow(child);
12511 DestroyWindow(parent);
12512 flush_sequence();
12513 }
12514
12515 static void test_enddialog_seq(HWND dialog, HWND owner)
12516 {
12517 const struct message seq[] = {
12518 { WM_ENABLE, sent },
12519 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
12520 { HCBT_ACTIVATE, hook|wparam, (WPARAM)owner },
12521 { WM_NCACTIVATE, sent|wparam|lparam, WA_INACTIVE, (LPARAM)owner },
12522 { WM_ACTIVATE, sent|wparam|lparam, WA_INACTIVE, (LPARAM)owner },
12523 /* FIXME: Following two are optional because Wine sends WM_QUERYNEWPALETTE instead of WM_WINDOWPOSCHANGING */
12524 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
12525 { WM_QUERYNEWPALETTE, sent|optional },
12526 { WM_NCACTIVATE, sent|wparam|lparam, WA_ACTIVE, (LPARAM)dialog },
12527 { WM_GETTEXT, sent|optional|defwinproc },
12528 { WM_ACTIVATE, sent|wparam|lparam, WA_ACTIVE, (LPARAM)dialog },
12529 { HCBT_SETFOCUS, hook|wparam, (WPARAM)owner },
12530 { WM_KILLFOCUS, sent|wparam, (WPARAM)owner },
12531 { WM_SETFOCUS, sent|defwinproc|wparam, (WPARAM)dialog },
12532 { 0 }
12533 };
12534
12535 flush_sequence();
12536 EndDialog(dialog, 0);
12537 ok_sequence(seq, "EndDialog", FALSE);
12538 }
12539
12540 static void test_enddialog_seq2(HWND dialog, HWND owner)
12541 {
12542 const struct message seq[] = {
12543 { WM_ENABLE, parent|sent },
12544 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
12545 { HCBT_ACTIVATE, hook|wparam, (WPARAM)owner },
12546 { WM_NCACTIVATE, sent|wparam|lparam, WA_INACTIVE, (LPARAM)owner },
12547 { WM_ACTIVATE, sent|wparam|lparam, WA_INACTIVE, (LPARAM)owner },
12548 { WM_WINDOWPOSCHANGING, sent|optional|wparam, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
12549 { WM_WINDOWPOSCHANGING, sent|optional|wparam, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
12550 { HCBT_SETFOCUS, hook|wparam, (WPARAM)owner },
12551 { WM_KILLFOCUS, sent|wparam, (WPARAM)owner },
12552 { WM_SETFOCUS, sent|parent|defwinproc|wparam, (WPARAM)dialog },
12553 { 0 }
12554 };
12555
12556 flush_sequence();
12557 EndDialog(dialog, 0);
12558 ok_sequence(seq, "EndDialog2", FALSE);
12559 }
12560
12561 static void test_EndDialog(void)
12562 {
12563 HWND hparent, hother, hactive, hdlg, hchild;
12564 WNDCLASSA cls;
12565
12566 hparent = CreateWindowExA(0, "TestParentClass", "Test parent",
12567 WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_DISABLED,
12568 100, 100, 200, 200, 0, 0, 0, NULL);
12569 ok (hparent != 0, "Failed to create parent window\n");
12570
12571 hother = CreateWindowExA(0, "TestParentClass", "Test parent 2",
12572 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
12573 200, 100, 200, 200, 0, 0, 0, NULL);
12574 ok (hother != 0, "Failed to create parent window\n");
12575
12576 ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
12577 cls.lpszClassName = "MyDialogClass";
12578 cls.hInstance = GetModuleHandleA(NULL);
12579 cls.lpfnWndProc = test_dlg_proc;
12580 if (!RegisterClassA(&cls)) assert(0);
12581
12582 flush_sequence();
12583 SetForegroundWindow(hother);
12584 hactive = GetForegroundWindow();
12585 ok(hother == hactive, "Wrong window has focus (%p != %p)\n", hother, hactive);
12586
12587 /* create a dialog where the parent is disabled, this parent should be
12588 * enabled and receive focus when dialog exits */
12589 hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", hparent, test_dlg_proc, 0);
12590 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
12591 SetForegroundWindow(hdlg);
12592 hactive = GetForegroundWindow();
12593 ok(hdlg == hactive, "Wrong window has focus (%p != %p)\n", hdlg, hactive);
12594 EndDialog(hdlg, 0);
12595 ok(IsWindowEnabled(hparent), "parent is not enabled\n");
12596 hactive = GetForegroundWindow();
12597 ok(hparent == hactive, "Wrong window has focus (parent != active) (active: %p, parent: %p, dlg: %p, other: %p)\n", hactive, hparent, hdlg, hother);
12598 DestroyWindow(hdlg);
12599 flush_sequence();
12600
12601 /* create a dialog where the parent is disabled and set active window to other window before calling EndDialog */
12602 EnableWindow(hparent, FALSE);
12603 hdlg = CreateWindowExA(0, "TestDialogClass", NULL,
12604 WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
12605 0, 0, 100, 100, hparent, 0, 0, NULL);
12606 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
12607 flush_sequence();
12608 SetForegroundWindow(hother);
12609 flush_sequence();
12610 hactive = GetForegroundWindow();
12611 ok(hactive == hother, "Wrong foreground (%p != %p)\n", hactive, hother);
12612 hactive = GetActiveWindow();
12613 ok(hactive == hother, "Wrong active window (%p != %p)\n", hactive, hother);
12614 EndDialog(hdlg, 0);
12615 ok(IsWindowEnabled(hparent), "parent is not enabled\n");
12616 hactive = GetForegroundWindow();
12617 ok(hother == hactive, "Wrong window has focus (other != active) (active: %p, parent: %p, dlg: %p, other: %p)\n", hactive, hparent, hdlg, hother);
12618 DestroyWindow(hdlg);
12619 flush_sequence();
12620
12621 DestroyWindow( hparent );
12622
12623 hparent = CreateWindowExA(0, "TestParentClass", "Test parent",
12624 WS_POPUP | WS_VISIBLE | WS_DISABLED,
12625 100, 100, 200, 200, 0, 0, 0, NULL);
12626 ok (hparent != 0, "Failed to create parent window\n");
12627
12628 hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
12629 WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_DISABLED,
12630 0, 0, 0, 0, 0, 0, 0, NULL);
12631 ok (hchild != 0, "Failed to create child window\n");
12632
12633 SetParent(hchild, hparent);
12634
12635 flush_sequence();
12636 SetForegroundWindow(hother);
12637 hactive = GetForegroundWindow();
12638 ok(hother == hactive, "Wrong foreground window (%p != %p)\n", hother, hactive);
12639
12640 hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", hchild, test_dlg_proc, 0);
12641 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
12642
12643 SetForegroundWindow(hdlg);
12644 test_enddialog_seq(hdlg, hchild);
12645
12646 hactive = GetForegroundWindow();
12647 ok(hactive == hchild, "Wrong foreground window (active: %p, parent: %p, dlg: %p, other: %p child: %p)\n", hactive, hparent, hdlg, hother, hchild);
12648
12649 DestroyWindow(hdlg);
12650
12651 /* Now set WS_CHILD style flag so that it's a real child and its parent will be dialog's owner. */
12652 SetWindowLongW(hchild, GWL_STYLE, GetWindowLongW(hchild, GWL_STYLE) | WS_CHILD);
12653
12654 SetForegroundWindow(hother);
12655 hactive = GetForegroundWindow();
12656 ok(hother == hactive, "Wrong foreground window (%p != %p)\n", hother, hactive);
12657
12658 hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", hchild, test_dlg_proc, 0);
12659 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
12660
12661 SetForegroundWindow(hdlg);
12662 test_enddialog_seq2(hdlg, hparent);
12663
12664 hactive = GetForegroundWindow();
12665 ok(hactive == hparent, "Wrong foreground window (active: %p, parent: %p, dlg: %p, other: %p child: %p)\n", hactive, hparent, hdlg, hother, hchild);
12666 DestroyWindow(hdlg);
12667 DestroyWindow(hchild);
12668 DestroyWindow(hparent);
12669 DestroyWindow(hother);
12670 flush_sequence();
12671
12672 UnregisterClassA(cls.lpszClassName, cls.hInstance);
12673 }
12674
12675 static void test_nullCallback(void)
12676 {
12677 HWND hwnd;
12678
12679 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
12680 100, 100, 200, 200, 0, 0, 0, NULL);
12681 ok (hwnd != 0, "Failed to create overlapped window\n");
12682
12683 SendMessageCallbackA(hwnd,WM_NULL,0,0,NULL,0);
12684 flush_events();
12685 DestroyWindow(hwnd);
12686 }
12687
12688 /* SetActiveWindow( 0 ) hwnd visible */
12689 static const struct message SetActiveWindowSeq0[] =
12690 {
12691 { HCBT_ACTIVATE, hook|optional },
12692 { WM_NCACTIVATE, sent|wparam, 0 },
12693 { WM_GETTEXT, sent|defwinproc|optional },
12694 { WM_ACTIVATE, sent|wparam, 0 },
12695 { WM_ACTIVATEAPP, sent|wparam|optional, 0 },
12696 { WM_ACTIVATEAPP, sent|wparam|optional, 0 },
12697 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
12698 { WM_KILLFOCUS, sent|optional },
12699 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
12700 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
12701 { WM_NCACTIVATE, sent|wparam|optional, 1 },
12702 { WM_GETTEXT, sent|defwinproc|optional },
12703 { WM_ACTIVATE, sent|wparam|optional, 1 },
12704 { HCBT_SETFOCUS, hook|optional },
12705 { WM_KILLFOCUS, sent|defwinproc|optional },
12706 { WM_IME_SETCONTEXT, sent|defwinproc|optional },
12707 { WM_IME_SETCONTEXT, sent|defwinproc|optional },
12708 { WM_IME_SETCONTEXT, sent|optional },
12709 { WM_IME_SETCONTEXT, sent|optional },
12710 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
12711 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
12712 { WM_SETFOCUS, sent|defwinproc|optional },
12713 { WM_GETTEXT, sent|optional },
12714 { 0 }
12715 };
12716 /* SetActiveWindow( hwnd ) hwnd visible */
12717 static const struct message SetActiveWindowSeq1[] =
12718 {
12719 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
12720 { 0 }
12721 };
12722 /* SetActiveWindow( popup ) hwnd visible, popup visible */
12723 static const struct message SetActiveWindowSeq2[] =
12724 {
12725 { HCBT_ACTIVATE, hook },
12726 { WM_NCACTIVATE, sent|wparam, 0 },
12727 { WM_GETTEXT, sent|defwinproc|optional },
12728 { WM_ACTIVATE, sent|wparam, 0 },
12729 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
12730 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
12731 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
12732 { WM_NCPAINT, sent|optional },
12733 { WM_GETTEXT, sent|defwinproc|optional },
12734 { WM_ERASEBKGND, sent|optional },
12735 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
12736 { WM_NCACTIVATE, sent|wparam, 1 },
12737 { WM_GETTEXT, sent|defwinproc|optional },
12738 { WM_ACTIVATE, sent|wparam, 1 },
12739 { HCBT_SETFOCUS, hook },
12740 { WM_KILLFOCUS, sent|defwinproc },
12741 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
12742 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
12743 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
12744 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
12745 { WM_SETFOCUS, sent|defwinproc },
12746 { WM_GETTEXT, sent|optional },
12747 { 0 }
12748 };
12749
12750 /* SetActiveWindow( hwnd ) hwnd not visible */
12751 static const struct message SetActiveWindowSeq3[] =
12752 {
12753 { HCBT_ACTIVATE, hook },
12754 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
12755 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
12756 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
12757 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
12758 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
12759 { WM_ACTIVATEAPP, sent|wparam, 1 },
12760 { WM_ACTIVATEAPP, sent|wparam, 1 },
12761 { WM_NCACTIVATE, sent|wparam, 1 },
12762 { WM_ACTIVATE, sent|wparam, 1 },
12763 { HCBT_SETFOCUS, hook },
12764 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
12765 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
12766 { WM_SETFOCUS, sent|defwinproc },
12767 { 0 }
12768 };
12769 /* SetActiveWindow( popup ) hwnd not visible, popup not visible */
12770 static const struct message SetActiveWindowSeq4[] =
12771 {
12772 { HCBT_ACTIVATE, hook },
12773 { WM_NCACTIVATE, sent|wparam, 0 },
12774 { WM_GETTEXT, sent|defwinproc|optional },
12775 { WM_ACTIVATE, sent|wparam, 0 },
12776 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
12777 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
12778 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
12779 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
12780 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
12781 { WM_NCACTIVATE, sent|wparam, 1 },
12782 { WM_GETTEXT, sent|defwinproc|optional },
12783 { WM_ACTIVATE, sent|wparam, 1 },
12784 { HCBT_SETFOCUS, hook },
12785 { WM_KILLFOCUS, sent|defwinproc },
12786 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
12787 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
12788 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
12789 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
12790 { WM_SETFOCUS, sent|defwinproc },
12791 { 0 }
12792 };
12793
12794
12795 static void test_SetActiveWindow(void)
12796 {
12797 HWND hwnd, popup, ret;
12798
12799 hwnd = CreateWindowExA(0, "TestWindowClass", "Test SetActiveWindow",
12800 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
12801 100, 100, 200, 200, 0, 0, 0, NULL);
12802
12803 popup = CreateWindowExA(0, "TestWindowClass", "Test SetActiveWindow",
12804 WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_POPUP,
12805 100, 100, 200, 200, hwnd, 0, 0, NULL);
12806
12807 ok(hwnd != 0, "Failed to create overlapped window\n");
12808 ok(popup != 0, "Failed to create popup window\n");
12809 SetForegroundWindow( popup );
12810 flush_sequence();
12811
12812 trace("SetActiveWindow(0)\n");
12813 ret = SetActiveWindow(0);
12814 ok( ret == popup, "Failed to SetActiveWindow(0)\n");
12815 ok_sequence(SetActiveWindowSeq0, "SetActiveWindow(0)", FALSE);
12816 flush_sequence();
12817
12818 trace("SetActiveWindow(hwnd), hwnd visible\n");
12819 ret = SetActiveWindow(hwnd);
12820 if (ret == hwnd) ok_sequence(SetActiveWindowSeq1, "SetActiveWindow(hwnd), hwnd visible", TRUE);
12821 flush_sequence();
12822
12823 trace("SetActiveWindow(popup), hwnd visible, popup visible\n");
12824 ret = SetActiveWindow(popup);
12825 ok( ret == hwnd, "Failed to SetActiveWindow(popup), popup visible\n");
12826 ok_sequence(SetActiveWindowSeq2, "SetActiveWindow(popup), hwnd visible, popup visible", FALSE);
12827 flush_sequence();
12828
12829 ShowWindow(hwnd, SW_HIDE);
12830 ShowWindow(popup, SW_HIDE);
12831 flush_sequence();
12832
12833 trace("SetActiveWindow(hwnd), hwnd not visible\n");
12834 ret = SetActiveWindow(hwnd);
12835 ok( ret == NULL, "SetActiveWindow(hwnd), hwnd not visible, previous is %p\n", ret );
12836 ok_sequence(SetActiveWindowSeq3, "SetActiveWindow(hwnd), hwnd not visible", TRUE);
12837 flush_sequence();
12838
12839 trace("SetActiveWindow(popup), hwnd not visible, popup not visible\n");
12840 ret = SetActiveWindow(popup);
12841 ok( ret == hwnd, "Failed to SetActiveWindow(popup)\n");
12842 ok_sequence(SetActiveWindowSeq4, "SetActiveWindow(popup), hwnd not visible, popup not visible", TRUE);
12843 flush_sequence();
12844
12845 trace("done\n");
12846
12847 DestroyWindow(hwnd);
12848 }
12849
12850 static const struct message SetForegroundWindowSeq[] =
12851 {
12852 { WM_NCACTIVATE, sent|wparam, 0 },
12853 { WM_GETTEXT, sent|defwinproc|optional },
12854 { WM_ACTIVATE, sent|wparam, 0 },
12855 { WM_ACTIVATEAPP, sent|wparam, 0 },
12856 { WM_KILLFOCUS, sent },
12857 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
12858 { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
12859 { 0 }
12860 };
12861
12862 static void test_SetForegroundWindow(void)
12863 {
12864 HWND hwnd;
12865
12866 hwnd = CreateWindowExA(0, "TestWindowClass", "Test SetForegroundWindow",
12867 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
12868 100, 100, 200, 200, 0, 0, 0, NULL);
12869 ok (hwnd != 0, "Failed to create overlapped window\n");
12870 SetForegroundWindow( hwnd );
12871 flush_sequence();
12872
12873 trace("SetForegroundWindow( 0 )\n");
12874 SetForegroundWindow( 0 );
12875 ok_sequence(WmEmptySeq, "SetForegroundWindow( 0 ) away from foreground top level window", FALSE);
12876 trace("SetForegroundWindow( GetDesktopWindow() )\n");
12877 SetForegroundWindow( GetDesktopWindow() );
12878 ok_sequence(SetForegroundWindowSeq, "SetForegroundWindow( desktop ) away from "
12879 "foreground top level window", FALSE);
12880 trace("done\n");
12881
12882 DestroyWindow(hwnd);
12883 }
12884
12885 static DWORD get_input_codepage( void )
12886 {
12887 DWORD cp;
12888 int ret;
12889 HKL hkl = GetKeyboardLayout( 0 );
12890
12891 ret = GetLocaleInfoW( LOWORD(hkl), LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
12892 (WCHAR *)&cp, sizeof(cp) / sizeof(WCHAR) );
12893 if (!ret) cp = CP_ACP;
12894 return cp;
12895 }
12896
12897 static void test_dbcs_wm_char(void)
12898 {
12899 BYTE dbch[2];
12900 WCHAR wch, bad_wch;
12901 HWND hwnd, hwnd2;
12902 MSG msg;
12903 DWORD time;
12904 POINT pt;
12905 DWORD_PTR res;
12906 CPINFOEXA cpinfo;
12907 UINT i, j, k;
12908 struct message wmCharSeq[2];
12909 BOOL ret;
12910 DWORD cp = get_input_codepage();
12911
12912 if (!pGetCPInfoExA)
12913 {
12914 win_skip("GetCPInfoExA is not available\n");
12915 return;
12916 }
12917
12918 pGetCPInfoExA( cp, 0, &cpinfo );
12919 if (cpinfo.MaxCharSize != 2)
12920 {
12921 skip( "Skipping DBCS WM_CHAR test in SBCS codepage '%s'\n", cpinfo.CodePageName );
12922 return;
12923 }
12924
12925 dbch[0] = dbch[1] = 0;
12926 wch = 0;
12927 bad_wch = cpinfo.UnicodeDefaultChar;
12928 for (i = 0; !wch && i < MAX_LEADBYTES && cpinfo.LeadByte[i]; i += 2)
12929 for (j = cpinfo.LeadByte[i]; !wch && j <= cpinfo.LeadByte[i+1]; j++)
12930 for (k = 128; k <= 255; k++)
12931 {
12932 char str[2];
12933 WCHAR wstr[2];
12934 str[0] = j;
12935 str[1] = k;
12936 if (MultiByteToWideChar( cp, 0, str, 2, wstr, 2 ) == 1 &&
12937 WideCharToMultiByte( cp, 0, wstr, 1, str, 2, NULL, NULL ) == 2 &&
12938 (BYTE)str[0] == j && (BYTE)str[1] == k &&
12939 HIBYTE(wstr[0]) && HIBYTE(wstr[0]) != 0xff)
12940 {
12941 dbch[0] = j;
12942 dbch[1] = k;
12943 wch = wstr[0];
12944 break;
12945 }
12946 }
12947
12948 if (!wch)
12949 {
12950 skip( "Skipping DBCS WM_CHAR test, no appropriate char found\n" );
12951 return;
12952 }
12953 trace( "using dbcs char %02x,%02x wchar %04x bad wchar %04x codepage '%s'\n",
12954 dbch[0], dbch[1], wch, bad_wch, cpinfo.CodePageName );
12955
12956 hwnd = CreateWindowExW(0, testWindowClassW, NULL,
12957 WS_OVERLAPPEDWINDOW, 100, 100, 200, 200, 0, 0, 0, NULL);
12958 hwnd2 = CreateWindowExW(0, testWindowClassW, NULL,
12959 WS_OVERLAPPEDWINDOW, 100, 100, 200, 200, 0, 0, 0, NULL);
12960 ok (hwnd != 0, "Failed to create overlapped window\n");
12961 ok (hwnd2 != 0, "Failed to create overlapped window\n");
12962 flush_sequence();
12963
12964 memset( wmCharSeq, 0, sizeof(wmCharSeq) );
12965 wmCharSeq[0].message = WM_CHAR;
12966 wmCharSeq[0].flags = sent|wparam;
12967 wmCharSeq[0].wParam = wch;
12968
12969 /* posted message */
12970 PostMessageA( hwnd, WM_CHAR, dbch[0], 0 );
12971 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12972 ok( !ret, "got message %x\n", msg.message );
12973 PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
12974 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12975 ok( ret, "no message\n" );
12976 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
12977 ok( msg.wParam == wch, "bad wparam %lx/%x\n", msg.wParam, wch );
12978 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12979 ok( !ret, "got message %x\n", msg.message );
12980
12981 /* posted thread message */
12982 PostThreadMessageA( GetCurrentThreadId(), WM_CHAR, dbch[0], 0 );
12983 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12984 ok( !ret, "got message %x\n", msg.message );
12985 PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
12986 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12987 ok( ret, "no message\n" );
12988 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
12989 ok( msg.wParam == wch, "bad wparam %lx/%x\n", msg.wParam, wch );
12990 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12991 ok( !ret, "got message %x\n", msg.message );
12992
12993 /* sent message */
12994 flush_sequence();
12995 SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
12996 ok_sequence( WmEmptySeq, "no messages", FALSE );
12997 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
12998 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
12999 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13000 ok( !ret, "got message %x\n", msg.message );
13001
13002 /* sent message with timeout */
13003 flush_sequence();
13004 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[0], 0, SMTO_NORMAL, 0, &res );
13005 ok_sequence( WmEmptySeq, "no messages", FALSE );
13006 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[1], 0, SMTO_NORMAL, 0, &res );
13007 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13008 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13009 ok( !ret, "got message %x\n", msg.message );
13010
13011 /* sent message with timeout and callback */
13012 flush_sequence();
13013 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[0], 0, SMTO_NORMAL, 0, &res );
13014 ok_sequence( WmEmptySeq, "no messages", FALSE );
13015 SendMessageCallbackA( hwnd, WM_CHAR, dbch[1], 0, NULL, 0 );
13016 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13017 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13018 ok( !ret, "got message %x\n", msg.message );
13019
13020 /* sent message with callback */
13021 flush_sequence();
13022 SendNotifyMessageA( hwnd, WM_CHAR, dbch[0], 0 );
13023 ok_sequence( WmEmptySeq, "no messages", FALSE );
13024 SendMessageCallbackA( hwnd, WM_CHAR, dbch[1], 0, NULL, 0 );
13025 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13026 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13027 ok( !ret, "got message %x\n", msg.message );
13028
13029 /* direct window proc call */
13030 flush_sequence();
13031 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
13032 ok_sequence( WmEmptySeq, "no messages", FALSE );
13033 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
13034 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13035
13036 /* dispatch message */
13037 msg.hwnd = hwnd;
13038 msg.message = WM_CHAR;
13039 msg.wParam = dbch[0];
13040 msg.lParam = 0;
13041 DispatchMessageA( &msg );
13042 ok_sequence( WmEmptySeq, "no messages", FALSE );
13043 msg.wParam = dbch[1];
13044 DispatchMessageA( &msg );
13045 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13046
13047 /* window handle is irrelevant */
13048 flush_sequence();
13049 SendMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
13050 ok_sequence( WmEmptySeq, "no messages", FALSE );
13051 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
13052 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13053 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13054 ok( !ret, "got message %x\n", msg.message );
13055
13056 /* interleaved post and send */
13057 flush_sequence();
13058 PostMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
13059 SendMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
13060 ok_sequence( WmEmptySeq, "no messages", FALSE );
13061 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13062 ok( !ret, "got message %x\n", msg.message );
13063 PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
13064 ok_sequence( WmEmptySeq, "no messages", FALSE );
13065 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13066 ok( ret, "no message\n" );
13067 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13068 ok( msg.wParam == wch, "bad wparam %lx/%x\n", msg.wParam, wch );
13069 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13070 ok( !ret, "got message %x\n", msg.message );
13071 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
13072 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13073 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13074 ok( !ret, "got message %x\n", msg.message );
13075
13076 /* interleaved sent message and winproc */
13077 flush_sequence();
13078 SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
13079 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
13080 ok_sequence( WmEmptySeq, "no messages", FALSE );
13081 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
13082 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13083 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
13084 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13085
13086 /* interleaved winproc and dispatch */
13087 msg.hwnd = hwnd;
13088 msg.message = WM_CHAR;
13089 msg.wParam = dbch[0];
13090 msg.lParam = 0;
13091 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
13092 DispatchMessageA( &msg );
13093 ok_sequence( WmEmptySeq, "no messages", FALSE );
13094 msg.wParam = dbch[1];
13095 DispatchMessageA( &msg );
13096 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13097 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
13098 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13099
13100 /* interleaved sends */
13101 flush_sequence();
13102 SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
13103 SendMessageCallbackA( hwnd, WM_CHAR, dbch[0], 0, NULL, 0 );
13104 ok_sequence( WmEmptySeq, "no messages", FALSE );
13105 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[1], 0, SMTO_NORMAL, 0, &res );
13106 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13107 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
13108 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13109
13110 /* dbcs WM_CHAR */
13111 flush_sequence();
13112 SendMessageA( hwnd2, WM_CHAR, (dbch[1] << 8) | dbch[0], 0 );
13113 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13114 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13115 ok( !ret, "got message %x\n", msg.message );
13116
13117 /* other char messages are not magic */
13118 PostMessageA( hwnd, WM_SYSCHAR, dbch[0], 0 );
13119 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13120 ok( ret, "no message\n" );
13121 ok( msg.message == WM_SYSCHAR, "unexpected message %x\n", msg.message );
13122 ok( msg.wParam == bad_wch, "bad wparam %lx/%x\n", msg.wParam, bad_wch );
13123 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13124 ok( !ret, "got message %x\n", msg.message );
13125 PostMessageA( hwnd, WM_DEADCHAR, dbch[0], 0 );
13126 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13127 ok( ret, "no message\n" );
13128 ok( msg.message == WM_DEADCHAR, "unexpected message %x\n", msg.message );
13129 ok( msg.wParam == bad_wch, "bad wparam %lx/%x\n", msg.wParam, bad_wch );
13130 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13131 ok( !ret, "got message %x\n", msg.message );
13132
13133 /* test retrieving messages */
13134
13135 PostMessageW( hwnd, WM_CHAR, wch, 0 );
13136 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
13137 ok( ret, "no message\n" );
13138 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13139 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13140 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13141 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
13142 ok( ret, "no message\n" );
13143 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13144 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13145 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13146 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
13147 ok( !ret, "got message %x\n", msg.message );
13148
13149 /* message filters */
13150 PostMessageW( hwnd, WM_CHAR, wch, 0 );
13151 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
13152 ok( ret, "no message\n" );
13153 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13154 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13155 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13156 /* message id is filtered, hwnd is not */
13157 ret = PeekMessageA( &msg, hwnd, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE );
13158 ok( !ret, "no message\n" );
13159 ret = PeekMessageA( &msg, hwnd2, 0, 0, PM_REMOVE );
13160 ok( ret, "no message\n" );
13161 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13162 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13163 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13164 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
13165 ok( !ret, "got message %x\n", msg.message );
13166
13167 /* mixing GetMessage and PostMessage */
13168 PostMessageW( hwnd, WM_CHAR, wch, 0xbeef );
13169 ok( GetMessageA( &msg, hwnd, 0, 0 ), "no message\n" );
13170 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13171 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13172 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13173 ok( msg.lParam == 0xbeef, "bad lparam %lx\n", msg.lParam );
13174 time = msg.time;
13175 pt = msg.pt;
13176 ok( time - GetTickCount() <= 100, "bad time %x\n", msg.time );
13177 ret = PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
13178 ok( ret, "no message\n" );
13179 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13180 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13181 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13182 ok( msg.lParam == 0xbeef, "bad lparam %lx\n", msg.lParam );
13183 ok( msg.time == time, "bad time %x/%x\n", msg.time, time );
13184 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 );
13185 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
13186 ok( !ret, "got message %x\n", msg.message );
13187
13188 /* without PM_REMOVE */
13189 PostMessageW( hwnd, WM_CHAR, wch, 0 );
13190 ret = PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
13191 ok( ret, "no message\n" );
13192 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13193 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13194 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13195 ret = PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
13196 ok( ret, "no message\n" );
13197 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13198 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13199 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13200 ret = PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
13201 ok( ret, "no message\n" );
13202 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13203 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13204 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13205 ret = PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
13206 ok( ret, "no message\n" );
13207 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13208 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13209 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13210 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
13211 ok( !ret, "got message %x\n", msg.message );
13212
13213 DestroyWindow(hwnd);
13214 DestroyWindow(hwnd2);
13215 }
13216
13217 static void test_unicode_wm_char(void)
13218 {
13219 HWND hwnd;
13220 MSG msg;
13221 struct message seq[2];
13222 HKL hkl_orig, hkl_greek;
13223 DWORD cp;
13224 LCID thread_locale;
13225
13226 hkl_orig = GetKeyboardLayout( 0 );
13227 GetLocaleInfoW( LOWORD( hkl_orig ), LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER, (WCHAR*)&cp, sizeof(cp) / sizeof(WCHAR) );
13228 if (cp != 1252)
13229 {
13230 skip( "Default codepage %d\n", cp );
13231 return;
13232 }
13233
13234 hkl_greek = LoadKeyboardLayoutA( "00000408", 0 );
13235 if (!hkl_greek || hkl_greek == hkl_orig /* win2k */)
13236 {
13237 skip( "Unable to load Greek keyboard layout\n" );
13238 return;
13239 }
13240
13241 hwnd = CreateWindowExW( 0, testWindowClassW, NULL, WS_OVERLAPPEDWINDOW,
13242 100, 100, 200, 200, 0, 0, 0, NULL );
13243 flush_sequence();
13244
13245 PostMessageW( hwnd, WM_CHAR, 0x3b1, 0 );
13246
13247 while (GetMessageW( &msg, hwnd, 0, 0 ))
13248 {
13249 if (!ignore_message( msg.message )) break;
13250 }
13251
13252 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13253 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13254 ok( msg.wParam == 0x3b1, "bad wparam %lx\n", msg.wParam );
13255 ok( msg.lParam == 0, "bad lparam %lx\n", msg.lParam );
13256
13257 DispatchMessageW( &msg );
13258
13259 memset( seq, 0, sizeof(seq) );
13260 seq[0].message = WM_CHAR;
13261 seq[0].flags = sent|wparam;
13262 seq[0].wParam = 0x3b1;
13263
13264 ok_sequence( seq, "unicode WM_CHAR", FALSE );
13265
13266 flush_sequence();
13267
13268 /* greek alpha -> 'a' in cp1252 */
13269 PostMessageW( hwnd, WM_CHAR, 0x3b1, 0 );
13270
13271 ok( GetMessageA( &msg, hwnd, 0, 0 ), "no message\n" );
13272 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13273 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13274 ok( msg.wParam == 0x61, "bad wparam %lx\n", msg.wParam );
13275 ok( msg.lParam == 0, "bad lparam %lx\n", msg.lParam );
13276
13277 DispatchMessageA( &msg );
13278
13279 seq[0].wParam = 0x61;
13280 ok_sequence( seq, "unicode WM_CHAR", FALSE );
13281
13282 thread_locale = GetThreadLocale();
13283 ActivateKeyboardLayout( hkl_greek, 0 );
13284 ok( GetThreadLocale() == thread_locale, "locale changed from %08x to %08x\n",
13285 thread_locale, GetThreadLocale() );
13286
13287 flush_sequence();
13288
13289 /* greek alpha -> 0xe1 in cp1253 */
13290 PostMessageW( hwnd, WM_CHAR, 0x3b1, 0 );
13291
13292 ok( GetMessageA( &msg, hwnd, 0, 0 ), "no message\n" );
13293 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13294 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13295 ok( msg.wParam == 0xe1, "bad wparam %lx\n", msg.wParam );
13296 ok( msg.lParam == 0, "bad lparam %lx\n", msg.lParam );
13297
13298 DispatchMessageA( &msg );
13299
13300 seq[0].wParam = 0x3b1;
13301 ok_sequence( seq, "unicode WM_CHAR", FALSE );
13302
13303 DestroyWindow( hwnd );
13304 ActivateKeyboardLayout( hkl_orig, 0 );
13305 UnloadKeyboardLayout( hkl_greek );
13306 }
13307
13308 #define ID_LISTBOX 0x000f
13309
13310 static const struct message wm_lb_setcursel_0[] =
13311 {
13312 { LB_SETCURSEL, sent|wparam|lparam, 0, 0 },
13313 { WM_CTLCOLORLISTBOX, sent|parent },
13314 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000120f2 },
13315 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 1 },
13316 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam, OBJID_CLIENT, 1 },
13317 { 0 }
13318 };
13319 static const struct message wm_lb_setcursel_1[] =
13320 {
13321 { LB_SETCURSEL, sent|wparam|lparam, 1, 0 },
13322 { WM_CTLCOLORLISTBOX, sent|parent },
13323 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000020f2 },
13324 { WM_CTLCOLORLISTBOX, sent|parent },
13325 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000121f2 },
13326 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 2 },
13327 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam, OBJID_CLIENT, 2 },
13328 { 0 }
13329 };
13330 static const struct message wm_lb_setcursel_2[] =
13331 {
13332 { LB_SETCURSEL, sent|wparam|lparam, 2, 0 },
13333 { WM_CTLCOLORLISTBOX, sent|parent },
13334 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000021f2 },
13335 { WM_CTLCOLORLISTBOX, sent|parent },
13336 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000122f2 },
13337 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 3 },
13338 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam, OBJID_CLIENT, 3 },
13339 { 0 }
13340 };
13341 static const struct message wm_lb_click_0[] =
13342 {
13343 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, MAKELPARAM(1,1) },
13344 { HCBT_SETFOCUS, hook },
13345 { WM_KILLFOCUS, sent|parent },
13346 { WM_IME_SETCONTEXT, sent|wparam|optional|parent, 0 },
13347 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
13348 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
13349 { WM_SETFOCUS, sent|defwinproc },
13350
13351 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x001142f2 },
13352 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_LISTBOX, LBN_SETFOCUS) },
13353 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 3 },
13354 { WM_LBTRACKPOINT, sent|wparam|lparam|parent, 0, MAKELPARAM(1,1) },
13355 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
13356
13357 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000142f2 },
13358 { WM_CTLCOLORLISTBOX, sent|parent },
13359 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000022f2 },
13360 { WM_CTLCOLORLISTBOX, sent|parent },
13361 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000120f2 },
13362 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x001140f2 },
13363
13364 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 1 },
13365 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam, OBJID_CLIENT, 1 },
13366
13367 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
13368 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
13369 { WM_CAPTURECHANGED, sent|wparam|lparam|defwinproc, 0, 0 },
13370 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_LISTBOX, LBN_SELCHANGE) },
13371 { 0 }
13372 };
13373 static const struct message wm_lb_deletestring[] =
13374 {
13375 { LB_DELETESTRING, sent|wparam|lparam, 0, 0 },
13376 { WM_DELETEITEM, sent|wparam|parent|optional, ID_LISTBOX, 0 },
13377 { WM_DRAWITEM, sent|wparam|parent|optional, ID_LISTBOX },
13378 { WM_DRAWITEM, sent|wparam|parent|optional, ID_LISTBOX },
13379 { 0 }
13380 };
13381 static const struct message wm_lb_deletestring_reset[] =
13382 {
13383 { LB_DELETESTRING, sent|wparam|lparam, 0, 0 },
13384 { LB_RESETCONTENT, sent|wparam|lparam|defwinproc|optional, 0, 0 },
13385 { WM_DELETEITEM, sent|wparam|parent|optional, ID_LISTBOX, 0 },
13386 { WM_DRAWITEM, sent|wparam|parent|optional, ID_LISTBOX },
13387 { WM_DRAWITEM, sent|wparam|parent|optional, ID_LISTBOX },
13388 { 0 }
13389 };
13390
13391 #define check_lb_state(a1, a2, a3, a4, a5) check_lb_state_dbg(a1, a2, a3, a4, a5, __LINE__)
13392
13393 static LRESULT (WINAPI *listbox_orig_proc)(HWND, UINT, WPARAM, LPARAM);
13394
13395 static LRESULT WINAPI listbox_hook_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
13396 {
13397 static LONG defwndproc_counter = 0;
13398 LRESULT ret;
13399 struct recvd_message msg;
13400
13401 /* do not log painting messages */
13402 if (message != WM_PAINT &&
13403 message != WM_NCPAINT &&
13404 message != WM_SYNCPAINT &&
13405 message != WM_ERASEBKGND &&
13406 message != WM_NCHITTEST &&
13407 message != WM_GETTEXT &&
13408 !ignore_message( message ))
13409 {
13410 msg.hwnd = hwnd;
13411 msg.message = message;
13412 msg.flags = sent|wparam|lparam;
13413 if (defwndproc_counter) msg.flags |= defwinproc;
13414 msg.wParam = wp;
13415 msg.lParam = lp;
13416 msg.descr = "listbox";
13417 add_message(&msg);
13418 }
13419
13420 defwndproc_counter++;
13421 ret = CallWindowProcA(listbox_orig_proc, hwnd, message, wp, lp);
13422 defwndproc_counter--;
13423
13424 return ret;
13425 }
13426
13427 static void check_lb_state_dbg(HWND listbox, int count, int cur_sel,
13428 int caret_index, int top_index, int line)
13429 {
13430 LRESULT ret;
13431
13432 /* calling an orig proc helps to avoid unnecessary message logging */
13433 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETCOUNT, 0, 0);
13434 ok_(__FILE__, line)(ret == count, "expected count %d, got %ld\n", count, ret);
13435 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETCURSEL, 0, 0);
13436 ok_(__FILE__, line)(ret == cur_sel, "expected cur sel %d, got %ld\n", cur_sel, ret);
13437 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETCARETINDEX, 0, 0);
13438 ok_(__FILE__, line)(ret == caret_index ||
13439 broken(cur_sel == -1 && caret_index == 0 && ret == -1), /* nt4 */
13440 "expected caret index %d, got %ld\n", caret_index, ret);
13441 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETTOPINDEX, 0, 0);
13442 ok_(__FILE__, line)(ret == top_index, "expected top index %d, got %ld\n", top_index, ret);
13443 }
13444
13445 static void test_listbox_messages(void)
13446 {
13447 HWND parent, listbox;
13448 LRESULT ret;
13449
13450 parent = CreateWindowExA(0, "TestParentClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
13451 100, 100, 200, 200, 0, 0, 0, NULL);
13452 listbox = CreateWindowExA(WS_EX_NOPARENTNOTIFY, "ListBox", NULL,
13453 WS_CHILD | LBS_NOTIFY | LBS_OWNERDRAWVARIABLE | LBS_HASSTRINGS | WS_VISIBLE,
13454 10, 10, 80, 80, parent, (HMENU)ID_LISTBOX, 0, NULL);
13455 listbox_orig_proc = (WNDPROC)SetWindowLongPtrA(listbox, GWLP_WNDPROC, (ULONG_PTR)listbox_hook_proc);
13456
13457 check_lb_state(listbox, 0, LB_ERR, 0, 0);
13458
13459 ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 0");
13460 ok(ret == 0, "expected 0, got %ld\n", ret);
13461 ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 1");
13462 ok(ret == 1, "expected 1, got %ld\n", ret);
13463 ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 2");
13464 ok(ret == 2, "expected 2, got %ld\n", ret);
13465
13466 check_lb_state(listbox, 3, LB_ERR, 0, 0);
13467
13468 flush_sequence();
13469
13470 log_all_parent_messages++;
13471
13472 trace("selecting item 0\n");
13473 ret = SendMessageA(listbox, LB_SETCURSEL, 0, 0);
13474 ok(ret == 0, "expected 0, got %ld\n", ret);
13475 ok_sequence(wm_lb_setcursel_0, "LB_SETCURSEL 0", FALSE );
13476 check_lb_state(listbox, 3, 0, 0, 0);
13477 flush_sequence();
13478
13479 trace("selecting item 1\n");
13480 ret = SendMessageA(listbox, LB_SETCURSEL, 1, 0);
13481 ok(ret == 1, "expected 1, got %ld\n", ret);
13482 ok_sequence(wm_lb_setcursel_1, "LB_SETCURSEL 1", FALSE );
13483 check_lb_state(listbox, 3, 1, 1, 0);
13484
13485 trace("selecting item 2\n");
13486 ret = SendMessageA(listbox, LB_SETCURSEL, 2, 0);
13487 ok(ret == 2, "expected 2, got %ld\n", ret);
13488 ok_sequence(wm_lb_setcursel_2, "LB_SETCURSEL 2", FALSE );
13489 check_lb_state(listbox, 3, 2, 2, 0);
13490
13491 trace("clicking on item 0\n");
13492 ret = SendMessageA(listbox, WM_LBUTTONDOWN, 0, MAKELPARAM(1, 1));
13493 ok(ret == LB_OKAY, "expected LB_OKAY, got %ld\n", ret);
13494 ret = SendMessageA(listbox, WM_LBUTTONUP, 0, 0);
13495 ok(ret == LB_OKAY, "expected LB_OKAY, got %ld\n", ret);
13496 ok_sequence(wm_lb_click_0, "WM_LBUTTONDOWN 0", FALSE );
13497 check_lb_state(listbox, 3, 0, 0, 0);
13498 flush_sequence();
13499
13500 trace("deleting item 0\n");
13501 ret = SendMessageA(listbox, LB_DELETESTRING, 0, 0);
13502 ok(ret == 2, "expected 2, got %ld\n", ret);
13503 ok_sequence(wm_lb_deletestring, "LB_DELETESTRING 0", FALSE );
13504 check_lb_state(listbox, 2, -1, 0, 0);
13505 flush_sequence();
13506
13507 trace("deleting item 0\n");
13508 ret = SendMessageA(listbox, LB_DELETESTRING, 0, 0);
13509 ok(ret == 1, "expected 1, got %ld\n", ret);
13510 ok_sequence(wm_lb_deletestring, "LB_DELETESTRING 0", FALSE );
13511 check_lb_state(listbox, 1, -1, 0, 0);
13512 flush_sequence();
13513
13514 trace("deleting item 0\n");
13515 ret = SendMessageA(listbox, LB_DELETESTRING, 0, 0);
13516 ok(ret == 0, "expected 0, got %ld\n", ret);
13517 ok_sequence(wm_lb_deletestring_reset, "LB_DELETESTRING 0", FALSE );
13518 check_lb_state(listbox, 0, -1, 0, 0);
13519 flush_sequence();
13520
13521 trace("deleting item 0\n");
13522 ret = SendMessageA(listbox, LB_DELETESTRING, 0, 0);
13523 ok(ret == LB_ERR, "expected LB_ERR, got %ld\n", ret);
13524 check_lb_state(listbox, 0, -1, 0, 0);
13525 flush_sequence();
13526
13527 log_all_parent_messages--;
13528
13529 DestroyWindow(listbox);
13530 DestroyWindow(parent);
13531 }
13532
13533 /*************************** Menu test ******************************/
13534 static const struct message wm_popup_menu_1[] =
13535 {
13536 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
13537 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
13538 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'E', 0x20000001 },
13539 { WM_SYSKEYDOWN, sent|wparam|lparam, 'E', 0x20000001 },
13540 { WM_SYSCHAR, sent|wparam|lparam, 'e', 0x20000001 },
13541 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_KEYMENU, 'e' },
13542 { WM_ENTERMENULOOP, sent|wparam|lparam, 0, 0 },
13543 { WM_INITMENU, sent|lparam, 0, 0 },
13544 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(1,MF_HILITE|MF_POPUP) },
13545 { WM_INITMENUPOPUP, sent|lparam, 0, 1 },
13546 { HCBT_CREATEWND, hook|optional }, /* Win9x doesn't create a window */
13547 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(200,MF_HILITE) },
13548 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'E', 0xf0000001 },
13549 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xd0000001 },
13550 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0x10000001, 0, 0x40000000 },
13551 { HCBT_DESTROYWND, hook|optional }, /* Win9x doesn't create a window */
13552 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
13553 { WM_MENUSELECT, sent|wparam|lparam, MAKEWPARAM(0,0xffff), 0 },
13554 { WM_EXITMENULOOP, sent|wparam|lparam, 0, 0 },
13555 { WM_MENUCOMMAND, sent }, /* |wparam, 200 - Win9x */
13556 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0xc0000001 },
13557 { WM_KEYUP, sent|wparam|lparam, VK_RETURN, 0xc0000001 },
13558 { 0 }
13559 };
13560 static const struct message wm_popup_menu_2[] =
13561 {
13562 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
13563 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
13564 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0x20000001 },
13565 { WM_SYSKEYDOWN, sent|wparam|lparam, 'F', 0x20000001 },
13566 { WM_SYSCHAR, sent|wparam|lparam, 'f', 0x20000001 },
13567 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_KEYMENU, 'f' },
13568 { WM_ENTERMENULOOP, sent|wparam|lparam, 0, 0 },
13569 { WM_INITMENU, sent|lparam, 0, 0 },
13570 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) },
13571 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
13572 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(0,MF_HILITE|MF_POPUP) }, /* Win9x */
13573 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x */
13574 { HCBT_CREATEWND, hook },
13575 { WM_MENUSELECT, sent }, /*|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) - XP
13576 |wparam, MAKEWPARAM(100,MF_HILITE) - Win9x */
13577 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0xf0000001 },
13578 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xd0000001 },
13579 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0x10000001 },
13580 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x doesn't send it */
13581 { HCBT_CREATEWND, hook|optional }, /* Win9x doesn't send it */
13582 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(100,MF_HILITE) },
13583 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0xd0000001 },
13584 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0x10000001 },
13585 { HCBT_DESTROYWND, hook },
13586 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
13587 { HCBT_DESTROYWND, hook|optional }, /* Win9x doesn't send it */
13588 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
13589 { WM_MENUSELECT, sent|wparam|lparam, MAKEWPARAM(0,0xffff), 0 },
13590 { WM_EXITMENULOOP, sent|wparam|lparam, 0, 0 },
13591 { WM_MENUCOMMAND, sent }, /* |wparam, 100 - Win9x */
13592 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0xc0000001 },
13593 { WM_KEYUP, sent|wparam|lparam, VK_RETURN, 0xc0000001 },
13594 { 0 }
13595 };
13596 static const struct message wm_popup_menu_3[] =
13597 {
13598 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
13599 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
13600 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0x20000001 },
13601 { WM_SYSKEYDOWN, sent|wparam|lparam, 'F', 0x20000001 },
13602 { WM_SYSCHAR, sent|wparam|lparam, 'f', 0x20000001 },
13603 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_KEYMENU, 'f' },
13604 { WM_ENTERMENULOOP, sent|wparam|lparam, 0, 0 },
13605 { WM_INITMENU, sent|lparam, 0, 0 },
13606 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) },
13607 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
13608 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(0,MF_HILITE|MF_POPUP) }, /* Win9x */
13609 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x */
13610 { HCBT_CREATEWND, hook },
13611 { WM_MENUSELECT, sent }, /*|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) - XP
13612 |wparam, MAKEWPARAM(100,MF_HILITE) - Win9x */
13613 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0xf0000001 },
13614 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xd0000001 },
13615 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0x10000001 },
13616 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x doesn't send it */
13617 { HCBT_CREATEWND, hook|optional }, /* Win9x doesn't send it */
13618 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(100,MF_HILITE) },
13619 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0xd0000001 },
13620 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0x10000001 },
13621 { HCBT_DESTROYWND, hook },
13622 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
13623 { HCBT_DESTROYWND, hook|optional }, /* Win9x doesn't send it */
13624 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
13625 { WM_MENUSELECT, sent|wparam|lparam, MAKEWPARAM(0,0xffff), 0 },
13626 { WM_EXITMENULOOP, sent|wparam|lparam, 0, 0 },
13627 { WM_COMMAND, sent|wparam|lparam, 100, 0 },
13628 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0xc0000001 },
13629 { WM_KEYUP, sent|wparam|lparam, VK_RETURN, 0xc0000001 },
13630 { 0 }
13631 };
13632
13633 static const struct message wm_single_menu_item[] =
13634 {
13635 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
13636 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
13637 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'Q', 0x20000001 },
13638 { WM_SYSKEYDOWN, sent|wparam|lparam, 'Q', 0x20000001 },
13639 { WM_SYSCHAR, sent|wparam|lparam, 'q', 0x20000001 },
13640 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_KEYMENU, 'q' },
13641 { WM_ENTERMENULOOP, sent|wparam|lparam, 0, 0 },
13642 { WM_INITMENU, sent|lparam, 0, 0 },
13643 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(300,MF_HILITE) },
13644 { WM_MENUSELECT, sent|wparam|lparam, MAKEWPARAM(0,0xffff), 0 },
13645 { WM_EXITMENULOOP, sent|wparam|lparam, 0, 0 },
13646 { WM_MENUCOMMAND, sent },
13647 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'Q', 0xe0000001 },
13648 { WM_SYSKEYUP, sent|wparam|lparam, 'Q', 0xe0000001 },
13649 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 },
13650 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
13651
13652 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_ESCAPE, 1 },
13653 { WM_KEYDOWN, sent|wparam|lparam, VK_ESCAPE, 1 },
13654 { WM_CHAR, sent|wparam|lparam, VK_ESCAPE, 0x00000001 },
13655 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_ESCAPE, 0xc0000001 },
13656 { WM_KEYUP, sent|wparam|lparam, VK_ESCAPE, 0xc0000001 },
13657 { 0 }
13658 };
13659
13660 static LRESULT WINAPI parent_menu_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
13661 {
13662 if (message == WM_ENTERIDLE ||
13663 message == WM_INITMENU ||
13664 message == WM_INITMENUPOPUP ||
13665 message == WM_MENUSELECT ||
13666 message == WM_PARENTNOTIFY ||
13667 message == WM_ENTERMENULOOP ||
13668 message == WM_EXITMENULOOP ||
13669 message == WM_UNINITMENUPOPUP ||
13670 message == WM_KEYDOWN ||
13671 message == WM_KEYUP ||
13672 message == WM_CHAR ||
13673 message == WM_SYSKEYDOWN ||
13674 message == WM_SYSKEYUP ||
13675 message == WM_SYSCHAR ||
13676 message == WM_COMMAND ||
13677 message == WM_MENUCOMMAND)
13678 {
13679 struct recvd_message msg;
13680
13681 msg.hwnd = hwnd;
13682 msg.message = message;
13683 msg.flags = sent|wparam|lparam;
13684 msg.wParam = wp;
13685 msg.lParam = lp;
13686 msg.descr = "parent_menu_proc";
13687 add_message(&msg);
13688 }
13689
13690 return DefWindowProcA(hwnd, message, wp, lp);
13691 }
13692
13693 static void set_menu_style(HMENU hmenu, DWORD style)
13694 {
13695 MENUINFO mi;
13696 BOOL ret;
13697
13698 mi.cbSize = sizeof(mi);
13699 mi.fMask = MIM_STYLE;
13700 mi.dwStyle = style;
13701 SetLastError(0xdeadbeef);
13702 ret = pSetMenuInfo(hmenu, &mi);
13703 ok(ret, "SetMenuInfo error %u\n", GetLastError());
13704 }
13705
13706 static DWORD get_menu_style(HMENU hmenu)
13707 {
13708 MENUINFO mi;
13709 BOOL ret;
13710
13711 mi.cbSize = sizeof(mi);
13712 mi.fMask = MIM_STYLE;
13713 mi.dwStyle = 0;
13714 SetLastError(0xdeadbeef);
13715 ret = pGetMenuInfo(hmenu, &mi);
13716 ok(ret, "GetMenuInfo error %u\n", GetLastError());
13717
13718 return mi.dwStyle;
13719 }
13720
13721 static void test_menu_messages(void)
13722 {
13723 MSG msg;
13724 WNDCLASSA cls;
13725 HMENU hmenu, hmenu_popup;
13726 HWND hwnd;
13727 DWORD style;
13728
13729 if (!pGetMenuInfo || !pSetMenuInfo)
13730 {
13731 win_skip("GetMenuInfo and/or SetMenuInfo are not available\n");
13732 return;
13733 }
13734 cls.style = 0;
13735 cls.lpfnWndProc = parent_menu_proc;
13736 cls.cbClsExtra = 0;
13737 cls.cbWndExtra = 0;
13738 cls.hInstance = GetModuleHandleA(0);
13739 cls.hIcon = 0;
13740 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
13741 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
13742 cls.lpszMenuName = NULL;
13743 cls.lpszClassName = "TestMenuClass";
13744 UnregisterClassA(cls.lpszClassName, cls.hInstance);
13745 if (!RegisterClassA(&cls)) assert(0);
13746
13747 SetLastError(0xdeadbeef);
13748 hwnd = CreateWindowExA(0, "TestMenuClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
13749 100, 100, 200, 200, 0, 0, 0, NULL);
13750 ok(hwnd != 0, "LoadMenuA error %u\n", GetLastError());
13751
13752 SetLastError(0xdeadbeef);
13753 hmenu = LoadMenuA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(1));
13754 ok(hmenu != 0, "LoadMenuA error %u\n", GetLastError());
13755
13756 SetMenu(hwnd, hmenu);
13757 SetForegroundWindow( hwnd );
13758 flush_events();
13759
13760 set_menu_style(hmenu, MNS_NOTIFYBYPOS);
13761 style = get_menu_style(hmenu);
13762 ok(style == MNS_NOTIFYBYPOS, "expected MNS_NOTIFYBYPOS, got %u\n", style);
13763
13764 hmenu_popup = GetSubMenu(hmenu, 0);
13765 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
13766 style = get_menu_style(hmenu_popup);
13767 ok(style == 0, "expected 0, got %u\n", style);
13768
13769 hmenu_popup = GetSubMenu(hmenu_popup, 0);
13770 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
13771 style = get_menu_style(hmenu_popup);
13772 ok(style == 0, "expected 0, got %u\n", style);
13773
13774 /* Alt+E, Enter */
13775 trace("testing a popup menu command\n");
13776 flush_sequence();
13777 keybd_event(VK_MENU, 0, 0, 0);
13778 keybd_event('E', 0, 0, 0);
13779 keybd_event('E', 0, KEYEVENTF_KEYUP, 0);
13780 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
13781 keybd_event(VK_RETURN, 0, 0, 0);
13782 keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
13783 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
13784 {
13785 TranslateMessage(&msg);
13786 DispatchMessageA(&msg);
13787 }
13788 if (!sequence_cnt) /* we didn't get any message */
13789 {
13790 skip( "queuing key events not supported\n" );
13791 goto done;
13792 }
13793 /* win98 queues only a WM_KEYUP and doesn't start menu tracking */
13794 if (sequence[0].message == WM_KEYUP && sequence[0].wParam == VK_MENU)
13795 {
13796 win_skip( "menu tracking through VK_MENU not supported\n" );
13797 goto done;
13798 }
13799 ok_sequence(wm_popup_menu_1, "popup menu command", FALSE);
13800
13801 /* Alt+F, Right, Enter */
13802 trace("testing submenu of a popup menu command\n");
13803 flush_sequence();
13804 keybd_event(VK_MENU, 0, 0, 0);
13805 keybd_event('F', 0, 0, 0);
13806 keybd_event('F', 0, KEYEVENTF_KEYUP, 0);
13807 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
13808 keybd_event(VK_RIGHT, 0, 0, 0);
13809 keybd_event(VK_RIGHT, 0, KEYEVENTF_KEYUP, 0);
13810 keybd_event(VK_RETURN, 0, 0, 0);
13811 keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
13812 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
13813 {
13814 TranslateMessage(&msg);
13815 DispatchMessageA(&msg);
13816 }
13817 ok_sequence(wm_popup_menu_2, "submenu of a popup menu command", FALSE);
13818
13819 trace("testing single menu item command\n");
13820 flush_sequence();
13821 keybd_event(VK_MENU, 0, 0, 0);
13822 keybd_event('Q', 0, 0, 0);
13823 keybd_event('Q', 0, KEYEVENTF_KEYUP, 0);
13824 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
13825 keybd_event(VK_ESCAPE, 0, 0, 0);
13826 keybd_event(VK_ESCAPE, 0, KEYEVENTF_KEYUP, 0);
13827 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
13828 {
13829 TranslateMessage(&msg);
13830 DispatchMessageA(&msg);
13831 }
13832 ok_sequence(wm_single_menu_item, "single menu item command", FALSE);
13833
13834 set_menu_style(hmenu, 0);
13835 style = get_menu_style(hmenu);
13836 ok(style == 0, "expected 0, got %u\n", style);
13837
13838 hmenu_popup = GetSubMenu(hmenu, 0);
13839 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
13840 set_menu_style(hmenu_popup, MNS_NOTIFYBYPOS);
13841 style = get_menu_style(hmenu_popup);
13842 ok(style == MNS_NOTIFYBYPOS, "expected MNS_NOTIFYBYPOS, got %u\n", style);
13843
13844 hmenu_popup = GetSubMenu(hmenu_popup, 0);
13845 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
13846 style = get_menu_style(hmenu_popup);
13847 ok(style == 0, "expected 0, got %u\n", style);
13848
13849 /* Alt+F, Right, Enter */
13850 trace("testing submenu of a popup menu command\n");
13851 flush_sequence();
13852 keybd_event(VK_MENU, 0, 0, 0);
13853 keybd_event('F', 0, 0, 0);
13854 keybd_event('F', 0, KEYEVENTF_KEYUP, 0);
13855 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
13856 keybd_event(VK_RIGHT, 0, 0, 0);
13857 keybd_event(VK_RIGHT, 0, KEYEVENTF_KEYUP, 0);
13858 keybd_event(VK_RETURN, 0, 0, 0);
13859 keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
13860 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
13861 {
13862 TranslateMessage(&msg);
13863 DispatchMessageA(&msg);
13864 }
13865 ok_sequence(wm_popup_menu_3, "submenu of a popup menu command", FALSE);
13866
13867 done:
13868 DestroyWindow(hwnd);
13869 DestroyMenu(hmenu);
13870 }
13871
13872
13873 static void test_paintingloop(void)
13874 {
13875 HWND hwnd;
13876
13877 paint_loop_done = FALSE;
13878 hwnd = CreateWindowExA(0x0,"PaintLoopWindowClass",
13879 "PaintLoopWindowClass",WS_OVERLAPPEDWINDOW,
13880 100, 100, 100, 100, 0, 0, 0, NULL );
13881 ok(hwnd != 0, "PaintLoop window error %u\n", GetLastError());
13882 ShowWindow(hwnd,SW_NORMAL);
13883 SetFocus(hwnd);
13884
13885 while (!paint_loop_done)
13886 {
13887 MSG msg;
13888 if (PeekMessageA(&msg, 0, 0, 0, 1))
13889 {
13890 TranslateMessage(&msg);
13891 DispatchMessageA(&msg);
13892 }
13893 }
13894 DestroyWindow(hwnd);
13895 }
13896
13897 static void test_defwinproc(void)
13898 {
13899 HWND hwnd;
13900 MSG msg;
13901 BOOL gotwmquit = FALSE;
13902 hwnd = CreateWindowExA(0, "static", "test_defwndproc", WS_POPUP, 0,0,0,0,0,0,0, NULL);
13903 assert(hwnd);
13904 DefWindowProcA( hwnd, WM_ENDSESSION, 1, 0);
13905 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) {
13906 if( msg.message == WM_QUIT) gotwmquit = TRUE;
13907 DispatchMessageA( &msg );
13908 }
13909 ok(!gotwmquit, "Unexpected WM_QUIT message!\n");
13910 DestroyWindow( hwnd);
13911 }
13912
13913 #define clear_clipboard(hwnd) clear_clipboard_(__LINE__, (hwnd))
13914 static void clear_clipboard_(int line, HWND hWnd)
13915 {
13916 BOOL succ;
13917 succ = OpenClipboard(hWnd);
13918 ok_(__FILE__, line)(succ, "OpenClipboard failed, err=%u\n", GetLastError());
13919 succ = EmptyClipboard();
13920 ok_(__FILE__, line)(succ, "EmptyClipboard failed, err=%u\n", GetLastError());
13921 succ = CloseClipboard();
13922 ok_(__FILE__, line)(succ, "CloseClipboard failed, err=%u\n", GetLastError());
13923 }
13924
13925 #define expect_HWND(expected, got) expect_HWND_(__LINE__, (expected), (got))
13926 static void expect_HWND_(int line, HWND expected, HWND got)
13927 {
13928 ok_(__FILE__, line)(got==expected, "Expected %p, got %p\n", expected, got);
13929 }
13930
13931 static WNDPROC pOldViewerProc;
13932
13933 static LRESULT CALLBACK recursive_viewer_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
13934 {
13935 static BOOL recursion_guard;
13936
13937 if (message == WM_DRAWCLIPBOARD && !recursion_guard)
13938 {
13939 recursion_guard = TRUE;
13940 clear_clipboard(hWnd);
13941 recursion_guard = FALSE;
13942 }
13943 return CallWindowProcA(pOldViewerProc, hWnd, message, wParam, lParam);
13944 }
13945
13946 static void test_clipboard_viewers(void)
13947 {
13948 static struct message wm_change_cb_chain[] =
13949 {
13950 { WM_CHANGECBCHAIN, sent|wparam|lparam, 0, 0 },
13951 { 0 }
13952 };
13953 static const struct message wm_clipboard_destroyed[] =
13954 {
13955 { WM_DESTROYCLIPBOARD, sent|wparam|lparam, 0, 0 },
13956 { 0 }
13957 };
13958 static struct message wm_clipboard_changed[] =
13959 {
13960 { WM_DRAWCLIPBOARD, sent|wparam|lparam, 0, 0 },
13961 { 0 }
13962 };
13963 static struct message wm_clipboard_changed_and_owned[] =
13964 {
13965 { WM_DESTROYCLIPBOARD, sent|wparam|lparam, 0, 0 },
13966 { WM_DRAWCLIPBOARD, sent|wparam|lparam, 0, 0 },
13967 { 0 }
13968 };
13969
13970 HINSTANCE hInst = GetModuleHandleA(NULL);
13971 HWND hWnd1, hWnd2, hWnd3;
13972 HWND hOrigViewer;
13973 HWND hRet;
13974
13975 hWnd1 = CreateWindowExA(0, "TestWindowClass", "Clipboard viewer test wnd 1",
13976 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX,
13977 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
13978 GetDesktopWindow(), NULL, hInst, NULL);
13979 hWnd2 = CreateWindowExA(0, "SimpleWindowClass", "Clipboard viewer test wnd 2",
13980 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX,
13981 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
13982 GetDesktopWindow(), NULL, hInst, NULL);
13983 hWnd3 = CreateWindowExA(0, "SimpleWindowClass", "Clipboard viewer test wnd 3",
13984 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX,
13985 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
13986 GetDesktopWindow(), NULL, hInst, NULL);
13987 trace("clipbd viewers: hWnd1=%p, hWnd2=%p, hWnd3=%p\n", hWnd1, hWnd2, hWnd3);
13988 assert(hWnd1 && hWnd2 && hWnd3);
13989
13990 flush_sequence();
13991
13992 /* Test getting the clipboard viewer and setting the viewer to NULL. */
13993 hOrigViewer = GetClipboardViewer();
13994 hRet = SetClipboardViewer(NULL);
13995 ok_sequence(WmEmptySeq, "set viewer to NULL", FALSE);
13996 expect_HWND(hOrigViewer, hRet);
13997 expect_HWND(NULL, GetClipboardViewer());
13998
13999 /* Test registering hWnd1 as a viewer. */
14000 hRet = SetClipboardViewer(hWnd1);
14001 wm_clipboard_changed[0].wParam = (WPARAM) GetClipboardOwner();
14002 ok_sequence(wm_clipboard_changed, "set viewer NULL->1", FALSE);
14003 expect_HWND(NULL, hRet);
14004 expect_HWND(hWnd1, GetClipboardViewer());
14005
14006 /* Test that changing the clipboard actually refreshes the registered viewer. */
14007 clear_clipboard(hWnd1);
14008 wm_clipboard_changed[0].wParam = (WPARAM) GetClipboardOwner();
14009 ok_sequence(wm_clipboard_changed, "clear clipbd (viewer=owner=1)", FALSE);
14010
14011 /* Again, but with different owner. */
14012 clear_clipboard(hWnd2);
14013 wm_clipboard_changed_and_owned[1].wParam = (WPARAM) GetClipboardOwner();
14014 ok_sequence(wm_clipboard_changed_and_owned, "clear clipbd (viewer=1, owner=2)", FALSE);
14015
14016 /* Test re-registering same window. */
14017 hRet = SetClipboardViewer(hWnd1);
14018 wm_clipboard_changed[0].wParam = (WPARAM) GetClipboardOwner();
14019 ok_sequence(wm_clipboard_changed, "set viewer 1->1", FALSE);
14020 expect_HWND(hWnd1, hRet);
14021 expect_HWND(hWnd1, GetClipboardViewer());
14022
14023 /* Test ChangeClipboardChain. */
14024 ChangeClipboardChain(hWnd2, hWnd3);
14025 wm_change_cb_chain[0].wParam = (WPARAM) hWnd2;
14026 wm_change_cb_chain[0].lParam = (LPARAM) hWnd3;
14027 ok_sequence(wm_change_cb_chain, "change chain (viewer=1, remove=2, next=3)", FALSE);
14028 expect_HWND(hWnd1, GetClipboardViewer());
14029
14030 ChangeClipboardChain(hWnd2, NULL);
14031 wm_change_cb_chain[0].wParam = (WPARAM) hWnd2;
14032 wm_change_cb_chain[0].lParam = 0;
14033 ok_sequence(wm_change_cb_chain, "change chain (viewer=1, remove=2, next=NULL)", FALSE);
14034 expect_HWND(hWnd1, GetClipboardViewer());
14035
14036 ChangeClipboardChain(NULL, hWnd2);
14037 ok_sequence(WmEmptySeq, "change chain (viewer=1, remove=NULL, next=2)", TRUE);
14038 expect_HWND(hWnd1, GetClipboardViewer());
14039
14040 /* Actually change clipboard viewer with ChangeClipboardChain. */
14041 ChangeClipboardChain(hWnd1, hWnd2);
14042 ok_sequence(WmEmptySeq, "change chain (viewer=remove=1, next=2)", FALSE);
14043 expect_HWND(hWnd2, GetClipboardViewer());
14044
14045 /* Test that no refresh messages are sent when viewer has unregistered. */
14046 clear_clipboard(hWnd2);
14047 ok_sequence(WmEmptySeq, "clear clipd (viewer=2, owner=1)", FALSE);
14048
14049 /* Register hWnd1 again. */
14050 ChangeClipboardChain(hWnd2, hWnd1);
14051 ok_sequence(WmEmptySeq, "change chain (viewer=remove=2, next=1)", FALSE);
14052 expect_HWND(hWnd1, GetClipboardViewer());
14053
14054 /* Subclass hWnd1 so that when it receives a WM_DRAWCLIPBOARD message, it
14055 * changes the clipboard. When this happens, the system shouldn't send
14056 * another WM_DRAWCLIPBOARD (as this could cause an infinite loop).
14057 */
14058 pOldViewerProc = (WNDPROC) SetWindowLongPtrA(hWnd1, GWLP_WNDPROC, (LONG_PTR) recursive_viewer_proc);
14059 clear_clipboard(hWnd2);
14060 /* The clipboard owner is changed in recursive_viewer_proc: */
14061 wm_clipboard_changed[0].wParam = (WPARAM) hWnd2;
14062 ok_sequence(wm_clipboard_changed, "recursive clear clipbd (viewer=1, owner=2)", TRUE);
14063
14064 /* Test unregistering. */
14065 ChangeClipboardChain(hWnd1, NULL);
14066 ok_sequence(WmEmptySeq, "change chain (viewer=remove=1, next=NULL)", FALSE);
14067 expect_HWND(NULL, GetClipboardViewer());
14068
14069 clear_clipboard(hWnd1);
14070 ok_sequence(wm_clipboard_destroyed, "clear clipbd (no viewer, owner=1)", FALSE);
14071
14072 DestroyWindow(hWnd1);
14073 DestroyWindow(hWnd2);
14074 DestroyWindow(hWnd3);
14075 SetClipboardViewer(hOrigViewer);
14076 }
14077
14078 static void test_PostMessage(void)
14079 {
14080 static const struct
14081 {
14082 HWND hwnd;
14083 BOOL ret;
14084 } data[] =
14085 {
14086 { HWND_TOP /* 0 */, TRUE },
14087 { HWND_BROADCAST, TRUE },
14088 { HWND_BOTTOM, TRUE },
14089 { HWND_TOPMOST, TRUE },
14090 { HWND_NOTOPMOST, FALSE },
14091 { HWND_MESSAGE, FALSE },
14092 { (HWND)0xdeadbeef, FALSE }
14093 };
14094 int i;
14095 HWND hwnd;
14096 BOOL ret;
14097 MSG msg;
14098 static const WCHAR staticW[] = {'s','t','a','t','i','c',0};
14099
14100 SetLastError(0xdeadbeef);
14101 hwnd = CreateWindowExW(0, staticW, NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
14102 if (!hwnd && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
14103 {
14104 win_skip("Skipping some PostMessage tests on Win9x/WinMe\n");
14105 return;
14106 }
14107 assert(hwnd);
14108
14109 flush_events();
14110
14111 PostMessageA(hwnd, WM_USER+1, 0x1234, 0x5678);
14112 PostMessageA(0, WM_USER+2, 0x5678, 0x1234);
14113
14114 for (i = 0; i < sizeof(data)/sizeof(data[0]); i++)
14115 {
14116 memset(&msg, 0xab, sizeof(msg));
14117 ret = PeekMessageA(&msg, data[i].hwnd, 0, 0, PM_NOREMOVE);
14118 ok(ret == data[i].ret, "%d: hwnd %p expected %d, got %d\n", i, data[i].hwnd, data[i].ret, ret);
14119 if (data[i].ret)
14120 {
14121 if (data[i].hwnd)
14122 ok(ret && msg.hwnd == 0 && msg.message == WM_USER+2 &&
14123 msg.wParam == 0x5678 && msg.lParam == 0x1234,
14124 "%d: got ret %d hwnd %p msg %04x wParam %08lx lParam %08lx instead of TRUE/0/WM_USER+2/0x5678/0x1234\n",
14125 i, ret, msg.hwnd, msg.message, msg.wParam, msg.lParam);
14126 else
14127 ok(ret && msg.hwnd == hwnd && msg.message == WM_USER+1 &&
14128 msg.wParam == 0x1234 && msg.lParam == 0x5678,
14129 "%d: got ret %d hwnd %p msg %04x wParam %08lx lParam %08lx instead of TRUE/%p/WM_USER+1/0x1234/0x5678\n",
14130 i, ret, msg.hwnd, msg.message, msg.wParam, msg.lParam, msg.hwnd);
14131 }
14132 }
14133
14134 DestroyWindow(hwnd);
14135 flush_events();
14136 }
14137
14138 static LPARAM g_broadcast_lparam;
14139 static LRESULT WINAPI broadcast_test_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
14140 {
14141 WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
14142
14143 if (wParam == 0xbaadbeef)
14144 g_broadcast_lparam = wParam;
14145 else
14146 g_broadcast_lparam = 0;
14147
14148 return CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
14149 }
14150
14151 static void test_broadcast(void)
14152 {
14153 static const UINT messages[] =
14154 {
14155 WM_USER-1,
14156 WM_USER,
14157 WM_USER+1,
14158 0xc000-1,
14159 0xc000, /* lowest possible atom returned by RegisterWindowMessage */
14160 0xffff,
14161 };
14162 WNDPROC oldproc;
14163 unsigned int i;
14164 HWND hwnd;
14165
14166 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0, 0, 0, 0, 0, 0, 0, NULL);
14167 ok(hwnd != NULL, "got %p\n", hwnd);
14168
14169 oldproc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)broadcast_test_proc);
14170 SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)oldproc);
14171
14172 for (i = 0; i < sizeof(messages)/sizeof(messages[0]); i++)
14173 {
14174 BOOL ret;
14175 MSG msg;
14176
14177 flush_events();
14178 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
14179 ;
14180
14181 /* post, broadcast */
14182 ret = PostMessageA(HWND_BROADCAST, messages[i], 0, 0);
14183 ok(ret, "%d: got %d, error %d\n", i, ret, GetLastError());
14184
14185 memset(&msg, 0xab, sizeof(msg));
14186 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
14187 if (messages[i] < WM_USER || messages[i] >= 0xc000)
14188 {
14189 ok(ret, "%d: message %04x, got %d, error %d\n", i, messages[i], ret, GetLastError());
14190 ok(msg.hwnd == hwnd, "%d: got %p\n", i, msg.hwnd);
14191 }
14192 else
14193 {
14194 ok(!ret, "%d: message %04x, got %d, error %d\n", i, messages[i], ret, GetLastError());
14195 }
14196
14197 /* post, topmost */
14198 ret = PostMessageA(HWND_TOPMOST, messages[i], 0, 0);
14199 ok(ret, "%d: got %d, error %d\n", i, ret, GetLastError());
14200
14201 memset(&msg, 0xab, sizeof(msg));
14202 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
14203 if (messages[i] < WM_USER || messages[i] >= 0xc000)
14204 {
14205 ok(ret, "%d: message %04x, got %d, error %d\n", i, messages[i], ret, GetLastError());
14206 ok(msg.hwnd == hwnd, "%d: got %p\n", i, msg.hwnd);
14207 }
14208 else
14209 {
14210 ok(!ret, "%d: got %d, error %d\n", i, ret, GetLastError());
14211 }
14212
14213 /* send, broadcast */
14214 g_broadcast_lparam = 0xdead;
14215 ret = SendMessageTimeoutA(HWND_BROADCAST, messages[i], 0xbaadbeef, 0, SMTO_NORMAL, 2000, NULL);
14216 if (!ret && GetLastError() == ERROR_TIMEOUT)
14217 win_skip("broadcasting test %d, timeout\n", i);
14218 else
14219 {
14220 if (messages[i] < WM_USER || messages[i] >= 0xc000)
14221 {
14222 ok(g_broadcast_lparam == 0xbaadbeef, "%d: message %04x, got %#lx, error %d\n", i, messages[i],
14223 g_broadcast_lparam, GetLastError());
14224 }
14225 else
14226 {
14227 ok(g_broadcast_lparam == 0xdead, "%d: message %04x, got %#lx, error %d\n", i, messages[i],
14228 g_broadcast_lparam, GetLastError());
14229 }
14230 }
14231
14232 /* send, topmost */
14233 g_broadcast_lparam = 0xdead;
14234 ret = SendMessageTimeoutA(HWND_TOPMOST, messages[i], 0xbaadbeef, 0, SMTO_NORMAL, 2000, NULL);
14235 if (!ret && GetLastError() == ERROR_TIMEOUT)
14236 win_skip("broadcasting test %d, timeout\n", i);
14237 else
14238 {
14239 if (messages[i] < WM_USER || messages[i] >= 0xc000)
14240 {
14241 ok(g_broadcast_lparam == 0xbaadbeef, "%d: message %04x, got %#lx, error %d\n", i, messages[i],
14242 g_broadcast_lparam, GetLastError());
14243 }
14244 else
14245 {
14246 ok(g_broadcast_lparam == 0xdead, "%d: message %04x, got %#lx, error %d\n", i, messages[i],
14247 g_broadcast_lparam, GetLastError());
14248 }
14249 }
14250 }
14251
14252 DestroyWindow(hwnd);
14253 }
14254
14255 static const struct
14256 {
14257 DWORD exp, broken;
14258 BOOL todo;
14259 } wait_idle_expect[] =
14260 {
14261 /* 0 */ { WAIT_TIMEOUT, WAIT_TIMEOUT, FALSE },
14262 { WAIT_TIMEOUT, 0, FALSE },
14263 { WAIT_TIMEOUT, 0, FALSE },
14264 { WAIT_TIMEOUT, WAIT_TIMEOUT, FALSE },
14265 { WAIT_TIMEOUT, WAIT_TIMEOUT, FALSE },
14266 /* 5 */ { WAIT_TIMEOUT, 0, FALSE },
14267 { WAIT_TIMEOUT, 0, FALSE },
14268 { WAIT_TIMEOUT, WAIT_TIMEOUT, FALSE },
14269 { 0, 0, FALSE },
14270 { 0, 0, FALSE },
14271 /* 10 */ { 0, 0, FALSE },
14272 { 0, 0, FALSE },
14273 { 0, WAIT_TIMEOUT, FALSE },
14274 { 0, 0, FALSE },
14275 { 0, 0, FALSE },
14276 /* 15 */ { 0, 0, FALSE },
14277 { WAIT_TIMEOUT, 0, FALSE },
14278 { WAIT_TIMEOUT, 0, FALSE },
14279 { WAIT_TIMEOUT, 0, FALSE },
14280 { WAIT_TIMEOUT, 0, FALSE },
14281 /* 20 */ { WAIT_TIMEOUT, 0, FALSE },
14282 };
14283
14284 static DWORD CALLBACK do_wait_idle_child_thread( void *arg )
14285 {
14286 MSG msg;
14287
14288 PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
14289 Sleep( 200 );
14290 MsgWaitForMultipleObjects( 0, NULL, FALSE, 100, QS_ALLINPUT );
14291 return 0;
14292 }
14293
14294 static void do_wait_idle_child( int arg )
14295 {
14296 WNDCLASSA cls;
14297 MSG msg;
14298 HWND hwnd = 0;
14299 HANDLE thread;
14300 DWORD id;
14301 HANDLE start_event = OpenEventA( EVENT_ALL_ACCESS, FALSE, "test_WaitForInputIdle_start" );
14302 HANDLE end_event = OpenEventA( EVENT_ALL_ACCESS, FALSE, "test_WaitForInputIdle_end" );
14303
14304 memset( &cls, 0, sizeof(cls) );
14305 cls.lpfnWndProc = DefWindowProcA;
14306 cls.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
14307 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
14308 cls.lpszClassName = "TestClass";
14309 RegisterClassA( &cls );
14310
14311 PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ); /* create the msg queue */
14312
14313 ok( start_event != 0, "failed to create start event, error %u\n", GetLastError() );
14314 ok( end_event != 0, "failed to create end event, error %u\n", GetLastError() );
14315
14316 switch (arg)
14317 {
14318 case 0:
14319 SetEvent( start_event );
14320 break;
14321 case 1:
14322 SetEvent( start_event );
14323 Sleep( 200 );
14324 PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
14325 break;
14326 case 2:
14327 SetEvent( start_event );
14328 Sleep( 200 );
14329 PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
14330 PostThreadMessageA( GetCurrentThreadId(), WM_COMMAND, 0x1234, 0xabcd );
14331 PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
14332 break;
14333 case 3:
14334 SetEvent( start_event );
14335 Sleep( 200 );
14336 SendMessageA( HWND_BROADCAST, WM_WININICHANGE, 0, 0 );
14337 break;
14338 case 4:
14339 SetEvent( start_event );
14340 Sleep( 200 );
14341 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
14342 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE|PM_NOYIELD )) DispatchMessageA( &msg );
14343 break;
14344 case 5:
14345 SetEvent( start_event );
14346 Sleep( 200 );
14347 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
14348 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
14349 break;
14350 case 6:
14351 SetEvent( start_event );
14352 Sleep( 200 );
14353 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
14354 while (PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ))
14355 {
14356 GetMessageA( &msg, 0, 0, 0 );
14357 DispatchMessageA( &msg );
14358 }
14359 break;
14360 case 7:
14361 SetEvent( start_event );
14362 Sleep( 200 );
14363 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
14364 SetTimer( hwnd, 3, 1, NULL );
14365 Sleep( 200 );
14366 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE|PM_NOYIELD )) DispatchMessageA( &msg );
14367 break;
14368 case 8:
14369 SetEvent( start_event );
14370 Sleep( 200 );
14371 PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
14372 MsgWaitForMultipleObjects( 0, NULL, FALSE, 100, QS_ALLINPUT );
14373 break;
14374 case 9:
14375 SetEvent( start_event );
14376 Sleep( 200 );
14377 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
14378 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
14379 for (;;) GetMessageA( &msg, 0, 0, 0 );
14380 break;
14381 case 10:
14382 SetEvent( start_event );
14383 Sleep( 200 );
14384 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
14385 SetTimer( hwnd, 3, 1, NULL );
14386 Sleep( 200 );
14387 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
14388 break;
14389 case 11:
14390 SetEvent( start_event );
14391 Sleep( 200 );
14392 return; /* exiting the process makes WaitForInputIdle return success too */
14393 case 12:
14394 PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
14395 Sleep( 200 );
14396 MsgWaitForMultipleObjects( 0, NULL, FALSE, 100, QS_ALLINPUT );
14397 SetEvent( start_event );
14398 break;
14399 case 13:
14400 SetEvent( start_event );
14401 PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
14402 Sleep( 200 );
14403 thread = CreateThread( NULL, 0, do_wait_idle_child_thread, NULL, 0, &id );
14404 WaitForSingleObject( thread, 10000 );
14405 CloseHandle( thread );
14406 break;
14407 case 14:
14408 SetEvent( start_event );
14409 Sleep( 200 );
14410 PeekMessageA( &msg, HWND_TOPMOST, 0, 0, PM_NOREMOVE );
14411 break;
14412 case 15:
14413 SetEvent( start_event );
14414 Sleep( 200 );
14415 PeekMessageA( &msg, HWND_BROADCAST, 0, 0, PM_NOREMOVE );
14416 break;
14417 case 16:
14418 SetEvent( start_event );
14419 Sleep( 200 );
14420 PeekMessageA( &msg, HWND_BOTTOM, 0, 0, PM_NOREMOVE );
14421 break;
14422 case 17:
14423 SetEvent( start_event );
14424 Sleep( 200 );
14425 PeekMessageA( &msg, (HWND)0xdeadbeef, 0, 0, PM_NOREMOVE );
14426 break;
14427 case 18:
14428 SetEvent( start_event );
14429 Sleep( 200 );
14430 PeekMessageA( &msg, HWND_NOTOPMOST, 0, 0, PM_NOREMOVE );
14431 break;
14432 case 19:
14433 SetEvent( start_event );
14434 Sleep( 200 );
14435 PeekMessageA( &msg, HWND_MESSAGE, 0, 0, PM_NOREMOVE );
14436 break;
14437 case 20:
14438 SetEvent( start_event );
14439 Sleep( 200 );
14440 PeekMessageA( &msg, GetDesktopWindow(), 0, 0, PM_NOREMOVE );
14441 break;
14442 }
14443 WaitForSingleObject( end_event, 2000 );
14444 CloseHandle( start_event );
14445 CloseHandle( end_event );
14446 if (hwnd) DestroyWindow( hwnd );
14447 }
14448
14449 static LRESULT CALLBACK wait_idle_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
14450 {
14451 if (msg == WM_WININICHANGE) Sleep( 200 ); /* make sure the child waits */
14452 return DefWindowProcA( hwnd, msg, wp, lp );
14453 }
14454
14455 static DWORD CALLBACK wait_idle_thread( void *arg )
14456 {
14457 WNDCLASSA cls;
14458 MSG msg;
14459 HWND hwnd;
14460
14461 memset( &cls, 0, sizeof(cls) );
14462 cls.lpfnWndProc = wait_idle_proc;
14463 cls.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
14464 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
14465 cls.lpszClassName = "TestClass";
14466 RegisterClassA( &cls );
14467
14468 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP, 0, 0, 10, 10, 0, 0, 0, NULL);
14469 while (GetMessageA( &msg, 0, 0, 0 )) DispatchMessageA( &msg );
14470 DestroyWindow(hwnd);
14471 return 0;
14472 }
14473
14474 static void test_WaitForInputIdle( char *argv0 )
14475 {
14476 char path[MAX_PATH];
14477 PROCESS_INFORMATION pi;
14478 STARTUPINFOA startup;
14479 BOOL ret;
14480 HANDLE start_event, end_event, thread;
14481 unsigned int i;
14482 DWORD id;
14483 const IMAGE_DOS_HEADER *dos = (const IMAGE_DOS_HEADER *)GetModuleHandleA(0);
14484 const IMAGE_NT_HEADERS *nt = (const IMAGE_NT_HEADERS *)((const char *)dos + dos->e_lfanew);
14485 BOOL console_app = (nt->OptionalHeader.Subsystem != IMAGE_SUBSYSTEM_WINDOWS_GUI);
14486
14487 if (console_app) /* build the test with -mwindows for better coverage */
14488 trace( "not built as a GUI app, WaitForInputIdle may not be fully tested\n" );
14489
14490 start_event = CreateEventA(NULL, 0, 0, "test_WaitForInputIdle_start");
14491 end_event = CreateEventA(NULL, 0, 0, "test_WaitForInputIdle_end");
14492 ok(start_event != 0, "failed to create start event, error %u\n", GetLastError());
14493 ok(end_event != 0, "failed to create end event, error %u\n", GetLastError());
14494
14495 memset( &startup, 0, sizeof(startup) );
14496 startup.cb = sizeof(startup);
14497 startup.dwFlags = STARTF_USESHOWWINDOW;
14498 startup.wShowWindow = SW_SHOWNORMAL;
14499
14500 thread = CreateThread( NULL, 0, wait_idle_thread, NULL, 0, &id );
14501
14502 for (i = 0; i < sizeof(wait_idle_expect)/sizeof(wait_idle_expect[0]); i++)
14503 {
14504 ResetEvent( start_event );
14505 ResetEvent( end_event );
14506 sprintf( path, "%s msg %u", argv0, i );
14507 ret = CreateProcessA( NULL, path, NULL, NULL, TRUE, 0, NULL, NULL, &startup, &pi );
14508 ok( ret, "CreateProcess '%s' failed err %u.\n", path, GetLastError() );
14509 if (ret)
14510 {
14511 ret = WaitForSingleObject( start_event, 5000 );
14512 ok( ret == WAIT_OBJECT_0, "%u: WaitForSingleObject failed\n", i );
14513 if (ret == WAIT_OBJECT_0)
14514 {
14515 ret = WaitForInputIdle( pi.hProcess, 1000 );
14516 if (ret == WAIT_FAILED)
14517 ok( console_app ||
14518 ret == wait_idle_expect[i].exp ||
14519 broken(ret == wait_idle_expect[i].broken),
14520 "%u: WaitForInputIdle error %08x expected %08x\n",
14521 i, ret, wait_idle_expect[i].exp );
14522 else todo_wine_if (wait_idle_expect[i].todo)
14523 ok( ret == wait_idle_expect[i].exp || broken(ret == wait_idle_expect[i].broken),
14524 "%u: WaitForInputIdle error %08x expected %08x\n",
14525 i, ret, wait_idle_expect[i].exp );
14526 SetEvent( end_event );
14527 WaitForSingleObject( pi.hProcess, 1000 ); /* give it a chance to exit on its own */
14528 }
14529 TerminateProcess( pi.hProcess, 0 ); /* just in case */
14530 winetest_wait_child_process( pi.hProcess );
14531 ret = WaitForInputIdle( pi.hProcess, 100 );
14532 ok( ret == WAIT_FAILED, "%u: WaitForInputIdle after exit error %08x\n", i, ret );
14533 CloseHandle( pi.hProcess );
14534 CloseHandle( pi.hThread );
14535 }
14536 }
14537 CloseHandle( start_event );
14538 PostThreadMessageA( id, WM_QUIT, 0, 0 );
14539 WaitForSingleObject( thread, 10000 );
14540 CloseHandle( thread );
14541 }
14542
14543 static const struct message WmSetParentSeq_1[] = {
14544 { WM_SHOWWINDOW, sent|wparam, 0 },
14545 { EVENT_OBJECT_PARENTCHANGE, winevent_hook|wparam|lparam, 0, 0 },
14546 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE },
14547 { WM_CHILDACTIVATE, sent },
14548 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOREDRAW|SWP_NOCLIENTSIZE },
14549 { WM_MOVE, sent|defwinproc|wparam, 0 },
14550 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
14551 { WM_SHOWWINDOW, sent|wparam, 1 },
14552 { 0 }
14553 };
14554
14555 static const struct message WmSetParentSeq_2[] = {
14556 { WM_SHOWWINDOW, sent|wparam, 0 },
14557 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
14558 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
14559 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
14560 { HCBT_SETFOCUS, hook|optional },
14561 { WM_NCACTIVATE, sent|wparam|optional, 0 },
14562 { WM_ACTIVATE, sent|wparam|optional, 0 },
14563 { WM_ACTIVATEAPP, sent|wparam|optional, 0 },
14564 { WM_KILLFOCUS, sent|wparam, 0 },
14565 { EVENT_OBJECT_PARENTCHANGE, winevent_hook|wparam|lparam, 0, 0 },
14566 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE },
14567 { HCBT_ACTIVATE, hook|optional },
14568 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
14569 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
14570 { WM_NCACTIVATE, sent|wparam|optional, 1 },
14571 { WM_ACTIVATE, sent|wparam|optional, 1 },
14572 { HCBT_SETFOCUS, hook|optional },
14573 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
14574 { WM_SETFOCUS, sent|optional|defwinproc },
14575 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOREDRAW|SWP_NOSIZE|SWP_NOCLIENTSIZE },
14576 { WM_MOVE, sent|defwinproc|wparam, 0 },
14577 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
14578 { WM_SHOWWINDOW, sent|wparam, 1 },
14579 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
14580 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
14581 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
14582 { 0 }
14583 };
14584
14585
14586 static void test_SetParent(void)
14587 {
14588 HWND parent1, parent2, child, popup;
14589 RECT rc, rc_old;
14590
14591 parent1 = CreateWindowExA(0, "TestParentClass", NULL, WS_OVERLAPPEDWINDOW,
14592 100, 100, 200, 200, 0, 0, 0, NULL);
14593 ok(parent1 != 0, "Failed to create parent1 window\n");
14594
14595 parent2 = CreateWindowExA(0, "TestParentClass", NULL, WS_OVERLAPPEDWINDOW,
14596 400, 100, 200, 200, 0, 0, 0, NULL);
14597 ok(parent2 != 0, "Failed to create parent2 window\n");
14598
14599 /* WS_CHILD window */
14600 child = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD | WS_VISIBLE,
14601 10, 10, 150, 150, parent1, 0, 0, NULL);
14602 ok(child != 0, "Failed to create child window\n");
14603
14604 GetWindowRect(parent1, &rc);
14605 trace("parent1 (%d,%d)-(%d,%d)\n", rc.left, rc.top, rc.right, rc.bottom);
14606 GetWindowRect(child, &rc_old);
14607 MapWindowPoints(0, parent1, (POINT *)&rc_old, 2);
14608 trace("child (%d,%d)-(%d,%d)\n", rc_old.left, rc_old.top, rc_old.right, rc_old.bottom);
14609
14610 flush_sequence();
14611
14612 SetParent(child, parent2);
14613 flush_events();
14614 ok_sequence(WmSetParentSeq_1, "SetParent() visible WS_CHILD", TRUE);
14615
14616 ok(GetWindowLongA(child, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
14617 ok(!IsWindowVisible(child), "IsWindowVisible() should return FALSE\n");
14618
14619 GetWindowRect(parent2, &rc);
14620 trace("parent2 (%d,%d)-(%d,%d)\n", rc.left, rc.top, rc.right, rc.bottom);
14621 GetWindowRect(child, &rc);
14622 MapWindowPoints(0, parent2, (POINT *)&rc, 2);
14623 trace("child (%d,%d)-(%d,%d)\n", rc.left, rc.top, rc.right, rc.bottom);
14624
14625 ok(EqualRect(&rc_old, &rc), "rects do not match (%d,%d-%d,%d) / (%d,%d-%d,%d)\n",
14626 rc_old.left, rc_old.top, rc_old.right, rc_old.bottom,
14627 rc.left, rc.top, rc.right, rc.bottom );
14628
14629 /* WS_POPUP window */
14630 popup = CreateWindowExA(0, "TestWindowClass", NULL, WS_POPUP | WS_VISIBLE,
14631 20, 20, 100, 100, 0, 0, 0, NULL);
14632 ok(popup != 0, "Failed to create popup window\n");
14633
14634 GetWindowRect(popup, &rc_old);
14635 trace("popup (%d,%d)-(%d,%d)\n", rc_old.left, rc_old.top, rc_old.right, rc_old.bottom);
14636
14637 flush_sequence();
14638
14639 SetParent(popup, child);
14640 flush_events();
14641 ok_sequence(WmSetParentSeq_2, "SetParent() visible WS_POPUP", TRUE);
14642
14643 ok(GetWindowLongA(popup, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
14644 ok(!IsWindowVisible(popup), "IsWindowVisible() should return FALSE\n");
14645
14646 GetWindowRect(child, &rc);
14647 trace("parent2 (%d,%d)-(%d,%d)\n", rc.left, rc.top, rc.right, rc.bottom);
14648 GetWindowRect(popup, &rc);
14649 MapWindowPoints(0, child, (POINT *)&rc, 2);
14650 trace("popup (%d,%d)-(%d,%d)\n", rc.left, rc.top, rc.right, rc.bottom);
14651
14652 ok(EqualRect(&rc_old, &rc), "rects do not match (%d,%d-%d,%d) / (%d,%d-%d,%d)\n",
14653 rc_old.left, rc_old.top, rc_old.right, rc_old.bottom,
14654 rc.left, rc.top, rc.right, rc.bottom );
14655
14656 DestroyWindow(popup);
14657 DestroyWindow(child);
14658 DestroyWindow(parent1);
14659 DestroyWindow(parent2);
14660
14661 flush_sequence();
14662 }
14663
14664 static const struct message WmKeyReleaseOnly[] = {
14665 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 0x41, 0x80000001 },
14666 { WM_KEYUP, sent|wparam|lparam, 0x41, 0x80000001 },
14667 { 0 }
14668 };
14669 static const struct message WmKeyPressNormal[] = {
14670 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 0x41, 0x1 },
14671 { WM_KEYDOWN, sent|wparam|lparam, 0x41, 0x1 },
14672 { 0 }
14673 };
14674 static const struct message WmKeyPressRepeat[] = {
14675 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 0x41, 0x40000001 },
14676 { WM_KEYDOWN, sent|wparam|lparam, 0x41, 0x40000001 },
14677 { 0 }
14678 };
14679 static const struct message WmKeyReleaseNormal[] = {
14680 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 0x41, 0xc0000001 },
14681 { WM_KEYUP, sent|wparam|lparam, 0x41, 0xc0000001 },
14682 { 0 }
14683 };
14684
14685 static void test_keyflags(void)
14686 {
14687 HWND test_window;
14688 SHORT key_state;
14689 BYTE keyboard_state[256];
14690 MSG msg;
14691
14692 test_window = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
14693 100, 100, 200, 200, 0, 0, 0, NULL);
14694
14695 flush_events();
14696 flush_sequence();
14697
14698 /* keyup without a keydown */
14699 keybd_event(0x41, 0, KEYEVENTF_KEYUP, 0);
14700 while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
14701 DispatchMessageA(&msg);
14702 ok_sequence(WmKeyReleaseOnly, "key release only", TRUE);
14703
14704 key_state = GetAsyncKeyState(0x41);
14705 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
14706
14707 key_state = GetKeyState(0x41);
14708 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
14709
14710 /* keydown */
14711 keybd_event(0x41, 0, 0, 0);
14712 while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
14713 DispatchMessageA(&msg);
14714 ok_sequence(WmKeyPressNormal, "key press only", FALSE);
14715
14716 key_state = GetAsyncKeyState(0x41);
14717 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
14718
14719 key_state = GetKeyState(0x41);
14720 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
14721
14722 /* keydown repeat */
14723 keybd_event(0x41, 0, 0, 0);
14724 while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
14725 DispatchMessageA(&msg);
14726 ok_sequence(WmKeyPressRepeat, "key press repeat", FALSE);
14727
14728 key_state = GetAsyncKeyState(0x41);
14729 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
14730
14731 key_state = GetKeyState(0x41);
14732 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
14733
14734 /* keyup */
14735 keybd_event(0x41, 0, KEYEVENTF_KEYUP, 0);
14736 while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
14737 DispatchMessageA(&msg);
14738 ok_sequence(WmKeyReleaseNormal, "key release repeat", FALSE);
14739
14740 key_state = GetAsyncKeyState(0x41);
14741 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
14742
14743 key_state = GetKeyState(0x41);
14744 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
14745
14746 /* set the key state in this thread */
14747 GetKeyboardState(keyboard_state);
14748 keyboard_state[0x41] = 0x80;
14749 SetKeyboardState(keyboard_state);
14750
14751 key_state = GetAsyncKeyState(0x41);
14752 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
14753
14754 /* keydown */
14755 keybd_event(0x41, 0, 0, 0);
14756 while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
14757 DispatchMessageA(&msg);
14758 ok_sequence(WmKeyPressRepeat, "key press after setkeyboardstate", TRUE);
14759
14760 key_state = GetAsyncKeyState(0x41);
14761 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
14762
14763 key_state = GetKeyState(0x41);
14764 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
14765
14766 /* clear the key state in this thread */
14767 GetKeyboardState(keyboard_state);
14768 keyboard_state[0x41] = 0;
14769 SetKeyboardState(keyboard_state);
14770
14771 key_state = GetAsyncKeyState(0x41);
14772 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
14773
14774 /* keyup */
14775 keybd_event(0x41, 0, KEYEVENTF_KEYUP, 0);
14776 while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
14777 DispatchMessageA(&msg);
14778 ok_sequence(WmKeyReleaseOnly, "key release after setkeyboardstate", TRUE);
14779
14780 key_state = GetAsyncKeyState(0x41);
14781 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
14782
14783 key_state = GetKeyState(0x41);
14784 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
14785
14786 DestroyWindow(test_window);
14787 flush_sequence();
14788 }
14789
14790 static const struct message WmHotkeyPressLWIN[] = {
14791 { WM_KEYDOWN, kbd_hook|wparam|lparam, VK_LWIN, LLKHF_INJECTED },
14792 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_LWIN, 1 },
14793 { WM_KEYDOWN, sent|wparam|lparam, VK_LWIN, 1 },
14794 { 0 }
14795 };
14796 static const struct message WmHotkeyPress[] = {
14797 { WM_KEYDOWN, kbd_hook|lparam, 0, LLKHF_INJECTED },
14798 { WM_HOTKEY, sent|wparam, 5 },
14799 { 0 }
14800 };
14801 static const struct message WmHotkeyRelease[] = {
14802 { WM_KEYUP, kbd_hook|lparam, 0, LLKHF_INJECTED|LLKHF_UP },
14803 { HCBT_KEYSKIPPED, hook|lparam|optional, 0, 0x80000001 },
14804 { WM_KEYUP, sent|lparam, 0, 0x80000001 },
14805 { 0 }
14806 };
14807 static const struct message WmHotkeyReleaseLWIN[] = {
14808 { WM_KEYUP, kbd_hook|wparam|lparam, VK_LWIN, LLKHF_INJECTED|LLKHF_UP },
14809 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_LWIN, 0xc0000001 },
14810 { WM_KEYUP, sent|wparam|lparam, VK_LWIN, 0xc0000001 },
14811 { 0 }
14812 };
14813 static const struct message WmHotkeyCombined[] = {
14814 { WM_KEYDOWN, kbd_hook|wparam|lparam, VK_LWIN, LLKHF_INJECTED },
14815 { WM_KEYDOWN, kbd_hook|lparam, 0, LLKHF_INJECTED },
14816 { WM_KEYUP, kbd_hook|lparam, 0, LLKHF_INJECTED|LLKHF_UP },
14817 { WM_KEYUP, kbd_hook|wparam|lparam, VK_LWIN, LLKHF_INJECTED|LLKHF_UP },
14818 { WM_APP, sent, 0, 0 },
14819 { WM_HOTKEY, sent|wparam, 5 },
14820 { WM_APP+1, sent, 0, 0 },
14821 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_LWIN, 1 },
14822 { WM_KEYDOWN, sent|wparam|lparam, VK_LWIN, 1 },
14823 { HCBT_KEYSKIPPED, hook|optional, 0, 0x80000001 },
14824 { WM_KEYUP, sent, 0, 0x80000001 }, /* lparam not checked so the sequence isn't a todo */
14825 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_LWIN, 0xc0000001 },
14826 { WM_KEYUP, sent|wparam|lparam, VK_LWIN, 0xc0000001 },
14827 { 0 }
14828 };
14829 static const struct message WmHotkeyPrevious[] = {
14830 { WM_KEYDOWN, kbd_hook|wparam|lparam, VK_LWIN, LLKHF_INJECTED },
14831 { WM_KEYDOWN, kbd_hook|lparam, 0, LLKHF_INJECTED },
14832 { WM_KEYUP, kbd_hook|lparam, 0, LLKHF_INJECTED|LLKHF_UP },
14833 { WM_KEYUP, kbd_hook|wparam|lparam, VK_LWIN, LLKHF_INJECTED|LLKHF_UP },
14834 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_LWIN, 1 },
14835 { WM_KEYDOWN, sent|wparam|lparam, VK_LWIN, 1 },
14836 { HCBT_KEYSKIPPED, hook|lparam|optional, 0, 1 },
14837 { WM_KEYDOWN, sent|lparam, 0, 1 },
14838 { HCBT_KEYSKIPPED, hook|optional|lparam, 0, 0xc0000001 },
14839 { WM_KEYUP, sent|lparam, 0, 0xc0000001 },
14840 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_LWIN, 0xc0000001 },
14841 { WM_KEYUP, sent|wparam|lparam, VK_LWIN, 0xc0000001 },
14842 { 0 }
14843 };
14844 static const struct message WmHotkeyNew[] = {
14845 { WM_KEYDOWN, kbd_hook|lparam, 0, LLKHF_INJECTED },
14846 { WM_KEYUP, kbd_hook|lparam, 0, LLKHF_INJECTED|LLKHF_UP },
14847 { WM_HOTKEY, sent|wparam, 5 },
14848 { HCBT_KEYSKIPPED, hook|optional, 0, 0x80000001 },
14849 { WM_KEYUP, sent, 0, 0x80000001 }, /* lparam not checked so the sequence isn't a todo */
14850 { 0 }
14851 };
14852
14853 static int hotkey_letter;
14854
14855 static LRESULT CALLBACK KeyboardHookProc(int nCode, WPARAM wParam, LPARAM lParam)
14856 {
14857 struct recvd_message msg;
14858
14859 if (nCode == HC_ACTION)
14860 {
14861 KBDLLHOOKSTRUCT *kdbhookstruct = (KBDLLHOOKSTRUCT*)lParam;
14862
14863 msg.hwnd = 0;
14864 msg.message = wParam;
14865 msg.flags = kbd_hook|wparam|lparam;
14866 msg.wParam = kdbhookstruct->vkCode;
14867 msg.lParam = kdbhookstruct->flags;
14868 msg.descr = "KeyboardHookProc";
14869 add_message(&msg);
14870
14871 if (wParam == WM_KEYUP || wParam == WM_KEYDOWN)
14872 {
14873 ok(kdbhookstruct->vkCode == VK_LWIN || kdbhookstruct->vkCode == hotkey_letter,
14874 "unexpected keycode %x\n", kdbhookstruct->vkCode);
14875 }
14876 }
14877
14878 return CallNextHookEx(hKBD_hook, nCode, wParam, lParam);
14879 }
14880
14881 static void test_hotkey(void)
14882 {
14883 HWND test_window, taskbar_window;
14884 BOOL ret;
14885 MSG msg;
14886 DWORD queue_status;
14887 SHORT key_state;
14888
14889 SetLastError(0xdeadbeef);
14890 ret = UnregisterHotKey(NULL, 0);
14891 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
14892 ok(GetLastError() == ERROR_HOTKEY_NOT_REGISTERED || broken(GetLastError() == 0xdeadbeef),
14893 "unexpected error %d\n", GetLastError());
14894
14895 if (ret == TRUE)
14896 {
14897 skip("hotkeys not supported\n");
14898 return;
14899 }
14900
14901 test_window = CreateWindowExA(0, "HotkeyWindowClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
14902 100, 100, 200, 200, 0, 0, 0, NULL);
14903
14904 flush_sequence();
14905
14906 SetLastError(0xdeadbeef);
14907 ret = UnregisterHotKey(test_window, 0);
14908 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
14909 ok(GetLastError() == ERROR_HOTKEY_NOT_REGISTERED || broken(GetLastError() == 0xdeadbeef),
14910 "unexpected error %d\n", GetLastError());
14911
14912 /* Search for a Windows Key + letter combination that hasn't been registered */
14913 for (hotkey_letter = 0x41; hotkey_letter <= 0x51; hotkey_letter ++)
14914 {
14915 SetLastError(0xdeadbeef);
14916 ret = RegisterHotKey(test_window, 5, MOD_WIN, hotkey_letter);
14917
14918 if (ret == TRUE)
14919 {
14920 break;
14921 }
14922 else
14923 {
14924 ok(GetLastError() == ERROR_HOTKEY_ALREADY_REGISTERED || broken(GetLastError() == 0xdeadbeef),
14925 "unexpected error %d\n", GetLastError());
14926 }
14927 }
14928
14929 if (hotkey_letter == 0x52)
14930 {
14931 ok(0, "Couldn't find any free Windows Key + letter combination\n");
14932 goto end;
14933 }
14934
14935 hKBD_hook = SetWindowsHookExA(WH_KEYBOARD_LL, KeyboardHookProc, GetModuleHandleA(NULL), 0);
14936 if (!hKBD_hook) win_skip("WH_KEYBOARD_LL is not supported\n");
14937
14938 /* Same key combination, different id */
14939 SetLastError(0xdeadbeef);
14940 ret = RegisterHotKey(test_window, 4, MOD_WIN, hotkey_letter);
14941 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
14942 ok(GetLastError() == ERROR_HOTKEY_ALREADY_REGISTERED || broken(GetLastError() == 0xdeadbeef),
14943 "unexpected error %d\n", GetLastError());
14944
14945 /* Same key combination, different window */
14946 SetLastError(0xdeadbeef);
14947 ret = RegisterHotKey(NULL, 5, MOD_WIN, hotkey_letter);
14948 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
14949 ok(GetLastError() == ERROR_HOTKEY_ALREADY_REGISTERED || broken(GetLastError() == 0xdeadbeef),
14950 "unexpected error %d\n", GetLastError());
14951
14952 /* Register the same hotkey twice */
14953 SetLastError(0xdeadbeef);
14954 ret = RegisterHotKey(test_window, 5, MOD_WIN, hotkey_letter);
14955 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
14956 ok(GetLastError() == ERROR_HOTKEY_ALREADY_REGISTERED || broken(GetLastError() == 0xdeadbeef),
14957 "unexpected error %d\n", GetLastError());
14958
14959 /* Window on another thread */
14960 taskbar_window = FindWindowA("Shell_TrayWnd", NULL);
14961 if (!taskbar_window)
14962 {
14963 skip("no taskbar?\n");
14964 }
14965 else
14966 {
14967 SetLastError(0xdeadbeef);
14968 ret = RegisterHotKey(taskbar_window, 5, 0, hotkey_letter);
14969 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
14970 ok(GetLastError() == ERROR_WINDOW_OF_OTHER_THREAD || broken(GetLastError() == 0xdeadbeef),
14971 "unexpected error %d\n", GetLastError());
14972 }
14973
14974 /* Inject the appropriate key sequence */
14975 keybd_event(VK_LWIN, 0, 0, 0);
14976 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
14977 DispatchMessageA(&msg);
14978 ok_sequence(WmHotkeyPressLWIN, "window hotkey press LWIN", FALSE);
14979
14980 keybd_event(hotkey_letter, 0, 0, 0);
14981 queue_status = GetQueueStatus(QS_HOTKEY);
14982 ok((queue_status & (QS_HOTKEY << 16)) == QS_HOTKEY << 16, "expected QS_HOTKEY << 16 set, got %x\n", queue_status);
14983 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
14984 {
14985 if (msg.message == WM_HOTKEY)
14986 {
14987 ok(msg.hwnd == test_window, "unexpected hwnd %p\n", msg.hwnd);
14988 ok(msg.lParam == MAKELPARAM(MOD_WIN, hotkey_letter), "unexpected WM_HOTKEY lparam %lx\n", msg.lParam);
14989 }
14990 DispatchMessageA(&msg);
14991 }
14992 ok_sequence(WmHotkeyPress, "window hotkey press", FALSE);
14993
14994 queue_status = GetQueueStatus(QS_HOTKEY);
14995 ok((queue_status & (QS_HOTKEY << 16)) == 0, "expected QS_HOTKEY << 16 cleared, got %x\n", queue_status);
14996
14997 key_state = GetAsyncKeyState(hotkey_letter);
14998 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
14999
15000 keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
15001 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
15002 DispatchMessageA(&msg);
15003 ok_sequence(WmHotkeyRelease, "window hotkey release", TRUE);
15004
15005 keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);
15006 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
15007 DispatchMessageA(&msg);
15008 ok_sequence(WmHotkeyReleaseLWIN, "window hotkey release LWIN", FALSE);
15009
15010 /* normal posted WM_HOTKEY messages set QS_HOTKEY */
15011 PostMessageA(test_window, WM_HOTKEY, 0, 0);
15012 queue_status = GetQueueStatus(QS_HOTKEY);
15013 ok((queue_status & (QS_HOTKEY << 16)) == QS_HOTKEY << 16, "expected QS_HOTKEY << 16 set, got %x\n", queue_status);
15014 queue_status = GetQueueStatus(QS_POSTMESSAGE);
15015 ok((queue_status & (QS_POSTMESSAGE << 16)) == QS_POSTMESSAGE << 16, "expected QS_POSTMESSAGE << 16 set, got %x\n", queue_status);
15016 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
15017 DispatchMessageA(&msg);
15018 flush_sequence();
15019
15020 /* Send and process all messages at once */
15021 PostMessageA(test_window, WM_APP, 0, 0);
15022 keybd_event(VK_LWIN, 0, 0, 0);
15023 keybd_event(hotkey_letter, 0, 0, 0);
15024 keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
15025 keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);
15026
15027 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
15028 {
15029 if (msg.message == WM_HOTKEY)
15030 {
15031 ok(msg.hwnd == test_window, "unexpected hwnd %p\n", msg.hwnd);
15032 ok(msg.lParam == MAKELPARAM(MOD_WIN, hotkey_letter), "unexpected WM_HOTKEY lparam %lx\n", msg.lParam);
15033 }
15034 DispatchMessageA(&msg);
15035 }
15036 ok_sequence(WmHotkeyCombined, "window hotkey combined", FALSE);
15037
15038 /* Register same hwnd/id with different key combination */
15039 ret = RegisterHotKey(test_window, 5, 0, hotkey_letter);
15040 ok(ret == TRUE, "expected TRUE, got %i, err=%d\n", ret, GetLastError());
15041
15042 /* Previous key combination does not work */
15043 keybd_event(VK_LWIN, 0, 0, 0);
15044 keybd_event(hotkey_letter, 0, 0, 0);
15045 keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
15046 keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);
15047
15048 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
15049 DispatchMessageA(&msg);
15050 ok_sequence(WmHotkeyPrevious, "window hotkey previous", FALSE);
15051
15052 /* New key combination works */
15053 keybd_event(hotkey_letter, 0, 0, 0);
15054 keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
15055
15056 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
15057 {
15058 if (msg.message == WM_HOTKEY)
15059 {
15060 ok(msg.hwnd == test_window, "unexpected hwnd %p\n", msg.hwnd);
15061 ok(msg.lParam == MAKELPARAM(0, hotkey_letter), "unexpected WM_HOTKEY lparam %lx\n", msg.lParam);
15062 }
15063 DispatchMessageA(&msg);
15064 }
15065 ok_sequence(WmHotkeyNew, "window hotkey new", FALSE);
15066
15067 /* Unregister hotkey properly */
15068 ret = UnregisterHotKey(test_window, 5);
15069 ok(ret == TRUE, "expected TRUE, got %i, err=%d\n", ret, GetLastError());
15070
15071 /* Unregister hotkey again */
15072 SetLastError(0xdeadbeef);
15073 ret = UnregisterHotKey(test_window, 5);
15074 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
15075 ok(GetLastError() == ERROR_HOTKEY_NOT_REGISTERED || broken(GetLastError() == 0xdeadbeef),
15076 "unexpected error %d\n", GetLastError());
15077
15078 /* Register thread hotkey */
15079 ret = RegisterHotKey(NULL, 5, MOD_WIN, hotkey_letter);
15080 ok(ret == TRUE, "expected TRUE, got %i, err=%d\n", ret, GetLastError());
15081
15082 /* Inject the appropriate key sequence */
15083 keybd_event(VK_LWIN, 0, 0, 0);
15084 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
15085 {
15086 ok(msg.hwnd != NULL, "unexpected thread message %x\n", msg.message);
15087 DispatchMessageA(&msg);
15088 }
15089 ok_sequence(WmHotkeyPressLWIN, "thread hotkey press LWIN", FALSE);
15090
15091 keybd_event(hotkey_letter, 0, 0, 0);
15092 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
15093 {
15094 if (msg.message == WM_HOTKEY)
15095 {
15096 struct recvd_message message;
15097 ok(msg.hwnd == NULL, "unexpected hwnd %p\n", msg.hwnd);
15098 ok(msg.lParam == MAKELPARAM(MOD_WIN, hotkey_letter), "unexpected WM_HOTKEY lparam %lx\n", msg.lParam);
15099 message.message = msg.message;
15100 message.flags = sent|wparam|lparam;
15101 message.wParam = msg.wParam;
15102 message.lParam = msg.lParam;
15103 message.descr = "test_hotkey thread message";
15104 add_message(&message);
15105 }
15106 else
15107 ok(msg.hwnd != NULL, "unexpected thread message %x\n", msg.message);
15108 DispatchMessageA(&msg);
15109 }
15110 ok_sequence(WmHotkeyPress, "thread hotkey press", FALSE);
15111
15112 keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
15113 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
15114 {
15115 ok(msg.hwnd != NULL, "unexpected thread message %x\n", msg.message);
15116 DispatchMessageA(&msg);
15117 }
15118 ok_sequence(WmHotkeyRelease, "thread hotkey release", TRUE);
15119
15120 keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);
15121 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
15122 {
15123 ok(msg.hwnd != NULL, "unexpected thread message %x\n", msg.message);
15124 DispatchMessageA(&msg);
15125 }
15126 ok_sequence(WmHotkeyReleaseLWIN, "thread hotkey release LWIN", FALSE);
15127
15128 /* Unregister thread hotkey */
15129 ret = UnregisterHotKey(NULL, 5);
15130 ok(ret == TRUE, "expected TRUE, got %i, err=%d\n", ret, GetLastError());
15131
15132 if (hKBD_hook) UnhookWindowsHookEx(hKBD_hook);
15133 hKBD_hook = NULL;
15134
15135 end:
15136 UnregisterHotKey(NULL, 5);
15137 UnregisterHotKey(test_window, 5);
15138 DestroyWindow(test_window);
15139 flush_sequence();
15140 }
15141
15142
15143 static const struct message WmSetFocus_1[] = {
15144 { HCBT_SETFOCUS, hook }, /* child */
15145 { HCBT_ACTIVATE, hook }, /* parent */
15146 { WM_QUERYNEWPALETTE, sent|wparam|lparam|parent|optional, 0, 0 },
15147 { WM_WINDOWPOSCHANGING, sent|parent, 0, SWP_NOSIZE|SWP_NOMOVE },
15148 { WM_ACTIVATEAPP, sent|wparam|parent, 1 },
15149 { WM_NCACTIVATE, sent|parent },
15150 { WM_GETTEXT, sent|defwinproc|parent|optional },
15151 { WM_GETTEXT, sent|defwinproc|parent|optional },
15152 { WM_ACTIVATE, sent|wparam|parent, 1 },
15153 { HCBT_SETFOCUS, hook }, /* parent */
15154 { WM_SETFOCUS, sent|defwinproc|parent },
15155 { WM_KILLFOCUS, sent|parent },
15156 { WM_SETFOCUS, sent },
15157 { 0 }
15158 };
15159 static const struct message WmSetFocus_2[] = {
15160 { HCBT_SETFOCUS, hook }, /* parent */
15161 { WM_KILLFOCUS, sent },
15162 { WM_SETFOCUS, sent|parent },
15163 { 0 }
15164 };
15165 static const struct message WmSetFocus_3[] = {
15166 { HCBT_SETFOCUS, hook }, /* child */
15167 { 0 }
15168 };
15169
15170 static void test_SetFocus(void)
15171 {
15172 HWND parent, old_parent, child, old_focus, old_active;
15173 MSG msg;
15174 struct wnd_event wnd_event;
15175 HANDLE hthread;
15176 DWORD ret, tid;
15177
15178 wnd_event.start_event = CreateEventW(NULL, 0, 0, NULL);
15179 ok(wnd_event.start_event != 0, "CreateEvent error %d\n", GetLastError());
15180 hthread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
15181 ok(hthread != 0, "CreateThread error %d\n", GetLastError());
15182 ret = WaitForSingleObject(wnd_event.start_event, INFINITE);
15183 ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
15184 CloseHandle(wnd_event.start_event);
15185
15186 parent = CreateWindowExA(0, "TestParentClass", NULL, WS_OVERLAPPEDWINDOW,
15187 0, 0, 0, 0, 0, 0, 0, NULL);
15188 ok(parent != 0, "failed to create parent window\n");
15189 child = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
15190 0, 0, 0, 0, parent, 0, 0, NULL);
15191 ok(child != 0, "failed to create child window\n");
15192
15193 trace("parent %p, child %p, thread window %p\n", parent, child, wnd_event.hwnd);
15194
15195 SetFocus(0);
15196 SetActiveWindow(0);
15197
15198 flush_events();
15199 flush_sequence();
15200
15201 ok(GetActiveWindow() == 0, "expected active 0, got %p\n", GetActiveWindow());
15202 ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
15203
15204 log_all_parent_messages++;
15205
15206 old_focus = SetFocus(child);
15207 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15208 ok_sequence(WmSetFocus_1, "SetFocus on a child window", TRUE);
15209 ok(old_focus == parent, "expected old focus %p, got %p\n", parent, old_focus);
15210 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15211 ok(GetFocus() == child, "expected focus %p, got %p\n", child, GetFocus());
15212
15213 old_focus = SetFocus(parent);
15214 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15215 ok_sequence(WmSetFocus_2, "SetFocus on a parent window", FALSE);
15216 ok(old_focus == child, "expected old focus %p, got %p\n", child, old_focus);
15217 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15218 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15219
15220 SetLastError(0xdeadbeef);
15221 old_focus = SetFocus((HWND)0xdeadbeef);
15222 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || broken(GetLastError() == 0xdeadbeef),
15223 "expected ERROR_INVALID_WINDOW_HANDLE, got %d\n", GetLastError());
15224 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15225 ok_sequence(WmEmptySeq, "SetFocus on an invalid window", FALSE);
15226 ok(old_focus == 0, "expected old focus 0, got %p\n", old_focus);
15227 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15228 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15229
15230 SetLastError(0xdeadbeef);
15231 old_focus = SetFocus(GetDesktopWindow());
15232 ok(GetLastError() == ERROR_ACCESS_DENIED /* Vista+ */ ||
15233 broken(GetLastError() == 0xdeadbeef), "expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
15234 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15235 ok_sequence(WmEmptySeq, "SetFocus on a desktop window", TRUE);
15236 ok(old_focus == 0, "expected old focus 0, got %p\n", old_focus);
15237 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15238 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15239
15240 SetLastError(0xdeadbeef);
15241 old_focus = SetFocus(wnd_event.hwnd);
15242 ok(GetLastError() == ERROR_ACCESS_DENIED /* Vista+ */ ||
15243 broken(GetLastError() == 0xdeadbeef), "expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
15244 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15245 ok_sequence(WmEmptySeq, "SetFocus on another thread window", TRUE);
15246 ok(old_focus == 0, "expected old focus 0, got %p\n", old_focus);
15247 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15248 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15249
15250 SetLastError(0xdeadbeef);
15251 old_active = SetActiveWindow((HWND)0xdeadbeef);
15252 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || broken(GetLastError() == 0xdeadbeef),
15253 "expected ERROR_INVALID_WINDOW_HANDLE, got %d\n", GetLastError());
15254 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15255 ok_sequence(WmEmptySeq, "SetActiveWindow on an invalid window", FALSE);
15256 ok(old_active == 0, "expected old focus 0, got %p\n", old_active);
15257 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15258 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15259
15260 SetLastError(0xdeadbeef);
15261 old_active = SetActiveWindow(GetDesktopWindow());
15262 todo_wine
15263 ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
15264 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15265 ok_sequence(WmEmptySeq, "SetActiveWindow on a desktop window", TRUE);
15266 ok(old_active == 0, "expected old focus 0, got %p\n", old_focus);
15267 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15268 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15269
15270 SetLastError(0xdeadbeef);
15271 old_active = SetActiveWindow(wnd_event.hwnd);
15272 todo_wine
15273 ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
15274 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15275 ok_sequence(WmEmptySeq, "SetActiveWindow on another thread window", TRUE);
15276 ok(old_active == 0, "expected old focus 0, got %p\n", old_active);
15277 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15278 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15279
15280 SetLastError(0xdeadbeef);
15281 ret = AttachThreadInput(GetCurrentThreadId(), tid, TRUE);
15282 ok(ret, "AttachThreadInput error %d\n", GetLastError());
15283
15284 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15285 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15286
15287 flush_events();
15288 flush_sequence();
15289
15290 old_focus = SetFocus(wnd_event.hwnd);
15291 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15292 ok(old_focus == wnd_event.hwnd, "expected old focus %p, got %p\n", wnd_event.hwnd, old_focus);
15293 ok(GetActiveWindow() == wnd_event.hwnd, "expected active %p, got %p\n", wnd_event.hwnd, GetActiveWindow());
15294 ok(GetFocus() == wnd_event.hwnd, "expected focus %p, got %p\n", wnd_event.hwnd, GetFocus());
15295
15296 old_focus = SetFocus(parent);
15297 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15298 ok(old_focus == parent, "expected old focus %p, got %p\n", parent, old_focus);
15299 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15300 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15301
15302 flush_events();
15303 flush_sequence();
15304
15305 old_active = SetActiveWindow(wnd_event.hwnd);
15306 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15307 ok(old_active == parent, "expected old focus %p, got %p\n", parent, old_active);
15308 ok(GetActiveWindow() == wnd_event.hwnd, "expected active %p, got %p\n", wnd_event.hwnd, GetActiveWindow());
15309 ok(GetFocus() == wnd_event.hwnd, "expected focus %p, got %p\n", wnd_event.hwnd, GetFocus());
15310
15311 SetLastError(0xdeadbeef);
15312 ret = AttachThreadInput(GetCurrentThreadId(), tid, FALSE);
15313 ok(ret, "AttachThreadInput error %d\n", GetLastError());
15314
15315 ok(GetActiveWindow() == 0, "expected active 0, got %p\n", GetActiveWindow());
15316 ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
15317
15318 old_parent = SetParent(child, GetDesktopWindow());
15319 ok(old_parent == parent, "expected old parent %p, got %p\n", parent, old_parent);
15320
15321 ok(GetActiveWindow() == 0, "expected active 0, got %p\n", GetActiveWindow());
15322 ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
15323
15324 old_focus = SetFocus(parent);
15325 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15326 ok(old_focus == parent, "expected old focus %p, got %p\n", parent, old_focus);
15327 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15328 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15329
15330 flush_events();
15331 flush_sequence();
15332
15333 SetLastError(0xdeadbeef);
15334 old_focus = SetFocus(child);
15335 todo_wine
15336 ok(GetLastError() == ERROR_INVALID_PARAMETER /* Vista+ */ ||
15337 broken(GetLastError() == 0) /* XP */ ||
15338 broken(GetLastError() == 0xdeadbeef), "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
15339 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15340 ok_sequence(WmSetFocus_3, "SetFocus on a child window", TRUE);
15341 ok(old_focus == 0, "expected old focus 0, got %p\n", old_focus);
15342 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15343 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15344
15345 SetLastError(0xdeadbeef);
15346 old_active = SetActiveWindow(child);
15347 ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
15348 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15349 ok_sequence(WmEmptySeq, "SetActiveWindow on a child window", FALSE);
15350 ok(old_active == parent, "expected old active %p, got %p\n", parent, old_active);
15351 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15352 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15353
15354 log_all_parent_messages--;
15355
15356 DestroyWindow(child);
15357 DestroyWindow(parent);
15358
15359 ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
15360 ok(ret, "PostMessage(WM_QUIT) error %d\n", GetLastError());
15361 ret = WaitForSingleObject(hthread, INFINITE);
15362 ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
15363 CloseHandle(hthread);
15364 }
15365
15366 static const struct message WmSetLayeredStyle[] = {
15367 { WM_STYLECHANGING, sent },
15368 { WM_STYLECHANGED, sent },
15369 { WM_GETTEXT, sent|defwinproc|optional },
15370 { 0 }
15371 };
15372
15373 static const struct message WmSetLayeredStyle2[] = {
15374 { WM_STYLECHANGING, sent },
15375 { WM_STYLECHANGED, sent },
15376 { WM_WINDOWPOSCHANGING, sent|optional|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
15377 { WM_NCCALCSIZE, sent|optional|wparam|defwinproc, 1 },
15378 { WM_WINDOWPOSCHANGED, sent|optional|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
15379 { WM_MOVE, sent|optional|defwinproc|wparam, 0 },
15380 { WM_SIZE, sent|optional|defwinproc|wparam, SIZE_RESTORED },
15381 { 0 }
15382 };
15383
15384 struct layered_window_info
15385 {
15386 HWND hwnd;
15387 HDC hdc;
15388 SIZE size;
15389 HANDLE event;
15390 BOOL ret;
15391 };
15392
15393 static DWORD CALLBACK update_layered_proc( void *param )
15394 {
15395 struct layered_window_info *info = param;
15396 POINT src = { 0, 0 };
15397
15398 info->ret = pUpdateLayeredWindow( info->hwnd, 0, NULL, &info->size,
15399 info->hdc, &src, 0, NULL, ULW_OPAQUE );
15400 ok( info->ret, "failed\n");
15401 SetEvent( info->event );
15402 return 0;
15403 }
15404
15405 static void test_layered_window(void)
15406 {
15407 HWND hwnd;
15408 HDC hdc;
15409 HBITMAP bmp;
15410 BOOL ret;
15411 SIZE size;
15412 POINT pos, src;
15413 RECT rect, client;
15414 HANDLE thread;
15415 DWORD tid;
15416 struct layered_window_info info;
15417
15418 if (!pUpdateLayeredWindow)
15419 {
15420 win_skip( "UpdateLayeredWindow not supported\n" );
15421 return;
15422 }
15423
15424 hdc = CreateCompatibleDC( 0 );
15425 bmp = CreateCompatibleBitmap( hdc, 300, 300 );
15426 SelectObject( hdc, bmp );
15427
15428 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_CAPTION | WS_THICKFRAME | WS_SYSMENU,
15429 100, 100, 300, 300, 0, 0, 0, NULL);
15430 ok( hwnd != 0, "failed to create window\n" );
15431 ShowWindow( hwnd, SW_SHOWNORMAL );
15432 UpdateWindow( hwnd );
15433 flush_events();
15434 flush_sequence();
15435
15436 GetWindowRect( hwnd, &rect );
15437 GetClientRect( hwnd, &client );
15438 ok( client.right < rect.right - rect.left, "wrong client area\n" );
15439 ok( client.bottom < rect.bottom - rect.top, "wrong client area\n" );
15440
15441 src.x = src.y = 0;
15442 pos.x = pos.y = 300;
15443 size.cx = size.cy = 250;
15444 ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
15445 ok( !ret, "UpdateLayeredWindow should fail on non-layered window\n" );
15446 ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError() );
15447 SetWindowLongA( hwnd, GWL_EXSTYLE, GetWindowLongA(hwnd, GWL_EXSTYLE) | WS_EX_LAYERED );
15448 ok_sequence( WmSetLayeredStyle, "WmSetLayeredStyle", FALSE );
15449
15450 ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
15451 ok( ret, "UpdateLayeredWindow failed err %u\n", GetLastError() );
15452 ok_sequence( WmEmptySeq, "UpdateLayeredWindow", FALSE );
15453 GetWindowRect( hwnd, &rect );
15454 ok( rect.left == 300 && rect.top == 300 && rect.right == 550 && rect.bottom == 550,
15455 "wrong window rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15456 GetClientRect( hwnd, &rect );
15457 ok( rect.right == client.right - 50 && rect.bottom == client.bottom - 50,
15458 "wrong client rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15459
15460 size.cx = 150;
15461 pos.y = 200;
15462 ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
15463 ok( ret, "UpdateLayeredWindow failed err %u\n", GetLastError() );
15464 ok_sequence( WmEmptySeq, "UpdateLayeredWindow", FALSE );
15465 GetWindowRect( hwnd, &rect );
15466 ok( rect.left == 300 && rect.top == 200 && rect.right == 450 && rect.bottom == 450,
15467 "wrong window rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15468 GetClientRect( hwnd, &rect );
15469 ok( rect.right == client.right - 150 && rect.bottom == client.bottom - 50,
15470 "wrong client rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15471
15472 SetWindowLongA( hwnd, GWL_STYLE,
15473 GetWindowLongA(hwnd, GWL_STYLE) & ~(WS_CAPTION | WS_THICKFRAME | WS_SYSMENU) );
15474 ok_sequence( WmSetLayeredStyle2, "WmSetLayeredStyle2", FALSE );
15475
15476 size.cx = 200;
15477 pos.x = 200;
15478 ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
15479 ok( ret, "UpdateLayeredWindow failed err %u\n", GetLastError() );
15480 ok_sequence( WmEmptySeq, "UpdateLayeredWindow", FALSE );
15481 GetWindowRect( hwnd, &rect );
15482 ok( rect.left == 200 && rect.top == 200 && rect.right == 400 && rect.bottom == 450,
15483 "wrong window rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15484 GetClientRect( hwnd, &rect );
15485 ok( (rect.right == 200 && rect.bottom == 250) ||
15486 broken(rect.right == client.right - 100 && rect.bottom == client.bottom - 50),
15487 "wrong client rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15488
15489 size.cx = 0;
15490 ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
15491 ok( !ret, "UpdateLayeredWindow should fail on non-layered window\n" );
15492 ok( GetLastError() == ERROR_INVALID_PARAMETER || broken(ERROR_MR_MID_NOT_FOUND) /* win7 */,
15493 "wrong error %u\n", GetLastError() );
15494 size.cx = 1;
15495 size.cy = -1;
15496 ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
15497 ok( !ret, "UpdateLayeredWindow should fail on non-layered window\n" );
15498 ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError() );
15499
15500 SetWindowLongA( hwnd, GWL_EXSTYLE, GetWindowLongA(hwnd, GWL_EXSTYLE) & ~WS_EX_LAYERED );
15501 ok_sequence( WmSetLayeredStyle, "WmSetLayeredStyle", FALSE );
15502 GetWindowRect( hwnd, &rect );
15503 ok( rect.left == 200 && rect.top == 200 && rect.right == 400 && rect.bottom == 450,
15504 "wrong window rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15505 GetClientRect( hwnd, &rect );
15506 ok( (rect.right == 200 && rect.bottom == 250) ||
15507 broken(rect.right == client.right - 100 && rect.bottom == client.bottom - 50),
15508 "wrong client rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15509
15510 SetWindowLongA( hwnd, GWL_EXSTYLE, GetWindowLongA(hwnd, GWL_EXSTYLE) | WS_EX_LAYERED );
15511 info.hwnd = hwnd;
15512 info.hdc = hdc;
15513 info.size.cx = 250;
15514 info.size.cy = 300;
15515 info.event = CreateEventA( NULL, TRUE, FALSE, NULL );
15516 info.ret = FALSE;
15517 thread = CreateThread( NULL, 0, update_layered_proc, &info, 0, &tid );
15518 ok( WaitForSingleObject( info.event, 1000 ) == 0, "wait failed\n" );
15519 ok( info.ret, "UpdateLayeredWindow failed in other thread\n" );
15520 WaitForSingleObject( thread, 1000 );
15521 CloseHandle( thread );
15522 GetWindowRect( hwnd, &rect );
15523 ok( rect.left == 200 && rect.top == 200 && rect.right == 450 && rect.bottom == 500,
15524 "wrong window rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15525 GetClientRect( hwnd, &rect );
15526 ok( (rect.right == 250 && rect.bottom == 300) ||
15527 broken(rect.right == client.right - 50 && rect.bottom == client.bottom),
15528 "wrong client rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15529
15530 DestroyWindow( hwnd );
15531 DeleteDC( hdc );
15532 DeleteObject( bmp );
15533 }
15534
15535 static HMENU hpopupmenu;
15536
15537 static LRESULT WINAPI cancel_popup_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
15538 {
15539 if (ignore_message( message )) return 0;
15540
15541 switch (message) {
15542 case WM_ENTERIDLE:
15543 todo_wine ok(GetCapture() == hwnd, "expected %p, got %p\n", hwnd, GetCapture());
15544 EndMenu();
15545 break;
15546 case WM_INITMENU:
15547 case WM_INITMENUPOPUP:
15548 case WM_UNINITMENUPOPUP:
15549 ok((HMENU)wParam == hpopupmenu, "expected %p, got %lx\n", hpopupmenu, wParam);
15550 break;
15551 case WM_CAPTURECHANGED:
15552 todo_wine ok(!lParam || (HWND)lParam == hwnd, "lost capture to %lx\n", lParam);
15553 break;
15554 }
15555
15556 return MsgCheckProc (FALSE, hwnd, message, wParam, lParam);
15557 }
15558
15559 static LRESULT WINAPI cancel_init_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
15560 {
15561 if (ignore_message( message )) return 0;
15562
15563 switch (message) {
15564 case WM_ENTERMENULOOP:
15565 ok(EndMenu() == TRUE, "EndMenu() failed\n");
15566 break;
15567 }
15568
15569 return MsgCheckProc (FALSE, hwnd, message, wParam, lParam);
15570 }
15571
15572 static void test_TrackPopupMenu(void)
15573 {
15574 HWND hwnd;
15575 BOOL ret;
15576
15577 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, 0,
15578 0, 0, 1, 1, 0,
15579 NULL, NULL, 0);
15580 ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
15581
15582 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)cancel_popup_proc);
15583
15584 hpopupmenu = CreatePopupMenu();
15585 ok(hpopupmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
15586
15587 AppendMenuA(hpopupmenu, MF_STRING, 100, "item 1");
15588 AppendMenuA(hpopupmenu, MF_STRING, 100, "item 2");
15589
15590 flush_events();
15591 flush_sequence();
15592 ret = TrackPopupMenu(hpopupmenu, 0, 100,100, 0, hwnd, NULL);
15593 ok_sequence(WmTrackPopupMenu, "TrackPopupMenu", TRUE);
15594 ok(ret == 1, "TrackPopupMenu failed with error %i\n", GetLastError());
15595
15596 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)cancel_init_proc);
15597
15598 flush_events();
15599 flush_sequence();
15600 ret = TrackPopupMenu(hpopupmenu, 0, 100,100, 0, hwnd, NULL);
15601 ok_sequence(WmTrackPopupMenuAbort, "WmTrackPopupMenuAbort", TRUE);
15602 ok(ret == TRUE, "TrackPopupMenu failed\n");
15603
15604 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)cancel_popup_proc);
15605
15606 SetCapture(hwnd);
15607
15608 flush_events();
15609 flush_sequence();
15610 ret = TrackPopupMenu(hpopupmenu, 0, 100,100, 0, hwnd, NULL);
15611 ok_sequence(WmTrackPopupMenuCapture, "TrackPopupMenuCapture", TRUE);
15612 ok(ret == 1, "TrackPopupMenuCapture failed with error %i\n", GetLastError());
15613
15614 DestroyMenu(hpopupmenu);
15615 DestroyWindow(hwnd);
15616 }
15617
15618 static void test_TrackPopupMenuEmpty(void)
15619 {
15620 HWND hwnd;
15621 BOOL ret;
15622
15623 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, 0,
15624 0, 0, 1, 1, 0,
15625 NULL, NULL, 0);
15626 ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
15627
15628 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)cancel_popup_proc);
15629
15630 hpopupmenu = CreatePopupMenu();
15631 ok(hpopupmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
15632
15633 flush_events();
15634 flush_sequence();
15635 ret = TrackPopupMenu(hpopupmenu, 0, 100,100, 0, hwnd, NULL);
15636 ok_sequence(WmTrackPopupMenuEmpty, "TrackPopupMenuEmpty", TRUE);
15637 ok(ret == 0, "TrackPopupMenu succeeded\n");
15638
15639 DestroyMenu(hpopupmenu);
15640 DestroyWindow(hwnd);
15641 }
15642
15643 static const struct message send_message_1[] = {
15644 { WM_USER+2, sent|wparam|lparam, 0, 0 },
15645 { WM_USER, sent|wparam|lparam, 0, 0 },
15646 { 0 }
15647 };
15648 static const struct message send_message_2[] = {
15649 { WM_USER+4, sent|wparam|lparam, 0, 0 },
15650 { 0 }
15651 };
15652 static const struct message send_message_3[] = {
15653 { WM_USER+3, sent|wparam|lparam, 0, 0 },
15654 { 0 }
15655 };
15656 static const struct message send_message_4[] = {
15657 { WM_USER+1, sent|wparam|lparam, 0, 0 },
15658 { 0 }
15659 };
15660
15661 static DWORD WINAPI SendMessage_thread_1(void *param)
15662 {
15663 struct wnd_event *wnd_event = param;
15664
15665 trace("thread: starting\n");
15666 WaitForSingleObject(wnd_event->start_event, INFINITE);
15667
15668 trace("thread: call PostMessage\n");
15669 PostMessageA(wnd_event->hwnd, WM_USER, 0, 0);
15670
15671 trace("thread: call PostMessage\n");
15672 PostMessageA(wnd_event->hwnd, WM_USER+1, 0, 0);
15673
15674 trace("thread: call SendMessage\n");
15675 SendMessageA(wnd_event->hwnd, WM_USER+2, 0, 0);
15676
15677 trace("thread: call SendMessage\n");
15678 SendMessageA(wnd_event->hwnd, WM_USER+3, 0, 0);
15679
15680 return 0;
15681 }
15682
15683 static DWORD WINAPI SendMessage_thread_2(void *param)
15684 {
15685 struct wnd_event *wnd_event = param;
15686
15687 trace("thread: starting\n");
15688 WaitForSingleObject(wnd_event->start_event, INFINITE);
15689
15690 trace("thread: call PostMessage\n");
15691 PostMessageA(wnd_event->hwnd, WM_USER, 0, 0);
15692
15693 trace("thread: call PostMessage\n");
15694 PostMessageA(wnd_event->hwnd, WM_USER+1, 0, 0);
15695
15696 /* this leads to sending an internal message under Wine */
15697 trace("thread: call EnableWindow\n");
15698 EnableWindow(wnd_event->hwnd, TRUE);
15699
15700 trace("thread: call SendMessage\n");
15701 SendMessageA(wnd_event->hwnd, WM_USER+2, 0, 0);
15702
15703 trace("thread: call SendMessage\n");
15704 SendMessageA(wnd_event->hwnd, WM_USER+3, 0, 0);
15705
15706 return 0;
15707 }
15708
15709 static void test_SendMessage_other_thread(int thread_n)
15710 {
15711 DWORD qs_all_input = QS_ALLINPUT & ~QS_RAWINPUT;
15712 HANDLE hthread;
15713 struct wnd_event wnd_event;
15714 DWORD tid, ret;
15715 MSG msg;
15716
15717 wnd_event.start_event = CreateEventA(NULL, 0, 0, NULL);
15718
15719 wnd_event.hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
15720 100, 100, 200, 200, 0, 0, 0, NULL);
15721 ok(wnd_event.hwnd != 0, "CreateWindowEx failed\n");
15722
15723 hthread = CreateThread(NULL, 0, thread_n == 1 ? SendMessage_thread_1 : SendMessage_thread_2, &wnd_event, 0, &tid);
15724 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
15725 CloseHandle(hthread);
15726
15727 flush_events();
15728 flush_sequence();
15729
15730 ret = GetQueueStatus(QS_SENDMESSAGE);
15731 ok(ret == 0, "wrong status %08x\n", ret);
15732
15733 SetEvent(wnd_event.start_event);
15734
15735 /* wait for other thread's SendMessage */
15736 for (;;)
15737 {
15738 ret = GetQueueStatus(QS_SENDMESSAGE);
15739 if (ret == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE)) break;
15740 Sleep(50);
15741 }
15742
15743 ret = GetQueueStatus(QS_SENDMESSAGE|QS_POSTMESSAGE);
15744 ok(ret == MAKELONG(QS_POSTMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE), "wrong status %08x\n", ret);
15745
15746 trace("main: call GetMessage\n");
15747 GetMessageA(&msg, 0, 0, 0);
15748 ok(msg.message == WM_USER, "expected WM_USER, got %04x\n", msg.message);
15749 DispatchMessageA(&msg);
15750 ok_sequence(send_message_1, "SendMessage from other thread 1", thread_n == 2);
15751
15752 /* intentionally yield */
15753 MsgWaitForMultipleObjects(0, NULL, FALSE, 100, qs_all_input);
15754
15755 trace("main: call SendMessage\n");
15756 SendMessageA(wnd_event.hwnd, WM_USER+4, 0, 0);
15757 ok_sequence(send_message_2, "SendMessage from other thread 2", FALSE);
15758
15759 ret = GetQueueStatus(QS_SENDMESSAGE|QS_POSTMESSAGE);
15760 ok(ret == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE), "wrong status %08x\n", ret);
15761
15762 trace("main: call PeekMessage\n");
15763 ok(PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE), "PeekMessage should not fail\n");
15764 ok(msg.message == WM_USER+1, "expected WM_USER+1, got %04x\n", msg.message);
15765 ok_sequence(send_message_3, "SendMessage from other thread 3", thread_n == 2);
15766
15767 trace("main: call PeekMessage\n");
15768 ok(PeekMessageA(&msg, 0, 0, 0, PM_REMOVE), "PeekMessage should not fail\n");
15769 ok(msg.message == WM_USER+1, "expected WM_USER+1, got %04x\n", msg.message);
15770 DispatchMessageA(&msg);
15771 ok_sequence(send_message_4, "SendMessage from other thread 4", FALSE);
15772
15773 /* intentionally yield */
15774 MsgWaitForMultipleObjects(0, NULL, FALSE, 100, qs_all_input);
15775
15776 ret = GetQueueStatus(QS_SENDMESSAGE|QS_POSTMESSAGE);
15777 /* FIXME: remove once Wine is fixed */
15778 todo_wine_if (thread_n == 2)
15779 ok(ret == 0, "wrong status %08x\n", ret);
15780
15781 trace("main: call PeekMessage\n");
15782 ok(!PeekMessageA(&msg, 0, 0, 0, PM_REMOVE), "PeekMessage should fail\n");
15783 ok_sequence(WmEmptySeq, "SendMessage from other thread 5", thread_n == 2);
15784
15785 ret = GetQueueStatus(QS_SENDMESSAGE|QS_POSTMESSAGE);
15786 ok(ret == 0, "wrong status %08x\n", ret);
15787
15788 trace("main: call DestroyWindow\n");
15789 DestroyWindow(msg.hwnd);
15790
15791 flush_events();
15792 flush_sequence();
15793 }
15794
15795 static const struct message DoubleSetCaptureSeq[] =
15796 {
15797 { WM_CAPTURECHANGED, sent },
15798 { 0 }
15799 };
15800
15801 static void test_DoubleSetCapture(void)
15802 {
15803 HWND hwnd;
15804
15805 hwnd = CreateWindowExA(0, "TestWindowClass", "Test DoubleSetCapture",
15806 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
15807 100, 100, 200, 200, 0, 0, 0, NULL);
15808 ok (hwnd != 0, "Failed to create overlapped window\n");
15809
15810 ShowWindow( hwnd, SW_SHOW );
15811 UpdateWindow( hwnd );
15812 flush_events();
15813 flush_sequence();
15814
15815 SetCapture( hwnd );
15816 SetCapture( hwnd );
15817 ok_sequence(DoubleSetCaptureSeq, "SetCapture( hwnd ) twice", FALSE);
15818
15819 DestroyWindow(hwnd);
15820 }
15821
15822 static void init_funcs(void)
15823 {
15824 HMODULE hKernel32 = GetModuleHandleA("kernel32.dll");
15825
15826 #define X(f) p##f = (void*)GetProcAddress(hKernel32, #f)
15827 X(ActivateActCtx);
15828 X(CreateActCtxW);
15829 X(DeactivateActCtx);
15830 X(GetCurrentActCtx);
15831 X(QueryActCtxW);
15832 X(ReleaseActCtx);
15833 #undef X
15834 }
15835
15836 START_TEST(msg)
15837 {
15838 char **test_argv;
15839 BOOL ret;
15840 BOOL (WINAPI *pIsWinEventHookInstalled)(DWORD)= 0;/*GetProcAddress(user32, "IsWinEventHookInstalled");*/
15841 HMODULE hModuleImm32;
15842 BOOL (WINAPI *pImmDisableIME)(DWORD);
15843 int argc;
15844
15845 init_funcs();
15846
15847 argc = winetest_get_mainargs( &test_argv );
15848 if (argc >= 3)
15849 {
15850 unsigned int arg;
15851 /* Child process. */
15852 sscanf (test_argv[2], "%d", (unsigned int *) &arg);
15853 do_wait_idle_child( arg );
15854 return;
15855 }
15856
15857 InitializeCriticalSection( &sequence_cs );
15858 init_procs();
15859
15860 hModuleImm32 = LoadLibraryA("imm32.dll");
15861 if (hModuleImm32) {
15862 pImmDisableIME = (void *)GetProcAddress(hModuleImm32, "ImmDisableIME");
15863 if (pImmDisableIME)
15864 pImmDisableIME(0);
15865 }
15866 pImmDisableIME = NULL;
15867 FreeLibrary(hModuleImm32);
15868
15869 if (!RegisterWindowClasses()) assert(0);
15870
15871 if (pSetWinEventHook)
15872 {
15873 hEvent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX,
15874 GetModuleHandleA(0), win_event_proc,
15875 0, GetCurrentThreadId(),
15876 WINEVENT_INCONTEXT);
15877 if (pIsWinEventHookInstalled && hEvent_hook)
15878 {
15879 UINT event;
15880 for (event = EVENT_MIN; event <= EVENT_MAX; event++)
15881 ok(pIsWinEventHookInstalled(event), "IsWinEventHookInstalled(%u) failed\n", event);
15882 }
15883 }
15884 if (!hEvent_hook) win_skip( "no win event hook support\n" );
15885
15886 cbt_hook_thread_id = GetCurrentThreadId();
15887 hCBT_hook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, GetCurrentThreadId());
15888 if (!hCBT_hook) win_skip( "cannot set global hook, will skip hook tests\n" );
15889
15890 test_winevents();
15891
15892 /* Fix message sequences before removing 4 lines below */
15893 if (pUnhookWinEvent && hEvent_hook)
15894 {
15895 ret = pUnhookWinEvent(hEvent_hook);
15896 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
15897 pUnhookWinEvent = 0;
15898 }
15899 hEvent_hook = 0;
15900
15901 test_SendMessage_other_thread(1);
15902 test_SendMessage_other_thread(2);
15903 test_SetFocus();
15904 test_SetParent();
15905 test_PostMessage();
15906 test_broadcast();
15907 test_ShowWindow();
15908 test_PeekMessage();
15909 test_PeekMessage2();
15910 test_PeekMessage3();
15911 test_WaitForInputIdle( test_argv[0] );
15912 test_scrollwindowex();
15913 test_messages();
15914 test_setwindowpos();
15915 test_showwindow();
15916 invisible_parent_tests();
15917 test_mdi_messages();
15918 test_button_messages();
15919 test_static_messages();
15920 test_listbox_messages();
15921 test_combobox_messages();
15922 test_wmime_keydown_message();
15923 test_paint_messages();
15924 test_interthread_messages();
15925 test_message_conversion();
15926 test_accelerators();
15927 test_timers();
15928 test_timers_no_wnd();
15929 test_timers_exceptions();
15930 if (hCBT_hook)
15931 {
15932 test_set_hook();
15933 test_recursive_hook();
15934 }
15935 test_DestroyWindow();
15936 test_DispatchMessage();
15937 test_SendMessageTimeout();
15938 test_edit_messages();
15939 test_quit_message();
15940 test_notify_message();
15941 test_SetActiveWindow();
15942
15943 if (!pTrackMouseEvent)
15944 win_skip("TrackMouseEvent is not available\n");
15945 else
15946 test_TrackMouseEvent();
15947
15948 test_SetWindowRgn();
15949 test_sys_menu();
15950 test_dialog_messages();
15951 test_EndDialog();
15952 test_nullCallback();
15953 test_dbcs_wm_char();
15954 test_unicode_wm_char();
15955 test_menu_messages();
15956 test_paintingloop();
15957 test_defwinproc();
15958 test_clipboard_viewers();
15959 test_keyflags();
15960 test_hotkey();
15961 test_layered_window();
15962 test_TrackPopupMenu();
15963 test_TrackPopupMenuEmpty();
15964 test_DoubleSetCapture();
15965 /* keep it the last test, under Windows it tends to break the tests
15966 * which rely on active/foreground windows being correct.
15967 */
15968 test_SetForegroundWindow();
15969
15970 UnhookWindowsHookEx(hCBT_hook);
15971 if (pUnhookWinEvent && hEvent_hook)
15972 {
15973 ret = pUnhookWinEvent(hEvent_hook);
15974 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
15975 SetLastError(0xdeadbeef);
15976 ok(!pUnhookWinEvent(hEvent_hook), "UnhookWinEvent succeeded\n");
15977 ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
15978 GetLastError() == 0xdeadbeef, /* Win9x */
15979 "unexpected error %d\n", GetLastError());
15980 }
15981 DeleteCriticalSection( &sequence_cs );
15982 }
Windows API implementation