?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
user32: Do not block sending/posting WM_NOTIFY messages.
[wine.git] / dlls / user32 / tests / msg.c
blobb2630ce3477e4c7fbeb5d833a350d529b0bb635a
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 /* kernel32 functions */
1747 static BOOL (WINAPI *pGetCPInfoExA)(UINT, DWORD, LPCPINFOEXA);
1748
1749 static void init_procs(void)
1750 {
1751 HMODULE user32 = GetModuleHandleA("user32.dll");
1752 HMODULE kernel32 = GetModuleHandleA("kernel32.dll");
1753
1754 #define GET_PROC(dll, func) \
1755 p ## func = (void*)GetProcAddress(dll, #func); \
1756 if(!p ## func) { \
1757 trace("GetProcAddress(%s) failed\n", #func); \
1758 }
1759
1760 GET_PROC(user32, GetAncestor)
1761 GET_PROC(user32, GetMenuInfo)
1762 GET_PROC(user32, NotifyWinEvent)
1763 GET_PROC(user32, SetMenuInfo)
1764 GET_PROC(user32, SetWinEventHook)
1765 GET_PROC(user32, TrackMouseEvent)
1766 GET_PROC(user32, UnhookWinEvent)
1767 GET_PROC(user32, GetMonitorInfoA)
1768 GET_PROC(user32, MonitorFromPoint)
1769 GET_PROC(user32, UpdateLayeredWindow)
1770 GET_PROC(user32, SetSystemTimer)
1771 GET_PROC(user32, KillSystemTimer)
1772
1773 GET_PROC(kernel32, GetCPInfoExA)
1774
1775 #undef GET_PROC
1776 }
1777
1778 static const char *get_winpos_flags(UINT flags)
1779 {
1780 static char buffer[300];
1781
1782 buffer[0] = 0;
1783 #define DUMP(flag) do { if (flags & flag) { strcat( buffer, "|" #flag ); flags &= ~flag; } } while(0)
1784 DUMP( SWP_SHOWWINDOW );
1785 DUMP( SWP_HIDEWINDOW );
1786 DUMP( SWP_NOACTIVATE );
1787 DUMP( SWP_FRAMECHANGED );
1788 DUMP( SWP_NOCOPYBITS );
1789 DUMP( SWP_NOOWNERZORDER );
1790 DUMP( SWP_NOSENDCHANGING );
1791 DUMP( SWP_DEFERERASE );
1792 DUMP( SWP_ASYNCWINDOWPOS );
1793 DUMP( SWP_NOZORDER );
1794 DUMP( SWP_NOREDRAW );
1795 DUMP( SWP_NOSIZE );
1796 DUMP( SWP_NOMOVE );
1797 DUMP( SWP_NOCLIENTSIZE );
1798 DUMP( SWP_NOCLIENTMOVE );
1799 if (flags) sprintf(buffer + strlen(buffer),"|0x%04x", flags);
1800 return buffer + 1;
1801 #undef DUMP
1802 }
1803
1804 static BOOL ignore_message( UINT message )
1805 {
1806 /* these are always ignored */
1807 return (message >= 0xc000 ||
1808 message == WM_GETICON ||
1809 message == WM_GETOBJECT ||
1810 message == WM_TIMECHANGE ||
1811 message == WM_DISPLAYCHANGE ||
1812 message == WM_DEVICECHANGE ||
1813 message == WM_DWMNCRENDERINGCHANGED);
1814 }
1815
1816
1817 #define add_message(msg) add_message_(__LINE__,msg);
1818 static void add_message_(int line, const struct recvd_message *msg)
1819 {
1820 struct recvd_message *seq;
1821
1822 EnterCriticalSection( &sequence_cs );
1823 if (!sequence)
1824 {
1825 sequence_size = 10;
1826 sequence = HeapAlloc( GetProcessHeap(), 0, sequence_size * sizeof(*sequence) );
1827 }
1828 if (sequence_cnt == sequence_size)
1829 {
1830 sequence_size *= 2;
1831 sequence = HeapReAlloc( GetProcessHeap(), 0, sequence, sequence_size * sizeof(*sequence) );
1832 }
1833 assert(sequence);
1834
1835 seq = &sequence[sequence_cnt++];
1836 seq->hwnd = msg->hwnd;
1837 seq->message = msg->message;
1838 seq->flags = msg->flags;
1839 seq->wParam = msg->wParam;
1840 seq->lParam = msg->lParam;
1841 seq->line = line;
1842 seq->descr = msg->descr;
1843 seq->output[0] = 0;
1844 LeaveCriticalSection( &sequence_cs );
1845
1846 if (msg->descr)
1847 {
1848 if (msg->flags & hook)
1849 {
1850 static const char * const CBT_code_name[10] =
1851 {
1852 "HCBT_MOVESIZE",
1853 "HCBT_MINMAX",
1854 "HCBT_QS",
1855 "HCBT_CREATEWND",
1856 "HCBT_DESTROYWND",
1857 "HCBT_ACTIVATE",
1858 "HCBT_CLICKSKIPPED",
1859 "HCBT_KEYSKIPPED",
1860 "HCBT_SYSCOMMAND",
1861 "HCBT_SETFOCUS"
1862 };
1863 const char *code_name = (msg->message <= HCBT_SETFOCUS) ? CBT_code_name[msg->message] : "Unknown";
1864
1865 sprintf( seq->output, "%s: hook %d (%s) wp %08lx lp %08lx",
1866 msg->descr, msg->message, code_name, msg->wParam, msg->lParam );
1867 }
1868 else if (msg->flags & winevent_hook)
1869 {
1870 sprintf( seq->output, "%s: winevent %p %08x %08lx %08lx",
1871 msg->descr, msg->hwnd, msg->message, msg->wParam, msg->lParam );
1872 }
1873 else
1874 {
1875 switch (msg->message)
1876 {
1877 case WM_WINDOWPOSCHANGING:
1878 case WM_WINDOWPOSCHANGED:
1879 {
1880 WINDOWPOS *winpos = (WINDOWPOS *)msg->lParam;
1881
1882 sprintf( seq->output, "%s: %p WM_WINDOWPOS%s wp %08lx lp %08lx after %p x %d y %d cx %d cy %d flags %s",
1883 msg->descr, msg->hwnd,
1884 (msg->message == WM_WINDOWPOSCHANGING) ? "CHANGING" : "CHANGED",
1885 msg->wParam, msg->lParam, winpos->hwndInsertAfter,
1886 winpos->x, winpos->y, winpos->cx, winpos->cy,
1887 get_winpos_flags(winpos->flags) );
1888
1889 /* Log only documented flags, win2k uses 0x1000 and 0x2000
1890 * in the high word for internal purposes
1891 */
1892 seq->wParam = winpos->flags & 0xffff;
1893 /* We are not interested in the flags that don't match under XP and Win9x */
1894 seq->wParam &= ~SWP_NOZORDER;
1895 break;
1896 }
1897
1898 case WM_DRAWITEM:
1899 {
1900 DRAW_ITEM_STRUCT di;
1901 DRAWITEMSTRUCT *dis = (DRAWITEMSTRUCT *)msg->lParam;
1902
1903 sprintf( seq->output, "%s: %p WM_DRAWITEM: type %x, ctl_id %x, item_id %x, action %x, state %x",
1904 msg->descr, msg->hwnd, dis->CtlType, dis->CtlID,
1905 dis->itemID, dis->itemAction, dis->itemState);
1906
1907 di.u.lp = 0;
1908 di.u.item.type = dis->CtlType;
1909 di.u.item.ctl_id = dis->CtlID;
1910 if (dis->CtlType == ODT_LISTBOX ||
1911 dis->CtlType == ODT_COMBOBOX ||
1912 dis->CtlType == ODT_MENU)
1913 di.u.item.item_id = dis->itemID;
1914 di.u.item.action = dis->itemAction;
1915 di.u.item.state = dis->itemState;
1916
1917 seq->lParam = di.u.lp;
1918 break;
1919 }
1920 default:
1921 if (msg->message >= 0xc000) return; /* ignore registered messages */
1922 sprintf( seq->output, "%s: %p %04x wp %08lx lp %08lx",
1923 msg->descr, msg->hwnd, msg->message, msg->wParam, msg->lParam );
1924 }
1925 if (msg->flags & (sent|posted|parent|defwinproc|beginpaint))
1926 sprintf( seq->output + strlen(seq->output), " (flags %x)", msg->flags );
1927 }
1928 }
1929 }
1930
1931 /* try to make sure pending X events have been processed before continuing */
1932 static void flush_events(void)
1933 {
1934 MSG msg;
1935 int diff = 200;
1936 int min_timeout = 100;
1937 DWORD time = GetTickCount() + diff;
1938
1939 while (diff > 0)
1940 {
1941 if (MsgWaitForMultipleObjects( 0, NULL, FALSE, min_timeout, QS_ALLINPUT ) == WAIT_TIMEOUT) break;
1942 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
1943 diff = time - GetTickCount();
1944 }
1945 }
1946
1947 static void flush_sequence(void)
1948 {
1949 EnterCriticalSection( &sequence_cs );
1950 HeapFree(GetProcessHeap(), 0, sequence);
1951 sequence = 0;
1952 sequence_cnt = sequence_size = 0;
1953 LeaveCriticalSection( &sequence_cs );
1954 }
1955
1956 static void dump_sequence(const struct message *expected, const char *context, const char *file, int line)
1957 {
1958 const struct recvd_message *actual = sequence;
1959 unsigned int count = 0;
1960
1961 trace_(file, line)("Failed sequence %s:\n", context );
1962 while (expected->message && actual->message)
1963 {
1964 if (actual->output[0])
1965 {
1966 if (expected->flags & hook)
1967 {
1968 trace_(file, line)( " %u: expected: hook %04x - actual: %s\n",
1969 count, expected->message, actual->output );
1970 }
1971 else if (expected->flags & winevent_hook)
1972 {
1973 trace_(file, line)( " %u: expected: winevent %04x - actual: %s\n",
1974 count, expected->message, actual->output );
1975 }
1976 else if (expected->flags & kbd_hook)
1977 {
1978 trace_(file, line)( " %u: expected: kbd %04x - actual: %s\n",
1979 count, expected->message, actual->output );
1980 }
1981 else
1982 {
1983 trace_(file, line)( " %u: expected: msg %04x - actual: %s\n",
1984 count, expected->message, actual->output );
1985 }
1986 }
1987
1988 if (expected->message == actual->message)
1989 {
1990 if ((expected->flags & defwinproc) != (actual->flags & defwinproc) &&
1991 (expected->flags & optional))
1992 {
1993 /* don't match messages if their defwinproc status differs */
1994 expected++;
1995 }
1996 else
1997 {
1998 expected++;
1999 actual++;
2000 }
2001 }
2002 /* silently drop winevent messages if there is no support for them */
2003 else if ((expected->flags & optional) || ((expected->flags & winevent_hook) && !hEvent_hook))
2004 expected++;
2005 else
2006 {
2007 expected++;
2008 actual++;
2009 }
2010 count++;
2011 }
2012
2013 /* optional trailing messages */
2014 while (expected->message && ((expected->flags & optional) ||
2015 ((expected->flags & winevent_hook) && !hEvent_hook)))
2016 {
2017 trace_(file, line)( " %u: expected: msg %04x - actual: nothing\n", count, expected->message );
2018 expected++;
2019 count++;
2020 }
2021
2022 if (expected->message)
2023 {
2024 trace_(file, line)( " %u: expected: msg %04x - actual: nothing\n", count, expected->message );
2025 return;
2026 }
2027
2028 while (actual->message && actual->output[0])
2029 {
2030 trace_(file, line)( " %u: expected: nothing - actual: %s\n", count, actual->output );
2031 actual++;
2032 count++;
2033 }
2034 }
2035
2036 #define ok_sequence( exp, contx, todo) \
2037 ok_sequence_( (exp), (contx), (todo), __FILE__, __LINE__)
2038
2039
2040 static void ok_sequence_(const struct message *expected_list, const char *context, BOOL todo,
2041 const char *file, int line)
2042 {
2043 static const struct recvd_message end_of_sequence;
2044 const struct message *expected = expected_list;
2045 const struct recvd_message *actual;
2046 int failcount = 0, dump = 0;
2047 unsigned int count = 0;
2048
2049 add_message(&end_of_sequence);
2050
2051 actual = sequence;
2052
2053 while (expected->message && actual->message)
2054 {
2055 if (expected->message == actual->message &&
2056 !((expected->flags ^ actual->flags) & (hook|winevent_hook|kbd_hook)))
2057 {
2058 if (expected->flags & wparam)
2059 {
2060 if (((expected->wParam ^ actual->wParam) & ~expected->wp_mask) && todo)
2061 {
2062 todo_wine {
2063 failcount ++;
2064 if (strcmp(winetest_platform, "wine")) dump++;
2065 ok_( file, line) (FALSE,
2066 "%s: %u: in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
2067 context, count, expected->message, expected->wParam, actual->wParam);
2068 }
2069 }
2070 else
2071 {
2072 ok_( file, line)( ((expected->wParam ^ actual->wParam) & ~expected->wp_mask) == 0,
2073 "%s: %u: in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
2074 context, count, expected->message, expected->wParam, actual->wParam);
2075 if ((expected->wParam ^ actual->wParam) & ~expected->wp_mask) dump++;
2076 }
2077
2078 }
2079 if (expected->flags & lparam)
2080 {
2081 if (((expected->lParam ^ actual->lParam) & ~expected->lp_mask) && todo)
2082 {
2083 todo_wine {
2084 failcount ++;
2085 if (strcmp(winetest_platform, "wine")) dump++;
2086 ok_( file, line) (FALSE,
2087 "%s: %u: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
2088 context, count, expected->message, expected->lParam, actual->lParam);
2089 }
2090 }
2091 else
2092 {
2093 ok_( file, line)(((expected->lParam ^ actual->lParam) & ~expected->lp_mask) == 0,
2094 "%s: %u: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
2095 context, count, expected->message, expected->lParam, actual->lParam);
2096 if ((expected->lParam ^ actual->lParam) & ~expected->lp_mask) dump++;
2097 }
2098 }
2099 if ((expected->flags & optional) &&
2100 ((expected->flags ^ actual->flags) & (defwinproc|parent)))
2101 {
2102 /* don't match optional messages if their defwinproc or parent status differs */
2103 expected++;
2104 count++;
2105 continue;
2106 }
2107 if ((expected->flags & defwinproc) != (actual->flags & defwinproc) && todo)
2108 {
2109 todo_wine {
2110 failcount ++;
2111 if (strcmp(winetest_platform, "wine")) dump++;
2112 ok_( file, line) (FALSE,
2113 "%s: %u: the msg 0x%04x should %shave been sent by DefWindowProc\n",
2114 context, count, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
2115 }
2116 }
2117 else
2118 {
2119 ok_( file, line) ((expected->flags & defwinproc) == (actual->flags & defwinproc),
2120 "%s: %u: the msg 0x%04x should %shave been sent by DefWindowProc\n",
2121 context, count, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
2122 if ((expected->flags & defwinproc) != (actual->flags & defwinproc)) dump++;
2123 }
2124
2125 ok_( file, line) ((expected->flags & beginpaint) == (actual->flags & beginpaint),
2126 "%s: %u: the msg 0x%04x should %shave been sent by BeginPaint\n",
2127 context, count, expected->message, (expected->flags & beginpaint) ? "" : "NOT ");
2128 if ((expected->flags & beginpaint) != (actual->flags & beginpaint)) dump++;
2129
2130 ok_( file, line) ((expected->flags & (sent|posted)) == (actual->flags & (sent|posted)),
2131 "%s: %u: the msg 0x%04x should have been %s\n",
2132 context, count, expected->message, (expected->flags & posted) ? "posted" : "sent");
2133 if ((expected->flags & (sent|posted)) != (actual->flags & (sent|posted))) dump++;
2134
2135 ok_( file, line) ((expected->flags & parent) == (actual->flags & parent),
2136 "%s: %u: the msg 0x%04x was expected in %s\n",
2137 context, count, expected->message, (expected->flags & parent) ? "parent" : "child");
2138 if ((expected->flags & parent) != (actual->flags & parent)) dump++;
2139
2140 ok_( file, line) ((expected->flags & hook) == (actual->flags & hook),
2141 "%s: %u: the msg 0x%04x should have been sent by a hook\n",
2142 context, count, expected->message);
2143 if ((expected->flags & hook) != (actual->flags & hook)) dump++;
2144
2145 ok_( file, line) ((expected->flags & winevent_hook) == (actual->flags & winevent_hook),
2146 "%s: %u: the msg 0x%04x should have been sent by a winevent hook\n",
2147 context, count, expected->message);
2148 if ((expected->flags & winevent_hook) != (actual->flags & winevent_hook)) dump++;
2149
2150 ok_( file, line) ((expected->flags & kbd_hook) == (actual->flags & kbd_hook),
2151 "%s: %u: the msg 0x%04x should have been sent by a keyboard hook\n",
2152 context, count, expected->message);
2153 if ((expected->flags & kbd_hook) != (actual->flags & kbd_hook)) dump++;
2154
2155 expected++;
2156 actual++;
2157 }
2158 /* silently drop hook messages if there is no support for them */
2159 else if ((expected->flags & optional) ||
2160 ((expected->flags & hook) && !hCBT_hook) ||
2161 ((expected->flags & winevent_hook) && !hEvent_hook) ||
2162 ((expected->flags & kbd_hook) && !hKBD_hook))
2163 expected++;
2164 else if (todo)
2165 {
2166 failcount++;
2167 todo_wine {
2168 if (strcmp(winetest_platform, "wine")) dump++;
2169 ok_( file, line) (FALSE, "%s: %u: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
2170 context, count, expected->message, actual->message);
2171 }
2172 goto done;
2173 }
2174 else
2175 {
2176 ok_( file, line) (FALSE, "%s: %u: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
2177 context, count, expected->message, actual->message);
2178 dump++;
2179 expected++;
2180 actual++;
2181 }
2182 count++;
2183 }
2184
2185 /* skip all optional trailing messages */
2186 while (expected->message && ((expected->flags & optional) ||
2187 ((expected->flags & hook) && !hCBT_hook) ||
2188 ((expected->flags & winevent_hook) && !hEvent_hook)))
2189 expected++;
2190
2191 if (todo)
2192 {
2193 todo_wine {
2194 if (expected->message || actual->message) {
2195 failcount++;
2196 if (strcmp(winetest_platform, "wine")) dump++;
2197 ok_( file, line) (FALSE, "%s: %u: the msg sequence is not complete: expected %04x - actual %04x\n",
2198 context, count, expected->message, actual->message);
2199 }
2200 }
2201 }
2202 else
2203 {
2204 if (expected->message || actual->message)
2205 {
2206 dump++;
2207 ok_( file, line) (FALSE, "%s: %u: the msg sequence is not complete: expected %04x - actual %04x\n",
2208 context, count, expected->message, actual->message);
2209 }
2210 }
2211 if( todo && !failcount) /* succeeded yet marked todo */
2212 todo_wine {
2213 if (!strcmp(winetest_platform, "wine")) dump++;
2214 ok_( file, line)( TRUE, "%s: marked \"todo_wine\" but succeeds\n", context);
2215 }
2216
2217 done:
2218 if (dump) dump_sequence(expected_list, context, file, line);
2219 flush_sequence();
2220 }
2221
2222 #define expect(EXPECTED,GOT) ok((GOT)==(EXPECTED), "Expected %d, got %d\n", (EXPECTED), (GOT))
2223
2224 /******************************** MDI test **********************************/
2225
2226 /* CreateWindow for MDI frame window, initially visible */
2227 static const struct message WmCreateMDIframeSeq[] = {
2228 { HCBT_CREATEWND, hook },
2229 { WM_GETMINMAXINFO, sent },
2230 { WM_NCCREATE, sent },
2231 { WM_NCCALCSIZE, sent|wparam, 0 },
2232 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
2233 { WM_CREATE, sent },
2234 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2235 { WM_NOTIFYFORMAT, sent|optional },
2236 { WM_QUERYUISTATE, sent|optional },
2237 { WM_WINDOWPOSCHANGING, sent|optional },
2238 { WM_GETMINMAXINFO, sent|optional },
2239 { WM_NCCALCSIZE, sent|optional },
2240 { WM_WINDOWPOSCHANGED, sent|optional },
2241 { WM_SHOWWINDOW, sent|wparam, 1 },
2242 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2243 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2244 { HCBT_ACTIVATE, hook },
2245 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
2246 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
2247 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* XP */
2248 { WM_ACTIVATEAPP, sent|wparam|optional, 1 }, /* Win9x doesn't send it */
2249 { WM_NCACTIVATE, sent },
2250 { WM_GETTEXT, sent|defwinproc|optional },
2251 { WM_ACTIVATE, sent|wparam, 1 },
2252 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* Win9x */
2253 { HCBT_SETFOCUS, hook },
2254 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2255 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
2256 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2257 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
2258 /* Win9x adds SWP_NOZORDER below */
2259 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2260 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP */
2261 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
2262 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2263 { WM_MOVE, sent },
2264 { 0 }
2265 };
2266 /* DestroyWindow for MDI frame window, initially visible */
2267 static const struct message WmDestroyMDIframeSeq[] = {
2268 { HCBT_DESTROYWND, hook },
2269 { 0x0090, sent|optional },
2270 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2271 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2272 { WM_NCACTIVATE, sent|wparam|optional, 0 }, /* Win9x */
2273 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2274 { WM_NCACTIVATE, sent|wparam|optional, 0 }, /* XP */
2275 { WM_ACTIVATE, sent|wparam|optional, 0 }, /* Win9x */
2276 { WM_ACTIVATEAPP, sent|wparam|optional, 0 }, /* Win9x */
2277 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
2278 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2279 { WM_DESTROY, sent },
2280 { WM_NCDESTROY, sent },
2281 { 0 }
2282 };
2283 /* CreateWindow for MDI client window, initially visible */
2284 static const struct message WmCreateMDIclientSeq[] = {
2285 { HCBT_CREATEWND, hook },
2286 { WM_NCCREATE, sent },
2287 { WM_NCCALCSIZE, sent|wparam, 0 },
2288 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
2289 { WM_CREATE, sent },
2290 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
2291 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2292 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2293 { WM_MOVE, sent },
2294 { WM_PARENTNOTIFY, sent|wparam, WM_CREATE }, /* in MDI frame */
2295 { WM_SHOWWINDOW, sent|wparam, 1 },
2296 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2297 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2298 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2299 { 0 }
2300 };
2301 /* ShowWindow(SW_SHOW) for MDI client window */
2302 static const struct message WmShowMDIclientSeq[] = {
2303 { WM_SHOWWINDOW, sent|wparam, 1 },
2304 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2305 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2306 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2307 { 0 }
2308 };
2309 /* ShowWindow(SW_HIDE) for MDI client window */
2310 static const struct message WmHideMDIclientSeq[] = {
2311 { WM_SHOWWINDOW, sent|wparam, 0 },
2312 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2313 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|optional, 0, 0 }, /* win2000 */
2314 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP */
2315 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2316 { 0 }
2317 };
2318 /* DestroyWindow for MDI client window, initially visible */
2319 static const struct message WmDestroyMDIclientSeq[] = {
2320 { HCBT_DESTROYWND, hook },
2321 { 0x0090, sent|optional },
2322 { WM_PARENTNOTIFY, sent|wparam, WM_DESTROY }, /* in MDI frame */
2323 { WM_SHOWWINDOW, sent|wparam, 0 },
2324 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2325 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2326 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2327 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2328 { WM_DESTROY, sent },
2329 { WM_NCDESTROY, sent },
2330 { 0 }
2331 };
2332 /* CreateWindow for MDI child window, initially visible */
2333 static const struct message WmCreateMDIchildVisibleSeq[] = {
2334 { HCBT_CREATEWND, hook },
2335 { WM_NCCREATE, sent },
2336 { WM_NCCALCSIZE, sent|wparam, 0 },
2337 { WM_CREATE, sent },
2338 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2339 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2340 { WM_MOVE, sent },
2341 /* Win2k sends wparam set to
2342 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2343 * while Win9x doesn't bother to set child window id according to
2344 * CLIENTCREATESTRUCT.idFirstChild
2345 */
2346 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2347 { WM_SHOWWINDOW, sent|wparam, 1 },
2348 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2349 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2350 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2351 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
2352 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2353 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2354 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2355
2356 /* Win9x: message sequence terminates here. */
2357
2358 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2359 { HCBT_SETFOCUS, hook }, /* in MDI client */
2360 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2361 { WM_IME_NOTIFY, sent|wparam|optional, 2 }, /* in MDI client */
2362 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2363 { WM_SETFOCUS, sent }, /* in MDI client */
2364 { HCBT_SETFOCUS, hook },
2365 { WM_KILLFOCUS, sent }, /* in MDI client */
2366 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2367 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2368 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2369 { WM_SETFOCUS, sent|defwinproc },
2370 { WM_MDIACTIVATE, sent|defwinproc },
2371 { 0 }
2372 };
2373 /* WM_CHILDACTIVATE sent to disabled window */
2374 static const struct message WmChildActivateDisabledWindowSeq[] = {
2375 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2376 { 0 }
2377 };
2378 /* WM_CHILDACTIVATE sent to enabled window */
2379 static const struct message WmChildActivateWindowSeq[] = {
2380 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2381 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 },
2382 { WM_MDIACTIVATE, sent|defwinproc },
2383 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2384 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2385 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2386 { HCBT_SETFOCUS, hook },
2387 { WM_KILLFOCUS, sent|defwinproc },
2388 { WM_SETFOCUS, sent },
2389 { HCBT_SETFOCUS, hook },
2390 { WM_KILLFOCUS, sent },
2391 { WM_SETFOCUS, sent|defwinproc },
2392 { WM_MDIACTIVATE, sent|defwinproc },
2393 { 0 }
2394 };
2395 /* CreateWindow for MDI child window with invisible parent */
2396 static const struct message WmCreateMDIchildInvisibleParentSeq[] = {
2397 { HCBT_CREATEWND, hook },
2398 { WM_GETMINMAXINFO, sent },
2399 { WM_NCCREATE, sent },
2400 { WM_NCCALCSIZE, sent|wparam, 0 },
2401 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
2402 { WM_CREATE, sent },
2403 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2404 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2405 { WM_MOVE, sent },
2406 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2407 { WM_SHOWWINDOW, sent|wparam, 1 },
2408 { WM_MDIREFRESHMENU, sent }, /* in MDI client */
2409 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2410 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2411 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2412
2413 /* Win9x: message sequence terminates here. */
2414
2415 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2416 { HCBT_SETFOCUS, hook }, /* in MDI client */
2417 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2418 { WM_IME_NOTIFY, sent|wparam|optional, 2 }, /* in MDI client */
2419 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2420 { WM_SETFOCUS, sent }, /* in MDI client */
2421 { HCBT_SETFOCUS, hook },
2422 { WM_KILLFOCUS, sent }, /* in MDI client */
2423 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2424 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2425 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2426 { WM_SETFOCUS, sent|defwinproc },
2427 { WM_MDIACTIVATE, sent|defwinproc },
2428 { 0 }
2429 };
2430 /* DestroyWindow for MDI child window, initially visible */
2431 static const struct message WmDestroyMDIchildVisibleSeq[] = {
2432 { HCBT_DESTROYWND, hook },
2433 /* Win2k sends wparam set to
2434 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
2435 * while Win9x doesn't bother to set child window id according to
2436 * CLIENTCREATESTRUCT.idFirstChild
2437 */
2438 { 0x0090, sent|optional },
2439 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
2440 { WM_SHOWWINDOW, sent|wparam, 0 },
2441 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2442 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2443 { WM_ERASEBKGND, sent|parent|optional },
2444 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2445
2446 /* { WM_DESTROY, sent }
2447 * Win9x: message sequence terminates here.
2448 */
2449
2450 { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
2451 { WM_KILLFOCUS, sent },
2452 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2453 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2454 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2455 { WM_SETFOCUS, sent }, /* in MDI client */
2456
2457 { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
2458 { WM_KILLFOCUS, sent }, /* in MDI client */
2459 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2460 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2461 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2462 { WM_SETFOCUS, sent }, /* in MDI client */
2463
2464 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2465
2466 { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
2467 { WM_KILLFOCUS, sent },
2468 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2469 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2470 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2471 { WM_SETFOCUS, sent }, /* in MDI client */
2472
2473 { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
2474 { WM_KILLFOCUS, sent }, /* in MDI client */
2475 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2476 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2477 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2478 { WM_SETFOCUS, sent }, /* in MDI client */
2479
2480 { WM_DESTROY, sent },
2481
2482 { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
2483 { WM_KILLFOCUS, sent },
2484 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2485 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2486 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2487 { WM_SETFOCUS, sent }, /* in MDI client */
2488
2489 { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
2490 { WM_KILLFOCUS, sent }, /* in MDI client */
2491 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2492 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2493 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2494 { WM_SETFOCUS, sent }, /* in MDI client */
2495
2496 { WM_NCDESTROY, sent },
2497 { 0 }
2498 };
2499 /* CreateWindow for MDI child window, initially invisible */
2500 static const struct message WmCreateMDIchildInvisibleSeq[] = {
2501 { HCBT_CREATEWND, hook },
2502 { WM_NCCREATE, sent },
2503 { WM_NCCALCSIZE, sent|wparam, 0 },
2504 { WM_CREATE, sent },
2505 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2506 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2507 { WM_MOVE, sent },
2508 /* Win2k sends wparam set to
2509 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2510 * while Win9x doesn't bother to set child window id according to
2511 * CLIENTCREATESTRUCT.idFirstChild
2512 */
2513 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2514 { 0 }
2515 };
2516 /* DestroyWindow for MDI child window, initially invisible */
2517 static const struct message WmDestroyMDIchildInvisibleSeq[] = {
2518 { HCBT_DESTROYWND, hook },
2519 /* Win2k sends wparam set to
2520 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
2521 * while Win9x doesn't bother to set child window id according to
2522 * CLIENTCREATESTRUCT.idFirstChild
2523 */
2524 { 0x0090, sent|optional },
2525 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
2526 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2527 { WM_DESTROY, sent },
2528 { WM_NCDESTROY, sent },
2529 /* FIXME: Wine destroys an icon/title window while Windows doesn't */
2530 { WM_PARENTNOTIFY, sent|wparam|optional, WM_DESTROY }, /* MDI client */
2531 { 0 }
2532 };
2533 /* CreateWindow for the 1st MDI child window, initially visible and maximized */
2534 static const struct message WmCreateMDIchildVisibleMaxSeq1[] = {
2535 { HCBT_CREATEWND, hook },
2536 { WM_NCCREATE, sent },
2537 { WM_NCCALCSIZE, sent|wparam, 0 },
2538 { WM_CREATE, sent },
2539 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2540 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2541 { WM_MOVE, sent },
2542 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2543 { WM_GETMINMAXINFO, sent },
2544 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
2545 { WM_NCCALCSIZE, sent|wparam, 1 },
2546 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2547 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2548 /* in MDI frame */
2549 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2550 { WM_NCCALCSIZE, sent|wparam, 1 },
2551 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2552 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2553 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2554 /* Win2k sends wparam set to
2555 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2556 * while Win9x doesn't bother to set child window id according to
2557 * CLIENTCREATESTRUCT.idFirstChild
2558 */
2559 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2560 { WM_SHOWWINDOW, sent|wparam, 1 },
2561 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2562 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2563 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2564 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
2565 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2566 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2567 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE, 0, SWP_FRAMECHANGED },
2568
2569 /* Win9x: message sequence terminates here. */
2570
2571 { WM_NCACTIVATE, sent|wparam|defwinproc|optional, 1 },
2572 { HCBT_SETFOCUS, hook|optional }, /* in MDI client */
2573 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2574 { WM_IME_NOTIFY, sent|wparam|optional, 2 }, /* in MDI client */
2575 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2576 { WM_SETFOCUS, sent|optional }, /* in MDI client */
2577 { HCBT_SETFOCUS, hook|optional },
2578 { WM_KILLFOCUS, sent|optional }, /* in MDI client */
2579 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2580 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2581 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2582 { WM_SETFOCUS, sent|defwinproc|optional },
2583 { WM_MDIACTIVATE, sent|defwinproc|optional },
2584 /* in MDI frame */
2585 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2586 { WM_NCCALCSIZE, sent|wparam, 1 },
2587 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2588 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2589 { 0 }
2590 };
2591 /* CreateWindow for the 2nd MDI child window, initially visible and maximized */
2592 static const struct message WmCreateMDIchildVisibleMaxSeq2[] = {
2593 /* restore the 1st MDI child */
2594 { WM_SETREDRAW, sent|wparam, 0 },
2595 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNORMAL },
2596 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
2597 { WM_NCCALCSIZE, sent|wparam, 1 },
2598 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2599 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2600 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2601 /* in MDI frame */
2602 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2603 { WM_NCCALCSIZE, sent|wparam, 1 },
2604 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2605 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2606 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2607 { WM_SETREDRAW, sent|wparam, 1 }, /* in the 1st MDI child */
2608 /* create the 2nd MDI child */
2609 { HCBT_CREATEWND, hook },
2610 { WM_NCCREATE, sent },
2611 { WM_NCCALCSIZE, sent|wparam, 0 },
2612 { WM_CREATE, sent },
2613 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2614 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2615 { WM_MOVE, sent },
2616 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2617 { WM_GETMINMAXINFO, sent },
2618 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
2619 { WM_NCCALCSIZE, sent|wparam, 1 },
2620 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2621 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2622 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2623 /* in MDI frame */
2624 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2625 { WM_NCCALCSIZE, sent|wparam, 1 },
2626 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2627 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2628 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2629 /* Win2k sends wparam set to
2630 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2631 * while Win9x doesn't bother to set child window id according to
2632 * CLIENTCREATESTRUCT.idFirstChild
2633 */
2634 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2635 { WM_SHOWWINDOW, sent|wparam, 1 },
2636 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2637 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2638 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2639 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
2640 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2641 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2642
2643 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
2644 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
2645
2646 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2647
2648 /* Win9x: message sequence terminates here. */
2649
2650 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2651 { HCBT_SETFOCUS, hook },
2652 { WM_KILLFOCUS, sent|defwinproc|optional }, /* in the 1st MDI child */
2653 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 }, /* in the 1st MDI child */
2654 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2655 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2656 { WM_SETFOCUS, sent }, /* in MDI client */
2657 { HCBT_SETFOCUS, hook },
2658 { WM_KILLFOCUS, sent }, /* in MDI client */
2659 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2660 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2661 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2662 { WM_SETFOCUS, sent|defwinproc },
2663
2664 { WM_MDIACTIVATE, sent|defwinproc },
2665 /* in MDI frame */
2666 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2667 { WM_NCCALCSIZE, sent|wparam, 1 },
2668 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2669 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2670 { 0 }
2671 };
2672 /* WM_MDICREATE MDI child window, initially visible and maximized */
2673 static const struct message WmCreateMDIchildVisibleMaxSeq3[] = {
2674 { WM_MDICREATE, sent },
2675 { HCBT_CREATEWND, hook },
2676 { WM_NCCREATE, sent },
2677 { WM_NCCALCSIZE, sent|wparam, 0 },
2678 { WM_CREATE, sent },
2679 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2680 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2681 { WM_MOVE, sent },
2682 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2683 { WM_GETMINMAXINFO, sent },
2684 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
2685 { WM_NCCALCSIZE, sent|wparam, 1 },
2686 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2687 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2688
2689 /* in MDI frame */
2690 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2691 { WM_NCCALCSIZE, sent|wparam, 1 },
2692 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2693 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2694 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2695
2696 /* Win2k sends wparam set to
2697 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2698 * while Win9x doesn't bother to set child window id according to
2699 * CLIENTCREATESTRUCT.idFirstChild
2700 */
2701 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2702 { WM_SHOWWINDOW, sent|wparam, 1 },
2703 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2704
2705 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2706
2707 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2708 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
2709 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2710
2711 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2712 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2713
2714 /* Win9x: message sequence terminates here. */
2715
2716 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2717 { WM_SETFOCUS, sent|optional }, /* in MDI client */
2718 { HCBT_SETFOCUS, hook }, /* in MDI client */
2719 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2720 { WM_IME_NOTIFY, sent|wparam|optional, 2 },
2721 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
2722 { WM_SETFOCUS, sent|optional }, /* in MDI client */
2723 { HCBT_SETFOCUS, hook|optional },
2724 { WM_KILLFOCUS, sent }, /* in MDI client */
2725 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2726 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2727 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2728 { WM_SETFOCUS, sent|defwinproc },
2729
2730 { WM_MDIACTIVATE, sent|defwinproc },
2731
2732 /* in MDI child */
2733 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2734 { WM_NCCALCSIZE, sent|wparam, 1 },
2735 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2736 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
2737
2738 /* in MDI frame */
2739 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2740 { WM_NCCALCSIZE, sent|wparam, 1 },
2741 { 0x0093, sent|defwinproc|optional },
2742 { 0x0093, sent|defwinproc|optional },
2743 { 0x0093, sent|defwinproc|optional },
2744 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2745 { WM_MOVE, sent|defwinproc },
2746 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2747
2748 /* in MDI client */
2749 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2750 { WM_NCCALCSIZE, sent|wparam, 1 },
2751 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2752 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2753
2754 /* in MDI child */
2755 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2756 { WM_NCCALCSIZE, sent|wparam, 1 },
2757 { 0x0093, sent|optional },
2758 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2759 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2760
2761 { 0x0093, sent|optional },
2762 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2763 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2764 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP sends it to MDI frame */
2765 { 0x0093, sent|defwinproc|optional },
2766 { 0x0093, sent|defwinproc|optional },
2767 { 0x0093, sent|defwinproc|optional },
2768 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2769 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
2770
2771 { 0 }
2772 };
2773 /* CreateWindow for the 1st MDI child window, initially invisible and maximized */
2774 static const struct message WmCreateMDIchildInvisibleMaxSeq4[] = {
2775 { HCBT_CREATEWND, hook },
2776 { WM_GETMINMAXINFO, sent },
2777 { WM_NCCREATE, sent },
2778 { WM_NCCALCSIZE, sent|wparam, 0 },
2779 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
2780 { WM_CREATE, sent },
2781 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2782 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2783 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE, 0, SWP_NOZORDER }, /* MDI frame */
2784 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* MDI frame */
2785 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE, 0, SWP_NOZORDER }, /* MDI frame */
2786 { WM_MOVE, sent },
2787 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2788 { WM_GETMINMAXINFO, sent },
2789 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
2790 { WM_GETMINMAXINFO, sent|defwinproc },
2791 { WM_NCCALCSIZE, sent|wparam, 1 },
2792 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_STATECHANGED },
2793 { WM_MOVE, sent|defwinproc },
2794 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2795 /* in MDI frame */
2796 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2797 { WM_NCCALCSIZE, sent|wparam, 1 },
2798 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2799 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2800 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* MDI child */
2801 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2802 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2803 /* Win2k sends wparam set to
2804 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2805 * while Win9x doesn't bother to set child window id according to
2806 * CLIENTCREATESTRUCT.idFirstChild
2807 */
2808 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2809 { 0 }
2810 };
2811 /* WM_SYSCOMMAND/SC_CLOSE for the 2nd MDI child window, initially visible and maximized */
2812 static const struct message WmDestroyMDIchildVisibleMaxSeq2[] = {
2813 { WM_SYSCOMMAND, sent|wparam, SC_CLOSE },
2814 { HCBT_SYSCOMMAND, hook },
2815 { WM_CLOSE, sent|defwinproc },
2816 { WM_MDIDESTROY, sent }, /* in MDI client */
2817
2818 /* bring the 1st MDI child to top */
2819 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE }, /* in the 1st MDI child */
2820 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE }, /* in the 2nd MDI child */
2821
2822 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2823
2824 { WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 }, /* in the 1st MDI child */
2825 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
2826 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
2827
2828 /* maximize the 1st MDI child */
2829 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2830 { WM_GETMINMAXINFO, sent|defwinproc },
2831 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_STATECHANGED },
2832 { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
2833 { WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 },
2834 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2835 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2836
2837 /* restore the 2nd MDI child */
2838 { WM_SETREDRAW, sent|defwinproc|wparam, 0 },
2839 { HCBT_MINMAX, hook|lparam, 0, SW_NORMALNA },
2840 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_STATECHANGED },
2841 { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
2842
2843 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2844
2845 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2846 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2847
2848 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2849
2850 { WM_SETREDRAW, sent|defwinproc|wparam, 1 },
2851 /* in MDI frame */
2852 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2853 { WM_NCCALCSIZE, sent|wparam, 1 },
2854 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2855 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2856 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2857
2858 /* bring the 1st MDI child to top */
2859 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2860 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2861 { HCBT_SETFOCUS, hook },
2862 { WM_KILLFOCUS, sent|defwinproc },
2863 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
2864 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2865 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2866 { WM_SETFOCUS, sent }, /* in MDI client */
2867 { HCBT_SETFOCUS, hook },
2868 { WM_KILLFOCUS, sent }, /* in MDI client */
2869 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2870 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2871 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2872 { WM_SETFOCUS, sent|defwinproc },
2873 { WM_MDIACTIVATE, sent|defwinproc },
2874 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2875
2876 /* apparently ShowWindow(SW_SHOW) on an MDI client */
2877 { WM_SHOWWINDOW, sent|wparam, 1 },
2878 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2879 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2880 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2881 { WM_MDIREFRESHMENU, sent },
2882
2883 { HCBT_DESTROYWND, hook },
2884 /* Win2k sends wparam set to
2885 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
2886 * while Win9x doesn't bother to set child window id according to
2887 * CLIENTCREATESTRUCT.idFirstChild
2888 */
2889 { 0x0090, sent|defwinproc|optional },
2890 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
2891 { WM_SHOWWINDOW, sent|defwinproc|wparam, 0 },
2892 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2893 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2894 { WM_ERASEBKGND, sent|parent|optional },
2895 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2896
2897 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2898 { WM_DESTROY, sent|defwinproc },
2899 { WM_NCDESTROY, sent|defwinproc },
2900 { 0 }
2901 };
2902 /* WM_MDIDESTROY for the single MDI child window, initially visible and maximized */
2903 static const struct message WmDestroyMDIchildVisibleMaxSeq1[] = {
2904 { WM_MDIDESTROY, sent }, /* in MDI client */
2905 { WM_SHOWWINDOW, sent|wparam, 0 },
2906 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2907 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2908 { WM_ERASEBKGND, sent|parent|optional },
2909 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2910
2911 { HCBT_SETFOCUS, hook },
2912 { WM_KILLFOCUS, sent },
2913 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2914 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2915 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2916 { WM_SETFOCUS, sent }, /* in MDI client */
2917 { HCBT_SETFOCUS, hook },
2918 { WM_KILLFOCUS, sent }, /* in MDI client */
2919 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2920 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2921 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2922 { WM_SETFOCUS, sent },
2923
2924 /* in MDI child */
2925 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2926 { WM_NCCALCSIZE, sent|wparam, 1 },
2927 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2928 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2929
2930 /* in MDI frame */
2931 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2932 { WM_NCCALCSIZE, sent|wparam, 1 },
2933 { 0x0093, sent|defwinproc|optional },
2934 { 0x0093, sent|defwinproc|optional },
2935 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2936 { WM_MOVE, sent|defwinproc },
2937 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2938
2939 /* in MDI client */
2940 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2941 { WM_NCCALCSIZE, sent|wparam, 1 },
2942 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2943 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2944
2945 /* in MDI child */
2946 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2947 { WM_NCCALCSIZE, sent|wparam, 1 },
2948 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
2949 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2950
2951 /* in MDI child */
2952 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2953 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2954 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2955 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2956
2957 /* in MDI frame */
2958 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2959 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2960 { 0x0093, sent|defwinproc|optional },
2961 { 0x0093, sent|defwinproc|optional },
2962 { 0x0093, sent|defwinproc|optional },
2963 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2964 { WM_MOVE, sent|defwinproc },
2965 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2966
2967 /* in MDI client */
2968 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2969 { WM_NCCALCSIZE, sent|wparam, 1 },
2970 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2971 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2972
2973 /* in MDI child */
2974 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE },
2975 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2976 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
2977 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2978 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2979 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2980
2981 { 0x0093, sent|defwinproc|optional },
2982 { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 }, /* XP sends it to MDI frame */
2983 { 0x0093, sent|defwinproc|optional },
2984 { 0x0093, sent|defwinproc|optional },
2985 { 0x0093, sent|defwinproc|optional },
2986 { 0x0093, sent|optional },
2987
2988 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2989 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2990 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2991 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2992 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
2993
2994 /* in MDI frame */
2995 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2996 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
2997 { 0x0093, sent|defwinproc|optional },
2998 { 0x0093, sent|defwinproc|optional },
2999 { 0x0093, sent|defwinproc|optional },
3000 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3001 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
3002 { 0x0093, sent|optional },
3003
3004 { WM_NCACTIVATE, sent|wparam, 0 },
3005 { WM_MDIACTIVATE, sent },
3006
3007 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNORMAL },
3008 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_STATECHANGED },
3009 { WM_NCCALCSIZE, sent|wparam, 1 },
3010
3011 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
3012
3013 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3014 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3015 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3016
3017 /* in MDI child */
3018 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3019 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
3020 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3021 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3022
3023 /* in MDI frame */
3024 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3025 { WM_NCCALCSIZE, sent|wparam, 1 },
3026 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3027 { WM_MOVE, sent|defwinproc },
3028 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3029
3030 /* in MDI client */
3031 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
3032 { WM_NCCALCSIZE, sent|wparam, 1 },
3033 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
3034 { WM_SIZE, sent|wparam, SIZE_RESTORED },
3035 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3036 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP */
3037 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
3038 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
3039 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
3040
3041 { HCBT_SETFOCUS, hook },
3042 { WM_KILLFOCUS, sent },
3043 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
3044 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3045 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3046 { WM_SETFOCUS, sent }, /* in MDI client */
3047
3048 { WM_MDIREFRESHMENU, sent }, /* in MDI client */
3049
3050 { HCBT_DESTROYWND, hook },
3051 /* Win2k sends wparam set to
3052 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
3053 * while Win9x doesn't bother to set child window id according to
3054 * CLIENTCREATESTRUCT.idFirstChild
3055 */
3056 { 0x0090, sent|optional },
3057 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
3058
3059 { WM_SHOWWINDOW, sent|wparam, 0 },
3060 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3061 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
3062 { WM_ERASEBKGND, sent|parent|optional },
3063 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3064
3065 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
3066 { WM_DESTROY, sent },
3067 { WM_NCDESTROY, sent },
3068 { 0 }
3069 };
3070 /* ShowWindow(SW_MAXIMIZE) for a not visible MDI child window */
3071 static const struct message WmMaximizeMDIchildInvisibleSeq[] = {
3072 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
3073 { WM_GETMINMAXINFO, sent },
3074 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
3075 { WM_NCCALCSIZE, sent|wparam, 1 },
3076 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
3077 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3078
3079 { WM_WINDOWPOSCHANGING, sent|wparam|optional|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3080 { WM_NCACTIVATE, sent|wparam|optional|defwinproc, 1 },
3081 { HCBT_SETFOCUS, hook|optional },
3082 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3083 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3084 { WM_SETFOCUS, sent|optional }, /* in MDI client */
3085 { HCBT_SETFOCUS, hook|optional },
3086 { WM_KILLFOCUS, sent|optional }, /* in MDI client */
3087 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
3088 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
3089 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3090 { WM_SETFOCUS, sent|optional|defwinproc },
3091 { WM_MDIACTIVATE, sent|optional|defwinproc },
3092 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3093 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3094 /* in MDI frame */
3095 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3096 { WM_NCCALCSIZE, sent|wparam, 1 },
3097 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3098 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
3099 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3100 { 0 }
3101 };
3102 /* ShowWindow(SW_MAXIMIZE) for a not visible maximized MDI child window */
3103 static const struct message WmMaximizeMDIchildInvisibleSeq2[] = {
3104 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
3105 { WM_GETMINMAXINFO, sent },
3106 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED },
3107 { WM_GETMINMAXINFO, sent|defwinproc },
3108 { WM_NCCALCSIZE, sent|wparam, 1 },
3109 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
3110 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3111
3112 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3113 { WM_NCACTIVATE, sent|wparam|defwinproc|optional, 1 },
3114 { HCBT_SETFOCUS, hook|optional },
3115 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3116 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3117 { WM_SETFOCUS, sent|optional }, /* in MDI client */
3118 { HCBT_SETFOCUS, hook|optional },
3119 { WM_KILLFOCUS, sent|optional }, /* in MDI client */
3120 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
3121 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
3122 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3123 { WM_SETFOCUS, sent|defwinproc|optional },
3124 { WM_MDIACTIVATE, sent|defwinproc|optional },
3125 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3126 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3127 { 0 }
3128 };
3129 /* WM_MDIMAXIMIZE for an MDI child window with invisible parent */
3130 static const struct message WmMaximizeMDIchildInvisibleParentSeq[] = {
3131 { WM_MDIMAXIMIZE, sent }, /* in MDI client */
3132 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
3133 { WM_GETMINMAXINFO, sent },
3134 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
3135 { WM_GETMINMAXINFO, sent|defwinproc },
3136 { WM_NCCALCSIZE, sent|wparam, 1 },
3137 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP doesn't send it */
3138 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3139 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_STATECHANGED },
3140 { WM_MOVE, sent|defwinproc },
3141 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3142
3143 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3144 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
3145 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3146 { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 },
3147 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
3148 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI client XP */
3149 /* in MDI frame */
3150 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3151 { WM_NCCALCSIZE, sent|wparam, 1 },
3152 { 0x0093, sent|defwinproc|optional },
3153 { 0x0094, sent|defwinproc|optional },
3154 { 0x0094, sent|defwinproc|optional },
3155 { 0x0094, sent|defwinproc|optional },
3156 { 0x0094, sent|defwinproc|optional },
3157 { 0x0093, sent|defwinproc|optional },
3158 { 0x0093, sent|defwinproc|optional },
3159 { 0x0091, sent|defwinproc|optional },
3160 { 0x0092, sent|defwinproc|optional },
3161 { 0x0092, sent|defwinproc|optional },
3162 { 0x0092, sent|defwinproc|optional },
3163 { 0x0092, sent|defwinproc|optional },
3164 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3165 { WM_MOVE, sent|defwinproc },
3166 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3167 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame win2000 */
3168 /* in MDI client */
3169 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
3170 { WM_NCCALCSIZE, sent|wparam, 1 },
3171 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
3172 { WM_SIZE, sent|wparam, SIZE_RESTORED },
3173 /* in MDI child */
3174 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE },
3175 { WM_GETMINMAXINFO, sent|defwinproc },
3176 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
3177 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
3178 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3179 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child win2000 */
3180 { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 },
3181 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
3182 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
3183 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI client XP */
3184 /* in MDI frame */
3185 { 0x0093, sent|optional },
3186 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
3187 { 0x0093, sent|defwinproc|optional },
3188 { 0x0093, sent|defwinproc|optional },
3189 { 0x0093, sent|defwinproc|optional },
3190 { 0x0091, sent|defwinproc|optional },
3191 { 0x0092, sent|defwinproc|optional },
3192 { 0x0092, sent|defwinproc|optional },
3193 { 0x0092, sent|defwinproc|optional },
3194 { 0x0092, sent|defwinproc|optional },
3195 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame XP */
3196 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame XP */
3197 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
3198 { 0 }
3199 };
3200 /* ShowWindow(SW_MAXIMIZE) for a visible MDI child window */
3201 static const struct message WmMaximizeMDIchildVisibleSeq[] = {
3202 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
3203 { WM_GETMINMAXINFO, sent },
3204 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
3205 { WM_NCCALCSIZE, sent|wparam, 1 },
3206 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3207 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3208 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3209 /* in MDI frame */
3210 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3211 { WM_NCCALCSIZE, sent|wparam, 1 },
3212 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3213 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
3214 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3215 { 0 }
3216 };
3217 /* ShowWindow(SW_RESTORE) for a visible maximized MDI child window */
3218 static const struct message WmRestoreMDIchildVisibleSeq[] = {
3219 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
3220 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
3221 { WM_NCCALCSIZE, sent|wparam, 1 },
3222 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3223 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3224 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3225 /* in MDI frame */
3226 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3227 { WM_NCCALCSIZE, sent|wparam, 1 },
3228 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3229 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
3230 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3231 { 0 }
3232 };
3233 /* ShowWindow(SW_RESTORE) for a visible minimized MDI child window */
3234 static const struct message WmRestoreMDIchildVisibleSeq_2[] = {
3235 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
3236 { WM_QUERYOPEN, sent|wparam|lparam, 0, 0 },
3237 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
3238 { WM_NCCALCSIZE, sent|wparam, 1 },
3239 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3240 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
3241 { WM_MOVE, sent|defwinproc },
3242 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3243 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3244 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3245 { HCBT_SETFOCUS, hook },
3246 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
3247 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
3248 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3249 { WM_SETFOCUS, sent },
3250 { 0 }
3251 };
3252 /* ShowWindow(SW_MINIMIZE) for a visible restored MDI child window */
3253 static const struct message WmMinimizeMDIchildVisibleSeq[] = {
3254 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
3255 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_STATECHANGED },
3256 { WM_NCCALCSIZE, sent|wparam, 1 },
3257 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_STATECHANGED },
3258 { WM_MOVE, sent|defwinproc },
3259 { WM_SIZE, sent|defwinproc|wparam|lparam, SIZE_MINIMIZED, 0 },
3260 { WM_CHILDACTIVATE, sent|wparam|lparam|defwinproc, 0, 0 },
3261 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3262 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3263 /* FIXME: Wine creates an icon/title window while Windows doesn't */
3264 { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE }, /* MDI client */
3265 { 0 }
3266 };
3267 /* ShowWindow(SW_RESTORE) for a not visible MDI child window */
3268 static const struct message WmRestoreMDIchildInvisibleSeq[] = {
3269 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
3270 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
3271 { WM_NCCALCSIZE, sent|wparam, 1 },
3272 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
3273 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3274 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3275 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3276 /* in MDI frame */
3277 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3278 { WM_NCCALCSIZE, sent|wparam, 1 },
3279 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3280 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
3281 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
3282 { 0 }
3283 };
3284
3285 static HWND mdi_client;
3286 static WNDPROC old_mdi_client_proc;
3287
3288 static LRESULT WINAPI mdi_client_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3289 {
3290 struct recvd_message msg;
3291
3292 /* do not log painting messages */
3293 if (message != WM_PAINT &&
3294 message != WM_NCPAINT &&
3295 message != WM_SYNCPAINT &&
3296 message != WM_ERASEBKGND &&
3297 message != WM_NCHITTEST &&
3298 message != WM_GETTEXT &&
3299 message != WM_MDIGETACTIVE &&
3300 !ignore_message( message ))
3301 {
3302 msg.hwnd = hwnd;
3303 msg.message = message;
3304 msg.flags = sent|wparam|lparam;
3305 msg.wParam = wParam;
3306 msg.lParam = lParam;
3307 msg.descr = "mdi client";
3308 add_message(&msg);
3309 }
3310
3311 return CallWindowProcA(old_mdi_client_proc, hwnd, message, wParam, lParam);
3312 }
3313
3314 static LRESULT WINAPI mdi_child_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3315 {
3316 static LONG defwndproc_counter = 0;
3317 LRESULT ret;
3318 struct recvd_message msg;
3319
3320 /* do not log painting messages */
3321 if (message != WM_PAINT &&
3322 message != WM_NCPAINT &&
3323 message != WM_SYNCPAINT &&
3324 message != WM_ERASEBKGND &&
3325 message != WM_NCHITTEST &&
3326 message != WM_GETTEXT &&
3327 !ignore_message( message ))
3328 {
3329 switch (message)
3330 {
3331 case WM_MDIACTIVATE:
3332 {
3333 HWND active, client = GetParent(hwnd);
3334
3335 active = (HWND)SendMessageA(client, WM_MDIGETACTIVE, 0, 0);
3336
3337 if (hwnd == (HWND)lParam) /* if we are being activated */
3338 ok (active == (HWND)lParam, "new active %p != active %p\n", (HWND)lParam, active);
3339 else
3340 ok (active == (HWND)wParam, "old active %p != active %p\n", (HWND)wParam, active);
3341 break;
3342 }
3343 }
3344
3345 msg.hwnd = hwnd;
3346 msg.message = message;
3347 msg.flags = sent|wparam|lparam;
3348 if (defwndproc_counter) msg.flags |= defwinproc;
3349 msg.wParam = wParam;
3350 msg.lParam = lParam;
3351 msg.descr = "mdi child";
3352 add_message(&msg);
3353 }
3354
3355 defwndproc_counter++;
3356 ret = DefMDIChildProcA(hwnd, message, wParam, lParam);
3357 defwndproc_counter--;
3358
3359 return ret;
3360 }
3361
3362 static LRESULT WINAPI mdi_frame_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3363 {
3364 static LONG defwndproc_counter = 0;
3365 LRESULT ret;
3366 struct recvd_message msg;
3367
3368 /* do not log painting messages */
3369 if (message != WM_PAINT &&
3370 message != WM_NCPAINT &&
3371 message != WM_SYNCPAINT &&
3372 message != WM_ERASEBKGND &&
3373 message != WM_NCHITTEST &&
3374 message != WM_GETTEXT &&
3375 !ignore_message( message ))
3376 {
3377 msg.hwnd = hwnd;
3378 msg.message = message;
3379 msg.flags = sent|wparam|lparam;
3380 if (defwndproc_counter) msg.flags |= defwinproc;
3381 msg.wParam = wParam;
3382 msg.lParam = lParam;
3383 msg.descr = "mdi frame";
3384 add_message(&msg);
3385 }
3386
3387 defwndproc_counter++;
3388 ret = DefFrameProcA(hwnd, mdi_client, message, wParam, lParam);
3389 defwndproc_counter--;
3390
3391 return ret;
3392 }
3393
3394 static BOOL mdi_RegisterWindowClasses(void)
3395 {
3396 WNDCLASSA cls;
3397
3398 cls.style = 0;
3399 cls.lpfnWndProc = mdi_frame_wnd_proc;
3400 cls.cbClsExtra = 0;
3401 cls.cbWndExtra = 0;
3402 cls.hInstance = GetModuleHandleA(0);
3403 cls.hIcon = 0;
3404 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
3405 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
3406 cls.lpszMenuName = NULL;
3407 cls.lpszClassName = "MDI_frame_class";
3408 if (!RegisterClassA(&cls)) return FALSE;
3409
3410 cls.lpfnWndProc = mdi_child_wnd_proc;
3411 cls.lpszClassName = "MDI_child_class";
3412 if (!RegisterClassA(&cls)) return FALSE;
3413
3414 if (!GetClassInfoA(0, "MDIClient", &cls)) assert(0);
3415 old_mdi_client_proc = cls.lpfnWndProc;
3416 cls.hInstance = GetModuleHandleA(0);
3417 cls.lpfnWndProc = mdi_client_hook_proc;
3418 cls.lpszClassName = "MDI_client_class";
3419 if (!RegisterClassA(&cls)) assert(0);
3420
3421 return TRUE;
3422 }
3423
3424 static void test_mdi_messages(void)
3425 {
3426 MDICREATESTRUCTA mdi_cs;
3427 CLIENTCREATESTRUCT client_cs;
3428 HWND mdi_frame, mdi_child, mdi_child2, active_child;
3429 BOOL zoomed;
3430 RECT rc;
3431 HMENU hMenu = CreateMenu();
3432 LONG val;
3433
3434 if (!mdi_RegisterWindowClasses()) assert(0);
3435
3436 flush_sequence();
3437
3438 trace("creating MDI frame window\n");
3439 mdi_frame = CreateWindowExA(0, "MDI_frame_class", "MDI frame window",
3440 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
3441 WS_MAXIMIZEBOX | WS_VISIBLE,
3442 100, 100, CW_USEDEFAULT, CW_USEDEFAULT,
3443 GetDesktopWindow(), hMenu,
3444 GetModuleHandleA(0), NULL);
3445 assert(mdi_frame);
3446 ok_sequence(WmCreateMDIframeSeq, "Create MDI frame window", FALSE);
3447
3448 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3449 ok(GetFocus() == mdi_frame, "wrong focus window %p\n", GetFocus());
3450
3451 trace("creating MDI client window\n");
3452 GetClientRect(mdi_frame, &rc);
3453 client_cs.hWindowMenu = 0;
3454 client_cs.idFirstChild = MDI_FIRST_CHILD_ID;
3455 mdi_client = CreateWindowExA(0, "MDI_client_class",
3456 NULL,
3457 WS_CHILD | WS_VISIBLE | MDIS_ALLCHILDSTYLES,
3458 rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top,
3459 mdi_frame, 0, GetModuleHandleA(0), &client_cs);
3460 assert(mdi_client);
3461 SetWindowLongA(mdi_client, 0, 0xdeadbeef);
3462
3463 ok_sequence(WmCreateMDIclientSeq, "Create visible MDI client window", FALSE);
3464 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3465 ok(GetFocus() == mdi_frame, "input focus should be on MDI frame not on %p\n", GetFocus());
3466
3467 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3468 ok(!active_child, "wrong active MDI child %p\n", active_child);
3469 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3470
3471 SetFocus(0);
3472 flush_sequence();
3473
3474 trace("creating invisible MDI child window\n");
3475 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3476 WS_CHILD,
3477 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3478 mdi_client, 0, GetModuleHandleA(0), NULL);
3479 assert(mdi_child);
3480
3481 flush_sequence();
3482 ShowWindow(mdi_child, SW_SHOWNORMAL);
3483 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOWNORMAL) MDI child window", FALSE);
3484
3485 ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3486 ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
3487
3488 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3489 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3490
3491 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3492 ok(!active_child, "wrong active MDI child %p\n", active_child);
3493 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3494
3495 ShowWindow(mdi_child, SW_HIDE);
3496 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE) MDI child window", FALSE);
3497 flush_sequence();
3498
3499 ShowWindow(mdi_child, SW_SHOW);
3500 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW) MDI child window", FALSE);
3501
3502 ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3503 ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
3504
3505 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3506 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3507
3508 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3509 ok(!active_child, "wrong active MDI child %p\n", active_child);
3510 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3511
3512 DestroyWindow(mdi_child);
3513 flush_sequence();
3514
3515 trace("creating visible MDI child window\n");
3516 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3517 WS_CHILD | WS_VISIBLE,
3518 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3519 mdi_client, 0, GetModuleHandleA(0), NULL);
3520 assert(mdi_child);
3521 ok_sequence(WmCreateMDIchildVisibleSeq, "Create visible MDI child window", FALSE);
3522
3523 ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3524 ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
3525
3526 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3527 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3528
3529 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3530 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3531 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3532 flush_sequence();
3533
3534 DestroyWindow(mdi_child);
3535 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
3536
3537 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3538 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3539
3540 /* Win2k: MDI client still returns a just destroyed child as active
3541 * Win9x: MDI client returns 0
3542 */
3543 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3544 ok(active_child == mdi_child || /* win2k */
3545 !active_child, /* win9x */
3546 "wrong active MDI child %p\n", active_child);
3547 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3548
3549 flush_sequence();
3550
3551 trace("creating invisible MDI child window\n");
3552 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3553 WS_CHILD,
3554 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3555 mdi_client, 0, GetModuleHandleA(0), NULL);
3556 assert(mdi_child2);
3557 ok_sequence(WmCreateMDIchildInvisibleSeq, "Create invisible MDI child window", FALSE);
3558
3559 ok(!(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE), "MDI child should not be visible\n");
3560 ok(!IsWindowVisible(mdi_child2), "MDI child should not be visible\n");
3561
3562 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3563 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3564
3565 /* Win2k: MDI client still returns a just destroyed child as active
3566 * Win9x: MDI client returns mdi_child2
3567 */
3568 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3569 ok(active_child == mdi_child || /* win2k */
3570 active_child == mdi_child2, /* win9x */
3571 "wrong active MDI child %p\n", active_child);
3572 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3573 flush_sequence();
3574
3575 ShowWindow(mdi_child2, SW_MAXIMIZE);
3576 ok_sequence(WmMaximizeMDIchildInvisibleSeq, "ShowWindow(SW_MAXIMIZE):invisible MDI child", FALSE);
3577
3578 ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3579 ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
3580
3581 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3582 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3583 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3584 flush_sequence();
3585
3586 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3587 ok(GetFocus() == mdi_child2 || /* win2k */
3588 GetFocus() == 0, /* win9x */
3589 "wrong focus window %p\n", GetFocus());
3590
3591 SetFocus(0);
3592 flush_sequence();
3593
3594 ShowWindow(mdi_child2, SW_HIDE);
3595 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
3596
3597 ShowWindow(mdi_child2, SW_RESTORE);
3598 ok_sequence(WmRestoreMDIchildInvisibleSeq, "ShowWindow(SW_RESTORE):invisible MDI child", FALSE);
3599 flush_sequence();
3600
3601 ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3602 ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
3603
3604 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3605 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3606 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3607 flush_sequence();
3608
3609 SetFocus(0);
3610 flush_sequence();
3611
3612 ShowWindow(mdi_child2, SW_HIDE);
3613 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
3614
3615 ShowWindow(mdi_child2, SW_SHOW);
3616 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):MDI child", FALSE);
3617
3618 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3619 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3620
3621 ShowWindow(mdi_child2, SW_MAXIMIZE);
3622 ok_sequence(WmMaximizeMDIchildVisibleSeq, "ShowWindow(SW_MAXIMIZE):MDI child", FALSE);
3623
3624 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3625 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3626
3627 ShowWindow(mdi_child2, SW_RESTORE);
3628 ok_sequence(WmRestoreMDIchildVisibleSeq, "ShowWindow(SW_RESTORE):maximized MDI child", FALSE);
3629
3630 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3631 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3632
3633 ShowWindow(mdi_child2, SW_MINIMIZE);
3634 ok_sequence(WmMinimizeMDIchildVisibleSeq, "ShowWindow(SW_MINIMIZE):MDI child", TRUE);
3635
3636 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3637 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3638
3639 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3640 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3641 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3642 flush_sequence();
3643
3644 ShowWindow(mdi_child2, SW_RESTORE);
3645 ok_sequence(WmRestoreMDIchildVisibleSeq_2, "ShowWindow(SW_RESTORE):minimized MDI child", FALSE);
3646
3647 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3648 ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
3649
3650 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3651 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3652 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3653 flush_sequence();
3654
3655 SetFocus(0);
3656 flush_sequence();
3657
3658 ShowWindow(mdi_child2, SW_HIDE);
3659 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
3660
3661 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3662 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3663
3664 DestroyWindow(mdi_child2);
3665 ok_sequence(WmDestroyMDIchildInvisibleSeq, "Destroy invisible MDI child window", FALSE);
3666
3667 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3668 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3669
3670 trace("Testing WM_CHILDACTIVATE\n");
3671
3672 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3673 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_DISABLED,
3674 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3675 mdi_client, 0, GetModuleHandleA(0), NULL);
3676
3677 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3678 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX,
3679 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3680 mdi_client, 0, GetModuleHandleA(0), NULL);
3681
3682 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3683 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3684 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3685
3686 flush_sequence();
3687 SendMessageW(mdi_child, WM_CHILDACTIVATE, 0, 0);
3688 ok_sequence(WmChildActivateDisabledWindowSeq, "WM_CHILDACTIVATE sent to disabled window", FALSE);
3689
3690 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3691 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3692 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3693 flush_sequence();
3694
3695 EnableWindow(mdi_child, TRUE);
3696
3697 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3698 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3699 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3700
3701 flush_sequence();
3702 SendMessageW(mdi_child, WM_CHILDACTIVATE, 0, 0);
3703 ok_sequence(WmChildActivateWindowSeq, "WM_CHILDACTIVATE sent to enabled window", FALSE);
3704
3705 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3706 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3707 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3708 flush_sequence();
3709
3710 DestroyWindow(mdi_child);
3711 DestroyWindow(mdi_child2);
3712 flush_sequence();
3713
3714 /* test for maximized MDI children */
3715 trace("creating maximized visible MDI child window 1\n");
3716 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3717 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3718 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3719 mdi_client, 0, GetModuleHandleA(0), NULL);
3720 assert(mdi_child);
3721 ok_sequence(WmCreateMDIchildVisibleMaxSeq1, "Create maximized visible 1st MDI child window", TRUE);
3722 ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
3723
3724 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3725 ok(GetFocus() == mdi_child || /* win2k */
3726 GetFocus() == 0, /* win9x */
3727 "wrong focus window %p\n", GetFocus());
3728
3729 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3730 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3731 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3732 flush_sequence();
3733
3734 trace("creating maximized visible MDI child window 2\n");
3735 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3736 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3737 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3738 mdi_client, 0, GetModuleHandleA(0), NULL);
3739 assert(mdi_child2);
3740 ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
3741 ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
3742 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
3743
3744 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3745 ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
3746
3747 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3748 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3749 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3750 flush_sequence();
3751
3752 trace("destroying maximized visible MDI child window 2\n");
3753 DestroyWindow(mdi_child2);
3754 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
3755
3756 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
3757
3758 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3759 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3760
3761 /* Win2k: MDI client still returns a just destroyed child as active
3762 * Win9x: MDI client returns 0
3763 */
3764 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3765 ok(active_child == mdi_child2 || /* win2k */
3766 !active_child, /* win9x */
3767 "wrong active MDI child %p\n", active_child);
3768 flush_sequence();
3769
3770 ShowWindow(mdi_child, SW_MAXIMIZE);
3771 ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
3772 flush_sequence();
3773
3774 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3775 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3776
3777 trace("re-creating maximized visible MDI child window 2\n");
3778 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3779 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3780 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3781 mdi_client, 0, GetModuleHandleA(0), NULL);
3782 assert(mdi_child2);
3783 ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
3784 ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
3785 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
3786
3787 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3788 ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
3789
3790 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3791 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3792 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3793 flush_sequence();
3794
3795 SendMessageA(mdi_child2, WM_SYSCOMMAND, SC_CLOSE, 0);
3796 ok_sequence(WmDestroyMDIchildVisibleMaxSeq2, "WM_SYSCOMMAND/SC_CLOSE on a visible maximized MDI child window", TRUE);
3797 ok(!IsWindow(mdi_child2), "MDI child 2 should be destroyed\n");
3798
3799 ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
3800 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3801 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3802
3803 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3804 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3805 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3806 flush_sequence();
3807
3808 DestroyWindow(mdi_child);
3809 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
3810
3811 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3812 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3813
3814 /* Win2k: MDI client still returns a just destroyed child as active
3815 * Win9x: MDI client returns 0
3816 */
3817 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3818 ok(active_child == mdi_child || /* win2k */
3819 !active_child, /* win9x */
3820 "wrong active MDI child %p\n", active_child);
3821 flush_sequence();
3822
3823 trace("creating maximized invisible MDI child window\n");
3824 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3825 WS_CHILD | WS_MAXIMIZE | WS_CAPTION | WS_THICKFRAME,
3826 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3827 mdi_client, 0, GetModuleHandleA(0), NULL);
3828 assert(mdi_child2);
3829 ok_sequence(WmCreateMDIchildInvisibleMaxSeq4, "Create maximized invisible MDI child window", FALSE);
3830 ok(IsZoomed(mdi_child2), "MDI child should be maximized\n");
3831 ok(!(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE), "MDI child should be not visible\n");
3832 ok(!IsWindowVisible(mdi_child2), "MDI child should be not visible\n");
3833
3834 /* Win2k: MDI client still returns a just destroyed child as active
3835 * Win9x: MDI client returns 0
3836 */
3837 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3838 ok(active_child == mdi_child || /* win2k */
3839 !active_child || active_child == mdi_child2, /* win9x */
3840 "wrong active MDI child %p\n", active_child);
3841 flush_sequence();
3842
3843 trace("call ShowWindow(mdi_child, SW_MAXIMIZE)\n");
3844 ShowWindow(mdi_child2, SW_MAXIMIZE);
3845 ok_sequence(WmMaximizeMDIchildInvisibleSeq2, "ShowWindow(SW_MAXIMIZE):invisible maximized MDI child", FALSE);
3846 ok(IsZoomed(mdi_child2), "MDI child should be maximized\n");
3847 ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3848 ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
3849
3850 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3851 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3852 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3853 flush_sequence();
3854
3855 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child2, 0);
3856 flush_sequence();
3857
3858 /* end of test for maximized MDI children */
3859 SetFocus(0);
3860 flush_sequence();
3861 trace("creating maximized visible MDI child window 1(Switch test)\n");
3862 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3863 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3864 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3865 mdi_client, 0, GetModuleHandleA(0), NULL);
3866 assert(mdi_child);
3867 ok_sequence(WmCreateMDIchildVisibleMaxSeq1, "Create maximized visible 1st MDI child window(Switch test)", TRUE);
3868 ok(IsZoomed(mdi_child), "1st MDI child should be maximized(Switch test)\n");
3869
3870 ok(GetActiveWindow() == mdi_frame, "wrong active window %p(Switch test)\n", GetActiveWindow());
3871 ok(GetFocus() == mdi_child || /* win2k */
3872 GetFocus() == 0, /* win9x */
3873 "wrong focus window %p(Switch test)\n", GetFocus());
3874
3875 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3876 ok(active_child == mdi_child, "wrong active MDI child %p(Switch test)\n", active_child);
3877 ok(zoomed, "wrong zoomed state %d(Switch test)\n", zoomed);
3878 flush_sequence();
3879
3880 trace("creating maximized visible MDI child window 2(Switch test)\n");
3881 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3882 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3883 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3884 mdi_client, 0, GetModuleHandleA(0), NULL);
3885 assert(mdi_child2);
3886 ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child window (Switch test)", TRUE);
3887
3888 ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized(Switch test)\n");
3889 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized(Switch test)\n");
3890
3891 ok(GetActiveWindow() == mdi_frame, "wrong active window %p(Switch test)\n", GetActiveWindow());
3892 ok(GetFocus() == mdi_child2, "wrong focus window %p(Switch test)\n", GetFocus());
3893
3894 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3895 ok(active_child == mdi_child2, "wrong active MDI child %p(Switch test)\n", active_child);
3896 ok(zoomed, "wrong zoomed state %d(Switch test)\n", zoomed);
3897 flush_sequence();
3898
3899 trace("Switch child window.\n");
3900 SendMessageA(mdi_client, WM_MDIACTIVATE, (WPARAM)mdi_child, 0);
3901 ok_sequence(WmSwitchChild, "Child did not switch correctly", TRUE);
3902 trace("end of test for switch maximized MDI children\n");
3903 flush_sequence();
3904
3905 /* Prepare for switching test of not maximized MDI children */
3906 ShowWindow( mdi_child, SW_NORMAL );
3907 ok(!IsZoomed(mdi_child), "wrong zoomed state for %p(Switch test)\n", mdi_child);
3908 ok(!IsZoomed(mdi_child2), "wrong zoomed state for %p(Switch test)\n", mdi_child2);
3909 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, 0);
3910 ok(active_child == mdi_child, "wrong active MDI child %p(Switch test)\n", active_child);
3911 flush_sequence();
3912
3913 SendMessageA(mdi_client, WM_MDIACTIVATE, (WPARAM)mdi_child2, 0);
3914 ok_sequence(WmSwitchNotMaximizedChild, "Not maximized child did not switch correctly", FALSE);
3915 trace("end of test for switch not maximized MDI children\n");
3916 flush_sequence();
3917
3918 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child, 0);
3919 flush_sequence();
3920
3921 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child2, 0);
3922 flush_sequence();
3923
3924 SetFocus(0);
3925 flush_sequence();
3926 /* end of tests for switch maximized/not maximized MDI children */
3927
3928 mdi_cs.szClass = "MDI_child_Class";
3929 mdi_cs.szTitle = "MDI child";
3930 mdi_cs.hOwner = GetModuleHandleA(0);
3931 mdi_cs.x = 0;
3932 mdi_cs.y = 0;
3933 mdi_cs.cx = CW_USEDEFAULT;
3934 mdi_cs.cy = CW_USEDEFAULT;
3935 mdi_cs.style = WS_CHILD | WS_SYSMENU | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE;
3936 mdi_cs.lParam = 0;
3937 mdi_child = (HWND)SendMessageA(mdi_client, WM_MDICREATE, 0, (LPARAM)&mdi_cs);
3938 ok(mdi_child != 0, "MDI child creation failed\n");
3939 ok_sequence(WmCreateMDIchildVisibleMaxSeq3, "WM_MDICREATE for maximized visible MDI child window", TRUE);
3940
3941 ok(GetMenuItemID(hMenu, GetMenuItemCount(hMenu) - 1) == SC_CLOSE, "SC_CLOSE menu item not found\n");
3942
3943 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3944 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3945
3946 ok(IsZoomed(mdi_child), "MDI child should be maximized\n");
3947 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3948 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3949
3950 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3951 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3952 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3953 flush_sequence();
3954
3955 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child, 0);
3956 ok_sequence(WmDestroyMDIchildVisibleMaxSeq1, "Destroy visible maximized MDI child window", TRUE);
3957
3958 ok(!IsWindow(mdi_child), "MDI child should be destroyed\n");
3959 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3960 ok(!active_child, "wrong active MDI child %p\n", active_child);
3961
3962 SetFocus(0);
3963 flush_sequence();
3964
3965 val = GetWindowLongA(mdi_client, 0);
3966 ok(val == 0xdeadbeef || broken(val == 0) /* >= Win Vista */, "Expected 0xdeadbeef, got 0x%x\n", val);
3967 DestroyWindow(mdi_client);
3968 ok_sequence(WmDestroyMDIclientSeq, "Destroy MDI client window", FALSE);
3969
3970 /* test maximization of MDI child with invisible parent */
3971 client_cs.hWindowMenu = 0;
3972 mdi_client = CreateWindowA("MDI_client_class",
3973 NULL,
3974 WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL | WS_VISIBLE,
3975 0, 0, 660, 430,
3976 mdi_frame, 0, GetModuleHandleA(0), &client_cs);
3977 ok_sequence(WmCreateMDIclientSeq, "Create MDI client window", FALSE);
3978
3979 ShowWindow(mdi_client, SW_HIDE);
3980 ok_sequence(WmHideMDIclientSeq, "Hide MDI client window", FALSE);
3981
3982 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3983 WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL,
3984 0, 0, 650, 440,
3985 mdi_client, 0, GetModuleHandleA(0), NULL);
3986 ok_sequence(WmCreateMDIchildInvisibleParentSeq, "Create MDI child window with invisible parent", FALSE);
3987
3988 SendMessageA(mdi_client, WM_MDIMAXIMIZE, (WPARAM) mdi_child, 0);
3989 ok_sequence(WmMaximizeMDIchildInvisibleParentSeq, "Maximize MDI child window with invisible parent", TRUE);
3990 zoomed = IsZoomed(mdi_child);
3991 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3992
3993 ShowWindow(mdi_client, SW_SHOW);
3994 ok_sequence(WmShowMDIclientSeq, "Show MDI client window", FALSE);
3995
3996 DestroyWindow(mdi_child);
3997 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible maximized MDI child window", TRUE);
3998
3999 /* end of test for maximization of MDI child with invisible parent */
4000
4001 DestroyWindow(mdi_client);
4002 ok_sequence(WmDestroyMDIclientSeq, "Destroy MDI client window", FALSE);
4003
4004 DestroyWindow(mdi_frame);
4005 ok_sequence(WmDestroyMDIframeSeq, "Destroy MDI frame window", FALSE);
4006 }
4007 /************************* End of MDI test **********************************/
4008
4009 static void test_WM_SETREDRAW(HWND hwnd)
4010 {
4011 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
4012
4013 flush_events();
4014 flush_sequence();
4015
4016 SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
4017 ok_sequence(WmSetRedrawFalseSeq, "SetRedraw:FALSE", FALSE);
4018
4019 ok(!(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should NOT be set\n");
4020 ok(!IsWindowVisible(hwnd), "IsWindowVisible() should return FALSE\n");
4021
4022 flush_sequence();
4023 SendMessageA(hwnd, WM_SETREDRAW, TRUE, 0);
4024 ok_sequence(WmSetRedrawTrueSeq, "SetRedraw:TRUE", FALSE);
4025
4026 ok(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4027 ok(IsWindowVisible(hwnd), "IsWindowVisible() should return TRUE\n");
4028
4029 /* restore original WS_VISIBLE state */
4030 SetWindowLongA(hwnd, GWL_STYLE, style);
4031
4032 flush_events();
4033 flush_sequence();
4034 }
4035
4036 static INT_PTR CALLBACK TestModalDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
4037 {
4038 struct recvd_message msg;
4039
4040 if (ignore_message( message )) return 0;
4041
4042 switch (message)
4043 {
4044 /* ignore */
4045 case WM_MOUSEMOVE:
4046 case WM_NCMOUSEMOVE:
4047 case WM_NCMOUSELEAVE:
4048 case WM_SETCURSOR:
4049 return 0;
4050 case WM_NCHITTEST:
4051 return HTCLIENT;
4052 }
4053
4054 msg.hwnd = hwnd;
4055 msg.message = message;
4056 msg.flags = sent|wparam|lparam;
4057 msg.wParam = wParam;
4058 msg.lParam = lParam;
4059 msg.descr = "dialog";
4060 add_message(&msg);
4061
4062 if (message == WM_INITDIALOG) SetTimer( hwnd, 1, 100, NULL );
4063 if (message == WM_TIMER) EndDialog( hwnd, 0 );
4064 return 0;
4065 }
4066
4067 static INT_PTR CALLBACK TestModalDlgProc2(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
4068 {
4069 struct recvd_message msg;
4070
4071 if (ignore_message( message )) return 0;
4072
4073 switch (message)
4074 {
4075 /* ignore */
4076 case WM_MOUSEMOVE:
4077 case WM_NCMOUSEMOVE:
4078 case WM_NCMOUSELEAVE:
4079 case WM_SETCURSOR:
4080 return 0;
4081 case WM_NCHITTEST:
4082 return HTCLIENT;
4083 }
4084
4085 msg.hwnd = hwnd;
4086 msg.message = message;
4087 msg.flags = sent|wparam|lparam;
4088 msg.wParam = wParam;
4089 msg.lParam = lParam;
4090 msg.descr = "dialog";
4091 add_message(&msg);
4092
4093 if (message == WM_INITDIALOG) EndDialog( hwnd, 0 );
4094 return 0;
4095 }
4096
4097 static void test_hv_scroll_1(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
4098 {
4099 DWORD style, exstyle;
4100 INT xmin, xmax;
4101 BOOL ret;
4102
4103 exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
4104 style = GetWindowLongA(hwnd, GWL_STYLE);
4105 /* do not be confused by WS_DLGFRAME set */
4106 if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
4107
4108 if (clear) ok(style & clear, "style %08x should be set\n", clear);
4109 if (set) ok(!(style & set), "style %08x should not be set\n", set);
4110
4111 ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
4112 ok( ret, "SetScrollRange(%d) error %d\n", ctl, GetLastError());
4113 if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
4114 ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollRange(SB_HORZ/SB_VERT) NC", FALSE);
4115 else
4116 ok_sequence(WmSetScrollRangeHVSeq, "SetScrollRange(SB_HORZ/SB_VERT)", FALSE);
4117
4118 style = GetWindowLongA(hwnd, GWL_STYLE);
4119 if (set) ok(style & set, "style %08x should be set\n", set);
4120 if (clear) ok(!(style & clear), "style %08x should not be set\n", clear);
4121
4122 /* a subsequent call should do nothing */
4123 ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
4124 ok( ret, "SetScrollRange(%d) error %d\n", ctl, GetLastError());
4125 ok_sequence(WmEmptySeq, "SetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
4126
4127 xmin = 0xdeadbeef;
4128 xmax = 0xdeadbeef;
4129 ret = GetScrollRange(hwnd, ctl, &xmin, &xmax);
4130 ok( ret, "GetScrollRange(%d) error %d\n", ctl, GetLastError());
4131 ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
4132 ok(xmin == min, "unexpected min scroll value %d\n", xmin);
4133 ok(xmax == max, "unexpected max scroll value %d\n", xmax);
4134 }
4135
4136 static void test_hv_scroll_2(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
4137 {
4138 DWORD style, exstyle;
4139 SCROLLINFO si;
4140 BOOL ret;
4141
4142 exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
4143 style = GetWindowLongA(hwnd, GWL_STYLE);
4144 /* do not be confused by WS_DLGFRAME set */
4145 if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
4146
4147 if (clear) ok(style & clear, "style %08x should be set\n", clear);
4148 if (set) ok(!(style & set), "style %08x should not be set\n", set);
4149
4150 si.cbSize = sizeof(si);
4151 si.fMask = SIF_RANGE;
4152 si.nMin = min;
4153 si.nMax = max;
4154 SetScrollInfo(hwnd, ctl, &si, TRUE);
4155 if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
4156 ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollInfo(SB_HORZ/SB_VERT) NC", FALSE);
4157 else
4158 ok_sequence(WmSetScrollRangeHVSeq, "SetScrollInfo(SB_HORZ/SB_VERT)", FALSE);
4159
4160 style = GetWindowLongA(hwnd, GWL_STYLE);
4161 if (set) ok(style & set, "style %08x should be set\n", set);
4162 if (clear) ok(!(style & clear), "style %08x should not be set\n", clear);
4163
4164 /* a subsequent call should do nothing */
4165 SetScrollInfo(hwnd, ctl, &si, TRUE);
4166 if (style & WS_HSCROLL)
4167 ok_sequence(WmSetScrollRangeHSeq_empty, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
4168 else if (style & WS_VSCROLL)
4169 ok_sequence(WmSetScrollRangeVSeq_empty, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
4170 else
4171 ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
4172
4173 si.fMask = SIF_PAGE;
4174 si.nPage = 5;
4175 SetScrollInfo(hwnd, ctl, &si, FALSE);
4176 ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
4177
4178 si.fMask = SIF_POS;
4179 si.nPos = max - 1;
4180 SetScrollInfo(hwnd, ctl, &si, FALSE);
4181 ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
4182
4183 si.fMask = SIF_RANGE;
4184 si.nMin = 0xdeadbeef;
4185 si.nMax = 0xdeadbeef;
4186 ret = GetScrollInfo(hwnd, ctl, &si);
4187 ok( ret, "GetScrollInfo error %d\n", GetLastError());
4188 ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
4189 ok(si.nMin == min, "unexpected min scroll value %d\n", si.nMin);
4190 ok(si.nMax == max, "unexpected max scroll value %d\n", si.nMax);
4191 }
4192
4193 /* Win9x sends WM_USER+xxx while and NT versions send SBM_xxx messages */
4194 static void test_scroll_messages(HWND hwnd)
4195 {
4196 SCROLLINFO si;
4197 INT min, max;
4198 BOOL ret;
4199
4200 flush_events();
4201 flush_sequence();
4202
4203 min = 0xdeadbeef;
4204 max = 0xdeadbeef;
4205 ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
4206 ok( ret, "GetScrollRange error %d\n", GetLastError());
4207 if (sequence->message != WmGetScrollRangeSeq[0].message)
4208 trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
4209 /* values of min and max are undefined */
4210 flush_sequence();
4211
4212 ret = SetScrollRange(hwnd, SB_CTL, 10, 150, FALSE);
4213 ok( ret, "SetScrollRange error %d\n", GetLastError());
4214 if (sequence->message != WmSetScrollRangeSeq[0].message)
4215 trace("SetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
4216 flush_sequence();
4217
4218 min = 0xdeadbeef;
4219 max = 0xdeadbeef;
4220 ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
4221 ok( ret, "GetScrollRange error %d\n", GetLastError());
4222 if (sequence->message != WmGetScrollRangeSeq[0].message)
4223 trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
4224 /* values of min and max are undefined */
4225 flush_sequence();
4226
4227 si.cbSize = sizeof(si);
4228 si.fMask = SIF_RANGE;
4229 si.nMin = 20;
4230 si.nMax = 160;
4231 SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
4232 if (sequence->message != WmSetScrollRangeSeq[0].message)
4233 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
4234 flush_sequence();
4235
4236 si.fMask = SIF_PAGE;
4237 si.nPage = 10;
4238 SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
4239 if (sequence->message != WmSetScrollRangeSeq[0].message)
4240 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
4241 flush_sequence();
4242
4243 si.fMask = SIF_POS;
4244 si.nPos = 20;
4245 SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
4246 if (sequence->message != WmSetScrollRangeSeq[0].message)
4247 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
4248 flush_sequence();
4249
4250 si.fMask = SIF_RANGE;
4251 si.nMin = 0xdeadbeef;
4252 si.nMax = 0xdeadbeef;
4253 ret = GetScrollInfo(hwnd, SB_CTL, &si);
4254 ok( ret, "GetScrollInfo error %d\n", GetLastError());
4255 if (sequence->message != WmGetScrollInfoSeq[0].message)
4256 trace("GetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
4257 /* values of min and max are undefined */
4258 flush_sequence();
4259
4260 /* set WS_HSCROLL */
4261 test_hv_scroll_1(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
4262 /* clear WS_HSCROLL */
4263 test_hv_scroll_1(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
4264
4265 /* set WS_HSCROLL */
4266 test_hv_scroll_2(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
4267 /* clear WS_HSCROLL */
4268 test_hv_scroll_2(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
4269
4270 /* set WS_VSCROLL */
4271 test_hv_scroll_1(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
4272 /* clear WS_VSCROLL */
4273 test_hv_scroll_1(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
4274
4275 /* set WS_VSCROLL */
4276 test_hv_scroll_2(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
4277 /* clear WS_VSCROLL */
4278 test_hv_scroll_2(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
4279 }
4280
4281 static void test_showwindow(void)
4282 {
4283 HWND hwnd, hchild;
4284 RECT rc;
4285
4286 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
4287 100, 100, 200, 200, 0, 0, 0, NULL);
4288 ok (hwnd != 0, "Failed to create overlapped window\n");
4289 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4290 0, 0, 10, 10, hwnd, 0, 0, NULL);
4291 ok (hchild != 0, "Failed to create child\n");
4292 flush_sequence();
4293
4294 /* ShowWindow( SW_SHOWNA) for invisible top level window */
4295 trace("calling ShowWindow( SW_SHOWNA) for invisible top level window\n");
4296 ok( ShowWindow(hwnd, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
4297 ok_sequence(WmSHOWNATopInvisible, "ShowWindow(SW_SHOWNA) on invisible top level window", FALSE);
4298
4299 /* ShowWindow( SW_SHOWNA) for now visible top level window */
4300 trace("calling ShowWindow( SW_SHOWNA) for now visible top level window\n");
4301 ok( ShowWindow(hwnd, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
4302 ok_sequence(WmSHOWNATopVisible, "ShowWindow(SW_SHOWNA) on visible top level window", FALSE);
4303 /* back to invisible */
4304 ShowWindow(hchild, SW_HIDE);
4305 ShowWindow(hwnd, SW_HIDE);
4306 flush_sequence();
4307 /* ShowWindow(SW_SHOWNA) with child and parent invisible */
4308 trace("calling ShowWindow( SW_SHOWNA) for invisible child with invisible parent\n");
4309 ok( ShowWindow(hchild, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
4310 ok_sequence(WmSHOWNAChildInvisParInvis, "ShowWindow(SW_SHOWNA) invisible child and parent", FALSE);
4311 /* ShowWindow(SW_SHOWNA) with child visible and parent invisible */
4312 ok( ShowWindow(hchild, SW_SHOW) != FALSE, "ShowWindow: window was invisible\n" );
4313 flush_sequence();
4314 trace("calling ShowWindow( SW_SHOWNA) for the visible child and invisible parent\n");
4315 ok( ShowWindow(hchild, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
4316 ok_sequence(WmSHOWNAChildVisParInvis, "ShowWindow(SW_SHOWNA) visible child and invisible parent", FALSE);
4317 /* ShowWindow(SW_SHOWNA) with child visible and parent visible */
4318 ShowWindow( hwnd, SW_SHOW);
4319 flush_sequence();
4320 trace("calling ShowWindow( SW_SHOWNA) for the visible child and parent\n");
4321 ok( ShowWindow(hchild, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
4322 ok_sequence(WmSHOWNAChildVisParVis, "ShowWindow(SW_SHOWNA) for the visible child and parent", FALSE);
4323
4324 /* ShowWindow(SW_SHOWNA) with child invisible and parent visible */
4325 ShowWindow( hchild, SW_HIDE);
4326 flush_sequence();
4327 trace("calling ShowWindow( SW_SHOWNA) for the invisible child and visible parent\n");
4328 ok( ShowWindow(hchild, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
4329 ok_sequence(WmSHOWNAChildInvisParVis, "ShowWindow(SW_SHOWNA) for the invisible child and visible parent", FALSE);
4330
4331 SetCapture(hchild);
4332 ok(GetCapture() == hchild, "wrong capture window %p\n", GetCapture());
4333 DestroyWindow(hchild);
4334 ok(!GetCapture(), "wrong capture window %p\n", GetCapture());
4335
4336 DestroyWindow(hwnd);
4337 flush_sequence();
4338
4339 /* Popup windows */
4340 /* Test 1:
4341 * 1. Create invisible maximized popup window.
4342 * 2. Move and resize it.
4343 * 3. Show it maximized.
4344 */
4345 trace("calling CreateWindowExA( WS_MAXIMIZE ) for invisible maximized popup window\n");
4346 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE,
4347 100, 100, 200, 200, 0, 0, 0, NULL);
4348 ok (hwnd != 0, "Failed to create popup window\n");
4349 ok(IsZoomed(hwnd), "window should be maximized\n");
4350 ok_sequence(WmCreateInvisibleMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
4351
4352 GetWindowRect(hwnd, &rc);
4353 ok( rc.right-rc.left == GetSystemMetrics(SM_CXSCREEN) &&
4354 rc.bottom-rc.top == GetSystemMetrics(SM_CYSCREEN),
4355 "Invalid maximized size before ShowWindow (%d,%d)-(%d,%d)\n",
4356 rc.left, rc.top, rc.right, rc.bottom);
4357 /* Reset window's size & position */
4358 SetWindowPos(hwnd, 0, 10, 10, 200, 200, SWP_NOZORDER | SWP_NOACTIVATE);
4359 ok(IsZoomed(hwnd), "window should be maximized\n");
4360 flush_sequence();
4361
4362 trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for invisible maximized popup window\n");
4363 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
4364 ok(IsZoomed(hwnd), "window should be maximized\n");
4365 ok_sequence(WmShowMaxPopupResizedSeq, "ShowWindow(SW_SHOWMAXIMIZED):invisible maximized and resized popup", FALSE);
4366
4367 GetWindowRect(hwnd, &rc);
4368 ok( rc.right-rc.left == GetSystemMetrics(SM_CXSCREEN) &&
4369 rc.bottom-rc.top == GetSystemMetrics(SM_CYSCREEN),
4370 "Invalid maximized size after ShowWindow (%d,%d)-(%d,%d)\n",
4371 rc.left, rc.top, rc.right, rc.bottom);
4372 DestroyWindow(hwnd);
4373 flush_sequence();
4374
4375 /* Test 2:
4376 * 1. Create invisible maximized popup window.
4377 * 2. Show it maximized.
4378 */
4379 trace("calling CreateWindowExA( WS_MAXIMIZE ) for invisible maximized popup window\n");
4380 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE,
4381 100, 100, 200, 200, 0, 0, 0, NULL);
4382 ok (hwnd != 0, "Failed to create popup window\n");
4383 ok(IsZoomed(hwnd), "window should be maximized\n");
4384 ok_sequence(WmCreateInvisibleMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
4385
4386 trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for invisible maximized popup window\n");
4387 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
4388 ok(IsZoomed(hwnd), "window should be maximized\n");
4389 ok_sequence(WmShowMaxPopupSeq, "ShowWindow(SW_SHOWMAXIMIZED):invisible maximized popup", FALSE);
4390 DestroyWindow(hwnd);
4391 flush_sequence();
4392
4393 /* Test 3:
4394 * 1. Create visible maximized popup window.
4395 */
4396 trace("calling CreateWindowExA( WS_MAXIMIZE ) for maximized popup window\n");
4397 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE | WS_VISIBLE,
4398 100, 100, 200, 200, 0, 0, 0, NULL);
4399 ok (hwnd != 0, "Failed to create popup window\n");
4400 ok(IsZoomed(hwnd), "window should be maximized\n");
4401 ok_sequence(WmCreateMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
4402 DestroyWindow(hwnd);
4403 flush_sequence();
4404
4405 /* Test 4:
4406 * 1. Create visible popup window.
4407 * 2. Maximize it.
4408 */
4409 trace("calling CreateWindowExA( WS_VISIBLE ) for popup window\n");
4410 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_VISIBLE,
4411 100, 100, 200, 200, 0, 0, 0, NULL);
4412 ok (hwnd != 0, "Failed to create popup window\n");
4413 ok(!IsZoomed(hwnd), "window should NOT be maximized\n");
4414 ok_sequence(WmCreatePopupSeq, "CreateWindow(WS_VISIBLE):popup", FALSE);
4415
4416 trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for visible popup window\n");
4417 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
4418 ok(IsZoomed(hwnd), "window should be maximized\n");
4419 ok_sequence(WmShowVisMaxPopupSeq, "ShowWindow(SW_SHOWMAXIMIZED):popup", FALSE);
4420 DestroyWindow(hwnd);
4421 flush_sequence();
4422 }
4423
4424 static void test_sys_menu(void)
4425 {
4426 HWND hwnd;
4427 HMENU hmenu;
4428 UINT state;
4429
4430 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
4431 100, 100, 200, 200, 0, 0, 0, NULL);
4432 ok (hwnd != 0, "Failed to create overlapped window\n");
4433
4434 flush_sequence();
4435
4436 /* test existing window without CS_NOCLOSE style */
4437 hmenu = GetSystemMenu(hwnd, FALSE);
4438 ok(hmenu != 0, "GetSystemMenu error %d\n", GetLastError());
4439
4440 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
4441 ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
4442 ok(!(state & (MF_DISABLED | MF_GRAYED)), "wrong SC_CLOSE state %x\n", state);
4443
4444 EnableMenuItem(hmenu, SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
4445 ok_sequence(WmEmptySeq, "WmEnableMenuItem", FALSE);
4446
4447 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
4448 ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
4449 ok((state & (MF_DISABLED | MF_GRAYED)) == MF_GRAYED, "wrong SC_CLOSE state %x\n", state);
4450
4451 EnableMenuItem(hmenu, SC_CLOSE, 0);
4452 ok_sequence(WmEmptySeq, "WmEnableMenuItem", FALSE);
4453
4454 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
4455 ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
4456 ok(!(state & (MF_DISABLED | MF_GRAYED)), "wrong SC_CLOSE state %x\n", state);
4457
4458 /* test whether removing WS_SYSMENU destroys a system menu */
4459 SetWindowLongW(hwnd, GWL_STYLE, WS_POPUP);
4460 SetWindowPos(hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_FRAMECHANGED);
4461 flush_sequence();
4462 hmenu = GetSystemMenu(hwnd, FALSE);
4463 ok(hmenu != 0, "GetSystemMenu error %d\n", GetLastError());
4464
4465 DestroyWindow(hwnd);
4466
4467 /* test new window with CS_NOCLOSE style */
4468 hwnd = CreateWindowExA(0, "NoCloseWindowClass", NULL, WS_OVERLAPPEDWINDOW,
4469 100, 100, 200, 200, 0, 0, 0, NULL);
4470 ok (hwnd != 0, "Failed to create overlapped window\n");
4471
4472 hmenu = GetSystemMenu(hwnd, FALSE);
4473 ok(hmenu != 0, "GetSystemMenu error %d\n", GetLastError());
4474
4475 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
4476 ok(state == 0xffffffff, "wrong SC_CLOSE state %x\n", state);
4477
4478 DestroyWindow(hwnd);
4479
4480 /* test new window without WS_SYSMENU style */
4481 hwnd = CreateWindowExA(0, "NoCloseWindowClass", NULL, WS_OVERLAPPEDWINDOW & ~WS_SYSMENU,
4482 100, 100, 200, 200, 0, 0, 0, NULL);
4483 ok(hwnd != 0, "Failed to create overlapped window\n");
4484
4485 hmenu = GetSystemMenu(hwnd, FALSE);
4486 ok(!hmenu, "GetSystemMenu error %d\n", GetLastError());
4487
4488 DestroyWindow(hwnd);
4489 }
4490
4491 /* For shown WS_OVERLAPPEDWINDOW */
4492 static const struct message WmSetIcon_1[] = {
4493 { WM_SETICON, sent },
4494 { 0x00AE, sent|defwinproc|optional }, /* XP */
4495 { WM_GETTEXT, sent|defwinproc|optional },
4496 { WM_GETTEXT, sent|defwinproc|optional }, /* XP sends a duplicate */
4497 { 0 }
4498 };
4499
4500 /* For WS_POPUP and hidden WS_OVERLAPPEDWINDOW */
4501 static const struct message WmSetIcon_2[] = {
4502 { WM_SETICON, sent },
4503 { 0 }
4504 };
4505
4506 /* Sending undocumented 0x3B message with wparam = 0x8000000b */
4507 static const struct message WmInitEndSession[] = {
4508 { 0x003B, sent },
4509 { WM_QUERYENDSESSION, sent|defwinproc|wparam|lparam, 0, ENDSESSION_LOGOFF },
4510 { 0 }
4511 };
4512
4513 /* Sending undocumented 0x3B message with wparam = 0x0000000b */
4514 static const struct message WmInitEndSession_2[] = {
4515 { 0x003B, sent },
4516 { WM_QUERYENDSESSION, sent|defwinproc|wparam|lparam, 0, 0 },
4517 { 0 }
4518 };
4519
4520 /* Sending undocumented 0x3B message with wparam = 0x80000008 */
4521 static const struct message WmInitEndSession_3[] = {
4522 { 0x003B, sent },
4523 { WM_ENDSESSION, sent|defwinproc|wparam|lparam, 0, ENDSESSION_LOGOFF },
4524 { 0 }
4525 };
4526
4527 /* Sending undocumented 0x3B message with wparam = 0x00000008 */
4528 static const struct message WmInitEndSession_4[] = {
4529 { 0x003B, sent },
4530 { WM_ENDSESSION, sent|defwinproc|wparam|lparam, 0, 0 },
4531 { 0 }
4532 };
4533
4534 /* Sending undocumented 0x3B message with wparam = 0x80000001 */
4535 static const struct message WmInitEndSession_5[] = {
4536 { 0x003B, sent },
4537 { WM_ENDSESSION, sent|defwinproc/*|wparam*/|lparam, 1, ENDSESSION_LOGOFF },
4538 { 0 }
4539 };
4540
4541 static const struct message WmOptionalPaint[] = {
4542 { WM_PAINT, sent|optional },
4543 { WM_NCPAINT, sent|beginpaint|optional },
4544 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
4545 { WM_ERASEBKGND, sent|beginpaint|optional },
4546 { 0 }
4547 };
4548
4549 static const struct message WmZOrder[] = {
4550 { WM_WINDOWPOSCHANGING, sent|wparam, 0, 0 },
4551 { WM_GETMINMAXINFO, sent|defwinproc|wparam, 0, 0 },
4552 { HCBT_ACTIVATE, hook },
4553 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
4554 { WM_WINDOWPOSCHANGING, sent|wparam, 3, 0 },
4555 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOREDRAW|SWP_NOMOVE|SWP_NOSIZE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE, 0 },
4556 { WM_GETTEXT, sent|optional },
4557 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
4558 { WM_ACTIVATEAPP, sent|wparam, 1, 0 },
4559 { WM_NCACTIVATE, sent|lparam, 1, 0 },
4560 { WM_GETTEXT, sent|defwinproc|optional },
4561 { WM_GETTEXT, sent|defwinproc|optional },
4562 { WM_ACTIVATE, sent|wparam|lparam, 1, 0 },
4563 { HCBT_SETFOCUS, hook },
4564 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
4565 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
4566 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
4567 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
4568 { WM_GETTEXT, sent|optional },
4569 { WM_NCCALCSIZE, sent|optional },
4570 { 0 }
4571 };
4572
4573 static void CALLBACK apc_test_proc(ULONG_PTR param)
4574 {
4575 /* nothing */
4576 }
4577
4578 static void test_MsgWaitForMultipleObjects(HWND hwnd)
4579 {
4580 DWORD ret;
4581 MSG msg;
4582
4583 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4584 ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %x\n", ret);
4585
4586 PostMessageA(hwnd, WM_USER, 0, 0);
4587
4588 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4589 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %x\n", ret);
4590
4591 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
4592 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4593
4594 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4595 ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %x\n", ret);
4596
4597 PostMessageA(hwnd, WM_USER, 0, 0);
4598
4599 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4600 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %x\n", ret);
4601
4602 ok(PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ), "PeekMessage should succeed\n");
4603 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4604
4605 /* shows QS_POSTMESSAGE flag is cleared in the PeekMessage call */
4606 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4607 ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %x\n", ret);
4608
4609 PostMessageA(hwnd, WM_USER, 0, 0);
4610
4611 /* new incoming message causes it to become signaled again */
4612 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4613 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %x\n", ret);
4614
4615 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
4616 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
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
4620 /* MWMO_INPUTAVAILABLE should succeed even if the message was already seen */
4621 PostMessageA( hwnd, WM_USER, 0, 0 );
4622 ok(PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ), "PeekMessage should succeed\n");
4623 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4624
4625 ret = MsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_POSTMESSAGE, MWMO_INPUTAVAILABLE );
4626 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjectsEx returned %x\n", ret);
4627
4628 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
4629 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4630
4631 /* without MWMO_ALERTABLE the result is never WAIT_IO_COMPLETION */
4632 ret = QueueUserAPC( apc_test_proc, GetCurrentThread(), 0 );
4633 ok(ret, "QueueUserAPC failed %u\n", GetLastError());
4634
4635 ret = MsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_POSTMESSAGE, 0 );
4636 ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjectsEx returned %x\n", ret);
4637
4638 /* but even with MWMO_ALERTABLE window events are preferred */
4639 PostMessageA( hwnd, WM_USER, 0, 0 );
4640
4641 ret = MsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_POSTMESSAGE, MWMO_ALERTABLE );
4642 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjectsEx returned %x\n", ret);
4643
4644 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
4645 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4646
4647 /* the APC call is still queued */
4648 ret = MsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_POSTMESSAGE, MWMO_ALERTABLE );
4649 ok(ret == WAIT_IO_COMPLETION, "MsgWaitForMultipleObjectsEx returned %x\n", ret);
4650 }
4651
4652 static void test_WM_DEVICECHANGE(HWND hwnd)
4653 {
4654 DWORD ret;
4655 MSG msg;
4656 int i;
4657 static const WPARAM wparams[] = {0,
4658 DBT_DEVNODES_CHANGED,
4659 DBT_QUERYCHANGECONFIG,
4660 DBT_CONFIGCHANGED,
4661 DBT_CONFIGCHANGECANCELED,
4662 DBT_NO_DISK_SPACE,
4663 DBT_LOW_DISK_SPACE,
4664 DBT_CONFIGMGPRIVATE, /* 0x7fff */
4665 DBT_DEVICEARRIVAL, /* 0x8000 */
4666 DBT_DEVICEQUERYREMOVE,
4667 DBT_DEVICEQUERYREMOVEFAILED,
4668 DBT_DEVICEREMOVEPENDING,
4669 DBT_DEVICEREMOVECOMPLETE,
4670 DBT_DEVICETYPESPECIFIC,
4671 DBT_CUSTOMEVENT};
4672
4673 for (i = 0; i < sizeof(wparams)/sizeof(wparams[0]); i++)
4674 {
4675 SetLastError(0xdeadbeef);
4676 ret = PostMessageA(hwnd, WM_DEVICECHANGE, wparams[i], 0);
4677 if (wparams[i] & 0x8000)
4678 {
4679 ok(ret == FALSE, "PostMessage should returned %d\n", ret);
4680 ok(GetLastError() == ERROR_MESSAGE_SYNC_ONLY, "PostMessage error %08x\n", GetLastError());
4681 }
4682 else
4683 {
4684 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4685 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %x\n", ret);
4686 memset(&msg, 0, sizeof(msg));
4687 ok(PeekMessageA(&msg, 0, 0, 0, PM_REMOVE), "PeekMessage should succeed\n");
4688 ok(msg.message == WM_DEVICECHANGE, "got %04x instead of WM_DEVICECHANGE\n", msg.message);
4689 }
4690 }
4691 }
4692
4693 static DWORD CALLBACK show_window_thread(LPVOID arg)
4694 {
4695 HWND hwnd = arg;
4696
4697 /* function will not return if ShowWindow(SW_HIDE) calls SendMessage() */
4698 ok(ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow(SW_HIDE) expected FALSE\n");
4699
4700 return 0;
4701 }
4702
4703 /* test if we receive the right sequence of messages */
4704 static void test_messages(void)
4705 {
4706 DWORD tid;
4707 HANDLE hthread;
4708 HWND hwnd, hparent, hchild;
4709 HWND hchild2, hbutton;
4710 HMENU hmenu;
4711 MSG msg;
4712 LRESULT res;
4713 POINT pos;
4714 BOOL ret;
4715
4716 flush_sequence();
4717
4718 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
4719 100, 100, 200, 200, 0, 0, 0, NULL);
4720 ok (hwnd != 0, "Failed to create overlapped window\n");
4721 ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
4722
4723 /* test ShowWindow(SW_HIDE) on a newly created invisible window */
4724 ok( ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow: window was visible\n" );
4725 ok_sequence(WmEmptySeq, "ShowWindow(SW_HIDE):overlapped, invisible", FALSE);
4726
4727 /* test WM_SETREDRAW on a not visible top level window */
4728 test_WM_SETREDRAW(hwnd);
4729
4730 SetWindowPos(hwnd, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4731 flush_events();
4732 ok_sequence(WmSWP_ShowOverlappedSeq, "SetWindowPos:SWP_SHOWWINDOW:overlapped", FALSE);
4733 ok(IsWindowVisible(hwnd), "window should be visible at this point\n");
4734
4735 ok(GetActiveWindow() == hwnd, "window should be active\n");
4736 ok(GetFocus() == hwnd, "window should have input focus\n");
4737 ShowWindow(hwnd, SW_HIDE);
4738 flush_events();
4739 ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
4740
4741 /* test ShowWindow(SW_HIDE) on a hidden window - single threaded */
4742 ok(ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow(SW_HIDE) expected FALSE\n");
4743 flush_events();
4744 ok_sequence(WmEmptySeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
4745
4746 /* test ShowWindow(SW_HIDE) on a hidden window - multi-threaded */
4747 hthread = CreateThread(NULL, 0, show_window_thread, hwnd, 0, &tid);
4748 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
4749 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
4750 CloseHandle(hthread);
4751 flush_events();
4752 ok_sequence(WmEmptySeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
4753
4754 ShowWindow(hwnd, SW_SHOW);
4755 flush_events();
4756 ok_sequence(WmShowOverlappedSeq, "ShowWindow(SW_SHOW):overlapped", TRUE);
4757
4758 ShowWindow(hwnd, SW_HIDE);
4759 flush_events();
4760 ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
4761
4762 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
4763 flush_events();
4764 ok_sequence(WmShowMaxOverlappedSeq, "ShowWindow(SW_SHOWMAXIMIZED):overlapped", TRUE);
4765 flush_sequence();
4766
4767 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_MAXIMIZE)
4768 {
4769 ShowWindow(hwnd, SW_RESTORE);
4770 flush_events();
4771 ok_sequence(WmShowRestoreMaxOverlappedSeq, "ShowWindow(SW_RESTORE):overlapped", TRUE);
4772 flush_sequence();
4773 }
4774
4775 ShowWindow(hwnd, SW_MINIMIZE);
4776 flush_events();
4777 ok_sequence(WmShowMinOverlappedSeq, "ShowWindow(SW_SHOWMINIMIZED):overlapped", TRUE);
4778 flush_sequence();
4779
4780 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_MINIMIZE)
4781 {
4782 ShowWindow(hwnd, SW_RESTORE);
4783 flush_events();
4784 ok_sequence(WmShowRestoreMinOverlappedSeq, "ShowWindow(SW_RESTORE):overlapped", TRUE);
4785 flush_sequence();
4786 }
4787
4788 ShowWindow(hwnd, SW_SHOW);
4789 flush_events();
4790 ok_sequence(WmOptionalPaint, "ShowWindow(SW_SHOW):overlapped already visible", FALSE);
4791
4792 SetWindowPos(hwnd, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4793 ok_sequence(WmSWP_HideOverlappedSeq, "SetWindowPos:SWP_HIDEWINDOW:overlapped", FALSE);
4794 ok(!IsWindowVisible(hwnd), "window should not be visible at this point\n");
4795 ok(GetActiveWindow() == hwnd, "window should still be active\n");
4796
4797 /* test WM_SETREDRAW on a visible top level window */
4798 ShowWindow(hwnd, SW_SHOW);
4799 flush_events();
4800 test_WM_SETREDRAW(hwnd);
4801
4802 trace("testing scroll APIs on a visible top level window %p\n", hwnd);
4803 test_scroll_messages(hwnd);
4804
4805 /* test resizing and moving */
4806 SetWindowPos( hwnd, 0, 0, 0, 300, 300, SWP_NOMOVE|SWP_NOACTIVATE );
4807 ok_sequence(WmSWP_ResizeSeq, "SetWindowPos:Resize", FALSE );
4808 flush_events();
4809 flush_sequence();
4810 SetWindowPos( hwnd, 0, 200, 200, 0, 0, SWP_NOSIZE|SWP_NOACTIVATE );
4811 ok_sequence(WmSWP_MoveSeq, "SetWindowPos:Move", FALSE );
4812 flush_events();
4813 flush_sequence();
4814 SetWindowPos( hwnd, 0, 200, 200, 250, 250, SWP_NOZORDER|SWP_NOACTIVATE );
4815 ok_sequence(WmSWP_ResizeNoZOrder, "SetWindowPos:WmSWP_ResizeNoZOrder", FALSE );
4816 flush_events();
4817 flush_sequence();
4818
4819 /* popups don't get WM_GETMINMAXINFO */
4820 SetWindowLongW( hwnd, GWL_STYLE, WS_VISIBLE|WS_POPUP );
4821 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_FRAMECHANGED);
4822 flush_sequence();
4823 SetWindowPos( hwnd, 0, 0, 0, 200, 200, SWP_NOMOVE|SWP_NOACTIVATE );
4824 ok_sequence(WmSWP_ResizePopupSeq, "SetWindowPos:ResizePopup", FALSE );
4825
4826 DestroyWindow(hwnd);
4827 ok_sequence(WmDestroyOverlappedSeq, "DestroyWindow:overlapped", FALSE);
4828
4829 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
4830 100, 100, 200, 200, 0, 0, 0, NULL);
4831 ok (hparent != 0, "Failed to create parent window\n");
4832 flush_sequence();
4833
4834 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_MAXIMIZE,
4835 0, 0, 10, 10, hparent, 0, 0, NULL);
4836 ok (hchild != 0, "Failed to create child window\n");
4837 ok_sequence(WmCreateMaximizedChildSeq, "CreateWindow:maximized child", FALSE);
4838 DestroyWindow(hchild);
4839 flush_sequence();
4840
4841 /* visible child window with a caption */
4842 hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
4843 WS_CHILD | WS_VISIBLE | WS_CAPTION,
4844 0, 0, 10, 10, hparent, 0, 0, NULL);
4845 ok (hchild != 0, "Failed to create child window\n");
4846 ok_sequence(WmCreateVisibleChildSeq, "CreateWindow:visible child", FALSE);
4847
4848 trace("testing scroll APIs on a visible child window %p\n", hchild);
4849 test_scroll_messages(hchild);
4850
4851 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4852 ok_sequence(WmShowChildSeq_4, "SetWindowPos(SWP_SHOWWINDOW):child with a caption", FALSE);
4853
4854 DestroyWindow(hchild);
4855 flush_sequence();
4856
4857 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4858 0, 0, 10, 10, hparent, 0, 0, NULL);
4859 ok (hchild != 0, "Failed to create child window\n");
4860 ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
4861
4862 hchild2 = CreateWindowExA(0, "SimpleWindowClass", "Test child2", WS_CHILD,
4863 100, 100, 50, 50, hparent, 0, 0, NULL);
4864 ok (hchild2 != 0, "Failed to create child2 window\n");
4865 flush_sequence();
4866
4867 hbutton = CreateWindowExA(0, "TestWindowClass", "Test button", WS_CHILD,
4868 0, 100, 50, 50, hchild, 0, 0, NULL);
4869 ok (hbutton != 0, "Failed to create button window\n");
4870
4871 /* test WM_SETREDRAW on a not visible child window */
4872 test_WM_SETREDRAW(hchild);
4873
4874 ShowWindow(hchild, SW_SHOW);
4875 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
4876
4877 /* check parent messages too */
4878 log_all_parent_messages++;
4879 ShowWindow(hchild, SW_HIDE);
4880 ok_sequence(WmHideChildSeq2, "ShowWindow(SW_HIDE):child", FALSE);
4881 log_all_parent_messages--;
4882
4883 ShowWindow(hchild, SW_SHOW);
4884 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
4885
4886 ShowWindow(hchild, SW_HIDE);
4887 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):child", FALSE);
4888
4889 ShowWindow(hchild, SW_SHOW);
4890 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
4891
4892 /* test WM_SETREDRAW on a visible child window */
4893 test_WM_SETREDRAW(hchild);
4894
4895 log_all_parent_messages++;
4896 MoveWindow(hchild, 10, 10, 20, 20, TRUE);
4897 ok_sequence(WmResizingChildWithMoveWindowSeq, "MoveWindow:child", FALSE);
4898 log_all_parent_messages--;
4899
4900 ShowWindow(hchild, SW_HIDE);
4901 flush_sequence();
4902 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4903 ok_sequence(WmShowChildSeq_2, "SetWindowPos:show_child_2", FALSE);
4904
4905 ShowWindow(hchild, SW_HIDE);
4906 flush_sequence();
4907 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE);
4908 ok_sequence(WmShowChildSeq_3, "SetWindowPos:show_child_3", FALSE);
4909
4910 /* DestroyWindow sequence below expects that a child has focus */
4911 SetFocus(hchild);
4912 flush_sequence();
4913
4914 DestroyWindow(hchild);
4915 ok_sequence(WmDestroyChildSeq, "DestroyWindow:child", FALSE);
4916 DestroyWindow(hchild2);
4917 DestroyWindow(hbutton);
4918
4919 flush_sequence();
4920 hchild = CreateWindowExA(0, "TestWindowClass", "Test Child Popup", WS_CHILD | WS_POPUP,
4921 0, 0, 100, 100, hparent, 0, 0, NULL);
4922 ok (hchild != 0, "Failed to create child popup window\n");
4923 ok_sequence(WmCreateChildPopupSeq, "CreateWindow:child_popup", FALSE);
4924 DestroyWindow(hchild);
4925
4926 /* test what happens to a window which sets WS_VISIBLE in WM_CREATE */
4927 flush_sequence();
4928 hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP,
4929 0, 0, 100, 100, hparent, 0, 0, NULL);
4930 ok (hchild != 0, "Failed to create popup window\n");
4931 ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
4932 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4933 ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
4934 flush_sequence();
4935 ShowWindow(hchild, SW_SHOW);
4936 ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
4937 flush_sequence();
4938 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
4939 ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
4940 flush_sequence();
4941 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4942 ok_sequence(WmShowVisiblePopupSeq_3, "SetWindowPos:show_visible_popup_3", FALSE);
4943 DestroyWindow(hchild);
4944
4945 /* this time add WS_VISIBLE for CreateWindowEx, but this fact actually
4946 * changes nothing in message sequences.
4947 */
4948 flush_sequence();
4949 hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP | WS_VISIBLE,
4950 0, 0, 100, 100, hparent, 0, 0, NULL);
4951 ok (hchild != 0, "Failed to create popup window\n");
4952 ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
4953 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4954 ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
4955 flush_sequence();
4956 ShowWindow(hchild, SW_SHOW);
4957 ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
4958 flush_sequence();
4959 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
4960 ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
4961 DestroyWindow(hchild);
4962
4963 flush_sequence();
4964 hwnd = CreateWindowExA(WS_EX_DLGMODALFRAME, "TestDialogClass", NULL, WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
4965 0, 0, 100, 100, hparent, 0, 0, NULL);
4966 ok(hwnd != 0, "Failed to create custom dialog window\n");
4967 ok_sequence(WmCreateCustomDialogSeq, "CreateCustomDialog", TRUE);
4968
4969 if(0) {
4970 trace("testing scroll APIs on a visible dialog %p\n", hwnd);
4971 test_scroll_messages(hwnd);
4972 }
4973
4974 flush_sequence();
4975
4976 test_def_id = TRUE;
4977 SendMessageA(hwnd, WM_NULL, 0, 0);
4978
4979 flush_sequence();
4980 after_end_dialog = TRUE;
4981 EndDialog( hwnd, 0 );
4982 ok_sequence(WmEndCustomDialogSeq, "EndCustomDialog", FALSE);
4983
4984 DestroyWindow(hwnd);
4985 after_end_dialog = FALSE;
4986 test_def_id = FALSE;
4987
4988 ok(GetCursorPos(&pos), "GetCursorPos failed\n");
4989 ok(SetCursorPos(109, 109), "SetCursorPos failed\n");
4990
4991 hwnd = CreateWindowExA(0, "TestDialogClass", NULL, WS_POPUP|WS_CHILD,
4992 0, 0, 100, 100, 0, 0, GetModuleHandleA(0), NULL);
4993 ok(hwnd != 0, "Failed to create custom dialog window\n");
4994 flush_sequence();
4995 trace("call ShowWindow(%p, SW_SHOW)\n", hwnd);
4996 ShowWindow(hwnd, SW_SHOW);
4997 ok_sequence(WmShowCustomDialogSeq, "ShowCustomDialog", TRUE);
4998
4999 flush_events();
5000 flush_sequence();
5001 ret = DrawMenuBar(hwnd);
5002 ok(ret, "DrawMenuBar failed: %d\n", GetLastError());
5003 flush_events();
5004 ok_sequence(WmDrawMenuBarSeq, "DrawMenuBar", FALSE);
5005 ok(SetCursorPos(pos.x, pos.y), "SetCursorPos failed\n");
5006
5007 DestroyWindow(hwnd);
5008
5009 hwnd = CreateWindowExA(0, "TestDialogClass", NULL, WS_CHILD|WS_VISIBLE,
5010 0, 0, 100, 100, hparent, 0, GetModuleHandleA(0), NULL);
5011 ok(hwnd != 0, "Failed to create custom dialog window\n");
5012 flush_events();
5013 flush_sequence();
5014 ret = DrawMenuBar(hwnd);
5015 ok(ret, "DrawMenuBar failed: %d\n", GetLastError());
5016 flush_events();
5017 ok_sequence(WmEmptySeq, "DrawMenuBar for a child window", FALSE);
5018
5019 DestroyWindow(hwnd);
5020
5021 flush_sequence();
5022 DialogBoxA( 0, "TEST_DIALOG", hparent, TestModalDlgProcA );
5023 ok_sequence(WmModalDialogSeq, "ModalDialog", TRUE);
5024
5025 DestroyWindow(hparent);
5026 flush_sequence();
5027
5028 /* Message sequence for SetMenu */
5029 ok(!DrawMenuBar(hwnd), "DrawMenuBar should return FALSE for a destroyed window\n");
5030 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "last error is %d\n", GetLastError());
5031 ok_sequence(WmEmptySeq, "DrawMenuBar for a window without a menu", FALSE);
5032
5033 hmenu = CreateMenu();
5034 ok (hmenu != 0, "Failed to create menu\n");
5035 ok (InsertMenuA(hmenu, -1, MF_BYPOSITION, 0x1000, "foo"), "InsertMenu failed\n");
5036 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
5037 100, 100, 200, 200, 0, hmenu, 0, NULL);
5038 ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
5039 ok (SetMenu(hwnd, 0), "SetMenu\n");
5040 ok_sequence(WmSetMenuNonVisibleSizeChangeSeq, "SetMenu:NonVisibleSizeChange", FALSE);
5041 ok (SetMenu(hwnd, 0), "SetMenu\n");
5042 ok_sequence(WmSetMenuNonVisibleNoSizeChangeSeq, "SetMenu:NonVisibleNoSizeChange", FALSE);
5043 ShowWindow(hwnd, SW_SHOW);
5044 UpdateWindow( hwnd );
5045 flush_events();
5046 flush_sequence();
5047 ok (SetMenu(hwnd, 0), "SetMenu\n");
5048 ok_sequence(WmSetMenuVisibleNoSizeChangeSeq, "SetMenu:VisibleNoSizeChange", FALSE);
5049 ok (SetMenu(hwnd, hmenu), "SetMenu\n");
5050 ok_sequence(WmSetMenuVisibleSizeChangeSeq, "SetMenu:VisibleSizeChange", FALSE);
5051
5052 UpdateWindow( hwnd );
5053 flush_events();
5054 flush_sequence();
5055 ok(DrawMenuBar(hwnd), "DrawMenuBar\n");
5056 flush_events();
5057 ok_sequence(WmDrawMenuBarSeq, "DrawMenuBar", FALSE);
5058
5059 DestroyWindow(hwnd);
5060 flush_sequence();
5061
5062 /* Message sequence for EnableWindow */
5063 hparent = CreateWindowExA(0, "TestWindowClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
5064 100, 100, 200, 200, 0, 0, 0, NULL);
5065 ok (hparent != 0, "Failed to create parent window\n");
5066 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
5067 0, 0, 10, 10, hparent, 0, 0, NULL);
5068 ok (hchild != 0, "Failed to create child window\n");
5069
5070 SetFocus(hchild);
5071 flush_events();
5072 flush_sequence();
5073
5074 EnableWindow(hparent, FALSE);
5075 ok_sequence(WmEnableWindowSeq_1, "EnableWindow(FALSE)", FALSE);
5076
5077 EnableWindow(hparent, TRUE);
5078 ok_sequence(WmEnableWindowSeq_2, "EnableWindow(TRUE)", FALSE);
5079
5080 flush_events();
5081 flush_sequence();
5082
5083 test_MsgWaitForMultipleObjects(hparent);
5084 test_WM_DEVICECHANGE(hparent);
5085
5086 /* the following test causes an exception in user.exe under win9x */
5087 if (!PostMessageW( hparent, WM_USER, 0, 0 ))
5088 {
5089 DestroyWindow(hparent);
5090 flush_sequence();
5091 return;
5092 }
5093 PostMessageW( hparent, WM_USER+1, 0, 0 );
5094 /* PeekMessage(NULL) fails, but still removes the message */
5095 SetLastError(0xdeadbeef);
5096 ok( !PeekMessageW( NULL, 0, 0, 0, PM_REMOVE ), "PeekMessage(NULL) should fail\n" );
5097 ok( GetLastError() == ERROR_NOACCESS || /* Win2k */
5098 GetLastError() == 0xdeadbeef, /* NT4 */
5099 "last error is %d\n", GetLastError() );
5100 ok( PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n" );
5101 ok( msg.message == WM_USER+1, "got %x instead of WM_USER+1\n", msg.message );
5102
5103 DestroyWindow(hchild);
5104 DestroyWindow(hparent);
5105 flush_sequence();
5106
5107 /* Message sequences for WM_SETICON */
5108 trace("testing WM_SETICON\n");
5109 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
5110 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
5111 NULL, NULL, 0);
5112 ShowWindow(hwnd, SW_SHOW);
5113 UpdateWindow(hwnd);
5114 flush_events();
5115 flush_sequence();
5116 SendMessageA(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIconA(0, (LPCSTR)IDI_APPLICATION));
5117 ok_sequence(WmSetIcon_1, "WM_SETICON for shown window with caption", FALSE);
5118
5119 ShowWindow(hwnd, SW_HIDE);
5120 flush_events();
5121 flush_sequence();
5122 SendMessageA(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIconA(0, (LPCSTR)IDI_APPLICATION));
5123 ok_sequence(WmSetIcon_2, "WM_SETICON for hidden window with caption", FALSE);
5124 DestroyWindow(hwnd);
5125 flush_sequence();
5126
5127 hwnd = CreateWindowExA(0, "TestPopupClass", NULL, WS_POPUP,
5128 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
5129 NULL, NULL, 0);
5130 ShowWindow(hwnd, SW_SHOW);
5131 UpdateWindow(hwnd);
5132 flush_events();
5133 flush_sequence();
5134 SendMessageA(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIconA(0, (LPCSTR)IDI_APPLICATION));
5135 ok_sequence(WmSetIcon_2, "WM_SETICON for shown window without caption", FALSE);
5136
5137 ShowWindow(hwnd, SW_HIDE);
5138 flush_events();
5139 flush_sequence();
5140 SendMessageA(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIconA(0, (LPCSTR)IDI_APPLICATION));
5141 ok_sequence(WmSetIcon_2, "WM_SETICON for hidden window without caption", FALSE);
5142
5143 flush_sequence();
5144 res = SendMessageA(hwnd, 0x3B, 0x8000000b, 0);
5145 if (!res)
5146 {
5147 todo_wine win_skip( "Message 0x3b not supported\n" );
5148 goto done;
5149 }
5150 ok_sequence(WmInitEndSession, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x8000000b", TRUE);
5151 ok(res == 1, "SendMessage(hwnd, 0x3B, 0x8000000b, 0) should have returned 1 instead of %ld\n", res);
5152 res = SendMessageA(hwnd, 0x3B, 0x0000000b, 0);
5153 ok_sequence(WmInitEndSession_2, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x0000000b", TRUE);
5154 ok(res == 1, "SendMessage(hwnd, 0x3B, 0x0000000b, 0) should have returned 1 instead of %ld\n", res);
5155 res = SendMessageA(hwnd, 0x3B, 0x0000000f, 0);
5156 ok_sequence(WmInitEndSession_2, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x0000000f", TRUE);
5157 ok(res == 1, "SendMessage(hwnd, 0x3B, 0x0000000f, 0) should have returned 1 instead of %ld\n", res);
5158
5159 flush_sequence();
5160 res = SendMessageA(hwnd, 0x3B, 0x80000008, 0);
5161 ok_sequence(WmInitEndSession_3, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x80000008", TRUE);
5162 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x80000008, 0) should have returned 2 instead of %ld\n", res);
5163 res = SendMessageA(hwnd, 0x3B, 0x00000008, 0);
5164 ok_sequence(WmInitEndSession_4, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x00000008", TRUE);
5165 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x00000008, 0) should have returned 2 instead of %ld\n", res);
5166
5167 res = SendMessageA(hwnd, 0x3B, 0x80000004, 0);
5168 ok_sequence(WmInitEndSession_3, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x80000004", TRUE);
5169 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x80000004, 0) should have returned 2 instead of %ld\n", res);
5170
5171 res = SendMessageA(hwnd, 0x3B, 0x80000001, 0);
5172 ok_sequence(WmInitEndSession_5, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x80000001", TRUE);
5173 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x80000001, 0) should have returned 2 instead of %ld\n", res);
5174
5175 done:
5176 DestroyWindow(hwnd);
5177 flush_sequence();
5178 }
5179
5180 static void test_setwindowpos(void)
5181 {
5182 HWND hwnd;
5183 RECT rc;
5184 LRESULT res;
5185 const INT winX = 100;
5186 const INT winY = 100;
5187 const INT sysX = GetSystemMetrics(SM_CXMINTRACK);
5188
5189 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, 0,
5190 0, 0, winX, winY, 0,
5191 NULL, NULL, 0);
5192
5193 GetWindowRect(hwnd, &rc);
5194 expect(sysX, rc.right);
5195 expect(winY, rc.bottom);
5196
5197 flush_events();
5198 flush_sequence();
5199 res = SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, winX, winY, 0);
5200 ok_sequence(WmZOrder, "Z-Order", TRUE);
5201 ok(res == TRUE, "SetWindowPos expected TRUE, got %ld\n", res);
5202
5203 GetWindowRect(hwnd, &rc);
5204 expect(sysX, rc.right);
5205 expect(winY, rc.bottom);
5206 DestroyWindow(hwnd);
5207 }
5208
5209 static void invisible_parent_tests(void)
5210 {
5211 HWND hparent, hchild;
5212
5213 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW,
5214 100, 100, 200, 200, 0, 0, 0, NULL);
5215 ok (hparent != 0, "Failed to create parent window\n");
5216 flush_sequence();
5217
5218 /* test showing child with hidden parent */
5219
5220 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5221 0, 0, 10, 10, hparent, 0, 0, NULL);
5222 ok (hchild != 0, "Failed to create child window\n");
5223 ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
5224
5225 ShowWindow( hchild, SW_MINIMIZE );
5226 ok_sequence(WmShowChildInvisibleParentSeq_1, "ShowWindow(SW_MINIMIZE) child with invisible parent", FALSE);
5227 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5228 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5229
5230 /* repeat */
5231 flush_events();
5232 flush_sequence();
5233 ShowWindow( hchild, SW_MINIMIZE );
5234 ok_sequence(WmShowChildInvisibleParentSeq_1r, "ShowWindow(SW_MINIMIZE) child with invisible parent", FALSE);
5235
5236 DestroyWindow(hchild);
5237 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5238 0, 0, 10, 10, hparent, 0, 0, NULL);
5239 flush_sequence();
5240
5241 ShowWindow( hchild, SW_MAXIMIZE );
5242 ok_sequence(WmShowChildInvisibleParentSeq_2, "ShowWindow(SW_MAXIMIZE) child with invisible parent", FALSE);
5243 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5244 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5245
5246 /* repeat */
5247 flush_events();
5248 flush_sequence();
5249 ShowWindow( hchild, SW_MAXIMIZE );
5250 ok_sequence(WmShowChildInvisibleParentSeq_2r, "ShowWindow(SW_MAXIMIZE) child with invisible parent", FALSE);
5251
5252 DestroyWindow(hchild);
5253 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5254 0, 0, 10, 10, hparent, 0, 0, NULL);
5255 flush_sequence();
5256
5257 ShowWindow( hchild, SW_RESTORE );
5258 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_RESTORE) child with invisible parent", FALSE);
5259 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5260 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5261
5262 DestroyWindow(hchild);
5263 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5264 0, 0, 10, 10, hparent, 0, 0, NULL);
5265 flush_sequence();
5266
5267 ShowWindow( hchild, SW_SHOWMINIMIZED );
5268 ok_sequence(WmShowChildInvisibleParentSeq_3, "ShowWindow(SW_SHOWMINIMIZED) child with invisible parent", FALSE);
5269 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5270 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5271
5272 /* repeat */
5273 flush_events();
5274 flush_sequence();
5275 ShowWindow( hchild, SW_SHOWMINIMIZED );
5276 ok_sequence(WmShowChildInvisibleParentSeq_3r, "ShowWindow(SW_SHOWMINIMIZED) child with invisible parent", FALSE);
5277
5278 DestroyWindow(hchild);
5279 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5280 0, 0, 10, 10, hparent, 0, 0, NULL);
5281 flush_sequence();
5282
5283 /* same as ShowWindow( hchild, SW_MAXIMIZE ); */
5284 ShowWindow( hchild, SW_SHOWMAXIMIZED );
5285 ok_sequence(WmShowChildInvisibleParentSeq_2, "ShowWindow(SW_SHOWMAXIMIZED) child with invisible parent", FALSE);
5286 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5287 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5288
5289 DestroyWindow(hchild);
5290 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5291 0, 0, 10, 10, hparent, 0, 0, NULL);
5292 flush_sequence();
5293
5294 ShowWindow( hchild, SW_SHOWMINNOACTIVE );
5295 ok_sequence(WmShowChildInvisibleParentSeq_4, "ShowWindow(SW_SHOWMINNOACTIVE) child with invisible parent", FALSE);
5296 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5297 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5298
5299 /* repeat */
5300 flush_events();
5301 flush_sequence();
5302 ShowWindow( hchild, SW_SHOWMINNOACTIVE );
5303 ok_sequence(WmShowChildInvisibleParentSeq_4r, "ShowWindow(SW_SHOWMINNOACTIVE) child with invisible parent", FALSE);
5304
5305 DestroyWindow(hchild);
5306 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5307 0, 0, 10, 10, hparent, 0, 0, NULL);
5308 flush_sequence();
5309
5310 /* FIXME: looks like XP SP2 doesn't know about SW_FORCEMINIMIZE at all */
5311 ShowWindow( hchild, SW_FORCEMINIMIZE );
5312 ok_sequence(WmEmptySeq, "ShowWindow(SW_FORCEMINIMIZE) child with invisible parent", TRUE);
5313 todo_wine {
5314 ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should be not set\n");
5315 }
5316 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5317
5318 DestroyWindow(hchild);
5319 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5320 0, 0, 10, 10, hparent, 0, 0, NULL);
5321 flush_sequence();
5322
5323 ShowWindow( hchild, SW_SHOWNA );
5324 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOWNA) child with invisible parent", FALSE);
5325 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5326 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5327
5328 /* repeat */
5329 flush_events();
5330 flush_sequence();
5331 ShowWindow( hchild, SW_SHOWNA );
5332 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOWNA) child with invisible parent", FALSE);
5333
5334 DestroyWindow(hchild);
5335 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5336 0, 0, 10, 10, hparent, 0, 0, NULL);
5337 flush_sequence();
5338
5339 ShowWindow( hchild, SW_SHOW );
5340 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOW) child with invisible parent", FALSE);
5341 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5342 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5343
5344 /* repeat */
5345 flush_events();
5346 flush_sequence();
5347 ShowWindow( hchild, SW_SHOW );
5348 ok_sequence(WmEmptySeq, "ShowWindow(SW_SHOW) child with invisible parent", FALSE);
5349
5350 ShowWindow( hchild, SW_HIDE );
5351 ok_sequence(WmHideChildInvisibleParentSeq, "ShowWindow:hide child with invisible parent", FALSE);
5352 ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should be not set\n");
5353 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5354
5355 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
5356 ok_sequence(WmShowChildInvisibleParentSeq_6, "SetWindowPos:show child with invisible parent", FALSE);
5357 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5358 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5359
5360 SetWindowPos(hchild, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
5361 ok_sequence(WmHideChildInvisibleParentSeq_2, "SetWindowPos:hide child with invisible parent", FALSE);
5362 ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should not be set\n");
5363 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
5364
5365 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
5366 flush_sequence();
5367 DestroyWindow(hchild);
5368 ok_sequence(WmDestroyInvisibleChildSeq, "DestroyInvisibleChildSeq", FALSE);
5369
5370 DestroyWindow(hparent);
5371 flush_sequence();
5372 }
5373
5374 /****************** button message test *************************/
5375 #define ID_BUTTON 0x000e
5376
5377 static const struct message WmSetFocusButtonSeq[] =
5378 {
5379 { HCBT_SETFOCUS, hook },
5380 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
5381 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
5382 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5383 { WM_SETFOCUS, sent|wparam, 0 },
5384 { WM_CTLCOLORBTN, sent|parent },
5385 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_SETFOCUS) },
5386 { WM_APP, sent|wparam|lparam, 0, 0 },
5387 { 0 }
5388 };
5389 static const struct message WmKillFocusButtonSeq[] =
5390 {
5391 { HCBT_SETFOCUS, hook },
5392 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5393 { WM_KILLFOCUS, sent|wparam, 0 },
5394 { WM_CTLCOLORBTN, sent|parent },
5395 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_KILLFOCUS) },
5396 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
5397 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
5398 { WM_APP, sent|wparam|lparam, 0, 0 },
5399 { WM_PAINT, sent },
5400 { WM_CTLCOLORBTN, sent|parent },
5401 { 0 }
5402 };
5403 static const struct message WmSetFocusStaticSeq[] =
5404 {
5405 { HCBT_SETFOCUS, hook },
5406 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
5407 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
5408 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5409 { WM_SETFOCUS, sent|wparam, 0 },
5410 { WM_CTLCOLORSTATIC, sent|parent },
5411 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_SETFOCUS) },
5412 { WM_COMMAND, sent|wparam|parent|optional, MAKEWPARAM(ID_BUTTON, BN_CLICKED) }, /* radio button */
5413 { WM_APP, sent|wparam|lparam, 0, 0 },
5414 { 0 }
5415 };
5416 static const struct message WmKillFocusStaticSeq[] =
5417 {
5418 { HCBT_SETFOCUS, hook },
5419 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5420 { WM_KILLFOCUS, sent|wparam, 0 },
5421 { WM_CTLCOLORSTATIC, sent|parent },
5422 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_KILLFOCUS) },
5423 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
5424 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
5425 { WM_APP, sent|wparam|lparam, 0, 0 },
5426 { WM_PAINT, sent },
5427 { WM_CTLCOLORSTATIC, sent|parent },
5428 { 0 }
5429 };
5430 static const struct message WmSetFocusOwnerdrawSeq[] =
5431 {
5432 { HCBT_SETFOCUS, hook },
5433 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
5434 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
5435 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5436 { WM_SETFOCUS, sent|wparam, 0 },
5437 { WM_CTLCOLORBTN, sent|parent },
5438 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_BUTTON, 0x001040e4 },
5439 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_SETFOCUS) },
5440 { WM_APP, sent|wparam|lparam, 0, 0 },
5441 { 0 }
5442 };
5443 static const struct message WmKillFocusOwnerdrawSeq[] =
5444 {
5445 { HCBT_SETFOCUS, hook },
5446 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5447 { WM_KILLFOCUS, sent|wparam, 0 },
5448 { WM_CTLCOLORBTN, sent|parent },
5449 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_BUTTON, 0x000040e4 },
5450 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_KILLFOCUS) },
5451 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
5452 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
5453 { WM_APP, sent|wparam|lparam, 0, 0 },
5454 { WM_PAINT, sent },
5455 { WM_CTLCOLORBTN, sent|parent },
5456 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_BUTTON, 0x000010e4 },
5457 { 0 }
5458 };
5459 static const struct message WmLButtonDownSeq[] =
5460 {
5461 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
5462 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
5463 { HCBT_SETFOCUS, hook },
5464 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
5465 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
5466 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5467 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
5468 { WM_CTLCOLORBTN, sent|defwinproc },
5469 { BM_SETSTATE, sent|wparam|defwinproc, TRUE },
5470 { WM_CTLCOLORBTN, sent|defwinproc },
5471 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5472 { 0 }
5473 };
5474 static const struct message WmLButtonDownStaticSeq[] =
5475 {
5476 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
5477 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
5478 { HCBT_SETFOCUS, hook },
5479 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
5480 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
5481 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5482 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
5483 { WM_CTLCOLORSTATIC, sent|defwinproc },
5484 { BM_SETSTATE, sent|wparam|defwinproc, TRUE },
5485 { WM_CTLCOLORSTATIC, sent|defwinproc },
5486 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5487 { 0 }
5488 };
5489 static const struct message WmLButtonUpSeq[] =
5490 {
5491 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
5492 { BM_SETSTATE, sent|wparam|defwinproc, FALSE },
5493 { WM_CTLCOLORBTN, sent|defwinproc },
5494 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5495 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
5496 { WM_CAPTURECHANGED, sent|wparam|defwinproc, 0 },
5497 { 0 }
5498 };
5499 static const struct message WmLButtonUpStaticSeq[] =
5500 {
5501 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
5502 { BM_SETSTATE, sent|wparam|defwinproc, FALSE },
5503 { WM_CTLCOLORSTATIC, sent|defwinproc },
5504 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5505 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
5506 { WM_CAPTURECHANGED, sent|wparam|defwinproc, 0 },
5507 { 0 }
5508 };
5509 static const struct message WmLButtonUpAutoSeq[] =
5510 {
5511 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
5512 { BM_SETSTATE, sent|wparam|defwinproc, FALSE },
5513 { WM_CTLCOLORSTATIC, sent|defwinproc },
5514 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5515 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
5516 { BM_SETCHECK, sent|defwinproc },
5517 { WM_CTLCOLORSTATIC, sent|defwinproc, 0, 0 },
5518 { WM_CAPTURECHANGED, sent|wparam|defwinproc, 0 },
5519 { 0 }
5520 };
5521 static const struct message WmLButtonUpBrokenSeq[] =
5522 {
5523 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
5524 { 0 }
5525 };
5526 static const struct message WmSetFontButtonSeq[] =
5527 {
5528 { WM_SETFONT, sent },
5529 { WM_PAINT, sent },
5530 { WM_ERASEBKGND, sent|defwinproc|optional },
5531 { WM_CTLCOLORBTN, sent|defwinproc },
5532 { WM_CTLCOLORBTN, sent|defwinproc|optional }, /* FIXME: Wine sends it twice for BS_OWNERDRAW */
5533 { 0 }
5534 };
5535 static const struct message WmSetFontStaticSeq[] =
5536 {
5537 { WM_SETFONT, sent },
5538 { WM_PAINT, sent },
5539 { WM_ERASEBKGND, sent|defwinproc|optional },
5540 { WM_CTLCOLORSTATIC, sent|defwinproc },
5541 { 0 }
5542 };
5543 static const struct message WmSetStyleButtonSeq[] =
5544 {
5545 { BM_SETSTYLE, sent },
5546 { WM_APP, sent|wparam|lparam, 0, 0 },
5547 { WM_PAINT, sent },
5548 { WM_NCPAINT, sent|defwinproc|optional }, /* FIXME: Wine sends it */
5549 { WM_ERASEBKGND, sent|defwinproc|optional }, /* Win9x doesn't send it */
5550 { WM_CTLCOLORBTN, sent|parent },
5551 { 0 }
5552 };
5553 static const struct message WmSetStyleStaticSeq[] =
5554 {
5555 { BM_SETSTYLE, sent },
5556 { WM_APP, sent|wparam|lparam, 0, 0 },
5557 { WM_PAINT, sent },
5558 { WM_NCPAINT, sent|defwinproc|optional }, /* FIXME: Wine sends it */
5559 { WM_ERASEBKGND, sent|defwinproc|optional }, /* Win9x doesn't send it */
5560 { WM_CTLCOLORSTATIC, sent|parent },
5561 { 0 }
5562 };
5563 static const struct message WmSetStyleUserSeq[] =
5564 {
5565 { BM_SETSTYLE, sent },
5566 { WM_APP, sent|wparam|lparam, 0, 0 },
5567 { WM_PAINT, sent },
5568 { WM_NCPAINT, sent|defwinproc|optional }, /* FIXME: Wine sends it */
5569 { WM_ERASEBKGND, sent|defwinproc|optional }, /* Win9x doesn't send it */
5570 { WM_CTLCOLORBTN, sent|parent },
5571 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_PAINT) },
5572 { 0 }
5573 };
5574 static const struct message WmSetStyleOwnerdrawSeq[] =
5575 {
5576 { BM_SETSTYLE, sent },
5577 { WM_APP, sent|wparam|lparam, 0, 0 },
5578 { WM_PAINT, sent },
5579 { WM_NCPAINT, sent|optional }, /* FIXME: Wine sends it */
5580 { WM_ERASEBKGND, sent|defwinproc|optional }, /* Win9x doesn't send it */
5581 { WM_CTLCOLORBTN, sent|parent },
5582 { WM_CTLCOLORBTN, sent|parent|optional }, /* Win9x doesn't send it */
5583 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_BUTTON, 0x000010e4 },
5584 { 0 }
5585 };
5586 static const struct message WmSetStateButtonSeq[] =
5587 {
5588 { BM_SETSTATE, sent },
5589 { WM_CTLCOLORBTN, sent|parent },
5590 { WM_APP, sent|wparam|lparam, 0, 0 },
5591 { 0 }
5592 };
5593 static const struct message WmSetStateStaticSeq[] =
5594 {
5595 { BM_SETSTATE, sent },
5596 { WM_CTLCOLORSTATIC, sent|parent },
5597 { WM_APP, sent|wparam|lparam, 0, 0 },
5598 { 0 }
5599 };
5600 static const struct message WmSetStateUserSeq[] =
5601 {
5602 { BM_SETSTATE, sent },
5603 { WM_CTLCOLORBTN, sent|parent },
5604 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_HILITE) },
5605 { WM_APP, sent|wparam|lparam, 0, 0 },
5606 { 0 }
5607 };
5608 static const struct message WmSetStateOwnerdrawSeq[] =
5609 {
5610 { BM_SETSTATE, sent },
5611 { WM_CTLCOLORBTN, sent|parent },
5612 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_BUTTON, 0x000120e4 },
5613 { WM_APP, sent|wparam|lparam, 0, 0 },
5614 { 0 }
5615 };
5616 static const struct message WmClearStateButtonSeq[] =
5617 {
5618 { BM_SETSTATE, sent },
5619 { WM_CTLCOLORBTN, sent|parent },
5620 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_UNHILITE) },
5621 { WM_APP, sent|wparam|lparam, 0, 0 },
5622 { 0 }
5623 };
5624 static const struct message WmClearStateOwnerdrawSeq[] =
5625 {
5626 { BM_SETSTATE, sent },
5627 { WM_CTLCOLORBTN, sent|parent },
5628 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_BUTTON, 0x000020e4 },
5629 { WM_APP, sent|wparam|lparam, 0, 0 },
5630 { 0 }
5631 };
5632 static const struct message WmSetCheckIgnoredSeq[] =
5633 {
5634 { BM_SETCHECK, sent },
5635 { WM_APP, sent|wparam|lparam, 0, 0 },
5636 { 0 }
5637 };
5638 static const struct message WmSetCheckStaticSeq[] =
5639 {
5640 { BM_SETCHECK, sent },
5641 { WM_CTLCOLORSTATIC, sent|parent },
5642 { WM_APP, sent|wparam|lparam, 0, 0 },
5643 { 0 }
5644 };
5645
5646 static WNDPROC old_button_proc;
5647
5648 static LRESULT CALLBACK button_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
5649 {
5650 static LONG defwndproc_counter = 0;
5651 LRESULT ret;
5652 struct recvd_message msg;
5653
5654 if (ignore_message( message )) return 0;
5655
5656 switch (message)
5657 {
5658 case WM_SYNCPAINT:
5659 break;
5660 case BM_SETSTATE:
5661 if (GetCapture())
5662 ok(GetCapture() == hwnd, "GetCapture() = %p\n", GetCapture());
5663 /* fall through */
5664 default:
5665 msg.hwnd = hwnd;
5666 msg.message = message;
5667 msg.flags = sent|wparam|lparam;
5668 if (defwndproc_counter) msg.flags |= defwinproc;
5669 msg.wParam = wParam;
5670 msg.lParam = lParam;
5671 msg.descr = "button";
5672 add_message(&msg);
5673 }
5674
5675 defwndproc_counter++;
5676 ret = CallWindowProcA(old_button_proc, hwnd, message, wParam, lParam);
5677 defwndproc_counter--;
5678
5679 return ret;
5680 }
5681
5682 static void subclass_button(void)
5683 {
5684 WNDCLASSA cls;
5685
5686 if (!GetClassInfoA(0, "button", &cls)) assert(0);
5687
5688 old_button_proc = cls.lpfnWndProc;
5689
5690 cls.hInstance = GetModuleHandleA(NULL);
5691 cls.lpfnWndProc = button_hook_proc;
5692 cls.lpszClassName = "my_button_class";
5693 UnregisterClassA(cls.lpszClassName, cls.hInstance);
5694 if (!RegisterClassA(&cls)) assert(0);
5695 }
5696
5697 static void test_button_messages(void)
5698 {
5699 static const struct
5700 {
5701 DWORD style;
5702 DWORD dlg_code;
5703 const struct message *setfocus;
5704 const struct message *killfocus;
5705 const struct message *setstyle;
5706 const struct message *setstate;
5707 const struct message *clearstate;
5708 const struct message *setcheck;
5709 const struct message *lbuttondown;
5710 const struct message *lbuttonup;
5711 const struct message *setfont;
5712 } button[] = {
5713 { BS_PUSHBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
5714 WmSetFocusButtonSeq, WmKillFocusButtonSeq, WmSetStyleButtonSeq,
5715 WmSetStateButtonSeq, WmSetStateButtonSeq, WmSetCheckIgnoredSeq,
5716 WmLButtonDownSeq, WmLButtonUpSeq, WmSetFontButtonSeq },
5717 { BS_DEFPUSHBUTTON, DLGC_BUTTON | DLGC_DEFPUSHBUTTON,
5718 WmSetFocusButtonSeq, WmKillFocusButtonSeq, WmSetStyleButtonSeq,
5719 WmSetStateButtonSeq, WmSetStateButtonSeq, WmSetCheckIgnoredSeq,
5720 WmLButtonDownSeq, WmLButtonUpSeq, WmSetFontButtonSeq },
5721 { BS_CHECKBOX, DLGC_BUTTON,
5722 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
5723 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
5724 WmLButtonDownStaticSeq, WmLButtonUpStaticSeq, WmSetFontStaticSeq },
5725 { BS_AUTOCHECKBOX, DLGC_BUTTON,
5726 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
5727 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
5728 WmLButtonDownStaticSeq, WmLButtonUpAutoSeq, WmSetFontStaticSeq },
5729 { BS_RADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
5730 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
5731 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
5732 WmLButtonDownStaticSeq, WmLButtonUpStaticSeq, WmSetFontStaticSeq },
5733 { BS_3STATE, DLGC_BUTTON,
5734 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
5735 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
5736 WmLButtonDownStaticSeq, WmLButtonUpStaticSeq, WmSetFontStaticSeq },
5737 { BS_AUTO3STATE, DLGC_BUTTON,
5738 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
5739 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
5740 WmLButtonDownStaticSeq, WmLButtonUpAutoSeq, WmSetFontStaticSeq },
5741 { BS_GROUPBOX, DLGC_STATIC,
5742 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
5743 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckIgnoredSeq,
5744 WmLButtonDownStaticSeq, WmLButtonUpStaticSeq, WmSetFontStaticSeq },
5745 { BS_USERBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
5746 WmSetFocusButtonSeq, WmKillFocusButtonSeq, WmSetStyleUserSeq,
5747 WmSetStateUserSeq, WmClearStateButtonSeq, WmSetCheckIgnoredSeq,
5748 WmLButtonDownSeq, WmLButtonUpSeq, WmSetFontButtonSeq },
5749 { BS_AUTORADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
5750 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
5751 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
5752 NULL /* avoid infinite loop */, WmLButtonUpBrokenSeq, WmSetFontStaticSeq },
5753 { BS_OWNERDRAW, DLGC_BUTTON,
5754 WmSetFocusOwnerdrawSeq, WmKillFocusOwnerdrawSeq, WmSetStyleOwnerdrawSeq,
5755 WmSetStateOwnerdrawSeq, WmClearStateOwnerdrawSeq, WmSetCheckIgnoredSeq,
5756 WmLButtonDownSeq, WmLButtonUpSeq, WmSetFontButtonSeq },
5757 };
5758 unsigned int i;
5759 HWND hwnd, parent;
5760 DWORD dlg_code;
5761 HFONT zfont;
5762
5763 /* selection with VK_SPACE should capture button window */
5764 hwnd = CreateWindowExA(0, "button", "test", BS_CHECKBOX | WS_VISIBLE | WS_POPUP,
5765 0, 0, 50, 14, 0, 0, 0, NULL);
5766 ok(hwnd != 0, "Failed to create button window\n");
5767 ReleaseCapture();
5768 SetFocus(hwnd);
5769 SendMessageA(hwnd, WM_KEYDOWN, VK_SPACE, 0);
5770 ok(GetCapture() == hwnd, "Should be captured on VK_SPACE WM_KEYDOWN\n");
5771 SendMessageA(hwnd, WM_KEYUP, VK_SPACE, 0);
5772 DestroyWindow(hwnd);
5773
5774 subclass_button();
5775
5776 parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
5777 100, 100, 200, 200, 0, 0, 0, NULL);
5778 ok(parent != 0, "Failed to create parent window\n");
5779
5780 for (i = 0; i < sizeof(button)/sizeof(button[0]); i++)
5781 {
5782 MSG msg;
5783 DWORD style, state;
5784 char desc[64];
5785
5786 trace("button style %08x\n", button[i].style);
5787
5788 hwnd = CreateWindowExA(0, "my_button_class", "test", button[i].style | WS_CHILD | BS_NOTIFY,
5789 0, 0, 50, 14, parent, (HMENU)ID_BUTTON, 0, NULL);
5790 ok(hwnd != 0, "Failed to create button window\n");
5791
5792 style = GetWindowLongA(hwnd, GWL_STYLE);
5793 style &= ~(WS_CHILD | BS_NOTIFY);
5794 /* XP turns a BS_USERBUTTON into BS_PUSHBUTTON */
5795 if (button[i].style == BS_USERBUTTON)
5796 ok(style == BS_PUSHBUTTON, "expected style BS_PUSHBUTTON got %x\n", style);
5797 else
5798 ok(style == button[i].style, "expected style %x got %x\n", button[i].style, style);
5799
5800 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
5801 ok(dlg_code == button[i].dlg_code, "%u: wrong dlg_code %08x\n", i, dlg_code);
5802
5803 ShowWindow(hwnd, SW_SHOW);
5804 UpdateWindow(hwnd);
5805 SetFocus(0);
5806 flush_events();
5807 SetFocus(0);
5808 flush_sequence();
5809
5810 log_all_parent_messages++;
5811
5812 ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
5813 SetFocus(hwnd);
5814 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
5815 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
5816 ok_sequence(button[i].setfocus, "SetFocus(hwnd) on a button", FALSE);
5817
5818 SetFocus(0);
5819 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
5820 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
5821 ok_sequence(button[i].killfocus, "SetFocus(0) on a button", FALSE);
5822
5823 ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
5824
5825 SendMessageA(hwnd, BM_SETSTYLE, button[i].style | BS_BOTTOM, TRUE);
5826 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
5827 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
5828 ok_sequence(button[i].setstyle, "BM_SETSTYLE on a button", FALSE);
5829
5830 style = GetWindowLongA(hwnd, GWL_STYLE);
5831 style &= ~(WS_VISIBLE | WS_CHILD | BS_NOTIFY);
5832 /* XP doesn't turn a BS_USERBUTTON into BS_PUSHBUTTON here! */
5833 ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style);
5834
5835 state = SendMessageA(hwnd, BM_GETSTATE, 0, 0);
5836 ok(state == 0, "expected state 0, got %04x\n", state);
5837
5838 flush_sequence();
5839
5840 SendMessageA(hwnd, BM_SETSTATE, TRUE, 0);
5841 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
5842 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
5843 ok_sequence(button[i].setstate, "BM_SETSTATE/TRUE on a button", FALSE);
5844
5845 state = SendMessageA(hwnd, BM_GETSTATE, 0, 0);
5846 ok(state == 0x0004, "expected state 0x0004, got %04x\n", state);
5847
5848 style = GetWindowLongA(hwnd, GWL_STYLE);
5849 style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
5850 ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style);
5851
5852 flush_sequence();
5853
5854 SendMessageA(hwnd, BM_SETSTATE, FALSE, 0);
5855 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
5856 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
5857 ok_sequence(button[i].clearstate, "BM_SETSTATE/FALSE on a button", FALSE);
5858
5859 state = SendMessageA(hwnd, BM_GETSTATE, 0, 0);
5860 ok(state == 0, "expected state 0, got %04x\n", state);
5861
5862 style = GetWindowLongA(hwnd, GWL_STYLE);
5863 style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
5864 ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style);
5865
5866 state = SendMessageA(hwnd, BM_GETCHECK, 0, 0);
5867 ok(state == BST_UNCHECKED, "expected BST_UNCHECKED, got %04x\n", state);
5868
5869 flush_sequence();
5870
5871 SendMessageA(hwnd, BM_SETCHECK, BST_UNCHECKED, 0);
5872 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
5873 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
5874 ok_sequence(WmSetCheckIgnoredSeq, "BM_SETCHECK on a button", FALSE);
5875
5876 state = SendMessageA(hwnd, BM_GETCHECK, 0, 0);
5877 ok(state == BST_UNCHECKED, "expected BST_UNCHECKED, got %04x\n", state);
5878
5879 style = GetWindowLongA(hwnd, GWL_STYLE);
5880 style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
5881 ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style);
5882
5883 flush_sequence();
5884
5885 SendMessageA(hwnd, BM_SETCHECK, BST_CHECKED, 0);
5886 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
5887 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
5888 ok_sequence(button[i].setcheck, "BM_SETCHECK on a button", FALSE);
5889
5890 state = SendMessageA(hwnd, BM_GETCHECK, 0, 0);
5891 if (button[i].style == BS_PUSHBUTTON ||
5892 button[i].style == BS_DEFPUSHBUTTON ||
5893 button[i].style == BS_GROUPBOX ||
5894 button[i].style == BS_USERBUTTON ||
5895 button[i].style == BS_OWNERDRAW)
5896 ok(state == BST_UNCHECKED, "expected check 0, got %04x\n", state);
5897 else
5898 ok(state == BST_CHECKED, "expected check 1, got %04x\n", state);
5899
5900 style = GetWindowLongA(hwnd, GWL_STYLE);
5901 style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
5902 if (button[i].style == BS_RADIOBUTTON ||
5903 button[i].style == BS_AUTORADIOBUTTON)
5904 ok(style == (button[i].style | WS_TABSTOP), "expected style %04x | WS_TABSTOP got %04x\n", button[i].style, style);
5905 else
5906 ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style);
5907
5908 log_all_parent_messages--;
5909
5910 DestroyWindow(hwnd);
5911
5912 hwnd = CreateWindowExA(0, "my_button_class", "test", button[i].style | WS_POPUP | WS_VISIBLE,
5913 0, 0, 50, 14, 0, 0, 0, NULL);
5914 ok(hwnd != 0, "Failed to create button window\n");
5915
5916 SetForegroundWindow(hwnd);
5917 flush_events();
5918
5919 SetActiveWindow(hwnd);
5920 SetFocus(0);
5921 flush_sequence();
5922
5923 if (button[i].lbuttondown)
5924 {
5925 SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
5926 sprintf(desc, "button[%i]: WM_LBUTTONDOWN on a button", i);
5927 ok_sequence(button[i].lbuttondown, desc, FALSE);
5928 }
5929
5930 SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
5931 sprintf(desc, "button[%i]: WM_LBUTTONUP on a button", i);
5932 ok_sequence(button[i].lbuttonup, desc, FALSE);
5933
5934 flush_sequence();
5935 zfont = GetStockObject(SYSTEM_FONT);
5936 SendMessageA(hwnd, WM_SETFONT, (WPARAM)zfont, TRUE);
5937 UpdateWindow(hwnd);
5938 sprintf(desc, "button[%i]: WM_SETFONT on a button", i);
5939 ok_sequence(button[i].setfont, desc, FALSE);
5940
5941 DestroyWindow(hwnd);
5942 }
5943
5944 DestroyWindow(parent);
5945 }
5946
5947 /****************** static message test *************************/
5948 static const struct message WmSetFontStaticSeq2[] =
5949 {
5950 { WM_SETFONT, sent },
5951 { WM_PAINT, sent|defwinproc|optional },
5952 { WM_ERASEBKGND, sent|defwinproc|optional },
5953 { WM_CTLCOLORSTATIC, sent|defwinproc|optional },
5954 { 0 }
5955 };
5956
5957 static WNDPROC old_static_proc;
5958
5959 static LRESULT CALLBACK static_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
5960 {
5961 static LONG defwndproc_counter = 0;
5962 LRESULT ret;
5963 struct recvd_message msg;
5964
5965 if (ignore_message( message )) return 0;
5966
5967 msg.hwnd = hwnd;
5968 msg.message = message;
5969 msg.flags = sent|wparam|lparam;
5970 if (defwndproc_counter) msg.flags |= defwinproc;
5971 msg.wParam = wParam;
5972 msg.lParam = lParam;
5973 msg.descr = "static";
5974 add_message(&msg);
5975
5976 defwndproc_counter++;
5977 ret = CallWindowProcA(old_static_proc, hwnd, message, wParam, lParam);
5978 defwndproc_counter--;
5979
5980 return ret;
5981 }
5982
5983 static void subclass_static(void)
5984 {
5985 WNDCLASSA cls;
5986
5987 if (!GetClassInfoA(0, "static", &cls)) assert(0);
5988
5989 old_static_proc = cls.lpfnWndProc;
5990
5991 cls.hInstance = GetModuleHandleA(NULL);
5992 cls.lpfnWndProc = static_hook_proc;
5993 cls.lpszClassName = "my_static_class";
5994 UnregisterClassA(cls.lpszClassName, cls.hInstance);
5995 if (!RegisterClassA(&cls)) assert(0);
5996 }
5997
5998 static void test_static_messages(void)
5999 {
6000 /* FIXME: make as comprehensive as the button message test */
6001 static const struct
6002 {
6003 DWORD style;
6004 DWORD dlg_code;
6005 const struct message *setfont;
6006 } static_ctrl[] = {
6007 { SS_LEFT, DLGC_STATIC,
6008 WmSetFontStaticSeq2 }
6009 };
6010 unsigned int i;
6011 HWND hwnd;
6012 DWORD dlg_code;
6013
6014 subclass_static();
6015
6016 for (i = 0; i < sizeof(static_ctrl)/sizeof(static_ctrl[0]); i++)
6017 {
6018 hwnd = CreateWindowExA(0, "my_static_class", "test", static_ctrl[i].style | WS_POPUP,
6019 0, 0, 50, 14, 0, 0, 0, NULL);
6020 ok(hwnd != 0, "Failed to create static window\n");
6021
6022 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
6023 ok(dlg_code == static_ctrl[i].dlg_code, "%u: wrong dlg_code %08x\n", i, dlg_code);
6024
6025 ShowWindow(hwnd, SW_SHOW);
6026 UpdateWindow(hwnd);
6027 SetFocus(0);
6028 flush_sequence();
6029
6030 trace("static style %08x\n", static_ctrl[i].style);
6031 SendMessageA(hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
6032 ok_sequence(static_ctrl[i].setfont, "WM_SETFONT on a static", FALSE);
6033
6034 DestroyWindow(hwnd);
6035 }
6036 }
6037
6038 /****************** ComboBox message test *************************/
6039 #define ID_COMBOBOX 0x000f
6040
6041 static const struct message WmKeyDownComboSeq[] =
6042 {
6043 { WM_KEYDOWN, sent|wparam|lparam, VK_DOWN, 0 },
6044 { WM_COMMAND, sent|wparam|defwinproc, MAKEWPARAM(1000, LBN_SELCHANGE) },
6045 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_COMBOBOX, CBN_SELENDOK) },
6046 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_COMBOBOX, CBN_SELCHANGE) },
6047 { WM_CTLCOLOREDIT, sent|parent },
6048 { WM_KEYUP, sent|wparam|lparam, VK_DOWN, 0 },
6049 { 0 }
6050 };
6051
6052 static const struct message WmSetPosComboSeq[] =
6053 {
6054 { WM_WINDOWPOSCHANGING, sent },
6055 { WM_NCCALCSIZE, sent|wparam, TRUE },
6056 { WM_CHILDACTIVATE, sent },
6057 { WM_WINDOWPOSCHANGED, sent },
6058 { WM_MOVE, sent|defwinproc },
6059 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
6060 { WM_WINDOWPOSCHANGING, sent|defwinproc },
6061 { WM_NCCALCSIZE, sent|defwinproc|wparam, TRUE },
6062 { WM_WINDOWPOSCHANGED, sent|defwinproc },
6063 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
6064 { 0 }
6065 };
6066
6067 static const struct message WMSetFocusComboBoxSeq[] =
6068 {
6069 { WM_SETFOCUS, sent },
6070 { WM_KILLFOCUS, sent|parent },
6071 { WM_SETFOCUS, sent },
6072 { WM_COMMAND, sent|defwinproc|wparam, MAKEWPARAM(1001, EN_SETFOCUS) },
6073 { EM_SETSEL, sent|defwinproc|wparam|lparam, 0, INT_MAX },
6074 { WM_CTLCOLOREDIT, sent|defwinproc|optional },/* Not sent on W2000, XP or Server 2003 */
6075 { WM_CTLCOLOREDIT, sent|parent|optional },/* Not sent on W2000, XP or Server 2003 */
6076 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_COMBOBOX, CBN_SETFOCUS) },
6077 { 0 }
6078 };
6079
6080 static const struct message SetFocusButtonSeq[] =
6081 {
6082 { WM_KILLFOCUS, sent },
6083 { CB_GETCOMBOBOXINFO, sent|optional },/* Windows 2000 */
6084 { 0x0167, sent|optional },/* Undocumented message. Sent on all versions except Windows 2000 */
6085 { WM_LBUTTONUP, sent|defwinproc },
6086 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_COMBOBOX, CBN_SELENDCANCEL) },
6087 { EM_SETSEL, sent|defwinproc|wparam|lparam, 0, 0 },
6088 { WM_CTLCOLOREDIT, sent|defwinproc|optional },/* Not sent on W2000, XP or Server 2003 */
6089 { WM_CTLCOLOREDIT, sent|parent|optional },/* Not sent on W2000, XP or Server 2003 */
6090 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_COMBOBOX, CBN_KILLFOCUS) },
6091 { WM_CTLCOLORBTN, sent|parent },
6092 { 0 }
6093 };
6094
6095 static const struct message SetFocusComboBoxSeq[] =
6096 {
6097 { WM_CTLCOLORBTN, sent|parent },
6098 { WM_SETFOCUS, sent },
6099 { WM_KILLFOCUS, sent|defwinproc },
6100 { WM_SETFOCUS, sent },
6101 { WM_COMMAND, sent|defwinproc|wparam, MAKEWPARAM(1001, EN_SETFOCUS) },
6102 { EM_SETSEL, sent|defwinproc|wparam|lparam, 0, INT_MAX },
6103 { WM_CTLCOLOREDIT, sent|defwinproc|optional },/* Not sent on W2000, XP or Server 2003 */
6104 { WM_CTLCOLOREDIT, sent|parent|optional },/* Not sent on W2000, XP or Server 2003 */
6105 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_COMBOBOX, CBN_SETFOCUS) },
6106 { 0 }
6107 };
6108
6109 static const struct message SetFocusButtonSeq2[] =
6110 {
6111 { WM_KILLFOCUS, sent },
6112 { CB_GETCOMBOBOXINFO, sent|optional },/* Windows 2000 */
6113 { 0x0167, sent|optional },/* Undocumented message. Sent on all versions except Windows 2000 */
6114 { WM_LBUTTONUP, sent|defwinproc },
6115 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_COMBOBOX, CBN_SELENDCANCEL) },
6116 { EM_SETSEL, sent|defwinproc|wparam|lparam, 0, 0 },
6117 { WM_CTLCOLOREDIT, sent|defwinproc },
6118 { WM_CTLCOLOREDIT, sent|parent },
6119 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_COMBOBOX, CBN_KILLFOCUS) },
6120 { WM_CTLCOLORBTN, sent|parent },
6121 { 0 }
6122 };
6123
6124 static WNDPROC old_combobox_proc, edit_window_proc;
6125
6126 static LRESULT CALLBACK combobox_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6127 {
6128 static LONG defwndproc_counter = 0;
6129 LRESULT ret;
6130 struct recvd_message msg;
6131
6132 /* do not log painting messages */
6133 if (message != WM_PAINT &&
6134 message != WM_NCPAINT &&
6135 message != WM_SYNCPAINT &&
6136 message != WM_ERASEBKGND &&
6137 message != WM_NCHITTEST &&
6138 message != WM_GETTEXT &&
6139 !ignore_message( message ))
6140 {
6141 msg.hwnd = hwnd;
6142 msg.message = message;
6143 msg.flags = sent|wparam|lparam;
6144 if (defwndproc_counter) msg.flags |= defwinproc;
6145 msg.wParam = wParam;
6146 msg.lParam = lParam;
6147 msg.descr = "combo";
6148 add_message(&msg);
6149 }
6150
6151 defwndproc_counter++;
6152 ret = CallWindowProcA(edit_window_proc, hwnd, message, wParam, lParam);
6153 defwndproc_counter--;
6154
6155 return ret;
6156 }
6157
6158 static LRESULT CALLBACK combobox_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6159 {
6160 static LONG defwndproc_counter = 0;
6161 LRESULT ret;
6162 struct recvd_message msg;
6163
6164 /* do not log painting messages */
6165 if (message != WM_PAINT &&
6166 message != WM_NCPAINT &&
6167 message != WM_SYNCPAINT &&
6168 message != WM_ERASEBKGND &&
6169 message != WM_NCHITTEST &&
6170 message != WM_GETTEXT &&
6171 !ignore_message( message ))
6172 {
6173 msg.hwnd = hwnd;
6174 msg.message = message;
6175 msg.flags = sent|wparam|lparam;
6176 if (defwndproc_counter) msg.flags |= defwinproc;
6177 msg.wParam = wParam;
6178 msg.lParam = lParam;
6179 msg.descr = "combo";
6180 add_message(&msg);
6181 }
6182
6183 defwndproc_counter++;
6184 ret = CallWindowProcA(old_combobox_proc, hwnd, message, wParam, lParam);
6185 defwndproc_counter--;
6186
6187 return ret;
6188 }
6189
6190 static void subclass_combobox(void)
6191 {
6192 WNDCLASSA cls;
6193
6194 if (!GetClassInfoA(0, "ComboBox", &cls)) assert(0);
6195
6196 old_combobox_proc = cls.lpfnWndProc;
6197
6198 cls.hInstance = GetModuleHandleA(NULL);
6199 cls.lpfnWndProc = combobox_hook_proc;
6200 cls.lpszClassName = "my_combobox_class";
6201 UnregisterClassA(cls.lpszClassName, cls.hInstance);
6202 if (!RegisterClassA(&cls)) assert(0);
6203 }
6204
6205 static void test_combobox_messages(void)
6206 {
6207 HWND parent, combo, button, edit;
6208 LRESULT ret;
6209 BOOL (WINAPI *pGetComboBoxInfo)(HWND, PCOMBOBOXINFO);
6210 COMBOBOXINFO cbInfo;
6211 BOOL res;
6212
6213 subclass_combobox();
6214
6215 parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
6216 100, 100, 200, 200, 0, 0, 0, NULL);
6217 ok(parent != 0, "Failed to create parent window\n");
6218 flush_sequence();
6219
6220 combo = CreateWindowExA(0, "my_combobox_class", "test", WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | CBS_HASSTRINGS,
6221 0, 0, 100, 150, parent, (HMENU)ID_COMBOBOX, 0, NULL);
6222 ok(combo != 0, "Failed to create combobox window\n");
6223
6224 UpdateWindow(combo);
6225
6226 ret = SendMessageA(combo, WM_GETDLGCODE, 0, 0);
6227 ok(ret == (DLGC_WANTCHARS | DLGC_WANTARROWS), "wrong dlg_code %08lx\n", ret);
6228
6229 ret = SendMessageA(combo, CB_ADDSTRING, 0, (LPARAM)"item 0");
6230 ok(ret == 0, "expected 0, got %ld\n", ret);
6231 ret = SendMessageA(combo, CB_ADDSTRING, 0, (LPARAM)"item 1");
6232 ok(ret == 1, "expected 1, got %ld\n", ret);
6233 ret = SendMessageA(combo, CB_ADDSTRING, 0, (LPARAM)"item 2");
6234 ok(ret == 2, "expected 2, got %ld\n", ret);
6235
6236 SendMessageA(combo, CB_SETCURSEL, 0, 0);
6237 SetFocus(combo);
6238 flush_sequence();
6239
6240 log_all_parent_messages++;
6241 SendMessageA(combo, WM_KEYDOWN, VK_DOWN, 0);
6242 SendMessageA(combo, WM_KEYUP, VK_DOWN, 0);
6243 log_all_parent_messages--;
6244 ok_sequence(WmKeyDownComboSeq, "WM_KEYDOWN/VK_DOWN on a ComboBox", FALSE);
6245
6246 flush_sequence();
6247 SetWindowPos(combo, 0, 10, 10, 120, 130, SWP_NOZORDER);
6248 ok_sequence(WmSetPosComboSeq, "repositioning messages on a ComboBox", FALSE);
6249
6250 DestroyWindow(combo);
6251 DestroyWindow(parent);
6252
6253 /* Start again. Test combobox text selection when getting and losing focus */
6254 pGetComboBoxInfo = (void *)GetProcAddress(GetModuleHandleA("user32.dll"), "GetComboBoxInfo");
6255 if (!pGetComboBoxInfo)
6256 {
6257 win_skip("GetComboBoxInfo is not available\n");
6258 return;
6259 }
6260
6261 parent = CreateWindowExA(0, "TestParentClass", "Parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
6262 10, 10, 300, 300, NULL, NULL, NULL, NULL);
6263 ok(parent != 0, "Failed to create parent window\n");
6264
6265 combo = CreateWindowExA(0, "my_combobox_class", "test", WS_CHILD | WS_VISIBLE | CBS_DROPDOWN,
6266 5, 5, 100, 100, parent, (HMENU)ID_COMBOBOX, NULL, NULL);
6267 ok(combo != 0, "Failed to create combobox window\n");
6268
6269 cbInfo.cbSize = sizeof(COMBOBOXINFO);
6270 SetLastError(0xdeadbeef);
6271 res = pGetComboBoxInfo(combo, &cbInfo);
6272 ok(res, "Failed to get COMBOBOXINFO structure; LastError: %u\n", GetLastError());
6273 edit = cbInfo.hwndItem;
6274
6275 edit_window_proc = (WNDPROC)SetWindowLongPtrA(edit, GWLP_WNDPROC, (ULONG_PTR)combobox_subclass_proc);
6276
6277 button = CreateWindowExA(0, "Button", "OK", WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON,
6278 5, 50, 100, 20, parent, NULL,
6279 (HINSTANCE)GetWindowLongPtrA(parent, GWLP_HINSTANCE), NULL);
6280 ok(button != 0, "Failed to create button window\n");
6281
6282 flush_sequence();
6283 log_all_parent_messages++;
6284 SendMessageA(combo, WM_SETFOCUS, 0, (LPARAM)edit);
6285 log_all_parent_messages--;
6286 ok_sequence(WMSetFocusComboBoxSeq, "WM_SETFOCUS on a ComboBox", TRUE);
6287
6288 flush_sequence();
6289 log_all_parent_messages++;
6290 SetFocus(button);
6291 log_all_parent_messages--;
6292 ok_sequence(SetFocusButtonSeq, "SetFocus on a Button", TRUE);
6293
6294 SendMessageA(combo, WM_SETTEXT, 0, (LPARAM)"Wine Test");
6295
6296 flush_sequence();
6297 log_all_parent_messages++;
6298 SetFocus(combo);
6299 log_all_parent_messages--;
6300 ok_sequence(SetFocusComboBoxSeq, "SetFocus on a ComboBox", TRUE);
6301
6302 flush_sequence();
6303 log_all_parent_messages++;
6304 SetFocus(button);
6305 log_all_parent_messages--;
6306 ok_sequence(SetFocusButtonSeq2, "SetFocus on a Button (2)", TRUE);
6307
6308 DestroyWindow(button);
6309 DestroyWindow(combo);
6310 DestroyWindow(parent);
6311 }
6312
6313 /****************** WM_IME_KEYDOWN message test *******************/
6314
6315 static const struct message WmImeKeydownMsgSeq_0[] =
6316 {
6317 { WM_IME_KEYDOWN, wparam, VK_RETURN },
6318 { WM_CHAR, wparam, 'A' },
6319 { 0 }
6320 };
6321
6322 static const struct message WmImeKeydownMsgSeq_1[] =
6323 {
6324 { WM_KEYDOWN, optional|wparam, VK_RETURN },
6325 { WM_CHAR, optional|wparam, VK_RETURN },
6326 { 0 }
6327 };
6328
6329 static LRESULT WINAPI wmime_keydown_procA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6330 {
6331 struct recvd_message msg;
6332
6333 msg.hwnd = hwnd;
6334 msg.message = message;
6335 msg.flags = wparam|lparam;
6336 msg.wParam = wParam;
6337 msg.lParam = lParam;
6338 msg.descr = "wmime_keydown";
6339 add_message(&msg);
6340
6341 return DefWindowProcA(hwnd, message, wParam, lParam);
6342 }
6343
6344 static void register_wmime_keydown_class(void)
6345 {
6346 WNDCLASSA cls;
6347
6348 ZeroMemory(&cls, sizeof(WNDCLASSA));
6349 cls.lpfnWndProc = wmime_keydown_procA;
6350 cls.hInstance = GetModuleHandleA(0);
6351 cls.lpszClassName = "wmime_keydown_class";
6352 if (!RegisterClassA(&cls)) assert(0);
6353 }
6354
6355 static void test_wmime_keydown_message(void)
6356 {
6357 HWND hwnd;
6358 MSG msg;
6359
6360 trace("Message sequences by WM_IME_KEYDOWN\n");
6361
6362 register_wmime_keydown_class();
6363 hwnd = CreateWindowExA(0, "wmime_keydown_class", NULL, WS_OVERLAPPEDWINDOW,
6364 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
6365 NULL, NULL, 0);
6366 flush_events();
6367 flush_sequence();
6368
6369 SendMessageA(hwnd, WM_IME_KEYDOWN, VK_RETURN, 0x1c0001);
6370 SendMessageA(hwnd, WM_CHAR, 'A', 1);
6371 ok_sequence(WmImeKeydownMsgSeq_0, "WM_IME_KEYDOWN 0", FALSE);
6372
6373 while ( PeekMessageA(&msg, 0, 0, 0, PM_REMOVE) )
6374 {
6375 TranslateMessage(&msg);
6376 DispatchMessageA(&msg);
6377 }
6378 ok_sequence(WmImeKeydownMsgSeq_1, "WM_IME_KEYDOWN 1", FALSE);
6379
6380 DestroyWindow(hwnd);
6381 }
6382
6383 /************* painting message test ********************/
6384
6385 void dump_region(HRGN hrgn)
6386 {
6387 DWORD i, size;
6388 RGNDATA *data = NULL;
6389 RECT *rect;
6390
6391 if (!hrgn)
6392 {
6393 printf( "null region\n" );
6394 return;
6395 }
6396 if (!(size = GetRegionData( hrgn, 0, NULL ))) return;
6397 if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return;
6398 GetRegionData( hrgn, size, data );
6399 printf("%d rects:", data->rdh.nCount );
6400 for (i = 0, rect = (RECT *)data->Buffer; i < data->rdh.nCount; i++, rect++)
6401 printf( " (%d,%d)-(%d,%d)", rect->left, rect->top, rect->right, rect->bottom );
6402 printf("\n");
6403 HeapFree( GetProcessHeap(), 0, data );
6404 }
6405
6406 static void check_update_rgn( HWND hwnd, HRGN hrgn )
6407 {
6408 INT ret;
6409 RECT r1, r2;
6410 HRGN tmp = CreateRectRgn( 0, 0, 0, 0 );
6411 HRGN update = CreateRectRgn( 0, 0, 0, 0 );
6412
6413 ret = GetUpdateRgn( hwnd, update, FALSE );
6414 ok( ret != ERROR, "GetUpdateRgn failed\n" );
6415 if (ret == NULLREGION)
6416 {
6417 ok( !hrgn, "Update region shouldn't be empty\n" );
6418 }
6419 else
6420 {
6421 if (CombineRgn( tmp, hrgn, update, RGN_XOR ) != NULLREGION)
6422 {
6423 ok( 0, "Regions are different\n" );
6424 if (winetest_debug > 0)
6425 {
6426 printf( "Update region: " );
6427 dump_region( update );
6428 printf( "Wanted region: " );
6429 dump_region( hrgn );
6430 }
6431 }
6432 }
6433 GetRgnBox( update, &r1 );
6434 GetUpdateRect( hwnd, &r2, FALSE );
6435 ok( r1.left == r2.left && r1.top == r2.top && r1.right == r2.right && r1.bottom == r2.bottom,
6436 "Rectangles are different: %d,%d-%d,%d / %d,%d-%d,%d\n",
6437 r1.left, r1.top, r1.right, r1.bottom, r2.left, r2.top, r2.right, r2.bottom );
6438
6439 DeleteObject( tmp );
6440 DeleteObject( update );
6441 }
6442
6443 static const struct message WmInvalidateRgn[] = {
6444 { WM_NCPAINT, sent },
6445 { WM_GETTEXT, sent|defwinproc|optional },
6446 { 0 }
6447 };
6448
6449 static const struct message WmGetUpdateRect[] = {
6450 { WM_NCPAINT, sent },
6451 { WM_GETTEXT, sent|defwinproc|optional },
6452 { WM_PAINT, sent },
6453 { 0 }
6454 };
6455
6456 static const struct message WmInvalidateFull[] = {
6457 { WM_NCPAINT, sent|wparam, 1 },
6458 { WM_GETTEXT, sent|defwinproc|optional },
6459 { 0 }
6460 };
6461
6462 static const struct message WmInvalidateErase[] = {
6463 { WM_NCPAINT, sent|wparam, 1 },
6464 { WM_GETTEXT, sent|defwinproc|optional },
6465 { WM_ERASEBKGND, sent },
6466 { 0 }
6467 };
6468
6469 static const struct message WmInvalidatePaint[] = {
6470 { WM_PAINT, sent },
6471 { WM_NCPAINT, sent|wparam|beginpaint, 1 },
6472 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
6473 { 0 }
6474 };
6475
6476 static const struct message WmInvalidateErasePaint[] = {
6477 { WM_PAINT, sent },
6478 { WM_NCPAINT, sent|wparam|beginpaint, 1 },
6479 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
6480 { WM_ERASEBKGND, sent|beginpaint|optional },
6481 { 0 }
6482 };
6483
6484 static const struct message WmInvalidateErasePaint2[] = {
6485 { WM_PAINT, sent },
6486 { WM_NCPAINT, sent|beginpaint },
6487 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
6488 { WM_ERASEBKGND, sent|beginpaint|optional },
6489 { 0 }
6490 };
6491
6492 static const struct message WmErase[] = {
6493 { WM_ERASEBKGND, sent },
6494 { 0 }
6495 };
6496
6497 static const struct message WmPaint[] = {
6498 { WM_PAINT, sent },
6499 { 0 }
6500 };
6501
6502 static const struct message WmParentOnlyPaint[] = {
6503 { WM_PAINT, sent|parent },
6504 { 0 }
6505 };
6506
6507 static const struct message WmInvalidateParent[] = {
6508 { WM_NCPAINT, sent|parent },
6509 { WM_GETTEXT, sent|defwinproc|parent|optional },
6510 { WM_ERASEBKGND, sent|parent },
6511 { 0 }
6512 };
6513
6514 static const struct message WmInvalidateParentChild[] = {
6515 { WM_NCPAINT, sent|parent },
6516 { WM_GETTEXT, sent|defwinproc|parent|optional },
6517 { WM_ERASEBKGND, sent|parent },
6518 { WM_NCPAINT, sent },
6519 { WM_GETTEXT, sent|defwinproc|optional },
6520 { WM_ERASEBKGND, sent },
6521 { 0 }
6522 };
6523
6524 static const struct message WmInvalidateParentChild2[] = {
6525 { WM_ERASEBKGND, sent|parent },
6526 { WM_NCPAINT, sent },
6527 { WM_GETTEXT, sent|defwinproc|optional },
6528 { WM_ERASEBKGND, sent },
6529 { 0 }
6530 };
6531
6532 static const struct message WmParentPaint[] = {
6533 { WM_PAINT, sent|parent },
6534 { WM_PAINT, sent },
6535 { 0 }
6536 };
6537
6538 static const struct message WmParentPaintNc[] = {
6539 { WM_PAINT, sent|parent },
6540 { WM_PAINT, sent },
6541 { WM_NCPAINT, sent|beginpaint },
6542 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
6543 { WM_ERASEBKGND, sent|beginpaint|optional },
6544 { 0 }
6545 };
6546
6547 static const struct message WmChildPaintNc[] = {
6548 { WM_PAINT, sent },
6549 { WM_NCPAINT, sent|beginpaint },
6550 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
6551 { WM_ERASEBKGND, sent|beginpaint|optional },
6552 { 0 }
6553 };
6554
6555 static const struct message WmParentErasePaint[] = {
6556 { WM_PAINT, sent|parent },
6557 { WM_NCPAINT, sent|parent|beginpaint },
6558 { WM_GETTEXT, sent|parent|beginpaint|defwinproc|optional },
6559 { WM_ERASEBKGND, sent|parent|beginpaint|optional },
6560 { WM_PAINT, sent },
6561 { WM_NCPAINT, sent|beginpaint },
6562 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
6563 { WM_ERASEBKGND, sent|beginpaint|optional },
6564 { 0 }
6565 };
6566
6567 static const struct message WmParentOnlyNcPaint[] = {
6568 { WM_PAINT, sent|parent },
6569 { WM_NCPAINT, sent|parent|beginpaint },
6570 { WM_GETTEXT, sent|parent|beginpaint|defwinproc|optional },
6571 { 0 }
6572 };
6573
6574 static const struct message WmSetParentStyle[] = {
6575 { WM_STYLECHANGING, sent|parent },
6576 { WM_STYLECHANGED, sent|parent },
6577 { 0 }
6578 };
6579
6580 static void test_paint_messages(void)
6581 {
6582 BOOL ret;
6583 RECT rect;
6584 POINT pt;
6585 MSG msg;
6586 HWND hparent, hchild;
6587 HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
6588 HRGN hrgn2 = CreateRectRgn( 0, 0, 0, 0 );
6589 HWND hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
6590 100, 100, 200, 200, 0, 0, 0, NULL);
6591 ok (hwnd != 0, "Failed to create overlapped window\n");
6592
6593 ShowWindow( hwnd, SW_SHOW );
6594 UpdateWindow( hwnd );
6595 flush_events();
6596 flush_sequence();
6597
6598 check_update_rgn( hwnd, 0 );
6599 SetRectRgn( hrgn, 10, 10, 20, 20 );
6600 ret = RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
6601 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
6602 check_update_rgn( hwnd, hrgn );
6603 SetRectRgn( hrgn2, 20, 20, 30, 30 );
6604 ret = RedrawWindow( hwnd, NULL, hrgn2, RDW_INVALIDATE );
6605 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
6606 CombineRgn( hrgn, hrgn, hrgn2, RGN_OR );
6607 check_update_rgn( hwnd, hrgn );
6608 /* validate everything */
6609 ret = RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
6610 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
6611 check_update_rgn( hwnd, 0 );
6612
6613 /* test empty region */
6614 SetRectRgn( hrgn, 10, 10, 10, 15 );
6615 ret = RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
6616 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
6617 check_update_rgn( hwnd, 0 );
6618 /* test empty rect */
6619 SetRect( &rect, 10, 10, 10, 15 );
6620 ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
6621 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
6622 check_update_rgn( hwnd, 0 );
6623
6624 /* flush pending messages */
6625 flush_events();
6626 flush_sequence();
6627
6628 GetClientRect( hwnd, &rect );
6629 SetRectRgn( hrgn, 0, 0, rect.right - rect.left, rect.bottom - rect.top );
6630 /* MSDN: if hwnd parameter is NULL, InvalidateRect invalidates and redraws
6631 * all windows and sends WM_ERASEBKGND and WM_NCPAINT.
6632 */
6633 trace("testing InvalidateRect(0, NULL, FALSE)\n");
6634 SetRectEmpty( &rect );
6635 ok(InvalidateRect(0, &rect, FALSE), "InvalidateRect(0, &rc, FALSE) should fail\n");
6636 check_update_rgn( hwnd, hrgn );
6637 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
6638 flush_events();
6639 ok_sequence( WmPaint, "Paint", FALSE );
6640 RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
6641 check_update_rgn( hwnd, 0 );
6642
6643 /* MSDN: if hwnd parameter is NULL, ValidateRect invalidates and redraws
6644 * all windows and sends WM_ERASEBKGND and WM_NCPAINT.
6645 */
6646 trace("testing ValidateRect(0, NULL)\n");
6647 SetRectEmpty( &rect );
6648 if (ValidateRect(0, &rect)) /* not supported on Win9x */
6649 {
6650 check_update_rgn( hwnd, hrgn );
6651 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
6652 flush_events();
6653 ok_sequence( WmPaint, "Paint", FALSE );
6654 RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
6655 check_update_rgn( hwnd, 0 );
6656 }
6657
6658 trace("testing InvalidateRgn(0, NULL, FALSE)\n");
6659 SetLastError(0xdeadbeef);
6660 ok(!InvalidateRgn(0, NULL, FALSE), "InvalidateRgn(0, NULL, FALSE) should fail\n");
6661 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || GetLastError() == 0xdeadbeef,
6662 "wrong error code %d\n", GetLastError());
6663 check_update_rgn( hwnd, 0 );
6664 flush_events();
6665 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
6666
6667 trace("testing ValidateRgn(0, NULL)\n");
6668 SetLastError(0xdeadbeef);
6669 ok(!ValidateRgn(0, NULL), "ValidateRgn(0, NULL) should fail\n");
6670 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE ||
6671 broken( GetLastError() == 0xdeadbeef ) /* win9x */,
6672 "wrong error code %d\n", GetLastError());
6673 check_update_rgn( hwnd, 0 );
6674 flush_events();
6675 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
6676
6677 trace("testing UpdateWindow(NULL)\n");
6678 SetLastError(0xdeadbeef);
6679 ok(!UpdateWindow(NULL), "UpdateWindow(NULL) should fail\n");
6680 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE ||
6681 broken( GetLastError() == 0xdeadbeef ) /* win9x */,
6682 "wrong error code %d\n", GetLastError());
6683 check_update_rgn( hwnd, 0 );
6684 flush_events();
6685 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
6686
6687 /* now with frame */
6688 SetRectRgn( hrgn, -5, -5, 20, 20 );
6689
6690 /* flush pending messages */
6691 flush_events();
6692 flush_sequence();
6693 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
6694 ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
6695
6696 SetRectRgn( hrgn, 0, 0, 20, 20 ); /* GetUpdateRgn clips to client area */
6697 check_update_rgn( hwnd, hrgn );
6698
6699 flush_sequence();
6700 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
6701 ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
6702
6703 flush_sequence();
6704 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
6705 ok_sequence( WmInvalidateFull, "InvalidateFull", FALSE );
6706
6707 GetClientRect( hwnd, &rect );
6708 SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
6709 check_update_rgn( hwnd, hrgn );
6710
6711 flush_sequence();
6712 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW );
6713 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
6714
6715 flush_sequence();
6716 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW | RDW_UPDATENOW );
6717 ok_sequence( WmInvalidatePaint, "InvalidatePaint", FALSE );
6718 check_update_rgn( hwnd, 0 );
6719
6720 flush_sequence();
6721 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_UPDATENOW );
6722 ok_sequence( WmInvalidateErasePaint, "InvalidateErasePaint", FALSE );
6723 check_update_rgn( hwnd, 0 );
6724
6725 flush_sequence();
6726 SetRectRgn( hrgn, 0, 0, 100, 100 );
6727 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
6728 SetRectRgn( hrgn, 0, 0, 50, 100 );
6729 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE );
6730 SetRectRgn( hrgn, 50, 0, 100, 100 );
6731 check_update_rgn( hwnd, hrgn );
6732 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
6733 ok_sequence( WmEmptySeq, "EmptySeq", FALSE ); /* must not generate messages, everything is valid */
6734 check_update_rgn( hwnd, 0 );
6735
6736 flush_sequence();
6737 SetRectRgn( hrgn, 0, 0, 100, 100 );
6738 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
6739 SetRectRgn( hrgn, 0, 0, 100, 50 );
6740 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
6741 ok_sequence( WmErase, "Erase", FALSE );
6742 SetRectRgn( hrgn, 0, 50, 100, 100 );
6743 check_update_rgn( hwnd, hrgn );
6744
6745 flush_sequence();
6746 SetRectRgn( hrgn, 0, 0, 100, 100 );
6747 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
6748 SetRectRgn( hrgn, 0, 0, 50, 50 );
6749 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOERASE | RDW_UPDATENOW );
6750 ok_sequence( WmPaint, "Paint", FALSE );
6751
6752 flush_sequence();
6753 SetRectRgn( hrgn, -4, -4, -2, -2 );
6754 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
6755 SetRectRgn( hrgn, -200, -200, -198, -198 );
6756 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME | RDW_ERASENOW );
6757 ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
6758
6759 flush_sequence();
6760 SetRectRgn( hrgn, -4, -4, -2, -2 );
6761 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
6762 SetRectRgn( hrgn, -4, -4, -3, -3 );
6763 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME );
6764 SetRectRgn( hrgn, 0, 0, 1, 1 );
6765 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_UPDATENOW );
6766 ok_sequence( WmPaint, "Paint", FALSE );
6767
6768 flush_sequence();
6769 SetRectRgn( hrgn, -4, -4, -1, -1 );
6770 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
6771 RedrawWindow( hwnd, NULL, 0, RDW_ERASENOW );
6772 /* make sure no WM_PAINT was generated */
6773 flush_events();
6774 ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
6775
6776 flush_sequence();
6777 SetRectRgn( hrgn, -4, -4, -1, -1 );
6778 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
6779 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
6780 {
6781 if (msg.hwnd == hwnd && msg.message == WM_PAINT)
6782 {
6783 /* GetUpdateRgn must return empty region since only nonclient area is invalidated */
6784 INT ret = GetUpdateRgn( hwnd, hrgn, FALSE );
6785 ok( ret == NULLREGION, "Invalid GetUpdateRgn result %d\n", ret );
6786 ret = GetUpdateRect( hwnd, &rect, FALSE );
6787 ok( ret, "Invalid GetUpdateRect result %d\n", ret );
6788 /* this will send WM_NCPAINT and validate the non client area */
6789 ret = GetUpdateRect( hwnd, &rect, TRUE );
6790 ok( !ret, "Invalid GetUpdateRect result %d\n", ret );
6791 }
6792 DispatchMessageA( &msg );
6793 }
6794 ok_sequence( WmGetUpdateRect, "GetUpdateRect", FALSE );
6795
6796 DestroyWindow( hwnd );
6797
6798 /* now test with a child window */
6799
6800 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW,
6801 100, 100, 200, 200, 0, 0, 0, NULL);
6802 ok (hparent != 0, "Failed to create parent window\n");
6803
6804 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE | WS_BORDER,
6805 10, 10, 100, 100, hparent, 0, 0, NULL);
6806 ok (hchild != 0, "Failed to create child window\n");
6807
6808 ShowWindow( hparent, SW_SHOW );
6809 UpdateWindow( hparent );
6810 UpdateWindow( hchild );
6811 flush_events();
6812 flush_sequence();
6813 log_all_parent_messages++;
6814
6815 SetRect( &rect, 0, 0, 50, 50 );
6816 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6817 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW | RDW_ALLCHILDREN );
6818 ok_sequence( WmInvalidateParentChild, "InvalidateParentChild", FALSE );
6819
6820 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6821 pt.x = pt.y = 0;
6822 MapWindowPoints( hchild, hparent, &pt, 1 );
6823 SetRectRgn( hrgn, 0, 0, 50 - pt.x, 50 - pt.y );
6824 check_update_rgn( hchild, hrgn );
6825 SetRectRgn( hrgn, 0, 0, 50, 50 );
6826 check_update_rgn( hparent, hrgn );
6827 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
6828 ok_sequence( WmInvalidateParent, "InvalidateParent", FALSE );
6829 RedrawWindow( hchild, NULL, 0, RDW_ERASENOW );
6830 ok_sequence( WmEmptySeq, "EraseNow child", FALSE );
6831
6832 flush_events();
6833 ok_sequence( WmParentPaintNc, "WmParentPaintNc", FALSE );
6834
6835 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
6836 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
6837 ok_sequence( WmInvalidateParent, "InvalidateParent2", FALSE );
6838 RedrawWindow( hchild, NULL, 0, RDW_ERASENOW );
6839 ok_sequence( WmEmptySeq, "EraseNow child", FALSE );
6840
6841 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
6842 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW | RDW_ALLCHILDREN );
6843 ok_sequence( WmInvalidateParentChild2, "InvalidateParentChild2", FALSE );
6844
6845 SetWindowLongA( hparent, GWL_STYLE, GetWindowLongA(hparent,GWL_STYLE) | WS_CLIPCHILDREN );
6846 flush_sequence();
6847 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
6848 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
6849 ok_sequence( WmInvalidateParentChild, "InvalidateParentChild3", FALSE );
6850
6851 /* flush all paint messages */
6852 flush_events();
6853 flush_sequence();
6854
6855 /* RDW_UPDATENOW on child with WS_CLIPCHILDREN doesn't change corresponding parent area */
6856 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
6857 SetRectRgn( hrgn, 0, 0, 50, 50 );
6858 check_update_rgn( hparent, hrgn );
6859 RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
6860 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
6861 SetRectRgn( hrgn, 0, 0, 50, 50 );
6862 check_update_rgn( hparent, hrgn );
6863
6864 /* flush all paint messages */
6865 flush_events();
6866 SetWindowLongA( hparent, GWL_STYLE, GetWindowLongA(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
6867 flush_sequence();
6868
6869 /* RDW_UPDATENOW on child without WS_CLIPCHILDREN will validate corresponding parent area */
6870 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6871 SetRectRgn( hrgn, 0, 0, 50, 50 );
6872 check_update_rgn( hparent, hrgn );
6873 RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
6874 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
6875 SetRectRgn( hrgn2, 10, 10, 50, 50 );
6876 CombineRgn( hrgn, hrgn, hrgn2, RGN_DIFF );
6877 check_update_rgn( hparent, hrgn );
6878 /* flush all paint messages */
6879 flush_events();
6880 flush_sequence();
6881
6882 /* same as above but parent gets completely validated */
6883 SetRect( &rect, 20, 20, 30, 30 );
6884 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6885 SetRectRgn( hrgn, 20, 20, 30, 30 );
6886 check_update_rgn( hparent, hrgn );
6887 RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
6888 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
6889 check_update_rgn( hparent, 0 ); /* no update region */
6890 flush_events();
6891 ok_sequence( WmEmptySeq, "WmEmpty", FALSE ); /* and no paint messages */
6892
6893 /* make sure RDW_VALIDATE on child doesn't have the same effect */
6894 flush_sequence();
6895 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6896 SetRectRgn( hrgn, 20, 20, 30, 30 );
6897 check_update_rgn( hparent, hrgn );
6898 RedrawWindow( hchild, NULL, 0, RDW_VALIDATE | RDW_NOERASE );
6899 SetRectRgn( hrgn, 20, 20, 30, 30 );
6900 check_update_rgn( hparent, hrgn );
6901
6902 /* same as above but normal WM_PAINT doesn't validate parent */
6903 flush_sequence();
6904 SetRect( &rect, 20, 20, 30, 30 );
6905 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6906 SetRectRgn( hrgn, 20, 20, 30, 30 );
6907 check_update_rgn( hparent, hrgn );
6908 /* no WM_PAINT in child while parent still pending */
6909 while (PeekMessageA( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
6910 ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
6911 while (PeekMessageA( &msg, hparent, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
6912 ok_sequence( WmParentErasePaint, "WmParentErasePaint", FALSE );
6913
6914 flush_sequence();
6915 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
6916 /* no WM_PAINT in child while parent still pending */
6917 while (PeekMessageA( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
6918 ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
6919 RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_NOERASE | RDW_NOCHILDREN );
6920 /* now that parent is valid child should get WM_PAINT */
6921 while (PeekMessageA( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
6922 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
6923 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
6924 ok_sequence( WmEmptySeq, "No other message", FALSE );
6925
6926 /* same thing with WS_CLIPCHILDREN in parent */
6927 flush_sequence();
6928 SetWindowLongA( hparent, GWL_STYLE, GetWindowLongA(hparent,GWL_STYLE) | WS_CLIPCHILDREN );
6929 ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
6930 /* changing style invalidates non client area, but we need to invalidate something else to see it */
6931 RedrawWindow( hparent, &rect, 0, RDW_UPDATENOW );
6932 ok_sequence( WmEmptySeq, "No message", FALSE );
6933 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_UPDATENOW );
6934 ok_sequence( WmParentOnlyNcPaint, "WmParentOnlyNcPaint", FALSE );
6935
6936 flush_sequence();
6937 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN );
6938 SetRectRgn( hrgn, 20, 20, 30, 30 );
6939 check_update_rgn( hparent, hrgn );
6940 /* no WM_PAINT in child while parent still pending */
6941 while (PeekMessageA( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
6942 ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
6943 /* WM_PAINT in parent first */
6944 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
6945 ok_sequence( WmParentPaintNc, "WmParentPaintNc2", FALSE );
6946
6947 /* no RDW_ERASE in parent still causes RDW_ERASE and RDW_FRAME in child */
6948 flush_sequence();
6949 SetRect( &rect, 0, 0, 30, 30 );
6950 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ALLCHILDREN );
6951 SetRectRgn( hrgn, 0, 0, 30, 30 );
6952 check_update_rgn( hparent, hrgn );
6953 flush_events();
6954 ok_sequence( WmParentPaintNc, "WmParentPaintNc3", FALSE );
6955
6956 /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
6957 flush_sequence();
6958 SetRect( &rect, -10, 0, 30, 30 );
6959 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE );
6960 SetRect( &rect, 0, 0, 20, 20 );
6961 RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_ALLCHILDREN );
6962 RedrawWindow( hparent, NULL, 0, RDW_UPDATENOW );
6963 ok_sequence( WmChildPaintNc, "WmChildPaintNc", FALSE );
6964
6965 /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
6966 flush_sequence();
6967 SetRect( &rect, -10, 0, 30, 30 );
6968 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE );
6969 SetRect( &rect, 0, 0, 100, 100 );
6970 RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_ALLCHILDREN );
6971 RedrawWindow( hparent, NULL, 0, RDW_UPDATENOW );
6972 ok_sequence( WmEmptySeq, "WmChildPaintNc2", FALSE );
6973 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
6974 ok_sequence( WmEmptySeq, "WmChildPaintNc3", FALSE );
6975
6976 /* WS_CLIPCHILDREN doesn't exclude children from update region */
6977 flush_sequence();
6978 RedrawWindow( hparent, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_NOCHILDREN );
6979 GetClientRect( hparent, &rect );
6980 SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
6981 check_update_rgn( hparent, hrgn );
6982 flush_events();
6983
6984 RedrawWindow( hparent, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN );
6985 GetClientRect( hparent, &rect );
6986 SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
6987 check_update_rgn( hparent, hrgn );
6988 flush_events();
6989
6990 /* test RDW_INTERNALPAINT behavior */
6991
6992 flush_sequence();
6993 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_NOCHILDREN );
6994 flush_events();
6995 ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
6996
6997 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_ALLCHILDREN );
6998 flush_events();
6999 ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
7000
7001 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
7002 flush_events();
7003 ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
7004
7005 assert( GetWindowLongA(hparent, GWL_STYLE) & WS_CLIPCHILDREN );
7006 UpdateWindow( hparent );
7007 flush_events();
7008 flush_sequence();
7009 trace("testing SWP_FRAMECHANGED on parent with WS_CLIPCHILDREN\n");
7010 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
7011 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
7012 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
7013 flush_events();
7014 ok_sequence(WmSWP_FrameChanged_clip, "SetWindowPos:FrameChanged_clip", FALSE );
7015
7016 UpdateWindow( hparent );
7017 flush_events();
7018 flush_sequence();
7019 trace("testing SWP_FRAMECHANGED|SWP_DEFERERASE on parent with WS_CLIPCHILDREN\n");
7020 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
7021 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_DEFERERASE |
7022 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
7023 flush_events();
7024 ok_sequence(WmSWP_FrameChangedDeferErase, "SetWindowPos:FrameChangedDeferErase", FALSE );
7025
7026 SetWindowLongA( hparent, GWL_STYLE, GetWindowLongA(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
7027 ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
7028 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
7029 flush_events();
7030 ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
7031
7032 assert( !(GetWindowLongA(hparent, GWL_STYLE) & WS_CLIPCHILDREN) );
7033 UpdateWindow( hparent );
7034 flush_events();
7035 flush_sequence();
7036 trace("testing SWP_FRAMECHANGED on parent without WS_CLIPCHILDREN\n");
7037 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
7038 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
7039 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
7040 flush_events();
7041 ok_sequence(WmSWP_FrameChanged_noclip, "SetWindowPos:FrameChanged_noclip", FALSE );
7042
7043 UpdateWindow( hparent );
7044 flush_events();
7045 flush_sequence();
7046 trace("testing SWP_FRAMECHANGED|SWP_DEFERERASE on parent without WS_CLIPCHILDREN\n");
7047 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
7048 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_DEFERERASE |
7049 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
7050 flush_events();
7051 ok_sequence(WmSWP_FrameChangedDeferErase, "SetWindowPos:FrameChangedDeferErase", FALSE );
7052
7053 ok(GetWindowLongA( hparent, GWL_STYLE ) & WS_VISIBLE, "parent should be visible\n");
7054 ok(GetWindowLongA( hchild, GWL_STYLE ) & WS_VISIBLE, "child should be visible\n");
7055
7056 UpdateWindow( hparent );
7057 flush_events();
7058 flush_sequence();
7059 trace("testing SetWindowPos(-10000, -10000) on child\n");
7060 SetWindowPos( hchild, 0, -10000, -10000, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER );
7061 check_update_rgn( hchild, 0 );
7062 flush_events();
7063
7064 #if 0 /* this one doesn't pass under Wine yet */
7065 UpdateWindow( hparent );
7066 flush_events();
7067 flush_sequence();
7068 trace("testing ShowWindow(SW_MINIMIZE) on child\n");
7069 ShowWindow( hchild, SW_MINIMIZE );
7070 check_update_rgn( hchild, 0 );
7071 flush_events();
7072 #endif
7073
7074 UpdateWindow( hparent );
7075 flush_events();
7076 flush_sequence();
7077 trace("testing SetWindowPos(-10000, -10000) on parent\n");
7078 SetWindowPos( hparent, 0, -10000, -10000, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER );
7079 check_update_rgn( hparent, 0 );
7080 flush_events();
7081
7082 log_all_parent_messages--;
7083 DestroyWindow( hparent );
7084 ok(!IsWindow(hchild), "child must be destroyed with its parent\n");
7085
7086 /* tests for moving windows off-screen (needs simple WS_POPUP windows) */
7087
7088 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_POPUP | WS_VISIBLE,
7089 100, 100, 200, 200, 0, 0, 0, NULL);
7090 ok (hparent != 0, "Failed to create parent window\n");
7091
7092 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
7093 10, 10, 100, 100, hparent, 0, 0, NULL);
7094 ok (hchild != 0, "Failed to create child window\n");
7095
7096 ShowWindow( hparent, SW_SHOW );
7097 UpdateWindow( hparent );
7098 UpdateWindow( hchild );
7099 flush_events();
7100 flush_sequence();
7101
7102 /* moving child outside of parent boundaries changes update region */
7103 SetRect( &rect, 0, 0, 40, 40 );
7104 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
7105 SetRectRgn( hrgn, 0, 0, 40, 40 );
7106 check_update_rgn( hchild, hrgn );
7107 MoveWindow( hchild, -10, 10, 100, 100, FALSE );
7108 SetRectRgn( hrgn, 10, 0, 40, 40 );
7109 check_update_rgn( hchild, hrgn );
7110 MoveWindow( hchild, -10, -10, 100, 100, FALSE );
7111 SetRectRgn( hrgn, 10, 10, 40, 40 );
7112 check_update_rgn( hchild, hrgn );
7113
7114 /* moving parent off-screen does too */
7115 SetRect( &rect, 0, 0, 100, 100 );
7116 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_NOCHILDREN );
7117 SetRectRgn( hrgn, 0, 0, 100, 100 );
7118 check_update_rgn( hparent, hrgn );
7119 SetRectRgn( hrgn, 10, 10, 40, 40 );
7120 check_update_rgn( hchild, hrgn );
7121 MoveWindow( hparent, -20, -20, 200, 200, FALSE );
7122 SetRectRgn( hrgn, 20, 20, 100, 100 );
7123 check_update_rgn( hparent, hrgn );
7124 SetRectRgn( hrgn, 30, 30, 40, 40 );
7125 check_update_rgn( hchild, hrgn );
7126
7127 /* invalidated region is cropped by the parent rects */
7128 SetRect( &rect, 0, 0, 50, 50 );
7129 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
7130 SetRectRgn( hrgn, 30, 30, 50, 50 );
7131 check_update_rgn( hchild, hrgn );
7132
7133 DestroyWindow( hparent );
7134 ok(!IsWindow(hchild), "child must be destroyed with its parent\n");
7135 flush_sequence();
7136
7137 DeleteObject( hrgn );
7138 DeleteObject( hrgn2 );
7139 }
7140
7141 struct wnd_event
7142 {
7143 HWND hwnd;
7144 HANDLE grand_child;
7145 HANDLE start_event;
7146 HANDLE stop_event;
7147 };
7148
7149 static DWORD WINAPI thread_proc(void *param)
7150 {
7151 MSG msg;
7152 struct wnd_event *wnd_event = param;
7153
7154 wnd_event->hwnd = CreateWindowExA(0, "TestWindowClass", "window caption text", WS_OVERLAPPEDWINDOW,
7155 100, 100, 200, 200, 0, 0, 0, NULL);
7156 ok(wnd_event->hwnd != 0, "Failed to create overlapped window\n");
7157
7158 SetEvent(wnd_event->start_event);
7159
7160 while (GetMessageA(&msg, 0, 0, 0))
7161 {
7162 TranslateMessage(&msg);
7163 DispatchMessageA(&msg);
7164 }
7165
7166 ok(IsWindow(wnd_event->hwnd), "window should still exist\n");
7167
7168 return 0;
7169 }
7170
7171 static DWORD CALLBACK create_grand_child_thread( void *param )
7172 {
7173 struct wnd_event *wnd_event = param;
7174 HWND hchild;
7175 MSG msg;
7176
7177 hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
7178 WS_CHILD | WS_VISIBLE, 0, 0, 10, 10, wnd_event->hwnd, 0, 0, NULL);
7179 ok (hchild != 0, "Failed to create child window\n");
7180 flush_events();
7181 flush_sequence();
7182 SetEvent( wnd_event->start_event );
7183
7184 for (;;)
7185 {
7186 MsgWaitForMultipleObjects(0, NULL, FALSE, 1000, QS_ALLINPUT);
7187 if (!IsWindow( hchild )) break; /* will be destroyed when parent thread exits */
7188 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
7189 }
7190 return 0;
7191 }
7192
7193 static DWORD CALLBACK create_child_thread( void *param )
7194 {
7195 struct wnd_event *wnd_event = param;
7196 struct wnd_event child_event;
7197 DWORD ret, tid;
7198 MSG msg;
7199
7200 child_event.hwnd = CreateWindowExA(0, "TestWindowClass", "Test child",
7201 WS_CHILD | WS_VISIBLE, 0, 0, 10, 10, wnd_event->hwnd, 0, 0, NULL);
7202 ok (child_event.hwnd != 0, "Failed to create child window\n");
7203 SetFocus( child_event.hwnd );
7204 flush_events();
7205 flush_sequence();
7206 child_event.start_event = wnd_event->start_event;
7207 wnd_event->grand_child = CreateThread(NULL, 0, create_grand_child_thread, &child_event, 0, &tid);
7208 for (;;)
7209 {
7210 DWORD ret = MsgWaitForMultipleObjects(1, &child_event.start_event, FALSE, 1000, QS_SENDMESSAGE);
7211 if (ret != 1) break;
7212 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
7213 }
7214 ret = WaitForSingleObject( wnd_event->stop_event, 5000 );
7215 ok( !ret, "WaitForSingleObject failed %x\n", ret );
7216 return 0;
7217 }
7218
7219 static const char manifest_dep[] =
7220 "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
7221 "<assemblyIdentity version=\"1.2.3.4\" name=\"testdep1\" type=\"win32\" processorArchitecture=\"" ARCH "\"/>"
7222 " <file name=\"testdep.dll\" />"
7223 "</assembly>";
7224
7225 static const char manifest_main[] =
7226 "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
7227 "<assemblyIdentity version=\"1.2.3.4\" name=\"Wine.Test\" type=\"win32\" />"
7228 "<dependency>"
7229 " <dependentAssembly>"
7230 " <assemblyIdentity type=\"win32\" name=\"testdep1\" version=\"1.2.3.4\" processorArchitecture=\"" ARCH "\" />"
7231 " </dependentAssembly>"
7232 "</dependency>"
7233 "</assembly>";
7234
7235 static void create_manifest_file(const char *filename, const char *manifest)
7236 {
7237 WCHAR path[MAX_PATH];
7238 HANDLE file;
7239 DWORD size;
7240
7241 MultiByteToWideChar( CP_ACP, 0, filename, -1, path, MAX_PATH );
7242 file = CreateFileW(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
7243 ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %u\n", GetLastError());
7244 WriteFile(file, manifest, strlen(manifest), &size, NULL);
7245 CloseHandle(file);
7246 }
7247
7248 static HANDLE test_create(const char *file)
7249 {
7250 WCHAR path[MAX_PATH];
7251 ACTCTXW actctx;
7252 HANDLE handle;
7253
7254 MultiByteToWideChar(CP_ACP, 0, file, -1, path, MAX_PATH);
7255 memset(&actctx, 0, sizeof(ACTCTXW));
7256 actctx.cbSize = sizeof(ACTCTXW);
7257 actctx.lpSource = path;
7258
7259 handle = pCreateActCtxW(&actctx);
7260 ok(handle != INVALID_HANDLE_VALUE, "failed to create context, error %u\n", GetLastError());
7261
7262 ok(actctx.cbSize == sizeof(actctx), "cbSize=%d\n", actctx.cbSize);
7263 ok(actctx.dwFlags == 0, "dwFlags=%d\n", actctx.dwFlags);
7264 ok(actctx.lpSource == path, "lpSource=%p\n", actctx.lpSource);
7265 ok(actctx.wProcessorArchitecture == 0, "wProcessorArchitecture=%d\n", actctx.wProcessorArchitecture);
7266 ok(actctx.wLangId == 0, "wLangId=%d\n", actctx.wLangId);
7267 ok(actctx.lpAssemblyDirectory == NULL, "lpAssemblyDirectory=%p\n", actctx.lpAssemblyDirectory);
7268 ok(actctx.lpResourceName == NULL, "lpResourceName=%p\n", actctx.lpResourceName);
7269 ok(actctx.lpApplicationName == NULL, "lpApplicationName=%p\n", actctx.lpApplicationName);
7270 ok(actctx.hModule == NULL, "hModule=%p\n", actctx.hModule);
7271
7272 return handle;
7273 }
7274
7275 static void test_interthread_messages(void)
7276 {
7277 HANDLE hThread, context, handle, event;
7278 ULONG_PTR cookie;
7279 DWORD tid;
7280 WNDPROC proc;
7281 MSG msg;
7282 char buf[256];
7283 int len, expected_len;
7284 struct wnd_event wnd_event;
7285 BOOL ret;
7286
7287 wnd_event.start_event = CreateEventW(NULL, 0, 0, NULL);
7288 if (!wnd_event.start_event)
7289 {
7290 win_skip("skipping interthread message test under win9x\n");
7291 return;
7292 }
7293
7294 hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
7295 ok(hThread != NULL, "CreateThread failed, error %d\n", GetLastError());
7296
7297 ok(WaitForSingleObject(wnd_event.start_event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7298
7299 CloseHandle(wnd_event.start_event);
7300
7301 SetLastError(0xdeadbeef);
7302 ok(!DestroyWindow(wnd_event.hwnd), "DestroyWindow succeeded\n");
7303 ok(GetLastError() == ERROR_ACCESS_DENIED || GetLastError() == 0xdeadbeef,
7304 "wrong error code %d\n", GetLastError());
7305
7306 proc = (WNDPROC)GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
7307 ok(proc != NULL, "GetWindowLongPtrA(GWLP_WNDPROC) error %d\n", GetLastError());
7308
7309 expected_len = lstrlenA("window caption text");
7310 memset(buf, 0, sizeof(buf));
7311 SetLastError(0xdeadbeef);
7312 len = CallWindowProcA(proc, wnd_event.hwnd, WM_GETTEXT, sizeof(buf), (LPARAM)buf);
7313 ok(len == expected_len, "CallWindowProcA(WM_GETTEXT) error %d, len %d, expected len %d\n", GetLastError(), len, expected_len);
7314 ok(!lstrcmpA(buf, "window caption text"), "window text mismatch\n");
7315
7316 msg.hwnd = wnd_event.hwnd;
7317 msg.message = WM_GETTEXT;
7318 msg.wParam = sizeof(buf);
7319 msg.lParam = (LPARAM)buf;
7320 memset(buf, 0, sizeof(buf));
7321 SetLastError(0xdeadbeef);
7322 len = DispatchMessageA(&msg);
7323 ok((!len && GetLastError() == ERROR_MESSAGE_SYNC_ONLY) || broken(len), /* nt4 */
7324 "DispatchMessageA(WM_GETTEXT) succeeded on another thread window: ret %d, error %d\n", len, GetLastError());
7325
7326 /* the following test causes an exception in user.exe under win9x */
7327 msg.hwnd = wnd_event.hwnd;
7328 msg.message = WM_TIMER;
7329 msg.wParam = 0;
7330 msg.lParam = GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
7331 SetLastError(0xdeadbeef);
7332 len = DispatchMessageA(&msg);
7333 ok(!len && GetLastError() == 0xdeadbeef,
7334 "DispatchMessageA(WM_TIMER) failed on another thread window: ret %d, error %d\n", len, GetLastError());
7335
7336 ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
7337 ok( ret, "PostMessageA(WM_QUIT) error %d\n", GetLastError());
7338
7339 ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7340 CloseHandle(hThread);
7341
7342 ok(!IsWindow(wnd_event.hwnd), "window should be destroyed on thread exit\n");
7343
7344 wnd_event.hwnd = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
7345 100, 100, 200, 200, 0, 0, 0, NULL);
7346 ok (wnd_event.hwnd != 0, "Failed to create parent window\n");
7347 flush_events();
7348 flush_sequence();
7349 log_all_parent_messages++;
7350 wnd_event.start_event = CreateEventA( NULL, TRUE, FALSE, NULL );
7351 wnd_event.stop_event = CreateEventA( NULL, TRUE, FALSE, NULL );
7352 hThread = CreateThread( NULL, 0, create_child_thread, &wnd_event, 0, &tid );
7353 for (;;)
7354 {
7355 ret = MsgWaitForMultipleObjects(1, &wnd_event.start_event, FALSE, 1000, QS_SENDMESSAGE);
7356 if (ret != 1) break;
7357 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
7358 }
7359 ok( !ret, "MsgWaitForMultipleObjects failed %x\n", ret );
7360 /* now wait for the thread without processing messages; this shouldn't deadlock */
7361 SetEvent( wnd_event.stop_event );
7362 ret = WaitForSingleObject( hThread, 5000 );
7363 ok( !ret, "WaitForSingleObject failed %x\n", ret );
7364 CloseHandle( hThread );
7365
7366 ret = WaitForSingleObject( wnd_event.grand_child, 5000 );
7367 ok( !ret, "WaitForSingleObject failed %x\n", ret );
7368 CloseHandle( wnd_event.grand_child );
7369
7370 CloseHandle( wnd_event.start_event );
7371 CloseHandle( wnd_event.stop_event );
7372 flush_events();
7373 ok_sequence(WmExitThreadSeq, "destroy child on thread exit", FALSE);
7374 log_all_parent_messages--;
7375 DestroyWindow( wnd_event.hwnd );
7376
7377 /* activation context tests */
7378 if (!pActivateActCtx)
7379 {
7380 win_skip("Activation contexts are not supported, skipping\n");
7381 return;
7382 }
7383
7384 create_manifest_file("testdep1.manifest", manifest_dep);
7385 create_manifest_file("main.manifest", manifest_main);
7386
7387 context = test_create("main.manifest");
7388 DeleteFileA("testdep1.manifest");
7389 DeleteFileA("main.manifest");
7390
7391 handle = (void*)0xdeadbeef;
7392 ret = pGetCurrentActCtx(&handle);
7393 ok(ret, "GetCurentActCtx failed: %u\n", GetLastError());
7394 ok(handle == 0, "active context %p\n", handle);
7395
7396 wnd_event.start_event = CreateEventW(NULL, 0, 0, NULL);
7397 hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
7398 ok(hThread != NULL, "CreateThread failed, error %d\n", GetLastError());
7399 ok(WaitForSingleObject(wnd_event.start_event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7400 CloseHandle(wnd_event.start_event);
7401
7402 /* context is activated after thread creation, so it doesn't inherit it by default */
7403 ret = pActivateActCtx(context, &cookie);
7404 ok(ret, "activation failed: %u\n", GetLastError());
7405
7406 handle = 0;
7407 ret = pGetCurrentActCtx(&handle);
7408 ok(ret, "GetCurentActCtx failed: %u\n", GetLastError());
7409 ok(handle != 0, "active context %p\n", handle);
7410 pReleaseActCtx(handle);
7411
7412 /* destination window will test for active context */
7413 ret = SendMessageA(wnd_event.hwnd, WM_USER+10, 0, 0);
7414 ok(ret, "thread window returned %d\n", ret);
7415
7416 event = CreateEventW(NULL, 0, 0, NULL);
7417 ret = PostMessageA(wnd_event.hwnd, WM_USER+10, 0, (LPARAM)event);
7418 ok(ret, "thread window returned %d\n", ret);
7419 ok(WaitForSingleObject(event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7420 CloseHandle(event);
7421
7422 ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
7423 ok(ret, "PostMessageA(WM_QUIT) error %d\n", GetLastError());
7424
7425 ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7426 CloseHandle(hThread);
7427
7428 ret = pDeactivateActCtx(0, cookie);
7429 ok(ret, "DeactivateActCtx failed: %u\n", GetLastError());
7430 pReleaseActCtx(context);
7431 }
7432
7433
7434 static const struct message WmVkN[] = {
7435 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
7436 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
7437 { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
7438 { WM_CHAR, wparam|lparam, 'n', 1 },
7439 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1002,1), 0 },
7440 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
7441 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
7442 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
7443 { 0 }
7444 };
7445 static const struct message WmShiftVkN[] = {
7446 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
7447 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
7448 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
7449 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
7450 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
7451 { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
7452 { WM_CHAR, wparam|lparam, 'N', 1 },
7453 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1001,1), 0 },
7454 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
7455 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
7456 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
7457 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xc0000001 }, /* XP */
7458 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
7459 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
7460 { 0 }
7461 };
7462 static const struct message WmCtrlVkN[] = {
7463 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
7464 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
7465 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
7466 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
7467 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
7468 { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
7469 { WM_CHAR, wparam|lparam, 0x000e, 1 },
7470 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
7471 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
7472 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
7473 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
7474 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
7475 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
7476 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
7477 { 0 }
7478 };
7479 static const struct message WmCtrlVkN_2[] = {
7480 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
7481 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
7482 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
7483 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
7484 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
7485 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
7486 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
7487 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
7488 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
7489 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
7490 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
7491 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
7492 { 0 }
7493 };
7494 static const struct message WmAltVkN[] = {
7495 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
7496 { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
7497 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
7498 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
7499 { WM_SYSKEYDOWN, wparam|lparam, 'N', 0x20000001 },
7500 { WM_SYSKEYDOWN, sent|wparam|lparam, 'N', 0x20000001 },
7501 { WM_SYSCHAR, wparam|lparam, 'n', 0x20000001 },
7502 { WM_SYSCHAR, sent|wparam|lparam, 'n', 0x20000001 },
7503 { WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 'n' },
7504 { HCBT_SYSCOMMAND, hook },
7505 { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
7506 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
7507 { 0x00AE, sent|defwinproc|optional }, /* XP */
7508 { WM_GETTEXT, sent|defwinproc|optional }, /* XP */
7509 { WM_INITMENU, sent|defwinproc },
7510 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
7511 { WM_MENUCHAR, sent|defwinproc|wparam, MAKEWPARAM('n',MF_SYSMENU) },
7512 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
7513 { WM_CAPTURECHANGED, sent|defwinproc },
7514 { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,0xffff) },
7515 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
7516 { WM_EXITMENULOOP, sent|defwinproc },
7517 { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) }, /* Win95 bug */
7518 { WM_EXITMENULOOP, sent|defwinproc|optional }, /* Win95 bug */
7519 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
7520 { WM_SYSKEYUP, wparam|lparam, 'N', 0xe0000001 },
7521 { WM_SYSKEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
7522 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
7523 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
7524 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
7525 { 0 }
7526 };
7527 static const struct message WmAltVkN_2[] = {
7528 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
7529 { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
7530 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
7531 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
7532 { WM_SYSKEYDOWN, wparam|lparam, 'N', 0x20000001 },
7533 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1003,1), 0 },
7534 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
7535 { WM_SYSKEYUP, wparam|lparam, 'N', 0xe0000001 },
7536 { WM_SYSKEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
7537 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
7538 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
7539 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
7540 { 0 }
7541 };
7542 static const struct message WmCtrlAltVkN[] = {
7543 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
7544 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
7545 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
7546 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
7547 { WM_KEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
7548 { WM_KEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
7549 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
7550 { WM_KEYDOWN, wparam|lparam, 'N', 0x20000001 },
7551 { WM_KEYDOWN, sent|wparam|lparam, 'N', 0x20000001 },
7552 { WM_CHAR, optional },
7553 { WM_CHAR, sent|optional },
7554 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
7555 { WM_KEYUP, wparam|lparam, 'N', 0xe0000001 },
7556 { WM_KEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
7557 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
7558 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
7559 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
7560 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
7561 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
7562 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
7563 { 0 }
7564 };
7565 static const struct message WmCtrlShiftVkN[] = {
7566 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
7567 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
7568 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
7569 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
7570 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
7571 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
7572 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
7573 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
7574 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1004,1), 0 },
7575 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
7576 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
7577 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
7578 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xc0000001 }, /* XP */
7579 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
7580 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
7581 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
7582 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
7583 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
7584 { 0 }
7585 };
7586 static const struct message WmCtrlAltShiftVkN[] = {
7587 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
7588 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
7589 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
7590 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
7591 { WM_KEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
7592 { WM_KEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
7593 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0x20000001 }, /* XP */
7594 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0x20000001 },
7595 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 0x20000001 },
7596 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
7597 { WM_KEYDOWN, wparam|lparam, 'N', 0x20000001 },
7598 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1005,1), 0 },
7599 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
7600 { WM_KEYUP, wparam|lparam, 'N', 0xe0000001 },
7601 { WM_KEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
7602 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xe0000001 }, /* XP */
7603 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xe0000001 },
7604 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xe0000001 },
7605 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
7606 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
7607 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
7608 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
7609 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
7610 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
7611 { 0 }
7612 };
7613 static const struct message WmAltPressRelease[] = {
7614 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
7615 { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
7616 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
7617 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
7618 { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
7619 { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
7620 { WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 0 },
7621 { HCBT_SYSCOMMAND, hook },
7622 { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
7623 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
7624 { WM_INITMENU, sent|defwinproc },
7625 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
7626 { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,MF_SYSMENU|MF_POPUP|MF_HILITE), 0, MAKEWPARAM(0,MF_RIGHTJUSTIFY) },
7627 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
7628
7629 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x30000001 }, /* XP */
7630
7631 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
7632 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0, },
7633 { WM_CAPTURECHANGED, sent|defwinproc },
7634 { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) },
7635 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
7636 { WM_EXITMENULOOP, sent|defwinproc },
7637 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
7638 { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
7639 { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
7640 { 0 }
7641 };
7642 static const struct message WmShiftMouseButton[] = {
7643 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
7644 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
7645 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
7646 { WM_MOUSEMOVE, wparam|optional, 0, 0 },
7647 { WM_MOUSEMOVE, sent|wparam|optional, 0, 0 },
7648 { WM_LBUTTONDOWN, wparam, MK_LBUTTON|MK_SHIFT, 0 },
7649 { WM_LBUTTONDOWN, sent|wparam, MK_LBUTTON|MK_SHIFT, 0 },
7650 { WM_LBUTTONUP, wparam, MK_SHIFT, 0 },
7651 { WM_LBUTTONUP, sent|wparam, MK_SHIFT, 0 },
7652 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xc0000001 }, /* XP */
7653 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
7654 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
7655 { 0 }
7656 };
7657 static const struct message WmF1Seq[] = {
7658 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F1, 1 }, /* XP */
7659 { WM_KEYDOWN, wparam|lparam, VK_F1, 1 },
7660 { WM_KEYDOWN, sent|wparam|lparam, VK_F1, 0x00000001 },
7661 { WM_KEYF1, wparam|lparam, 0, 0 },
7662 { WM_KEYF1, sent|wparam|lparam, 0, 0 },
7663 { WM_HELP, sent|defwinproc },
7664 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F1, 0xc0000001 }, /* XP */
7665 { WM_KEYUP, wparam|lparam, VK_F1, 0xc0000001 },
7666 { WM_KEYUP, sent|wparam|lparam, VK_F1, 0xc0000001 },
7667 { 0 }
7668 };
7669 static const struct message WmVkAppsSeq[] = {
7670 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_APPS, 1 }, /* XP */
7671 { WM_KEYDOWN, wparam|lparam, VK_APPS, 1 },
7672 { WM_KEYDOWN, sent|wparam|lparam, VK_APPS, 0x00000001 },
7673 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_APPS, 0xc0000001 }, /* XP */
7674 { WM_KEYUP, wparam|lparam, VK_APPS, 0xc0000001 },
7675 { WM_KEYUP, sent|wparam|lparam, VK_APPS, 0xc0000001 },
7676 { WM_CONTEXTMENU, lparam, /*hwnd*/0, -1 },
7677 { WM_CONTEXTMENU, sent|lparam, /*hwnd*/0, -1 },
7678 { 0 }
7679 };
7680 static const struct message WmVkF10Seq[] = {
7681 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 1 }, /* XP */
7682 { WM_SYSKEYDOWN, wparam|lparam, VK_F10, 1 },
7683 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_F10, 0x00000001 },
7684 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 0xc0000001 }, /* XP */
7685 { WM_SYSKEYUP, wparam|lparam, VK_F10, 0xc0000001 },
7686 { WM_SYSKEYUP, sent|wparam|lparam, VK_F10, 0xc0000001 },
7687 { WM_SYSCOMMAND, sent|defwinproc|wparam, SC_KEYMENU },
7688 { HCBT_SYSCOMMAND, hook },
7689 { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
7690 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
7691 { WM_INITMENU, sent|defwinproc },
7692 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
7693 { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,MF_SYSMENU|MF_POPUP|MF_HILITE), 0, MAKEWPARAM(0,MF_RIGHTJUSTIFY) },
7694 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
7695
7696 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 0x10000001 }, /* XP */
7697
7698 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 1 }, /* XP */
7699 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
7700 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0, },
7701 { WM_CAPTURECHANGED, sent|defwinproc },
7702 { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) },
7703 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
7704 { WM_EXITMENULOOP, sent|defwinproc },
7705 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 0xc0000001 }, /* XP */
7706 { WM_SYSKEYUP, wparam|lparam, VK_F10, 0xc0000001 },
7707 { WM_SYSKEYUP, sent|wparam|lparam, VK_F10, 0xc0000001 },
7708 { 0 }
7709 };
7710 static const struct message WmShiftF10Seq[] = {
7711 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
7712 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
7713 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 0x00000001 },
7714 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 1 }, /* XP */
7715 { WM_SYSKEYDOWN, wparam|lparam, VK_F10, 1 },
7716 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_F10, 0x00000001 },
7717 { WM_CONTEXTMENU, sent|defwinproc|lparam, /*hwnd*/0, -1 },
7718 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 0xc0000001 }, /* XP */
7719 { WM_SYSKEYUP, wparam|lparam, VK_F10, 0xc0000001 },
7720 { WM_SYSKEYUP, sent|wparam|lparam, VK_F10, 0xc0000001 },
7721 { WM_SYSCOMMAND, sent|defwinproc|wparam, SC_KEYMENU },
7722 { HCBT_SYSCOMMAND, hook },
7723 { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
7724 { WM_INITMENU, sent|defwinproc },
7725 { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,MF_SYSMENU|MF_POPUP|MF_HILITE), 0, MAKEWPARAM(0,MF_RIGHTJUSTIFY) },
7726 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xd0000001 }, /* XP */
7727 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_ESCAPE, 0x10000001 }, /* XP */
7728 { WM_CAPTURECHANGED, sent|defwinproc|wparam|lparam, 0, 0 },
7729 { WM_MENUSELECT, sent|defwinproc|wparam|lparam, 0xffff0000, 0 },
7730 { WM_EXITMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
7731 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_ESCAPE, 0xc0000001 }, /* XP */
7732 { WM_KEYUP, wparam|lparam, VK_ESCAPE, 0xc0000001 },
7733 { WM_KEYUP, sent|wparam|lparam, VK_ESCAPE, 0xc0000001 },
7734 { 0 }
7735 };
7736
7737 static void pump_msg_loop(HWND hwnd, HACCEL hAccel)
7738 {
7739 MSG msg;
7740
7741 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
7742 {
7743 struct recvd_message log_msg;
7744
7745 /* ignore some unwanted messages */
7746 if (msg.message == WM_MOUSEMOVE ||
7747 msg.message == WM_TIMER ||
7748 ignore_message( msg.message ))
7749 continue;
7750
7751 log_msg.hwnd = msg.hwnd;
7752 log_msg.message = msg.message;
7753 log_msg.flags = wparam|lparam;
7754 log_msg.wParam = msg.wParam;
7755 log_msg.lParam = msg.lParam;
7756 log_msg.descr = "accel";
7757 add_message(&log_msg);
7758
7759 if (!hAccel || !TranslateAcceleratorA(hwnd, hAccel, &msg))
7760 {
7761 TranslateMessage(&msg);
7762 DispatchMessageA(&msg);
7763 }
7764 }
7765 }
7766
7767 static void test_accelerators(void)
7768 {
7769 RECT rc;
7770 POINT pt;
7771 SHORT state;
7772 HACCEL hAccel;
7773 HWND hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
7774 100, 100, 200, 200, 0, 0, 0, NULL);
7775 BOOL ret;
7776
7777 assert(hwnd != 0);
7778 UpdateWindow(hwnd);
7779 flush_events();
7780 flush_sequence();
7781
7782 SetFocus(hwnd);
7783 ok(GetFocus() == hwnd, "wrong focus window %p\n", GetFocus());
7784
7785 state = GetKeyState(VK_SHIFT);
7786 ok(!(state & 0x8000), "wrong Shift state %04x\n", state);
7787 state = GetKeyState(VK_CAPITAL);
7788 ok(state == 0, "wrong CapsLock state %04x\n", state);
7789
7790 hAccel = LoadAcceleratorsA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(1));
7791 assert(hAccel != 0);
7792
7793 flush_events();
7794 pump_msg_loop(hwnd, 0);
7795 flush_sequence();
7796
7797 trace("testing VK_N press/release\n");
7798 flush_sequence();
7799 keybd_event('N', 0, 0, 0);
7800 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7801 pump_msg_loop(hwnd, hAccel);
7802 if (!sequence_cnt) /* we didn't get any message */
7803 {
7804 skip( "queuing key events not supported\n" );
7805 goto done;
7806 }
7807 ok_sequence(WmVkN, "VK_N press/release", FALSE);
7808
7809 trace("testing Shift+VK_N press/release\n");
7810 flush_sequence();
7811 keybd_event(VK_SHIFT, 0, 0, 0);
7812 keybd_event('N', 0, 0, 0);
7813 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7814 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
7815 pump_msg_loop(hwnd, hAccel);
7816 ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
7817
7818 trace("testing Ctrl+VK_N press/release\n");
7819 flush_sequence();
7820 keybd_event(VK_CONTROL, 0, 0, 0);
7821 keybd_event('N', 0, 0, 0);
7822 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7823 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
7824 pump_msg_loop(hwnd, hAccel);
7825 ok_sequence(WmCtrlVkN, "Ctrl+VK_N press/release", FALSE);
7826
7827 trace("testing Alt+VK_N press/release\n");
7828 flush_sequence();
7829 keybd_event(VK_MENU, 0, 0, 0);
7830 keybd_event('N', 0, 0, 0);
7831 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7832 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
7833 pump_msg_loop(hwnd, hAccel);
7834 ok_sequence(WmAltVkN, "Alt+VK_N press/release", FALSE);
7835
7836 trace("testing Ctrl+Alt+VK_N press/release 1\n");
7837 flush_sequence();
7838 keybd_event(VK_CONTROL, 0, 0, 0);
7839 keybd_event(VK_MENU, 0, 0, 0);
7840 keybd_event('N', 0, 0, 0);
7841 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7842 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
7843 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
7844 pump_msg_loop(hwnd, hAccel);
7845 ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 1", FALSE);
7846
7847 ret = DestroyAcceleratorTable(hAccel);
7848 ok( ret, "DestroyAcceleratorTable error %d\n", GetLastError());
7849
7850 hAccel = LoadAcceleratorsA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(2));
7851 assert(hAccel != 0);
7852
7853 trace("testing VK_N press/release\n");
7854 flush_sequence();
7855 keybd_event('N', 0, 0, 0);
7856 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7857 pump_msg_loop(hwnd, hAccel);
7858 ok_sequence(WmVkN, "VK_N press/release", FALSE);
7859
7860 trace("testing Shift+VK_N press/release\n");
7861 flush_sequence();
7862 keybd_event(VK_SHIFT, 0, 0, 0);
7863 keybd_event('N', 0, 0, 0);
7864 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7865 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
7866 pump_msg_loop(hwnd, hAccel);
7867 ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
7868
7869 trace("testing Ctrl+VK_N press/release 2\n");
7870 flush_sequence();
7871 keybd_event(VK_CONTROL, 0, 0, 0);
7872 keybd_event('N', 0, 0, 0);
7873 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7874 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
7875 pump_msg_loop(hwnd, hAccel);
7876 ok_sequence(WmCtrlVkN_2, "Ctrl+VK_N press/release 2", FALSE);
7877
7878 trace("testing Alt+VK_N press/release 2\n");
7879 flush_sequence();
7880 keybd_event(VK_MENU, 0, 0, 0);
7881 keybd_event('N', 0, 0, 0);
7882 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7883 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
7884 pump_msg_loop(hwnd, hAccel);
7885 ok_sequence(WmAltVkN_2, "Alt+VK_N press/release 2", FALSE);
7886
7887 trace("testing Ctrl+Alt+VK_N press/release 2\n");
7888 flush_sequence();
7889 keybd_event(VK_CONTROL, 0, 0, 0);
7890 keybd_event(VK_MENU, 0, 0, 0);
7891 keybd_event('N', 0, 0, 0);
7892 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7893 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
7894 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
7895 pump_msg_loop(hwnd, hAccel);
7896 ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 2", FALSE);
7897
7898 trace("testing Ctrl+Shift+VK_N press/release\n");
7899 flush_sequence();
7900 keybd_event(VK_CONTROL, 0, 0, 0);
7901 keybd_event(VK_SHIFT, 0, 0, 0);
7902 keybd_event('N', 0, 0, 0);
7903 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7904 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
7905 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
7906 pump_msg_loop(hwnd, hAccel);
7907 ok_sequence(WmCtrlShiftVkN, "Ctrl+Shift+VK_N press/release", FALSE);
7908
7909 trace("testing Ctrl+Alt+Shift+VK_N press/release\n");
7910 flush_sequence();
7911 keybd_event(VK_CONTROL, 0, 0, 0);
7912 keybd_event(VK_MENU, 0, 0, 0);
7913 keybd_event(VK_SHIFT, 0, 0, 0);
7914 keybd_event('N', 0, 0, 0);
7915 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
7916 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
7917 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
7918 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
7919 pump_msg_loop(hwnd, hAccel);
7920 ok_sequence(WmCtrlAltShiftVkN, "Ctrl+Alt+Shift+VK_N press/release", FALSE);
7921
7922 ret = DestroyAcceleratorTable(hAccel);
7923 ok( ret, "DestroyAcceleratorTable error %d\n", GetLastError());
7924 hAccel = 0;
7925
7926 trace("testing Alt press/release\n");
7927 flush_sequence();
7928 keybd_event(VK_MENU, 0, 0, 0);
7929 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
7930 keybd_event(VK_MENU, 0, 0, 0);
7931 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
7932 pump_msg_loop(hwnd, 0);
7933 /* this test doesn't pass in Wine for managed windows */
7934 ok_sequence(WmAltPressRelease, "Alt press/release", TRUE);
7935
7936 trace("testing VK_F1 press/release\n");
7937 keybd_event(VK_F1, 0, 0, 0);
7938 keybd_event(VK_F1, 0, KEYEVENTF_KEYUP, 0);
7939 pump_msg_loop(hwnd, 0);
7940 ok_sequence(WmF1Seq, "F1 press/release", FALSE);
7941
7942 trace("testing VK_APPS press/release\n");
7943 keybd_event(VK_APPS, 0, 0, 0);
7944 keybd_event(VK_APPS, 0, KEYEVENTF_KEYUP, 0);
7945 pump_msg_loop(hwnd, 0);
7946 ok_sequence(WmVkAppsSeq, "VK_APPS press/release", FALSE);
7947
7948 trace("testing VK_F10 press/release\n");
7949 keybd_event(VK_F10, 0, 0, 0);
7950 keybd_event(VK_F10, 0, KEYEVENTF_KEYUP, 0);
7951 keybd_event(VK_F10, 0, 0, 0);
7952 keybd_event(VK_F10, 0, KEYEVENTF_KEYUP, 0);
7953 pump_msg_loop(hwnd, 0);
7954 ok_sequence(WmVkF10Seq, "VK_F10 press/release", TRUE);
7955
7956 trace("testing SHIFT+F10 press/release\n");
7957 keybd_event(VK_SHIFT, 0, 0, 0);
7958 keybd_event(VK_F10, 0, 0, 0);
7959 keybd_event(VK_F10, 0, KEYEVENTF_KEYUP, 0);
7960 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
7961 keybd_event(VK_ESCAPE, 0, 0, 0);
7962 keybd_event(VK_ESCAPE, 0, KEYEVENTF_KEYUP, 0);
7963 pump_msg_loop(hwnd, 0);
7964 ok_sequence(WmShiftF10Seq, "SHIFT+F10 press/release", TRUE);
7965
7966 trace("testing Shift+MouseButton press/release\n");
7967 /* first, move mouse pointer inside of the window client area */
7968 GetClientRect(hwnd, &rc);
7969 MapWindowPoints(hwnd, 0, (LPPOINT)&rc, 2);
7970 rc.left += (rc.right - rc.left)/2;
7971 rc.top += (rc.bottom - rc.top)/2;
7972 SetCursorPos(rc.left, rc.top);
7973 SetActiveWindow(hwnd);
7974
7975 flush_events();
7976 flush_sequence();
7977 GetCursorPos(&pt);
7978 if (pt.x == rc.left && pt.y == rc.top)
7979 {
7980 int i;
7981 keybd_event(VK_SHIFT, 0, 0, 0);
7982 mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
7983 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
7984 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
7985 pump_msg_loop(hwnd, 0);
7986 for (i = 0; i < sequence_cnt; i++) if (sequence[i].message == WM_LBUTTONDOWN) break;
7987 if (i < sequence_cnt)
7988 ok_sequence(WmShiftMouseButton, "Shift+MouseButton press/release", FALSE);
7989 else
7990 skip( "Shift+MouseButton event didn't get to the window\n" );
7991 }
7992
7993 done:
7994 if (hAccel) DestroyAcceleratorTable(hAccel);
7995 DestroyWindow(hwnd);
7996 }
7997
7998 /************* window procedures ********************/
7999
8000 static LRESULT MsgCheckProc (BOOL unicode, HWND hwnd, UINT message,
8001 WPARAM wParam, LPARAM lParam)
8002 {
8003 static LONG defwndproc_counter = 0;
8004 static LONG beginpaint_counter = 0;
8005 LRESULT ret;
8006 struct recvd_message msg;
8007
8008 if (ignore_message( message )) return 0;
8009
8010 switch (message)
8011 {
8012 case WM_ENABLE:
8013 {
8014 LONG style = GetWindowLongA(hwnd, GWL_STYLE);
8015 ok((BOOL)wParam == !(style & WS_DISABLED),
8016 "wrong WS_DISABLED state: %ld != %d\n", wParam, !(style & WS_DISABLED));
8017 break;
8018 }
8019
8020 case WM_CAPTURECHANGED:
8021 if (test_DestroyWindow_flag)
8022 {
8023 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
8024 if (style & WS_CHILD)
8025 lParam = GetWindowLongPtrA(hwnd, GWLP_ID);
8026 else if (style & WS_POPUP)
8027 lParam = WND_POPUP_ID;
8028 else
8029 lParam = WND_PARENT_ID;
8030 }
8031 break;
8032
8033 case WM_NCDESTROY:
8034 {
8035 HWND capture;
8036
8037 ok(!GetWindow(hwnd, GW_CHILD), "children should be unlinked at this point\n");
8038 capture = GetCapture();
8039 if (capture)
8040 {
8041 ok(capture == hwnd, "capture should NOT be released at this point (capture %p)\n", capture);
8042 trace("current capture %p, releasing...\n", capture);
8043 ReleaseCapture();
8044 }
8045 }
8046 /* fall through */
8047 case WM_DESTROY:
8048 if (pGetAncestor)
8049 ok(pGetAncestor(hwnd, GA_PARENT) != 0, "parent should NOT be unlinked at this point\n");
8050 if (test_DestroyWindow_flag)
8051 {
8052 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
8053 if (style & WS_CHILD)
8054 lParam = GetWindowLongPtrA(hwnd, GWLP_ID);
8055 else if (style & WS_POPUP)
8056 lParam = WND_POPUP_ID;
8057 else
8058 lParam = WND_PARENT_ID;
8059 }
8060 break;
8061
8062 /* test_accelerators() depends on this */
8063 case WM_NCHITTEST:
8064 return HTCLIENT;
8065
8066 case WM_USER+10:
8067 {
8068 ACTIVATION_CONTEXT_BASIC_INFORMATION basicinfo;
8069 HANDLE handle, event = (HANDLE)lParam;
8070 BOOL ret;
8071
8072 handle = (void*)0xdeadbeef;
8073 ret = pGetCurrentActCtx(&handle);
8074 ok(ret, "failed to get current context, %u\n", GetLastError());
8075 ok(handle == 0, "got active context %p\n", handle);
8076
8077 memset(&basicinfo, 0xff, sizeof(basicinfo));
8078 ret = pQueryActCtxW(QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX, handle, 0, ActivationContextBasicInformation,
8079 &basicinfo, sizeof(basicinfo), NULL);
8080 ok(ret, "got %d, error %d\n", ret, GetLastError());
8081 ok(basicinfo.hActCtx == NULL, "got %p\n", basicinfo.hActCtx);
8082 ok(basicinfo.dwFlags == 0, "got %x\n", basicinfo.dwFlags);
8083
8084 if (event) SetEvent(event);
8085 return 1;
8086 }
8087
8088 /* ignore */
8089 case WM_MOUSEMOVE:
8090 case WM_MOUSEACTIVATE:
8091 case WM_NCMOUSEMOVE:
8092 case WM_SETCURSOR:
8093 case WM_IME_SELECT:
8094 return 0;
8095 }
8096
8097 msg.hwnd = hwnd;
8098 msg.message = message;
8099 msg.flags = sent|wparam|lparam;
8100 if (defwndproc_counter) msg.flags |= defwinproc;
8101 if (beginpaint_counter) msg.flags |= beginpaint;
8102 msg.wParam = wParam;
8103 msg.lParam = lParam;
8104 msg.descr = "MsgCheckProc";
8105 add_message(&msg);
8106
8107 if (message == WM_GETMINMAXINFO && (GetWindowLongA(hwnd, GWL_STYLE) & WS_CHILD))
8108 {
8109 HWND parent = GetParent(hwnd);
8110 RECT rc;
8111 MINMAXINFO *minmax = (MINMAXINFO *)lParam;
8112
8113 GetClientRect(parent, &rc);
8114 trace("parent %p client size = (%d x %d)\n", parent, rc.right, rc.bottom);
8115 trace("Reserved=%d,%d MaxSize=%d,%d MaxPos=%d,%d MinTrack=%d,%d MaxTrack=%d,%d\n",
8116 minmax->ptReserved.x, minmax->ptReserved.y,
8117 minmax->ptMaxSize.x, minmax->ptMaxSize.y,
8118 minmax->ptMaxPosition.x, minmax->ptMaxPosition.y,
8119 minmax->ptMinTrackSize.x, minmax->ptMinTrackSize.y,
8120 minmax->ptMaxTrackSize.x, minmax->ptMaxTrackSize.y);
8121
8122 ok(minmax->ptMaxSize.x == rc.right, "default width of maximized child %d != %d\n",
8123 minmax->ptMaxSize.x, rc.right);
8124 ok(minmax->ptMaxSize.y == rc.bottom, "default height of maximized child %d != %d\n",
8125 minmax->ptMaxSize.y, rc.bottom);
8126 }
8127
8128 if (message == WM_PAINT)
8129 {
8130 PAINTSTRUCT ps;
8131 beginpaint_counter++;
8132 BeginPaint( hwnd, &ps );
8133 beginpaint_counter--;
8134 EndPaint( hwnd, &ps );
8135 return 0;
8136 }
8137
8138 defwndproc_counter++;
8139 ret = unicode ? DefWindowProcW(hwnd, message, wParam, lParam)
8140 : DefWindowProcA(hwnd, message, wParam, lParam);
8141 defwndproc_counter--;
8142
8143 return ret;
8144 }
8145
8146 static LRESULT WINAPI MsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8147 {
8148 return MsgCheckProc (FALSE, hwnd, message, wParam, lParam);
8149 }
8150
8151 static LRESULT WINAPI MsgCheckProcW(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8152 {
8153 return MsgCheckProc (TRUE, hwnd, message, wParam, lParam);
8154 }
8155
8156 static LRESULT WINAPI PopupMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8157 {
8158 static LONG defwndproc_counter = 0;
8159 LRESULT ret;
8160 struct recvd_message msg;
8161
8162 if (ignore_message( message )) return 0;
8163
8164 switch (message)
8165 {
8166 case WM_QUERYENDSESSION:
8167 case WM_ENDSESSION:
8168 lParam &= ~0x01; /* Vista adds a 0x01 flag */
8169 break;
8170 }
8171
8172 msg.hwnd = hwnd;
8173 msg.message = message;
8174 msg.flags = sent|wparam|lparam;
8175 if (defwndproc_counter) msg.flags |= defwinproc;
8176 msg.wParam = wParam;
8177 msg.lParam = lParam;
8178 msg.descr = "popup";
8179 add_message(&msg);
8180
8181 if (message == WM_CREATE)
8182 {
8183 DWORD style = GetWindowLongA(hwnd, GWL_STYLE) | WS_VISIBLE;
8184 SetWindowLongA(hwnd, GWL_STYLE, style);
8185 }
8186
8187 defwndproc_counter++;
8188 ret = DefWindowProcA(hwnd, message, wParam, lParam);
8189 defwndproc_counter--;
8190
8191 return ret;
8192 }
8193
8194 static LRESULT WINAPI ParentMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8195 {
8196 static LONG defwndproc_counter = 0;
8197 static LONG beginpaint_counter = 0;
8198 LRESULT ret;
8199 struct recvd_message msg;
8200
8201 if (ignore_message( message )) return 0;
8202
8203 if (log_all_parent_messages ||
8204 message == WM_PARENTNOTIFY || message == WM_CANCELMODE ||
8205 message == WM_SETFOCUS || message == WM_KILLFOCUS ||
8206 message == WM_ENABLE || message == WM_ENTERIDLE ||
8207 message == WM_DRAWITEM || message == WM_COMMAND ||
8208 message == WM_IME_SETCONTEXT)
8209 {
8210 switch (message)
8211 {
8212 /* ignore */
8213 case WM_NCHITTEST:
8214 return HTCLIENT;
8215 case WM_SETCURSOR:
8216 case WM_MOUSEMOVE:
8217 case WM_NCMOUSEMOVE:
8218 return 0;
8219
8220 case WM_ERASEBKGND:
8221 {
8222 RECT rc;
8223 INT ret = GetClipBox((HDC)wParam, &rc);
8224
8225 trace("WM_ERASEBKGND: GetClipBox()=%d, (%d,%d-%d,%d)\n",
8226 ret, rc.left, rc.top, rc.right, rc.bottom);
8227 break;
8228 }
8229 }
8230
8231 msg.hwnd = hwnd;
8232 msg.message = message;
8233 msg.flags = sent|parent|wparam|lparam;
8234 if (defwndproc_counter) msg.flags |= defwinproc;
8235 if (beginpaint_counter) msg.flags |= beginpaint;
8236 msg.wParam = wParam;
8237 msg.lParam = lParam;
8238 msg.descr = "parent";
8239 add_message(&msg);
8240 }
8241
8242 if (message == WM_PAINT)
8243 {
8244 PAINTSTRUCT ps;
8245 beginpaint_counter++;
8246 BeginPaint( hwnd, &ps );
8247 beginpaint_counter--;
8248 EndPaint( hwnd, &ps );
8249 return 0;
8250 }
8251
8252 defwndproc_counter++;
8253 ret = DefWindowProcA(hwnd, message, wParam, lParam);
8254 defwndproc_counter--;
8255
8256 return ret;
8257 }
8258
8259 static INT_PTR CALLBACK StopQuitMsgCheckProcA(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
8260 {
8261 if (message == WM_CREATE)
8262 PostMessageA(hwnd, WM_CLOSE, 0, 0);
8263 else if (message == WM_CLOSE)
8264 {
8265 /* Only the first WM_QUIT will survive the window destruction */
8266 PostMessageA(hwnd, WM_USER, 0x1234, 0x5678);
8267 PostMessageA(hwnd, WM_QUIT, 0x1234, 0x5678);
8268 PostMessageA(hwnd, WM_QUIT, 0x4321, 0x8765);
8269 }
8270
8271 return DefWindowProcA(hwnd, message, wp, lp);
8272 }
8273
8274 static LRESULT WINAPI TestDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8275 {
8276 static LONG defwndproc_counter = 0;
8277 LRESULT ret;
8278 struct recvd_message msg;
8279
8280 if (ignore_message( message )) return 0;
8281
8282 if (test_def_id)
8283 {
8284 DefDlgProcA(hwnd, DM_SETDEFID, 1, 0);
8285 ret = DefDlgProcA(hwnd, DM_GETDEFID, 0, 0);
8286 if (after_end_dialog)
8287 ok( ret == 0, "DM_GETDEFID should return 0 after EndDialog, got %lx\n", ret );
8288 else
8289 ok(HIWORD(ret) == DC_HASDEFID, "DM_GETDEFID should return DC_HASDEFID, got %lx\n", ret);
8290 }
8291
8292 msg.hwnd = hwnd;
8293 msg.message = message;
8294 msg.flags = sent|wparam|lparam;
8295 if (defwndproc_counter) msg.flags |= defwinproc;
8296 msg.wParam = wParam;
8297 msg.lParam = lParam;
8298 msg.descr = "dialog";
8299 add_message(&msg);
8300
8301 defwndproc_counter++;
8302 ret = DefDlgProcA(hwnd, message, wParam, lParam);
8303 defwndproc_counter--;
8304
8305 return ret;
8306 }
8307
8308 static LRESULT WINAPI ShowWindowProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8309 {
8310 static LONG defwndproc_counter = 0;
8311 LRESULT ret;
8312 struct recvd_message msg;
8313
8314 /* log only specific messages we are interested in */
8315 switch (message)
8316 {
8317 #if 0 /* probably log these as well */
8318 case WM_ACTIVATE:
8319 case WM_SETFOCUS:
8320 case WM_KILLFOCUS:
8321 #endif
8322 case WM_SHOWWINDOW:
8323 case WM_SIZE:
8324 case WM_MOVE:
8325 case WM_GETMINMAXINFO:
8326 case WM_WINDOWPOSCHANGING:
8327 case WM_WINDOWPOSCHANGED:
8328 break;
8329
8330 default: /* ignore */
8331 /*trace("showwindow: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);*/
8332 return DefWindowProcA(hwnd, message, wParam, lParam);
8333 }
8334
8335 msg.hwnd = hwnd;
8336 msg.message = message;
8337 msg.flags = sent|wparam|lparam;
8338 if (defwndproc_counter) msg.flags |= defwinproc;
8339 msg.wParam = wParam;
8340 msg.lParam = lParam;
8341 msg.descr = "show";
8342 add_message(&msg);
8343
8344 defwndproc_counter++;
8345 ret = DefWindowProcA(hwnd, message, wParam, lParam);
8346 defwndproc_counter--;
8347
8348 return ret;
8349 }
8350
8351 static LRESULT WINAPI PaintLoopProcA(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
8352 {
8353 switch (msg)
8354 {
8355 case WM_CREATE: return 0;
8356 case WM_PAINT:
8357 {
8358 MSG msg2;
8359 static int i = 0;
8360
8361 if (i < 256)
8362 {
8363 i++;
8364 if (PeekMessageA(&msg2, 0, 0, 0, 1))
8365 {
8366 TranslateMessage(&msg2);
8367 DispatchMessageA(&msg2);
8368 }
8369 i--;
8370 }
8371 else ok(broken(1), "infinite loop\n");
8372 if ( i == 0)
8373 paint_loop_done = TRUE;
8374 return DefWindowProcA(hWnd,msg,wParam,lParam);
8375 }
8376 }
8377 return DefWindowProcA(hWnd,msg,wParam,lParam);
8378 }
8379
8380 static LRESULT WINAPI HotkeyMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8381 {
8382 static LONG defwndproc_counter = 0;
8383 LRESULT ret;
8384 struct recvd_message msg;
8385 DWORD queue_status;
8386
8387 if (ignore_message( message )) return 0;
8388
8389 if ((message >= WM_KEYFIRST && message <= WM_KEYLAST) ||
8390 message == WM_HOTKEY || message >= WM_APP)
8391 {
8392 msg.hwnd = hwnd;
8393 msg.message = message;
8394 msg.flags = sent|wparam|lparam;
8395 if (defwndproc_counter) msg.flags |= defwinproc;
8396 msg.wParam = wParam;
8397 msg.lParam = lParam;
8398 msg.descr = "HotkeyMsgCheckProcA";
8399 add_message(&msg);
8400 }
8401
8402 defwndproc_counter++;
8403 ret = DefWindowProcA(hwnd, message, wParam, lParam);
8404 defwndproc_counter--;
8405
8406 if (message == WM_APP)
8407 {
8408 queue_status = GetQueueStatus(QS_HOTKEY);
8409 ok((queue_status & (QS_HOTKEY << 16)) == QS_HOTKEY << 16, "expected QS_HOTKEY << 16 set, got %x\n", queue_status);
8410 queue_status = GetQueueStatus(QS_POSTMESSAGE);
8411 ok((queue_status & (QS_POSTMESSAGE << 16)) == QS_POSTMESSAGE << 16, "expected QS_POSTMESSAGE << 16 set, got %x\n", queue_status);
8412 PostMessageA(hwnd, WM_APP+1, 0, 0);
8413 }
8414 else if (message == WM_APP+1)
8415 {
8416 queue_status = GetQueueStatus(QS_HOTKEY);
8417 ok((queue_status & (QS_HOTKEY << 16)) == 0, "expected QS_HOTKEY << 16 cleared, got %x\n", queue_status);
8418 }
8419
8420 return ret;
8421 }
8422
8423 static BOOL RegisterWindowClasses(void)
8424 {
8425 WNDCLASSA cls;
8426 WNDCLASSW clsW;
8427
8428 cls.style = 0;
8429 cls.lpfnWndProc = MsgCheckProcA;
8430 cls.cbClsExtra = 0;
8431 cls.cbWndExtra = 0;
8432 cls.hInstance = GetModuleHandleA(0);
8433 cls.hIcon = 0;
8434 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
8435 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
8436 cls.lpszMenuName = NULL;
8437 cls.lpszClassName = "TestWindowClass";
8438 if(!RegisterClassA(&cls)) return FALSE;
8439
8440 cls.lpfnWndProc = HotkeyMsgCheckProcA;
8441 cls.lpszClassName = "HotkeyWindowClass";
8442 if(!RegisterClassA(&cls)) return FALSE;
8443
8444 cls.lpfnWndProc = ShowWindowProcA;
8445 cls.lpszClassName = "ShowWindowClass";
8446 if(!RegisterClassA(&cls)) return FALSE;
8447
8448 cls.lpfnWndProc = PopupMsgCheckProcA;
8449 cls.lpszClassName = "TestPopupClass";
8450 if(!RegisterClassA(&cls)) return FALSE;
8451
8452 cls.lpfnWndProc = ParentMsgCheckProcA;
8453 cls.lpszClassName = "TestParentClass";
8454 if(!RegisterClassA(&cls)) return FALSE;
8455
8456 cls.lpfnWndProc = StopQuitMsgCheckProcA;
8457 cls.lpszClassName = "StopQuitClass";
8458 if(!RegisterClassA(&cls)) return FALSE;
8459
8460 cls.lpfnWndProc = DefWindowProcA;
8461 cls.lpszClassName = "SimpleWindowClass";
8462 if(!RegisterClassA(&cls)) return FALSE;
8463
8464 cls.lpfnWndProc = PaintLoopProcA;
8465 cls.lpszClassName = "PaintLoopWindowClass";
8466 if(!RegisterClassA(&cls)) return FALSE;
8467
8468 cls.style = CS_NOCLOSE;
8469 cls.lpszClassName = "NoCloseWindowClass";
8470 if(!RegisterClassA(&cls)) return FALSE;
8471
8472 ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
8473 cls.style = 0;
8474 cls.hInstance = GetModuleHandleA(0);
8475 cls.hbrBackground = 0;
8476 cls.lpfnWndProc = TestDlgProcA;
8477 cls.lpszClassName = "TestDialogClass";
8478 if(!RegisterClassA(&cls)) return FALSE;
8479
8480 clsW.style = 0;
8481 clsW.lpfnWndProc = MsgCheckProcW;
8482 clsW.cbClsExtra = 0;
8483 clsW.cbWndExtra = 0;
8484 clsW.hInstance = GetModuleHandleW(0);
8485 clsW.hIcon = 0;
8486 clsW.hCursor = LoadCursorW(0, (LPWSTR)IDC_ARROW);
8487 clsW.hbrBackground = GetStockObject(WHITE_BRUSH);
8488 clsW.lpszMenuName = NULL;
8489 clsW.lpszClassName = testWindowClassW;
8490 RegisterClassW(&clsW); /* ignore error, this fails on Win9x */
8491
8492 return TRUE;
8493 }
8494
8495 static BOOL is_our_logged_class(HWND hwnd)
8496 {
8497 char buf[256];
8498
8499 if (GetClassNameA(hwnd, buf, sizeof(buf)))
8500 {
8501 if (!lstrcmpiA(buf, "TestWindowClass") ||
8502 !lstrcmpiA(buf, "ShowWindowClass") ||
8503 !lstrcmpiA(buf, "TestParentClass") ||
8504 !lstrcmpiA(buf, "TestPopupClass") ||
8505 !lstrcmpiA(buf, "SimpleWindowClass") ||
8506 !lstrcmpiA(buf, "TestDialogClass") ||
8507 !lstrcmpiA(buf, "MDI_frame_class") ||
8508 !lstrcmpiA(buf, "MDI_client_class") ||
8509 !lstrcmpiA(buf, "MDI_child_class") ||
8510 !lstrcmpiA(buf, "my_button_class") ||
8511 !lstrcmpiA(buf, "my_edit_class") ||
8512 !lstrcmpiA(buf, "static") ||
8513 !lstrcmpiA(buf, "ListBox") ||
8514 !lstrcmpiA(buf, "ComboBox") ||
8515 !lstrcmpiA(buf, "MyDialogClass") ||
8516 !lstrcmpiA(buf, "#32770") ||
8517 !lstrcmpiA(buf, "#32768"))
8518 return TRUE;
8519 }
8520 return FALSE;
8521 }
8522
8523 static LRESULT CALLBACK cbt_hook_proc(int nCode, WPARAM wParam, LPARAM lParam)
8524 {
8525 HWND hwnd;
8526
8527 ok(cbt_hook_thread_id == GetCurrentThreadId(), "we didn't ask for events from other threads\n");
8528
8529 if (nCode == HCBT_CLICKSKIPPED)
8530 {
8531 /* ignore this event, XP sends it a lot when switching focus between windows */
8532 return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
8533 }
8534
8535 if (nCode == HCBT_SYSCOMMAND || nCode == HCBT_KEYSKIPPED)
8536 {
8537 struct recvd_message msg;
8538
8539 msg.hwnd = 0;
8540 msg.message = nCode;
8541 msg.flags = hook|wparam|lparam;
8542 msg.wParam = wParam;
8543 msg.lParam = lParam;
8544 msg.descr = "CBT";
8545 add_message(&msg);
8546
8547 return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
8548 }
8549
8550 if (nCode == HCBT_DESTROYWND)
8551 {
8552 if (test_DestroyWindow_flag)
8553 {
8554 DWORD style = GetWindowLongA((HWND)wParam, GWL_STYLE);
8555 if (style & WS_CHILD)
8556 lParam = GetWindowLongPtrA((HWND)wParam, GWLP_ID);
8557 else if (style & WS_POPUP)
8558 lParam = WND_POPUP_ID;
8559 else
8560 lParam = WND_PARENT_ID;
8561 }
8562 }
8563
8564 /* Log also SetFocus(0) calls */
8565 hwnd = wParam ? (HWND)wParam : (HWND)lParam;
8566
8567 if (is_our_logged_class(hwnd))
8568 {
8569 struct recvd_message msg;
8570
8571 msg.hwnd = hwnd;
8572 msg.message = nCode;
8573 msg.flags = hook|wparam|lparam;
8574 msg.wParam = wParam;
8575 msg.lParam = lParam;
8576 msg.descr = "CBT";
8577 add_message(&msg);
8578 }
8579 return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
8580 }
8581
8582 static void CALLBACK win_event_proc(HWINEVENTHOOK hevent,
8583 DWORD event,
8584 HWND hwnd,
8585 LONG object_id,
8586 LONG child_id,
8587 DWORD thread_id,
8588 DWORD event_time)
8589 {
8590 ok(thread_id == GetCurrentThreadId(), "we didn't ask for events from other threads\n");
8591
8592 /* ignore mouse cursor events */
8593 if (object_id == OBJID_CURSOR) return;
8594
8595 if (!hwnd || is_our_logged_class(hwnd))
8596 {
8597 struct recvd_message msg;
8598
8599 msg.hwnd = hwnd;
8600 msg.message = event;
8601 msg.flags = winevent_hook|wparam|lparam;
8602 msg.wParam = object_id;
8603 msg.lParam = child_id;
8604 msg.descr = "WEH";
8605 add_message(&msg);
8606 }
8607 }
8608
8609 static const WCHAR wszUnicode[] = {'U','n','i','c','o','d','e',0};
8610 static const WCHAR wszAnsi[] = {'U',0};
8611
8612 static LRESULT CALLBACK MsgConversionProcW(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
8613 {
8614 switch (uMsg)
8615 {
8616 case CB_FINDSTRINGEXACT:
8617 trace("String: %p\n", (LPCWSTR)lParam);
8618 if (!lstrcmpW((LPCWSTR)lParam, wszUnicode))
8619 return 1;
8620 if (!lstrcmpW((LPCWSTR)lParam, wszAnsi))
8621 return 0;
8622 return -1;
8623 }
8624 return DefWindowProcW(hwnd, uMsg, wParam, lParam);
8625 }
8626
8627 static const struct message WmGetTextLengthAfromW[] = {
8628 { WM_GETTEXTLENGTH, sent },
8629 { WM_GETTEXT, sent|optional },
8630 { 0 }
8631 };
8632
8633 static const WCHAR dummy_window_text[] = {'d','u','m','m','y',' ','t','e','x','t',0};
8634
8635 /* dummy window proc for WM_GETTEXTLENGTH test */
8636 static LRESULT CALLBACK get_text_len_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
8637 {
8638 switch(msg)
8639 {
8640 case WM_GETTEXTLENGTH:
8641 return lstrlenW(dummy_window_text) + 37; /* some random length */
8642 case WM_GETTEXT:
8643 lstrcpynW( (LPWSTR)lp, dummy_window_text, wp );
8644 return lstrlenW( (LPWSTR)lp );
8645 default:
8646 return DefWindowProcW( hwnd, msg, wp, lp );
8647 }
8648 }
8649
8650 static void test_message_conversion(void)
8651 {
8652 static const WCHAR wszMsgConversionClass[] =
8653 {'M','s','g','C','o','n','v','e','r','s','i','o','n','C','l','a','s','s',0};
8654 WNDCLASSW cls;
8655 LRESULT lRes;
8656 HWND hwnd;
8657 WNDPROC wndproc, newproc;
8658 BOOL ret;
8659
8660 cls.style = 0;
8661 cls.lpfnWndProc = MsgConversionProcW;
8662 cls.cbClsExtra = 0;
8663 cls.cbWndExtra = 0;
8664 cls.hInstance = GetModuleHandleW(NULL);
8665 cls.hIcon = NULL;
8666 cls.hCursor = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
8667 cls.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
8668 cls.lpszMenuName = NULL;
8669 cls.lpszClassName = wszMsgConversionClass;
8670 /* this call will fail on Win9x, but that doesn't matter as this test is
8671 * meaningless on those platforms */
8672 if(!RegisterClassW(&cls)) return;
8673
8674 hwnd = CreateWindowExW(0, wszMsgConversionClass, NULL, WS_OVERLAPPED,
8675 100, 100, 200, 200, 0, 0, 0, NULL);
8676 ok(hwnd != NULL, "Window creation failed\n");
8677
8678 /* {W, A} -> A */
8679
8680 wndproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC);
8681 lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8682 ok(lRes == 0, "String should have been converted\n");
8683 lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8684 ok(lRes == 1, "String shouldn't have been converted\n");
8685
8686 /* {W, A} -> W */
8687
8688 wndproc = (WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC);
8689 lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8690 ok(lRes == 1, "String shouldn't have been converted\n");
8691 lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8692 ok(lRes == 1, "String shouldn't have been converted\n");
8693
8694 /* Synchronous messages */
8695
8696 lRes = SendMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8697 ok(lRes == 0, "String should have been converted\n");
8698 lRes = SendMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8699 ok(lRes == 1, "String shouldn't have been converted\n");
8700
8701 /* Asynchronous messages */
8702
8703 SetLastError(0);
8704 lRes = PostMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8705 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
8706 "PostMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
8707 SetLastError(0);
8708 lRes = PostMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8709 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
8710 "PostMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
8711 SetLastError(0);
8712 lRes = PostThreadMessageA(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8713 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
8714 "PosThreadtMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
8715 SetLastError(0);
8716 lRes = PostThreadMessageW(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8717 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
8718 "PosThreadtMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
8719 SetLastError(0);
8720 lRes = SendNotifyMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8721 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
8722 "SendNotifyMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
8723 SetLastError(0);
8724 lRes = SendNotifyMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
8725 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
8726 "SendNotifyMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
8727 SetLastError(0);
8728 lRes = SendMessageCallbackA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
8729 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
8730 "SendMessageCallback on sync only message returned %ld, last error %d\n", lRes, GetLastError());
8731 SetLastError(0);
8732 lRes = SendMessageCallbackW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
8733 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
8734 "SendMessageCallback on sync only message returned %ld, last error %d\n", lRes, GetLastError());
8735
8736 /* Check WM_GETTEXTLENGTH A->W behaviour, whether WM_GETTEXT is also sent or not */
8737
8738 hwnd = CreateWindowW (testWindowClassW, wszUnicode,
8739 WS_OVERLAPPEDWINDOW,
8740 100, 100, 200, 200, 0, 0, 0, NULL);
8741 assert(hwnd);
8742 flush_sequence();
8743 lRes = SendMessageA (hwnd, WM_GETTEXTLENGTH, 0, 0);
8744 ok_sequence(WmGetTextLengthAfromW, "ANSI WM_GETTEXTLENGTH to Unicode window", FALSE);
8745 ok( lRes == WideCharToMultiByte( CP_ACP, 0, wszUnicode, lstrlenW(wszUnicode), NULL, 0, NULL, NULL ),
8746 "got bad length %ld\n", lRes );
8747
8748 flush_sequence();
8749 lRes = CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ),
8750 hwnd, WM_GETTEXTLENGTH, 0, 0);
8751 ok_sequence(WmGetTextLengthAfromW, "ANSI WM_GETTEXTLENGTH to Unicode window", FALSE);
8752 ok( lRes == WideCharToMultiByte( CP_ACP, 0, wszUnicode, lstrlenW(wszUnicode), NULL, 0, NULL, NULL ),
8753 "got bad length %ld\n", lRes );
8754
8755 wndproc = (WNDPROC)SetWindowLongPtrW( hwnd, GWLP_WNDPROC, (LONG_PTR)get_text_len_proc );
8756 newproc = (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC );
8757 lRes = CallWindowProcA( newproc, hwnd, WM_GETTEXTLENGTH, 0, 0 );
8758 ok( lRes == WideCharToMultiByte( CP_ACP, 0, dummy_window_text, lstrlenW(dummy_window_text),
8759 NULL, 0, NULL, NULL ) ||
8760 broken(lRes == lstrlenW(dummy_window_text) + 37),
8761 "got bad length %ld\n", lRes );
8762
8763 SetWindowLongPtrW( hwnd, GWLP_WNDPROC, (LONG_PTR)wndproc ); /* restore old wnd proc */
8764 lRes = CallWindowProcA( newproc, hwnd, WM_GETTEXTLENGTH, 0, 0 );
8765 ok( lRes == WideCharToMultiByte( CP_ACP, 0, dummy_window_text, lstrlenW(dummy_window_text),
8766 NULL, 0, NULL, NULL ) ||
8767 broken(lRes == lstrlenW(dummy_window_text) + 37),
8768 "got bad length %ld\n", lRes );
8769
8770 ret = DestroyWindow(hwnd);
8771 ok( ret, "DestroyWindow() error %d\n", GetLastError());
8772 }
8773
8774 struct timer_info
8775 {
8776 HWND hWnd;
8777 HANDLE handles[2];
8778 DWORD id;
8779 };
8780
8781 static VOID CALLBACK tfunc(HWND hwnd, UINT uMsg, UINT_PTR id, DWORD dwTime)
8782 {
8783 }
8784
8785 #define TIMER_ID 0x19
8786 #define TIMER_COUNT_EXPECTED 100
8787 #define TIMER_COUNT_TOLERANCE 10
8788
8789 static int count = 0;
8790 static void CALLBACK callback_count(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
8791 {
8792 count++;
8793 }
8794
8795 static DWORD exception;
8796 static void CALLBACK callback_exception(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
8797 {
8798 count++;
8799 RaiseException(exception, 0, 0, NULL);
8800 }
8801
8802 static DWORD WINAPI timer_thread_proc(LPVOID x)
8803 {
8804 struct timer_info *info = x;
8805 DWORD r;
8806
8807 r = KillTimer(info->hWnd, 0x19);
8808 ok(r,"KillTimer failed in thread\n");
8809 r = SetTimer(info->hWnd,TIMER_ID,10000,tfunc);
8810 ok(r,"SetTimer failed in thread\n");
8811 ok(r==TIMER_ID,"SetTimer id different\n");
8812 r = SetEvent(info->handles[0]);
8813 ok(r,"SetEvent failed in thread\n");
8814 return 0;
8815 }
8816
8817 static void test_timers(void)
8818 {
8819 struct timer_info info;
8820 DWORD start;
8821 DWORD id;
8822 MSG msg;
8823
8824 info.hWnd = CreateWindowA("TestWindowClass", NULL,
8825 WS_OVERLAPPEDWINDOW ,
8826 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
8827 NULL, NULL, 0);
8828
8829 info.id = SetTimer(info.hWnd,TIMER_ID,10000,tfunc);
8830 ok(info.id, "SetTimer failed\n");
8831 ok(info.id==TIMER_ID, "SetTimer timer ID different\n");
8832 info.handles[0] = CreateEventW(NULL,0,0,NULL);
8833 info.handles[1] = CreateThread(NULL,0,timer_thread_proc,&info,0,&id);
8834
8835 WaitForMultipleObjects(2, info.handles, FALSE, INFINITE);
8836
8837 WaitForSingleObject(info.handles[1], INFINITE);
8838
8839 CloseHandle(info.handles[0]);
8840 CloseHandle(info.handles[1]);
8841
8842 ok( KillTimer(info.hWnd, TIMER_ID), "KillTimer failed\n");
8843
8844 /* Check the minimum allowed timeout for a timer. MSDN indicates that it should be 10.0 ms,
8845 * which occurs sometimes, but most testing on the VMs indicates a minimum timeout closer to
8846 * 15.6 ms. Since there is some measurement error between test runs we are allowing for
8847 * ±9 counts (~4 ms) around the expected value.
8848 */
8849 count = 0;
8850 id = SetTimer(info.hWnd, TIMER_ID, 0, callback_count);
8851 ok(id != 0, "did not get id from SetTimer.\n");
8852 ok(id==TIMER_ID, "SetTimer timer ID different\n");
8853 start = GetTickCount();
8854 while (GetTickCount()-start < 1001 && GetMessageA(&msg, info.hWnd, 0, 0))
8855 DispatchMessageA(&msg);
8856 ok(abs(count-TIMER_COUNT_EXPECTED) < TIMER_COUNT_TOLERANCE /* xp */
8857 || broken(abs(count-64) < TIMER_COUNT_TOLERANCE) /* most common */
8858 || broken(abs(count-43) < TIMER_COUNT_TOLERANCE) /* w2k3, win8 */,
8859 "did not get expected count for minimum timeout (%d != ~%d).\n",
8860 count, TIMER_COUNT_EXPECTED);
8861 ok(KillTimer(info.hWnd, id), "KillTimer failed\n");
8862 /* Perform the same check on SetSystemTimer (only available on w2k3 and older) */
8863 if (pSetSystemTimer)
8864 {
8865 int syscount = 0;
8866
8867 count = 0;
8868 id = pSetSystemTimer(info.hWnd, TIMER_ID, 0, callback_count);
8869 ok(id != 0, "did not get id from SetSystemTimer.\n");
8870 ok(id==TIMER_ID, "SetTimer timer ID different\n");
8871 start = GetTickCount();
8872 while (GetTickCount()-start < 1001 && GetMessageA(&msg, info.hWnd, 0, 0))
8873 {
8874 if (msg.message == WM_SYSTIMER)
8875 syscount++;
8876 DispatchMessageA(&msg);
8877 }
8878 ok(abs(syscount-TIMER_COUNT_EXPECTED) < TIMER_COUNT_TOLERANCE
8879 || broken(abs(syscount-64) < TIMER_COUNT_TOLERANCE) /* most common */
8880 || broken(syscount > 4000 && syscount < 12000) /* win2k3sp0 */,
8881 "did not get expected count for minimum timeout (%d != ~%d).\n",
8882 syscount, TIMER_COUNT_EXPECTED);
8883 todo_wine ok(count == 0, "did not get expected count for callback timeout (%d != 0).\n",
8884 count);
8885 ok(pKillSystemTimer(info.hWnd, id), "KillSystemTimer failed\n");
8886 }
8887
8888 ok(DestroyWindow(info.hWnd), "failed to destroy window\n");
8889 }
8890
8891 static void test_timers_no_wnd(void)
8892 {
8893 static UINT_PTR ids[0xffff];
8894 UINT_PTR id, id2;
8895 DWORD start;
8896 MSG msg;
8897 int i;
8898
8899 count = 0;
8900 id = SetTimer(NULL, 0, 100, callback_count);
8901 ok(id != 0, "did not get id from SetTimer.\n");
8902 id2 = SetTimer(NULL, id, 200, callback_count);
8903 ok(id2 == id, "did not get same id from SetTimer when replacing (%li expected %li).\n", id2, id);
8904 Sleep(150);
8905 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
8906 ok(count == 0, "did not get zero count as expected (%i).\n", count);
8907 Sleep(150);
8908 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
8909 ok(count == 1, "did not get one count as expected (%i).\n", count);
8910 KillTimer(NULL, id);
8911 Sleep(250);
8912 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
8913 ok(count == 1, "killing replaced timer did not work (%i).\n", count);
8914
8915 /* Check the minimum allowed timeout for a timer. MSDN indicates that it should be 10.0 ms,
8916 * which occurs sometimes, but most testing on the VMs indicates a minimum timeout closer to
8917 * 15.6 ms. Since there is some measurement error between test runs we are allowing for
8918 * ±9 counts (~4 ms) around the expected value.
8919 */
8920 count = 0;
8921 id = SetTimer(NULL, 0, 0, callback_count);
8922 ok(id != 0, "did not get id from SetTimer.\n");
8923 start = GetTickCount();
8924 while (GetTickCount()-start < 1001 && GetMessageA(&msg, NULL, 0, 0))
8925 DispatchMessageA(&msg);
8926 ok(abs(count-TIMER_COUNT_EXPECTED) < TIMER_COUNT_TOLERANCE /* xp */
8927 || broken(abs(count-64) < TIMER_COUNT_TOLERANCE) /* most common */,
8928 "did not get expected count for minimum timeout (%d != ~%d).\n",
8929 count, TIMER_COUNT_EXPECTED);
8930 KillTimer(NULL, id);
8931 /* Note: SetSystemTimer doesn't support a NULL window, see test_timers */
8932
8933 /* Check what happens when we're running out of timers */
8934 for (i=0; i<sizeof(ids)/sizeof(ids[0]); i++)
8935 {
8936 SetLastError(0xdeadbeef);
8937 ids[i] = SetTimer(NULL, 0, USER_TIMER_MAXIMUM, tfunc);
8938 if (!ids[i]) break;
8939 }
8940 ok(i != sizeof(ids)/sizeof(ids[0]), "all timers were created successfully\n");
8941 ok(GetLastError()==ERROR_NO_MORE_USER_HANDLES || broken(GetLastError()==0xdeadbeef),
8942 "GetLastError() = %d\n", GetLastError());
8943 while (i > 0) KillTimer(NULL, ids[--i]);
8944 }
8945
8946 static void test_timers_exception(DWORD code)
8947 {
8948 UINT_PTR id;
8949 MSG msg;
8950
8951 exception = code;
8952 id = SetTimer(NULL, 0, 1000, callback_exception);
8953 ok(id != 0, "did not get id from SetTimer.\n");
8954
8955 memset(&msg, 0, sizeof(msg));
8956 msg.message = WM_TIMER;
8957 msg.wParam = id;
8958 msg.lParam = (LPARAM)callback_exception;
8959
8960 count = 0;
8961 DispatchMessageA(&msg);
8962 ok(count == 1, "did not get one count as expected (%i).\n", count);
8963
8964 KillTimer(NULL, id);
8965 }
8966
8967 static void test_timers_exceptions(void)
8968 {
8969 test_timers_exception(EXCEPTION_ACCESS_VIOLATION);
8970 test_timers_exception(EXCEPTION_DATATYPE_MISALIGNMENT);
8971 test_timers_exception(EXCEPTION_BREAKPOINT);
8972 test_timers_exception(EXCEPTION_SINGLE_STEP);
8973 test_timers_exception(EXCEPTION_ARRAY_BOUNDS_EXCEEDED);
8974 test_timers_exception(EXCEPTION_FLT_DENORMAL_OPERAND);
8975 test_timers_exception(EXCEPTION_FLT_DIVIDE_BY_ZERO);
8976 test_timers_exception(EXCEPTION_FLT_INEXACT_RESULT);
8977 test_timers_exception(EXCEPTION_ILLEGAL_INSTRUCTION);
8978 test_timers_exception(0xE000BEEF); /* customer exception */
8979 }
8980
8981 /* Various win events with arbitrary parameters */
8982 static const struct message WmWinEventsSeq[] = {
8983 { EVENT_SYSTEM_SOUND, winevent_hook|wparam|lparam, OBJID_WINDOW, 0 },
8984 { EVENT_SYSTEM_ALERT, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
8985 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, OBJID_TITLEBAR, 2 },
8986 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_MENU, 3 },
8987 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_CLIENT, 4 },
8988 { EVENT_SYSTEM_MENUPOPUPSTART, winevent_hook|wparam|lparam, OBJID_VSCROLL, 5 },
8989 { EVENT_SYSTEM_MENUPOPUPEND, winevent_hook|wparam|lparam, OBJID_HSCROLL, 6 },
8990 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, OBJID_SIZEGRIP, 7 },
8991 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, OBJID_CARET, 8 },
8992 /* our win event hook ignores OBJID_CURSOR events */
8993 /*{ EVENT_SYSTEM_MOVESIZESTART, winevent_hook|wparam|lparam, OBJID_CURSOR, 9 },*/
8994 { EVENT_SYSTEM_MOVESIZEEND, winevent_hook|wparam|lparam, OBJID_ALERT, 10 },
8995 { EVENT_SYSTEM_CONTEXTHELPSTART, winevent_hook|wparam|lparam, OBJID_SOUND, 11 },
8996 { EVENT_SYSTEM_CONTEXTHELPEND, winevent_hook|wparam|lparam, OBJID_QUERYCLASSNAMEIDX, 12 },
8997 { EVENT_SYSTEM_DRAGDROPSTART, winevent_hook|wparam|lparam, OBJID_NATIVEOM, 13 },
8998 { EVENT_SYSTEM_DRAGDROPEND, winevent_hook|wparam|lparam, OBJID_WINDOW, 0 },
8999 { EVENT_SYSTEM_DIALOGSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
9000 { EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam, OBJID_TITLEBAR, 2 },
9001 { EVENT_SYSTEM_SCROLLINGSTART, winevent_hook|wparam|lparam, OBJID_MENU, 3 },
9002 { EVENT_SYSTEM_SCROLLINGEND, winevent_hook|wparam|lparam, OBJID_CLIENT, 4 },
9003 { EVENT_SYSTEM_SWITCHSTART, winevent_hook|wparam|lparam, OBJID_VSCROLL, 5 },
9004 { EVENT_SYSTEM_SWITCHEND, winevent_hook|wparam|lparam, OBJID_HSCROLL, 6 },
9005 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, OBJID_SIZEGRIP, 7 },
9006 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam, OBJID_CARET, 8 },
9007 { 0 }
9008 };
9009 static const struct message WmWinEventCaretSeq[] = {
9010 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
9011 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
9012 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 2 */
9013 { EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
9014 { 0 }
9015 };
9016 static const struct message WmWinEventCaretSeq_2[] = {
9017 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
9018 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
9019 { EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
9020 { 0 }
9021 };
9022 static const struct message WmWinEventAlertSeq[] = {
9023 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_ALERT, 0 },
9024 { 0 }
9025 };
9026 static const struct message WmWinEventAlertSeq_2[] = {
9027 /* create window in the thread proc */
9028 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_WINDOW, 2 },
9029 /* our test event */
9030 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_ALERT, 2 },
9031 { 0 }
9032 };
9033 static const struct message WmGlobalHookSeq_1[] = {
9034 /* create window in the thread proc */
9035 { HCBT_CREATEWND, hook|lparam, 0, 2 },
9036 /* our test events */
9037 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 2 },
9038 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 2 },
9039 { 0 }
9040 };
9041 static const struct message WmGlobalHookSeq_2[] = {
9042 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 0 }, /* old local hook */
9043 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 2 }, /* new global hook */
9044 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 0 }, /* old local hook */
9045 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 2 }, /* new global hook */
9046 { 0 }
9047 };
9048
9049 static const struct message WmMouseLLHookSeq[] = {
9050 { WM_MOUSEMOVE, hook },
9051 { WM_LBUTTONUP, hook },
9052 { WM_MOUSEMOVE, hook },
9053 { 0 }
9054 };
9055
9056 static void CALLBACK win_event_global_hook_proc(HWINEVENTHOOK hevent,
9057 DWORD event,
9058 HWND hwnd,
9059 LONG object_id,
9060 LONG child_id,
9061 DWORD thread_id,
9062 DWORD event_time)
9063 {
9064 char buf[256];
9065
9066 if (GetClassNameA(hwnd, buf, sizeof(buf)))
9067 {
9068 if (!lstrcmpiA(buf, "TestWindowClass") ||
9069 !lstrcmpiA(buf, "static"))
9070 {
9071 struct recvd_message msg;
9072
9073 msg.hwnd = hwnd;
9074 msg.message = event;
9075 msg.flags = winevent_hook|wparam|lparam;
9076 msg.wParam = object_id;
9077 msg.lParam = (thread_id == GetCurrentThreadId()) ? child_id : (child_id + 2);
9078 msg.descr = "WEH_2";
9079 add_message(&msg);
9080 }
9081 }
9082 }
9083
9084 static HHOOK hCBT_global_hook;
9085 static DWORD cbt_global_hook_thread_id;
9086
9087 static LRESULT CALLBACK cbt_global_hook_proc(int nCode, WPARAM wParam, LPARAM lParam)
9088 {
9089 HWND hwnd;
9090 char buf[256];
9091
9092 if (nCode == HCBT_SYSCOMMAND)
9093 {
9094 struct recvd_message msg;
9095
9096 msg.hwnd = 0;
9097 msg.message = nCode;
9098 msg.flags = hook|wparam|lparam;
9099 msg.wParam = wParam;
9100 msg.lParam = (cbt_global_hook_thread_id == GetCurrentThreadId()) ? 1 : 2;
9101 msg.descr = "CBT_2";
9102 add_message(&msg);
9103
9104 return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
9105 }
9106 /* WH_MOUSE_LL hook */
9107 if (nCode == HC_ACTION)
9108 {
9109 MSLLHOOKSTRUCT *mhll = (MSLLHOOKSTRUCT *)lParam;
9110
9111 /* we can't test for real mouse events */
9112 if (mhll->flags & LLMHF_INJECTED)
9113 {
9114 struct recvd_message msg;
9115
9116 memset (&msg, 0, sizeof (msg));
9117 msg.message = wParam;
9118 msg.flags = hook;
9119 msg.descr = "CBT_2";
9120 add_message(&msg);
9121 }
9122 return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
9123 }
9124
9125 /* Log also SetFocus(0) calls */
9126 hwnd = wParam ? (HWND)wParam : (HWND)lParam;
9127
9128 if (GetClassNameA(hwnd, buf, sizeof(buf)))
9129 {
9130 if (!lstrcmpiA(buf, "TestWindowClass") ||
9131 !lstrcmpiA(buf, "static"))
9132 {
9133 struct recvd_message msg;
9134
9135 msg.hwnd = hwnd;
9136 msg.message = nCode;
9137 msg.flags = hook|wparam|lparam;
9138 msg.wParam = wParam;
9139 msg.lParam = (cbt_global_hook_thread_id == GetCurrentThreadId()) ? 1 : 2;
9140 msg.descr = "CBT_2";
9141 add_message(&msg);
9142 }
9143 }
9144 return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
9145 }
9146
9147 static DWORD WINAPI win_event_global_thread_proc(void *param)
9148 {
9149 HWND hwnd;
9150 MSG msg;
9151 HANDLE hevent = *(HANDLE *)param;
9152
9153 assert(pNotifyWinEvent);
9154
9155 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
9156 assert(hwnd);
9157 trace("created thread window %p\n", hwnd);
9158
9159 *(HWND *)param = hwnd;
9160
9161 flush_sequence();
9162 /* this event should be received only by our new hook proc,
9163 * an old one does not expect an event from another thread.
9164 */
9165 pNotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE, hwnd, OBJID_ALERT, 0);
9166 SetEvent(hevent);
9167
9168 while (GetMessageA(&msg, 0, 0, 0))
9169 {
9170 TranslateMessage(&msg);
9171 DispatchMessageA(&msg);
9172 }
9173 return 0;
9174 }
9175
9176 static DWORD WINAPI cbt_global_hook_thread_proc(void *param)
9177 {
9178 HWND hwnd;
9179 MSG msg;
9180 HANDLE hevent = *(HANDLE *)param;
9181
9182 flush_sequence();
9183 /* these events should be received only by our new hook proc,
9184 * an old one does not expect an event from another thread.
9185 */
9186
9187 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
9188 assert(hwnd);
9189 trace("created thread window %p\n", hwnd);
9190
9191 *(HWND *)param = hwnd;
9192
9193 /* Windows doesn't like when a thread plays games with the focus,
9194 that leads to all kinds of misbehaviours and failures to activate
9195 a window. So, better keep next lines commented out.
9196 SetFocus(0);
9197 SetFocus(hwnd);*/
9198
9199 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_PREVWINDOW, 0);
9200 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0);
9201
9202 SetEvent(hevent);
9203
9204 while (GetMessageA(&msg, 0, 0, 0))
9205 {
9206 TranslateMessage(&msg);
9207 DispatchMessageA(&msg);
9208 }
9209 return 0;
9210 }
9211
9212 static DWORD WINAPI mouse_ll_global_thread_proc(void *param)
9213 {
9214 HWND hwnd;
9215 MSG msg;
9216 HANDLE hevent = *(HANDLE *)param;
9217
9218 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
9219 assert(hwnd);
9220 trace("created thread window %p\n", hwnd);
9221
9222 *(HWND *)param = hwnd;
9223
9224 flush_sequence();
9225
9226 /* Windows doesn't like when a thread plays games with the focus,
9227 * that leads to all kinds of misbehaviours and failures to activate
9228 * a window. So, better don't generate a mouse click message below.
9229 */
9230 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
9231 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
9232 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
9233
9234 SetEvent(hevent);
9235 while (GetMessageA(&msg, 0, 0, 0))
9236 {
9237 TranslateMessage(&msg);
9238 DispatchMessageA(&msg);
9239 }
9240 return 0;
9241 }
9242
9243 static void test_winevents(void)
9244 {
9245 BOOL ret;
9246 MSG msg;
9247 HWND hwnd, hwnd2;
9248 UINT i;
9249 HANDLE hthread, hevent;
9250 DWORD tid;
9251 HWINEVENTHOOK hhook;
9252 const struct message *events = WmWinEventsSeq;
9253
9254 hwnd = CreateWindowExA(0, "TestWindowClass", NULL,
9255 WS_OVERLAPPEDWINDOW,
9256 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
9257 NULL, NULL, 0);
9258 assert(hwnd);
9259
9260 /****** start of global hook test *************/
9261 hCBT_global_hook = SetWindowsHookExA(WH_CBT, cbt_global_hook_proc, GetModuleHandleA(0), 0);
9262 if (!hCBT_global_hook)
9263 {
9264 ok(DestroyWindow(hwnd), "failed to destroy window\n");
9265 skip( "cannot set global hook\n" );
9266 return;
9267 }
9268
9269 hevent = CreateEventA(NULL, 0, 0, NULL);
9270 assert(hevent);
9271 hwnd2 = hevent;
9272
9273 hthread = CreateThread(NULL, 0, cbt_global_hook_thread_proc, &hwnd2, 0, &tid);
9274 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
9275
9276 ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9277
9278 ok_sequence(WmGlobalHookSeq_1, "global hook 1", FALSE);
9279
9280 flush_sequence();
9281 /* this one should be received only by old hook proc */
9282 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0);
9283 /* this one should be received only by old hook proc */
9284 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_PREVWINDOW, 0);
9285
9286 ok_sequence(WmGlobalHookSeq_2, "global hook 2", FALSE);
9287
9288 ret = UnhookWindowsHookEx(hCBT_global_hook);
9289 ok( ret, "UnhookWindowsHookEx error %d\n", GetLastError());
9290
9291 PostThreadMessageA(tid, WM_QUIT, 0, 0);
9292 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9293 CloseHandle(hthread);
9294 CloseHandle(hevent);
9295 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
9296 /****** end of global hook test *************/
9297
9298 if (!pSetWinEventHook || !pNotifyWinEvent || !pUnhookWinEvent)
9299 {
9300 ok(DestroyWindow(hwnd), "failed to destroy window\n");
9301 return;
9302 }
9303
9304 flush_sequence();
9305
9306 if (0)
9307 {
9308 /* this test doesn't pass under Win9x */
9309 /* win2k ignores events with hwnd == 0 */
9310 SetLastError(0xdeadbeef);
9311 pNotifyWinEvent(events[0].message, 0, events[0].wParam, events[0].lParam);
9312 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || /* Win2k */
9313 GetLastError() == 0xdeadbeef, /* Win9x */
9314 "unexpected error %d\n", GetLastError());
9315 ok_sequence(WmEmptySeq, "empty notify winevents", FALSE);
9316 }
9317
9318 for (i = 0; i < sizeof(WmWinEventsSeq)/sizeof(WmWinEventsSeq[0]); i++)
9319 pNotifyWinEvent(events[i].message, hwnd, events[i].wParam, events[i].lParam);
9320
9321 ok_sequence(WmWinEventsSeq, "notify winevents", FALSE);
9322
9323 /****** start of event filtering test *************/
9324 hhook = pSetWinEventHook(
9325 EVENT_OBJECT_SHOW, /* 0x8002 */
9326 EVENT_OBJECT_LOCATIONCHANGE, /* 0x800B */
9327 GetModuleHandleA(0), win_event_global_hook_proc,
9328 GetCurrentProcessId(), 0,
9329 WINEVENT_INCONTEXT);
9330 ok(hhook != 0, "SetWinEventHook error %d\n", GetLastError());
9331
9332 hevent = CreateEventA(NULL, 0, 0, NULL);
9333 assert(hevent);
9334 hwnd2 = hevent;
9335
9336 hthread = CreateThread(NULL, 0, win_event_global_thread_proc, &hwnd2, 0, &tid);
9337 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
9338
9339 ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9340
9341 ok_sequence(WmWinEventAlertSeq, "alert winevent", FALSE);
9342
9343 flush_sequence();
9344 /* this one should be received only by old hook proc */
9345 pNotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_CARET, 0); /* 0x8000 */
9346 pNotifyWinEvent(EVENT_OBJECT_SHOW, hwnd, OBJID_CARET, 0); /* 0x8002 */
9347 /* this one should be received only by old hook proc */
9348 pNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, hwnd, OBJID_CARET, 0); /* 0x800C */
9349
9350 ok_sequence(WmWinEventCaretSeq, "caret winevent", FALSE);
9351
9352 ret = pUnhookWinEvent(hhook);
9353 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
9354
9355 PostThreadMessageA(tid, WM_QUIT, 0, 0);
9356 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9357 CloseHandle(hthread);
9358 CloseHandle(hevent);
9359 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
9360 /****** end of event filtering test *************/
9361
9362 /****** start of out of context event test *************/
9363 hhook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0,
9364 win_event_global_hook_proc, GetCurrentProcessId(), 0,
9365 WINEVENT_OUTOFCONTEXT);
9366 ok(hhook != 0, "SetWinEventHook error %d\n", GetLastError());
9367
9368 hevent = CreateEventA(NULL, 0, 0, NULL);
9369 assert(hevent);
9370 hwnd2 = hevent;
9371
9372 flush_sequence();
9373
9374 hthread = CreateThread(NULL, 0, win_event_global_thread_proc, &hwnd2, 0, &tid);
9375 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
9376
9377 ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9378
9379 ok_sequence(WmEmptySeq, "empty notify winevents", FALSE);
9380 /* process pending winevent messages */
9381 ok(!PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE), "msg queue should be empty\n");
9382 ok_sequence(WmWinEventAlertSeq_2, "alert winevent for out of context proc", FALSE);
9383
9384 flush_sequence();
9385 /* this one should be received only by old hook proc */
9386 pNotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_CARET, 0); /* 0x8000 */
9387 pNotifyWinEvent(EVENT_OBJECT_SHOW, hwnd, OBJID_CARET, 0); /* 0x8002 */
9388 /* this one should be received only by old hook proc */
9389 pNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, hwnd, OBJID_CARET, 0); /* 0x800C */
9390
9391 ok_sequence(WmWinEventCaretSeq_2, "caret winevent for incontext proc", FALSE);
9392 /* process pending winevent messages */
9393 ok(!PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE), "msg queue should be empty\n");
9394 ok_sequence(WmWinEventCaretSeq_2, "caret winevent for out of context proc", FALSE);
9395
9396 ret = pUnhookWinEvent(hhook);
9397 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
9398
9399 PostThreadMessageA(tid, WM_QUIT, 0, 0);
9400 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9401 CloseHandle(hthread);
9402 CloseHandle(hevent);
9403 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
9404 /****** end of out of context event test *************/
9405
9406 /****** start of MOUSE_LL hook test *************/
9407 hCBT_global_hook = SetWindowsHookExA(WH_MOUSE_LL, cbt_global_hook_proc, GetModuleHandleA(0), 0);
9408 /* WH_MOUSE_LL is not supported on Win9x platforms */
9409 if (!hCBT_global_hook)
9410 {
9411 win_skip("Skipping WH_MOUSE_LL test on this platform\n");
9412 goto skip_mouse_ll_hook_test;
9413 }
9414
9415 hevent = CreateEventA(NULL, 0, 0, NULL);
9416 assert(hevent);
9417 hwnd2 = hevent;
9418
9419 hthread = CreateThread(NULL, 0, mouse_ll_global_thread_proc, &hwnd2, 0, &tid);
9420 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
9421
9422 while (WaitForSingleObject(hevent, 100) == WAIT_TIMEOUT)
9423 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
9424
9425 ok_sequence(WmMouseLLHookSeq, "MOUSE_LL hook other thread", FALSE);
9426 flush_sequence();
9427
9428 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
9429 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
9430 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
9431
9432 ok_sequence(WmMouseLLHookSeq, "MOUSE_LL hook same thread", FALSE);
9433
9434 ret = UnhookWindowsHookEx(hCBT_global_hook);
9435 ok( ret, "UnhookWindowsHookEx error %d\n", GetLastError());
9436
9437 PostThreadMessageA(tid, WM_QUIT, 0, 0);
9438 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9439 CloseHandle(hthread);
9440 CloseHandle(hevent);
9441 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
9442 /****** end of MOUSE_LL hook test *************/
9443 skip_mouse_ll_hook_test:
9444
9445 ok(DestroyWindow(hwnd), "failed to destroy window\n");
9446 }
9447
9448 static void test_set_hook(void)
9449 {
9450 BOOL ret;
9451 HHOOK hhook;
9452 HWINEVENTHOOK hwinevent_hook;
9453
9454 hhook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, GetModuleHandleA(0), GetCurrentThreadId());
9455 ok(hhook != 0, "local hook does not require hModule set to 0\n");
9456 UnhookWindowsHookEx(hhook);
9457
9458 if (0)
9459 {
9460 /* this test doesn't pass under Win9x: BUG! */
9461 SetLastError(0xdeadbeef);
9462 hhook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, 0);
9463 ok(!hhook, "global hook requires hModule != 0\n");
9464 ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD, "unexpected error %d\n", GetLastError());
9465 }
9466
9467 SetLastError(0xdeadbeef);
9468 hhook = SetWindowsHookExA(WH_CBT, 0, GetModuleHandleA(0), GetCurrentThreadId());
9469 ok(!hhook, "SetWinEventHook with invalid proc should fail\n");
9470 ok(GetLastError() == ERROR_INVALID_FILTER_PROC || /* Win2k */
9471 GetLastError() == 0xdeadbeef, /* Win9x */
9472 "unexpected error %d\n", GetLastError());
9473
9474 SetLastError(0xdeadbeef);
9475 ok(!UnhookWindowsHookEx((HHOOK)0xdeadbeef), "UnhookWindowsHookEx succeeded\n");
9476 ok(GetLastError() == ERROR_INVALID_HOOK_HANDLE || /* Win2k */
9477 GetLastError() == 0xdeadbeef, /* Win9x */
9478 "unexpected error %d\n", GetLastError());
9479
9480 if (!pSetWinEventHook || !pUnhookWinEvent) return;
9481
9482 /* even process local incontext hooks require hmodule */
9483 SetLastError(0xdeadbeef);
9484 hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
9485 GetCurrentProcessId(), 0, WINEVENT_INCONTEXT);
9486 ok(!hwinevent_hook, "WINEVENT_INCONTEXT requires hModule != 0\n");
9487 ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD || /* Win2k */
9488 GetLastError() == 0xdeadbeef, /* Win9x */
9489 "unexpected error %d\n", GetLastError());
9490
9491 /* even thread local incontext hooks require hmodule */
9492 SetLastError(0xdeadbeef);
9493 hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
9494 GetCurrentProcessId(), GetCurrentThreadId(), WINEVENT_INCONTEXT);
9495 ok(!hwinevent_hook, "WINEVENT_INCONTEXT requires hModule != 0\n");
9496 ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD || /* Win2k */
9497 GetLastError() == 0xdeadbeef, /* Win9x */
9498 "unexpected error %d\n", GetLastError());
9499
9500 if (0)
9501 {
9502 /* these 3 tests don't pass under Win9x */
9503 SetLastError(0xdeadbeef);
9504 hwinevent_hook = pSetWinEventHook(1, 0, 0, win_event_proc,
9505 GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
9506 ok(!hwinevent_hook, "SetWinEventHook with invalid event range should fail\n");
9507 ok(GetLastError() == ERROR_INVALID_HOOK_FILTER, "unexpected error %d\n", GetLastError());
9508
9509 SetLastError(0xdeadbeef);
9510 hwinevent_hook = pSetWinEventHook(-1, 1, 0, win_event_proc,
9511 GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
9512 ok(!hwinevent_hook, "SetWinEventHook with invalid event range should fail\n");
9513 ok(GetLastError() == ERROR_INVALID_HOOK_FILTER, "unexpected error %d\n", GetLastError());
9514
9515 SetLastError(0xdeadbeef);
9516 hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
9517 0, 0xdeadbeef, WINEVENT_OUTOFCONTEXT);
9518 ok(!hwinevent_hook, "SetWinEventHook with invalid tid should fail\n");
9519 ok(GetLastError() == ERROR_INVALID_THREAD_ID, "unexpected error %d\n", GetLastError());
9520 }
9521
9522 SetLastError(0xdeadbeef);
9523 hwinevent_hook = pSetWinEventHook(0, 0, 0, win_event_proc,
9524 GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
9525 ok(hwinevent_hook != 0, "SetWinEventHook error %d\n", GetLastError());
9526 ok(GetLastError() == 0xdeadbeef, "unexpected error %d\n", GetLastError());
9527 ret = pUnhookWinEvent(hwinevent_hook);
9528 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
9529
9530 todo_wine {
9531 /* This call succeeds under win2k SP4, but fails under Wine.
9532 Does win2k test/use passed process id? */
9533 SetLastError(0xdeadbeef);
9534 hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
9535 0xdeadbeef, 0, WINEVENT_OUTOFCONTEXT);
9536 ok(hwinevent_hook != 0, "SetWinEventHook error %d\n", GetLastError());
9537 ok(GetLastError() == 0xdeadbeef, "unexpected error %d\n", GetLastError());
9538 ret = pUnhookWinEvent(hwinevent_hook);
9539 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
9540 }
9541
9542 SetLastError(0xdeadbeef);
9543 ok(!pUnhookWinEvent((HWINEVENTHOOK)0xdeadbeef), "UnhookWinEvent succeeded\n");
9544 ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
9545 GetLastError() == 0xdeadbeef, /* Win9x */
9546 "unexpected error %d\n", GetLastError());
9547 }
9548
9549 static HWND hook_hwnd;
9550 static HHOOK recursive_hook;
9551 static int hook_depth, max_hook_depth;
9552
9553 static LRESULT WINAPI rec_get_message_hook(int code, WPARAM w, LPARAM l)
9554 {
9555 LRESULT res;
9556 MSG msg;
9557 BOOL b;
9558
9559 hook_depth++;
9560 if(hook_depth > max_hook_depth)
9561 max_hook_depth = hook_depth;
9562
9563 b = PeekMessageW(&msg, hook_hwnd, 0, 0, PM_NOREMOVE);
9564 ok(b, "PeekMessage failed\n");
9565
9566 res = CallNextHookEx(recursive_hook, code, w, l);
9567
9568 hook_depth--;
9569 return res;
9570 }
9571
9572 static void test_recursive_hook(void)
9573 {
9574 MSG msg;
9575 BOOL b;
9576
9577 hook_hwnd = CreateWindowA("Static", NULL, WS_POPUP, 0, 0, 200, 60, NULL, NULL, NULL, NULL);
9578 ok(hook_hwnd != NULL, "CreateWindow failed\n");
9579
9580 recursive_hook = SetWindowsHookExW(WH_GETMESSAGE, rec_get_message_hook, NULL, GetCurrentThreadId());
9581 ok(recursive_hook != NULL, "SetWindowsHookEx failed\n");
9582
9583 PostMessageW(hook_hwnd, WM_USER, 0, 0);
9584 PostMessageW(hook_hwnd, WM_USER+1, 0, 0);
9585
9586 hook_depth = 0;
9587 GetMessageW(&msg, hook_hwnd, 0, 0);
9588 ok(15 <= max_hook_depth && max_hook_depth < 45, "max_hook_depth = %d\n", max_hook_depth);
9589 trace("max_hook_depth = %d\n", max_hook_depth);
9590
9591 b = UnhookWindowsHookEx(recursive_hook);
9592 ok(b, "UnhokWindowsHookEx failed\n");
9593
9594 DestroyWindow(hook_hwnd);
9595 }
9596
9597 static const struct message ScrollWindowPaint1[] = {
9598 { WM_PAINT, sent },
9599 { WM_ERASEBKGND, sent|beginpaint },
9600 { WM_GETTEXTLENGTH, sent|optional },
9601 { WM_PAINT, sent|optional },
9602 { WM_NCPAINT, sent|beginpaint|optional },
9603 { WM_GETTEXT, sent|beginpaint|optional },
9604 { WM_GETTEXT, sent|beginpaint|optional },
9605 { WM_GETTEXT, sent|beginpaint|optional },
9606 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
9607 { WM_ERASEBKGND, sent|beginpaint|optional },
9608 { 0 }
9609 };
9610
9611 static const struct message ScrollWindowPaint2[] = {
9612 { WM_PAINT, sent },
9613 { 0 }
9614 };
9615
9616 static void test_scrollwindowex(void)
9617 {
9618 HWND hwnd, hchild;
9619 RECT rect={0,0,130,130};
9620
9621 hwnd = CreateWindowExA(0, "TestWindowClass", "Test Scroll",
9622 WS_VISIBLE|WS_OVERLAPPEDWINDOW,
9623 100, 100, 200, 200, 0, 0, 0, NULL);
9624 ok (hwnd != 0, "Failed to create overlapped window\n");
9625 hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
9626 WS_VISIBLE|WS_CAPTION|WS_CHILD,
9627 10, 10, 150, 150, hwnd, 0, 0, NULL);
9628 ok (hchild != 0, "Failed to create child\n");
9629 UpdateWindow(hwnd);
9630 flush_events();
9631 flush_sequence();
9632
9633 /* scroll without the child window */
9634 trace("start scroll\n");
9635 ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL,
9636 SW_ERASE|SW_INVALIDATE);
9637 ok_sequence(WmEmptySeq, "ScrollWindowEx", FALSE);
9638 trace("end scroll\n");
9639 flush_sequence();
9640 flush_events();
9641 ok_sequence(ScrollWindowPaint1, "ScrollWindowEx", FALSE);
9642 flush_events();
9643 flush_sequence();
9644
9645 /* Now without the SW_ERASE flag */
9646 trace("start scroll\n");
9647 ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL, SW_INVALIDATE);
9648 ok_sequence(WmEmptySeq, "ScrollWindowEx", FALSE);
9649 trace("end scroll\n");
9650 flush_sequence();
9651 flush_events();
9652 ok_sequence(ScrollWindowPaint2, "ScrollWindowEx", FALSE);
9653 flush_events();
9654 flush_sequence();
9655
9656 /* now scroll the child window as well */
9657 trace("start scroll\n");
9658 ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL,
9659 SW_SCROLLCHILDREN|SW_ERASE|SW_INVALIDATE);
9660 /* wine sends WM_POSCHANGING, WM_POSCHANGED messages */
9661 /* windows sometimes a WM_MOVE */
9662 ok_sequence(WmEmptySeq, "ScrollWindowEx", TRUE);
9663 trace("end scroll\n");
9664 flush_sequence();
9665 flush_events();
9666 ok_sequence(ScrollWindowPaint1, "ScrollWindowEx", FALSE);
9667 flush_events();
9668 flush_sequence();
9669
9670 /* now scroll with ScrollWindow() */
9671 trace("start scroll with ScrollWindow\n");
9672 ScrollWindow( hwnd, 5, 5, NULL, NULL);
9673 trace("end scroll\n");
9674 flush_sequence();
9675 flush_events();
9676 ok_sequence(ScrollWindowPaint1, "ScrollWindow", FALSE);
9677
9678 ok(DestroyWindow(hchild), "failed to destroy window\n");
9679 ok(DestroyWindow(hwnd), "failed to destroy window\n");
9680 flush_sequence();
9681 }
9682
9683 static const struct message destroy_window_with_children[] = {
9684 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 }, /* popup */
9685 { HCBT_DESTROYWND, hook|lparam, 0, WND_PARENT_ID }, /* parent */
9686 { 0x0090, sent|optional },
9687 { HCBT_DESTROYWND, hook|lparam, 0, WND_POPUP_ID }, /* popup */
9688 { 0x0090, sent|optional },
9689 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 }, /* popup */
9690 { WM_DESTROY, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
9691 { WM_CAPTURECHANGED, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
9692 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
9693 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 }, /* parent */
9694 { WM_DESTROY, sent|wparam|lparam, 0, WND_PARENT_ID }, /* parent */
9695 { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 2 }, /* child2 */
9696 { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 1 }, /* child1 */
9697 { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 3 }, /* child3 */
9698 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 2 }, /* child2 */
9699 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 3 }, /* child3 */
9700 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 1 }, /* child1 */
9701 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_PARENT_ID }, /* parent */
9702 { 0 }
9703 };
9704
9705 static void test_DestroyWindow(void)
9706 {
9707 BOOL ret;
9708 HWND parent, child1, child2, child3, child4, test;
9709 UINT_PTR child_id = WND_CHILD_ID + 1;
9710
9711 parent = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
9712 100, 100, 200, 200, 0, 0, 0, NULL);
9713 assert(parent != 0);
9714 child1 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
9715 0, 0, 50, 50, parent, (HMENU)child_id++, 0, NULL);
9716 assert(child1 != 0);
9717 child2 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
9718 0, 0, 50, 50, GetDesktopWindow(), (HMENU)child_id++, 0, NULL);
9719 assert(child2 != 0);
9720 child3 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
9721 0, 0, 50, 50, child1, (HMENU)child_id++, 0, NULL);
9722 assert(child3 != 0);
9723 child4 = CreateWindowExA(0, "TestWindowClass", NULL, WS_POPUP,
9724 0, 0, 50, 50, parent, 0, 0, NULL);
9725 assert(child4 != 0);
9726
9727 /* test owner/parent of child2 */
9728 test = GetParent(child2);
9729 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
9730 ok(!IsChild(parent, child2), "wrong parent/child %p/%p\n", parent, child2);
9731 if(pGetAncestor) {
9732 test = pGetAncestor(child2, GA_PARENT);
9733 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
9734 }
9735 test = GetWindow(child2, GW_OWNER);
9736 ok(!test, "wrong owner %p\n", test);
9737
9738 test = SetParent(child2, parent);
9739 ok(test == GetDesktopWindow(), "wrong old parent %p\n", test);
9740
9741 /* test owner/parent of the parent */
9742 test = GetParent(parent);
9743 ok(!test, "wrong parent %p\n", test);
9744 ok(!IsChild(GetDesktopWindow(), parent), "wrong parent/child %p/%p\n", GetDesktopWindow(), parent);
9745 if(pGetAncestor) {
9746 test = pGetAncestor(parent, GA_PARENT);
9747 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
9748 }
9749 test = GetWindow(parent, GW_OWNER);
9750 ok(!test, "wrong owner %p\n", test);
9751
9752 /* test owner/parent of child1 */
9753 test = GetParent(child1);
9754 ok(test == parent, "wrong parent %p\n", test);
9755 ok(IsChild(parent, child1), "wrong parent/child %p/%p\n", parent, child1);
9756 if(pGetAncestor) {
9757 test = pGetAncestor(child1, GA_PARENT);
9758 ok(test == parent, "wrong parent %p\n", test);
9759 }
9760 test = GetWindow(child1, GW_OWNER);
9761 ok(!test, "wrong owner %p\n", test);
9762
9763 /* test owner/parent of child2 */
9764 test = GetParent(child2);
9765 ok(test == parent, "wrong parent %p\n", test);
9766 ok(IsChild(parent, child2), "wrong parent/child %p/%p\n", parent, child2);
9767 if(pGetAncestor) {
9768 test = pGetAncestor(child2, GA_PARENT);
9769 ok(test == parent, "wrong parent %p\n", test);
9770 }
9771 test = GetWindow(child2, GW_OWNER);
9772 ok(!test, "wrong owner %p\n", test);
9773
9774 /* test owner/parent of child3 */
9775 test = GetParent(child3);
9776 ok(test == child1, "wrong parent %p\n", test);
9777 ok(IsChild(parent, child3), "wrong parent/child %p/%p\n", parent, child3);
9778 if(pGetAncestor) {
9779 test = pGetAncestor(child3, GA_PARENT);
9780 ok(test == child1, "wrong parent %p\n", test);
9781 }
9782 test = GetWindow(child3, GW_OWNER);
9783 ok(!test, "wrong owner %p\n", test);
9784
9785 /* test owner/parent of child4 */
9786 test = GetParent(child4);
9787 ok(test == parent, "wrong parent %p\n", test);
9788 ok(!IsChild(parent, child4), "wrong parent/child %p/%p\n", parent, child4);
9789 if(pGetAncestor) {
9790 test = pGetAncestor(child4, GA_PARENT);
9791 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
9792 }
9793 test = GetWindow(child4, GW_OWNER);
9794 ok(test == parent, "wrong owner %p\n", test);
9795
9796 flush_sequence();
9797
9798 trace("parent %p, child1 %p, child2 %p, child3 %p, child4 %p\n",
9799 parent, child1, child2, child3, child4);
9800
9801 SetCapture(child4);
9802 test = GetCapture();
9803 ok(test == child4, "wrong capture window %p\n", test);
9804
9805 test_DestroyWindow_flag = TRUE;
9806 ret = DestroyWindow(parent);
9807 ok( ret, "DestroyWindow() error %d\n", GetLastError());
9808 test_DestroyWindow_flag = FALSE;
9809 ok_sequence(destroy_window_with_children, "destroy window with children", FALSE);
9810
9811 ok(!IsWindow(parent), "parent still exists\n");
9812 ok(!IsWindow(child1), "child1 still exists\n");
9813 ok(!IsWindow(child2), "child2 still exists\n");
9814 ok(!IsWindow(child3), "child3 still exists\n");
9815 ok(!IsWindow(child4), "child4 still exists\n");
9816
9817 test = GetCapture();
9818 ok(!test, "wrong capture window %p\n", test);
9819 }
9820
9821
9822 static const struct message WmDispatchPaint[] = {
9823 { WM_NCPAINT, sent },
9824 { WM_GETTEXT, sent|defwinproc|optional },
9825 { WM_GETTEXT, sent|defwinproc|optional },
9826 { WM_ERASEBKGND, sent },
9827 { 0 }
9828 };
9829
9830 static LRESULT WINAPI DispatchMessageCheckProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
9831 {
9832 if (message == WM_PAINT) return 0;
9833 return MsgCheckProcA( hwnd, message, wParam, lParam );
9834 }
9835
9836 static void test_DispatchMessage(void)
9837 {
9838 RECT rect;
9839 MSG msg;
9840 int count;
9841 HWND hwnd = CreateWindowA( "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
9842 100, 100, 200, 200, 0, 0, 0, NULL);
9843 ShowWindow( hwnd, SW_SHOW );
9844 UpdateWindow( hwnd );
9845 flush_events();
9846 flush_sequence();
9847 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)DispatchMessageCheckProc );
9848
9849 SetRect( &rect, -5, -5, 5, 5 );
9850 RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
9851 count = 0;
9852 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
9853 {
9854 if (msg.message != WM_PAINT) DispatchMessageA( &msg );
9855 else
9856 {
9857 flush_sequence();
9858 DispatchMessageA( &msg );
9859 /* DispatchMessage will send WM_NCPAINT if non client area is still invalid after WM_PAINT */
9860 if (!count) ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
9861 else ok_sequence( WmEmptySeq, "WmEmpty", FALSE );
9862 if (++count > 10) break;
9863 }
9864 }
9865 ok( msg.message == WM_PAINT && count > 10, "WM_PAINT messages stopped\n" );
9866
9867 trace("now without DispatchMessage\n");
9868 flush_sequence();
9869 RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
9870 count = 0;
9871 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
9872 {
9873 if (msg.message != WM_PAINT) DispatchMessageA( &msg );
9874 else
9875 {
9876 HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
9877 flush_sequence();
9878 /* this will send WM_NCCPAINT just like DispatchMessage does */
9879 GetUpdateRgn( hwnd, hrgn, TRUE );
9880 ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
9881 DeleteObject( hrgn );
9882 GetClientRect( hwnd, &rect );
9883 ValidateRect( hwnd, &rect ); /* this will stop WM_PAINTs */
9884 ok( !count, "Got multiple WM_PAINTs\n" );
9885 if (++count > 10) break;
9886 }
9887 }
9888
9889 flush_sequence();
9890 RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
9891 count = 0;
9892 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
9893 {
9894 if (msg.message != WM_PAINT) DispatchMessageA( &msg );
9895 else
9896 {
9897 HDC hdc;
9898
9899 flush_sequence();
9900 hdc = BeginPaint( hwnd, NULL );
9901 ok( !hdc, "got valid hdc %p from BeginPaint\n", hdc );
9902 ok( !EndPaint( hwnd, NULL ), "EndPaint succeeded\n" );
9903 ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
9904 ok( !count, "Got multiple WM_PAINTs\n" );
9905 if (++count > 10) break;
9906 }
9907 }
9908 DestroyWindow(hwnd);
9909 }
9910
9911
9912 static const struct message WmUser[] = {
9913 { WM_USER, sent },
9914 { 0 }
9915 };
9916
9917 struct sendmsg_info
9918 {
9919 HWND hwnd;
9920 DWORD timeout;
9921 DWORD ret;
9922 };
9923
9924 static DWORD CALLBACK send_msg_thread( LPVOID arg )
9925 {
9926 struct sendmsg_info *info = arg;
9927 SetLastError( 0xdeadbeef );
9928 info->ret = SendMessageTimeoutA( info->hwnd, WM_USER, 0, 0, 0, info->timeout, NULL );
9929 if (!info->ret) ok( GetLastError() == ERROR_TIMEOUT ||
9930 broken(GetLastError() == 0), /* win9x */
9931 "unexpected error %d\n", GetLastError());
9932 return 0;
9933 }
9934
9935 static void wait_for_thread( HANDLE thread )
9936 {
9937 while (MsgWaitForMultipleObjects(1, &thread, FALSE, INFINITE, QS_SENDMESSAGE) != WAIT_OBJECT_0)
9938 {
9939 MSG msg;
9940 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA(&msg);
9941 }
9942 }
9943
9944 static LRESULT WINAPI send_msg_delay_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
9945 {
9946 if (message == WM_USER) Sleep(200);
9947 return MsgCheckProcA( hwnd, message, wParam, lParam );
9948 }
9949
9950 static void test_SendMessageTimeout(void)
9951 {
9952 HANDLE thread;
9953 struct sendmsg_info info;
9954 DWORD tid;
9955 BOOL is_win9x;
9956
9957 info.hwnd = CreateWindowA( "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
9958 100, 100, 200, 200, 0, 0, 0, NULL);
9959 flush_events();
9960 flush_sequence();
9961
9962 info.timeout = 1000;
9963 info.ret = 0xdeadbeef;
9964 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
9965 wait_for_thread( thread );
9966 CloseHandle( thread );
9967 ok( info.ret == 1, "SendMessageTimeout failed\n" );
9968 ok_sequence( WmUser, "WmUser", FALSE );
9969
9970 info.timeout = 1;
9971 info.ret = 0xdeadbeef;
9972 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
9973 Sleep(100); /* SendMessageTimeout should time out here */
9974 wait_for_thread( thread );
9975 CloseHandle( thread );
9976 ok( info.ret == 0, "SendMessageTimeout succeeded\n" );
9977 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
9978
9979 /* 0 means infinite timeout (but not on win9x) */
9980 info.timeout = 0;
9981 info.ret = 0xdeadbeef;
9982 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
9983 Sleep(100);
9984 wait_for_thread( thread );
9985 CloseHandle( thread );
9986 is_win9x = !info.ret;
9987 if (is_win9x) ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
9988 else ok_sequence( WmUser, "WmUser", FALSE );
9989
9990 /* timeout is treated as signed despite the prototype (but not on win9x) */
9991 info.timeout = 0x7fffffff;
9992 info.ret = 0xdeadbeef;
9993 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
9994 Sleep(100);
9995 wait_for_thread( thread );
9996 CloseHandle( thread );
9997 ok( info.ret == 1, "SendMessageTimeout failed\n" );
9998 ok_sequence( WmUser, "WmUser", FALSE );
9999
10000 info.timeout = 0x80000000;
10001 info.ret = 0xdeadbeef;
10002 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
10003 Sleep(100);
10004 wait_for_thread( thread );
10005 CloseHandle( thread );
10006 if (is_win9x)
10007 {
10008 ok( info.ret == 1, "SendMessageTimeout failed\n" );
10009 ok_sequence( WmUser, "WmUser", FALSE );
10010 }
10011 else
10012 {
10013 ok( info.ret == 0, "SendMessageTimeout succeeded\n" );
10014 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
10015 }
10016
10017 /* now check for timeout during message processing */
10018 SetWindowLongPtrA( info.hwnd, GWLP_WNDPROC, (LONG_PTR)send_msg_delay_proc );
10019 info.timeout = 100;
10020 info.ret = 0xdeadbeef;
10021 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
10022 wait_for_thread( thread );
10023 CloseHandle( thread );
10024 /* we should time out but still get the message */
10025 ok( info.ret == 0, "SendMessageTimeout failed\n" );
10026 ok_sequence( WmUser, "WmUser", FALSE );
10027
10028 DestroyWindow( info.hwnd );
10029 }
10030
10031
10032 /****************** edit message test *************************/
10033 #define ID_EDIT 0x1234
10034 static const struct message sl_edit_setfocus[] =
10035 {
10036 { HCBT_SETFOCUS, hook },
10037 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
10038 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10039 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
10040 { WM_SETFOCUS, sent|wparam, 0 },
10041 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
10042 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 15 },
10043 { WM_CTLCOLOREDIT, sent|parent },
10044 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
10045 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10046 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10047 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
10048 { 0 }
10049 };
10050 static const struct message sl_edit_invisible[] =
10051 {
10052 { HCBT_SETFOCUS, hook },
10053 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
10054 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10055 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
10056 { WM_KILLFOCUS, sent|parent },
10057 { WM_SETFOCUS, sent },
10058 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
10059 { 0 }
10060 };
10061 static const struct message ml_edit_setfocus[] =
10062 {
10063 { HCBT_SETFOCUS, hook },
10064 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
10065 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10066 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
10067 { WM_SETFOCUS, sent|wparam, 0 },
10068 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
10069 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
10070 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10071 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10072 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
10073 { 0 }
10074 };
10075 static const struct message sl_edit_killfocus[] =
10076 {
10077 { HCBT_SETFOCUS, hook },
10078 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
10079 { WM_KILLFOCUS, sent|wparam, 0 },
10080 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10081 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10082 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_KILLFOCUS) },
10083 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
10084 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
10085 { 0 }
10086 };
10087 static const struct message sl_edit_lbutton_dblclk[] =
10088 {
10089 { WM_LBUTTONDBLCLK, sent },
10090 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
10091 { 0 }
10092 };
10093 static const struct message sl_edit_lbutton_down[] =
10094 {
10095 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
10096 { HCBT_SETFOCUS, hook },
10097 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
10098 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10099 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
10100 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
10101 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
10102 { WM_CTLCOLOREDIT, sent|parent },
10103 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
10104 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10105 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10106 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10107 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
10108 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
10109 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10110 { WM_CTLCOLOREDIT, sent|parent|optional },
10111 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
10112 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10113 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10114 { 0 }
10115 };
10116 static const struct message ml_edit_lbutton_down[] =
10117 {
10118 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
10119 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
10120 { HCBT_SETFOCUS, hook },
10121 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
10122 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10123 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
10124 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
10125 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
10126 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
10127 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10128 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10129 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
10130 { 0 }
10131 };
10132 static const struct message sl_edit_lbutton_up[] =
10133 {
10134 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
10135 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10136 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
10137 { WM_CAPTURECHANGED, sent|defwinproc },
10138 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
10139 { 0 }
10140 };
10141 static const struct message ml_edit_lbutton_up[] =
10142 {
10143 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
10144 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
10145 { WM_CAPTURECHANGED, sent|defwinproc },
10146 { 0 }
10147 };
10148
10149 static WNDPROC old_edit_proc;
10150
10151 static LRESULT CALLBACK edit_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
10152 {
10153 static LONG defwndproc_counter = 0;
10154 LRESULT ret;
10155 struct recvd_message msg;
10156
10157 if (ignore_message( message )) return 0;
10158
10159 msg.hwnd = hwnd;
10160 msg.message = message;
10161 msg.flags = sent|wparam|lparam;
10162 if (defwndproc_counter) msg.flags |= defwinproc;
10163 msg.wParam = wParam;
10164 msg.lParam = lParam;
10165 msg.descr = "edit";
10166 add_message(&msg);
10167
10168 defwndproc_counter++;
10169 ret = CallWindowProcA(old_edit_proc, hwnd, message, wParam, lParam);
10170 defwndproc_counter--;
10171
10172 return ret;
10173 }
10174
10175 static void subclass_edit(void)
10176 {
10177 WNDCLASSA cls;
10178
10179 if (!GetClassInfoA(0, "edit", &cls)) assert(0);
10180
10181 old_edit_proc = cls.lpfnWndProc;
10182
10183 cls.hInstance = GetModuleHandleA(NULL);
10184 cls.lpfnWndProc = edit_hook_proc;
10185 cls.lpszClassName = "my_edit_class";
10186 UnregisterClassA(cls.lpszClassName, cls.hInstance);
10187 if (!RegisterClassA(&cls)) assert(0);
10188 }
10189
10190 static void test_edit_messages(void)
10191 {
10192 HWND hwnd, parent;
10193 DWORD dlg_code;
10194
10195 subclass_edit();
10196 log_all_parent_messages++;
10197
10198 parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
10199 100, 100, 200, 200, 0, 0, 0, NULL);
10200 ok (parent != 0, "Failed to create parent window\n");
10201
10202 /* test single line edit */
10203 hwnd = CreateWindowExA(0, "my_edit_class", "test", WS_CHILD,
10204 0, 0, 80, 20, parent, (HMENU)ID_EDIT, 0, NULL);
10205 ok(hwnd != 0, "Failed to create edit window\n");
10206
10207 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
10208 ok(dlg_code == (DLGC_WANTCHARS|DLGC_HASSETSEL|DLGC_WANTARROWS), "wrong dlg_code %08x\n", dlg_code);
10209
10210 flush_sequence();
10211 SetFocus(hwnd);
10212 ok_sequence(sl_edit_invisible, "SetFocus(hwnd) on an invisible edit", FALSE);
10213
10214 ShowWindow(hwnd, SW_SHOW);
10215 UpdateWindow(hwnd);
10216 SetFocus(0);
10217 flush_sequence();
10218
10219 SetFocus(hwnd);
10220 ok_sequence(sl_edit_setfocus, "SetFocus(hwnd) on an edit", FALSE);
10221
10222 SetFocus(0);
10223 ok_sequence(sl_edit_killfocus, "SetFocus(0) on an edit", FALSE);
10224
10225 SetFocus(0);
10226 ReleaseCapture();
10227 flush_sequence();
10228
10229 SendMessageA(hwnd, WM_LBUTTONDBLCLK, 0, 0);
10230 ok_sequence(sl_edit_lbutton_dblclk, "WM_LBUTTONDBLCLK on an edit", FALSE);
10231
10232 SetFocus(0);
10233 ReleaseCapture();
10234 flush_sequence();
10235
10236 SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
10237 ok_sequence(sl_edit_lbutton_down, "WM_LBUTTONDOWN on an edit", FALSE);
10238
10239 SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
10240 ok_sequence(sl_edit_lbutton_up, "WM_LBUTTONUP on an edit", FALSE);
10241
10242 DestroyWindow(hwnd);
10243
10244 /* test multiline edit */
10245 hwnd = CreateWindowExA(0, "my_edit_class", "test", WS_CHILD | ES_MULTILINE,
10246 0, 0, 80, 20, parent, (HMENU)ID_EDIT, 0, NULL);
10247 ok(hwnd != 0, "Failed to create edit window\n");
10248
10249 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
10250 ok(dlg_code == (DLGC_WANTCHARS|DLGC_HASSETSEL|DLGC_WANTARROWS|DLGC_WANTALLKEYS),
10251 "wrong dlg_code %08x\n", dlg_code);
10252
10253 ShowWindow(hwnd, SW_SHOW);
10254 UpdateWindow(hwnd);
10255 SetFocus(0);
10256 flush_sequence();
10257
10258 SetFocus(hwnd);
10259 ok_sequence(ml_edit_setfocus, "SetFocus(hwnd) on multiline edit", FALSE);
10260
10261 SetFocus(0);
10262 ok_sequence(sl_edit_killfocus, "SetFocus(0) on multiline edit", FALSE);
10263
10264 SetFocus(0);
10265 ReleaseCapture();
10266 flush_sequence();
10267
10268 SendMessageA(hwnd, WM_LBUTTONDBLCLK, 0, 0);
10269 ok_sequence(sl_edit_lbutton_dblclk, "WM_LBUTTONDBLCLK on multiline edit", FALSE);
10270
10271 SetFocus(0);
10272 ReleaseCapture();
10273 flush_sequence();
10274
10275 SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
10276 ok_sequence(ml_edit_lbutton_down, "WM_LBUTTONDOWN on multiline edit", FALSE);
10277
10278 SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
10279 ok_sequence(ml_edit_lbutton_up, "WM_LBUTTONUP on multiline edit", FALSE);
10280
10281 DestroyWindow(hwnd);
10282 DestroyWindow(parent);
10283
10284 log_all_parent_messages--;
10285 }
10286
10287 /**************************** End of Edit test ******************************/
10288
10289 static const struct message WmKeyDownSkippedSeq[] =
10290 {
10291 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
10292 { 0 }
10293 };
10294 static const struct message WmKeyDownWasDownSkippedSeq[] =
10295 {
10296 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x40000001 }, /* XP */
10297 { 0 }
10298 };
10299 static const struct message WmKeyUpSkippedSeq[] =
10300 {
10301 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
10302 { 0 }
10303 };
10304 static const struct message WmUserKeyUpSkippedSeq[] =
10305 {
10306 { WM_USER, sent },
10307 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
10308 { 0 }
10309 };
10310
10311 #define EV_STOP 0
10312 #define EV_SENDMSG 1
10313 #define EV_ACK 2
10314
10315 struct peekmsg_info
10316 {
10317 HWND hwnd;
10318 HANDLE hevent[3]; /* 0 - start/stop, 1 - SendMessage, 2 - ack */
10319 };
10320
10321 static DWORD CALLBACK send_msg_thread_2(void *param)
10322 {
10323 DWORD ret;
10324 struct peekmsg_info *info = param;
10325
10326 trace("thread: looping\n");
10327 SetEvent(info->hevent[EV_ACK]);
10328
10329 while (1)
10330 {
10331 ret = WaitForMultipleObjects(2, info->hevent, FALSE, INFINITE);
10332
10333 switch (ret)
10334 {
10335 case WAIT_OBJECT_0 + EV_STOP:
10336 trace("thread: exiting\n");
10337 return 0;
10338
10339 case WAIT_OBJECT_0 + EV_SENDMSG:
10340 trace("thread: sending message\n");
10341 ret = SendNotifyMessageA(info->hwnd, WM_USER, 0, 0);
10342 ok(ret, "SendNotifyMessageA failed error %u\n", GetLastError());
10343 SetEvent(info->hevent[EV_ACK]);
10344 break;
10345
10346 default:
10347 trace("unexpected return: %04x\n", ret);
10348 assert(0);
10349 break;
10350 }
10351 }
10352 return 0;
10353 }
10354
10355 static void test_PeekMessage(void)
10356 {
10357 MSG msg;
10358 HANDLE hthread;
10359 DWORD tid, qstatus;
10360 UINT qs_all_input = QS_ALLINPUT;
10361 UINT qs_input = QS_INPUT;
10362 BOOL ret;
10363 struct peekmsg_info info;
10364
10365 info.hwnd = CreateWindowA("TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
10366 100, 100, 200, 200, 0, 0, 0, NULL);
10367 assert(info.hwnd);
10368 ShowWindow(info.hwnd, SW_SHOW);
10369 UpdateWindow(info.hwnd);
10370 SetFocus(info.hwnd);
10371
10372 info.hevent[EV_STOP] = CreateEventA(NULL, 0, 0, NULL);
10373 info.hevent[EV_SENDMSG] = CreateEventA(NULL, 0, 0, NULL);
10374 info.hevent[EV_ACK] = CreateEventA(NULL, 0, 0, NULL);
10375
10376 hthread = CreateThread(NULL, 0, send_msg_thread_2, &info, 0, &tid);
10377 WaitForSingleObject(info.hevent[EV_ACK], 10000);
10378
10379 flush_events();
10380 flush_sequence();
10381
10382 SetLastError(0xdeadbeef);
10383 qstatus = GetQueueStatus(qs_all_input);
10384 if (GetLastError() == ERROR_INVALID_FLAGS)
10385 {
10386 trace("QS_RAWINPUT not supported on this platform\n");
10387 qs_all_input &= ~QS_RAWINPUT;
10388 qs_input &= ~QS_RAWINPUT;
10389 }
10390 if (qstatus & QS_POSTMESSAGE)
10391 {
10392 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) /* nothing */ ;
10393 qstatus = GetQueueStatus(qs_all_input);
10394 }
10395 ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
10396
10397 trace("signalling to send message\n");
10398 SetEvent(info.hevent[EV_SENDMSG]);
10399 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
10400
10401 /* pass invalid QS_xxxx flags */
10402 SetLastError(0xdeadbeef);
10403 qstatus = GetQueueStatus(0xffffffff);
10404 ok(qstatus == 0 || broken(qstatus) /* win9x */, "GetQueueStatus should fail: %08x\n", qstatus);
10405 if (!qstatus)
10406 {
10407 ok(GetLastError() == ERROR_INVALID_FLAGS, "wrong error %d\n", GetLastError());
10408 qstatus = GetQueueStatus(qs_all_input);
10409 }
10410 qstatus &= ~MAKELONG( 0x4000, 0x4000 ); /* sometimes set on Win95 */
10411 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE),
10412 "wrong qstatus %08x\n", qstatus);
10413
10414 msg.message = 0;
10415 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
10416 ok(!ret,
10417 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10418 msg.message);
10419 ok_sequence(WmUser, "WmUser", FALSE);
10420
10421 qstatus = GetQueueStatus(qs_all_input);
10422 ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
10423
10424 keybd_event('N', 0, 0, 0);
10425 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
10426 qstatus = GetQueueStatus(qs_all_input);
10427 if (!(qstatus & MAKELONG(QS_KEY, QS_KEY)))
10428 {
10429 skip( "queuing key events not supported\n" );
10430 goto done;
10431 }
10432 ok(qstatus == MAKELONG(QS_KEY, QS_KEY) ||
10433 /* keybd_event seems to trigger a sent message on NT4 */
10434 qstatus == MAKELONG(QS_KEY|QS_SENDMESSAGE, QS_KEY|QS_SENDMESSAGE),
10435 "wrong qstatus %08x\n", qstatus);
10436
10437 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
10438 qstatus = GetQueueStatus(qs_all_input);
10439 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY) ||
10440 qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY|QS_SENDMESSAGE),
10441 "wrong qstatus %08x\n", qstatus);
10442
10443 InvalidateRect(info.hwnd, NULL, FALSE);
10444 qstatus = GetQueueStatus(qs_all_input);
10445 ok(qstatus == MAKELONG(QS_PAINT, QS_PAINT|QS_POSTMESSAGE|QS_KEY) ||
10446 qstatus == MAKELONG(QS_PAINT, QS_PAINT|QS_POSTMESSAGE|QS_KEY|QS_SENDMESSAGE),
10447 "wrong qstatus %08x\n", qstatus);
10448
10449 trace("signalling to send message\n");
10450 SetEvent(info.hevent[EV_SENDMSG]);
10451 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
10452
10453 qstatus = GetQueueStatus(qs_all_input);
10454 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_PAINT|QS_POSTMESSAGE|QS_KEY),
10455 "wrong qstatus %08x\n", qstatus);
10456
10457 msg.message = 0;
10458 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (qs_input << 16));
10459 if (ret && msg.message == WM_CHAR)
10460 {
10461 win_skip( "PM_QS_* flags not supported in PeekMessage\n" );
10462 goto done;
10463 }
10464 ok(!ret,
10465 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10466 msg.message);
10467 if (!sequence_cnt) /* nt4 doesn't fetch anything with PM_QS_* flags */
10468 {
10469 win_skip( "PM_QS_* flags not supported in PeekMessage\n" );
10470 goto done;
10471 }
10472 ok_sequence(WmUser, "WmUser", FALSE);
10473
10474 qstatus = GetQueueStatus(qs_all_input);
10475 ok(qstatus == MAKELONG(0, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
10476 "wrong qstatus %08x\n", qstatus);
10477
10478 trace("signalling to send message\n");
10479 SetEvent(info.hevent[EV_SENDMSG]);
10480 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
10481
10482 qstatus = GetQueueStatus(qs_all_input);
10483 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_PAINT|QS_POSTMESSAGE|QS_KEY),
10484 "wrong qstatus %08x\n", qstatus);
10485
10486 msg.message = 0;
10487 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE );
10488 ok(!ret,
10489 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10490 msg.message);
10491 ok_sequence(WmUser, "WmUser", FALSE);
10492
10493 qstatus = GetQueueStatus(qs_all_input);
10494 ok(qstatus == MAKELONG(0, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
10495 "wrong qstatus %08x\n", qstatus);
10496
10497 msg.message = 0;
10498 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE);
10499 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
10500 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
10501 ret, msg.message, msg.wParam);
10502 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10503
10504 qstatus = GetQueueStatus(qs_all_input);
10505 ok(qstatus == MAKELONG(0, QS_PAINT|QS_KEY),
10506 "wrong qstatus %08x\n", qstatus);
10507
10508 msg.message = 0;
10509 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE);
10510 ok(!ret,
10511 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10512 msg.message);
10513 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10514
10515 qstatus = GetQueueStatus(qs_all_input);
10516 ok(qstatus == MAKELONG(0, QS_PAINT|QS_KEY),
10517 "wrong qstatus %08x\n", qstatus);
10518
10519 msg.message = 0;
10520 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_PAINT);
10521 ok(ret && msg.message == WM_PAINT,
10522 "got %d and %04x instead of TRUE and WM_PAINT\n", ret, msg.message);
10523 DispatchMessageA(&msg);
10524 ok_sequence(WmPaint, "WmPaint", FALSE);
10525
10526 qstatus = GetQueueStatus(qs_all_input);
10527 ok(qstatus == MAKELONG(0, QS_KEY),
10528 "wrong qstatus %08x\n", qstatus);
10529
10530 msg.message = 0;
10531 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_PAINT);
10532 ok(!ret,
10533 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10534 msg.message);
10535 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10536
10537 qstatus = GetQueueStatus(qs_all_input);
10538 ok(qstatus == MAKELONG(0, QS_KEY),
10539 "wrong qstatus %08x\n", qstatus);
10540
10541 trace("signalling to send message\n");
10542 SetEvent(info.hevent[EV_SENDMSG]);
10543 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
10544
10545 qstatus = GetQueueStatus(qs_all_input);
10546 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_KEY),
10547 "wrong qstatus %08x\n", qstatus);
10548
10549 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
10550
10551 qstatus = GetQueueStatus(qs_all_input);
10552 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
10553 "wrong qstatus %08x\n", qstatus);
10554
10555 msg.message = 0;
10556 ret = PeekMessageA(&msg, 0, WM_CHAR, WM_CHAR, PM_REMOVE);
10557 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
10558 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
10559 ret, msg.message, msg.wParam);
10560 ok_sequence(WmUser, "WmUser", FALSE);
10561
10562 qstatus = GetQueueStatus(qs_all_input);
10563 ok(qstatus == MAKELONG(0, QS_KEY),
10564 "wrong qstatus %08x\n", qstatus);
10565
10566 msg.message = 0;
10567 ret = PeekMessageA(&msg, 0, WM_CHAR, WM_CHAR, PM_REMOVE);
10568 ok(!ret,
10569 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10570 msg.message);
10571 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10572
10573 qstatus = GetQueueStatus(qs_all_input);
10574 ok(qstatus == MAKELONG(0, QS_KEY),
10575 "wrong qstatus %08x\n", qstatus);
10576
10577 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
10578
10579 qstatus = GetQueueStatus(qs_all_input);
10580 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY),
10581 "wrong qstatus %08x\n", qstatus);
10582
10583 trace("signalling to send message\n");
10584 SetEvent(info.hevent[EV_SENDMSG]);
10585 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
10586
10587 qstatus = GetQueueStatus(qs_all_input);
10588 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
10589 "wrong qstatus %08x\n", qstatus);
10590
10591 msg.message = 0;
10592 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_KEY << 16));
10593 ok(!ret,
10594 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10595 msg.message);
10596 ok_sequence(WmUser, "WmUser", FALSE);
10597
10598 qstatus = GetQueueStatus(qs_all_input);
10599 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE|QS_KEY),
10600 "wrong qstatus %08x\n", qstatus);
10601
10602 msg.message = 0;
10603 if (qs_all_input & QS_RAWINPUT) /* use QS_RAWINPUT only if supported */
10604 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_RAWINPUT << 16));
10605 else /* workaround for a missing QS_RAWINPUT support */
10606 ret = PeekMessageA(&msg, 0, WM_KEYDOWN, WM_KEYDOWN, PM_REMOVE);
10607 ok(ret && msg.message == WM_KEYDOWN && msg.wParam == 'N',
10608 "got %d and %04x wParam %08lx instead of TRUE and WM_KEYDOWN wParam 'N'\n",
10609 ret, msg.message, msg.wParam);
10610 ok_sequence(WmKeyDownSkippedSeq, "WmKeyDownSkippedSeq", FALSE);
10611
10612 qstatus = GetQueueStatus(qs_all_input);
10613 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE|QS_KEY),
10614 "wrong qstatus %08x\n", qstatus);
10615
10616 msg.message = 0;
10617 if (qs_all_input & QS_RAWINPUT) /* use QS_RAWINPUT only if supported */
10618 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_RAWINPUT << 16));
10619 else /* workaround for a missing QS_RAWINPUT support */
10620 ret = PeekMessageA(&msg, 0, WM_KEYUP, WM_KEYUP, PM_REMOVE);
10621 ok(ret && msg.message == WM_KEYUP && msg.wParam == 'N',
10622 "got %d and %04x wParam %08lx instead of TRUE and WM_KEYUP wParam 'N'\n",
10623 ret, msg.message, msg.wParam);
10624 ok_sequence(WmKeyUpSkippedSeq, "WmKeyUpSkippedSeq", FALSE);
10625
10626 qstatus = GetQueueStatus(qs_all_input);
10627 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
10628 "wrong qstatus %08x\n", qstatus);
10629
10630 msg.message = 0;
10631 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE);
10632 ok(!ret,
10633 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10634 msg.message);
10635 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10636
10637 qstatus = GetQueueStatus(qs_all_input);
10638 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
10639 "wrong qstatus %08x\n", qstatus);
10640
10641 msg.message = 0;
10642 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
10643 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
10644 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
10645 ret, msg.message, msg.wParam);
10646 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10647
10648 qstatus = GetQueueStatus(qs_all_input);
10649 ok(qstatus == 0,
10650 "wrong qstatus %08x\n", qstatus);
10651
10652 msg.message = 0;
10653 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
10654 ok(!ret,
10655 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10656 msg.message);
10657 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10658
10659 qstatus = GetQueueStatus(qs_all_input);
10660 ok(qstatus == 0,
10661 "wrong qstatus %08x\n", qstatus);
10662
10663 /* test whether presence of the quit flag in the queue affects
10664 * the queue state
10665 */
10666 PostQuitMessage(0x1234abcd);
10667
10668 qstatus = GetQueueStatus(qs_all_input);
10669 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE),
10670 "wrong qstatus %08x\n", qstatus);
10671
10672 PostMessageA(info.hwnd, WM_USER, 0, 0);
10673
10674 qstatus = GetQueueStatus(qs_all_input);
10675 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE),
10676 "wrong qstatus %08x\n", qstatus);
10677
10678 msg.message = 0;
10679 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
10680 ok(ret && msg.message == WM_USER,
10681 "got %d and %04x instead of TRUE and WM_USER\n", ret, msg.message);
10682 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10683
10684 qstatus = GetQueueStatus(qs_all_input);
10685 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
10686 "wrong qstatus %08x\n", qstatus);
10687
10688 msg.message = 0;
10689 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
10690 ok(ret && msg.message == WM_QUIT,
10691 "got %d and %04x instead of TRUE and WM_QUIT\n", ret, msg.message);
10692 ok(msg.wParam == 0x1234abcd, "got wParam %08lx instead of 0x1234abcd\n", msg.wParam);
10693 ok(msg.lParam == 0, "got lParam %08lx instead of 0\n", msg.lParam);
10694 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10695
10696 qstatus = GetQueueStatus(qs_all_input);
10697 todo_wine {
10698 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
10699 "wrong qstatus %08x\n", qstatus);
10700 }
10701
10702 msg.message = 0;
10703 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
10704 ok(!ret,
10705 "PeekMessageA should have returned FALSE instead of msg %04x\n",
10706 msg.message);
10707 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
10708
10709 qstatus = GetQueueStatus(qs_all_input);
10710 ok(qstatus == 0,
10711 "wrong qstatus %08x\n", qstatus);
10712
10713 /* some GetMessage tests */
10714
10715 keybd_event('N', 0, 0, 0);
10716 qstatus = GetQueueStatus(qs_all_input);
10717 ok(qstatus == MAKELONG(QS_KEY, QS_KEY), "wrong qstatus %08x\n", qstatus);
10718
10719 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
10720 qstatus = GetQueueStatus(qs_all_input);
10721 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY), "wrong qstatus %08x\n", qstatus);
10722
10723 if (qstatus)
10724 {
10725 ret = GetMessageA( &msg, 0, 0, 0 );
10726 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
10727 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
10728 ret, msg.message, msg.wParam);
10729 qstatus = GetQueueStatus(qs_all_input);
10730 ok(qstatus == MAKELONG(0, QS_KEY), "wrong qstatus %08x\n", qstatus);
10731 }
10732
10733 if (qstatus)
10734 {
10735 ret = GetMessageA( &msg, 0, 0, 0 );
10736 ok(ret && msg.message == WM_KEYDOWN && msg.wParam == 'N',
10737 "got %d and %04x wParam %08lx instead of TRUE and WM_KEYDOWN wParam 'N'\n",
10738 ret, msg.message, msg.wParam);
10739 ok_sequence(WmKeyDownSkippedSeq, "WmKeyDownSkippedSeq", FALSE);
10740 qstatus = GetQueueStatus(qs_all_input);
10741 ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
10742 }
10743
10744 keybd_event('N', 0, 0, 0);
10745 qstatus = GetQueueStatus(qs_all_input);
10746 ok(qstatus == MAKELONG(QS_KEY, QS_KEY), "wrong qstatus %08x\n", qstatus);
10747
10748 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
10749 qstatus = GetQueueStatus(qs_all_input);
10750 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY), "wrong qstatus %08x\n", qstatus);
10751
10752 if (qstatus & (QS_KEY << 16))
10753 {
10754 ret = GetMessageA( &msg, 0, WM_KEYDOWN, WM_KEYUP );
10755 ok(ret && msg.message == WM_KEYDOWN && msg.wParam == 'N',
10756 "got %d and %04x wParam %08lx instead of TRUE and WM_KEYDOWN wParam 'N'\n",
10757 ret, msg.message, msg.wParam);
10758 ok_sequence(WmKeyDownWasDownSkippedSeq, "WmKeyDownWasDownSkippedSeq", FALSE);
10759 qstatus = GetQueueStatus(qs_all_input);
10760 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE), "wrong qstatus %08x\n", qstatus);
10761 }
10762
10763 if (qstatus)
10764 {
10765 ret = GetMessageA( &msg, 0, WM_CHAR, WM_CHAR );
10766 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
10767 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
10768 ret, msg.message, msg.wParam);
10769 qstatus = GetQueueStatus(qs_all_input);
10770 ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
10771 }
10772
10773 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
10774 qstatus = GetQueueStatus(qs_all_input);
10775 ok(qstatus == MAKELONG(QS_KEY, QS_KEY), "wrong qstatus %08x\n", qstatus);
10776
10777 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
10778 qstatus = GetQueueStatus(qs_all_input);
10779 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY), "wrong qstatus %08x\n", qstatus);
10780
10781 trace("signalling to send message\n");
10782 SetEvent(info.hevent[EV_SENDMSG]);
10783 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
10784 qstatus = GetQueueStatus(qs_all_input);
10785 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
10786 "wrong qstatus %08x\n", qstatus);
10787
10788 if (qstatus & (QS_KEY << 16))
10789 {
10790 ret = GetMessageA( &msg, 0, WM_KEYDOWN, WM_KEYUP );
10791 ok(ret && msg.message == WM_KEYUP && msg.wParam == 'N',
10792 "got %d and %04x wParam %08lx instead of TRUE and WM_KEYDOWN wParam 'N'\n",
10793 ret, msg.message, msg.wParam);
10794 ok_sequence(WmUserKeyUpSkippedSeq, "WmUserKeyUpSkippedSeq", FALSE);
10795 qstatus = GetQueueStatus(qs_all_input);
10796 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE), "wrong qstatus %08x\n", qstatus);
10797 }
10798
10799 if (qstatus)
10800 {
10801 ret = GetMessageA( &msg, 0, WM_CHAR, WM_CHAR );
10802 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
10803 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
10804 ret, msg.message, msg.wParam);
10805 qstatus = GetQueueStatus(qs_all_input);
10806 ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
10807 }
10808 done:
10809 trace("signalling to exit\n");
10810 SetEvent(info.hevent[EV_STOP]);
10811
10812 WaitForSingleObject(hthread, INFINITE);
10813
10814 CloseHandle(hthread);
10815 CloseHandle(info.hevent[0]);
10816 CloseHandle(info.hevent[1]);
10817 CloseHandle(info.hevent[2]);
10818
10819 DestroyWindow(info.hwnd);
10820 }
10821
10822 static void wait_move_event(HWND hwnd, int x, int y)
10823 {
10824 MSG msg;
10825 DWORD time;
10826 BOOL ret;
10827
10828 time = GetTickCount();
10829 while (GetTickCount() - time < 200) {
10830 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
10831 if (ret && msg.pt.x > x && msg.pt.y > y) break;
10832 if (!ret) MsgWaitForMultipleObjects( 0, NULL, FALSE, GetTickCount() - time, QS_ALLINPUT );
10833 else Sleep( GetTickCount() - time );
10834 }
10835 }
10836
10837 #define STEP 5
10838 static void test_PeekMessage2(void)
10839 {
10840 HWND hwnd;
10841 BOOL ret;
10842 MSG msg;
10843 UINT message;
10844 DWORD time1, time2, time3;
10845 int x1, y1, x2, y2, x3, y3;
10846 POINT pos;
10847
10848 time1 = time2 = time3 = 0;
10849 x1 = y1 = x2 = y2 = x3 = y3 = 0;
10850
10851 /* Initialise window and make sure it is ready for events */
10852 hwnd = CreateWindowA("TestWindowClass", "PeekMessage2", WS_OVERLAPPEDWINDOW,
10853 10, 10, 800, 800, NULL, NULL, NULL, NULL);
10854 assert(hwnd);
10855 trace("Window for test_PeekMessage2 %p\n", hwnd);
10856 ShowWindow(hwnd, SW_SHOW);
10857 UpdateWindow(hwnd);
10858 SetFocus(hwnd);
10859 GetCursorPos(&pos);
10860 SetCursorPos(100, 100);
10861 mouse_event(MOUSEEVENTF_MOVE, -STEP, -STEP, 0, 0);
10862 flush_events();
10863
10864 /* Do initial mousemove, wait until we can see it
10865 and then do our test peek with PM_NOREMOVE. */
10866 mouse_event(MOUSEEVENTF_MOVE, STEP, STEP, 0, 0);
10867 wait_move_event(hwnd, 100-STEP, 100-STEP);
10868
10869 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
10870 if (!ret)
10871 {
10872 skip( "queuing mouse events not supported\n" );
10873 goto done;
10874 }
10875 else
10876 {
10877 trace("1st move event: %04x %x %d %d\n", msg.message, msg.time, msg.pt.x, msg.pt.y);
10878 message = msg.message;
10879 time1 = msg.time;
10880 x1 = msg.pt.x;
10881 y1 = msg.pt.y;
10882 ok(message == WM_MOUSEMOVE, "message not WM_MOUSEMOVE, %04x instead\n", message);
10883 }
10884
10885 /* Allow time to advance a bit, and then simulate the user moving their
10886 * mouse around. After that we peek again with PM_NOREMOVE.
10887 * Although the previous mousemove message was never removed, the
10888 * mousemove we now peek should reflect the recent mouse movements
10889 * because the input queue will merge the move events. */
10890 Sleep(100);
10891 mouse_event(MOUSEEVENTF_MOVE, STEP, STEP, 0, 0);
10892 wait_move_event(hwnd, x1, y1);
10893
10894 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
10895 ok(ret, "no message available\n");
10896 if (ret) {
10897 trace("2nd move event: %04x %x %d %d\n", msg.message, msg.time, msg.pt.x, msg.pt.y);
10898 message = msg.message;
10899 time2 = msg.time;
10900 x2 = msg.pt.x;
10901 y2 = msg.pt.y;
10902 ok(message == WM_MOUSEMOVE, "message not WM_MOUSEMOVE, %04x instead\n", message);
10903 ok(time2 > time1, "message time not advanced: %x %x\n", time1, time2);
10904 ok(x2 != x1 && y2 != y1, "coords not changed: (%d %d) (%d %d)\n", x1, y1, x2, y2);
10905 }
10906
10907 /* Have another go, to drive the point home */
10908 Sleep(100);
10909 mouse_event(MOUSEEVENTF_MOVE, STEP, STEP, 0, 0);
10910 wait_move_event(hwnd, x2, y2);
10911
10912 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
10913 ok(ret, "no message available\n");
10914 if (ret) {
10915 trace("3rd move event: %04x %x %d %d\n", msg.message, msg.time, msg.pt.x, msg.pt.y);
10916 message = msg.message;
10917 time3 = msg.time;
10918 x3 = msg.pt.x;
10919 y3 = msg.pt.y;
10920 ok(message == WM_MOUSEMOVE, "message not WM_MOUSEMOVE, %04x instead\n", message);
10921 ok(time3 > time2, "message time not advanced: %x %x\n", time2, time3);
10922 ok(x3 != x2 && y3 != y2, "coords not changed: (%d %d) (%d %d)\n", x2, y2, x3, y3);
10923 }
10924
10925 done:
10926 DestroyWindow(hwnd);
10927 SetCursorPos(pos.x, pos.y);
10928 flush_events();
10929 }
10930
10931 static void test_PeekMessage3(void)
10932 {
10933 HWND hwnd;
10934 BOOL ret;
10935 MSG msg;
10936
10937 hwnd = CreateWindowA("TestWindowClass", "PeekMessage3", WS_OVERLAPPEDWINDOW,
10938 10, 10, 800, 800, NULL, NULL, NULL, NULL);
10939 ok(hwnd != NULL, "expected hwnd != NULL\n");
10940 flush_events();
10941
10942 /* GetMessage() and PeekMessage(..., PM_REMOVE) should prefer messages which
10943 * were already seen. */
10944
10945 SetTimer(hwnd, 1, 0, NULL);
10946 while (!PeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE));
10947 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
10948 PostMessageA(hwnd, WM_USER, 0, 0);
10949 ret = PeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE);
10950 todo_wine
10951 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
10952 ret = GetMessageA(&msg, NULL, 0, 0);
10953 todo_wine
10954 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
10955 ret = GetMessageA(&msg, NULL, 0, 0);
10956 todo_wine
10957 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
10958 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
10959 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
10960
10961 SetTimer(hwnd, 1, 0, NULL);
10962 while (!PeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE));
10963 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
10964 PostMessageA(hwnd, WM_USER, 0, 0);
10965 ret = PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE);
10966 todo_wine
10967 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
10968 ret = PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE);
10969 todo_wine
10970 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
10971 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
10972 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
10973
10974 /* It doesn't matter if a message range is specified or not. */
10975
10976 SetTimer(hwnd, 1, 0, NULL);
10977 while (!PeekMessageA(&msg, NULL, WM_TIMER, WM_TIMER, PM_NOREMOVE));
10978 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
10979 PostMessageA(hwnd, WM_USER, 0, 0);
10980 ret = GetMessageA(&msg, NULL, 0, 0);
10981 todo_wine
10982 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
10983 ret = GetMessageA(&msg, NULL, 0, 0);
10984 todo_wine
10985 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
10986 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
10987 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
10988
10989 /* But not if the post messages were added before the PeekMessage() call. */
10990
10991 PostMessageA(hwnd, WM_USER, 0, 0);
10992 SetTimer(hwnd, 1, 0, NULL);
10993 while (!PeekMessageA(&msg, NULL, WM_TIMER, WM_TIMER, PM_NOREMOVE));
10994 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
10995 ret = GetMessageA(&msg, NULL, 0, 0);
10996 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
10997 ret = GetMessageA(&msg, NULL, 0, 0);
10998 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
10999 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
11000 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
11001
11002 /* More complicated test with multiple messages. */
11003
11004 PostMessageA(hwnd, WM_USER, 0, 0);
11005 SetTimer(hwnd, 1, 0, NULL);
11006 while (!PeekMessageA(&msg, NULL, WM_TIMER, WM_TIMER, PM_NOREMOVE));
11007 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11008 PostMessageA(hwnd, WM_USER + 1, 0, 0);
11009 ret = GetMessageA(&msg, NULL, 0, 0);
11010 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
11011 ret = GetMessageA(&msg, NULL, 0, 0);
11012 todo_wine
11013 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11014 ret = GetMessageA(&msg, NULL, 0, 0);
11015 todo_wine
11016 ok(ret && msg.message == WM_USER + 1, "msg.message = %u instead of WM_USER + 1\n", msg.message);
11017 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
11018 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
11019
11020 /* Also works for posted messages, but the situation is a bit different,
11021 * because both messages are in the same queue. */
11022
11023 PostMessageA(hwnd, WM_TIMER, 0, 0);
11024 while (!PeekMessageA(&msg, NULL, WM_TIMER, WM_TIMER, PM_NOREMOVE));
11025 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11026 PostMessageA(hwnd, WM_USER, 0, 0);
11027 ret = GetMessageA(&msg, NULL, 0, 0);
11028 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11029 ret = GetMessageA(&msg, NULL, 0, 0);
11030 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
11031 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
11032 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
11033
11034 PostMessageA(hwnd, WM_USER, 0, 0);
11035 PostMessageA(hwnd, WM_TIMER, 0, 0);
11036 while (!PeekMessageA(&msg, NULL, WM_TIMER, WM_TIMER, PM_NOREMOVE));
11037 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11038 ret = GetMessageA(&msg, NULL, 0, 0);
11039 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
11040 ret = GetMessageA(&msg, NULL, 0, 0);
11041 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
11042 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
11043 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
11044
11045 DestroyWindow(hwnd);
11046 flush_events();
11047 }
11048
11049 static INT_PTR CALLBACK wm_quit_dlg_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
11050 {
11051 struct recvd_message msg;
11052
11053 if (ignore_message( message )) return 0;
11054
11055 msg.hwnd = hwnd;
11056 msg.message = message;
11057 msg.flags = sent|wparam|lparam;
11058 msg.wParam = wp;
11059 msg.lParam = lp;
11060 msg.descr = "dialog";
11061 add_message(&msg);
11062
11063 switch (message)
11064 {
11065 case WM_INITDIALOG:
11066 PostMessageA(hwnd, WM_QUIT, 0x1234, 0x5678);
11067 PostMessageA(hwnd, WM_USER, 0xdead, 0xbeef);
11068 return 0;
11069
11070 case WM_GETDLGCODE:
11071 return 0;
11072
11073 case WM_USER:
11074 EndDialog(hwnd, 0);
11075 break;
11076 }
11077
11078 return 1;
11079 }
11080
11081 static const struct message WmQuitDialogSeq[] = {
11082 { HCBT_CREATEWND, hook },
11083 { WM_SETFONT, sent },
11084 { WM_INITDIALOG, sent },
11085 { WM_CHANGEUISTATE, sent|optional },
11086 { HCBT_DESTROYWND, hook },
11087 { 0x0090, sent|optional }, /* Vista */
11088 { WM_DESTROY, sent },
11089 { WM_NCDESTROY, sent },
11090 { 0 }
11091 };
11092
11093 static const struct message WmStopQuitSeq[] = {
11094 { WM_DWMNCRENDERINGCHANGED, posted|optional },
11095 { WM_CLOSE, posted },
11096 { WM_QUIT, posted|wparam|lparam, 0x1234, 0 },
11097 { 0 }
11098 };
11099
11100 static void test_quit_message(void)
11101 {
11102 MSG msg;
11103 BOOL ret;
11104
11105 /* test using PostQuitMessage */
11106 flush_events();
11107 PostQuitMessage(0xbeef);
11108
11109 msg.message = 0;
11110 ret = PeekMessageA(&msg, 0, 0, 0, PM_QS_SENDMESSAGE);
11111 ok(!ret, "got %x message\n", msg.message);
11112
11113 ret = PeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE);
11114 ok(ret, "PeekMessage failed with error %d\n", GetLastError());
11115 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
11116 ok(msg.wParam == 0xbeef, "wParam was 0x%lx instead of 0xbeef\n", msg.wParam);
11117
11118 ret = PostThreadMessageA(GetCurrentThreadId(), WM_USER, 0, 0);
11119 ok(ret, "PostMessage failed with error %d\n", GetLastError());
11120
11121 ret = GetMessageA(&msg, NULL, 0, 0);
11122 ok(ret > 0, "GetMessage failed with error %d\n", GetLastError());
11123 ok(msg.message == WM_USER, "Received message 0x%04x instead of WM_USER\n", msg.message);
11124
11125 /* note: WM_QUIT message received after WM_USER message */
11126 ret = GetMessageA(&msg, NULL, 0, 0);
11127 ok(!ret, "GetMessage return %d with error %d instead of FALSE\n", ret, GetLastError());
11128 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
11129 ok(msg.wParam == 0xbeef, "wParam was 0x%lx instead of 0xbeef\n", msg.wParam);
11130
11131 ret = PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE);
11132 ok( !ret || msg.message != WM_QUIT, "Received WM_QUIT again\n" );
11133
11134 /* now test with PostThreadMessage - different behaviour! */
11135 PostThreadMessageA(GetCurrentThreadId(), WM_QUIT, 0xdead, 0);
11136
11137 ret = PeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE);
11138 ok(ret, "PeekMessage failed with error %d\n", GetLastError());
11139 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
11140 ok(msg.wParam == 0xdead, "wParam was 0x%lx instead of 0xdead\n", msg.wParam);
11141
11142 ret = PostThreadMessageA(GetCurrentThreadId(), WM_USER, 0, 0);
11143 ok(ret, "PostMessage failed with error %d\n", GetLastError());
11144
11145 /* note: we receive the WM_QUIT message first this time */
11146 ret = GetMessageA(&msg, NULL, 0, 0);
11147 ok(!ret, "GetMessage return %d with error %d instead of FALSE\n", ret, GetLastError());
11148 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
11149 ok(msg.wParam == 0xdead, "wParam was 0x%lx instead of 0xdead\n", msg.wParam);
11150
11151 ret = GetMessageA(&msg, NULL, 0, 0);
11152 ok(ret > 0, "GetMessage failed with error %d\n", GetLastError());
11153 ok(msg.message == WM_USER, "Received message 0x%04x instead of WM_USER\n", msg.message);
11154
11155 flush_events();
11156 flush_sequence();
11157 ret = DialogBoxParamA(GetModuleHandleA(NULL), "TEST_EMPTY_DIALOG", 0, wm_quit_dlg_proc, 0);
11158 ok(ret == 1, "expected 1, got %d\n", ret);
11159 ok_sequence(WmQuitDialogSeq, "WmQuitDialogSeq", FALSE);
11160 memset(&msg, 0xab, sizeof(msg));
11161 ret = PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE);
11162 ok(ret, "PeekMessage failed\n");
11163 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
11164 ok(msg.wParam == 0x1234, "wParam was 0x%lx instead of 0x1234\n", msg.wParam);
11165 ok(msg.lParam == 0, "lParam was 0x%lx instead of 0\n", msg.lParam);
11166
11167 /* Check what happens to a WM_QUIT message posted to a window that gets
11168 * destroyed.
11169 */
11170 CreateWindowExA(0, "StopQuitClass", "Stop Quit Test", WS_OVERLAPPEDWINDOW,
11171 0, 0, 100, 100, NULL, NULL, NULL, NULL);
11172 flush_sequence();
11173 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
11174 {
11175 struct recvd_message rmsg;
11176 rmsg.hwnd = msg.hwnd;
11177 rmsg.message = msg.message;
11178 rmsg.flags = posted|wparam|lparam;
11179 rmsg.wParam = msg.wParam;
11180 rmsg.lParam = msg.lParam;
11181 rmsg.descr = "stop/quit";
11182 if (msg.message == WM_QUIT)
11183 /* The hwnd can only be checked here */
11184 ok(!msg.hwnd, "The WM_QUIT hwnd was %p instead of NULL\n", msg.hwnd);
11185 add_message(&rmsg);
11186 DispatchMessageA(&msg);
11187 }
11188 ok_sequence(WmStopQuitSeq, "WmStopQuitSeq", FALSE);
11189 }
11190
11191 static const struct message WmNotifySeq[] = {
11192 { WM_NOTIFY, sent|wparam|lparam, 0x1234, 0xdeadbeef },
11193 { 0 }
11194 };
11195
11196 static void test_notify_message(void)
11197 {
11198 HWND hwnd;
11199 BOOL ret;
11200 MSG msg;
11201
11202 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
11203 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0, NULL, NULL, 0);
11204 ok(hwnd != 0, "Failed to create window\n");
11205 flush_events();
11206 flush_sequence();
11207
11208 ret = SendNotifyMessageA(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef);
11209 ok(ret == TRUE, "SendNotifyMessageA failed with error %u\n", GetLastError());
11210 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
11211
11212 ret = SendNotifyMessageW(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef);
11213 ok(ret == TRUE, "SendNotifyMessageW failed with error %u\n", GetLastError());
11214 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
11215
11216 ret = SendMessageCallbackA(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef, NULL, 0);
11217 ok(ret == TRUE, "SendMessageCallbackA failed with error %u\n", GetLastError());
11218 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
11219
11220 ret = SendMessageCallbackW(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef, NULL, 0);
11221 ok(ret == TRUE, "SendMessageCallbackW failed with error %u\n", GetLastError());
11222 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
11223
11224 ret = PostMessageA(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef);
11225 ok(ret == TRUE, "PostMessageA failed with error %u\n", GetLastError());
11226 flush_events();
11227 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
11228
11229 ret = PostMessageW(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef);
11230 ok(ret == TRUE, "PostMessageW failed with error %u\n", GetLastError());
11231 flush_events();
11232 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
11233
11234 ret = PostThreadMessageA(GetCurrentThreadId(), WM_NOTIFY, 0x1234, 0xdeadbeef);
11235 ok(ret == TRUE, "PostThreadMessageA failed with error %u\n", GetLastError());
11236 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
11237 {
11238 msg.hwnd = hwnd;
11239 DispatchMessageA(&msg);
11240 }
11241 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
11242
11243 ret = PostThreadMessageW(GetCurrentThreadId(), WM_NOTIFY, 0x1234, 0xdeadbeef);
11244 ok(ret == TRUE, "PostThreadMessageW failed with error %u\n", GetLastError());
11245 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
11246 {
11247 msg.hwnd = hwnd;
11248 DispatchMessageA(&msg);
11249 }
11250 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
11251
11252 DestroyWindow(hwnd);
11253 }
11254
11255 static const struct message WmMouseHoverSeq[] = {
11256 { WM_MOUSEACTIVATE, sent|optional }, /* we can get those when moving the mouse in focus-follow-mouse mode under X11 */
11257 { WM_MOUSEACTIVATE, sent|optional },
11258 { WM_TIMER, sent|optional }, /* XP sends it */
11259 { WM_SYSTIMER, sent },
11260 { WM_MOUSEHOVER, sent|wparam, 0 },
11261 { 0 }
11262 };
11263
11264 static void pump_msg_loop_timeout(DWORD timeout, BOOL inject_mouse_move)
11265 {
11266 MSG msg;
11267 DWORD start_ticks, end_ticks;
11268
11269 start_ticks = GetTickCount();
11270 /* add some deviation (50%) to cover not expected delays */
11271 start_ticks += timeout / 2;
11272
11273 do
11274 {
11275 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
11276 {
11277 /* Timer proc messages are not dispatched to the window proc,
11278 * and therefore not logged.
11279 */
11280 if ((msg.message == WM_TIMER || msg.message == WM_SYSTIMER) && msg.hwnd)
11281 {
11282 struct recvd_message s_msg;
11283
11284 s_msg.hwnd = msg.hwnd;
11285 s_msg.message = msg.message;
11286 s_msg.flags = sent|wparam|lparam;
11287 s_msg.wParam = msg.wParam;
11288 s_msg.lParam = msg.lParam;
11289 s_msg.descr = "msg_loop";
11290 add_message(&s_msg);
11291 }
11292 DispatchMessageA(&msg);
11293 }
11294
11295 end_ticks = GetTickCount();
11296
11297 /* inject WM_MOUSEMOVE to see how it changes tracking */
11298 if (inject_mouse_move && start_ticks + timeout / 2 >= end_ticks)
11299 {
11300 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
11301 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
11302
11303 inject_mouse_move = FALSE;
11304 }
11305 } while (start_ticks + timeout >= end_ticks);
11306 }
11307
11308 static void test_TrackMouseEvent(void)
11309 {
11310 TRACKMOUSEEVENT tme;
11311 BOOL ret;
11312 HWND hwnd, hchild;
11313 RECT rc_parent, rc_child;
11314 UINT default_hover_time, hover_width = 0, hover_height = 0;
11315
11316 #define track_hover(track_hwnd, track_hover_time) \
11317 tme.cbSize = sizeof(tme); \
11318 tme.dwFlags = TME_HOVER; \
11319 tme.hwndTrack = track_hwnd; \
11320 tme.dwHoverTime = track_hover_time; \
11321 SetLastError(0xdeadbeef); \
11322 ret = pTrackMouseEvent(&tme); \
11323 ok(ret, "TrackMouseEvent(TME_HOVER) error %d\n", GetLastError())
11324
11325 #define track_query(expected_track_flags, expected_track_hwnd, expected_hover_time) \
11326 tme.cbSize = sizeof(tme); \
11327 tme.dwFlags = TME_QUERY; \
11328 tme.hwndTrack = (HWND)0xdeadbeef; \
11329 tme.dwHoverTime = 0xdeadbeef; \
11330 SetLastError(0xdeadbeef); \
11331 ret = pTrackMouseEvent(&tme); \
11332 ok(ret, "TrackMouseEvent(TME_QUERY) error %d\n", GetLastError());\
11333 ok(tme.cbSize == sizeof(tme), "wrong tme.cbSize %u\n", tme.cbSize); \
11334 ok(tme.dwFlags == (expected_track_flags), \
11335 "wrong tme.dwFlags %08x, expected %08x\n", tme.dwFlags, (expected_track_flags)); \
11336 ok(tme.hwndTrack == (expected_track_hwnd), \
11337 "wrong tme.hwndTrack %p, expected %p\n", tme.hwndTrack, (expected_track_hwnd)); \
11338 ok(tme.dwHoverTime == (expected_hover_time), \
11339 "wrong tme.dwHoverTime %u, expected %u\n", tme.dwHoverTime, (expected_hover_time))
11340
11341 #define track_hover_cancel(track_hwnd) \
11342 tme.cbSize = sizeof(tme); \
11343 tme.dwFlags = TME_HOVER | TME_CANCEL; \
11344 tme.hwndTrack = track_hwnd; \
11345 tme.dwHoverTime = 0xdeadbeef; \
11346 SetLastError(0xdeadbeef); \
11347 ret = pTrackMouseEvent(&tme); \
11348 ok(ret, "TrackMouseEvent(TME_HOVER | TME_CANCEL) error %d\n", GetLastError())
11349
11350 default_hover_time = 0xdeadbeef;
11351 SetLastError(0xdeadbeef);
11352 ret = SystemParametersInfoA(SPI_GETMOUSEHOVERTIME, 0, &default_hover_time, 0);
11353 ok(ret || broken(GetLastError() == 0xdeadbeef), /* win9x */
11354 "SystemParametersInfo(SPI_GETMOUSEHOVERTIME) error %u\n", GetLastError());
11355 if (!ret) default_hover_time = 400;
11356 trace("SPI_GETMOUSEHOVERTIME returned %u ms\n", default_hover_time);
11357
11358 SetLastError(0xdeadbeef);
11359 ret = SystemParametersInfoA(SPI_GETMOUSEHOVERWIDTH, 0, &hover_width, 0);
11360 ok(ret || broken(GetLastError() == 0xdeadbeef), /* win9x */
11361 "SystemParametersInfo(SPI_GETMOUSEHOVERWIDTH) error %u\n", GetLastError());
11362 if (!ret) hover_width = 4;
11363 SetLastError(0xdeadbeef);
11364 ret = SystemParametersInfoA(SPI_GETMOUSEHOVERHEIGHT, 0, &hover_height, 0);
11365 ok(ret || broken(GetLastError() == 0xdeadbeef), /* win9x */
11366 "SystemParametersInfo(SPI_GETMOUSEHOVERHEIGHT) error %u\n", GetLastError());
11367 if (!ret) hover_height = 4;
11368 trace("hover rect is %u x %d\n", hover_width, hover_height);
11369
11370 hwnd = CreateWindowExA(0, "TestWindowClass", NULL,
11371 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
11372 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
11373 NULL, NULL, 0);
11374 assert(hwnd);
11375
11376 hchild = CreateWindowExA(0, "TestWindowClass", NULL,
11377 WS_CHILD | WS_BORDER | WS_VISIBLE,
11378 50, 50, 200, 200, hwnd,
11379 NULL, NULL, 0);
11380 assert(hchild);
11381
11382 SetWindowPos( hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE );
11383 flush_events();
11384 flush_sequence();
11385
11386 tme.cbSize = 0;
11387 tme.dwFlags = TME_QUERY;
11388 tme.hwndTrack = (HWND)0xdeadbeef;
11389 tme.dwHoverTime = 0xdeadbeef;
11390 SetLastError(0xdeadbeef);
11391 ret = pTrackMouseEvent(&tme);
11392 ok(!ret, "TrackMouseEvent should fail\n");
11393 ok(GetLastError() == ERROR_INVALID_PARAMETER || broken(GetLastError() == 0xdeadbeef),
11394 "not expected error %u\n", GetLastError());
11395
11396 tme.cbSize = sizeof(tme);
11397 tme.dwFlags = TME_HOVER;
11398 tme.hwndTrack = (HWND)0xdeadbeef;
11399 tme.dwHoverTime = 0xdeadbeef;
11400 SetLastError(0xdeadbeef);
11401 ret = pTrackMouseEvent(&tme);
11402 ok(!ret, "TrackMouseEvent should fail\n");
11403 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || broken(GetLastError() == 0xdeadbeef),
11404 "not expected error %u\n", GetLastError());
11405
11406 tme.cbSize = sizeof(tme);
11407 tme.dwFlags = TME_HOVER | TME_CANCEL;
11408 tme.hwndTrack = (HWND)0xdeadbeef;
11409 tme.dwHoverTime = 0xdeadbeef;
11410 SetLastError(0xdeadbeef);
11411 ret = pTrackMouseEvent(&tme);
11412 ok(!ret, "TrackMouseEvent should fail\n");
11413 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || broken(GetLastError() == 0xdeadbeef),
11414 "not expected error %u\n", GetLastError());
11415
11416 GetWindowRect(hwnd, &rc_parent);
11417 GetWindowRect(hchild, &rc_child);
11418 SetCursorPos(rc_child.left - 10, rc_child.top - 10);
11419
11420 /* Process messages so that the system updates its internal current
11421 * window and hittest, otherwise TrackMouseEvent calls don't have any
11422 * effect.
11423 */
11424 flush_events();
11425 flush_sequence();
11426
11427 track_query(0, NULL, 0);
11428 track_hover(hchild, 0);
11429 track_query(0, NULL, 0);
11430
11431 flush_events();
11432 flush_sequence();
11433
11434 track_hover(hwnd, 0);
11435 tme.cbSize = sizeof(tme);
11436 tme.dwFlags = TME_QUERY;
11437 tme.hwndTrack = (HWND)0xdeadbeef;
11438 tme.dwHoverTime = 0xdeadbeef;
11439 SetLastError(0xdeadbeef);
11440 ret = pTrackMouseEvent(&tme);
11441 ok(ret, "TrackMouseEvent(TME_QUERY) error %d\n", GetLastError());
11442 ok(tme.cbSize == sizeof(tme), "wrong tme.cbSize %u\n", tme.cbSize);
11443 if (!tme.dwFlags)
11444 {
11445 skip( "Cursor not inside window, skipping TrackMouseEvent tests\n" );
11446 DestroyWindow( hwnd );
11447 return;
11448 }
11449 ok(tme.dwFlags == TME_HOVER, "wrong tme.dwFlags %08x, expected TME_HOVER\n", tme.dwFlags);
11450 ok(tme.hwndTrack == hwnd, "wrong tme.hwndTrack %p, expected %p\n", tme.hwndTrack, hwnd);
11451 ok(tme.dwHoverTime == default_hover_time, "wrong tme.dwHoverTime %u, expected %u\n",
11452 tme.dwHoverTime, default_hover_time);
11453
11454 pump_msg_loop_timeout(default_hover_time, FALSE);
11455 ok_sequence(WmMouseHoverSeq, "WmMouseHoverSeq", FALSE);
11456
11457 track_query(0, NULL, 0);
11458
11459 track_hover(hwnd, HOVER_DEFAULT);
11460 track_query(TME_HOVER, hwnd, default_hover_time);
11461
11462 Sleep(default_hover_time / 2);
11463 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
11464 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
11465
11466 track_query(TME_HOVER, hwnd, default_hover_time);
11467
11468 pump_msg_loop_timeout(default_hover_time, FALSE);
11469 ok_sequence(WmMouseHoverSeq, "WmMouseHoverSeq", FALSE);
11470
11471 track_query(0, NULL, 0);
11472
11473 track_hover(hwnd, HOVER_DEFAULT);
11474 track_query(TME_HOVER, hwnd, default_hover_time);
11475
11476 pump_msg_loop_timeout(default_hover_time, TRUE);
11477 ok_sequence(WmMouseHoverSeq, "WmMouseHoverSeq", FALSE);
11478
11479 track_query(0, NULL, 0);
11480
11481 track_hover(hwnd, HOVER_DEFAULT);
11482 track_query(TME_HOVER, hwnd, default_hover_time);
11483 track_hover_cancel(hwnd);
11484
11485 DestroyWindow(hwnd);
11486
11487 #undef track_hover
11488 #undef track_query
11489 #undef track_hover_cancel
11490 }
11491
11492
11493 static const struct message WmSetWindowRgn[] = {
11494 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
11495 { WM_NCCALCSIZE, sent|wparam, 1 },
11496 { WM_NCPAINT, sent|optional }, /* wparam != 1 */
11497 { WM_GETTEXT, sent|defwinproc|optional },
11498 { WM_ERASEBKGND, sent|optional },
11499 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
11500 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
11501 { 0 }
11502 };
11503
11504 static const struct message WmSetWindowRgn_no_redraw[] = {
11505 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW },
11506 { WM_NCCALCSIZE, sent|wparam, 1 },
11507 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW },
11508 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
11509 { 0 }
11510 };
11511
11512 static const struct message WmSetWindowRgn_clear[] = {
11513 { WM_WINDOWPOSCHANGING, sent/*|wparam*/, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE/*|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE only on some Windows versions */ },
11514 { WM_NCCALCSIZE, sent|wparam, 1 },
11515 { WM_NCPAINT, sent|optional },
11516 { WM_GETTEXT, sent|defwinproc|optional },
11517 { WM_ERASEBKGND, sent|optional }, /* FIXME: remove optional once Wine is fixed */
11518 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
11519 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
11520 { WM_NCPAINT, sent|optional },
11521 { WM_GETTEXT, sent|defwinproc|optional },
11522 { WM_ERASEBKGND, sent|optional },
11523 { WM_WINDOWPOSCHANGING, sent|optional },
11524 { WM_NCCALCSIZE, sent|optional|wparam, 1 },
11525 { WM_NCPAINT, sent|optional },
11526 { WM_GETTEXT, sent|defwinproc|optional },
11527 { WM_ERASEBKGND, sent|optional },
11528 { WM_WINDOWPOSCHANGED, sent|optional|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
11529 { WM_NCCALCSIZE, sent|optional|wparam, 1 },
11530 { WM_NCPAINT, sent|optional },
11531 { WM_GETTEXT, sent|defwinproc|optional },
11532 { WM_ERASEBKGND, sent|optional },
11533 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
11534 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
11535 { 0 }
11536 };
11537
11538 static void test_SetWindowRgn(void)
11539 {
11540 HRGN hrgn;
11541 HWND hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
11542 100, 100, 200, 200, 0, 0, 0, NULL);
11543 ok( hwnd != 0, "Failed to create overlapped window\n" );
11544
11545 ShowWindow( hwnd, SW_SHOW );
11546 UpdateWindow( hwnd );
11547 flush_events();
11548 flush_sequence();
11549
11550 trace("testing SetWindowRgn\n");
11551 hrgn = CreateRectRgn( 0, 0, 150, 150 );
11552 SetWindowRgn( hwnd, hrgn, TRUE );
11553 ok_sequence( WmSetWindowRgn, "WmSetWindowRgn", FALSE );
11554
11555 hrgn = CreateRectRgn( 30, 30, 160, 160 );
11556 SetWindowRgn( hwnd, hrgn, FALSE );
11557 ok_sequence( WmSetWindowRgn_no_redraw, "WmSetWindowRgn_no_redraw", FALSE );
11558
11559 hrgn = CreateRectRgn( 0, 0, 180, 180 );
11560 SetWindowRgn( hwnd, hrgn, TRUE );
11561 ok_sequence( WmSetWindowRgn, "WmSetWindowRgn2", FALSE );
11562
11563 SetWindowRgn( hwnd, 0, TRUE );
11564 ok_sequence( WmSetWindowRgn_clear, "WmSetWindowRgn_clear", FALSE );
11565
11566 DestroyWindow( hwnd );
11567 }
11568
11569 /*************************** ShowWindow() test ******************************/
11570 static const struct message WmShowNormal[] = {
11571 { WM_SHOWWINDOW, sent|wparam, 1 },
11572 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
11573 { HCBT_ACTIVATE, hook },
11574 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2003 doesn't send it */
11575 { HCBT_SETFOCUS, hook },
11576 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
11577 { 0 }
11578 };
11579 static const struct message WmShow[] = {
11580 { WM_SHOWWINDOW, sent|wparam, 1 },
11581 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
11582 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
11583 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
11584 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
11585 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
11586 { 0 }
11587 };
11588 static const struct message WmShowNoActivate_1[] = {
11589 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNOACTIVATE },
11590 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
11591 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
11592 { WM_MOVE, sent|defwinproc|optional },
11593 { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
11594 { 0 }
11595 };
11596 static const struct message WmShowNoActivate_2[] = {
11597 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNOACTIVATE },
11598 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
11599 { HCBT_ACTIVATE, hook|optional },
11600 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
11601 { HCBT_SETFOCUS, hook|optional },
11602 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
11603 { WM_MOVE, sent|defwinproc },
11604 { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
11605 { HCBT_SETFOCUS, hook|optional },
11606 { HCBT_ACTIVATE, hook|optional }, /* win2003 doesn't send it */
11607 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2003 doesn't send it */
11608 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
11609 { HCBT_SETFOCUS, hook|optional }, /* win2003 doesn't send it */
11610 { 0 }
11611 };
11612 static const struct message WmShowNA_1[] = {
11613 { WM_SHOWWINDOW, sent|wparam, 1 },
11614 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
11615 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
11616 { 0 }
11617 };
11618 static const struct message WmShowNA_2[] = {
11619 { WM_SHOWWINDOW, sent|wparam, 1 },
11620 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
11621 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
11622 { 0 }
11623 };
11624 static const struct message WmRestore_1[] = {
11625 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
11626 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11627 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
11628 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
11629 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
11630 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11631 { WM_MOVE, sent|defwinproc },
11632 { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
11633 { HCBT_SETFOCUS, hook|optional }, /* win2000 sends it */
11634 { 0 }
11635 };
11636 static const struct message WmRestore_2[] = {
11637 { WM_SHOWWINDOW, sent|wparam, 1 },
11638 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
11639 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
11640 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
11641 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
11642 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
11643 { 0 }
11644 };
11645 static const struct message WmRestore_3[] = {
11646 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
11647 { WM_GETMINMAXINFO, sent },
11648 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11649 { HCBT_ACTIVATE, hook|optional }, /* win2003 doesn't send it */
11650 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2003 doesn't send it */
11651 { HCBT_SETFOCUS, hook|optional }, /* win2003 doesn't send it */
11652 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11653 { WM_MOVE, sent|defwinproc },
11654 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
11655 { HCBT_SETFOCUS, hook|optional }, /* win2003 sends it */
11656 { 0 }
11657 };
11658 static const struct message WmRestore_4[] = {
11659 { HCBT_MINMAX, hook|lparam|optional, 0, SW_RESTORE },
11660 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
11661 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
11662 { WM_MOVE, sent|defwinproc|optional },
11663 { WM_SIZE, sent|wparam|defwinproc|optional, SIZE_RESTORED },
11664 { 0 }
11665 };
11666 static const struct message WmRestore_5[] = {
11667 { HCBT_MINMAX, hook|lparam|optional, 0, SW_SHOWNORMAL },
11668 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
11669 { HCBT_ACTIVATE, hook|optional },
11670 { HCBT_SETFOCUS, hook|optional },
11671 { WM_WINDOWPOSCHANGED, sent|wparam|optional, 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|optional, SIZE_RESTORED },
11674 { 0 }
11675 };
11676 static const struct message WmHide_1[] = {
11677 { WM_SHOWWINDOW, sent|wparam, 0 },
11678 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE, 0, SWP_NOACTIVATE },
11679 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE, 0, SWP_NOACTIVATE },
11680 { HCBT_ACTIVATE, hook|optional },
11681 { HCBT_SETFOCUS, hook|optional }, /* win2000 sends it */
11682 { 0 }
11683 };
11684 static const struct message WmHide_2[] = {
11685 { WM_SHOWWINDOW, sent|wparam, 0 },
11686 { WM_WINDOWPOSCHANGING, sent /*|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE*/ }, /* win2000 doesn't add SWP_NOACTIVATE */
11687 { WM_WINDOWPOSCHANGED, sent /*|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ }, /* win2000 doesn't add SWP_NOACTIVATE */
11688 { HCBT_ACTIVATE, hook|optional },
11689 { 0 }
11690 };
11691 static const struct message WmHide_3[] = {
11692 { WM_SHOWWINDOW, sent|wparam, 0 },
11693 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
11694 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
11695 { HCBT_SETFOCUS, hook|optional },
11696 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
11697 { 0 }
11698 };
11699 static const struct message WmShowMinimized_1[] = {
11700 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
11701 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11702 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
11703 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
11704 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11705 { WM_MOVE, sent|defwinproc },
11706 { WM_SIZE, sent|wparam|lparam|defwinproc, SIZE_MINIMIZED, 0 },
11707 { 0 }
11708 };
11709 static const struct message WmMinimize_1[] = {
11710 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
11711 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
11712 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
11713 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11714 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11715 { WM_MOVE, sent|defwinproc },
11716 { WM_SIZE, sent|wparam|lparam|defwinproc, SIZE_MINIMIZED, 0 },
11717 { 0 }
11718 };
11719 static const struct message WmMinimize_2[] = {
11720 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
11721 { HCBT_SETFOCUS, hook|optional },
11722 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
11723 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
11724 { WM_MOVE, sent|defwinproc },
11725 { WM_SIZE, sent|wparam|lparam|defwinproc, SIZE_MINIMIZED, 0 },
11726 { 0 }
11727 };
11728 static const struct message WmMinimize_3[] = {
11729 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
11730 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
11731 { HCBT_ACTIVATE, hook|optional },
11732 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
11733 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
11734 { WM_MOVE, sent|defwinproc },
11735 { WM_SIZE, sent|wparam|lparam|defwinproc, SIZE_MINIMIZED, 0 },
11736 { 0 }
11737 };
11738 static const struct message WmShowMinNoActivate[] = {
11739 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
11740 { WM_WINDOWPOSCHANGING, sent },
11741 { WM_WINDOWPOSCHANGED, sent },
11742 { WM_MOVE, sent|defwinproc|optional },
11743 { WM_SIZE, sent|wparam|lparam|defwinproc|optional, SIZE_MINIMIZED, 0 },
11744 { 0 }
11745 };
11746 static const struct message WmMinMax_1[] = {
11747 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
11748 { 0 }
11749 };
11750 static const struct message WmMinMax_2[] = {
11751 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
11752 { WM_GETMINMAXINFO, sent|optional },
11753 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED },
11754 { HCBT_ACTIVATE, hook|optional },
11755 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
11756 { HCBT_SETFOCUS, hook|optional },
11757 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
11758 { WM_MOVE, sent|defwinproc|optional },
11759 { WM_SIZE, sent|wparam|defwinproc|optional, SIZE_MAXIMIZED },
11760 { HCBT_SETFOCUS, hook|optional },
11761 { 0 }
11762 };
11763 static const struct message WmMinMax_3[] = {
11764 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
11765 { HCBT_SETFOCUS, hook|optional },
11766 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11767 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11768 { WM_MOVE, sent|defwinproc|optional },
11769 { WM_SIZE, sent|wparam|lparam|defwinproc|optional, SIZE_MINIMIZED, 0 },
11770 { 0 }
11771 };
11772 static const struct message WmMinMax_4[] = {
11773 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
11774 { 0 }
11775 };
11776 static const struct message WmShowMaximized_1[] = {
11777 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
11778 { WM_GETMINMAXINFO, sent },
11779 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11780 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
11781 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
11782 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
11783 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11784 { WM_MOVE, sent|defwinproc },
11785 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
11786 { HCBT_SETFOCUS, hook|optional }, /* win2003 sends it */
11787 { 0 }
11788 };
11789 static const struct message WmShowMaximized_2[] = {
11790 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
11791 { WM_GETMINMAXINFO, sent },
11792 { WM_WINDOWPOSCHANGING, sent|optional },
11793 { HCBT_ACTIVATE, hook|optional },
11794 { WM_WINDOWPOSCHANGED, sent|optional },
11795 { WM_MOVE, sent|optional }, /* Win9x doesn't send it */
11796 { WM_SIZE, sent|wparam|optional, SIZE_MAXIMIZED }, /* Win9x doesn't send it */
11797 { WM_WINDOWPOSCHANGING, sent|optional },
11798 { HCBT_SETFOCUS, hook|optional },
11799 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
11800 { WM_MOVE, sent|defwinproc },
11801 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
11802 { HCBT_SETFOCUS, hook|optional },
11803 { 0 }
11804 };
11805 static const struct message WmShowMaximized_3[] = {
11806 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
11807 { WM_GETMINMAXINFO, sent|optional },
11808 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
11809 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
11810 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
11811 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
11812 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
11813 { WM_MOVE, sent|defwinproc|optional },
11814 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
11815 { 0 }
11816 };
11817
11818 static void test_ShowWindow(void)
11819 {
11820 /* ShowWindow commands in random order */
11821 static const struct
11822 {
11823 INT cmd; /* ShowWindow command */
11824 LPARAM ret; /* ShowWindow return value */
11825 DWORD style; /* window style after the command */
11826 const struct message *msg; /* message sequence the command produces */
11827 INT wp_cmd, wp_flags; /* window placement after the command */
11828 POINT wp_min, wp_max; /* window placement after the command */
11829 BOOL todo_msg; /* message sequence doesn't match what Wine does */
11830 } sw[] =
11831 {
11832 /* 1 */ { SW_SHOWNORMAL, FALSE, WS_VISIBLE, WmShowNormal,
11833 SW_SHOWNORMAL, 0, {-1,-1}, {-1,-1}, FALSE },
11834 /* 2 */ { SW_SHOWNORMAL, TRUE, WS_VISIBLE, WmEmptySeq,
11835 SW_SHOWNORMAL, 0, {-1,-1}, {-1,-1}, FALSE },
11836 /* 3 */ { SW_HIDE, TRUE, 0, WmHide_1,
11837 SW_SHOWNORMAL, 0, {-1,-1}, {-1,-1}, FALSE },
11838 /* 4 */ { SW_HIDE, FALSE, 0, WmEmptySeq,
11839 SW_SHOWNORMAL, 0, {-1,-1}, {-1,-1}, FALSE },
11840 /* 5 */ { SW_SHOWMINIMIZED, FALSE, WS_VISIBLE|WS_MINIMIZE, WmShowMinimized_1,
11841 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11842 /* 6 */ { SW_SHOWMINIMIZED, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_1,
11843 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11844 /* 7 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_1,
11845 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11846 /* 8 */ { SW_HIDE, FALSE, WS_MINIMIZE, WmEmptySeq,
11847 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11848 /* 9 */ { SW_SHOWMAXIMIZED, FALSE, WS_VISIBLE|WS_MAXIMIZE, WmShowMaximized_1,
11849 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11850 /* 10 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmMinMax_2,
11851 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11852 /* 11 */ { SW_HIDE, TRUE, WS_MAXIMIZE, WmHide_1,
11853 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11854 /* 12 */ { SW_HIDE, FALSE, WS_MAXIMIZE, WmEmptySeq,
11855 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11856 /* 13 */ { SW_SHOWNOACTIVATE, FALSE, WS_VISIBLE, WmShowNoActivate_1,
11857 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11858 /* 14 */ { SW_SHOWNOACTIVATE, TRUE, WS_VISIBLE, WmEmptySeq,
11859 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11860 /* 15 */ { SW_HIDE, TRUE, 0, WmHide_2,
11861 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11862 /* 16 */ { SW_HIDE, FALSE, 0, WmEmptySeq,
11863 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11864 /* 17 */ { SW_SHOW, FALSE, WS_VISIBLE, WmShow,
11865 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11866 /* 18 */ { SW_SHOW, TRUE, WS_VISIBLE, WmEmptySeq,
11867 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11868 /* 19 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_1,
11869 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11870 /* 20 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_3,
11871 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11872 /* 21 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2,
11873 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11874 /* 22 */ { SW_SHOWMINNOACTIVE, FALSE, WS_VISIBLE|WS_MINIMIZE, WmShowMinNoActivate,
11875 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, TRUE },
11876 /* 23 */ { SW_SHOWMINNOACTIVE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_4,
11877 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11878 /* 24 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2,
11879 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11880 /* 25 */ { SW_HIDE, FALSE, WS_MINIMIZE, WmEmptySeq,
11881 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11882 /* 26 */ { SW_SHOWNA, FALSE, WS_VISIBLE|WS_MINIMIZE, WmShowNA_1,
11883 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11884 /* 27 */ { SW_SHOWNA, TRUE, WS_VISIBLE|WS_MINIMIZE, WmShowNA_2,
11885 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11886 /* 28 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2,
11887 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11888 /* 29 */ { SW_HIDE, FALSE, WS_MINIMIZE, WmEmptySeq,
11889 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11890 /* 30 */ { SW_RESTORE, FALSE, WS_VISIBLE, WmRestore_1,
11891 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11892 /* 31 */ { SW_RESTORE, TRUE, WS_VISIBLE, WmEmptySeq,
11893 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11894 /* 32 */ { SW_HIDE, TRUE, 0, WmHide_3,
11895 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11896 /* 33 */ { SW_HIDE, FALSE, 0, WmEmptySeq,
11897 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11898 /* 34 */ { SW_NORMALNA, FALSE, 0, WmEmptySeq, /* what does this mean?! */
11899 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11900 /* 35 */ { SW_NORMALNA, FALSE, 0, WmEmptySeq,
11901 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11902 /* 36 */ { SW_HIDE, FALSE, 0, WmEmptySeq,
11903 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11904 /* 37 */ { SW_RESTORE, FALSE, WS_VISIBLE, WmRestore_2,
11905 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11906 /* 38 */ { SW_RESTORE, TRUE, WS_VISIBLE, WmEmptySeq,
11907 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11908 /* 39 */ { SW_SHOWNOACTIVATE, TRUE, WS_VISIBLE, WmEmptySeq,
11909 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11910 /* 40 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_2,
11911 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11912 /* 41 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_3,
11913 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11914 /* 42 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmShowMaximized_2,
11915 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11916 /* 43 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmMinMax_2,
11917 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11918 /* 44 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_1,
11919 SW_SHOWMINIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11920 /* 45 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_3,
11921 SW_SHOWMINIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11922 /* 46 */ { SW_RESTORE, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmRestore_3,
11923 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11924 /* 47 */ { SW_RESTORE, TRUE, WS_VISIBLE, WmRestore_4,
11925 SW_SHOWNORMAL, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11926 /* 48 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmShowMaximized_3,
11927 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11928 /* 49 */ { SW_SHOW, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmEmptySeq,
11929 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11930 /* 50 */ { SW_SHOWNORMAL, TRUE, WS_VISIBLE, WmRestore_5,
11931 SW_SHOWNORMAL, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11932 /* 51 */ { SW_SHOWNORMAL, TRUE, WS_VISIBLE, WmRestore_5,
11933 SW_SHOWNORMAL, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11934 /* 52 */ { SW_HIDE, TRUE, 0, WmHide_1,
11935 SW_SHOWNORMAL, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11936 /* 53 */ { SW_HIDE, FALSE, 0, WmEmptySeq,
11937 SW_SHOWNORMAL, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
11938 /* 54 */ { SW_MINIMIZE, FALSE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_3,
11939 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11940 /* 55 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2,
11941 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
11942 /* 56 */ { SW_SHOWNOACTIVATE, FALSE, WS_VISIBLE, WmShowNoActivate_2,
11943 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
11944 /* 57 */ { SW_SHOW, TRUE, WS_VISIBLE, WmEmptySeq,
11945 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE }
11946 };
11947 HWND hwnd;
11948 DWORD style;
11949 LPARAM ret;
11950 INT i;
11951 WINDOWPLACEMENT wp;
11952 RECT win_rc, work_rc = {0, 0, 0, 0};
11953
11954 #define WS_BASE (WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_POPUP|WS_CLIPSIBLINGS)
11955 hwnd = CreateWindowExA(0, "ShowWindowClass", NULL, WS_BASE,
11956 120, 120, 90, 90,
11957 0, 0, 0, NULL);
11958 assert(hwnd);
11959
11960 style = GetWindowLongA(hwnd, GWL_STYLE) & ~WS_BASE;
11961 ok(style == 0, "expected style 0, got %08x\n", style);
11962
11963 flush_events();
11964 flush_sequence();
11965
11966 if (pGetMonitorInfoA && pMonitorFromPoint)
11967 {
11968 HMONITOR hmon;
11969 MONITORINFO mi;
11970 POINT pt = {0, 0};
11971
11972 SetLastError(0xdeadbeef);
11973 hmon = pMonitorFromPoint(pt, MONITOR_DEFAULTTOPRIMARY);
11974 ok(hmon != 0, "MonitorFromPoint error %u\n", GetLastError());
11975
11976 mi.cbSize = sizeof(mi);
11977 SetLastError(0xdeadbeef);
11978 ret = pGetMonitorInfoA(hmon, &mi);
11979 ok(ret, "GetMonitorInfo error %u\n", GetLastError());
11980 trace("monitor (%d,%d-%d,%d), work (%d,%d-%d,%d)\n",
11981 mi.rcMonitor.left, mi.rcMonitor.top, mi.rcMonitor.right, mi.rcMonitor.bottom,
11982 mi.rcWork.left, mi.rcWork.top, mi.rcWork.right, mi.rcWork.bottom);
11983 work_rc = mi.rcWork;
11984 }
11985
11986 GetWindowRect(hwnd, &win_rc);
11987 OffsetRect(&win_rc, -work_rc.left, -work_rc.top);
11988
11989 wp.length = sizeof(wp);
11990 SetLastError(0xdeadbeaf);
11991 ret = GetWindowPlacement(hwnd, &wp);
11992 ok(ret, "GetWindowPlacement error %u\n", GetLastError());
11993 ok(wp.flags == 0, "expected 0, got %#x\n", wp.flags);
11994 ok(wp.showCmd == SW_SHOWNORMAL, "expected SW_SHOWNORMAL, got %d\n", wp.showCmd);
11995 ok(wp.ptMinPosition.x == -1 && wp.ptMinPosition.y == -1,
11996 "expected -1,-1 got %d,%d\n", wp.ptMinPosition.x, wp.ptMinPosition.y);
11997 ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1,
11998 "expected -1,-1 got %d,%d\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y);
11999 todo_wine_if (work_rc.left || work_rc.top) /* FIXME: remove once Wine is fixed */
12000 ok(EqualRect(&win_rc, &wp.rcNormalPosition),
12001 "expected %d,%d-%d,%d got %d,%d-%d,%d\n",
12002 win_rc.left, win_rc.top, win_rc.right, win_rc.bottom,
12003 wp.rcNormalPosition.left, wp.rcNormalPosition.top,
12004 wp.rcNormalPosition.right, wp.rcNormalPosition.bottom);
12005
12006 for (i = 0; i < sizeof(sw)/sizeof(sw[0]); i++)
12007 {
12008 static const char * const sw_cmd_name[13] =
12009 {
12010 "SW_HIDE", "SW_SHOWNORMAL", "SW_SHOWMINIMIZED", "SW_SHOWMAXIMIZED",
12011 "SW_SHOWNOACTIVATE", "SW_SHOW", "SW_MINIMIZE", "SW_SHOWMINNOACTIVE",
12012 "SW_SHOWNA", "SW_RESTORE", "SW_SHOWDEFAULT", "SW_FORCEMINIMIZE",
12013 "SW_NORMALNA" /* 0xCC */
12014 };
12015 char comment[64];
12016 INT idx; /* index into the above array of names */
12017
12018 idx = (sw[i].cmd == SW_NORMALNA) ? 12 : sw[i].cmd;
12019
12020 style = GetWindowLongA(hwnd, GWL_STYLE);
12021 trace("%d: sending %s, current window style %08x\n", i+1, sw_cmd_name[idx], style);
12022 ret = ShowWindow(hwnd, sw[i].cmd);
12023 ok(!ret == !sw[i].ret, "%d: cmd %s: expected ret %lu, got %lu\n", i+1, sw_cmd_name[idx], sw[i].ret, ret);
12024 style = GetWindowLongA(hwnd, GWL_STYLE) & ~WS_BASE;
12025 ok(style == sw[i].style, "%d: expected style %08x, got %08x\n", i+1, sw[i].style, style);
12026
12027 sprintf(comment, "%d: ShowWindow(%s)", i+1, sw_cmd_name[idx]);
12028 ok_sequence(sw[i].msg, comment, sw[i].todo_msg);
12029
12030 wp.length = sizeof(wp);
12031 SetLastError(0xdeadbeaf);
12032 ret = GetWindowPlacement(hwnd, &wp);
12033 ok(ret, "GetWindowPlacement error %u\n", GetLastError());
12034 ok(wp.flags == sw[i].wp_flags, "expected %#x, got %#x\n", sw[i].wp_flags, wp.flags);
12035 ok(wp.showCmd == sw[i].wp_cmd, "expected %d, got %d\n", sw[i].wp_cmd, wp.showCmd);
12036
12037 /* NT moves the minimized window to -32000,-32000, win9x to 3000,3000 */
12038 if ((wp.ptMinPosition.x + work_rc.left == -32000 && wp.ptMinPosition.y + work_rc.top == -32000) ||
12039 (wp.ptMinPosition.x + work_rc.left == 3000 && wp.ptMinPosition.y + work_rc.top == 3000))
12040 {
12041 ok((wp.ptMinPosition.x + work_rc.left == sw[i].wp_min.x && wp.ptMinPosition.y + work_rc.top == sw[i].wp_min.y) ||
12042 (wp.ptMinPosition.x + work_rc.left == 3000 && wp.ptMinPosition.y + work_rc.top == 3000),
12043 "expected %d,%d got %d,%d\n", sw[i].wp_min.x, sw[i].wp_min.y, wp.ptMinPosition.x, wp.ptMinPosition.y);
12044 }
12045 else
12046 {
12047 ok(wp.ptMinPosition.x == sw[i].wp_min.x && wp.ptMinPosition.y == sw[i].wp_min.y,
12048 "expected %d,%d got %d,%d\n", sw[i].wp_min.x, sw[i].wp_min.y, wp.ptMinPosition.x, wp.ptMinPosition.y);
12049 }
12050
12051 if (wp.ptMaxPosition.x != sw[i].wp_max.x || wp.ptMaxPosition.y != sw[i].wp_max.y)
12052 todo_wine
12053 ok(wp.ptMaxPosition.x == sw[i].wp_max.x && wp.ptMaxPosition.y == sw[i].wp_max.y,
12054 "expected %d,%d got %d,%d\n", sw[i].wp_max.x, sw[i].wp_max.y, wp.ptMaxPosition.x, wp.ptMaxPosition.y);
12055 else
12056 ok(wp.ptMaxPosition.x == sw[i].wp_max.x && wp.ptMaxPosition.y == sw[i].wp_max.y,
12057 "expected %d,%d got %d,%d\n", sw[i].wp_max.x, sw[i].wp_max.y, wp.ptMaxPosition.x, wp.ptMaxPosition.y);
12058
12059 if (0) /* FIXME: Wine behaves completely different here */
12060 ok(EqualRect(&win_rc, &wp.rcNormalPosition),
12061 "expected %d,%d-%d,%d got %d,%d-%d,%d\n",
12062 win_rc.left, win_rc.top, win_rc.right, win_rc.bottom,
12063 wp.rcNormalPosition.left, wp.rcNormalPosition.top,
12064 wp.rcNormalPosition.right, wp.rcNormalPosition.bottom);
12065 }
12066 DestroyWindow(hwnd);
12067 flush_events();
12068 }
12069
12070 static INT_PTR WINAPI test_dlg_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
12071 {
12072 struct recvd_message msg;
12073
12074 if (ignore_message( message )) return 0;
12075
12076 msg.hwnd = hwnd;
12077 msg.message = message;
12078 msg.flags = sent|wparam|lparam;
12079 msg.wParam = wParam;
12080 msg.lParam = lParam;
12081 msg.descr = "dialog";
12082 add_message(&msg);
12083
12084 /* calling DefDlgProc leads to a recursion under XP */
12085
12086 switch (message)
12087 {
12088 case WM_INITDIALOG:
12089 case WM_GETDLGCODE:
12090 return 0;
12091 }
12092 return 1;
12093 }
12094
12095 static WNDPROC orig_edit_proc;
12096 static LRESULT WINAPI dlg_creation_edit_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
12097 {
12098 struct recvd_message msg;
12099
12100 if (ignore_message( message )) return 0;
12101
12102 msg.hwnd = hwnd;
12103 msg.message = message;
12104 msg.flags = sent|wparam|lparam;
12105 msg.wParam = wp;
12106 msg.lParam = lp;
12107 msg.descr = "edit";
12108 add_message(&msg);
12109
12110 return CallWindowProcW(orig_edit_proc, hwnd, message, wp, lp);
12111 }
12112
12113 static INT_PTR WINAPI test_dlg_proc2(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
12114 {
12115 struct recvd_message msg;
12116
12117 if (ignore_message( message )) return 0;
12118
12119 msg.hwnd = hwnd;
12120 msg.message = message;
12121 msg.flags = sent|wparam|lparam|parent;
12122 msg.wParam = wParam;
12123 msg.lParam = lParam;
12124 msg.descr = "dialog";
12125 add_message(&msg);
12126
12127 if (message == WM_INITDIALOG)
12128 {
12129 orig_edit_proc = (WNDPROC)SetWindowLongPtrW(GetDlgItem(hwnd, 200),
12130 GWLP_WNDPROC, (LONG_PTR)dlg_creation_edit_proc);
12131 }
12132
12133 return 1;
12134 }
12135
12136 static INT_PTR WINAPI test_dlg_proc3(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
12137 {
12138 ok( 0, "should not be called since DefDlgProc is not used\n" );
12139 return 0;
12140 }
12141
12142 static LRESULT WINAPI test_dlg_proc4(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
12143 {
12144 struct recvd_message msg;
12145
12146 if (!ignore_message( message ))
12147 {
12148 msg.hwnd = hwnd;
12149 msg.message = message;
12150 msg.flags = sent|wparam|lparam|parent;
12151 msg.wParam = wParam;
12152 msg.lParam = lParam;
12153 msg.descr = "dialog";
12154 add_message(&msg);
12155 }
12156 if (message == WM_INITDIALOG)
12157 {
12158 orig_edit_proc = (WNDPROC)SetWindowLongPtrW(GetDlgItem(hwnd, 200),
12159 GWLP_WNDPROC, (LONG_PTR)dlg_creation_edit_proc);
12160 return 1;
12161 }
12162 return DefWindowProcW( hwnd, message, wParam, lParam );
12163 }
12164
12165 static const struct message WmDefDlgSetFocus_1[] = {
12166 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
12167 { WM_GETTEXTLENGTH, sent|wparam|lparam|optional, 0, 0 }, /* XP */
12168 { WM_GETTEXT, sent|wparam|optional, 6 }, /* XP */
12169 { WM_GETTEXT, sent|wparam|optional, 12 }, /* XP */
12170 { EM_SETSEL, sent|wparam, 0 }, /* XP sets lparam to text length, Win9x to -2 */
12171 { HCBT_SETFOCUS, hook },
12172 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
12173 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
12174 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
12175 { WM_SETFOCUS, sent|wparam, 0 },
12176 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
12177 { WM_CTLCOLOREDIT, sent },
12178 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
12179 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
12180 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
12181 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
12182 { WM_COMMAND, sent|wparam, MAKEWPARAM(1, EN_SETFOCUS) },
12183 { 0 }
12184 };
12185 static const struct message WmDefDlgSetFocus_2[] = {
12186 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
12187 { WM_GETTEXTLENGTH, sent|wparam|lparam|optional, 0, 0 }, /* XP */
12188 { WM_GETTEXT, sent|wparam|optional, 6 }, /* XP */
12189 { WM_GETTEXT, sent|wparam|optional, 12 }, /* XP */
12190 { EM_SETSEL, sent|wparam, 0 }, /* XP sets lparam to text length, Win9x to -2 */
12191 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
12192 { WM_CTLCOLOREDIT, sent|optional }, /* XP */
12193 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
12194 { 0 }
12195 };
12196 /* Creation of a dialog */
12197 static const struct message WmCreateDialogParamSeq_1[] = {
12198 { HCBT_CREATEWND, hook },
12199 { WM_NCCREATE, sent },
12200 { WM_NCCALCSIZE, sent|wparam, 0 },
12201 { WM_CREATE, sent },
12202 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
12203 { WM_SIZE, sent|wparam, SIZE_RESTORED },
12204 { WM_MOVE, sent },
12205 { WM_SETFONT, sent },
12206 { WM_INITDIALOG, sent },
12207 { WM_CHANGEUISTATE, sent|optional },
12208 { 0 }
12209 };
12210 /* Creation of a dialog */
12211 static const struct message WmCreateDialogParamSeq_2[] = {
12212 { HCBT_CREATEWND, hook },
12213 { WM_NCCREATE, sent },
12214 { WM_NCCALCSIZE, sent|wparam, 0 },
12215 { WM_CREATE, sent },
12216 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
12217 { WM_SIZE, sent|wparam, SIZE_RESTORED },
12218 { WM_MOVE, sent },
12219 { WM_CHANGEUISTATE, sent|optional },
12220 { 0 }
12221 };
12222
12223 static const struct message WmCreateDialogParamSeq_3[] = {
12224 { HCBT_CREATEWND, hook },
12225 { WM_SETFONT, sent|parent },
12226 { WM_INITDIALOG, sent|parent },
12227 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
12228 { EM_SETSEL, sent|wparam|lparam, 0, INT_MAX },
12229 { EM_SETSEL, sent|wparam|lparam|optional, 0, INT_MAX },
12230 { EM_SETSEL, sent|wparam|lparam|optional, 0, INT_MAX },
12231 { EM_SETSEL, sent|wparam|lparam|optional, 0, INT_MAX },
12232 { HCBT_ACTIVATE, hook },
12233 { WM_QUERYNEWPALETTE, sent|parent|optional }, /* TODO: this message should not be sent */
12234 { WM_WINDOWPOSCHANGING, sent|parent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
12235 { WM_WINDOWPOSCHANGING, sent|parent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
12236 { WM_ACTIVATEAPP, sent|parent|wparam, 1 },
12237 { WM_NCACTIVATE, sent|parent },
12238 { WM_ACTIVATE, sent|parent|wparam, 1 },
12239 { WM_SETFOCUS, sent },
12240 { WM_COMMAND, sent|parent|wparam, MAKELONG(200, EN_SETFOCUS) },
12241 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
12242 { WM_USER, sent|parent },
12243 { WM_CHANGEUISTATE, sent|parent|optional },
12244 { 0 }
12245 };
12246
12247 static const struct message WmCreateDialogParamSeq_4[] = {
12248 { HCBT_CREATEWND, hook },
12249 { WM_NCCREATE, sent|parent },
12250 { WM_NCCALCSIZE, sent|parent|wparam, 0 },
12251 { WM_CREATE, sent|parent },
12252 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
12253 { WM_SIZE, sent|parent|wparam, SIZE_RESTORED },
12254 { WM_MOVE, sent|parent },
12255 { WM_SETFONT, sent|parent },
12256 { WM_INITDIALOG, sent|parent },
12257 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
12258 { EM_SETSEL, sent|wparam|lparam, 0, INT_MAX },
12259 { EM_SETSEL, sent|wparam|lparam|optional, 0, INT_MAX },
12260 { EM_SETSEL, sent|wparam|lparam|optional, 0, INT_MAX },
12261 { EM_SETSEL, sent|wparam|lparam|optional, 0, INT_MAX },
12262 { HCBT_ACTIVATE, hook },
12263 { WM_QUERYNEWPALETTE, sent|parent|optional }, /* TODO: this message should not be sent */
12264 { WM_WINDOWPOSCHANGING, sent|parent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
12265 { WM_WINDOWPOSCHANGING, sent|parent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
12266 { WM_ACTIVATEAPP, sent|parent|wparam, 1 },
12267 { WM_NCACTIVATE, sent|parent },
12268 { WM_ACTIVATE, sent|parent|wparam, 1 },
12269 { HCBT_SETFOCUS, hook },
12270 { WM_SETFOCUS, sent|parent },
12271 { WM_KILLFOCUS, sent|parent },
12272 { WM_SETFOCUS, sent },
12273 { WM_COMMAND, sent|parent|wparam, MAKELONG(200, EN_SETFOCUS) },
12274 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
12275 { WM_USER, sent|parent },
12276 { WM_CHANGEUISTATE, sent|parent|optional },
12277 { WM_UPDATEUISTATE, sent|parent|optional },
12278 { WM_UPDATEUISTATE, sent|optional },
12279 { 0 }
12280 };
12281
12282 static void test_dialog_messages(void)
12283 {
12284 WNDCLASSA cls;
12285 HWND hdlg, hedit1, hedit2, hfocus, parent, child, child2;
12286 LRESULT ret;
12287
12288 #define set_selection(hctl, start, end) \
12289 ret = SendMessageA(hctl, EM_SETSEL, start, end); \
12290 ok(ret == 1, "EM_SETSEL returned %ld\n", ret);
12291
12292 #define check_selection(hctl, start, end) \
12293 ret = SendMessageA(hctl, EM_GETSEL, 0, 0); \
12294 ok(ret == MAKELRESULT(start, end), "wrong selection (%d - %d)\n", LOWORD(ret), HIWORD(ret));
12295
12296 subclass_edit();
12297
12298 hdlg = CreateWindowExA(WS_EX_DLGMODALFRAME, "TestDialogClass", NULL,
12299 WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
12300 0, 0, 100, 100, 0, 0, 0, NULL);
12301 ok(hdlg != 0, "Failed to create custom dialog window\n");
12302
12303 hedit1 = CreateWindowExA(0, "my_edit_class", NULL,
12304 WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP,
12305 0, 0, 80, 20, hdlg, (HMENU)1, 0, NULL);
12306 ok(hedit1 != 0, "Failed to create edit control\n");
12307 hedit2 = CreateWindowExA(0, "my_edit_class", NULL,
12308 WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP,
12309 0, 40, 80, 20, hdlg, (HMENU)2, 0, NULL);
12310 ok(hedit2 != 0, "Failed to create edit control\n");
12311
12312 SendMessageA(hedit1, WM_SETTEXT, 0, (LPARAM)"hello");
12313 SendMessageA(hedit2, WM_SETTEXT, 0, (LPARAM)"bye");
12314
12315 hfocus = GetFocus();
12316 ok(hfocus == hdlg, "wrong focus %p\n", hfocus);
12317
12318 SetFocus(hedit2);
12319 hfocus = GetFocus();
12320 ok(hfocus == hedit2, "wrong focus %p\n", hfocus);
12321
12322 check_selection(hedit1, 0, 0);
12323 check_selection(hedit2, 0, 0);
12324
12325 set_selection(hedit2, 0, -1);
12326 check_selection(hedit2, 0, 3);
12327
12328 SetFocus(0);
12329 hfocus = GetFocus();
12330 ok(hfocus == 0, "wrong focus %p\n", hfocus);
12331
12332 flush_sequence();
12333 ret = DefDlgProcA(hdlg, WM_SETFOCUS, 0, 0);
12334 ok(ret == 0, "WM_SETFOCUS returned %ld\n", ret);
12335 ok_sequence(WmDefDlgSetFocus_1, "DefDlgProc(WM_SETFOCUS) 1", FALSE);
12336
12337 hfocus = GetFocus();
12338 ok(hfocus == hedit1, "wrong focus %p\n", hfocus);
12339
12340 check_selection(hedit1, 0, 5);
12341 check_selection(hedit2, 0, 3);
12342
12343 flush_sequence();
12344 ret = DefDlgProcA(hdlg, WM_SETFOCUS, 0, 0);
12345 ok(ret == 0, "WM_SETFOCUS returned %ld\n", ret);
12346 ok_sequence(WmDefDlgSetFocus_2, "DefDlgProc(WM_SETFOCUS) 2", FALSE);
12347
12348 hfocus = GetFocus();
12349 ok(hfocus == hedit1, "wrong focus %p\n", hfocus);
12350
12351 check_selection(hedit1, 0, 5);
12352 check_selection(hedit2, 0, 3);
12353
12354 EndDialog(hdlg, 0);
12355 DestroyWindow(hedit1);
12356 DestroyWindow(hedit2);
12357 DestroyWindow(hdlg);
12358 flush_sequence();
12359
12360 #undef set_selection
12361 #undef check_selection
12362
12363 ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
12364 cls.lpszClassName = "MyDialogClass";
12365 cls.hInstance = GetModuleHandleA(NULL);
12366 /* need a cast since a dlgproc is used as a wndproc */
12367 cls.lpfnWndProc = test_dlg_proc;
12368 if (!RegisterClassA(&cls)) assert(0);
12369
12370 hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", 0, test_dlg_proc, 0);
12371 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
12372 ok_sequence(WmCreateDialogParamSeq_1, "CreateDialogParam_1", FALSE);
12373 EndDialog(hdlg, 0);
12374 DestroyWindow(hdlg);
12375 flush_sequence();
12376
12377 hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", 0, NULL, 0);
12378 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
12379 ok_sequence(WmCreateDialogParamSeq_2, "CreateDialogParam_2", FALSE);
12380 EndDialog(hdlg, 0);
12381 DestroyWindow(hdlg);
12382 flush_sequence();
12383
12384 hdlg = CreateDialogParamA(0, "FOCUS_TEST_DIALOG_3", 0, test_dlg_proc2, 0);
12385 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
12386 ok_sequence(WmCreateDialogParamSeq_3, "CreateDialogParam_3", TRUE);
12387 EndDialog(hdlg, 0);
12388 DestroyWindow(hdlg);
12389 flush_sequence();
12390
12391 UnregisterClassA( cls.lpszClassName, cls.hInstance );
12392 cls.lpfnWndProc = test_dlg_proc4;
12393 ok( RegisterClassA(&cls), "failed to register class again\n" );
12394 hdlg = CreateDialogParamA(0, "FOCUS_TEST_DIALOG_4", 0, test_dlg_proc3, 0);
12395 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
12396 ok_sequence(WmCreateDialogParamSeq_4, "CreateDialogParam_4", TRUE);
12397 EndDialog(hdlg, 0);
12398 DestroyWindow(hdlg);
12399 flush_sequence();
12400
12401 UnregisterClassA(cls.lpszClassName, cls.hInstance);
12402
12403 parent = CreateWindowExA(0, "TestParentClass", "Test parent",
12404 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
12405 100, 100, 200, 200, 0, 0, 0, NULL);
12406 ok (parent != 0, "Failed to create parent window\n");
12407
12408 /* This child has no parent set. We will later call SetParent on it,
12409 * so that it will have a parent set, but no WS_CHILD style. */
12410 child = CreateWindowExA(0, "TestWindowClass", "Test child",
12411 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
12412 100, 100, 200, 200, 0, 0, 0, NULL);
12413 ok (child != 0, "Failed to create child window\n");
12414
12415 /* This is a regular child window. When used as an owner, the other
12416 * child window will be used. */
12417 child2 = CreateWindowExA(0, "SimpleWindowClass", "Test child2",
12418 WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_CHILD,
12419 100, 100, 200, 200, child, 0, 0, NULL);
12420 ok (child2 != 0, "Failed to create child window\n");
12421
12422 SetParent(child, parent);
12423 SetFocus(child);
12424
12425 flush_sequence();
12426 DialogBoxA( 0, "TEST_DIALOG", child2, TestModalDlgProc2 );
12427 ok_sequence(WmModalDialogSeq_2, "ModalDialog2", TRUE);
12428
12429 DestroyWindow(child2);
12430 DestroyWindow(child);
12431 DestroyWindow(parent);
12432 flush_sequence();
12433 }
12434
12435 static void test_enddialog_seq(HWND dialog, HWND owner)
12436 {
12437 const struct message seq[] = {
12438 { WM_ENABLE, sent },
12439 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
12440 { HCBT_ACTIVATE, hook|wparam, (WPARAM)owner },
12441 { WM_NCACTIVATE, sent|wparam|lparam, WA_INACTIVE, (LPARAM)owner },
12442 { WM_ACTIVATE, sent|wparam|lparam, WA_INACTIVE, (LPARAM)owner },
12443 /* FIXME: Following two are optional because Wine sends WM_QUERYNEWPALETTE instead of WM_WINDOWPOSCHANGING */
12444 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
12445 { WM_QUERYNEWPALETTE, sent|optional },
12446 { WM_NCACTIVATE, sent|wparam|lparam, WA_ACTIVE, (LPARAM)dialog },
12447 { WM_GETTEXT, sent|optional|defwinproc },
12448 { WM_ACTIVATE, sent|wparam|lparam, WA_ACTIVE, (LPARAM)dialog },
12449 { HCBT_SETFOCUS, hook|wparam, (WPARAM)owner },
12450 { WM_KILLFOCUS, sent|wparam, (WPARAM)owner },
12451 { WM_SETFOCUS, sent|defwinproc|wparam, (WPARAM)dialog },
12452 { 0 }
12453 };
12454
12455 flush_sequence();
12456 EndDialog(dialog, 0);
12457 ok_sequence(seq, "EndDialog", FALSE);
12458 }
12459
12460 static void test_enddialog_seq2(HWND dialog, HWND owner)
12461 {
12462 const struct message seq[] = {
12463 { WM_ENABLE, parent|sent },
12464 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
12465 { HCBT_ACTIVATE, hook|wparam, (WPARAM)owner },
12466 { WM_NCACTIVATE, sent|wparam|lparam, WA_INACTIVE, (LPARAM)owner },
12467 { WM_ACTIVATE, sent|wparam|lparam, WA_INACTIVE, (LPARAM)owner },
12468 { WM_WINDOWPOSCHANGING, sent|optional|wparam, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
12469 { WM_WINDOWPOSCHANGING, sent|optional|wparam, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
12470 { HCBT_SETFOCUS, hook|wparam, (WPARAM)owner },
12471 { WM_KILLFOCUS, sent|wparam, (WPARAM)owner },
12472 { WM_SETFOCUS, sent|parent|defwinproc|wparam, (WPARAM)dialog },
12473 { 0 }
12474 };
12475
12476 flush_sequence();
12477 EndDialog(dialog, 0);
12478 ok_sequence(seq, "EndDialog2", FALSE);
12479 }
12480
12481 static void test_EndDialog(void)
12482 {
12483 HWND hparent, hother, hactive, hdlg, hchild;
12484 WNDCLASSA cls;
12485
12486 hparent = CreateWindowExA(0, "TestParentClass", "Test parent",
12487 WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_DISABLED,
12488 100, 100, 200, 200, 0, 0, 0, NULL);
12489 ok (hparent != 0, "Failed to create parent window\n");
12490
12491 hother = CreateWindowExA(0, "TestParentClass", "Test parent 2",
12492 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
12493 200, 100, 200, 200, 0, 0, 0, NULL);
12494 ok (hother != 0, "Failed to create parent window\n");
12495
12496 ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
12497 cls.lpszClassName = "MyDialogClass";
12498 cls.hInstance = GetModuleHandleA(NULL);
12499 cls.lpfnWndProc = test_dlg_proc;
12500 if (!RegisterClassA(&cls)) assert(0);
12501
12502 flush_sequence();
12503 SetForegroundWindow(hother);
12504 hactive = GetForegroundWindow();
12505 ok(hother == hactive, "Wrong window has focus (%p != %p)\n", hother, hactive);
12506
12507 /* create a dialog where the parent is disabled, this parent should be
12508 * enabled and receive focus when dialog exits */
12509 hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", hparent, test_dlg_proc, 0);
12510 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
12511 SetForegroundWindow(hdlg);
12512 hactive = GetForegroundWindow();
12513 ok(hdlg == hactive, "Wrong window has focus (%p != %p)\n", hdlg, hactive);
12514 EndDialog(hdlg, 0);
12515 ok(IsWindowEnabled(hparent), "parent is not enabled\n");
12516 hactive = GetForegroundWindow();
12517 ok(hparent == hactive, "Wrong window has focus (parent != active) (active: %p, parent: %p, dlg: %p, other: %p)\n", hactive, hparent, hdlg, hother);
12518 DestroyWindow(hdlg);
12519 flush_sequence();
12520
12521 /* create a dialog where the parent is disabled and set active window to other window before calling EndDialog */
12522 EnableWindow(hparent, FALSE);
12523 hdlg = CreateWindowExA(0, "TestDialogClass", NULL,
12524 WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
12525 0, 0, 100, 100, hparent, 0, 0, NULL);
12526 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
12527 flush_sequence();
12528 SetForegroundWindow(hother);
12529 flush_sequence();
12530 hactive = GetForegroundWindow();
12531 ok(hactive == hother, "Wrong foreground (%p != %p)\n", hactive, hother);
12532 hactive = GetActiveWindow();
12533 ok(hactive == hother, "Wrong active window (%p != %p)\n", hactive, hother);
12534 EndDialog(hdlg, 0);
12535 ok(IsWindowEnabled(hparent), "parent is not enabled\n");
12536 hactive = GetForegroundWindow();
12537 ok(hother == hactive, "Wrong window has focus (other != active) (active: %p, parent: %p, dlg: %p, other: %p)\n", hactive, hparent, hdlg, hother);
12538 DestroyWindow(hdlg);
12539 flush_sequence();
12540
12541 DestroyWindow( hparent );
12542
12543 hparent = CreateWindowExA(0, "TestParentClass", "Test parent",
12544 WS_POPUP | WS_VISIBLE | WS_DISABLED,
12545 100, 100, 200, 200, 0, 0, 0, NULL);
12546 ok (hparent != 0, "Failed to create parent window\n");
12547
12548 hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
12549 WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_DISABLED,
12550 0, 0, 0, 0, 0, 0, 0, NULL);
12551 ok (hchild != 0, "Failed to create child window\n");
12552
12553 SetParent(hchild, hparent);
12554
12555 flush_sequence();
12556 SetForegroundWindow(hother);
12557 hactive = GetForegroundWindow();
12558 ok(hother == hactive, "Wrong foreground window (%p != %p)\n", hother, hactive);
12559
12560 hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", hchild, test_dlg_proc, 0);
12561 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
12562
12563 SetForegroundWindow(hdlg);
12564 test_enddialog_seq(hdlg, hchild);
12565
12566 hactive = GetForegroundWindow();
12567 ok(hactive == hchild, "Wrong foreground window (active: %p, parent: %p, dlg: %p, other: %p child: %p)\n", hactive, hparent, hdlg, hother, hchild);
12568
12569 DestroyWindow(hdlg);
12570
12571 /* Now set WS_CHILD style flag so that it's a real child and its parent will be dialog's owner. */
12572 SetWindowLongW(hchild, GWL_STYLE, GetWindowLongW(hchild, GWL_STYLE) | WS_CHILD);
12573
12574 SetForegroundWindow(hother);
12575 hactive = GetForegroundWindow();
12576 ok(hother == hactive, "Wrong foreground window (%p != %p)\n", hother, hactive);
12577
12578 hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", hchild, test_dlg_proc, 0);
12579 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
12580
12581 SetForegroundWindow(hdlg);
12582 test_enddialog_seq2(hdlg, hparent);
12583
12584 hactive = GetForegroundWindow();
12585 ok(hactive == hparent, "Wrong foreground window (active: %p, parent: %p, dlg: %p, other: %p child: %p)\n", hactive, hparent, hdlg, hother, hchild);
12586 DestroyWindow(hdlg);
12587 DestroyWindow(hchild);
12588 DestroyWindow(hparent);
12589 DestroyWindow(hother);
12590 flush_sequence();
12591
12592 UnregisterClassA(cls.lpszClassName, cls.hInstance);
12593 }
12594
12595 static void test_nullCallback(void)
12596 {
12597 HWND hwnd;
12598
12599 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
12600 100, 100, 200, 200, 0, 0, 0, NULL);
12601 ok (hwnd != 0, "Failed to create overlapped window\n");
12602
12603 SendMessageCallbackA(hwnd,WM_NULL,0,0,NULL,0);
12604 flush_events();
12605 DestroyWindow(hwnd);
12606 }
12607
12608 /* SetActiveWindow( 0 ) hwnd visible */
12609 static const struct message SetActiveWindowSeq0[] =
12610 {
12611 { HCBT_ACTIVATE, hook|optional },
12612 { WM_NCACTIVATE, sent|wparam, 0 },
12613 { WM_GETTEXT, sent|defwinproc|optional },
12614 { WM_ACTIVATE, sent|wparam, 0 },
12615 { WM_ACTIVATEAPP, sent|wparam|optional, 0 },
12616 { WM_ACTIVATEAPP, sent|wparam|optional, 0 },
12617 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
12618 { WM_KILLFOCUS, sent|optional },
12619 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
12620 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
12621 { WM_NCACTIVATE, sent|wparam|optional, 1 },
12622 { WM_GETTEXT, sent|defwinproc|optional },
12623 { WM_ACTIVATE, sent|wparam|optional, 1 },
12624 { HCBT_SETFOCUS, hook|optional },
12625 { WM_KILLFOCUS, sent|defwinproc|optional },
12626 { WM_IME_SETCONTEXT, sent|defwinproc|optional },
12627 { WM_IME_SETCONTEXT, sent|defwinproc|optional },
12628 { WM_IME_SETCONTEXT, sent|optional },
12629 { WM_IME_SETCONTEXT, sent|optional },
12630 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
12631 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
12632 { WM_SETFOCUS, sent|defwinproc|optional },
12633 { WM_GETTEXT, sent|optional },
12634 { 0 }
12635 };
12636 /* SetActiveWindow( hwnd ) hwnd visible */
12637 static const struct message SetActiveWindowSeq1[] =
12638 {
12639 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
12640 { 0 }
12641 };
12642 /* SetActiveWindow( popup ) hwnd visible, popup visible */
12643 static const struct message SetActiveWindowSeq2[] =
12644 {
12645 { HCBT_ACTIVATE, hook },
12646 { WM_NCACTIVATE, sent|wparam, 0 },
12647 { WM_GETTEXT, sent|defwinproc|optional },
12648 { WM_ACTIVATE, sent|wparam, 0 },
12649 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
12650 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
12651 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
12652 { WM_NCPAINT, sent|optional },
12653 { WM_GETTEXT, sent|defwinproc|optional },
12654 { WM_ERASEBKGND, sent|optional },
12655 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
12656 { WM_NCACTIVATE, sent|wparam, 1 },
12657 { WM_GETTEXT, sent|defwinproc|optional },
12658 { WM_ACTIVATE, sent|wparam, 1 },
12659 { HCBT_SETFOCUS, hook },
12660 { WM_KILLFOCUS, sent|defwinproc },
12661 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
12662 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
12663 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
12664 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
12665 { WM_SETFOCUS, sent|defwinproc },
12666 { WM_GETTEXT, sent|optional },
12667 { 0 }
12668 };
12669
12670 /* SetActiveWindow( hwnd ) hwnd not visible */
12671 static const struct message SetActiveWindowSeq3[] =
12672 {
12673 { HCBT_ACTIVATE, hook },
12674 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
12675 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
12676 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
12677 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
12678 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
12679 { WM_ACTIVATEAPP, sent|wparam, 1 },
12680 { WM_ACTIVATEAPP, sent|wparam, 1 },
12681 { WM_NCACTIVATE, sent|wparam, 1 },
12682 { WM_ACTIVATE, sent|wparam, 1 },
12683 { HCBT_SETFOCUS, hook },
12684 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
12685 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
12686 { WM_SETFOCUS, sent|defwinproc },
12687 { 0 }
12688 };
12689 /* SetActiveWindow( popup ) hwnd not visible, popup not visible */
12690 static const struct message SetActiveWindowSeq4[] =
12691 {
12692 { HCBT_ACTIVATE, hook },
12693 { WM_NCACTIVATE, sent|wparam, 0 },
12694 { WM_GETTEXT, sent|defwinproc|optional },
12695 { WM_ACTIVATE, sent|wparam, 0 },
12696 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
12697 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
12698 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
12699 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
12700 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
12701 { WM_NCACTIVATE, sent|wparam, 1 },
12702 { WM_GETTEXT, sent|defwinproc|optional },
12703 { WM_ACTIVATE, sent|wparam, 1 },
12704 { HCBT_SETFOCUS, hook },
12705 { WM_KILLFOCUS, sent|defwinproc },
12706 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
12707 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
12708 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
12709 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
12710 { WM_SETFOCUS, sent|defwinproc },
12711 { 0 }
12712 };
12713
12714
12715 static void test_SetActiveWindow(void)
12716 {
12717 HWND hwnd, popup, ret;
12718
12719 hwnd = CreateWindowExA(0, "TestWindowClass", "Test SetActiveWindow",
12720 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
12721 100, 100, 200, 200, 0, 0, 0, NULL);
12722
12723 popup = CreateWindowExA(0, "TestWindowClass", "Test SetActiveWindow",
12724 WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_POPUP,
12725 100, 100, 200, 200, hwnd, 0, 0, NULL);
12726
12727 ok(hwnd != 0, "Failed to create overlapped window\n");
12728 ok(popup != 0, "Failed to create popup window\n");
12729 SetForegroundWindow( popup );
12730 flush_sequence();
12731
12732 trace("SetActiveWindow(0)\n");
12733 ret = SetActiveWindow(0);
12734 ok( ret == popup, "Failed to SetActiveWindow(0)\n");
12735 ok_sequence(SetActiveWindowSeq0, "SetActiveWindow(0)", FALSE);
12736 flush_sequence();
12737
12738 trace("SetActiveWindow(hwnd), hwnd visible\n");
12739 ret = SetActiveWindow(hwnd);
12740 if (ret == hwnd) ok_sequence(SetActiveWindowSeq1, "SetActiveWindow(hwnd), hwnd visible", TRUE);
12741 flush_sequence();
12742
12743 trace("SetActiveWindow(popup), hwnd visible, popup visible\n");
12744 ret = SetActiveWindow(popup);
12745 ok( ret == hwnd, "Failed to SetActiveWindow(popup), popup visible\n");
12746 ok_sequence(SetActiveWindowSeq2, "SetActiveWindow(popup), hwnd visible, popup visible", FALSE);
12747 flush_sequence();
12748
12749 ShowWindow(hwnd, SW_HIDE);
12750 ShowWindow(popup, SW_HIDE);
12751 flush_sequence();
12752
12753 trace("SetActiveWindow(hwnd), hwnd not visible\n");
12754 ret = SetActiveWindow(hwnd);
12755 ok( ret == NULL, "SetActiveWindow(hwnd), hwnd not visible, previous is %p\n", ret );
12756 ok_sequence(SetActiveWindowSeq3, "SetActiveWindow(hwnd), hwnd not visible", TRUE);
12757 flush_sequence();
12758
12759 trace("SetActiveWindow(popup), hwnd not visible, popup not visible\n");
12760 ret = SetActiveWindow(popup);
12761 ok( ret == hwnd, "Failed to SetActiveWindow(popup)\n");
12762 ok_sequence(SetActiveWindowSeq4, "SetActiveWindow(popup), hwnd not visible, popup not visible", TRUE);
12763 flush_sequence();
12764
12765 trace("done\n");
12766
12767 DestroyWindow(hwnd);
12768 }
12769
12770 static const struct message SetForegroundWindowSeq[] =
12771 {
12772 { WM_NCACTIVATE, sent|wparam, 0 },
12773 { WM_GETTEXT, sent|defwinproc|optional },
12774 { WM_ACTIVATE, sent|wparam, 0 },
12775 { WM_ACTIVATEAPP, sent|wparam, 0 },
12776 { WM_KILLFOCUS, sent },
12777 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
12778 { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
12779 { 0 }
12780 };
12781
12782 static void test_SetForegroundWindow(void)
12783 {
12784 HWND hwnd;
12785
12786 hwnd = CreateWindowExA(0, "TestWindowClass", "Test SetForegroundWindow",
12787 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
12788 100, 100, 200, 200, 0, 0, 0, NULL);
12789 ok (hwnd != 0, "Failed to create overlapped window\n");
12790 SetForegroundWindow( hwnd );
12791 flush_sequence();
12792
12793 trace("SetForegroundWindow( 0 )\n");
12794 SetForegroundWindow( 0 );
12795 ok_sequence(WmEmptySeq, "SetForegroundWindow( 0 ) away from foreground top level window", FALSE);
12796 trace("SetForegroundWindow( GetDesktopWindow() )\n");
12797 SetForegroundWindow( GetDesktopWindow() );
12798 ok_sequence(SetForegroundWindowSeq, "SetForegroundWindow( desktop ) away from "
12799 "foreground top level window", FALSE);
12800 trace("done\n");
12801
12802 DestroyWindow(hwnd);
12803 }
12804
12805 static DWORD get_input_codepage( void )
12806 {
12807 DWORD cp;
12808 int ret;
12809 HKL hkl = GetKeyboardLayout( 0 );
12810
12811 ret = GetLocaleInfoW( LOWORD(hkl), LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
12812 (WCHAR *)&cp, sizeof(cp) / sizeof(WCHAR) );
12813 if (!ret) cp = CP_ACP;
12814 return cp;
12815 }
12816
12817 static void test_dbcs_wm_char(void)
12818 {
12819 BYTE dbch[2];
12820 WCHAR wch, bad_wch;
12821 HWND hwnd, hwnd2;
12822 MSG msg;
12823 DWORD time;
12824 POINT pt;
12825 DWORD_PTR res;
12826 CPINFOEXA cpinfo;
12827 UINT i, j, k;
12828 struct message wmCharSeq[2];
12829 BOOL ret;
12830 DWORD cp = get_input_codepage();
12831
12832 if (!pGetCPInfoExA)
12833 {
12834 win_skip("GetCPInfoExA is not available\n");
12835 return;
12836 }
12837
12838 pGetCPInfoExA( cp, 0, &cpinfo );
12839 if (cpinfo.MaxCharSize != 2)
12840 {
12841 skip( "Skipping DBCS WM_CHAR test in SBCS codepage '%s'\n", cpinfo.CodePageName );
12842 return;
12843 }
12844
12845 dbch[0] = dbch[1] = 0;
12846 wch = 0;
12847 bad_wch = cpinfo.UnicodeDefaultChar;
12848 for (i = 0; !wch && i < MAX_LEADBYTES && cpinfo.LeadByte[i]; i += 2)
12849 for (j = cpinfo.LeadByte[i]; !wch && j <= cpinfo.LeadByte[i+1]; j++)
12850 for (k = 128; k <= 255; k++)
12851 {
12852 char str[2];
12853 WCHAR wstr[2];
12854 str[0] = j;
12855 str[1] = k;
12856 if (MultiByteToWideChar( cp, 0, str, 2, wstr, 2 ) == 1 &&
12857 WideCharToMultiByte( cp, 0, wstr, 1, str, 2, NULL, NULL ) == 2 &&
12858 (BYTE)str[0] == j && (BYTE)str[1] == k &&
12859 HIBYTE(wstr[0]) && HIBYTE(wstr[0]) != 0xff)
12860 {
12861 dbch[0] = j;
12862 dbch[1] = k;
12863 wch = wstr[0];
12864 break;
12865 }
12866 }
12867
12868 if (!wch)
12869 {
12870 skip( "Skipping DBCS WM_CHAR test, no appropriate char found\n" );
12871 return;
12872 }
12873 trace( "using dbcs char %02x,%02x wchar %04x bad wchar %04x codepage '%s'\n",
12874 dbch[0], dbch[1], wch, bad_wch, cpinfo.CodePageName );
12875
12876 hwnd = CreateWindowExW(0, testWindowClassW, NULL,
12877 WS_OVERLAPPEDWINDOW, 100, 100, 200, 200, 0, 0, 0, NULL);
12878 hwnd2 = CreateWindowExW(0, testWindowClassW, NULL,
12879 WS_OVERLAPPEDWINDOW, 100, 100, 200, 200, 0, 0, 0, NULL);
12880 ok (hwnd != 0, "Failed to create overlapped window\n");
12881 ok (hwnd2 != 0, "Failed to create overlapped window\n");
12882 flush_sequence();
12883
12884 memset( wmCharSeq, 0, sizeof(wmCharSeq) );
12885 wmCharSeq[0].message = WM_CHAR;
12886 wmCharSeq[0].flags = sent|wparam;
12887 wmCharSeq[0].wParam = wch;
12888
12889 /* posted message */
12890 PostMessageA( hwnd, WM_CHAR, dbch[0], 0 );
12891 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12892 ok( !ret, "got message %x\n", msg.message );
12893 PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
12894 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12895 ok( ret, "no message\n" );
12896 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
12897 ok( msg.wParam == wch, "bad wparam %lx/%x\n", msg.wParam, wch );
12898 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12899 ok( !ret, "got message %x\n", msg.message );
12900
12901 /* posted thread message */
12902 PostThreadMessageA( GetCurrentThreadId(), WM_CHAR, dbch[0], 0 );
12903 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12904 ok( !ret, "got message %x\n", msg.message );
12905 PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
12906 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12907 ok( ret, "no message\n" );
12908 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
12909 ok( msg.wParam == wch, "bad wparam %lx/%x\n", msg.wParam, wch );
12910 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12911 ok( !ret, "got message %x\n", msg.message );
12912
12913 /* sent message */
12914 flush_sequence();
12915 SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
12916 ok_sequence( WmEmptySeq, "no messages", FALSE );
12917 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
12918 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
12919 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12920 ok( !ret, "got message %x\n", msg.message );
12921
12922 /* sent message with timeout */
12923 flush_sequence();
12924 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[0], 0, SMTO_NORMAL, 0, &res );
12925 ok_sequence( WmEmptySeq, "no messages", FALSE );
12926 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[1], 0, SMTO_NORMAL, 0, &res );
12927 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
12928 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12929 ok( !ret, "got message %x\n", msg.message );
12930
12931 /* sent message with timeout and callback */
12932 flush_sequence();
12933 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[0], 0, SMTO_NORMAL, 0, &res );
12934 ok_sequence( WmEmptySeq, "no messages", FALSE );
12935 SendMessageCallbackA( hwnd, WM_CHAR, dbch[1], 0, NULL, 0 );
12936 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
12937 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12938 ok( !ret, "got message %x\n", msg.message );
12939
12940 /* sent message with callback */
12941 flush_sequence();
12942 SendNotifyMessageA( hwnd, WM_CHAR, dbch[0], 0 );
12943 ok_sequence( WmEmptySeq, "no messages", FALSE );
12944 SendMessageCallbackA( hwnd, WM_CHAR, dbch[1], 0, NULL, 0 );
12945 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
12946 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12947 ok( !ret, "got message %x\n", msg.message );
12948
12949 /* direct window proc call */
12950 flush_sequence();
12951 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
12952 ok_sequence( WmEmptySeq, "no messages", FALSE );
12953 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
12954 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
12955
12956 /* dispatch message */
12957 msg.hwnd = hwnd;
12958 msg.message = WM_CHAR;
12959 msg.wParam = dbch[0];
12960 msg.lParam = 0;
12961 DispatchMessageA( &msg );
12962 ok_sequence( WmEmptySeq, "no messages", FALSE );
12963 msg.wParam = dbch[1];
12964 DispatchMessageA( &msg );
12965 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
12966
12967 /* window handle is irrelevant */
12968 flush_sequence();
12969 SendMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
12970 ok_sequence( WmEmptySeq, "no messages", FALSE );
12971 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
12972 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
12973 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12974 ok( !ret, "got message %x\n", msg.message );
12975
12976 /* interleaved post and send */
12977 flush_sequence();
12978 PostMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
12979 SendMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
12980 ok_sequence( WmEmptySeq, "no messages", FALSE );
12981 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12982 ok( !ret, "got message %x\n", msg.message );
12983 PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
12984 ok_sequence( WmEmptySeq, "no messages", FALSE );
12985 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12986 ok( ret, "no message\n" );
12987 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
12988 ok( msg.wParam == wch, "bad wparam %lx/%x\n", msg.wParam, wch );
12989 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12990 ok( !ret, "got message %x\n", msg.message );
12991 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
12992 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
12993 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
12994 ok( !ret, "got message %x\n", msg.message );
12995
12996 /* interleaved sent message and winproc */
12997 flush_sequence();
12998 SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
12999 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
13000 ok_sequence( WmEmptySeq, "no messages", FALSE );
13001 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
13002 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13003 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
13004 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13005
13006 /* interleaved winproc and dispatch */
13007 msg.hwnd = hwnd;
13008 msg.message = WM_CHAR;
13009 msg.wParam = dbch[0];
13010 msg.lParam = 0;
13011 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
13012 DispatchMessageA( &msg );
13013 ok_sequence( WmEmptySeq, "no messages", FALSE );
13014 msg.wParam = dbch[1];
13015 DispatchMessageA( &msg );
13016 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13017 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
13018 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13019
13020 /* interleaved sends */
13021 flush_sequence();
13022 SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
13023 SendMessageCallbackA( hwnd, WM_CHAR, dbch[0], 0, NULL, 0 );
13024 ok_sequence( WmEmptySeq, "no messages", FALSE );
13025 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[1], 0, SMTO_NORMAL, 0, &res );
13026 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13027 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
13028 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13029
13030 /* dbcs WM_CHAR */
13031 flush_sequence();
13032 SendMessageA( hwnd2, WM_CHAR, (dbch[1] << 8) | dbch[0], 0 );
13033 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
13034 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13035 ok( !ret, "got message %x\n", msg.message );
13036
13037 /* other char messages are not magic */
13038 PostMessageA( hwnd, WM_SYSCHAR, dbch[0], 0 );
13039 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13040 ok( ret, "no message\n" );
13041 ok( msg.message == WM_SYSCHAR, "unexpected message %x\n", msg.message );
13042 ok( msg.wParam == bad_wch, "bad wparam %lx/%x\n", msg.wParam, bad_wch );
13043 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13044 ok( !ret, "got message %x\n", msg.message );
13045 PostMessageA( hwnd, WM_DEADCHAR, dbch[0], 0 );
13046 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13047 ok( ret, "no message\n" );
13048 ok( msg.message == WM_DEADCHAR, "unexpected message %x\n", msg.message );
13049 ok( msg.wParam == bad_wch, "bad wparam %lx/%x\n", msg.wParam, bad_wch );
13050 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
13051 ok( !ret, "got message %x\n", msg.message );
13052
13053 /* test retrieving messages */
13054
13055 PostMessageW( hwnd, WM_CHAR, wch, 0 );
13056 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
13057 ok( ret, "no message\n" );
13058 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13059 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13060 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13061 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
13062 ok( ret, "no message\n" );
13063 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13064 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13065 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13066 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
13067 ok( !ret, "got message %x\n", msg.message );
13068
13069 /* message filters */
13070 PostMessageW( hwnd, WM_CHAR, wch, 0 );
13071 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
13072 ok( ret, "no message\n" );
13073 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13074 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13075 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13076 /* message id is filtered, hwnd is not */
13077 ret = PeekMessageA( &msg, hwnd, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE );
13078 ok( !ret, "no message\n" );
13079 ret = PeekMessageA( &msg, hwnd2, 0, 0, PM_REMOVE );
13080 ok( ret, "no message\n" );
13081 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13082 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13083 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13084 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
13085 ok( !ret, "got message %x\n", msg.message );
13086
13087 /* mixing GetMessage and PostMessage */
13088 PostMessageW( hwnd, WM_CHAR, wch, 0xbeef );
13089 ok( GetMessageA( &msg, hwnd, 0, 0 ), "no message\n" );
13090 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13091 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13092 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13093 ok( msg.lParam == 0xbeef, "bad lparam %lx\n", msg.lParam );
13094 time = msg.time;
13095 pt = msg.pt;
13096 ok( time - GetTickCount() <= 100, "bad time %x\n", msg.time );
13097 ret = PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
13098 ok( ret, "no message\n" );
13099 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13100 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13101 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13102 ok( msg.lParam == 0xbeef, "bad lparam %lx\n", msg.lParam );
13103 ok( msg.time == time, "bad time %x/%x\n", msg.time, time );
13104 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 );
13105 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
13106 ok( !ret, "got message %x\n", msg.message );
13107
13108 /* without PM_REMOVE */
13109 PostMessageW( hwnd, WM_CHAR, wch, 0 );
13110 ret = PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
13111 ok( ret, "no message\n" );
13112 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13113 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13114 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13115 ret = PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
13116 ok( ret, "no message\n" );
13117 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13118 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13119 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13120 ret = PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
13121 ok( ret, "no message\n" );
13122 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13123 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13124 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13125 ret = PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
13126 ok( ret, "no message\n" );
13127 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13128 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13129 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
13130 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
13131 ok( !ret, "got message %x\n", msg.message );
13132
13133 DestroyWindow(hwnd);
13134 DestroyWindow(hwnd2);
13135 }
13136
13137 static void test_unicode_wm_char(void)
13138 {
13139 HWND hwnd;
13140 MSG msg;
13141 struct message seq[2];
13142 HKL hkl_orig, hkl_greek;
13143 DWORD cp;
13144 LCID thread_locale;
13145
13146 hkl_orig = GetKeyboardLayout( 0 );
13147 GetLocaleInfoW( LOWORD( hkl_orig ), LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER, (WCHAR*)&cp, sizeof(cp) / sizeof(WCHAR) );
13148 if (cp != 1252)
13149 {
13150 skip( "Default codepage %d\n", cp );
13151 return;
13152 }
13153
13154 hkl_greek = LoadKeyboardLayoutA( "00000408", 0 );
13155 if (!hkl_greek || hkl_greek == hkl_orig /* win2k */)
13156 {
13157 skip( "Unable to load Greek keyboard layout\n" );
13158 return;
13159 }
13160
13161 hwnd = CreateWindowExW( 0, testWindowClassW, NULL, WS_OVERLAPPEDWINDOW,
13162 100, 100, 200, 200, 0, 0, 0, NULL );
13163 flush_sequence();
13164
13165 PostMessageW( hwnd, WM_CHAR, 0x3b1, 0 );
13166
13167 while (GetMessageW( &msg, hwnd, 0, 0 ))
13168 {
13169 if (!ignore_message( msg.message )) break;
13170 }
13171
13172 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13173 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13174 ok( msg.wParam == 0x3b1, "bad wparam %lx\n", msg.wParam );
13175 ok( msg.lParam == 0, "bad lparam %lx\n", msg.lParam );
13176
13177 DispatchMessageW( &msg );
13178
13179 memset( seq, 0, sizeof(seq) );
13180 seq[0].message = WM_CHAR;
13181 seq[0].flags = sent|wparam;
13182 seq[0].wParam = 0x3b1;
13183
13184 ok_sequence( seq, "unicode WM_CHAR", FALSE );
13185
13186 flush_sequence();
13187
13188 /* greek alpha -> 'a' in cp1252 */
13189 PostMessageW( hwnd, WM_CHAR, 0x3b1, 0 );
13190
13191 ok( GetMessageA( &msg, hwnd, 0, 0 ), "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 == 0x61, "bad wparam %lx\n", msg.wParam );
13195 ok( msg.lParam == 0, "bad lparam %lx\n", msg.lParam );
13196
13197 DispatchMessageA( &msg );
13198
13199 seq[0].wParam = 0x61;
13200 ok_sequence( seq, "unicode WM_CHAR", FALSE );
13201
13202 thread_locale = GetThreadLocale();
13203 ActivateKeyboardLayout( hkl_greek, 0 );
13204 ok( GetThreadLocale() == thread_locale, "locale changed from %08x to %08x\n",
13205 thread_locale, GetThreadLocale() );
13206
13207 flush_sequence();
13208
13209 /* greek alpha -> 0xe1 in cp1253 */
13210 PostMessageW( hwnd, WM_CHAR, 0x3b1, 0 );
13211
13212 ok( GetMessageA( &msg, hwnd, 0, 0 ), "no message\n" );
13213 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
13214 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
13215 ok( msg.wParam == 0xe1, "bad wparam %lx\n", msg.wParam );
13216 ok( msg.lParam == 0, "bad lparam %lx\n", msg.lParam );
13217
13218 DispatchMessageA( &msg );
13219
13220 seq[0].wParam = 0x3b1;
13221 ok_sequence( seq, "unicode WM_CHAR", FALSE );
13222
13223 DestroyWindow( hwnd );
13224 ActivateKeyboardLayout( hkl_orig, 0 );
13225 UnloadKeyboardLayout( hkl_greek );
13226 }
13227
13228 #define ID_LISTBOX 0x000f
13229
13230 static const struct message wm_lb_setcursel_0[] =
13231 {
13232 { LB_SETCURSEL, sent|wparam|lparam, 0, 0 },
13233 { WM_CTLCOLORLISTBOX, sent|parent },
13234 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000120f2 },
13235 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 1 },
13236 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam, OBJID_CLIENT, 1 },
13237 { 0 }
13238 };
13239 static const struct message wm_lb_setcursel_1[] =
13240 {
13241 { LB_SETCURSEL, sent|wparam|lparam, 1, 0 },
13242 { WM_CTLCOLORLISTBOX, sent|parent },
13243 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000020f2 },
13244 { WM_CTLCOLORLISTBOX, sent|parent },
13245 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000121f2 },
13246 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 2 },
13247 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam, OBJID_CLIENT, 2 },
13248 { 0 }
13249 };
13250 static const struct message wm_lb_setcursel_2[] =
13251 {
13252 { LB_SETCURSEL, sent|wparam|lparam, 2, 0 },
13253 { WM_CTLCOLORLISTBOX, sent|parent },
13254 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000021f2 },
13255 { WM_CTLCOLORLISTBOX, sent|parent },
13256 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000122f2 },
13257 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 3 },
13258 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam, OBJID_CLIENT, 3 },
13259 { 0 }
13260 };
13261 static const struct message wm_lb_click_0[] =
13262 {
13263 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, MAKELPARAM(1,1) },
13264 { HCBT_SETFOCUS, hook },
13265 { WM_KILLFOCUS, sent|parent },
13266 { WM_IME_SETCONTEXT, sent|wparam|optional|parent, 0 },
13267 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
13268 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
13269 { WM_SETFOCUS, sent|defwinproc },
13270
13271 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x001142f2 },
13272 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_LISTBOX, LBN_SETFOCUS) },
13273 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 3 },
13274 { WM_LBTRACKPOINT, sent|wparam|lparam|parent, 0, MAKELPARAM(1,1) },
13275 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
13276
13277 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000142f2 },
13278 { WM_CTLCOLORLISTBOX, sent|parent },
13279 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000022f2 },
13280 { WM_CTLCOLORLISTBOX, sent|parent },
13281 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000120f2 },
13282 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x001140f2 },
13283
13284 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 1 },
13285 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam, OBJID_CLIENT, 1 },
13286
13287 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
13288 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
13289 { WM_CAPTURECHANGED, sent|wparam|lparam|defwinproc, 0, 0 },
13290 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_LISTBOX, LBN_SELCHANGE) },
13291 { 0 }
13292 };
13293 static const struct message wm_lb_deletestring[] =
13294 {
13295 { LB_DELETESTRING, sent|wparam|lparam, 0, 0 },
13296 { WM_DELETEITEM, sent|wparam|parent|optional, ID_LISTBOX, 0 },
13297 { WM_DRAWITEM, sent|wparam|parent|optional, ID_LISTBOX },
13298 { WM_DRAWITEM, sent|wparam|parent|optional, ID_LISTBOX },
13299 { 0 }
13300 };
13301 static const struct message wm_lb_deletestring_reset[] =
13302 {
13303 { LB_DELETESTRING, sent|wparam|lparam, 0, 0 },
13304 { LB_RESETCONTENT, sent|wparam|lparam|defwinproc|optional, 0, 0 },
13305 { WM_DELETEITEM, sent|wparam|parent|optional, ID_LISTBOX, 0 },
13306 { WM_DRAWITEM, sent|wparam|parent|optional, ID_LISTBOX },
13307 { WM_DRAWITEM, sent|wparam|parent|optional, ID_LISTBOX },
13308 { 0 }
13309 };
13310
13311 #define check_lb_state(a1, a2, a3, a4, a5) check_lb_state_dbg(a1, a2, a3, a4, a5, __LINE__)
13312
13313 static LRESULT (WINAPI *listbox_orig_proc)(HWND, UINT, WPARAM, LPARAM);
13314
13315 static LRESULT WINAPI listbox_hook_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
13316 {
13317 static LONG defwndproc_counter = 0;
13318 LRESULT ret;
13319 struct recvd_message msg;
13320
13321 /* do not log painting messages */
13322 if (message != WM_PAINT &&
13323 message != WM_NCPAINT &&
13324 message != WM_SYNCPAINT &&
13325 message != WM_ERASEBKGND &&
13326 message != WM_NCHITTEST &&
13327 message != WM_GETTEXT &&
13328 !ignore_message( message ))
13329 {
13330 msg.hwnd = hwnd;
13331 msg.message = message;
13332 msg.flags = sent|wparam|lparam;
13333 if (defwndproc_counter) msg.flags |= defwinproc;
13334 msg.wParam = wp;
13335 msg.lParam = lp;
13336 msg.descr = "listbox";
13337 add_message(&msg);
13338 }
13339
13340 defwndproc_counter++;
13341 ret = CallWindowProcA(listbox_orig_proc, hwnd, message, wp, lp);
13342 defwndproc_counter--;
13343
13344 return ret;
13345 }
13346
13347 static void check_lb_state_dbg(HWND listbox, int count, int cur_sel,
13348 int caret_index, int top_index, int line)
13349 {
13350 LRESULT ret;
13351
13352 /* calling an orig proc helps to avoid unnecessary message logging */
13353 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETCOUNT, 0, 0);
13354 ok_(__FILE__, line)(ret == count, "expected count %d, got %ld\n", count, ret);
13355 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETCURSEL, 0, 0);
13356 ok_(__FILE__, line)(ret == cur_sel, "expected cur sel %d, got %ld\n", cur_sel, ret);
13357 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETCARETINDEX, 0, 0);
13358 ok_(__FILE__, line)(ret == caret_index ||
13359 broken(cur_sel == -1 && caret_index == 0 && ret == -1), /* nt4 */
13360 "expected caret index %d, got %ld\n", caret_index, ret);
13361 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETTOPINDEX, 0, 0);
13362 ok_(__FILE__, line)(ret == top_index, "expected top index %d, got %ld\n", top_index, ret);
13363 }
13364
13365 static void test_listbox_messages(void)
13366 {
13367 HWND parent, listbox;
13368 LRESULT ret;
13369
13370 parent = CreateWindowExA(0, "TestParentClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
13371 100, 100, 200, 200, 0, 0, 0, NULL);
13372 listbox = CreateWindowExA(WS_EX_NOPARENTNOTIFY, "ListBox", NULL,
13373 WS_CHILD | LBS_NOTIFY | LBS_OWNERDRAWVARIABLE | LBS_HASSTRINGS | WS_VISIBLE,
13374 10, 10, 80, 80, parent, (HMENU)ID_LISTBOX, 0, NULL);
13375 listbox_orig_proc = (WNDPROC)SetWindowLongPtrA(listbox, GWLP_WNDPROC, (ULONG_PTR)listbox_hook_proc);
13376
13377 check_lb_state(listbox, 0, LB_ERR, 0, 0);
13378
13379 ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 0");
13380 ok(ret == 0, "expected 0, got %ld\n", ret);
13381 ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 1");
13382 ok(ret == 1, "expected 1, got %ld\n", ret);
13383 ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 2");
13384 ok(ret == 2, "expected 2, got %ld\n", ret);
13385
13386 check_lb_state(listbox, 3, LB_ERR, 0, 0);
13387
13388 flush_sequence();
13389
13390 log_all_parent_messages++;
13391
13392 trace("selecting item 0\n");
13393 ret = SendMessageA(listbox, LB_SETCURSEL, 0, 0);
13394 ok(ret == 0, "expected 0, got %ld\n", ret);
13395 ok_sequence(wm_lb_setcursel_0, "LB_SETCURSEL 0", FALSE );
13396 check_lb_state(listbox, 3, 0, 0, 0);
13397 flush_sequence();
13398
13399 trace("selecting item 1\n");
13400 ret = SendMessageA(listbox, LB_SETCURSEL, 1, 0);
13401 ok(ret == 1, "expected 1, got %ld\n", ret);
13402 ok_sequence(wm_lb_setcursel_1, "LB_SETCURSEL 1", FALSE );
13403 check_lb_state(listbox, 3, 1, 1, 0);
13404
13405 trace("selecting item 2\n");
13406 ret = SendMessageA(listbox, LB_SETCURSEL, 2, 0);
13407 ok(ret == 2, "expected 2, got %ld\n", ret);
13408 ok_sequence(wm_lb_setcursel_2, "LB_SETCURSEL 2", FALSE );
13409 check_lb_state(listbox, 3, 2, 2, 0);
13410
13411 trace("clicking on item 0\n");
13412 ret = SendMessageA(listbox, WM_LBUTTONDOWN, 0, MAKELPARAM(1, 1));
13413 ok(ret == LB_OKAY, "expected LB_OKAY, got %ld\n", ret);
13414 ret = SendMessageA(listbox, WM_LBUTTONUP, 0, 0);
13415 ok(ret == LB_OKAY, "expected LB_OKAY, got %ld\n", ret);
13416 ok_sequence(wm_lb_click_0, "WM_LBUTTONDOWN 0", FALSE );
13417 check_lb_state(listbox, 3, 0, 0, 0);
13418 flush_sequence();
13419
13420 trace("deleting item 0\n");
13421 ret = SendMessageA(listbox, LB_DELETESTRING, 0, 0);
13422 ok(ret == 2, "expected 2, got %ld\n", ret);
13423 ok_sequence(wm_lb_deletestring, "LB_DELETESTRING 0", FALSE );
13424 check_lb_state(listbox, 2, -1, 0, 0);
13425 flush_sequence();
13426
13427 trace("deleting item 0\n");
13428 ret = SendMessageA(listbox, LB_DELETESTRING, 0, 0);
13429 ok(ret == 1, "expected 1, got %ld\n", ret);
13430 ok_sequence(wm_lb_deletestring, "LB_DELETESTRING 0", FALSE );
13431 check_lb_state(listbox, 1, -1, 0, 0);
13432 flush_sequence();
13433
13434 trace("deleting item 0\n");
13435 ret = SendMessageA(listbox, LB_DELETESTRING, 0, 0);
13436 ok(ret == 0, "expected 0, got %ld\n", ret);
13437 ok_sequence(wm_lb_deletestring_reset, "LB_DELETESTRING 0", FALSE );
13438 check_lb_state(listbox, 0, -1, 0, 0);
13439 flush_sequence();
13440
13441 trace("deleting item 0\n");
13442 ret = SendMessageA(listbox, LB_DELETESTRING, 0, 0);
13443 ok(ret == LB_ERR, "expected LB_ERR, got %ld\n", ret);
13444 check_lb_state(listbox, 0, -1, 0, 0);
13445 flush_sequence();
13446
13447 log_all_parent_messages--;
13448
13449 DestroyWindow(listbox);
13450 DestroyWindow(parent);
13451 }
13452
13453 /*************************** Menu test ******************************/
13454 static const struct message wm_popup_menu_1[] =
13455 {
13456 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
13457 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
13458 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'E', 0x20000001 },
13459 { WM_SYSKEYDOWN, sent|wparam|lparam, 'E', 0x20000001 },
13460 { WM_SYSCHAR, sent|wparam|lparam, 'e', 0x20000001 },
13461 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_KEYMENU, 'e' },
13462 { WM_ENTERMENULOOP, sent|wparam|lparam, 0, 0 },
13463 { WM_INITMENU, sent|lparam, 0, 0 },
13464 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(1,MF_HILITE|MF_POPUP) },
13465 { WM_INITMENUPOPUP, sent|lparam, 0, 1 },
13466 { HCBT_CREATEWND, hook|optional }, /* Win9x doesn't create a window */
13467 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(200,MF_HILITE) },
13468 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'E', 0xf0000001 },
13469 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xd0000001 },
13470 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0x10000001, 0, 0x40000000 },
13471 { HCBT_DESTROYWND, hook|optional }, /* Win9x doesn't create a window */
13472 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
13473 { WM_MENUSELECT, sent|wparam|lparam, MAKEWPARAM(0,0xffff), 0 },
13474 { WM_EXITMENULOOP, sent|wparam|lparam, 0, 0 },
13475 { WM_MENUCOMMAND, sent }, /* |wparam, 200 - Win9x */
13476 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0xc0000001 },
13477 { WM_KEYUP, sent|wparam|lparam, VK_RETURN, 0xc0000001 },
13478 { 0 }
13479 };
13480 static const struct message wm_popup_menu_2[] =
13481 {
13482 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
13483 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
13484 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0x20000001 },
13485 { WM_SYSKEYDOWN, sent|wparam|lparam, 'F', 0x20000001 },
13486 { WM_SYSCHAR, sent|wparam|lparam, 'f', 0x20000001 },
13487 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_KEYMENU, 'f' },
13488 { WM_ENTERMENULOOP, sent|wparam|lparam, 0, 0 },
13489 { WM_INITMENU, sent|lparam, 0, 0 },
13490 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) },
13491 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
13492 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(0,MF_HILITE|MF_POPUP) }, /* Win9x */
13493 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x */
13494 { HCBT_CREATEWND, hook },
13495 { WM_MENUSELECT, sent }, /*|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) - XP
13496 |wparam, MAKEWPARAM(100,MF_HILITE) - Win9x */
13497 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0xf0000001 },
13498 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xd0000001 },
13499 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0x10000001 },
13500 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x doesn't send it */
13501 { HCBT_CREATEWND, hook|optional }, /* Win9x doesn't send it */
13502 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(100,MF_HILITE) },
13503 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0xd0000001 },
13504 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0x10000001 },
13505 { HCBT_DESTROYWND, hook },
13506 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
13507 { HCBT_DESTROYWND, hook|optional }, /* Win9x doesn't send it */
13508 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
13509 { WM_MENUSELECT, sent|wparam|lparam, MAKEWPARAM(0,0xffff), 0 },
13510 { WM_EXITMENULOOP, sent|wparam|lparam, 0, 0 },
13511 { WM_MENUCOMMAND, sent }, /* |wparam, 100 - Win9x */
13512 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0xc0000001 },
13513 { WM_KEYUP, sent|wparam|lparam, VK_RETURN, 0xc0000001 },
13514 { 0 }
13515 };
13516 static const struct message wm_popup_menu_3[] =
13517 {
13518 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
13519 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
13520 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0x20000001 },
13521 { WM_SYSKEYDOWN, sent|wparam|lparam, 'F', 0x20000001 },
13522 { WM_SYSCHAR, sent|wparam|lparam, 'f', 0x20000001 },
13523 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_KEYMENU, 'f' },
13524 { WM_ENTERMENULOOP, sent|wparam|lparam, 0, 0 },
13525 { WM_INITMENU, sent|lparam, 0, 0 },
13526 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) },
13527 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
13528 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(0,MF_HILITE|MF_POPUP) }, /* Win9x */
13529 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x */
13530 { HCBT_CREATEWND, hook },
13531 { WM_MENUSELECT, sent }, /*|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) - XP
13532 |wparam, MAKEWPARAM(100,MF_HILITE) - Win9x */
13533 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0xf0000001 },
13534 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xd0000001 },
13535 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0x10000001 },
13536 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x doesn't send it */
13537 { HCBT_CREATEWND, hook|optional }, /* Win9x doesn't send it */
13538 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(100,MF_HILITE) },
13539 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0xd0000001 },
13540 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0x10000001 },
13541 { HCBT_DESTROYWND, hook },
13542 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
13543 { HCBT_DESTROYWND, hook|optional }, /* Win9x doesn't send it */
13544 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
13545 { WM_MENUSELECT, sent|wparam|lparam, MAKEWPARAM(0,0xffff), 0 },
13546 { WM_EXITMENULOOP, sent|wparam|lparam, 0, 0 },
13547 { WM_COMMAND, sent|wparam|lparam, 100, 0 },
13548 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0xc0000001 },
13549 { WM_KEYUP, sent|wparam|lparam, VK_RETURN, 0xc0000001 },
13550 { 0 }
13551 };
13552
13553 static const struct message wm_single_menu_item[] =
13554 {
13555 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
13556 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
13557 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'Q', 0x20000001 },
13558 { WM_SYSKEYDOWN, sent|wparam|lparam, 'Q', 0x20000001 },
13559 { WM_SYSCHAR, sent|wparam|lparam, 'q', 0x20000001 },
13560 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_KEYMENU, 'q' },
13561 { WM_ENTERMENULOOP, sent|wparam|lparam, 0, 0 },
13562 { WM_INITMENU, sent|lparam, 0, 0 },
13563 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(300,MF_HILITE) },
13564 { WM_MENUSELECT, sent|wparam|lparam, MAKEWPARAM(0,0xffff), 0 },
13565 { WM_EXITMENULOOP, sent|wparam|lparam, 0, 0 },
13566 { WM_MENUCOMMAND, sent },
13567 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'Q', 0xe0000001 },
13568 { WM_SYSKEYUP, sent|wparam|lparam, 'Q', 0xe0000001 },
13569 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 },
13570 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
13571
13572 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_ESCAPE, 1 },
13573 { WM_KEYDOWN, sent|wparam|lparam, VK_ESCAPE, 1 },
13574 { WM_CHAR, sent|wparam|lparam, VK_ESCAPE, 0x00000001 },
13575 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_ESCAPE, 0xc0000001 },
13576 { WM_KEYUP, sent|wparam|lparam, VK_ESCAPE, 0xc0000001 },
13577 { 0 }
13578 };
13579
13580 static LRESULT WINAPI parent_menu_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
13581 {
13582 if (message == WM_ENTERIDLE ||
13583 message == WM_INITMENU ||
13584 message == WM_INITMENUPOPUP ||
13585 message == WM_MENUSELECT ||
13586 message == WM_PARENTNOTIFY ||
13587 message == WM_ENTERMENULOOP ||
13588 message == WM_EXITMENULOOP ||
13589 message == WM_UNINITMENUPOPUP ||
13590 message == WM_KEYDOWN ||
13591 message == WM_KEYUP ||
13592 message == WM_CHAR ||
13593 message == WM_SYSKEYDOWN ||
13594 message == WM_SYSKEYUP ||
13595 message == WM_SYSCHAR ||
13596 message == WM_COMMAND ||
13597 message == WM_MENUCOMMAND)
13598 {
13599 struct recvd_message msg;
13600
13601 msg.hwnd = hwnd;
13602 msg.message = message;
13603 msg.flags = sent|wparam|lparam;
13604 msg.wParam = wp;
13605 msg.lParam = lp;
13606 msg.descr = "parent_menu_proc";
13607 add_message(&msg);
13608 }
13609
13610 return DefWindowProcA(hwnd, message, wp, lp);
13611 }
13612
13613 static void set_menu_style(HMENU hmenu, DWORD style)
13614 {
13615 MENUINFO mi;
13616 BOOL ret;
13617
13618 mi.cbSize = sizeof(mi);
13619 mi.fMask = MIM_STYLE;
13620 mi.dwStyle = style;
13621 SetLastError(0xdeadbeef);
13622 ret = pSetMenuInfo(hmenu, &mi);
13623 ok(ret, "SetMenuInfo error %u\n", GetLastError());
13624 }
13625
13626 static DWORD get_menu_style(HMENU hmenu)
13627 {
13628 MENUINFO mi;
13629 BOOL ret;
13630
13631 mi.cbSize = sizeof(mi);
13632 mi.fMask = MIM_STYLE;
13633 mi.dwStyle = 0;
13634 SetLastError(0xdeadbeef);
13635 ret = pGetMenuInfo(hmenu, &mi);
13636 ok(ret, "GetMenuInfo error %u\n", GetLastError());
13637
13638 return mi.dwStyle;
13639 }
13640
13641 static void test_menu_messages(void)
13642 {
13643 MSG msg;
13644 WNDCLASSA cls;
13645 HMENU hmenu, hmenu_popup;
13646 HWND hwnd;
13647 DWORD style;
13648
13649 if (!pGetMenuInfo || !pSetMenuInfo)
13650 {
13651 win_skip("GetMenuInfo and/or SetMenuInfo are not available\n");
13652 return;
13653 }
13654 cls.style = 0;
13655 cls.lpfnWndProc = parent_menu_proc;
13656 cls.cbClsExtra = 0;
13657 cls.cbWndExtra = 0;
13658 cls.hInstance = GetModuleHandleA(0);
13659 cls.hIcon = 0;
13660 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
13661 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
13662 cls.lpszMenuName = NULL;
13663 cls.lpszClassName = "TestMenuClass";
13664 UnregisterClassA(cls.lpszClassName, cls.hInstance);
13665 if (!RegisterClassA(&cls)) assert(0);
13666
13667 SetLastError(0xdeadbeef);
13668 hwnd = CreateWindowExA(0, "TestMenuClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
13669 100, 100, 200, 200, 0, 0, 0, NULL);
13670 ok(hwnd != 0, "LoadMenuA error %u\n", GetLastError());
13671
13672 SetLastError(0xdeadbeef);
13673 hmenu = LoadMenuA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(1));
13674 ok(hmenu != 0, "LoadMenuA error %u\n", GetLastError());
13675
13676 SetMenu(hwnd, hmenu);
13677 SetForegroundWindow( hwnd );
13678 flush_events();
13679
13680 set_menu_style(hmenu, MNS_NOTIFYBYPOS);
13681 style = get_menu_style(hmenu);
13682 ok(style == MNS_NOTIFYBYPOS, "expected MNS_NOTIFYBYPOS, got %u\n", style);
13683
13684 hmenu_popup = GetSubMenu(hmenu, 0);
13685 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
13686 style = get_menu_style(hmenu_popup);
13687 ok(style == 0, "expected 0, got %u\n", style);
13688
13689 hmenu_popup = GetSubMenu(hmenu_popup, 0);
13690 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
13691 style = get_menu_style(hmenu_popup);
13692 ok(style == 0, "expected 0, got %u\n", style);
13693
13694 /* Alt+E, Enter */
13695 trace("testing a popup menu command\n");
13696 flush_sequence();
13697 keybd_event(VK_MENU, 0, 0, 0);
13698 keybd_event('E', 0, 0, 0);
13699 keybd_event('E', 0, KEYEVENTF_KEYUP, 0);
13700 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
13701 keybd_event(VK_RETURN, 0, 0, 0);
13702 keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
13703 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
13704 {
13705 TranslateMessage(&msg);
13706 DispatchMessageA(&msg);
13707 }
13708 if (!sequence_cnt) /* we didn't get any message */
13709 {
13710 skip( "queuing key events not supported\n" );
13711 goto done;
13712 }
13713 /* win98 queues only a WM_KEYUP and doesn't start menu tracking */
13714 if (sequence[0].message == WM_KEYUP && sequence[0].wParam == VK_MENU)
13715 {
13716 win_skip( "menu tracking through VK_MENU not supported\n" );
13717 goto done;
13718 }
13719 ok_sequence(wm_popup_menu_1, "popup menu command", FALSE);
13720
13721 /* Alt+F, Right, Enter */
13722 trace("testing submenu of a popup menu command\n");
13723 flush_sequence();
13724 keybd_event(VK_MENU, 0, 0, 0);
13725 keybd_event('F', 0, 0, 0);
13726 keybd_event('F', 0, KEYEVENTF_KEYUP, 0);
13727 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
13728 keybd_event(VK_RIGHT, 0, 0, 0);
13729 keybd_event(VK_RIGHT, 0, KEYEVENTF_KEYUP, 0);
13730 keybd_event(VK_RETURN, 0, 0, 0);
13731 keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
13732 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
13733 {
13734 TranslateMessage(&msg);
13735 DispatchMessageA(&msg);
13736 }
13737 ok_sequence(wm_popup_menu_2, "submenu of a popup menu command", FALSE);
13738
13739 trace("testing single menu item command\n");
13740 flush_sequence();
13741 keybd_event(VK_MENU, 0, 0, 0);
13742 keybd_event('Q', 0, 0, 0);
13743 keybd_event('Q', 0, KEYEVENTF_KEYUP, 0);
13744 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
13745 keybd_event(VK_ESCAPE, 0, 0, 0);
13746 keybd_event(VK_ESCAPE, 0, KEYEVENTF_KEYUP, 0);
13747 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
13748 {
13749 TranslateMessage(&msg);
13750 DispatchMessageA(&msg);
13751 }
13752 ok_sequence(wm_single_menu_item, "single menu item command", FALSE);
13753
13754 set_menu_style(hmenu, 0);
13755 style = get_menu_style(hmenu);
13756 ok(style == 0, "expected 0, got %u\n", style);
13757
13758 hmenu_popup = GetSubMenu(hmenu, 0);
13759 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
13760 set_menu_style(hmenu_popup, MNS_NOTIFYBYPOS);
13761 style = get_menu_style(hmenu_popup);
13762 ok(style == MNS_NOTIFYBYPOS, "expected MNS_NOTIFYBYPOS, got %u\n", style);
13763
13764 hmenu_popup = GetSubMenu(hmenu_popup, 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 /* Alt+F, Right, Enter */
13770 trace("testing submenu of a popup menu command\n");
13771 flush_sequence();
13772 keybd_event(VK_MENU, 0, 0, 0);
13773 keybd_event('F', 0, 0, 0);
13774 keybd_event('F', 0, KEYEVENTF_KEYUP, 0);
13775 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
13776 keybd_event(VK_RIGHT, 0, 0, 0);
13777 keybd_event(VK_RIGHT, 0, KEYEVENTF_KEYUP, 0);
13778 keybd_event(VK_RETURN, 0, 0, 0);
13779 keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
13780 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
13781 {
13782 TranslateMessage(&msg);
13783 DispatchMessageA(&msg);
13784 }
13785 ok_sequence(wm_popup_menu_3, "submenu of a popup menu command", FALSE);
13786
13787 done:
13788 DestroyWindow(hwnd);
13789 DestroyMenu(hmenu);
13790 }
13791
13792
13793 static void test_paintingloop(void)
13794 {
13795 HWND hwnd;
13796
13797 paint_loop_done = FALSE;
13798 hwnd = CreateWindowExA(0x0,"PaintLoopWindowClass",
13799 "PaintLoopWindowClass",WS_OVERLAPPEDWINDOW,
13800 100, 100, 100, 100, 0, 0, 0, NULL );
13801 ok(hwnd != 0, "PaintLoop window error %u\n", GetLastError());
13802 ShowWindow(hwnd,SW_NORMAL);
13803 SetFocus(hwnd);
13804
13805 while (!paint_loop_done)
13806 {
13807 MSG msg;
13808 if (PeekMessageA(&msg, 0, 0, 0, 1))
13809 {
13810 TranslateMessage(&msg);
13811 DispatchMessageA(&msg);
13812 }
13813 }
13814 DestroyWindow(hwnd);
13815 }
13816
13817 static void test_defwinproc(void)
13818 {
13819 HWND hwnd;
13820 MSG msg;
13821 BOOL gotwmquit = FALSE;
13822 hwnd = CreateWindowExA(0, "static", "test_defwndproc", WS_POPUP, 0,0,0,0,0,0,0, NULL);
13823 assert(hwnd);
13824 DefWindowProcA( hwnd, WM_ENDSESSION, 1, 0);
13825 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) {
13826 if( msg.message == WM_QUIT) gotwmquit = TRUE;
13827 DispatchMessageA( &msg );
13828 }
13829 ok(!gotwmquit, "Unexpected WM_QUIT message!\n");
13830 DestroyWindow( hwnd);
13831 }
13832
13833 #define clear_clipboard(hwnd) clear_clipboard_(__LINE__, (hwnd))
13834 static void clear_clipboard_(int line, HWND hWnd)
13835 {
13836 BOOL succ;
13837 succ = OpenClipboard(hWnd);
13838 ok_(__FILE__, line)(succ, "OpenClipboard failed, err=%u\n", GetLastError());
13839 succ = EmptyClipboard();
13840 ok_(__FILE__, line)(succ, "EmptyClipboard failed, err=%u\n", GetLastError());
13841 succ = CloseClipboard();
13842 ok_(__FILE__, line)(succ, "CloseClipboard failed, err=%u\n", GetLastError());
13843 }
13844
13845 #define expect_HWND(expected, got) expect_HWND_(__LINE__, (expected), (got))
13846 static void expect_HWND_(int line, HWND expected, HWND got)
13847 {
13848 ok_(__FILE__, line)(got==expected, "Expected %p, got %p\n", expected, got);
13849 }
13850
13851 static WNDPROC pOldViewerProc;
13852
13853 static LRESULT CALLBACK recursive_viewer_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
13854 {
13855 static BOOL recursion_guard;
13856
13857 if (message == WM_DRAWCLIPBOARD && !recursion_guard)
13858 {
13859 recursion_guard = TRUE;
13860 clear_clipboard(hWnd);
13861 recursion_guard = FALSE;
13862 }
13863 return CallWindowProcA(pOldViewerProc, hWnd, message, wParam, lParam);
13864 }
13865
13866 static void test_clipboard_viewers(void)
13867 {
13868 static struct message wm_change_cb_chain[] =
13869 {
13870 { WM_CHANGECBCHAIN, sent|wparam|lparam, 0, 0 },
13871 { 0 }
13872 };
13873 static const struct message wm_clipboard_destroyed[] =
13874 {
13875 { WM_DESTROYCLIPBOARD, sent|wparam|lparam, 0, 0 },
13876 { 0 }
13877 };
13878 static struct message wm_clipboard_changed[] =
13879 {
13880 { WM_DRAWCLIPBOARD, sent|wparam|lparam, 0, 0 },
13881 { 0 }
13882 };
13883 static struct message wm_clipboard_changed_and_owned[] =
13884 {
13885 { WM_DESTROYCLIPBOARD, sent|wparam|lparam, 0, 0 },
13886 { WM_DRAWCLIPBOARD, sent|wparam|lparam, 0, 0 },
13887 { 0 }
13888 };
13889
13890 HINSTANCE hInst = GetModuleHandleA(NULL);
13891 HWND hWnd1, hWnd2, hWnd3;
13892 HWND hOrigViewer;
13893 HWND hRet;
13894
13895 hWnd1 = CreateWindowExA(0, "TestWindowClass", "Clipboard viewer test wnd 1",
13896 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX,
13897 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
13898 GetDesktopWindow(), NULL, hInst, NULL);
13899 hWnd2 = CreateWindowExA(0, "SimpleWindowClass", "Clipboard viewer test wnd 2",
13900 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX,
13901 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
13902 GetDesktopWindow(), NULL, hInst, NULL);
13903 hWnd3 = CreateWindowExA(0, "SimpleWindowClass", "Clipboard viewer test wnd 3",
13904 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX,
13905 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
13906 GetDesktopWindow(), NULL, hInst, NULL);
13907 trace("clipbd viewers: hWnd1=%p, hWnd2=%p, hWnd3=%p\n", hWnd1, hWnd2, hWnd3);
13908 assert(hWnd1 && hWnd2 && hWnd3);
13909
13910 flush_sequence();
13911
13912 /* Test getting the clipboard viewer and setting the viewer to NULL. */
13913 hOrigViewer = GetClipboardViewer();
13914 hRet = SetClipboardViewer(NULL);
13915 ok_sequence(WmEmptySeq, "set viewer to NULL", FALSE);
13916 expect_HWND(hOrigViewer, hRet);
13917 expect_HWND(NULL, GetClipboardViewer());
13918
13919 /* Test registering hWnd1 as a viewer. */
13920 hRet = SetClipboardViewer(hWnd1);
13921 wm_clipboard_changed[0].wParam = (WPARAM) GetClipboardOwner();
13922 ok_sequence(wm_clipboard_changed, "set viewer NULL->1", FALSE);
13923 expect_HWND(NULL, hRet);
13924 expect_HWND(hWnd1, GetClipboardViewer());
13925
13926 /* Test that changing the clipboard actually refreshes the registered viewer. */
13927 clear_clipboard(hWnd1);
13928 wm_clipboard_changed[0].wParam = (WPARAM) GetClipboardOwner();
13929 ok_sequence(wm_clipboard_changed, "clear clipbd (viewer=owner=1)", FALSE);
13930
13931 /* Again, but with different owner. */
13932 clear_clipboard(hWnd2);
13933 wm_clipboard_changed_and_owned[1].wParam = (WPARAM) GetClipboardOwner();
13934 ok_sequence(wm_clipboard_changed_and_owned, "clear clipbd (viewer=1, owner=2)", FALSE);
13935
13936 /* Test re-registering same window. */
13937 hRet = SetClipboardViewer(hWnd1);
13938 wm_clipboard_changed[0].wParam = (WPARAM) GetClipboardOwner();
13939 ok_sequence(wm_clipboard_changed, "set viewer 1->1", FALSE);
13940 expect_HWND(hWnd1, hRet);
13941 expect_HWND(hWnd1, GetClipboardViewer());
13942
13943 /* Test ChangeClipboardChain. */
13944 ChangeClipboardChain(hWnd2, hWnd3);
13945 wm_change_cb_chain[0].wParam = (WPARAM) hWnd2;
13946 wm_change_cb_chain[0].lParam = (LPARAM) hWnd3;
13947 ok_sequence(wm_change_cb_chain, "change chain (viewer=1, remove=2, next=3)", FALSE);
13948 expect_HWND(hWnd1, GetClipboardViewer());
13949
13950 ChangeClipboardChain(hWnd2, NULL);
13951 wm_change_cb_chain[0].wParam = (WPARAM) hWnd2;
13952 wm_change_cb_chain[0].lParam = 0;
13953 ok_sequence(wm_change_cb_chain, "change chain (viewer=1, remove=2, next=NULL)", FALSE);
13954 expect_HWND(hWnd1, GetClipboardViewer());
13955
13956 ChangeClipboardChain(NULL, hWnd2);
13957 ok_sequence(WmEmptySeq, "change chain (viewer=1, remove=NULL, next=2)", TRUE);
13958 expect_HWND(hWnd1, GetClipboardViewer());
13959
13960 /* Actually change clipboard viewer with ChangeClipboardChain. */
13961 ChangeClipboardChain(hWnd1, hWnd2);
13962 ok_sequence(WmEmptySeq, "change chain (viewer=remove=1, next=2)", FALSE);
13963 expect_HWND(hWnd2, GetClipboardViewer());
13964
13965 /* Test that no refresh messages are sent when viewer has unregistered. */
13966 clear_clipboard(hWnd2);
13967 ok_sequence(WmEmptySeq, "clear clipd (viewer=2, owner=1)", FALSE);
13968
13969 /* Register hWnd1 again. */
13970 ChangeClipboardChain(hWnd2, hWnd1);
13971 ok_sequence(WmEmptySeq, "change chain (viewer=remove=2, next=1)", FALSE);
13972 expect_HWND(hWnd1, GetClipboardViewer());
13973
13974 /* Subclass hWnd1 so that when it receives a WM_DRAWCLIPBOARD message, it
13975 * changes the clipboard. When this happens, the system shouldn't send
13976 * another WM_DRAWCLIPBOARD (as this could cause an infinite loop).
13977 */
13978 pOldViewerProc = (WNDPROC) SetWindowLongPtrA(hWnd1, GWLP_WNDPROC, (LONG_PTR) recursive_viewer_proc);
13979 clear_clipboard(hWnd2);
13980 /* The clipboard owner is changed in recursive_viewer_proc: */
13981 wm_clipboard_changed[0].wParam = (WPARAM) hWnd2;
13982 ok_sequence(wm_clipboard_changed, "recursive clear clipbd (viewer=1, owner=2)", TRUE);
13983
13984 /* Test unregistering. */
13985 ChangeClipboardChain(hWnd1, NULL);
13986 ok_sequence(WmEmptySeq, "change chain (viewer=remove=1, next=NULL)", FALSE);
13987 expect_HWND(NULL, GetClipboardViewer());
13988
13989 clear_clipboard(hWnd1);
13990 ok_sequence(wm_clipboard_destroyed, "clear clipbd (no viewer, owner=1)", FALSE);
13991
13992 DestroyWindow(hWnd1);
13993 DestroyWindow(hWnd2);
13994 DestroyWindow(hWnd3);
13995 SetClipboardViewer(hOrigViewer);
13996 }
13997
13998 static void test_PostMessage(void)
13999 {
14000 static const struct
14001 {
14002 HWND hwnd;
14003 BOOL ret;
14004 } data[] =
14005 {
14006 { HWND_TOP /* 0 */, TRUE },
14007 { HWND_BROADCAST, TRUE },
14008 { HWND_BOTTOM, TRUE },
14009 { HWND_TOPMOST, TRUE },
14010 { HWND_NOTOPMOST, FALSE },
14011 { HWND_MESSAGE, FALSE },
14012 { (HWND)0xdeadbeef, FALSE }
14013 };
14014 int i;
14015 HWND hwnd;
14016 BOOL ret;
14017 MSG msg;
14018 static const WCHAR staticW[] = {'s','t','a','t','i','c',0};
14019
14020 SetLastError(0xdeadbeef);
14021 hwnd = CreateWindowExW(0, staticW, NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
14022 if (!hwnd && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
14023 {
14024 win_skip("Skipping some PostMessage tests on Win9x/WinMe\n");
14025 return;
14026 }
14027 assert(hwnd);
14028
14029 flush_events();
14030
14031 PostMessageA(hwnd, WM_USER+1, 0x1234, 0x5678);
14032 PostMessageA(0, WM_USER+2, 0x5678, 0x1234);
14033
14034 for (i = 0; i < sizeof(data)/sizeof(data[0]); i++)
14035 {
14036 memset(&msg, 0xab, sizeof(msg));
14037 ret = PeekMessageA(&msg, data[i].hwnd, 0, 0, PM_NOREMOVE);
14038 ok(ret == data[i].ret, "%d: hwnd %p expected %d, got %d\n", i, data[i].hwnd, data[i].ret, ret);
14039 if (data[i].ret)
14040 {
14041 if (data[i].hwnd)
14042 ok(ret && msg.hwnd == 0 && msg.message == WM_USER+2 &&
14043 msg.wParam == 0x5678 && msg.lParam == 0x1234,
14044 "%d: got ret %d hwnd %p msg %04x wParam %08lx lParam %08lx instead of TRUE/0/WM_USER+2/0x5678/0x1234\n",
14045 i, ret, msg.hwnd, msg.message, msg.wParam, msg.lParam);
14046 else
14047 ok(ret && msg.hwnd == hwnd && msg.message == WM_USER+1 &&
14048 msg.wParam == 0x1234 && msg.lParam == 0x5678,
14049 "%d: got ret %d hwnd %p msg %04x wParam %08lx lParam %08lx instead of TRUE/%p/WM_USER+1/0x1234/0x5678\n",
14050 i, ret, msg.hwnd, msg.message, msg.wParam, msg.lParam, msg.hwnd);
14051 }
14052 }
14053
14054 DestroyWindow(hwnd);
14055 flush_events();
14056 }
14057
14058 static LPARAM g_broadcast_lparam;
14059 static LRESULT WINAPI broadcast_test_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
14060 {
14061 WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
14062
14063 if (wParam == 0xbaadbeef)
14064 g_broadcast_lparam = wParam;
14065 else
14066 g_broadcast_lparam = 0;
14067
14068 return CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
14069 }
14070
14071 static void test_broadcast(void)
14072 {
14073 static const UINT messages[] =
14074 {
14075 WM_USER-1,
14076 WM_USER,
14077 WM_USER+1,
14078 0xc000-1,
14079 0xc000, /* lowest possible atom returned by RegisterWindowMessage */
14080 0xffff,
14081 };
14082 WNDPROC oldproc;
14083 unsigned int i;
14084 HWND hwnd;
14085
14086 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0, 0, 0, 0, 0, 0, 0, NULL);
14087 ok(hwnd != NULL, "got %p\n", hwnd);
14088
14089 oldproc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)broadcast_test_proc);
14090 SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)oldproc);
14091
14092 for (i = 0; i < sizeof(messages)/sizeof(messages[0]); i++)
14093 {
14094 BOOL ret;
14095 MSG msg;
14096
14097 flush_events();
14098 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
14099 ;
14100
14101 /* post, broadcast */
14102 ret = PostMessageA(HWND_BROADCAST, messages[i], 0, 0);
14103 ok(ret, "%d: got %d, error %d\n", i, ret, GetLastError());
14104
14105 memset(&msg, 0xab, sizeof(msg));
14106 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
14107 if (messages[i] < WM_USER || messages[i] >= 0xc000)
14108 {
14109 ok(ret, "%d: message %04x, got %d, error %d\n", i, messages[i], ret, GetLastError());
14110 ok(msg.hwnd == hwnd, "%d: got %p\n", i, msg.hwnd);
14111 }
14112 else
14113 {
14114 ok(!ret, "%d: message %04x, got %d, error %d\n", i, messages[i], ret, GetLastError());
14115 }
14116
14117 /* post, topmost */
14118 ret = PostMessageA(HWND_TOPMOST, messages[i], 0, 0);
14119 ok(ret, "%d: got %d, error %d\n", i, ret, GetLastError());
14120
14121 memset(&msg, 0xab, sizeof(msg));
14122 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
14123 if (messages[i] < WM_USER || messages[i] >= 0xc000)
14124 {
14125 ok(ret, "%d: message %04x, got %d, error %d\n", i, messages[i], ret, GetLastError());
14126 ok(msg.hwnd == hwnd, "%d: got %p\n", i, msg.hwnd);
14127 }
14128 else
14129 {
14130 ok(!ret, "%d: got %d, error %d\n", i, ret, GetLastError());
14131 }
14132
14133 /* send, broadcast */
14134 g_broadcast_lparam = 0xdead;
14135 ret = SendMessageTimeoutA(HWND_BROADCAST, messages[i], 0xbaadbeef, 0, SMTO_NORMAL, 2000, NULL);
14136 if (!ret && GetLastError() == ERROR_TIMEOUT)
14137 win_skip("broadcasting test %d, timeout\n", i);
14138 else
14139 {
14140 if (messages[i] < WM_USER || messages[i] >= 0xc000)
14141 {
14142 ok(g_broadcast_lparam == 0xbaadbeef, "%d: message %04x, got %#lx, error %d\n", i, messages[i],
14143 g_broadcast_lparam, GetLastError());
14144 }
14145 else
14146 {
14147 ok(g_broadcast_lparam == 0xdead, "%d: message %04x, got %#lx, error %d\n", i, messages[i],
14148 g_broadcast_lparam, GetLastError());
14149 }
14150 }
14151
14152 /* send, topmost */
14153 g_broadcast_lparam = 0xdead;
14154 ret = SendMessageTimeoutA(HWND_TOPMOST, messages[i], 0xbaadbeef, 0, SMTO_NORMAL, 2000, NULL);
14155 if (!ret && GetLastError() == ERROR_TIMEOUT)
14156 win_skip("broadcasting test %d, timeout\n", i);
14157 else
14158 {
14159 if (messages[i] < WM_USER || messages[i] >= 0xc000)
14160 {
14161 ok(g_broadcast_lparam == 0xbaadbeef, "%d: message %04x, got %#lx, error %d\n", i, messages[i],
14162 g_broadcast_lparam, GetLastError());
14163 }
14164 else
14165 {
14166 ok(g_broadcast_lparam == 0xdead, "%d: message %04x, got %#lx, error %d\n", i, messages[i],
14167 g_broadcast_lparam, GetLastError());
14168 }
14169 }
14170 }
14171
14172 DestroyWindow(hwnd);
14173 }
14174
14175 static const struct
14176 {
14177 DWORD exp, broken;
14178 BOOL todo;
14179 } wait_idle_expect[] =
14180 {
14181 /* 0 */ { WAIT_TIMEOUT, WAIT_TIMEOUT, FALSE },
14182 { WAIT_TIMEOUT, 0, FALSE },
14183 { WAIT_TIMEOUT, 0, FALSE },
14184 { WAIT_TIMEOUT, WAIT_TIMEOUT, FALSE },
14185 { WAIT_TIMEOUT, WAIT_TIMEOUT, FALSE },
14186 /* 5 */ { WAIT_TIMEOUT, 0, FALSE },
14187 { WAIT_TIMEOUT, 0, FALSE },
14188 { WAIT_TIMEOUT, WAIT_TIMEOUT, FALSE },
14189 { 0, 0, FALSE },
14190 { 0, 0, FALSE },
14191 /* 10 */ { 0, 0, FALSE },
14192 { 0, 0, FALSE },
14193 { 0, WAIT_TIMEOUT, FALSE },
14194 { 0, 0, FALSE },
14195 { 0, 0, FALSE },
14196 /* 15 */ { 0, 0, FALSE },
14197 { WAIT_TIMEOUT, 0, FALSE },
14198 { WAIT_TIMEOUT, 0, FALSE },
14199 { WAIT_TIMEOUT, 0, FALSE },
14200 { WAIT_TIMEOUT, 0, FALSE },
14201 /* 20 */ { WAIT_TIMEOUT, 0, FALSE },
14202 };
14203
14204 static DWORD CALLBACK do_wait_idle_child_thread( void *arg )
14205 {
14206 MSG msg;
14207
14208 PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
14209 Sleep( 200 );
14210 MsgWaitForMultipleObjects( 0, NULL, FALSE, 100, QS_ALLINPUT );
14211 return 0;
14212 }
14213
14214 static void do_wait_idle_child( int arg )
14215 {
14216 WNDCLASSA cls;
14217 MSG msg;
14218 HWND hwnd = 0;
14219 HANDLE thread;
14220 DWORD id;
14221 HANDLE start_event = OpenEventA( EVENT_ALL_ACCESS, FALSE, "test_WaitForInputIdle_start" );
14222 HANDLE end_event = OpenEventA( EVENT_ALL_ACCESS, FALSE, "test_WaitForInputIdle_end" );
14223
14224 memset( &cls, 0, sizeof(cls) );
14225 cls.lpfnWndProc = DefWindowProcA;
14226 cls.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
14227 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
14228 cls.lpszClassName = "TestClass";
14229 RegisterClassA( &cls );
14230
14231 PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ); /* create the msg queue */
14232
14233 ok( start_event != 0, "failed to create start event, error %u\n", GetLastError() );
14234 ok( end_event != 0, "failed to create end event, error %u\n", GetLastError() );
14235
14236 switch (arg)
14237 {
14238 case 0:
14239 SetEvent( start_event );
14240 break;
14241 case 1:
14242 SetEvent( start_event );
14243 Sleep( 200 );
14244 PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
14245 break;
14246 case 2:
14247 SetEvent( start_event );
14248 Sleep( 200 );
14249 PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
14250 PostThreadMessageA( GetCurrentThreadId(), WM_COMMAND, 0x1234, 0xabcd );
14251 PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
14252 break;
14253 case 3:
14254 SetEvent( start_event );
14255 Sleep( 200 );
14256 SendMessageA( HWND_BROADCAST, WM_WININICHANGE, 0, 0 );
14257 break;
14258 case 4:
14259 SetEvent( start_event );
14260 Sleep( 200 );
14261 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
14262 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE|PM_NOYIELD )) DispatchMessageA( &msg );
14263 break;
14264 case 5:
14265 SetEvent( start_event );
14266 Sleep( 200 );
14267 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
14268 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
14269 break;
14270 case 6:
14271 SetEvent( start_event );
14272 Sleep( 200 );
14273 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
14274 while (PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ))
14275 {
14276 GetMessageA( &msg, 0, 0, 0 );
14277 DispatchMessageA( &msg );
14278 }
14279 break;
14280 case 7:
14281 SetEvent( start_event );
14282 Sleep( 200 );
14283 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
14284 SetTimer( hwnd, 3, 1, NULL );
14285 Sleep( 200 );
14286 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE|PM_NOYIELD )) DispatchMessageA( &msg );
14287 break;
14288 case 8:
14289 SetEvent( start_event );
14290 Sleep( 200 );
14291 PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
14292 MsgWaitForMultipleObjects( 0, NULL, FALSE, 100, QS_ALLINPUT );
14293 break;
14294 case 9:
14295 SetEvent( start_event );
14296 Sleep( 200 );
14297 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
14298 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
14299 for (;;) GetMessageA( &msg, 0, 0, 0 );
14300 break;
14301 case 10:
14302 SetEvent( start_event );
14303 Sleep( 200 );
14304 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
14305 SetTimer( hwnd, 3, 1, NULL );
14306 Sleep( 200 );
14307 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
14308 break;
14309 case 11:
14310 SetEvent( start_event );
14311 Sleep( 200 );
14312 return; /* exiting the process makes WaitForInputIdle return success too */
14313 case 12:
14314 PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
14315 Sleep( 200 );
14316 MsgWaitForMultipleObjects( 0, NULL, FALSE, 100, QS_ALLINPUT );
14317 SetEvent( start_event );
14318 break;
14319 case 13:
14320 SetEvent( start_event );
14321 PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
14322 Sleep( 200 );
14323 thread = CreateThread( NULL, 0, do_wait_idle_child_thread, NULL, 0, &id );
14324 WaitForSingleObject( thread, 10000 );
14325 CloseHandle( thread );
14326 break;
14327 case 14:
14328 SetEvent( start_event );
14329 Sleep( 200 );
14330 PeekMessageA( &msg, HWND_TOPMOST, 0, 0, PM_NOREMOVE );
14331 break;
14332 case 15:
14333 SetEvent( start_event );
14334 Sleep( 200 );
14335 PeekMessageA( &msg, HWND_BROADCAST, 0, 0, PM_NOREMOVE );
14336 break;
14337 case 16:
14338 SetEvent( start_event );
14339 Sleep( 200 );
14340 PeekMessageA( &msg, HWND_BOTTOM, 0, 0, PM_NOREMOVE );
14341 break;
14342 case 17:
14343 SetEvent( start_event );
14344 Sleep( 200 );
14345 PeekMessageA( &msg, (HWND)0xdeadbeef, 0, 0, PM_NOREMOVE );
14346 break;
14347 case 18:
14348 SetEvent( start_event );
14349 Sleep( 200 );
14350 PeekMessageA( &msg, HWND_NOTOPMOST, 0, 0, PM_NOREMOVE );
14351 break;
14352 case 19:
14353 SetEvent( start_event );
14354 Sleep( 200 );
14355 PeekMessageA( &msg, HWND_MESSAGE, 0, 0, PM_NOREMOVE );
14356 break;
14357 case 20:
14358 SetEvent( start_event );
14359 Sleep( 200 );
14360 PeekMessageA( &msg, GetDesktopWindow(), 0, 0, PM_NOREMOVE );
14361 break;
14362 }
14363 WaitForSingleObject( end_event, 2000 );
14364 CloseHandle( start_event );
14365 CloseHandle( end_event );
14366 if (hwnd) DestroyWindow( hwnd );
14367 }
14368
14369 static LRESULT CALLBACK wait_idle_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
14370 {
14371 if (msg == WM_WININICHANGE) Sleep( 200 ); /* make sure the child waits */
14372 return DefWindowProcA( hwnd, msg, wp, lp );
14373 }
14374
14375 static DWORD CALLBACK wait_idle_thread( void *arg )
14376 {
14377 WNDCLASSA cls;
14378 MSG msg;
14379 HWND hwnd;
14380
14381 memset( &cls, 0, sizeof(cls) );
14382 cls.lpfnWndProc = wait_idle_proc;
14383 cls.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
14384 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
14385 cls.lpszClassName = "TestClass";
14386 RegisterClassA( &cls );
14387
14388 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP, 0, 0, 10, 10, 0, 0, 0, NULL);
14389 while (GetMessageA( &msg, 0, 0, 0 )) DispatchMessageA( &msg );
14390 DestroyWindow(hwnd);
14391 return 0;
14392 }
14393
14394 static void test_WaitForInputIdle( char *argv0 )
14395 {
14396 char path[MAX_PATH];
14397 PROCESS_INFORMATION pi;
14398 STARTUPINFOA startup;
14399 BOOL ret;
14400 HANDLE start_event, end_event, thread;
14401 unsigned int i;
14402 DWORD id;
14403 const IMAGE_DOS_HEADER *dos = (const IMAGE_DOS_HEADER *)GetModuleHandleA(0);
14404 const IMAGE_NT_HEADERS *nt = (const IMAGE_NT_HEADERS *)((const char *)dos + dos->e_lfanew);
14405 BOOL console_app = (nt->OptionalHeader.Subsystem != IMAGE_SUBSYSTEM_WINDOWS_GUI);
14406
14407 if (console_app) /* build the test with -mwindows for better coverage */
14408 trace( "not built as a GUI app, WaitForInputIdle may not be fully tested\n" );
14409
14410 start_event = CreateEventA(NULL, 0, 0, "test_WaitForInputIdle_start");
14411 end_event = CreateEventA(NULL, 0, 0, "test_WaitForInputIdle_end");
14412 ok(start_event != 0, "failed to create start event, error %u\n", GetLastError());
14413 ok(end_event != 0, "failed to create end event, error %u\n", GetLastError());
14414
14415 memset( &startup, 0, sizeof(startup) );
14416 startup.cb = sizeof(startup);
14417 startup.dwFlags = STARTF_USESHOWWINDOW;
14418 startup.wShowWindow = SW_SHOWNORMAL;
14419
14420 thread = CreateThread( NULL, 0, wait_idle_thread, NULL, 0, &id );
14421
14422 for (i = 0; i < sizeof(wait_idle_expect)/sizeof(wait_idle_expect[0]); i++)
14423 {
14424 ResetEvent( start_event );
14425 ResetEvent( end_event );
14426 sprintf( path, "%s msg %u", argv0, i );
14427 ret = CreateProcessA( NULL, path, NULL, NULL, TRUE, 0, NULL, NULL, &startup, &pi );
14428 ok( ret, "CreateProcess '%s' failed err %u.\n", path, GetLastError() );
14429 if (ret)
14430 {
14431 ret = WaitForSingleObject( start_event, 5000 );
14432 ok( ret == WAIT_OBJECT_0, "%u: WaitForSingleObject failed\n", i );
14433 if (ret == WAIT_OBJECT_0)
14434 {
14435 ret = WaitForInputIdle( pi.hProcess, 1000 );
14436 if (ret == WAIT_FAILED)
14437 ok( console_app ||
14438 ret == wait_idle_expect[i].exp ||
14439 broken(ret == wait_idle_expect[i].broken),
14440 "%u: WaitForInputIdle error %08x expected %08x\n",
14441 i, ret, wait_idle_expect[i].exp );
14442 else todo_wine_if (wait_idle_expect[i].todo)
14443 ok( ret == wait_idle_expect[i].exp || broken(ret == wait_idle_expect[i].broken),
14444 "%u: WaitForInputIdle error %08x expected %08x\n",
14445 i, ret, wait_idle_expect[i].exp );
14446 SetEvent( end_event );
14447 WaitForSingleObject( pi.hProcess, 1000 ); /* give it a chance to exit on its own */
14448 }
14449 TerminateProcess( pi.hProcess, 0 ); /* just in case */
14450 winetest_wait_child_process( pi.hProcess );
14451 ret = WaitForInputIdle( pi.hProcess, 100 );
14452 ok( ret == WAIT_FAILED, "%u: WaitForInputIdle after exit error %08x\n", i, ret );
14453 CloseHandle( pi.hProcess );
14454 CloseHandle( pi.hThread );
14455 }
14456 }
14457 CloseHandle( start_event );
14458 PostThreadMessageA( id, WM_QUIT, 0, 0 );
14459 WaitForSingleObject( thread, 10000 );
14460 CloseHandle( thread );
14461 }
14462
14463 static const struct message WmSetParentSeq_1[] = {
14464 { WM_SHOWWINDOW, sent|wparam, 0 },
14465 { EVENT_OBJECT_PARENTCHANGE, winevent_hook|wparam|lparam, 0, 0 },
14466 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE },
14467 { WM_CHILDACTIVATE, sent },
14468 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOREDRAW|SWP_NOCLIENTSIZE },
14469 { WM_MOVE, sent|defwinproc|wparam, 0 },
14470 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
14471 { WM_SHOWWINDOW, sent|wparam, 1 },
14472 { 0 }
14473 };
14474
14475 static const struct message WmSetParentSeq_2[] = {
14476 { WM_SHOWWINDOW, sent|wparam, 0 },
14477 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
14478 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
14479 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
14480 { HCBT_SETFOCUS, hook|optional },
14481 { WM_NCACTIVATE, sent|wparam|optional, 0 },
14482 { WM_ACTIVATE, sent|wparam|optional, 0 },
14483 { WM_ACTIVATEAPP, sent|wparam|optional, 0 },
14484 { WM_KILLFOCUS, sent|wparam, 0 },
14485 { EVENT_OBJECT_PARENTCHANGE, winevent_hook|wparam|lparam, 0, 0 },
14486 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE },
14487 { HCBT_ACTIVATE, hook|optional },
14488 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
14489 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
14490 { WM_NCACTIVATE, sent|wparam|optional, 1 },
14491 { WM_ACTIVATE, sent|wparam|optional, 1 },
14492 { HCBT_SETFOCUS, hook|optional },
14493 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
14494 { WM_SETFOCUS, sent|optional|defwinproc },
14495 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOREDRAW|SWP_NOSIZE|SWP_NOCLIENTSIZE },
14496 { WM_MOVE, sent|defwinproc|wparam, 0 },
14497 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
14498 { WM_SHOWWINDOW, sent|wparam, 1 },
14499 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
14500 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
14501 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
14502 { 0 }
14503 };
14504
14505
14506 static void test_SetParent(void)
14507 {
14508 HWND parent1, parent2, child, popup;
14509 RECT rc, rc_old;
14510
14511 parent1 = CreateWindowExA(0, "TestParentClass", NULL, WS_OVERLAPPEDWINDOW,
14512 100, 100, 200, 200, 0, 0, 0, NULL);
14513 ok(parent1 != 0, "Failed to create parent1 window\n");
14514
14515 parent2 = CreateWindowExA(0, "TestParentClass", NULL, WS_OVERLAPPEDWINDOW,
14516 400, 100, 200, 200, 0, 0, 0, NULL);
14517 ok(parent2 != 0, "Failed to create parent2 window\n");
14518
14519 /* WS_CHILD window */
14520 child = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD | WS_VISIBLE,
14521 10, 10, 150, 150, parent1, 0, 0, NULL);
14522 ok(child != 0, "Failed to create child window\n");
14523
14524 GetWindowRect(parent1, &rc);
14525 trace("parent1 (%d,%d)-(%d,%d)\n", rc.left, rc.top, rc.right, rc.bottom);
14526 GetWindowRect(child, &rc_old);
14527 MapWindowPoints(0, parent1, (POINT *)&rc_old, 2);
14528 trace("child (%d,%d)-(%d,%d)\n", rc_old.left, rc_old.top, rc_old.right, rc_old.bottom);
14529
14530 flush_sequence();
14531
14532 SetParent(child, parent2);
14533 flush_events();
14534 ok_sequence(WmSetParentSeq_1, "SetParent() visible WS_CHILD", TRUE);
14535
14536 ok(GetWindowLongA(child, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
14537 ok(!IsWindowVisible(child), "IsWindowVisible() should return FALSE\n");
14538
14539 GetWindowRect(parent2, &rc);
14540 trace("parent2 (%d,%d)-(%d,%d)\n", rc.left, rc.top, rc.right, rc.bottom);
14541 GetWindowRect(child, &rc);
14542 MapWindowPoints(0, parent2, (POINT *)&rc, 2);
14543 trace("child (%d,%d)-(%d,%d)\n", rc.left, rc.top, rc.right, rc.bottom);
14544
14545 ok(EqualRect(&rc_old, &rc), "rects do not match (%d,%d-%d,%d) / (%d,%d-%d,%d)\n",
14546 rc_old.left, rc_old.top, rc_old.right, rc_old.bottom,
14547 rc.left, rc.top, rc.right, rc.bottom );
14548
14549 /* WS_POPUP window */
14550 popup = CreateWindowExA(0, "TestWindowClass", NULL, WS_POPUP | WS_VISIBLE,
14551 20, 20, 100, 100, 0, 0, 0, NULL);
14552 ok(popup != 0, "Failed to create popup window\n");
14553
14554 GetWindowRect(popup, &rc_old);
14555 trace("popup (%d,%d)-(%d,%d)\n", rc_old.left, rc_old.top, rc_old.right, rc_old.bottom);
14556
14557 flush_sequence();
14558
14559 SetParent(popup, child);
14560 flush_events();
14561 ok_sequence(WmSetParentSeq_2, "SetParent() visible WS_POPUP", TRUE);
14562
14563 ok(GetWindowLongA(popup, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
14564 ok(!IsWindowVisible(popup), "IsWindowVisible() should return FALSE\n");
14565
14566 GetWindowRect(child, &rc);
14567 trace("parent2 (%d,%d)-(%d,%d)\n", rc.left, rc.top, rc.right, rc.bottom);
14568 GetWindowRect(popup, &rc);
14569 MapWindowPoints(0, child, (POINT *)&rc, 2);
14570 trace("popup (%d,%d)-(%d,%d)\n", rc.left, rc.top, rc.right, rc.bottom);
14571
14572 ok(EqualRect(&rc_old, &rc), "rects do not match (%d,%d-%d,%d) / (%d,%d-%d,%d)\n",
14573 rc_old.left, rc_old.top, rc_old.right, rc_old.bottom,
14574 rc.left, rc.top, rc.right, rc.bottom );
14575
14576 DestroyWindow(popup);
14577 DestroyWindow(child);
14578 DestroyWindow(parent1);
14579 DestroyWindow(parent2);
14580
14581 flush_sequence();
14582 }
14583
14584 static const struct message WmKeyReleaseOnly[] = {
14585 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 0x41, 0x80000001 },
14586 { WM_KEYUP, sent|wparam|lparam, 0x41, 0x80000001 },
14587 { 0 }
14588 };
14589 static const struct message WmKeyPressNormal[] = {
14590 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 0x41, 0x1 },
14591 { WM_KEYDOWN, sent|wparam|lparam, 0x41, 0x1 },
14592 { 0 }
14593 };
14594 static const struct message WmKeyPressRepeat[] = {
14595 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 0x41, 0x40000001 },
14596 { WM_KEYDOWN, sent|wparam|lparam, 0x41, 0x40000001 },
14597 { 0 }
14598 };
14599 static const struct message WmKeyReleaseNormal[] = {
14600 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 0x41, 0xc0000001 },
14601 { WM_KEYUP, sent|wparam|lparam, 0x41, 0xc0000001 },
14602 { 0 }
14603 };
14604
14605 static void test_keyflags(void)
14606 {
14607 HWND test_window;
14608 SHORT key_state;
14609 BYTE keyboard_state[256];
14610 MSG msg;
14611
14612 test_window = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
14613 100, 100, 200, 200, 0, 0, 0, NULL);
14614
14615 flush_events();
14616 flush_sequence();
14617
14618 /* keyup without a keydown */
14619 keybd_event(0x41, 0, KEYEVENTF_KEYUP, 0);
14620 while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
14621 DispatchMessageA(&msg);
14622 ok_sequence(WmKeyReleaseOnly, "key release only", TRUE);
14623
14624 key_state = GetAsyncKeyState(0x41);
14625 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
14626
14627 key_state = GetKeyState(0x41);
14628 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
14629
14630 /* keydown */
14631 keybd_event(0x41, 0, 0, 0);
14632 while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
14633 DispatchMessageA(&msg);
14634 ok_sequence(WmKeyPressNormal, "key press only", FALSE);
14635
14636 key_state = GetAsyncKeyState(0x41);
14637 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
14638
14639 key_state = GetKeyState(0x41);
14640 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
14641
14642 /* keydown repeat */
14643 keybd_event(0x41, 0, 0, 0);
14644 while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
14645 DispatchMessageA(&msg);
14646 ok_sequence(WmKeyPressRepeat, "key press repeat", FALSE);
14647
14648 key_state = GetAsyncKeyState(0x41);
14649 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
14650
14651 key_state = GetKeyState(0x41);
14652 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
14653
14654 /* keyup */
14655 keybd_event(0x41, 0, KEYEVENTF_KEYUP, 0);
14656 while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
14657 DispatchMessageA(&msg);
14658 ok_sequence(WmKeyReleaseNormal, "key release repeat", FALSE);
14659
14660 key_state = GetAsyncKeyState(0x41);
14661 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
14662
14663 key_state = GetKeyState(0x41);
14664 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
14665
14666 /* set the key state in this thread */
14667 GetKeyboardState(keyboard_state);
14668 keyboard_state[0x41] = 0x80;
14669 SetKeyboardState(keyboard_state);
14670
14671 key_state = GetAsyncKeyState(0x41);
14672 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
14673
14674 /* keydown */
14675 keybd_event(0x41, 0, 0, 0);
14676 while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
14677 DispatchMessageA(&msg);
14678 ok_sequence(WmKeyPressRepeat, "key press after setkeyboardstate", TRUE);
14679
14680 key_state = GetAsyncKeyState(0x41);
14681 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
14682
14683 key_state = GetKeyState(0x41);
14684 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
14685
14686 /* clear the key state in this thread */
14687 GetKeyboardState(keyboard_state);
14688 keyboard_state[0x41] = 0;
14689 SetKeyboardState(keyboard_state);
14690
14691 key_state = GetAsyncKeyState(0x41);
14692 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
14693
14694 /* keyup */
14695 keybd_event(0x41, 0, KEYEVENTF_KEYUP, 0);
14696 while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
14697 DispatchMessageA(&msg);
14698 ok_sequence(WmKeyReleaseOnly, "key release after setkeyboardstate", TRUE);
14699
14700 key_state = GetAsyncKeyState(0x41);
14701 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
14702
14703 key_state = GetKeyState(0x41);
14704 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
14705
14706 DestroyWindow(test_window);
14707 flush_sequence();
14708 }
14709
14710 static const struct message WmHotkeyPressLWIN[] = {
14711 { WM_KEYDOWN, kbd_hook|wparam|lparam, VK_LWIN, LLKHF_INJECTED },
14712 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_LWIN, 1 },
14713 { WM_KEYDOWN, sent|wparam|lparam, VK_LWIN, 1 },
14714 { 0 }
14715 };
14716 static const struct message WmHotkeyPress[] = {
14717 { WM_KEYDOWN, kbd_hook|lparam, 0, LLKHF_INJECTED },
14718 { WM_HOTKEY, sent|wparam, 5 },
14719 { 0 }
14720 };
14721 static const struct message WmHotkeyRelease[] = {
14722 { WM_KEYUP, kbd_hook|lparam, 0, LLKHF_INJECTED|LLKHF_UP },
14723 { HCBT_KEYSKIPPED, hook|lparam|optional, 0, 0x80000001 },
14724 { WM_KEYUP, sent|lparam, 0, 0x80000001 },
14725 { 0 }
14726 };
14727 static const struct message WmHotkeyReleaseLWIN[] = {
14728 { WM_KEYUP, kbd_hook|wparam|lparam, VK_LWIN, LLKHF_INJECTED|LLKHF_UP },
14729 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_LWIN, 0xc0000001 },
14730 { WM_KEYUP, sent|wparam|lparam, VK_LWIN, 0xc0000001 },
14731 { 0 }
14732 };
14733 static const struct message WmHotkeyCombined[] = {
14734 { WM_KEYDOWN, kbd_hook|wparam|lparam, VK_LWIN, LLKHF_INJECTED },
14735 { WM_KEYDOWN, kbd_hook|lparam, 0, LLKHF_INJECTED },
14736 { WM_KEYUP, kbd_hook|lparam, 0, LLKHF_INJECTED|LLKHF_UP },
14737 { WM_KEYUP, kbd_hook|wparam|lparam, VK_LWIN, LLKHF_INJECTED|LLKHF_UP },
14738 { WM_APP, sent, 0, 0 },
14739 { WM_HOTKEY, sent|wparam, 5 },
14740 { WM_APP+1, sent, 0, 0 },
14741 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_LWIN, 1 },
14742 { WM_KEYDOWN, sent|wparam|lparam, VK_LWIN, 1 },
14743 { HCBT_KEYSKIPPED, hook|optional, 0, 0x80000001 },
14744 { WM_KEYUP, sent, 0, 0x80000001 }, /* lparam not checked so the sequence isn't a todo */
14745 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_LWIN, 0xc0000001 },
14746 { WM_KEYUP, sent|wparam|lparam, VK_LWIN, 0xc0000001 },
14747 { 0 }
14748 };
14749 static const struct message WmHotkeyPrevious[] = {
14750 { WM_KEYDOWN, kbd_hook|wparam|lparam, VK_LWIN, LLKHF_INJECTED },
14751 { WM_KEYDOWN, kbd_hook|lparam, 0, LLKHF_INJECTED },
14752 { WM_KEYUP, kbd_hook|lparam, 0, LLKHF_INJECTED|LLKHF_UP },
14753 { WM_KEYUP, kbd_hook|wparam|lparam, VK_LWIN, LLKHF_INJECTED|LLKHF_UP },
14754 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_LWIN, 1 },
14755 { WM_KEYDOWN, sent|wparam|lparam, VK_LWIN, 1 },
14756 { HCBT_KEYSKIPPED, hook|lparam|optional, 0, 1 },
14757 { WM_KEYDOWN, sent|lparam, 0, 1 },
14758 { HCBT_KEYSKIPPED, hook|optional|lparam, 0, 0xc0000001 },
14759 { WM_KEYUP, sent|lparam, 0, 0xc0000001 },
14760 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_LWIN, 0xc0000001 },
14761 { WM_KEYUP, sent|wparam|lparam, VK_LWIN, 0xc0000001 },
14762 { 0 }
14763 };
14764 static const struct message WmHotkeyNew[] = {
14765 { WM_KEYDOWN, kbd_hook|lparam, 0, LLKHF_INJECTED },
14766 { WM_KEYUP, kbd_hook|lparam, 0, LLKHF_INJECTED|LLKHF_UP },
14767 { WM_HOTKEY, sent|wparam, 5 },
14768 { HCBT_KEYSKIPPED, hook|optional, 0, 0x80000001 },
14769 { WM_KEYUP, sent, 0, 0x80000001 }, /* lparam not checked so the sequence isn't a todo */
14770 { 0 }
14771 };
14772
14773 static int hotkey_letter;
14774
14775 static LRESULT CALLBACK KeyboardHookProc(int nCode, WPARAM wParam, LPARAM lParam)
14776 {
14777 struct recvd_message msg;
14778
14779 if (nCode == HC_ACTION)
14780 {
14781 KBDLLHOOKSTRUCT *kdbhookstruct = (KBDLLHOOKSTRUCT*)lParam;
14782
14783 msg.hwnd = 0;
14784 msg.message = wParam;
14785 msg.flags = kbd_hook|wparam|lparam;
14786 msg.wParam = kdbhookstruct->vkCode;
14787 msg.lParam = kdbhookstruct->flags;
14788 msg.descr = "KeyboardHookProc";
14789 add_message(&msg);
14790
14791 if (wParam == WM_KEYUP || wParam == WM_KEYDOWN)
14792 {
14793 ok(kdbhookstruct->vkCode == VK_LWIN || kdbhookstruct->vkCode == hotkey_letter,
14794 "unexpected keycode %x\n", kdbhookstruct->vkCode);
14795 }
14796 }
14797
14798 return CallNextHookEx(hKBD_hook, nCode, wParam, lParam);
14799 }
14800
14801 static void test_hotkey(void)
14802 {
14803 HWND test_window, taskbar_window;
14804 BOOL ret;
14805 MSG msg;
14806 DWORD queue_status;
14807 SHORT key_state;
14808
14809 SetLastError(0xdeadbeef);
14810 ret = UnregisterHotKey(NULL, 0);
14811 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
14812 ok(GetLastError() == ERROR_HOTKEY_NOT_REGISTERED || broken(GetLastError() == 0xdeadbeef),
14813 "unexpected error %d\n", GetLastError());
14814
14815 if (ret == TRUE)
14816 {
14817 skip("hotkeys not supported\n");
14818 return;
14819 }
14820
14821 test_window = CreateWindowExA(0, "HotkeyWindowClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
14822 100, 100, 200, 200, 0, 0, 0, NULL);
14823
14824 flush_sequence();
14825
14826 SetLastError(0xdeadbeef);
14827 ret = UnregisterHotKey(test_window, 0);
14828 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
14829 ok(GetLastError() == ERROR_HOTKEY_NOT_REGISTERED || broken(GetLastError() == 0xdeadbeef),
14830 "unexpected error %d\n", GetLastError());
14831
14832 /* Search for a Windows Key + letter combination that hasn't been registered */
14833 for (hotkey_letter = 0x41; hotkey_letter <= 0x51; hotkey_letter ++)
14834 {
14835 SetLastError(0xdeadbeef);
14836 ret = RegisterHotKey(test_window, 5, MOD_WIN, hotkey_letter);
14837
14838 if (ret == TRUE)
14839 {
14840 break;
14841 }
14842 else
14843 {
14844 ok(GetLastError() == ERROR_HOTKEY_ALREADY_REGISTERED || broken(GetLastError() == 0xdeadbeef),
14845 "unexpected error %d\n", GetLastError());
14846 }
14847 }
14848
14849 if (hotkey_letter == 0x52)
14850 {
14851 ok(0, "Couldn't find any free Windows Key + letter combination\n");
14852 goto end;
14853 }
14854
14855 hKBD_hook = SetWindowsHookExA(WH_KEYBOARD_LL, KeyboardHookProc, GetModuleHandleA(NULL), 0);
14856 if (!hKBD_hook) win_skip("WH_KEYBOARD_LL is not supported\n");
14857
14858 /* Same key combination, different id */
14859 SetLastError(0xdeadbeef);
14860 ret = RegisterHotKey(test_window, 4, MOD_WIN, hotkey_letter);
14861 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
14862 ok(GetLastError() == ERROR_HOTKEY_ALREADY_REGISTERED || broken(GetLastError() == 0xdeadbeef),
14863 "unexpected error %d\n", GetLastError());
14864
14865 /* Same key combination, different window */
14866 SetLastError(0xdeadbeef);
14867 ret = RegisterHotKey(NULL, 5, MOD_WIN, hotkey_letter);
14868 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
14869 ok(GetLastError() == ERROR_HOTKEY_ALREADY_REGISTERED || broken(GetLastError() == 0xdeadbeef),
14870 "unexpected error %d\n", GetLastError());
14871
14872 /* Register the same hotkey twice */
14873 SetLastError(0xdeadbeef);
14874 ret = RegisterHotKey(test_window, 5, MOD_WIN, hotkey_letter);
14875 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
14876 ok(GetLastError() == ERROR_HOTKEY_ALREADY_REGISTERED || broken(GetLastError() == 0xdeadbeef),
14877 "unexpected error %d\n", GetLastError());
14878
14879 /* Window on another thread */
14880 taskbar_window = FindWindowA("Shell_TrayWnd", NULL);
14881 if (!taskbar_window)
14882 {
14883 skip("no taskbar?\n");
14884 }
14885 else
14886 {
14887 SetLastError(0xdeadbeef);
14888 ret = RegisterHotKey(taskbar_window, 5, 0, hotkey_letter);
14889 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
14890 ok(GetLastError() == ERROR_WINDOW_OF_OTHER_THREAD || broken(GetLastError() == 0xdeadbeef),
14891 "unexpected error %d\n", GetLastError());
14892 }
14893
14894 /* Inject the appropriate key sequence */
14895 keybd_event(VK_LWIN, 0, 0, 0);
14896 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
14897 DispatchMessageA(&msg);
14898 ok_sequence(WmHotkeyPressLWIN, "window hotkey press LWIN", FALSE);
14899
14900 keybd_event(hotkey_letter, 0, 0, 0);
14901 queue_status = GetQueueStatus(QS_HOTKEY);
14902 ok((queue_status & (QS_HOTKEY << 16)) == QS_HOTKEY << 16, "expected QS_HOTKEY << 16 set, got %x\n", queue_status);
14903 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
14904 {
14905 if (msg.message == WM_HOTKEY)
14906 {
14907 ok(msg.hwnd == test_window, "unexpected hwnd %p\n", msg.hwnd);
14908 ok(msg.lParam == MAKELPARAM(MOD_WIN, hotkey_letter), "unexpected WM_HOTKEY lparam %lx\n", msg.lParam);
14909 }
14910 DispatchMessageA(&msg);
14911 }
14912 ok_sequence(WmHotkeyPress, "window hotkey press", FALSE);
14913
14914 queue_status = GetQueueStatus(QS_HOTKEY);
14915 ok((queue_status & (QS_HOTKEY << 16)) == 0, "expected QS_HOTKEY << 16 cleared, got %x\n", queue_status);
14916
14917 key_state = GetAsyncKeyState(hotkey_letter);
14918 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
14919
14920 keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
14921 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
14922 DispatchMessageA(&msg);
14923 ok_sequence(WmHotkeyRelease, "window hotkey release", TRUE);
14924
14925 keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);
14926 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
14927 DispatchMessageA(&msg);
14928 ok_sequence(WmHotkeyReleaseLWIN, "window hotkey release LWIN", FALSE);
14929
14930 /* normal posted WM_HOTKEY messages set QS_HOTKEY */
14931 PostMessageA(test_window, WM_HOTKEY, 0, 0);
14932 queue_status = GetQueueStatus(QS_HOTKEY);
14933 ok((queue_status & (QS_HOTKEY << 16)) == QS_HOTKEY << 16, "expected QS_HOTKEY << 16 set, got %x\n", queue_status);
14934 queue_status = GetQueueStatus(QS_POSTMESSAGE);
14935 ok((queue_status & (QS_POSTMESSAGE << 16)) == QS_POSTMESSAGE << 16, "expected QS_POSTMESSAGE << 16 set, got %x\n", queue_status);
14936 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
14937 DispatchMessageA(&msg);
14938 flush_sequence();
14939
14940 /* Send and process all messages at once */
14941 PostMessageA(test_window, WM_APP, 0, 0);
14942 keybd_event(VK_LWIN, 0, 0, 0);
14943 keybd_event(hotkey_letter, 0, 0, 0);
14944 keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
14945 keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);
14946
14947 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
14948 {
14949 if (msg.message == WM_HOTKEY)
14950 {
14951 ok(msg.hwnd == test_window, "unexpected hwnd %p\n", msg.hwnd);
14952 ok(msg.lParam == MAKELPARAM(MOD_WIN, hotkey_letter), "unexpected WM_HOTKEY lparam %lx\n", msg.lParam);
14953 }
14954 DispatchMessageA(&msg);
14955 }
14956 ok_sequence(WmHotkeyCombined, "window hotkey combined", FALSE);
14957
14958 /* Register same hwnd/id with different key combination */
14959 ret = RegisterHotKey(test_window, 5, 0, hotkey_letter);
14960 ok(ret == TRUE, "expected TRUE, got %i, err=%d\n", ret, GetLastError());
14961
14962 /* Previous key combination does not work */
14963 keybd_event(VK_LWIN, 0, 0, 0);
14964 keybd_event(hotkey_letter, 0, 0, 0);
14965 keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
14966 keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);
14967
14968 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
14969 DispatchMessageA(&msg);
14970 ok_sequence(WmHotkeyPrevious, "window hotkey previous", FALSE);
14971
14972 /* New key combination works */
14973 keybd_event(hotkey_letter, 0, 0, 0);
14974 keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
14975
14976 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
14977 {
14978 if (msg.message == WM_HOTKEY)
14979 {
14980 ok(msg.hwnd == test_window, "unexpected hwnd %p\n", msg.hwnd);
14981 ok(msg.lParam == MAKELPARAM(0, hotkey_letter), "unexpected WM_HOTKEY lparam %lx\n", msg.lParam);
14982 }
14983 DispatchMessageA(&msg);
14984 }
14985 ok_sequence(WmHotkeyNew, "window hotkey new", FALSE);
14986
14987 /* Unregister hotkey properly */
14988 ret = UnregisterHotKey(test_window, 5);
14989 ok(ret == TRUE, "expected TRUE, got %i, err=%d\n", ret, GetLastError());
14990
14991 /* Unregister hotkey again */
14992 SetLastError(0xdeadbeef);
14993 ret = UnregisterHotKey(test_window, 5);
14994 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
14995 ok(GetLastError() == ERROR_HOTKEY_NOT_REGISTERED || broken(GetLastError() == 0xdeadbeef),
14996 "unexpected error %d\n", GetLastError());
14997
14998 /* Register thread hotkey */
14999 ret = RegisterHotKey(NULL, 5, MOD_WIN, hotkey_letter);
15000 ok(ret == TRUE, "expected TRUE, got %i, err=%d\n", ret, GetLastError());
15001
15002 /* Inject the appropriate key sequence */
15003 keybd_event(VK_LWIN, 0, 0, 0);
15004 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
15005 {
15006 ok(msg.hwnd != NULL, "unexpected thread message %x\n", msg.message);
15007 DispatchMessageA(&msg);
15008 }
15009 ok_sequence(WmHotkeyPressLWIN, "thread hotkey press LWIN", FALSE);
15010
15011 keybd_event(hotkey_letter, 0, 0, 0);
15012 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
15013 {
15014 if (msg.message == WM_HOTKEY)
15015 {
15016 struct recvd_message message;
15017 ok(msg.hwnd == NULL, "unexpected hwnd %p\n", msg.hwnd);
15018 ok(msg.lParam == MAKELPARAM(MOD_WIN, hotkey_letter), "unexpected WM_HOTKEY lparam %lx\n", msg.lParam);
15019 message.message = msg.message;
15020 message.flags = sent|wparam|lparam;
15021 message.wParam = msg.wParam;
15022 message.lParam = msg.lParam;
15023 message.descr = "test_hotkey thread message";
15024 add_message(&message);
15025 }
15026 else
15027 ok(msg.hwnd != NULL, "unexpected thread message %x\n", msg.message);
15028 DispatchMessageA(&msg);
15029 }
15030 ok_sequence(WmHotkeyPress, "thread hotkey press", FALSE);
15031
15032 keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
15033 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
15034 {
15035 ok(msg.hwnd != NULL, "unexpected thread message %x\n", msg.message);
15036 DispatchMessageA(&msg);
15037 }
15038 ok_sequence(WmHotkeyRelease, "thread hotkey release", TRUE);
15039
15040 keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);
15041 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
15042 {
15043 ok(msg.hwnd != NULL, "unexpected thread message %x\n", msg.message);
15044 DispatchMessageA(&msg);
15045 }
15046 ok_sequence(WmHotkeyReleaseLWIN, "thread hotkey release LWIN", FALSE);
15047
15048 /* Unregister thread hotkey */
15049 ret = UnregisterHotKey(NULL, 5);
15050 ok(ret == TRUE, "expected TRUE, got %i, err=%d\n", ret, GetLastError());
15051
15052 if (hKBD_hook) UnhookWindowsHookEx(hKBD_hook);
15053 hKBD_hook = NULL;
15054
15055 end:
15056 UnregisterHotKey(NULL, 5);
15057 UnregisterHotKey(test_window, 5);
15058 DestroyWindow(test_window);
15059 flush_sequence();
15060 }
15061
15062
15063 static const struct message WmSetFocus_1[] = {
15064 { HCBT_SETFOCUS, hook }, /* child */
15065 { HCBT_ACTIVATE, hook }, /* parent */
15066 { WM_QUERYNEWPALETTE, sent|wparam|lparam|parent|optional, 0, 0 },
15067 { WM_WINDOWPOSCHANGING, sent|parent, 0, SWP_NOSIZE|SWP_NOMOVE },
15068 { WM_ACTIVATEAPP, sent|wparam|parent, 1 },
15069 { WM_NCACTIVATE, sent|parent },
15070 { WM_GETTEXT, sent|defwinproc|parent|optional },
15071 { WM_GETTEXT, sent|defwinproc|parent|optional },
15072 { WM_ACTIVATE, sent|wparam|parent, 1 },
15073 { HCBT_SETFOCUS, hook }, /* parent */
15074 { WM_SETFOCUS, sent|defwinproc|parent },
15075 { WM_KILLFOCUS, sent|parent },
15076 { WM_SETFOCUS, sent },
15077 { 0 }
15078 };
15079 static const struct message WmSetFocus_2[] = {
15080 { HCBT_SETFOCUS, hook }, /* parent */
15081 { WM_KILLFOCUS, sent },
15082 { WM_SETFOCUS, sent|parent },
15083 { 0 }
15084 };
15085 static const struct message WmSetFocus_3[] = {
15086 { HCBT_SETFOCUS, hook }, /* child */
15087 { 0 }
15088 };
15089
15090 static void test_SetFocus(void)
15091 {
15092 HWND parent, old_parent, child, old_focus, old_active;
15093 MSG msg;
15094 struct wnd_event wnd_event;
15095 HANDLE hthread;
15096 DWORD ret, tid;
15097
15098 wnd_event.start_event = CreateEventW(NULL, 0, 0, NULL);
15099 ok(wnd_event.start_event != 0, "CreateEvent error %d\n", GetLastError());
15100 hthread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
15101 ok(hthread != 0, "CreateThread error %d\n", GetLastError());
15102 ret = WaitForSingleObject(wnd_event.start_event, INFINITE);
15103 ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
15104 CloseHandle(wnd_event.start_event);
15105
15106 parent = CreateWindowExA(0, "TestParentClass", NULL, WS_OVERLAPPEDWINDOW,
15107 0, 0, 0, 0, 0, 0, 0, NULL);
15108 ok(parent != 0, "failed to create parent window\n");
15109 child = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
15110 0, 0, 0, 0, parent, 0, 0, NULL);
15111 ok(child != 0, "failed to create child window\n");
15112
15113 trace("parent %p, child %p, thread window %p\n", parent, child, wnd_event.hwnd);
15114
15115 SetFocus(0);
15116 SetActiveWindow(0);
15117
15118 flush_events();
15119 flush_sequence();
15120
15121 ok(GetActiveWindow() == 0, "expected active 0, got %p\n", GetActiveWindow());
15122 ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
15123
15124 log_all_parent_messages++;
15125
15126 old_focus = SetFocus(child);
15127 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15128 ok_sequence(WmSetFocus_1, "SetFocus on a child window", TRUE);
15129 ok(old_focus == parent, "expected old focus %p, got %p\n", parent, old_focus);
15130 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15131 ok(GetFocus() == child, "expected focus %p, got %p\n", child, GetFocus());
15132
15133 old_focus = SetFocus(parent);
15134 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15135 ok_sequence(WmSetFocus_2, "SetFocus on a parent window", FALSE);
15136 ok(old_focus == child, "expected old focus %p, got %p\n", child, old_focus);
15137 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15138 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15139
15140 SetLastError(0xdeadbeef);
15141 old_focus = SetFocus((HWND)0xdeadbeef);
15142 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || broken(GetLastError() == 0xdeadbeef),
15143 "expected ERROR_INVALID_WINDOW_HANDLE, got %d\n", GetLastError());
15144 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15145 ok_sequence(WmEmptySeq, "SetFocus on an invalid window", FALSE);
15146 ok(old_focus == 0, "expected old focus 0, got %p\n", old_focus);
15147 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15148 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15149
15150 SetLastError(0xdeadbeef);
15151 old_focus = SetFocus(GetDesktopWindow());
15152 ok(GetLastError() == ERROR_ACCESS_DENIED /* Vista+ */ ||
15153 broken(GetLastError() == 0xdeadbeef), "expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
15154 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15155 ok_sequence(WmEmptySeq, "SetFocus on a desktop window", TRUE);
15156 ok(old_focus == 0, "expected old focus 0, got %p\n", old_focus);
15157 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15158 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15159
15160 SetLastError(0xdeadbeef);
15161 old_focus = SetFocus(wnd_event.hwnd);
15162 ok(GetLastError() == ERROR_ACCESS_DENIED /* Vista+ */ ||
15163 broken(GetLastError() == 0xdeadbeef), "expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
15164 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15165 ok_sequence(WmEmptySeq, "SetFocus on another thread window", TRUE);
15166 ok(old_focus == 0, "expected old focus 0, got %p\n", old_focus);
15167 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15168 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15169
15170 SetLastError(0xdeadbeef);
15171 old_active = SetActiveWindow((HWND)0xdeadbeef);
15172 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || broken(GetLastError() == 0xdeadbeef),
15173 "expected ERROR_INVALID_WINDOW_HANDLE, got %d\n", GetLastError());
15174 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15175 ok_sequence(WmEmptySeq, "SetActiveWindow on an invalid window", FALSE);
15176 ok(old_active == 0, "expected old focus 0, got %p\n", old_active);
15177 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15178 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15179
15180 SetLastError(0xdeadbeef);
15181 old_active = SetActiveWindow(GetDesktopWindow());
15182 todo_wine
15183 ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
15184 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15185 ok_sequence(WmEmptySeq, "SetActiveWindow on a desktop window", TRUE);
15186 ok(old_active == 0, "expected old focus 0, got %p\n", old_focus);
15187 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15188 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15189
15190 SetLastError(0xdeadbeef);
15191 old_active = SetActiveWindow(wnd_event.hwnd);
15192 todo_wine
15193 ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
15194 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15195 ok_sequence(WmEmptySeq, "SetActiveWindow on another thread window", TRUE);
15196 ok(old_active == 0, "expected old focus 0, got %p\n", old_active);
15197 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15198 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15199
15200 SetLastError(0xdeadbeef);
15201 ret = AttachThreadInput(GetCurrentThreadId(), tid, TRUE);
15202 ok(ret, "AttachThreadInput error %d\n", GetLastError());
15203
15204 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15205 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15206
15207 flush_events();
15208 flush_sequence();
15209
15210 old_focus = SetFocus(wnd_event.hwnd);
15211 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15212 ok(old_focus == wnd_event.hwnd, "expected old focus %p, got %p\n", wnd_event.hwnd, old_focus);
15213 ok(GetActiveWindow() == wnd_event.hwnd, "expected active %p, got %p\n", wnd_event.hwnd, GetActiveWindow());
15214 ok(GetFocus() == wnd_event.hwnd, "expected focus %p, got %p\n", wnd_event.hwnd, GetFocus());
15215
15216 old_focus = SetFocus(parent);
15217 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15218 ok(old_focus == parent, "expected old focus %p, got %p\n", parent, old_focus);
15219 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15220 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15221
15222 flush_events();
15223 flush_sequence();
15224
15225 old_active = SetActiveWindow(wnd_event.hwnd);
15226 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15227 ok(old_active == parent, "expected old focus %p, got %p\n", parent, old_active);
15228 ok(GetActiveWindow() == wnd_event.hwnd, "expected active %p, got %p\n", wnd_event.hwnd, GetActiveWindow());
15229 ok(GetFocus() == wnd_event.hwnd, "expected focus %p, got %p\n", wnd_event.hwnd, GetFocus());
15230
15231 SetLastError(0xdeadbeef);
15232 ret = AttachThreadInput(GetCurrentThreadId(), tid, FALSE);
15233 ok(ret, "AttachThreadInput error %d\n", GetLastError());
15234
15235 ok(GetActiveWindow() == 0, "expected active 0, got %p\n", GetActiveWindow());
15236 ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
15237
15238 old_parent = SetParent(child, GetDesktopWindow());
15239 ok(old_parent == parent, "expected old parent %p, got %p\n", parent, old_parent);
15240
15241 ok(GetActiveWindow() == 0, "expected active 0, got %p\n", GetActiveWindow());
15242 ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
15243
15244 old_focus = SetFocus(parent);
15245 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15246 ok(old_focus == parent, "expected old focus %p, got %p\n", parent, 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 flush_events();
15251 flush_sequence();
15252
15253 SetLastError(0xdeadbeef);
15254 old_focus = SetFocus(child);
15255 todo_wine
15256 ok(GetLastError() == ERROR_INVALID_PARAMETER /* Vista+ */ ||
15257 broken(GetLastError() == 0) /* XP */ ||
15258 broken(GetLastError() == 0xdeadbeef), "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
15259 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15260 ok_sequence(WmSetFocus_3, "SetFocus on a child window", TRUE);
15261 ok(old_focus == 0, "expected old focus 0, got %p\n", old_focus);
15262 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15263 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15264
15265 SetLastError(0xdeadbeef);
15266 old_active = SetActiveWindow(child);
15267 ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
15268 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
15269 ok_sequence(WmEmptySeq, "SetActiveWindow on a child window", FALSE);
15270 ok(old_active == parent, "expected old active %p, got %p\n", parent, old_active);
15271 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
15272 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
15273
15274 log_all_parent_messages--;
15275
15276 DestroyWindow(child);
15277 DestroyWindow(parent);
15278
15279 ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
15280 ok(ret, "PostMessage(WM_QUIT) error %d\n", GetLastError());
15281 ret = WaitForSingleObject(hthread, INFINITE);
15282 ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
15283 CloseHandle(hthread);
15284 }
15285
15286 static const struct message WmSetLayeredStyle[] = {
15287 { WM_STYLECHANGING, sent },
15288 { WM_STYLECHANGED, sent },
15289 { WM_GETTEXT, sent|defwinproc|optional },
15290 { 0 }
15291 };
15292
15293 static const struct message WmSetLayeredStyle2[] = {
15294 { WM_STYLECHANGING, sent },
15295 { WM_STYLECHANGED, sent },
15296 { WM_WINDOWPOSCHANGING, sent|optional|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
15297 { WM_NCCALCSIZE, sent|optional|wparam|defwinproc, 1 },
15298 { WM_WINDOWPOSCHANGED, sent|optional|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
15299 { WM_MOVE, sent|optional|defwinproc|wparam, 0 },
15300 { WM_SIZE, sent|optional|defwinproc|wparam, SIZE_RESTORED },
15301 { 0 }
15302 };
15303
15304 struct layered_window_info
15305 {
15306 HWND hwnd;
15307 HDC hdc;
15308 SIZE size;
15309 HANDLE event;
15310 BOOL ret;
15311 };
15312
15313 static DWORD CALLBACK update_layered_proc( void *param )
15314 {
15315 struct layered_window_info *info = param;
15316 POINT src = { 0, 0 };
15317
15318 info->ret = pUpdateLayeredWindow( info->hwnd, 0, NULL, &info->size,
15319 info->hdc, &src, 0, NULL, ULW_OPAQUE );
15320 ok( info->ret, "failed\n");
15321 SetEvent( info->event );
15322 return 0;
15323 }
15324
15325 static void test_layered_window(void)
15326 {
15327 HWND hwnd;
15328 HDC hdc;
15329 HBITMAP bmp;
15330 BOOL ret;
15331 SIZE size;
15332 POINT pos, src;
15333 RECT rect, client;
15334 HANDLE thread;
15335 DWORD tid;
15336 struct layered_window_info info;
15337
15338 if (!pUpdateLayeredWindow)
15339 {
15340 win_skip( "UpdateLayeredWindow not supported\n" );
15341 return;
15342 }
15343
15344 hdc = CreateCompatibleDC( 0 );
15345 bmp = CreateCompatibleBitmap( hdc, 300, 300 );
15346 SelectObject( hdc, bmp );
15347
15348 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_CAPTION | WS_THICKFRAME | WS_SYSMENU,
15349 100, 100, 300, 300, 0, 0, 0, NULL);
15350 ok( hwnd != 0, "failed to create window\n" );
15351 ShowWindow( hwnd, SW_SHOWNORMAL );
15352 UpdateWindow( hwnd );
15353 flush_events();
15354 flush_sequence();
15355
15356 GetWindowRect( hwnd, &rect );
15357 GetClientRect( hwnd, &client );
15358 ok( client.right < rect.right - rect.left, "wrong client area\n" );
15359 ok( client.bottom < rect.bottom - rect.top, "wrong client area\n" );
15360
15361 src.x = src.y = 0;
15362 pos.x = pos.y = 300;
15363 size.cx = size.cy = 250;
15364 ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
15365 ok( !ret, "UpdateLayeredWindow should fail on non-layered window\n" );
15366 ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError() );
15367 SetWindowLongA( hwnd, GWL_EXSTYLE, GetWindowLongA(hwnd, GWL_EXSTYLE) | WS_EX_LAYERED );
15368 ok_sequence( WmSetLayeredStyle, "WmSetLayeredStyle", FALSE );
15369
15370 ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
15371 ok( ret, "UpdateLayeredWindow failed err %u\n", GetLastError() );
15372 ok_sequence( WmEmptySeq, "UpdateLayeredWindow", FALSE );
15373 GetWindowRect( hwnd, &rect );
15374 ok( rect.left == 300 && rect.top == 300 && rect.right == 550 && rect.bottom == 550,
15375 "wrong window rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15376 GetClientRect( hwnd, &rect );
15377 ok( rect.right == client.right - 50 && rect.bottom == client.bottom - 50,
15378 "wrong client rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15379
15380 size.cx = 150;
15381 pos.y = 200;
15382 ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
15383 ok( ret, "UpdateLayeredWindow failed err %u\n", GetLastError() );
15384 ok_sequence( WmEmptySeq, "UpdateLayeredWindow", FALSE );
15385 GetWindowRect( hwnd, &rect );
15386 ok( rect.left == 300 && rect.top == 200 && rect.right == 450 && rect.bottom == 450,
15387 "wrong window rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15388 GetClientRect( hwnd, &rect );
15389 ok( rect.right == client.right - 150 && rect.bottom == client.bottom - 50,
15390 "wrong client rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15391
15392 SetWindowLongA( hwnd, GWL_STYLE,
15393 GetWindowLongA(hwnd, GWL_STYLE) & ~(WS_CAPTION | WS_THICKFRAME | WS_SYSMENU) );
15394 ok_sequence( WmSetLayeredStyle2, "WmSetLayeredStyle2", FALSE );
15395
15396 size.cx = 200;
15397 pos.x = 200;
15398 ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
15399 ok( ret, "UpdateLayeredWindow failed err %u\n", GetLastError() );
15400 ok_sequence( WmEmptySeq, "UpdateLayeredWindow", FALSE );
15401 GetWindowRect( hwnd, &rect );
15402 ok( rect.left == 200 && rect.top == 200 && rect.right == 400 && rect.bottom == 450,
15403 "wrong window rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15404 GetClientRect( hwnd, &rect );
15405 ok( (rect.right == 200 && rect.bottom == 250) ||
15406 broken(rect.right == client.right - 100 && rect.bottom == client.bottom - 50),
15407 "wrong client rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15408
15409 size.cx = 0;
15410 ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
15411 ok( !ret, "UpdateLayeredWindow should fail on non-layered window\n" );
15412 ok( GetLastError() == ERROR_INVALID_PARAMETER || broken(ERROR_MR_MID_NOT_FOUND) /* win7 */,
15413 "wrong error %u\n", GetLastError() );
15414 size.cx = 1;
15415 size.cy = -1;
15416 ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
15417 ok( !ret, "UpdateLayeredWindow should fail on non-layered window\n" );
15418 ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError() );
15419
15420 SetWindowLongA( hwnd, GWL_EXSTYLE, GetWindowLongA(hwnd, GWL_EXSTYLE) & ~WS_EX_LAYERED );
15421 ok_sequence( WmSetLayeredStyle, "WmSetLayeredStyle", FALSE );
15422 GetWindowRect( hwnd, &rect );
15423 ok( rect.left == 200 && rect.top == 200 && rect.right == 400 && rect.bottom == 450,
15424 "wrong window rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15425 GetClientRect( hwnd, &rect );
15426 ok( (rect.right == 200 && rect.bottom == 250) ||
15427 broken(rect.right == client.right - 100 && rect.bottom == client.bottom - 50),
15428 "wrong client rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15429
15430 SetWindowLongA( hwnd, GWL_EXSTYLE, GetWindowLongA(hwnd, GWL_EXSTYLE) | WS_EX_LAYERED );
15431 info.hwnd = hwnd;
15432 info.hdc = hdc;
15433 info.size.cx = 250;
15434 info.size.cy = 300;
15435 info.event = CreateEventA( NULL, TRUE, FALSE, NULL );
15436 info.ret = FALSE;
15437 thread = CreateThread( NULL, 0, update_layered_proc, &info, 0, &tid );
15438 ok( WaitForSingleObject( info.event, 1000 ) == 0, "wait failed\n" );
15439 ok( info.ret, "UpdateLayeredWindow failed in other thread\n" );
15440 WaitForSingleObject( thread, 1000 );
15441 CloseHandle( thread );
15442 GetWindowRect( hwnd, &rect );
15443 ok( rect.left == 200 && rect.top == 200 && rect.right == 450 && rect.bottom == 500,
15444 "wrong window rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15445 GetClientRect( hwnd, &rect );
15446 ok( (rect.right == 250 && rect.bottom == 300) ||
15447 broken(rect.right == client.right - 50 && rect.bottom == client.bottom),
15448 "wrong client rect %d,%d,%d,%d\n", rect.left, rect.top, rect.right, rect.bottom );
15449
15450 DestroyWindow( hwnd );
15451 DeleteDC( hdc );
15452 DeleteObject( bmp );
15453 }
15454
15455 static HMENU hpopupmenu;
15456
15457 static LRESULT WINAPI cancel_popup_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
15458 {
15459 if (ignore_message( message )) return 0;
15460
15461 switch (message) {
15462 case WM_ENTERIDLE:
15463 todo_wine ok(GetCapture() == hwnd, "expected %p, got %p\n", hwnd, GetCapture());
15464 EndMenu();
15465 break;
15466 case WM_INITMENU:
15467 case WM_INITMENUPOPUP:
15468 case WM_UNINITMENUPOPUP:
15469 ok((HMENU)wParam == hpopupmenu, "expected %p, got %lx\n", hpopupmenu, wParam);
15470 break;
15471 case WM_CAPTURECHANGED:
15472 todo_wine ok(!lParam || (HWND)lParam == hwnd, "lost capture to %lx\n", lParam);
15473 break;
15474 }
15475
15476 return MsgCheckProc (FALSE, hwnd, message, wParam, lParam);
15477 }
15478
15479 static LRESULT WINAPI cancel_init_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
15480 {
15481 if (ignore_message( message )) return 0;
15482
15483 switch (message) {
15484 case WM_ENTERMENULOOP:
15485 ok(EndMenu() == TRUE, "EndMenu() failed\n");
15486 break;
15487 }
15488
15489 return MsgCheckProc (FALSE, hwnd, message, wParam, lParam);
15490 }
15491
15492 static void test_TrackPopupMenu(void)
15493 {
15494 HWND hwnd;
15495 BOOL ret;
15496
15497 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, 0,
15498 0, 0, 1, 1, 0,
15499 NULL, NULL, 0);
15500 ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
15501
15502 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)cancel_popup_proc);
15503
15504 hpopupmenu = CreatePopupMenu();
15505 ok(hpopupmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
15506
15507 AppendMenuA(hpopupmenu, MF_STRING, 100, "item 1");
15508 AppendMenuA(hpopupmenu, MF_STRING, 100, "item 2");
15509
15510 flush_events();
15511 flush_sequence();
15512 ret = TrackPopupMenu(hpopupmenu, 0, 100,100, 0, hwnd, NULL);
15513 ok_sequence(WmTrackPopupMenu, "TrackPopupMenu", TRUE);
15514 ok(ret == 1, "TrackPopupMenu failed with error %i\n", GetLastError());
15515
15516 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)cancel_init_proc);
15517
15518 flush_events();
15519 flush_sequence();
15520 ret = TrackPopupMenu(hpopupmenu, 0, 100,100, 0, hwnd, NULL);
15521 ok_sequence(WmTrackPopupMenuAbort, "WmTrackPopupMenuAbort", TRUE);
15522 ok(ret == TRUE, "TrackPopupMenu failed\n");
15523
15524 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)cancel_popup_proc);
15525
15526 SetCapture(hwnd);
15527
15528 flush_events();
15529 flush_sequence();
15530 ret = TrackPopupMenu(hpopupmenu, 0, 100,100, 0, hwnd, NULL);
15531 ok_sequence(WmTrackPopupMenuCapture, "TrackPopupMenuCapture", TRUE);
15532 ok(ret == 1, "TrackPopupMenuCapture failed with error %i\n", GetLastError());
15533
15534 DestroyMenu(hpopupmenu);
15535 DestroyWindow(hwnd);
15536 }
15537
15538 static void test_TrackPopupMenuEmpty(void)
15539 {
15540 HWND hwnd;
15541 BOOL ret;
15542
15543 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, 0,
15544 0, 0, 1, 1, 0,
15545 NULL, NULL, 0);
15546 ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
15547
15548 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)cancel_popup_proc);
15549
15550 hpopupmenu = CreatePopupMenu();
15551 ok(hpopupmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
15552
15553 flush_events();
15554 flush_sequence();
15555 ret = TrackPopupMenu(hpopupmenu, 0, 100,100, 0, hwnd, NULL);
15556 ok_sequence(WmTrackPopupMenuEmpty, "TrackPopupMenuEmpty", TRUE);
15557 ok(ret == 0, "TrackPopupMenu succeeded\n");
15558
15559 DestroyMenu(hpopupmenu);
15560 DestroyWindow(hwnd);
15561 }
15562
15563 static const struct message send_message_1[] = {
15564 { WM_USER+2, sent|wparam|lparam, 0, 0 },
15565 { WM_USER, sent|wparam|lparam, 0, 0 },
15566 { 0 }
15567 };
15568 static const struct message send_message_2[] = {
15569 { WM_USER+4, sent|wparam|lparam, 0, 0 },
15570 { 0 }
15571 };
15572 static const struct message send_message_3[] = {
15573 { WM_USER+3, sent|wparam|lparam, 0, 0 },
15574 { 0 }
15575 };
15576 static const struct message send_message_4[] = {
15577 { WM_USER+1, sent|wparam|lparam, 0, 0 },
15578 { 0 }
15579 };
15580
15581 static DWORD WINAPI SendMessage_thread_1(void *param)
15582 {
15583 struct wnd_event *wnd_event = param;
15584
15585 trace("thread: starting\n");
15586 WaitForSingleObject(wnd_event->start_event, INFINITE);
15587
15588 trace("thread: call PostMessage\n");
15589 PostMessageA(wnd_event->hwnd, WM_USER, 0, 0);
15590
15591 trace("thread: call PostMessage\n");
15592 PostMessageA(wnd_event->hwnd, WM_USER+1, 0, 0);
15593
15594 trace("thread: call SendMessage\n");
15595 SendMessageA(wnd_event->hwnd, WM_USER+2, 0, 0);
15596
15597 trace("thread: call SendMessage\n");
15598 SendMessageA(wnd_event->hwnd, WM_USER+3, 0, 0);
15599
15600 return 0;
15601 }
15602
15603 static DWORD WINAPI SendMessage_thread_2(void *param)
15604 {
15605 struct wnd_event *wnd_event = param;
15606
15607 trace("thread: starting\n");
15608 WaitForSingleObject(wnd_event->start_event, INFINITE);
15609
15610 trace("thread: call PostMessage\n");
15611 PostMessageA(wnd_event->hwnd, WM_USER, 0, 0);
15612
15613 trace("thread: call PostMessage\n");
15614 PostMessageA(wnd_event->hwnd, WM_USER+1, 0, 0);
15615
15616 /* this leads to sending an internal message under Wine */
15617 trace("thread: call EnableWindow\n");
15618 EnableWindow(wnd_event->hwnd, TRUE);
15619
15620 trace("thread: call SendMessage\n");
15621 SendMessageA(wnd_event->hwnd, WM_USER+2, 0, 0);
15622
15623 trace("thread: call SendMessage\n");
15624 SendMessageA(wnd_event->hwnd, WM_USER+3, 0, 0);
15625
15626 return 0;
15627 }
15628
15629 static void test_SendMessage_other_thread(int thread_n)
15630 {
15631 DWORD qs_all_input = QS_ALLINPUT & ~QS_RAWINPUT;
15632 HANDLE hthread;
15633 struct wnd_event wnd_event;
15634 DWORD tid, ret;
15635 MSG msg;
15636
15637 wnd_event.start_event = CreateEventA(NULL, 0, 0, NULL);
15638
15639 wnd_event.hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
15640 100, 100, 200, 200, 0, 0, 0, NULL);
15641 ok(wnd_event.hwnd != 0, "CreateWindowEx failed\n");
15642
15643 hthread = CreateThread(NULL, 0, thread_n == 1 ? SendMessage_thread_1 : SendMessage_thread_2, &wnd_event, 0, &tid);
15644 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
15645 CloseHandle(hthread);
15646
15647 flush_events();
15648 flush_sequence();
15649
15650 ret = GetQueueStatus(QS_SENDMESSAGE);
15651 ok(ret == 0, "wrong status %08x\n", ret);
15652
15653 SetEvent(wnd_event.start_event);
15654
15655 /* wait for other thread's SendMessage */
15656 for (;;)
15657 {
15658 ret = GetQueueStatus(QS_SENDMESSAGE);
15659 if (ret == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE)) break;
15660 Sleep(50);
15661 }
15662
15663 ret = GetQueueStatus(QS_SENDMESSAGE|QS_POSTMESSAGE);
15664 ok(ret == MAKELONG(QS_POSTMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE), "wrong status %08x\n", ret);
15665
15666 trace("main: call GetMessage\n");
15667 GetMessageA(&msg, 0, 0, 0);
15668 ok(msg.message == WM_USER, "expected WM_USER, got %04x\n", msg.message);
15669 DispatchMessageA(&msg);
15670 ok_sequence(send_message_1, "SendMessage from other thread 1", thread_n == 2);
15671
15672 /* intentionally yield */
15673 MsgWaitForMultipleObjects(0, NULL, FALSE, 100, qs_all_input);
15674
15675 trace("main: call SendMessage\n");
15676 SendMessageA(wnd_event.hwnd, WM_USER+4, 0, 0);
15677 ok_sequence(send_message_2, "SendMessage from other thread 2", FALSE);
15678
15679 ret = GetQueueStatus(QS_SENDMESSAGE|QS_POSTMESSAGE);
15680 ok(ret == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE), "wrong status %08x\n", ret);
15681
15682 trace("main: call PeekMessage\n");
15683 ok(PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE), "PeekMessage should not fail\n");
15684 ok(msg.message == WM_USER+1, "expected WM_USER+1, got %04x\n", msg.message);
15685 ok_sequence(send_message_3, "SendMessage from other thread 3", thread_n == 2);
15686
15687 trace("main: call PeekMessage\n");
15688 ok(PeekMessageA(&msg, 0, 0, 0, PM_REMOVE), "PeekMessage should not fail\n");
15689 ok(msg.message == WM_USER+1, "expected WM_USER+1, got %04x\n", msg.message);
15690 DispatchMessageA(&msg);
15691 ok_sequence(send_message_4, "SendMessage from other thread 4", FALSE);
15692
15693 /* intentionally yield */
15694 MsgWaitForMultipleObjects(0, NULL, FALSE, 100, qs_all_input);
15695
15696 ret = GetQueueStatus(QS_SENDMESSAGE|QS_POSTMESSAGE);
15697 /* FIXME: remove once Wine is fixed */
15698 todo_wine_if (thread_n == 2)
15699 ok(ret == 0, "wrong status %08x\n", ret);
15700
15701 trace("main: call PeekMessage\n");
15702 ok(!PeekMessageA(&msg, 0, 0, 0, PM_REMOVE), "PeekMessage should fail\n");
15703 ok_sequence(WmEmptySeq, "SendMessage from other thread 5", thread_n == 2);
15704
15705 ret = GetQueueStatus(QS_SENDMESSAGE|QS_POSTMESSAGE);
15706 ok(ret == 0, "wrong status %08x\n", ret);
15707
15708 trace("main: call DestroyWindow\n");
15709 DestroyWindow(msg.hwnd);
15710
15711 flush_events();
15712 flush_sequence();
15713 }
15714
15715 static const struct message DoubleSetCaptureSeq[] =
15716 {
15717 { WM_CAPTURECHANGED, sent },
15718 { 0 }
15719 };
15720
15721 static void test_DoubleSetCapture(void)
15722 {
15723 HWND hwnd;
15724
15725 hwnd = CreateWindowExA(0, "TestWindowClass", "Test DoubleSetCapture",
15726 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
15727 100, 100, 200, 200, 0, 0, 0, NULL);
15728 ok (hwnd != 0, "Failed to create overlapped window\n");
15729
15730 ShowWindow( hwnd, SW_SHOW );
15731 UpdateWindow( hwnd );
15732 flush_events();
15733 flush_sequence();
15734
15735 SetCapture( hwnd );
15736 SetCapture( hwnd );
15737 ok_sequence(DoubleSetCaptureSeq, "SetCapture( hwnd ) twice", FALSE);
15738
15739 DestroyWindow(hwnd);
15740 }
15741
15742 static void init_funcs(void)
15743 {
15744 HMODULE hKernel32 = GetModuleHandleA("kernel32.dll");
15745
15746 #define X(f) p##f = (void*)GetProcAddress(hKernel32, #f)
15747 X(ActivateActCtx);
15748 X(CreateActCtxW);
15749 X(DeactivateActCtx);
15750 X(GetCurrentActCtx);
15751 X(QueryActCtxW);
15752 X(ReleaseActCtx);
15753 #undef X
15754 }
15755
15756 START_TEST(msg)
15757 {
15758 char **test_argv;
15759 BOOL ret;
15760 BOOL (WINAPI *pIsWinEventHookInstalled)(DWORD)= 0;/*GetProcAddress(user32, "IsWinEventHookInstalled");*/
15761 HMODULE hModuleImm32;
15762 BOOL (WINAPI *pImmDisableIME)(DWORD);
15763 int argc;
15764
15765 init_funcs();
15766
15767 argc = winetest_get_mainargs( &test_argv );
15768 if (argc >= 3)
15769 {
15770 unsigned int arg;
15771 /* Child process. */
15772 sscanf (test_argv[2], "%d", (unsigned int *) &arg);
15773 do_wait_idle_child( arg );
15774 return;
15775 }
15776
15777 InitializeCriticalSection( &sequence_cs );
15778 init_procs();
15779
15780 hModuleImm32 = LoadLibraryA("imm32.dll");
15781 if (hModuleImm32) {
15782 pImmDisableIME = (void *)GetProcAddress(hModuleImm32, "ImmDisableIME");
15783 if (pImmDisableIME)
15784 pImmDisableIME(0);
15785 }
15786 pImmDisableIME = NULL;
15787 FreeLibrary(hModuleImm32);
15788
15789 if (!RegisterWindowClasses()) assert(0);
15790
15791 if (pSetWinEventHook)
15792 {
15793 hEvent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX,
15794 GetModuleHandleA(0), win_event_proc,
15795 0, GetCurrentThreadId(),
15796 WINEVENT_INCONTEXT);
15797 if (pIsWinEventHookInstalled && hEvent_hook)
15798 {
15799 UINT event;
15800 for (event = EVENT_MIN; event <= EVENT_MAX; event++)
15801 ok(pIsWinEventHookInstalled(event), "IsWinEventHookInstalled(%u) failed\n", event);
15802 }
15803 }
15804 if (!hEvent_hook) win_skip( "no win event hook support\n" );
15805
15806 cbt_hook_thread_id = GetCurrentThreadId();
15807 hCBT_hook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, GetCurrentThreadId());
15808 if (!hCBT_hook) win_skip( "cannot set global hook, will skip hook tests\n" );
15809
15810 test_winevents();
15811
15812 /* Fix message sequences before removing 4 lines below */
15813 if (pUnhookWinEvent && hEvent_hook)
15814 {
15815 ret = pUnhookWinEvent(hEvent_hook);
15816 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
15817 pUnhookWinEvent = 0;
15818 }
15819 hEvent_hook = 0;
15820
15821 test_SendMessage_other_thread(1);
15822 test_SendMessage_other_thread(2);
15823 test_SetFocus();
15824 test_SetParent();
15825 test_PostMessage();
15826 test_broadcast();
15827 test_ShowWindow();
15828 test_PeekMessage();
15829 test_PeekMessage2();
15830 test_PeekMessage3();
15831 test_WaitForInputIdle( test_argv[0] );
15832 test_scrollwindowex();
15833 test_messages();
15834 test_setwindowpos();
15835 test_showwindow();
15836 invisible_parent_tests();
15837 test_mdi_messages();
15838 test_button_messages();
15839 test_static_messages();
15840 test_listbox_messages();
15841 test_combobox_messages();
15842 test_wmime_keydown_message();
15843 test_paint_messages();
15844 test_interthread_messages();
15845 test_message_conversion();
15846 test_accelerators();
15847 test_timers();
15848 test_timers_no_wnd();
15849 test_timers_exceptions();
15850 if (hCBT_hook)
15851 {
15852 test_set_hook();
15853 test_recursive_hook();
15854 }
15855 test_DestroyWindow();
15856 test_DispatchMessage();
15857 test_SendMessageTimeout();
15858 test_edit_messages();
15859 test_quit_message();
15860 test_notify_message();
15861 test_SetActiveWindow();
15862
15863 if (!pTrackMouseEvent)
15864 win_skip("TrackMouseEvent is not available\n");
15865 else
15866 test_TrackMouseEvent();
15867
15868 test_SetWindowRgn();
15869 test_sys_menu();
15870 test_dialog_messages();
15871 test_EndDialog();
15872 test_nullCallback();
15873 test_dbcs_wm_char();
15874 test_unicode_wm_char();
15875 test_menu_messages();
15876 test_paintingloop();
15877 test_defwinproc();
15878 test_clipboard_viewers();
15879 test_keyflags();
15880 test_hotkey();
15881 test_layered_window();
15882 test_TrackPopupMenu();
15883 test_TrackPopupMenuEmpty();
15884 test_DoubleSetCapture();
15885 /* keep it the last test, under Windows it tends to break the tests
15886 * which rely on active/foreground windows being correct.
15887 */
15888 test_SetForegroundWindow();
15889
15890 UnhookWindowsHookEx(hCBT_hook);
15891 if (pUnhookWinEvent && hEvent_hook)
15892 {
15893 ret = pUnhookWinEvent(hEvent_hook);
15894 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
15895 SetLastError(0xdeadbeef);
15896 ok(!pUnhookWinEvent(hEvent_hook), "UnhookWinEvent succeeded\n");
15897 ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
15898 GetLastError() == 0xdeadbeef, /* Win9x */
15899 "unexpected error %d\n", GetLastError());
15900 }
15901 DeleteCriticalSection( &sequence_cs );
15902 }
Windows API implementation