2 * Unit tests for window message handling
4 * Copyright 1999 Ove Kaaven
5 * Copyright 2003 Dimitrie O. Paun
6 * Copyright 2004, 2005 Dmitry Timoshkov
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.
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.
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
27 #define _WIN32_WINNT 0x0501 /* For WM_CHANGEUISTATE,QS_RAWINPUT */
35 #include "wine/test.h"
37 #define MDI_FIRST_CHILD_ID 2004
39 /* undocumented SWP flags - from SDK 3.1 */
40 #define SWP_NOCLIENTSIZE 0x0800
41 #define SWP_NOCLIENTMOVE 0x1000
43 #define SW_NORMALNA 0xCC /* undoc. flag in MinMaximize */
46 #define WM_SYSTIMER 0x0118
49 #define WND_PARENT_ID 1
50 #define WND_POPUP_ID 2
51 #define WND_CHILD_ID 3
53 static BOOL test_DestroyWindow_flag
;
54 static HWINEVENTHOOK hEvent_hook
;
56 static HWND (WINAPI
*pGetAncestor
)(HWND
,UINT
);
58 static void dump_winpos_flags(UINT flags
);
61 FIXME: add tests for these
62 Window Edge Styles (Win31/Win95/98 look), in order of precedence:
63 WS_EX_DLGMODALFRAME: double border, WS_CAPTION allowed
64 WS_THICKFRAME: thick border
65 WS_DLGFRAME: double border, WS_CAPTION not allowed (but possibly shown anyway)
66 WS_BORDER (default for overlapped windows): single black border
67 none (default for child (and popup?) windows): no border
84 UINT message
; /* the WM_* code */
85 msg_flags_t flags
; /* message props */
86 WPARAM wParam
; /* expected value of wParam */
87 LPARAM lParam
; /* expected value of lParam */
90 /* Empty message sequence */
91 static const struct message WmEmptySeq
[] =
95 /* CreateWindow (for overlapped window, not initially visible) (16/32) */
96 static const struct message WmCreateOverlappedSeq
[] = {
97 { HCBT_CREATEWND
, hook
},
98 { WM_GETMINMAXINFO
, sent
},
99 { WM_NCCREATE
, sent
},
100 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
101 { EVENT_OBJECT_REORDER
, winevent_hook
|wparam
|lparam
, 0, 0 },
103 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, 0, 0 },
106 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
107 * for a not visible overlapped window.
109 static const struct message WmSWP_ShowOverlappedSeq
[] = {
110 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
111 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
112 { WM_NCPAINT
, sent
|wparam
|optional
, 1 },
113 { WM_GETTEXT
, sent
|defwinproc
|optional
},
114 { WM_ERASEBKGND
, sent
|optional
},
115 { HCBT_ACTIVATE
, hook
},
116 { EVENT_SYSTEM_FOREGROUND
, winevent_hook
|wparam
|lparam
, 0, 0 },
117 { WM_QUERYNEWPALETTE
, sent
|wparam
|lparam
|optional
, 0, 0 },
118 { WM_WINDOWPOSCHANGING
, sent
|wparam
|optional
, SWP_NOSIZE
|SWP_NOMOVE
}, /* Win9x: SWP_NOSENDCHANGING */
119 { WM_ACTIVATEAPP
, sent
|wparam
, 1 },
120 { WM_NCACTIVATE
, sent
|wparam
, 1 },
121 { WM_GETTEXT
, sent
|defwinproc
|optional
},
122 { WM_ACTIVATE
, sent
|wparam
, 1 },
123 { HCBT_SETFOCUS
, hook
},
124 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
125 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 2 },
126 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
127 { WM_SETFOCUS
, sent
|wparam
|defwinproc
, 0 },
128 { WM_NCPAINT
, sent
|wparam
|optional
, 1 },
129 { WM_GETTEXT
, sent
|defwinproc
|optional
},
130 { WM_ERASEBKGND
, sent
|optional
},
131 /* Win9x adds SWP_NOZORDER below */
132 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
133 { WM_NCCALCSIZE
, sent
|wparam
|optional
, 1 },
134 { WM_NCPAINT
, sent
|wparam
|optional
, 1 },
135 { WM_ERASEBKGND
, sent
|optional
},
136 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
139 /* SetWindowPos(SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE)
140 * for a visible overlapped window.
142 static const struct message WmSWP_HideOverlappedSeq
[] = {
143 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
144 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, 0, 0 },
145 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
149 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE)
150 * for a visible overlapped window.
152 static const struct message WmSWP_ResizeSeq
[] = {
153 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOACTIVATE
|SWP_NOMOVE
},
154 { WM_GETMINMAXINFO
, sent
|defwinproc
},
155 { WM_NCCALCSIZE
, sent
|wparam
, TRUE
},
156 { WM_NCPAINT
, sent
|optional
},
157 { WM_GETTEXT
, sent
|defwinproc
|optional
},
158 { WM_ERASEBKGND
, sent
|optional
},
159 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOACTIVATE
|SWP_NOMOVE
|SWP_NOCLIENTMOVE
},
160 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_RESTORED
},
161 { WM_NCCALCSIZE
, sent
|wparam
|optional
, TRUE
},
162 { WM_NCPAINT
, sent
|optional
},
163 { WM_GETTEXT
, sent
|defwinproc
|optional
},
164 { WM_ERASEBKGND
, sent
|optional
},
165 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
166 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, 0, 0 }, /* XP sends a duplicate */
170 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE)
171 * for a visible popup window.
173 static const struct message WmSWP_ResizePopupSeq
[] = {
174 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOACTIVATE
|SWP_NOMOVE
},
175 { WM_GETMINMAXINFO
, sent
|defwinproc
|optional
}, /* Win9x */
176 { WM_NCCALCSIZE
, sent
|wparam
, TRUE
},
177 { WM_NCPAINT
, sent
|optional
},
178 { WM_GETTEXT
, sent
|defwinproc
|optional
},
179 { WM_ERASEBKGND
, sent
|optional
},
180 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOACTIVATE
|SWP_NOMOVE
|SWP_NOCLIENTMOVE
},
181 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_RESTORED
},
182 { WM_NCCALCSIZE
, sent
|wparam
|optional
, TRUE
},
183 { WM_NCPAINT
, sent
|optional
},
184 { WM_GETTEXT
, sent
|defwinproc
|optional
},
185 { WM_ERASEBKGND
, sent
|optional
},
186 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
190 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE)
191 * for a visible overlapped window.
193 static const struct message WmSWP_MoveSeq
[] = {
194 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOACTIVATE
|SWP_NOSIZE
},
195 { WM_NCPAINT
, sent
|optional
},
196 { WM_GETTEXT
, sent
|defwinproc
|optional
},
197 { WM_ERASEBKGND
, sent
|optional
},
198 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOCLIENTSIZE
},
199 { WM_MOVE
, sent
|defwinproc
|wparam
, 0 },
200 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
204 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|
205 SWP_NOZORDER|SWP_FRAMECHANGED)
206 * for a visible overlapped window with WS_CLIPCHILDREN style set.
208 static const struct message WmSWP_FrameChanged_clip
[] = {
209 { WM_WINDOWPOSCHANGING
, sent
|wparam
|parent
, SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
},
210 { WM_NCCALCSIZE
, sent
|wparam
|parent
, 1 },
211 { WM_NCPAINT
, sent
|parent
}, /* wparam != 1 */
212 { WM_GETTEXT
, sent
|parent
|defwinproc
|optional
},
213 { WM_ERASEBKGND
, sent
|parent
|optional
}, /* FIXME: remove optional once Wine is fixed */
214 { WM_NCPAINT
, sent
}, /* wparam != 1 */
215 { WM_ERASEBKGND
, sent
},
216 { WM_WINDOWPOSCHANGED
, sent
|wparam
|parent
, SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
217 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
221 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|
222 SWP_NOZORDER|SWP_FRAMECHANGED)
223 * for a visible overlapped window.
225 static const struct message WmSWP_FrameChangedDeferErase
[] = {
226 { WM_WINDOWPOSCHANGING
, sent
|wparam
|parent
, SWP_NOSIZE
|SWP_NOMOVE
|SWP_DEFERERASE
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
},
227 { WM_NCCALCSIZE
, sent
|wparam
|parent
, 1 },
228 { WM_WINDOWPOSCHANGED
, sent
|wparam
|parent
, SWP_NOSIZE
|SWP_NOMOVE
|SWP_DEFERERASE
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
229 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
230 { WM_PAINT
, sent
|parent
},
231 { WM_NCPAINT
, sent
|beginpaint
|parent
}, /* wparam != 1 */
232 { WM_GETTEXT
, sent
|beginpaint
|parent
|defwinproc
|optional
},
234 { WM_NCPAINT
, sent
|beginpaint
}, /* wparam != 1 */
235 { WM_ERASEBKGND
, sent
|beginpaint
},
239 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|
240 SWP_NOZORDER|SWP_FRAMECHANGED)
241 * for a visible overlapped window without WS_CLIPCHILDREN style set.
243 static const struct message WmSWP_FrameChanged_noclip
[] = {
244 { WM_WINDOWPOSCHANGING
, sent
|wparam
|parent
, SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
},
245 { WM_NCCALCSIZE
, sent
|wparam
|parent
, 1 },
246 { WM_NCPAINT
, sent
|parent
}, /* wparam != 1 */
247 { WM_GETTEXT
, sent
|parent
|defwinproc
|optional
},
248 { WM_ERASEBKGND
, sent
|parent
|optional
}, /* FIXME: remove optional once Wine is fixed */
249 { WM_WINDOWPOSCHANGED
, sent
|wparam
|parent
, SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
250 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
252 { WM_NCPAINT
, sent
|beginpaint
}, /* wparam != 1 */
253 { WM_ERASEBKGND
, sent
|beginpaint
},
257 /* ShowWindow(SW_SHOW) for a not visible overlapped window */
258 static const struct message WmShowOverlappedSeq
[] = {
259 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
260 { WM_NCPAINT
, sent
|wparam
|optional
, 1 },
261 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
262 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
263 { WM_NCPAINT
, sent
|wparam
|optional
, 1 },
264 { WM_GETTEXT
, sent
|defwinproc
|optional
},
265 { WM_ERASEBKGND
, sent
|optional
},
266 { HCBT_ACTIVATE
, hook
},
267 { EVENT_SYSTEM_FOREGROUND
, winevent_hook
|wparam
|lparam
, 0, 0 },
268 { WM_QUERYNEWPALETTE
, sent
|wparam
|lparam
|optional
, 0, 0 },
269 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOSIZE
|SWP_NOMOVE
},
270 { WM_NCPAINT
, sent
|wparam
|optional
, 1 },
271 { WM_ACTIVATEAPP
, sent
|wparam
, 1 },
272 { WM_NCACTIVATE
, sent
|wparam
, 1 },
273 { WM_GETTEXT
, sent
|defwinproc
|optional
},
274 { WM_ACTIVATE
, sent
|wparam
, 1 },
275 { HCBT_SETFOCUS
, hook
},
276 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
277 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 2 },
278 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
279 { WM_SETFOCUS
, sent
|wparam
|defwinproc
, 0 },
280 { WM_NCPAINT
, sent
|wparam
|optional
, 1 },
281 { WM_GETTEXT
, sent
|defwinproc
|optional
},
282 { WM_ERASEBKGND
, sent
|optional
},
283 /* Win9x adds SWP_NOZORDER below */
284 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
285 { WM_NCCALCSIZE
, sent
|optional
},
286 { WM_NCPAINT
, sent
|optional
},
287 { WM_ERASEBKGND
, sent
|optional
},
288 #if 0 /* CreateWindow/ShowWindow(SW_SHOW) also generates WM_SIZE/WM_MOVE
289 * messages. Does that mean that CreateWindow doesn't set initial
290 * window dimensions for overlapped windows?
297 /* ShowWindow(SW_SHOWMAXIMIZED) for a not visible overlapped window */
298 static const struct message WmShowMaxOverlappedSeq
[] = {
299 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MAXIMIZE
},
300 { WM_GETMINMAXINFO
, sent
},
301 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|0x8000 },
302 { WM_GETMINMAXINFO
, sent
|defwinproc
},
303 { WM_NCCALCSIZE
, sent
|wparam
, TRUE
},
304 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
305 { HCBT_ACTIVATE
, hook
},
306 { EVENT_SYSTEM_FOREGROUND
, winevent_hook
|wparam
|lparam
, 0, 0 },
307 { WM_QUERYNEWPALETTE
, sent
|wparam
|lparam
|optional
, 0, 0 },
308 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOSIZE
|SWP_NOMOVE
},
309 { WM_ACTIVATEAPP
, sent
|wparam
, 1 },
310 { WM_NCACTIVATE
, sent
|wparam
, 1 },
311 { WM_GETTEXT
, sent
|defwinproc
|optional
},
312 { WM_ACTIVATE
, sent
|wparam
, 1 },
313 { HCBT_SETFOCUS
, hook
},
314 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
315 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 2 },
316 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
317 { WM_SETFOCUS
, sent
|wparam
|defwinproc
, 0 },
318 { WM_NCPAINT
, sent
|wparam
|optional
, 1 },
319 { WM_GETTEXT
, sent
|defwinproc
|optional
},
320 { WM_ERASEBKGND
, sent
|optional
},
321 /* Win9x adds SWP_NOZORDER below */
322 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|0x8000 },
323 { WM_MOVE
, sent
|defwinproc
},
324 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
325 { WM_NCCALCSIZE
, sent
|optional
},
326 { WM_NCPAINT
, sent
|optional
},
327 { WM_ERASEBKGND
, sent
|optional
},
328 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
329 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
332 /* ShowWindow(SW_HIDE) for a visible overlapped window */
333 static const struct message WmHideOverlappedSeq
[] = {
334 { WM_SHOWWINDOW
, sent
|wparam
, 0 },
335 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
336 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, 0, 0 },
337 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
338 { WM_SIZE
, sent
|optional
}, /* XP doesn't send it */
339 { WM_MOVE
, sent
|optional
}, /* XP doesn't send it */
340 { WM_NCACTIVATE
, sent
|wparam
, 0 },
341 { WM_ACTIVATE
, sent
|wparam
, 0 },
342 { WM_ACTIVATEAPP
, sent
|wparam
, 0 },
343 { WM_KILLFOCUS
, sent
|wparam
, 0 },
344 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 },
345 { WM_IME_NOTIFY
, sent
|wparam
|optional
|defwinproc
, 1 },
348 /* DestroyWindow for a visible overlapped window */
349 static const struct message WmDestroyOverlappedSeq
[] = {
350 { HCBT_DESTROYWND
, hook
},
351 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
352 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, 0, 0 },
353 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
354 { WM_NCACTIVATE
, sent
|wparam
, 0 },
355 { WM_ACTIVATE
, sent
|wparam
, 0 },
356 { WM_ACTIVATEAPP
, sent
|wparam
, 0 },
357 { WM_KILLFOCUS
, sent
|wparam
, 0 },
358 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 },
359 { WM_IME_NOTIFY
, sent
|wparam
|optional
|defwinproc
, 1 },
360 { EVENT_OBJECT_DESTROY
, winevent_hook
|wparam
|lparam
, 0, 0 },
361 { WM_DESTROY
, sent
},
362 { WM_NCDESTROY
, sent
},
365 /* CreateWindow(WS_MAXIMIZE|WS_VISIBLE) for popup window */
366 static const struct message WmCreateMaxPopupSeq
[] = {
367 { HCBT_CREATEWND
, hook
},
368 { WM_NCCREATE
, sent
},
369 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
371 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
373 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MAXIMIZE
},
374 { WM_GETMINMAXINFO
, sent
},
375 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOACTIVATE
|SWP_FRAMECHANGED
|0x8000 },
376 { WM_NCCALCSIZE
, sent
|wparam
, TRUE
},
377 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOREDRAW
|0x8000 },
378 { WM_MOVE
, sent
|defwinproc
},
379 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
380 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
381 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
382 { HCBT_ACTIVATE
, hook
},
383 { WM_QUERYNEWPALETTE
, sent
|wparam
|lparam
|optional
, 0, 0 },
384 { WM_WINDOWPOSCHANGING
, sent
|wparam
|optional
, SWP_NOSIZE
|SWP_NOMOVE
},
385 { WM_ACTIVATEAPP
, sent
|wparam
, 1 },
386 { WM_NCACTIVATE
, sent
|wparam
, 1 },
387 { WM_ACTIVATE
, sent
|wparam
, 1 },
388 { HCBT_SETFOCUS
, hook
},
389 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
390 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 2 },
391 { WM_SETFOCUS
, sent
|wparam
|defwinproc
, 0 },
392 { WM_SYNCPAINT
, sent
|wparam
|optional
, 4 },
393 { WM_NCPAINT
, sent
|wparam
|optional
, 1 },
394 { WM_ERASEBKGND
, sent
|optional
},
395 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOCLIENTMOVE
|SWP_NOCLIENTSIZE
|SWP_SHOWWINDOW
|SWP_NOMOVE
|SWP_NOSIZE
},
398 /* CreateWindow(WS_MAXIMIZE) for popup window, not initially visible */
399 static const struct message WmCreateInvisibleMaxPopupSeq
[] = {
400 { HCBT_CREATEWND
, hook
},
401 { WM_NCCREATE
, sent
},
402 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
404 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
406 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MAXIMIZE
},
407 { WM_GETMINMAXINFO
, sent
},
408 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOACTIVATE
|SWP_FRAMECHANGED
|0x8000 },
409 { WM_NCCALCSIZE
, sent
|wparam
, TRUE
},
410 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOREDRAW
|0x8000 },
411 { WM_MOVE
, sent
|defwinproc
},
412 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
415 /* ShowWindow(SW_SHOWMAXIMIZED) for a resized not visible popup window */
416 static const struct message WmShowMaxPopupResizedSeq
[] = {
417 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MAXIMIZE
},
418 { WM_GETMINMAXINFO
, sent
},
419 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
},
420 { WM_NCCALCSIZE
, sent
|wparam
, TRUE
},
421 { HCBT_ACTIVATE
, hook
},
422 { WM_QUERYNEWPALETTE
, sent
|wparam
|lparam
|optional
, 0, 0 },
423 { WM_WINDOWPOSCHANGING
, sent
|wparam
|optional
, SWP_NOSIZE
|SWP_NOMOVE
},
424 { WM_ACTIVATEAPP
, sent
|wparam
, 1 },
425 { WM_NCACTIVATE
, sent
|wparam
, 1 },
426 { WM_ACTIVATE
, sent
|wparam
, 1 },
427 { HCBT_SETFOCUS
, hook
},
428 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
429 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 2 },
430 { WM_SETFOCUS
, sent
|wparam
|defwinproc
, 0 },
431 { WM_NCPAINT
, sent
|wparam
|optional
, 1 },
432 { WM_ERASEBKGND
, sent
|optional
},
433 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOCLIENTMOVE
|SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|SWP_NOMOVE
},
434 /* WinNT4.0 sends WM_MOVE */
435 { WM_MOVE
, sent
|defwinproc
|optional
},
436 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
439 /* ShowWindow(SW_SHOWMAXIMIZED) for a not visible popup window */
440 static const struct message WmShowMaxPopupSeq
[] = {
441 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MAXIMIZE
},
442 { WM_GETMINMAXINFO
, sent
},
443 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
},
444 { WM_NCCALCSIZE
, sent
|wparam
, TRUE
},
445 { HCBT_ACTIVATE
, hook
},
446 { WM_QUERYNEWPALETTE
, sent
|wparam
|lparam
|optional
, 0, 0 },
447 { WM_WINDOWPOSCHANGING
, sent
|wparam
|optional
, SWP_NOSIZE
|SWP_NOMOVE
},
448 { WM_ACTIVATEAPP
, sent
|wparam
, 1 },
449 { WM_NCACTIVATE
, sent
|wparam
, 1 },
450 { WM_ACTIVATE
, sent
|wparam
, 1 },
451 { HCBT_SETFOCUS
, hook
},
452 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
453 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 2 },
454 { WM_SETFOCUS
, sent
|wparam
|defwinproc
, 0 },
455 { WM_SYNCPAINT
, sent
|wparam
|optional
, 4 },
456 { WM_NCPAINT
, sent
|wparam
|optional
, 1 },
457 { WM_ERASEBKGND
, sent
|optional
},
458 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
|SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|SWP_NOMOVE
|SWP_NOSIZE
},
461 /* CreateWindow(WS_VISIBLE) for popup window */
462 static const struct message WmCreatePopupSeq
[] = {
463 { HCBT_CREATEWND
, hook
},
464 { WM_NCCREATE
, sent
},
465 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
467 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
469 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
470 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
471 { HCBT_ACTIVATE
, hook
},
472 { WM_QUERYNEWPALETTE
, sent
|wparam
|lparam
|optional
, 0, 0 },
473 { WM_WINDOWPOSCHANGING
, sent
|wparam
|optional
, SWP_NOSIZE
|SWP_NOMOVE
},
474 { WM_NCPAINT
, sent
|wparam
|optional
, 1 },
475 { WM_ERASEBKGND
, sent
|optional
},
476 { WM_ACTIVATEAPP
, sent
|wparam
, 1 },
477 { WM_NCACTIVATE
, sent
|wparam
, 1 },
478 { WM_ACTIVATE
, sent
|wparam
, 1 },
479 { HCBT_SETFOCUS
, hook
},
480 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
481 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 2 },
482 { WM_SETFOCUS
, sent
|wparam
|defwinproc
, 0 },
483 { WM_SYNCPAINT
, sent
|wparam
|optional
, 4 },
484 { WM_NCPAINT
, sent
|wparam
|optional
, 1 },
485 { WM_ERASEBKGND
, sent
|optional
},
486 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOCLIENTMOVE
|SWP_NOCLIENTSIZE
|SWP_SHOWWINDOW
|SWP_NOMOVE
|SWP_NOSIZE
},
489 /* ShowWindow(SW_SHOWMAXIMIZED) for a visible popup window */
490 static const struct message WmShowVisMaxPopupSeq
[] = {
491 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MAXIMIZE
},
492 { WM_GETMINMAXINFO
, sent
},
493 { WM_GETTEXT
, sent
|optional
},
494 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|0x8000 },
495 { WM_NCCALCSIZE
, sent
|wparam
, TRUE
},
496 { WM_QUERYNEWPALETTE
, sent
|wparam
|lparam
|optional
, 0, 0 },
497 { WM_NCPAINT
, sent
|wparam
|optional
, 1 },
498 { WM_ERASEBKGND
, sent
|optional
},
499 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|0x8000 },
500 { WM_MOVE
, sent
|defwinproc
},
501 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
504 /* CreateWindow (for a child popup window, not initially visible) */
505 static const struct message WmCreateChildPopupSeq
[] = {
506 { HCBT_CREATEWND
, hook
},
507 { WM_NCCREATE
, sent
},
508 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
510 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, 0, 0 },
511 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
515 /* CreateWindow (for a popup window, not initially visible,
516 * which sets WS_VISIBLE in WM_CREATE handler)
518 static const struct message WmCreateInvisiblePopupSeq
[] = {
519 { HCBT_CREATEWND
, hook
},
520 { WM_NCCREATE
, sent
},
521 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
523 { WM_STYLECHANGING
, sent
},
524 { WM_STYLECHANGED
, sent
},
525 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, 0, 0 },
526 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
530 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER)
531 * for a popup window with WS_VISIBLE style set
533 static const struct message WmShowVisiblePopupSeq_2
[] = {
534 { WM_WINDOWPOSCHANGING
, sent
|wparam
, 0 },
537 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
538 * for a popup window with WS_VISIBLE style set
540 static const struct message WmShowVisiblePopupSeq_3
[] = {
541 { WM_WINDOWPOSCHANGING
, sent
|wparam
, 0 },
542 { HCBT_ACTIVATE
, hook
},
543 { EVENT_SYSTEM_FOREGROUND
, winevent_hook
|wparam
|lparam
, 0, 0 },
544 { WM_QUERYNEWPALETTE
, sent
|wparam
|lparam
|optional
, 0, 0 },
545 { WM_WINDOWPOSCHANGING
, sent
|wparam
, 0 },
546 { WM_NCACTIVATE
, sent
|wparam
, 1 },
547 { WM_ACTIVATE
, sent
|wparam
, 1 },
548 { HCBT_SETFOCUS
, hook
},
549 { WM_KILLFOCUS
, sent
|parent
},
550 { WM_IME_SETCONTEXT
, sent
|parent
|wparam
|optional
, 0 },
551 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
552 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 2 },
553 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
554 { WM_SETFOCUS
, sent
|defwinproc
},
557 /* CreateWindow (for child window, not initially visible) */
558 static const struct message WmCreateChildSeq
[] = {
559 { HCBT_CREATEWND
, hook
},
560 { WM_NCCREATE
, sent
},
561 /* child is inserted into parent's child list after WM_NCCREATE returns */
562 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
564 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, 0, 0 },
565 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
567 { WM_PARENTNOTIFY
, sent
|parent
|wparam
, WM_CREATE
},
570 /* CreateWindow (for maximized child window, not initially visible) */
571 static const struct message WmCreateMaximizedChildSeq
[] = {
572 { HCBT_CREATEWND
, hook
},
573 { WM_NCCREATE
, sent
},
574 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
576 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, 0, 0 },
577 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
579 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MAXIMIZE
},
580 { WM_GETMINMAXINFO
, sent
},
581 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|0x8000 },
582 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
583 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOMOVE
|SWP_NOREDRAW
|SWP_NOCLIENTMOVE
|0x8000 },
584 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
585 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
586 { WM_PARENTNOTIFY
, sent
|parent
|wparam
, WM_CREATE
},
589 /* CreateWindow (for a child window, initially visible) */
590 static const struct message WmCreateVisibleChildSeq
[] = {
591 { HCBT_CREATEWND
, hook
},
592 { WM_NCCREATE
, sent
},
593 /* child is inserted into parent's child list after WM_NCCREATE returns */
594 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
595 { EVENT_OBJECT_REORDER
, winevent_hook
|wparam
|lparam
, 0, 0 },
597 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, 0, 0 },
598 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
600 { WM_PARENTNOTIFY
, sent
|parent
|wparam
, WM_CREATE
},
601 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
602 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
},
603 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
604 { WM_ERASEBKGND
, sent
|parent
|optional
},
605 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
606 { WM_NCCALCSIZE
, sent
|wparam
|optional
, 1 }, /* WinXP */
607 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
610 /* ShowWindow(SW_SHOW) for a not visible child window */
611 static const struct message WmShowChildSeq
[] = {
612 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
613 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
614 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
615 { WM_ERASEBKGND
, sent
|parent
|optional
},
616 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
619 /* ShowWindow(SW_HIDE) for a visible child window */
620 static const struct message WmHideChildSeq
[] = {
621 { WM_SHOWWINDOW
, sent
|wparam
, 0 },
622 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
623 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, 0, 0 },
624 { WM_ERASEBKGND
, sent
|parent
|optional
},
625 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
628 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
629 * for a not visible child window
631 static const struct message WmShowChildSeq_2
[] = {
632 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
633 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
634 { WM_CHILDACTIVATE
, sent
},
635 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
638 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE)
639 * for a not visible child window
641 static const struct message WmShowChildSeq_3
[] = {
642 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
},
643 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
644 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
647 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
648 * for a visible child window with a caption
650 static const struct message WmShowChildSeq_4
[] = {
651 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
652 { WM_CHILDACTIVATE
, sent
},
655 /* ShowWindow(SW_MINIMIZE) for child with invisible parent */
656 static const struct message WmShowChildInvisibleParentSeq_1
[] = {
657 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MINIMIZE
},
658 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOCOPYBITS
|0x8000 },
659 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
660 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOREDRAW
|SWP_NOCOPYBITS
|0x8000 },
661 { WM_MOVE
, sent
|defwinproc
},
662 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MINIMIZED
},
663 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
664 /* FIXME: Wine creates an icon/title window while Windows doesn't */
665 { WM_PARENTNOTIFY
, sent
|parent
|wparam
|optional
, WM_CREATE
},
666 { WM_GETTEXT
, sent
|optional
},
669 /* repeated ShowWindow(SW_MINIMIZE) for child with invisible parent */
670 static const struct message WmShowChildInvisibleParentSeq_1r
[] = {
671 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MINIMIZE
},
674 /* ShowWindow(SW_MAXIMIZE) for child with invisible parent */
675 static const struct message WmShowChildInvisibleParentSeq_2
[] = {
676 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MAXIMIZE
},
677 { WM_GETMINMAXINFO
, sent
},
678 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|0x8000 },
679 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
680 { WM_CHILDACTIVATE
, sent
},
681 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|SWP_NOMOVE
|SWP_NOREDRAW
|SWP_NOCLIENTMOVE
|0x8000 },
682 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
683 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
686 /* repeated ShowWindow(SW_MAXIMIZE) for child with invisible parent */
687 static const struct message WmShowChildInvisibleParentSeq_2r
[] = {
688 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MAXIMIZE
},
691 /* ShowWindow(SW_SHOWMINIMIZED) for child with invisible parent */
692 static const struct message WmShowChildInvisibleParentSeq_3
[] = {
693 { HCBT_MINMAX
, hook
|lparam
, 0, SW_SHOWMINIMIZED
},
694 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
695 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
696 { WM_CHILDACTIVATE
, sent
},
697 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|SWP_NOREDRAW
|SWP_NOCOPYBITS
|0x8000 },
698 { WM_MOVE
, sent
|defwinproc
},
699 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MINIMIZED
},
700 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
701 /* FIXME: Wine creates an icon/title window while Windows doesn't */
702 { WM_PARENTNOTIFY
, sent
|parent
|wparam
|optional
, WM_CREATE
},
703 { WM_GETTEXT
, sent
|optional
},
706 /* repeated ShowWindow(SW_SHOWMINIMIZED) for child with invisible parent */
707 static const struct message WmShowChildInvisibleParentSeq_3r
[] = {
708 { HCBT_MINMAX
, hook
|lparam
, 0, SW_SHOWMINIMIZED
},
711 /* ShowWindow(SW_SHOWMINNOACTIVE) for child with invisible parent */
712 static const struct message WmShowChildInvisibleParentSeq_4
[] = {
713 { HCBT_MINMAX
, hook
|lparam
, 0, SW_SHOWMINNOACTIVE
},
714 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOCOPYBITS
|0x8000 },
715 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
716 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOREDRAW
|SWP_NOCOPYBITS
|0x8000 },
717 { WM_MOVE
, sent
|defwinproc
},
718 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MINIMIZED
},
719 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
720 /* FIXME: Wine creates an icon/title window while Windows doesn't */
721 { WM_PARENTNOTIFY
, sent
|parent
|wparam
|optional
, WM_CREATE
},
722 { WM_GETTEXT
, sent
|optional
},
725 /* repeated ShowWindow(SW_SHOWMINNOACTIVE) for child with invisible parent */
726 static const struct message WmShowChildInvisibleParentSeq_4r
[] = {
727 { HCBT_MINMAX
, hook
|lparam
, 0, SW_SHOWMINNOACTIVE
},
730 /* ShowWindow(SW_SHOW) for child with invisible parent */
731 static const struct message WmShowChildInvisibleParentSeq_5
[] = {
732 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
735 /* ShowWindow(SW_HIDE) for child with invisible parent */
736 static const struct message WmHideChildInvisibleParentSeq
[] = {
737 { WM_SHOWWINDOW
, sent
|wparam
, 0 },
740 /* SetWindowPos(SWP_SHOWWINDOW) for child with invisible parent */
741 static const struct message WmShowChildInvisibleParentSeq_6
[] = {
742 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
},
743 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
744 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
|SWP_NOREDRAW
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
747 /* SetWindowPos(SWP_HIDEWINDOW) for child with invisible parent */
748 static const struct message WmHideChildInvisibleParentSeq_2
[] = {
749 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
750 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, 0, 0 },
751 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOREDRAW
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
754 /* DestroyWindow for a visible child window */
755 static const struct message WmDestroyChildSeq
[] = {
756 { HCBT_DESTROYWND
, hook
},
757 { WM_PARENTNOTIFY
, sent
|parent
|wparam
, WM_DESTROY
},
758 { WM_SHOWWINDOW
, sent
|wparam
, 0 },
759 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
760 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, 0, 0 },
761 { WM_ERASEBKGND
, sent
|parent
|optional
},
762 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
763 { HCBT_SETFOCUS
, hook
}, /* set focus to a parent */
764 { WM_KILLFOCUS
, sent
},
765 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 },
766 { WM_IME_SETCONTEXT
, sent
|wparam
|parent
|optional
, 1 },
767 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
768 { WM_SETFOCUS
, sent
|parent
},
769 { EVENT_OBJECT_DESTROY
, winevent_hook
|wparam
|lparam
, 0, 0 },
770 { WM_DESTROY
, sent
},
771 { WM_DESTROY
, sent
|optional
}, /* some other (IME?) window */
772 { WM_NCDESTROY
, sent
|optional
}, /* some other (IME?) window */
773 { WM_NCDESTROY
, sent
},
776 /* DestroyWindow for a visible child window with invisible parent */
777 static const struct message WmDestroyInvisibleChildSeq
[] = {
778 { HCBT_DESTROYWND
, hook
},
779 { WM_PARENTNOTIFY
, sent
|parent
|wparam
, WM_DESTROY
},
780 { WM_SHOWWINDOW
, sent
|wparam
, 0 },
781 { EVENT_OBJECT_DESTROY
, winevent_hook
|wparam
|lparam
, 0, 0 },
782 { WM_DESTROY
, sent
},
783 { WM_NCDESTROY
, sent
},
786 /* Moving the mouse in nonclient area */
787 static const struct message WmMouseMoveInNonClientAreaSeq
[] = { /* FIXME: add */
788 { WM_NCHITTEST
, sent
},
789 { WM_SETCURSOR
, sent
},
790 { WM_NCMOUSEMOVE
, posted
},
793 /* Moving the mouse in client area */
794 static const struct message WmMouseMoveInClientAreaSeq
[] = { /* FIXME: add */
795 { WM_NCHITTEST
, sent
},
796 { WM_SETCURSOR
, sent
},
797 { WM_MOUSEMOVE
, posted
},
800 /* Moving by dragging the title bar (after WM_NCHITTEST and WM_SETCURSOR) (outline move) */
801 static const struct message WmDragTitleBarSeq
[] = { /* FIXME: add */
802 { WM_NCLBUTTONDOWN
, sent
|wparam
, HTCAPTION
},
803 { WM_SYSCOMMAND
, sent
|defwinproc
|wparam
, SC_MOVE
+2 },
804 { WM_GETMINMAXINFO
, sent
|defwinproc
},
805 { WM_ENTERSIZEMOVE
, sent
|defwinproc
},
806 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, 0 },
807 { WM_WINDOWPOSCHANGED
, sent
|wparam
|defwinproc
, 0 },
808 { WM_MOVE
, sent
|defwinproc
},
809 { WM_EXITSIZEMOVE
, sent
|defwinproc
},
812 /* Sizing by dragging the thick borders (after WM_NCHITTEST and WM_SETCURSOR) (outline move) */
813 static const struct message WmDragThickBordersBarSeq
[] = { /* FIXME: add */
814 { WM_NCLBUTTONDOWN
, sent
|wparam
, 0xd },
815 { WM_SYSCOMMAND
, sent
|defwinproc
|wparam
, 0xf004 },
816 { WM_GETMINMAXINFO
, sent
|defwinproc
},
817 { WM_ENTERSIZEMOVE
, sent
|defwinproc
},
818 { WM_SIZING
, sent
|defwinproc
|wparam
, 4}, /* one for each mouse movement */
819 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, 0 },
820 { WM_GETMINMAXINFO
, sent
|defwinproc
},
821 { WM_NCCALCSIZE
, sent
|defwinproc
|wparam
, 1 },
822 { WM_NCPAINT
, sent
|defwinproc
|wparam
, 1 },
823 { WM_GETTEXT
, sent
|defwinproc
},
824 { WM_ERASEBKGND
, sent
|defwinproc
},
825 { WM_WINDOWPOSCHANGED
, sent
|wparam
|defwinproc
, 0 },
826 { WM_MOVE
, sent
|defwinproc
},
827 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_RESTORED
},
828 { WM_EXITSIZEMOVE
, sent
|defwinproc
},
831 /* Resizing child window with MoveWindow (32) */
832 static const struct message WmResizingChildWithMoveWindowSeq
[] = {
833 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOACTIVATE
},
834 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
835 { WM_ERASEBKGND
, sent
|optional
},
836 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOACTIVATE
},
837 { WM_MOVE
, sent
|defwinproc
},
838 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_RESTORED
},
839 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
842 /* Clicking on inactive button */
843 static const struct message WmClickInactiveButtonSeq
[] = { /* FIXME: add */
844 { WM_NCHITTEST
, sent
},
845 { WM_PARENTNOTIFY
, sent
|parent
|wparam
, WM_LBUTTONDOWN
},
846 { WM_MOUSEACTIVATE
, sent
},
847 { WM_MOUSEACTIVATE
, sent
|parent
|defwinproc
},
848 { WM_SETCURSOR
, sent
},
849 { WM_SETCURSOR
, sent
|parent
|defwinproc
},
850 { WM_LBUTTONDOWN
, posted
},
851 { WM_KILLFOCUS
, posted
|parent
},
852 { WM_SETFOCUS
, posted
},
853 { WM_CTLCOLORBTN
, posted
|parent
},
854 { BM_SETSTATE
, posted
},
855 { WM_CTLCOLORBTN
, posted
|parent
},
856 { WM_LBUTTONUP
, posted
},
857 { BM_SETSTATE
, posted
},
858 { WM_CTLCOLORBTN
, posted
|parent
},
859 { WM_COMMAND
, posted
|parent
},
862 /* Reparenting a button (16/32) */
863 /* The last child (button) reparented gets topmost for its new parent. */
864 static const struct message WmReparentButtonSeq
[] = { /* FIXME: add */
865 { WM_SHOWWINDOW
, sent
|wparam
, 0 },
866 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOMOVE
|SWP_NOSIZE
},
867 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, 0, 0 },
868 { WM_ERASEBKGND
, sent
|parent
},
869 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOMOVE
|SWP_NOSIZE
},
870 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOSIZE
},
871 { WM_CHILDACTIVATE
, sent
},
872 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOSIZE
|SWP_NOREDRAW
},
873 { WM_MOVE
, sent
|defwinproc
},
874 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
877 /* Creation of a custom dialog (32) */
878 static const struct message WmCreateCustomDialogSeq
[] = {
879 { HCBT_CREATEWND
, hook
},
880 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
881 { WM_GETMINMAXINFO
, sent
},
882 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
883 { WM_NCCREATE
, sent
},
884 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
885 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
886 { EVENT_OBJECT_REORDER
, winevent_hook
|wparam
|lparam
, 0, 0 },
887 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
889 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, 0, 0 },
890 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
891 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
892 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
893 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
894 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
895 { HCBT_ACTIVATE
, hook
},
896 { EVENT_SYSTEM_FOREGROUND
, winevent_hook
|wparam
|lparam
, 0, 0 },
898 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
900 { WM_QUERYNEWPALETTE
, sent
|wparam
|lparam
|optional
, 0, 0 },
901 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
903 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOSIZE
|SWP_NOMOVE
},
905 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
906 { WM_NCACTIVATE
, sent
|wparam
, 1 },
907 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
908 { WM_GETTEXT
, sent
|optional
|defwinproc
},
909 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
910 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
911 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
912 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
913 { WM_GETTEXT
, sent
|optional
|defwinproc
},
914 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
915 { WM_ACTIVATE
, sent
|wparam
, 1 },
916 { WM_KILLFOCUS
, sent
|parent
},
917 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
918 { WM_IME_SETCONTEXT
, sent
|parent
|wparam
|optional
, 0 },
919 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
920 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 },
921 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
922 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 2 },
923 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
924 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
925 { WM_SETFOCUS
, sent
},
926 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
927 { WM_GETDLGCODE
, sent
|defwinproc
|wparam
, 0 },
928 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
929 { WM_NCPAINT
, sent
|wparam
, 1 },
930 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
931 { WM_GETTEXT
, sent
|optional
|defwinproc
},
932 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
933 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
934 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
935 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
936 { WM_GETTEXT
, sent
|optional
|defwinproc
},
937 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
938 { WM_ERASEBKGND
, sent
},
939 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
940 { WM_CTLCOLORDLG
, sent
|defwinproc
},
941 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
942 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
943 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
944 { WM_GETTEXT
, sent
|optional
},
945 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
946 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
947 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
948 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
949 { WM_GETTEXT
, sent
|optional
},
950 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
951 { WM_NCCALCSIZE
, sent
|optional
},
952 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
953 { WM_NCPAINT
, sent
|optional
},
954 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
955 { WM_GETTEXT
, sent
|optional
|defwinproc
},
956 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
957 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
958 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
959 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
960 { WM_GETTEXT
, sent
|optional
|defwinproc
},
961 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
962 { WM_ERASEBKGND
, sent
|optional
},
963 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
964 { WM_CTLCOLORDLG
, sent
|optional
|defwinproc
},
965 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
966 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
967 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
968 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
972 /* Calling EndDialog for a custom dialog (32) */
973 static const struct message WmEndCustomDialogSeq
[] = {
974 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
975 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, 0, 0 },
976 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
977 { WM_GETTEXT
, sent
|optional
},
978 { HCBT_ACTIVATE
, hook
},
979 { WM_NCACTIVATE
, sent
|wparam
, 0 },
980 { WM_GETTEXT
, sent
|optional
|defwinproc
},
981 { WM_GETTEXT
, sent
|optional
|defwinproc
},
982 { WM_ACTIVATE
, sent
|wparam
, 0 },
983 { EVENT_SYSTEM_FOREGROUND
, winevent_hook
|wparam
|lparam
, 0, 0 },
984 { WM_WINDOWPOSCHANGING
, sent
|wparam
|optional
, SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
985 { HCBT_SETFOCUS
, hook
},
986 { WM_KILLFOCUS
, sent
},
987 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 },
988 { WM_IME_SETCONTEXT
, sent
|parent
|wparam
|defwinproc
|optional
, 1 },
989 { WM_IME_NOTIFY
, sent
|wparam
|optional
, 1 },
990 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
991 { WM_SETFOCUS
, sent
|parent
|defwinproc
},
994 /* ShowWindow(SW_SHOW) for a custom dialog (initially invisible) */
995 static const struct message WmShowCustomDialogSeq
[] = {
996 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
997 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
998 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
999 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
1000 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
1001 { HCBT_ACTIVATE
, hook
},
1002 { EVENT_SYSTEM_FOREGROUND
, winevent_hook
|wparam
|lparam
, 0, 0 },
1004 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
1005 { WM_QUERYNEWPALETTE
, sent
|wparam
|lparam
|optional
, 0, 0 },
1007 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
1008 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOSIZE
|SWP_NOMOVE
},
1009 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1010 { WM_ACTIVATEAPP
, sent
|wparam
|optional
, 1 },
1011 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
1012 { WM_NCACTIVATE
, sent
|wparam
, 1 },
1013 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1014 { WM_ACTIVATE
, sent
|wparam
, 1 },
1016 { WM_KILLFOCUS
, sent
|parent
},
1017 { WM_IME_SETCONTEXT
, sent
|parent
|wparam
|optional
, 0 },
1018 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
1019 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 },
1020 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
1021 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 2 },
1022 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, OBJID_CLIENT
, 0 },
1023 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1024 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1025 { WM_SETFOCUS
, sent
},
1026 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1027 { WM_GETDLGCODE
, sent
|defwinproc
|wparam
, 0 },
1028 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1029 { WM_NCPAINT
, sent
|wparam
, 1 },
1030 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1031 { WM_ERASEBKGND
, sent
},
1032 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1033 { WM_CTLCOLORDLG
, sent
|defwinproc
},
1035 { EVENT_OBJECT_DEFACTIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1036 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1039 /* Creation and destruction of a modal dialog (32) */
1040 static const struct message WmModalDialogSeq
[] = {
1041 { WM_CANCELMODE
, sent
|parent
},
1042 { HCBT_SETFOCUS
, hook
},
1043 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1044 { WM_KILLFOCUS
, sent
|parent
},
1045 { WM_IME_SETCONTEXT
, sent
|parent
|wparam
|optional
, 0 },
1046 { EVENT_OBJECT_STATECHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1047 { WM_ENABLE
, sent
|parent
|wparam
, 0 },
1048 { HCBT_CREATEWND
, hook
},
1049 { EVENT_OBJECT_REORDER
, winevent_hook
|wparam
|lparam
, 0, 0 },
1050 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1051 { WM_SETFONT
, sent
},
1052 { WM_INITDIALOG
, sent
},
1053 { WM_CHANGEUISTATE
, sent
|optional
},
1054 { WM_SHOWWINDOW
, sent
},
1055 { HCBT_ACTIVATE
, hook
},
1056 { EVENT_SYSTEM_FOREGROUND
, winevent_hook
|wparam
|lparam
, 0, 0 },
1057 { WM_QUERYNEWPALETTE
, sent
|wparam
|lparam
|optional
, 0, 0 },
1058 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOSIZE
|SWP_NOMOVE
},
1059 { WM_NCACTIVATE
, sent
|wparam
, 1 },
1060 { WM_GETTEXT
, sent
|optional
},
1061 { WM_ACTIVATE
, sent
|wparam
, 1 },
1062 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
},
1063 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
1064 { WM_NCPAINT
, sent
},
1065 { WM_GETTEXT
, sent
|optional
},
1066 { WM_ERASEBKGND
, sent
},
1067 { WM_CTLCOLORDLG
, sent
},
1068 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1069 { WM_GETTEXT
, sent
|optional
},
1070 { WM_NCCALCSIZE
, sent
|optional
},
1071 { WM_NCPAINT
, sent
|optional
},
1072 { WM_GETTEXT
, sent
|optional
},
1073 { WM_ERASEBKGND
, sent
|optional
},
1074 { WM_CTLCOLORDLG
, sent
|optional
},
1075 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1076 { WM_PAINT
, sent
|optional
},
1077 { WM_CTLCOLORBTN
, sent
},
1078 { WM_ENTERIDLE
, sent
|parent
|optional
},
1079 { WM_ENTERIDLE
, sent
|parent
|optional
},
1080 { WM_ENTERIDLE
, sent
|parent
|optional
},
1081 { WM_ENTERIDLE
, sent
|parent
|optional
},
1082 { WM_ENTERIDLE
, sent
|parent
|optional
},
1083 { WM_ENTERIDLE
, sent
|parent
|optional
},
1084 { WM_ENTERIDLE
, sent
|parent
|optional
},
1085 { WM_ENTERIDLE
, sent
|parent
|optional
},
1086 { WM_ENTERIDLE
, sent
|parent
|optional
},
1087 { WM_ENTERIDLE
, sent
|parent
|optional
},
1088 { WM_ENTERIDLE
, sent
|parent
|optional
},
1089 { WM_ENTERIDLE
, sent
|parent
|optional
},
1090 { WM_ENTERIDLE
, sent
|parent
|optional
},
1091 { WM_ENTERIDLE
, sent
|parent
|optional
},
1092 { WM_ENTERIDLE
, sent
|parent
|optional
},
1093 { WM_ENTERIDLE
, sent
|parent
|optional
},
1094 { WM_ENTERIDLE
, sent
|parent
|optional
},
1095 { WM_ENTERIDLE
, sent
|parent
|optional
},
1096 { WM_ENTERIDLE
, sent
|parent
|optional
},
1097 { WM_ENTERIDLE
, sent
|parent
|optional
},
1099 { EVENT_OBJECT_STATECHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1100 { WM_ENABLE
, sent
|parent
|wparam
, 1 },
1101 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
},
1102 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1103 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1104 { WM_GETTEXT
, sent
|optional
},
1105 { HCBT_ACTIVATE
, hook
},
1106 { WM_NCACTIVATE
, sent
|wparam
, 0 },
1107 { WM_GETTEXT
, sent
|optional
},
1108 { WM_ACTIVATE
, sent
|wparam
, 0 },
1109 { EVENT_SYSTEM_FOREGROUND
, winevent_hook
|wparam
|lparam
, 0, 0 },
1110 { WM_WINDOWPOSCHANGING
, sent
|optional
},
1111 { HCBT_SETFOCUS
, hook
},
1112 { WM_IME_SETCONTEXT
, sent
|parent
|wparam
|defwinproc
|optional
, 1 },
1113 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1114 { WM_SETFOCUS
, sent
|parent
|defwinproc
},
1115 { EVENT_SYSTEM_DIALOGEND
, winevent_hook
|wparam
|lparam
, 0, 0 },
1116 { HCBT_DESTROYWND
, hook
},
1117 { EVENT_OBJECT_DESTROY
, winevent_hook
|wparam
|lparam
, 0, 0 },
1118 { WM_DESTROY
, sent
},
1119 { WM_NCDESTROY
, sent
},
1122 /* Creation of a modal dialog that is resized inside WM_INITDIALOG (32) */
1123 static const struct message WmCreateModalDialogResizeSeq
[] = { /* FIXME: add */
1124 /* (inside dialog proc, handling WM_INITDIALOG) */
1125 { WM_WINDOWPOSCHANGING
, sent
|wparam
, 0 },
1126 { WM_NCCALCSIZE
, sent
},
1127 { WM_NCACTIVATE
, sent
|parent
|wparam
, 0 },
1128 { WM_GETTEXT
, sent
|defwinproc
},
1129 { WM_ACTIVATE
, sent
|parent
|wparam
, 0 },
1130 { WM_WINDOWPOSCHANGING
, sent
|wparam
, 0 },
1131 { WM_WINDOWPOSCHANGING
, sent
|parent
},
1132 { WM_NCACTIVATE
, sent
|wparam
, 1 },
1133 { WM_ACTIVATE
, sent
|wparam
, 1 },
1134 { WM_WINDOWPOSCHANGED
, sent
|wparam
, 0 },
1135 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_RESTORED
},
1136 /* (setting focus) */
1137 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
1138 { WM_WINDOWPOSCHANGING
, sent
|wparam
, 0 },
1139 { WM_NCPAINT
, sent
},
1140 { WM_GETTEXT
, sent
|defwinproc
},
1141 { WM_ERASEBKGND
, sent
},
1142 { WM_CTLCOLORDLG
, sent
|defwinproc
},
1143 { WM_WINDOWPOSCHANGED
, sent
|wparam
, 0 },
1145 /* (bunch of WM_CTLCOLOR* for each control) */
1146 { WM_PAINT
, sent
|parent
},
1147 { WM_ENTERIDLE
, sent
|parent
|wparam
, 0 },
1148 { WM_SETCURSOR
, sent
|parent
},
1151 /* SetMenu for NonVisible windows with size change*/
1152 static const struct message WmSetMenuNonVisibleSizeChangeSeq
[] = {
1153 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1154 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
1155 { EVENT_OBJECT_REORDER
, winevent_hook
|wparam
|lparam
, 0, 0 },
1156 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOREDRAW
},
1157 { WM_MOVE
, sent
|defwinproc
},
1158 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_RESTORED
},
1159 { WM_NCCALCSIZE
,sent
|wparam
|optional
, 1 }, /* XP */
1160 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1161 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, 0, 0 }, /* XP sends a duplicate */
1162 { WM_GETTEXT
, sent
|optional
},
1163 { WM_NCCALCSIZE
, sent
|wparam
|optional
, 1 },
1166 /* SetMenu for NonVisible windows with no size change */
1167 static const struct message WmSetMenuNonVisibleNoSizeChangeSeq
[] = {
1168 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1169 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
1170 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOREDRAW
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1171 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1174 /* SetMenu for Visible windows with size change */
1175 static const struct message WmSetMenuVisibleSizeChangeSeq
[] = {
1176 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1177 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
1178 { EVENT_OBJECT_REORDER
, winevent_hook
|wparam
|lparam
, 0, 0 },
1179 { WM_NCPAINT
, sent
}, /* wparam != 1 */
1180 { WM_GETTEXT
, sent
|defwinproc
|optional
},
1181 { WM_ERASEBKGND
, sent
|optional
},
1182 { WM_ACTIVATE
, sent
|optional
},
1183 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1184 { WM_MOVE
, sent
|defwinproc
},
1185 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_RESTORED
},
1186 { WM_NCCALCSIZE
, sent
|wparam
|optional
, 1 },
1187 { WM_NCPAINT
, sent
|optional
}, /* wparam != 1 */
1188 { WM_ERASEBKGND
, sent
|optional
},
1189 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1190 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
|optional
, 0, 0 }, /* XP sends a duplicate */
1193 /* SetMenu for Visible windows with no size change */
1194 static const struct message WmSetMenuVisibleNoSizeChangeSeq
[] = {
1195 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1196 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
1197 { WM_NCPAINT
, sent
}, /* wparam != 1 */
1198 { WM_GETTEXT
, sent
|defwinproc
|optional
},
1199 { WM_ERASEBKGND
, sent
|optional
},
1200 { WM_ACTIVATE
, sent
|optional
},
1201 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1202 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1205 /* DrawMenuBar for a visible window */
1206 static const struct message WmDrawMenuBarSeq
[] =
1208 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1209 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
1210 { WM_NCPAINT
, sent
}, /* wparam != 1 */
1211 { WM_GETTEXT
, sent
|defwinproc
|optional
},
1212 { WM_ERASEBKGND
, sent
|optional
},
1213 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1214 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1218 static const struct message WmSetRedrawFalseSeq
[] =
1220 { WM_SETREDRAW
, sent
|wparam
, 0 },
1224 static const struct message WmSetRedrawTrueSeq
[] =
1226 { WM_SETREDRAW
, sent
|wparam
, 1 },
1230 static const struct message WmEnableWindowSeq_1
[] =
1232 { WM_CANCELMODE
, sent
|wparam
|lparam
, 0, 0 },
1233 { EVENT_OBJECT_STATECHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1234 { WM_ENABLE
, sent
|wparam
|lparam
, FALSE
, 0 },
1238 static const struct message WmEnableWindowSeq_2
[] =
1240 { EVENT_OBJECT_STATECHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1241 { WM_ENABLE
, sent
|wparam
|lparam
, TRUE
, 0 },
1245 static const struct message WmGetScrollRangeSeq
[] =
1247 { SBM_GETRANGE
, sent
},
1250 static const struct message WmGetScrollInfoSeq
[] =
1252 { SBM_GETSCROLLINFO
, sent
},
1255 static const struct message WmSetScrollRangeSeq
[] =
1257 /* MSDN claims that Windows sends SBM_SETRANGE message, but win2k SP4
1258 sends SBM_SETSCROLLINFO.
1260 { SBM_SETSCROLLINFO
, sent
},
1263 /* SetScrollRange for a window without a non-client area */
1264 static const struct message WmSetScrollRangeHSeq_empty
[] =
1266 { EVENT_OBJECT_VALUECHANGE
, winevent_hook
|wparam
|lparam
, OBJID_HSCROLL
, 0 },
1269 static const struct message WmSetScrollRangeVSeq_empty
[] =
1271 { EVENT_OBJECT_VALUECHANGE
, winevent_hook
|wparam
|lparam
, OBJID_VSCROLL
, 0 },
1274 static const struct message WmSetScrollRangeHVSeq
[] =
1276 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOMOVE
|SWP_NOSIZE
},
1277 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
1278 { WM_GETTEXT
, sent
|defwinproc
|optional
},
1279 { WM_ERASEBKGND
, sent
|optional
},
1280 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOMOVE
|SWP_NOSIZE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1281 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1282 { EVENT_OBJECT_VALUECHANGE
, winevent_hook
|lparam
|optional
, 0/*OBJID_HSCROLL or OBJID_VSCROLL*/, 0 },
1285 /* SetScrollRange for a window with a non-client area */
1286 static const struct message WmSetScrollRangeHV_NC_Seq
[] =
1288 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOMOVE
|SWP_NOSIZE
},
1289 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
1290 { EVENT_OBJECT_REORDER
, winevent_hook
|wparam
|lparam
, 0, 0 },
1291 { WM_NCPAINT
, sent
|optional
},
1292 { WM_GETTEXT
, sent
|defwinproc
|optional
},
1293 { WM_GETTEXT
, sent
|defwinproc
|optional
},
1294 { WM_ERASEBKGND
, sent
|optional
},
1295 { WM_CTLCOLORDLG
, sent
|defwinproc
|optional
}, /* sent to a parent of the dialog */
1296 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOMOVE
|SWP_NOSIZE
|SWP_NOCLIENTMOVE
},
1297 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_RESTORED
},
1298 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1299 { EVENT_OBJECT_VALUECHANGE
, winevent_hook
|lparam
|optional
, 0/*OBJID_HSCROLL or OBJID_VSCROLL*/, 0 },
1300 { WM_GETTEXT
, sent
|optional
},
1301 { WM_GETTEXT
, sent
|optional
},
1302 { WM_GETTEXT
, sent
|optional
},
1303 { WM_GETTEXT
, sent
|optional
},
1306 /* test if we receive the right sequence of messages */
1307 /* after calling ShowWindow( SW_SHOWNA) */
1308 static const struct message WmSHOWNAChildInvisParInvis
[] = {
1309 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
1312 static const struct message WmSHOWNAChildVisParInvis
[] = {
1313 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
1316 static const struct message WmSHOWNAChildVisParVis
[] = {
1317 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
1318 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
},
1321 static const struct message WmSHOWNAChildInvisParVis
[] = {
1322 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
1323 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1324 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
1325 { WM_ERASEBKGND
, sent
|optional
},
1326 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOACTIVATE
|SWP_NOCLIENTMOVE
},
1329 static const struct message WmSHOWNATopVisible
[] = {
1330 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
1331 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
},
1334 static const struct message WmSHOWNATopInvisible
[] = {
1335 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
1336 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1337 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
1338 { WM_NCPAINT
, sent
|wparam
, 1 },
1339 { WM_GETTEXT
, sent
|defwinproc
|optional
},
1340 { WM_ERASEBKGND
, sent
|optional
},
1341 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1342 { WM_NCCALCSIZE
, sent
|wparam
|optional
, 1 },
1343 { WM_NCPAINT
, sent
|wparam
|optional
, 1 },
1344 { WM_ERASEBKGND
, sent
|optional
},
1345 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1346 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
1351 static int after_end_dialog
;
1352 static int sequence_cnt
, sequence_size
;
1353 static struct message
* sequence
;
1354 static int log_all_parent_messages
;
1356 static void add_message(const struct message
*msg
)
1361 sequence
= HeapAlloc( GetProcessHeap(), 0, sequence_size
* sizeof (struct message
) );
1363 if (sequence_cnt
== sequence_size
)
1366 sequence
= HeapReAlloc( GetProcessHeap(), 0, sequence
, sequence_size
* sizeof (struct message
) );
1370 sequence
[sequence_cnt
].message
= msg
->message
;
1371 sequence
[sequence_cnt
].flags
= msg
->flags
;
1372 sequence
[sequence_cnt
].wParam
= msg
->wParam
;
1373 sequence
[sequence_cnt
].lParam
= msg
->lParam
;
1378 /* try to make sure pending X events have been processed before continuing */
1379 static void flush_events(void)
1383 DWORD time
= GetTickCount() + diff
;
1387 MsgWaitForMultipleObjects( 0, NULL
, FALSE
, diff
, QS_ALLINPUT
);
1388 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
1389 diff
= time
- GetTickCount();
1393 static void flush_sequence(void)
1395 HeapFree(GetProcessHeap(), 0, sequence
);
1397 sequence_cnt
= sequence_size
= 0;
1400 #define ok_sequence( exp, contx, todo) \
1401 ok_sequence_( (exp), (contx), (todo), __FILE__, __LINE__)
1404 static void ok_sequence_(const struct message
*expected
, const char *context
, int todo
,
1405 const char *file
, int line
)
1407 static const struct message end_of_sequence
= { 0, 0, 0, 0 };
1408 const struct message
*actual
;
1411 add_message(&end_of_sequence
);
1415 while (expected
->message
&& actual
->message
)
1417 trace_( file
, line
)("expected %04x - actual %04x\n", expected
->message
, actual
->message
);
1419 if (expected
->message
== actual
->message
)
1421 if (expected
->flags
& wparam
)
1423 if (expected
->wParam
!= actual
->wParam
&& todo
)
1427 ok_( file
, line
) (FALSE
,
1428 "%s: in msg 0x%04x expecting wParam 0x%x got 0x%x\n",
1429 context
, expected
->message
, expected
->wParam
, actual
->wParam
);
1433 ok_( file
, line
) (expected
->wParam
== actual
->wParam
,
1434 "%s: in msg 0x%04x expecting wParam 0x%x got 0x%x\n",
1435 context
, expected
->message
, expected
->wParam
, actual
->wParam
);
1437 if (expected
->flags
& lparam
)
1439 if (expected
->lParam
!= actual
->lParam
&& todo
)
1443 ok_( file
, line
) (FALSE
,
1444 "%s: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
1445 context
, expected
->message
, expected
->lParam
, actual
->lParam
);
1449 ok_( file
, line
) (expected
->lParam
== actual
->lParam
,
1450 "%s: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
1451 context
, expected
->message
, expected
->lParam
, actual
->lParam
);
1453 if ((expected
->flags
& defwinproc
) != (actual
->flags
& defwinproc
) && todo
)
1457 ok_( file
, line
) (FALSE
,
1458 "%s: the msg 0x%04x should %shave been sent by DefWindowProc\n",
1459 context
, expected
->message
, (expected
->flags
& defwinproc
) ? "" : "NOT ");
1463 ok_( file
, line
) ((expected
->flags
& defwinproc
) == (actual
->flags
& defwinproc
),
1464 "%s: the msg 0x%04x should %shave been sent by DefWindowProc\n",
1465 context
, expected
->message
, (expected
->flags
& defwinproc
) ? "" : "NOT ");
1466 ok_( file
, line
) ((expected
->flags
& beginpaint
) == (actual
->flags
& beginpaint
),
1467 "%s: the msg 0x%04x should %shave been sent by BeginPaint\n",
1468 context
, expected
->message
, (expected
->flags
& beginpaint
) ? "" : "NOT ");
1469 ok_( file
, line
) ((expected
->flags
& (sent
|posted
)) == (actual
->flags
& (sent
|posted
)),
1470 "%s: the msg 0x%04x should have been %s\n",
1471 context
, expected
->message
, (expected
->flags
& posted
) ? "posted" : "sent");
1472 ok_( file
, line
) ((expected
->flags
& parent
) == (actual
->flags
& parent
),
1473 "%s: the msg 0x%04x was expected in %s\n",
1474 context
, expected
->message
, (expected
->flags
& parent
) ? "parent" : "child");
1475 ok_( file
, line
) ((expected
->flags
& hook
) == (actual
->flags
& hook
),
1476 "%s: the msg 0x%04x should have been sent by a hook\n",
1477 context
, expected
->message
);
1478 ok_( file
, line
) ((expected
->flags
& winevent_hook
) == (actual
->flags
& winevent_hook
),
1479 "%s: the msg 0x%04x should have been sent by a winevent hook\n",
1480 context
, expected
->message
);
1484 /* silently drop winevent messages if there is no support for them */
1485 else if ((expected
->flags
& optional
) || ((expected
->flags
& winevent_hook
) && !hEvent_hook
))
1491 ok_( file
, line
) (FALSE
, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
1492 context
, expected
->message
, actual
->message
);
1499 ok_( file
, line
) (FALSE
, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
1500 context
, expected
->message
, actual
->message
);
1506 /* skip all optional trailing messages */
1507 while (expected
->message
&& ((expected
->flags
& optional
) ||
1508 ((expected
->flags
& winevent_hook
) && !hEvent_hook
)))
1514 if (expected
->message
|| actual
->message
) {
1516 ok_( file
, line
) (FALSE
, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
1517 context
, expected
->message
, actual
->message
);
1523 if (expected
->message
|| actual
->message
)
1524 ok_( file
, line
) (FALSE
, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
1525 context
, expected
->message
, actual
->message
);
1527 if( todo
&& !failcount
) /* succeeded yet marked todo */
1529 ok_( file
, line
)( TRUE
, "%s: marked \"todo_wine\" but succeeds\n", context
);
1535 /******************************** MDI test **********************************/
1537 /* CreateWindow for MDI frame window, initially visible */
1538 static const struct message WmCreateMDIframeSeq
[] = {
1539 { HCBT_CREATEWND
, hook
},
1540 { WM_GETMINMAXINFO
, sent
},
1541 { WM_NCCREATE
, sent
},
1542 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
1543 { EVENT_OBJECT_REORDER
, winevent_hook
|wparam
|lparam
, 0, 0 },
1544 { WM_CREATE
, sent
},
1545 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1546 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
1547 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
1548 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
1549 { HCBT_ACTIVATE
, hook
},
1550 { EVENT_SYSTEM_FOREGROUND
, winevent_hook
|wparam
|lparam
, 0, 0 },
1551 { WM_QUERYNEWPALETTE
, sent
|wparam
|lparam
|optional
, 0, 0 },
1552 { WM_WINDOWPOSCHANGING
, sent
|wparam
|optional
, SWP_NOSIZE
|SWP_NOMOVE
}, /* XP */
1553 { WM_ACTIVATEAPP
, sent
|wparam
|optional
, 1 }, /* Win9x doesn't send it */
1554 { WM_NCACTIVATE
, sent
|wparam
, 1 },
1555 { WM_GETTEXT
, sent
|defwinproc
|optional
},
1556 { WM_ACTIVATE
, sent
|wparam
, 1 },
1557 { WM_WINDOWPOSCHANGING
, sent
|wparam
|optional
, SWP_NOSIZE
|SWP_NOMOVE
}, /* Win9x */
1558 { HCBT_SETFOCUS
, hook
},
1559 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
1560 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 2 },
1561 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1562 { WM_SETFOCUS
, sent
|wparam
|defwinproc
, 0 },
1563 /* Win9x adds SWP_NOZORDER below */
1564 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1565 { WM_NCCALCSIZE
, sent
|wparam
|optional
, 1 }, /* XP */
1566 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1567 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
1571 /* DestroyWindow for MDI frame window, initially visible */
1572 static const struct message WmDestroyMDIframeSeq
[] = {
1573 { HCBT_DESTROYWND
, hook
},
1574 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1575 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1576 { WM_NCACTIVATE
, sent
|wparam
|optional
, 0 }, /* Win9x */
1577 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1578 { WM_NCACTIVATE
, sent
|wparam
|optional
, 0 }, /* XP */
1579 { WM_ACTIVATE
, sent
|wparam
|optional
, 0 }, /* Win9x */
1580 { WM_ACTIVATEAPP
, sent
|wparam
|optional
, 0 }, /* Win9x */
1581 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 },
1582 { EVENT_OBJECT_DESTROY
, winevent_hook
|wparam
|lparam
, 0, 0 },
1583 { WM_DESTROY
, sent
},
1584 { WM_NCDESTROY
, sent
},
1587 /* CreateWindow for MDI client window, initially visible */
1588 static const struct message WmCreateMDIclientSeq
[] = {
1589 { HCBT_CREATEWND
, hook
},
1590 { WM_NCCREATE
, sent
},
1591 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
1592 { WM_CREATE
, sent
},
1593 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1594 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
1596 { WM_PARENTNOTIFY
, sent
|wparam
, WM_CREATE
}, /* in MDI frame */
1597 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
1598 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1599 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
1600 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1603 /* ShowWindow(SW_SHOW) for MDI client window */
1604 static const struct message WmShowMDIclientSeq
[] = {
1605 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
1606 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1607 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
1608 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1611 /* ShowWindow(SW_HIDE) for MDI client window */
1612 static const struct message WmHideMDIclientSeq
[] = {
1613 { WM_SHOWWINDOW
, sent
|wparam
, 0 },
1614 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1615 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
1616 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1619 /* DestroyWindow for MDI client window, initially visible */
1620 static const struct message WmDestroyMDIclientSeq
[] = {
1621 { HCBT_DESTROYWND
, hook
},
1622 { WM_PARENTNOTIFY
, sent
|wparam
, WM_DESTROY
}, /* in MDI frame */
1623 { WM_SHOWWINDOW
, sent
|wparam
, 0 },
1624 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1625 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1626 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1627 { EVENT_OBJECT_DESTROY
, winevent_hook
|wparam
|lparam
, 0, 0 },
1628 { WM_DESTROY
, sent
},
1629 { WM_NCDESTROY
, sent
},
1632 /* CreateWindow for MDI child window, initially visible */
1633 static const struct message WmCreateMDIchildVisibleSeq
[] = {
1634 { HCBT_CREATEWND
, hook
},
1635 { WM_NCCREATE
, sent
},
1636 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
1637 { WM_CREATE
, sent
},
1638 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1639 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
1641 /* Win2k sends wparam set to
1642 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1643 * while Win9x doesn't bother to set child window id according to
1644 * CLIENTCREATESTRUCT.idFirstChild
1646 { WM_PARENTNOTIFY
, sent
/*|wparam, WM_CREATE*/ }, /* in MDI client */
1647 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
1648 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1649 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
1650 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1651 { WM_MDIREFRESHMENU
, sent
/*|wparam|lparam, 0, 0*/ },
1652 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
1653 { WM_CHILDACTIVATE
, sent
|wparam
|lparam
, 0, 0 },
1654 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1656 /* Win9x: message sequence terminates here. */
1658 { WM_NCACTIVATE
, sent
|wparam
|defwinproc
, 1 },
1659 { HCBT_SETFOCUS
, hook
}, /* in MDI client */
1660 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 }, /* in MDI client */
1661 { WM_IME_NOTIFY
, sent
|wparam
|optional
, 2 }, /* in MDI client */
1662 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1663 { WM_SETFOCUS
, sent
}, /* in MDI client */
1664 { HCBT_SETFOCUS
, hook
},
1665 { WM_KILLFOCUS
, sent
}, /* in MDI client */
1666 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 }, /* in MDI client */
1667 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
1668 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1669 { WM_SETFOCUS
, sent
|defwinproc
},
1670 { WM_MDIACTIVATE
, sent
|defwinproc
},
1673 /* CreateWindow for MDI child window with invisible parent */
1674 static const struct message WmCreateMDIchildInvisibleParentSeq
[] = {
1675 { HCBT_CREATEWND
, hook
},
1676 { WM_GETMINMAXINFO
, sent
},
1677 { WM_NCCREATE
, sent
},
1678 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
1679 { WM_CREATE
, sent
},
1680 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1681 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
1683 { WM_PARENTNOTIFY
, sent
/*|wparam, WM_CREATE*/ }, /* in MDI client */
1684 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
1685 { WM_MDIREFRESHMENU
, sent
}, /* in MDI client */
1686 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
1687 { WM_CHILDACTIVATE
, sent
|wparam
|lparam
, 0, 0 },
1688 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1690 /* Win9x: message sequence terminates here. */
1692 { WM_NCACTIVATE
, sent
|wparam
|defwinproc
, 1 },
1693 { HCBT_SETFOCUS
, hook
}, /* in MDI client */
1694 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 }, /* in MDI client */
1695 { WM_IME_NOTIFY
, sent
|wparam
|optional
, 2 }, /* in MDI client */
1696 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1697 { WM_SETFOCUS
, sent
}, /* in MDI client */
1698 { HCBT_SETFOCUS
, hook
},
1699 { WM_KILLFOCUS
, sent
}, /* in MDI client */
1700 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 }, /* in MDI client */
1701 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
1702 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1703 { WM_SETFOCUS
, sent
|defwinproc
},
1704 { WM_MDIACTIVATE
, sent
|defwinproc
},
1707 /* DestroyWindow for MDI child window, initially visible */
1708 static const struct message WmDestroyMDIchildVisibleSeq
[] = {
1709 { HCBT_DESTROYWND
, hook
},
1710 /* Win2k sends wparam set to
1711 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
1712 * while Win9x doesn't bother to set child window id according to
1713 * CLIENTCREATESTRUCT.idFirstChild
1715 { WM_PARENTNOTIFY
, sent
/*|wparam, WM_DESTROY*/ }, /* in MDI client */
1716 { WM_SHOWWINDOW
, sent
|wparam
, 0 },
1717 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1718 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1719 { WM_ERASEBKGND
, sent
|parent
|optional
},
1720 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1722 /* { WM_DESTROY, sent }
1723 * Win9x: message sequence terminates here.
1726 { HCBT_SETFOCUS
, hook
}, /* set focus to MDI client */
1727 { WM_KILLFOCUS
, sent
},
1728 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 },
1729 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 }, /* in MDI client */
1730 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1731 { WM_SETFOCUS
, sent
}, /* in MDI client */
1733 { HCBT_SETFOCUS
, hook
}, /* MDI client sets focus back to MDI child */
1734 { WM_KILLFOCUS
, sent
}, /* in MDI client */
1735 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 }, /* in MDI client */
1736 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 },
1737 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1738 { WM_SETFOCUS
, sent
}, /* in MDI client */
1740 { EVENT_OBJECT_DESTROY
, winevent_hook
|wparam
|lparam
, 0, 0 },
1742 { HCBT_SETFOCUS
, hook
}, /* set focus to MDI client */
1743 { WM_KILLFOCUS
, sent
},
1744 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 },
1745 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 }, /* in MDI client */
1746 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1747 { WM_SETFOCUS
, sent
}, /* in MDI client */
1749 { HCBT_SETFOCUS
, hook
}, /* MDI client sets focus back to MDI child */
1750 { WM_KILLFOCUS
, sent
}, /* in MDI client */
1751 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 }, /* in MDI client */
1752 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 },
1753 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1754 { WM_SETFOCUS
, sent
}, /* in MDI client */
1756 { WM_DESTROY
, sent
},
1758 { HCBT_SETFOCUS
, hook
}, /* set focus to MDI client */
1759 { WM_KILLFOCUS
, sent
},
1760 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 },
1761 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 }, /* in MDI client */
1762 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1763 { WM_SETFOCUS
, sent
}, /* in MDI client */
1765 { HCBT_SETFOCUS
, hook
}, /* MDI client sets focus back to MDI child */
1766 { WM_KILLFOCUS
, sent
}, /* in MDI client */
1767 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 }, /* in MDI client */
1768 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 },
1769 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1770 { WM_SETFOCUS
, sent
}, /* in MDI client */
1772 { WM_NCDESTROY
, sent
},
1775 /* CreateWindow for MDI child window, initially invisible */
1776 static const struct message WmCreateMDIchildInvisibleSeq
[] = {
1777 { HCBT_CREATEWND
, hook
},
1778 { WM_NCCREATE
, sent
},
1779 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
1780 { WM_CREATE
, sent
},
1781 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1782 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
1784 /* Win2k sends wparam set to
1785 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1786 * while Win9x doesn't bother to set child window id according to
1787 * CLIENTCREATESTRUCT.idFirstChild
1789 { WM_PARENTNOTIFY
, sent
/*|wparam, WM_CREATE*/ }, /* in MDI client */
1792 /* DestroyWindow for MDI child window, initially invisible */
1793 static const struct message WmDestroyMDIchildInvisibleSeq
[] = {
1794 { HCBT_DESTROYWND
, hook
},
1795 /* Win2k sends wparam set to
1796 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
1797 * while Win9x doesn't bother to set child window id according to
1798 * CLIENTCREATESTRUCT.idFirstChild
1800 { WM_PARENTNOTIFY
, sent
/*|wparam, WM_DESTROY*/ }, /* in MDI client */
1801 { EVENT_OBJECT_DESTROY
, winevent_hook
|wparam
|lparam
, 0, 0 },
1802 { WM_DESTROY
, sent
},
1803 { WM_NCDESTROY
, sent
},
1806 /* CreateWindow for the 1st MDI child window, initially visible and maximized */
1807 static const struct message WmCreateMDIchildVisibleMaxSeq1
[] = {
1808 { HCBT_CREATEWND
, hook
},
1809 { WM_NCCREATE
, sent
},
1810 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
1811 { WM_CREATE
, sent
},
1812 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1813 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
1815 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MAXIMIZE
},
1816 { WM_GETMINMAXINFO
, sent
},
1817 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|0x8000 },
1818 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
1819 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOREDRAW
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
|0x8000 },
1820 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
1822 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1823 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
1824 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1825 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
1826 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
1827 /* Win2k sends wparam set to
1828 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1829 * while Win9x doesn't bother to set child window id according to
1830 * CLIENTCREATESTRUCT.idFirstChild
1832 { WM_PARENTNOTIFY
, sent
/*|wparam, WM_CREATE*/ }, /* in MDI client */
1833 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
1834 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1835 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
1836 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1837 { WM_MDIREFRESHMENU
, sent
/*|wparam|lparam, 0, 0*/ },
1838 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
1839 { WM_CHILDACTIVATE
, sent
|wparam
|lparam
, 0, 0 },
1840 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1842 /* Win9x: message sequence terminates here. */
1844 { WM_NCACTIVATE
, sent
|wparam
|defwinproc
, 1 },
1845 { HCBT_SETFOCUS
, hook
}, /* in MDI client */
1846 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 }, /* in MDI client */
1847 { WM_IME_NOTIFY
, sent
|wparam
|optional
, 2 }, /* in MDI client */
1848 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1849 { WM_SETFOCUS
, sent
}, /* in MDI client */
1850 { HCBT_SETFOCUS
, hook
},
1851 { WM_KILLFOCUS
, sent
}, /* in MDI client */
1852 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 }, /* in MDI client */
1853 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
1854 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1855 { WM_SETFOCUS
, sent
|defwinproc
},
1856 { WM_MDIACTIVATE
, sent
|defwinproc
},
1858 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1859 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
1860 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1861 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
1864 /* CreateWindow for the 2nd MDI child window, initially visible and maximized */
1865 static const struct message WmCreateMDIchildVisibleMaxSeq2
[] = {
1866 /* restore the 1st MDI child */
1867 { WM_SETREDRAW
, sent
|wparam
, 0 },
1868 { HCBT_MINMAX
, hook
|lparam
, 0, SW_SHOWNORMAL
},
1869 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|0x8000 },
1870 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
1871 { WM_CHILDACTIVATE
, sent
|wparam
|lparam
, 0, 0 },
1872 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOREDRAW
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
|0x8000 },
1873 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_RESTORED
},
1875 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1876 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
1877 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1878 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
1879 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
1880 { WM_SETREDRAW
, sent
|wparam
, 1 }, /* in the 1st MDI child */
1881 /* create the 2nd MDI child */
1882 { HCBT_CREATEWND
, hook
},
1883 { WM_NCCREATE
, sent
},
1884 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
1885 { WM_CREATE
, sent
},
1886 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1887 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
1889 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MAXIMIZE
},
1890 { WM_GETMINMAXINFO
, sent
},
1891 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|0x8000 },
1892 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
1893 { EVENT_OBJECT_REORDER
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1894 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOREDRAW
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
|0x8000 },
1895 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
1897 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1898 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
1899 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1900 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
1901 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
1902 /* Win2k sends wparam set to
1903 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1904 * while Win9x doesn't bother to set child window id according to
1905 * CLIENTCREATESTRUCT.idFirstChild
1907 { WM_PARENTNOTIFY
, sent
/*|wparam, WM_CREATE*/ }, /* in MDI client */
1908 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
1909 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1910 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
1911 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1912 { WM_MDIREFRESHMENU
, sent
/*|wparam|lparam, 0, 0*/ },
1913 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
1914 { WM_CHILDACTIVATE
, sent
|wparam
|lparam
, 0, 0 },
1916 { WM_NCACTIVATE
, sent
|wparam
|defwinproc
, 0 }, /* in the 1st MDI child */
1917 { WM_MDIACTIVATE
, sent
|defwinproc
}, /* in the 1st MDI child */
1919 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1921 /* Win9x: message sequence terminates here. */
1923 { WM_NCACTIVATE
, sent
|wparam
|defwinproc
, 1 },
1924 { HCBT_SETFOCUS
, hook
},
1925 { WM_KILLFOCUS
, sent
|defwinproc
}, /* in the 1st MDI child */
1926 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 0 }, /* in the 1st MDI child */
1927 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 }, /* in MDI client */
1928 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1929 { WM_SETFOCUS
, sent
}, /* in MDI client */
1930 { HCBT_SETFOCUS
, hook
},
1931 { WM_KILLFOCUS
, sent
}, /* in MDI client */
1932 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 }, /* in MDI client */
1933 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
1934 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1935 { WM_SETFOCUS
, sent
|defwinproc
},
1937 { WM_MDIACTIVATE
, sent
|defwinproc
},
1939 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1940 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
1941 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1942 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
1945 /* WM_MDICREATE MDI child window, initially visible and maximized */
1946 static const struct message WmCreateMDIchildVisibleMaxSeq3
[] = {
1947 { WM_MDICREATE
, sent
},
1948 { HCBT_CREATEWND
, hook
},
1949 { WM_NCCREATE
, sent
},
1950 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
1951 { WM_CREATE
, sent
},
1952 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, 0, 0 },
1953 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
1955 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MAXIMIZE
},
1956 { WM_GETMINMAXINFO
, sent
},
1957 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|0x8000 },
1958 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
1959 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOREDRAW
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
|0x8000 },
1960 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
1963 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1964 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
1965 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1966 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
1967 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
1969 /* Win2k sends wparam set to
1970 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1971 * while Win9x doesn't bother to set child window id according to
1972 * CLIENTCREATESTRUCT.idFirstChild
1974 { WM_PARENTNOTIFY
, sent
/*|wparam, WM_CREATE*/ }, /* in MDI client */
1975 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
1976 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1978 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
1980 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
1981 { WM_MDIREFRESHMENU
, sent
/*|wparam|lparam, 0, 0*/ },
1982 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
1984 { WM_CHILDACTIVATE
, sent
|wparam
|lparam
, 0, 0 },
1985 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
1987 /* Win9x: message sequence terminates here. */
1989 { WM_NCACTIVATE
, sent
|wparam
|defwinproc
, 1 },
1990 { WM_SETFOCUS
, sent
|optional
}, /* in MDI client */
1991 { HCBT_SETFOCUS
, hook
}, /* in MDI client */
1992 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 }, /* in MDI client */
1993 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
1994 { WM_SETFOCUS
, sent
|optional
}, /* in MDI client */
1995 { HCBT_SETFOCUS
, hook
|optional
},
1996 { WM_KILLFOCUS
, sent
}, /* in MDI client */
1997 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 }, /* in MDI client */
1998 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
1999 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
2000 { WM_SETFOCUS
, sent
|defwinproc
},
2002 { WM_MDIACTIVATE
, sent
|defwinproc
},
2005 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2006 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2007 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
2008 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
2011 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2012 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2013 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2014 { WM_MOVE
, sent
|defwinproc
},
2015 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_RESTORED
},
2018 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOACTIVATE
},
2019 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2020 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOACTIVATE
|SWP_NOMOVE
|SWP_NOCLIENTMOVE
},
2021 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
2024 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOACTIVATE
},
2025 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2026 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOACTIVATE
|SWP_NOMOVE
|SWP_NOCLIENTMOVE
},
2027 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
2029 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
2030 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI client */
2031 { WM_NCCALCSIZE
, sent
|wparam
|optional
, 1 }, /* XP sends it to MDI frame */
2032 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
2033 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* XP sends a duplicate */
2037 /* CreateWindow for the 1st MDI child window, initially invisible and maximized */
2038 static const struct message WmCreateMDIchildInvisibleMaxSeq4
[] = {
2039 { HCBT_CREATEWND
, hook
},
2040 { WM_GETMINMAXINFO
, sent
},
2041 { WM_NCCREATE
, sent
},
2042 { WM_NCCALCSIZE
, sent
|wparam
, 0 },
2043 { EVENT_OBJECT_REORDER
, winevent_hook
|wparam
|lparam
, 0, 0 },
2044 { WM_CREATE
, sent
},
2045 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, 0, 0 },
2046 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
2048 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MAXIMIZE
},
2049 { WM_GETMINMAXINFO
, sent
},
2050 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|0x8000 },
2051 { WM_GETMINMAXINFO
, sent
|defwinproc
},
2052 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2053 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOREDRAW
|SWP_NOCLIENTSIZE
|0x8000 },
2054 { WM_MOVE
, sent
|defwinproc
},
2055 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
2057 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2058 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2059 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
2060 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
2061 { WM_NCCALCSIZE
, sent
|wparam
, 1 }, /* MDI child */
2062 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
2063 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
2064 /* Win2k sends wparam set to
2065 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2066 * while Win9x doesn't bother to set child window id according to
2067 * CLIENTCREATESTRUCT.idFirstChild
2069 { WM_PARENTNOTIFY
, sent
/*|wparam, WM_CREATE*/ }, /* in MDI client */
2072 /* WM_SYSCOMMAND/SC_CLOSE for the 2nd MDI child window, initially visible and maximized */
2073 static const struct message WmDestroyMDIchildVisibleMaxSeq2
[] = {
2074 { WM_SYSCOMMAND
, sent
|wparam
, SC_CLOSE
},
2075 { HCBT_SYSCOMMAND
, hook
},
2076 { WM_CLOSE
, sent
|defwinproc
},
2077 { WM_MDIDESTROY
, sent
}, /* in MDI client */
2079 /* bring the 1st MDI child to top */
2080 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_NOSIZE
|SWP_NOMOVE
}, /* in the 1st MDI child */
2081 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
}, /* in the 2nd MDI child */
2083 { EVENT_OBJECT_REORDER
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
2085 { WM_CHILDACTIVATE
, sent
|defwinproc
|wparam
|lparam
, 0, 0 }, /* in the 1st MDI child */
2086 { WM_NCACTIVATE
, sent
|wparam
|defwinproc
, 0 }, /* in the 1st MDI child */
2087 { WM_MDIACTIVATE
, sent
|defwinproc
}, /* in the 1st MDI child */
2089 /* maximize the 1st MDI child */
2090 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MAXIMIZE
},
2091 { WM_GETMINMAXINFO
, sent
|defwinproc
},
2092 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_FRAMECHANGED
|0x8000 },
2093 { WM_NCCALCSIZE
, sent
|defwinproc
|wparam
, 1 },
2094 { WM_CHILDACTIVATE
, sent
|defwinproc
|wparam
|lparam
, 0, 0 },
2095 { WM_WINDOWPOSCHANGED
, sent
|wparam
|defwinproc
, SWP_FRAMECHANGED
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOREDRAW
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
|0x8000 },
2096 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
2098 /* restore the 2nd MDI child */
2099 { WM_SETREDRAW
, sent
|defwinproc
|wparam
, 0 },
2100 { HCBT_MINMAX
, hook
|lparam
, 0, SW_NORMALNA
},
2101 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_SHOWWINDOW
|0x8000 },
2102 { WM_NCCALCSIZE
, sent
|defwinproc
|wparam
, 1 },
2104 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
2106 { WM_WINDOWPOSCHANGED
, sent
|wparam
|defwinproc
, SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOREDRAW
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
|0x8000 },
2107 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_RESTORED
},
2109 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
2111 { WM_SETREDRAW
, sent
|defwinproc
|wparam
, 1 },
2113 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2114 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2115 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
2116 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
2117 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
2119 /* bring the 1st MDI child to top */
2120 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2121 { WM_NCACTIVATE
, sent
|wparam
|defwinproc
, 1 },
2122 { HCBT_SETFOCUS
, hook
},
2123 { WM_KILLFOCUS
, sent
|defwinproc
},
2124 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 0 },
2125 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 }, /* in MDI client */
2126 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
2127 { WM_SETFOCUS
, sent
}, /* in MDI client */
2128 { HCBT_SETFOCUS
, hook
},
2129 { WM_KILLFOCUS
, sent
}, /* in MDI client */
2130 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 }, /* in MDI client */
2131 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
2132 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
2133 { WM_SETFOCUS
, sent
|defwinproc
},
2134 { WM_MDIACTIVATE
, sent
|defwinproc
},
2135 { WM_WINDOWPOSCHANGED
, sent
|wparam
|defwinproc
, SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOREDRAW
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
2137 /* apparently ShowWindow(SW_SHOW) on an MDI client */
2138 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
2139 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2140 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
2141 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
2142 { WM_MDIREFRESHMENU
, sent
},
2144 { HCBT_DESTROYWND
, hook
},
2145 /* Win2k sends wparam set to
2146 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
2147 * while Win9x doesn't bother to set child window id according to
2148 * CLIENTCREATESTRUCT.idFirstChild
2150 { WM_PARENTNOTIFY
, sent
/*|wparam, WM_DESTROY*/ }, /* in MDI client */
2151 { WM_SHOWWINDOW
, sent
|defwinproc
|wparam
, 0 },
2152 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2153 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, 0, 0 },
2154 { WM_ERASEBKGND
, sent
|parent
|optional
},
2155 { WM_WINDOWPOSCHANGED
, sent
|wparam
|defwinproc
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
2157 { EVENT_OBJECT_DESTROY
, winevent_hook
|wparam
|lparam
, 0, 0 },
2158 { WM_DESTROY
, sent
|defwinproc
},
2159 { WM_NCDESTROY
, sent
|defwinproc
},
2162 /* WM_MDIDESTROY for the single MDI child window, initially visible and maximized */
2163 static const struct message WmDestroyMDIchildVisibleMaxSeq1
[] = {
2164 { WM_MDIDESTROY
, sent
}, /* in MDI client */
2165 { WM_SHOWWINDOW
, sent
|wparam
, 0 },
2166 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2167 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, 0, 0 },
2168 { WM_ERASEBKGND
, sent
|parent
|optional
},
2169 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
2171 { HCBT_SETFOCUS
, hook
},
2172 { WM_KILLFOCUS
, sent
},
2173 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 },
2174 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 }, /* in MDI client */
2175 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
2176 { WM_SETFOCUS
, sent
}, /* in MDI client */
2177 { HCBT_SETFOCUS
, hook
},
2178 { WM_KILLFOCUS
, sent
}, /* in MDI client */
2179 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 }, /* in MDI client */
2180 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 },
2181 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
2182 { WM_SETFOCUS
, sent
},
2185 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2186 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2187 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOREDRAW
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
2188 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
2191 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2192 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2193 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2194 { WM_MOVE
, sent
|defwinproc
},
2195 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_RESTORED
},
2198 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOACTIVATE
},
2199 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2200 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOACTIVATE
|SWP_NOMOVE
|SWP_NOCLIENTMOVE
},
2201 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
2204 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOACTIVATE
},
2205 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2206 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOACTIVATE
|SWP_NOMOVE
|SWP_NOREDRAW
|SWP_NOCLIENTMOVE
},
2207 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
2210 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2211 { WM_NCCALCSIZE
, sent
|wparam
|defwinproc
, 1 },
2212 { WM_WINDOWPOSCHANGED
, sent
|wparam
|defwinproc
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOREDRAW
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
2213 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
2216 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2217 { WM_NCCALCSIZE
, sent
|wparam
|defwinproc
, 1 },
2218 { WM_WINDOWPOSCHANGED
, sent
|wparam
|defwinproc
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2219 { WM_MOVE
, sent
|defwinproc
},
2220 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_RESTORED
},
2223 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOACTIVATE
},
2224 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2225 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOACTIVATE
|SWP_NOMOVE
|SWP_NOCLIENTMOVE
},
2226 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
2229 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_NOACTIVATE
},
2230 { WM_NCCALCSIZE
, sent
|wparam
|defwinproc
, 1 },
2231 { WM_WINDOWPOSCHANGED
, sent
|wparam
|defwinproc
, SWP_NOACTIVATE
|SWP_NOMOVE
|SWP_NOREDRAW
|SWP_NOCLIENTMOVE
},
2232 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
2233 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
2234 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI client */
2236 { WM_NCCALCSIZE
, sent
|wparam
|defwinproc
|optional
, 1 }, /* XP sends it to MDI frame */
2238 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
2239 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
2240 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI client */
2241 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
2242 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* XP sends a duplicate */
2245 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2246 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2247 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
2248 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
2250 { WM_NCACTIVATE
, sent
|wparam
, 0 },
2251 { WM_MDIACTIVATE
, sent
},
2253 { HCBT_MINMAX
, hook
|lparam
, 0, SW_SHOWNORMAL
},
2254 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_SHOWWINDOW
|0x8000 },
2255 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2257 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
2259 { WM_CHILDACTIVATE
, sent
|wparam
|lparam
, 0, 0 },
2260 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_SHOWWINDOW
|SWP_NOMOVE
|SWP_NOCLIENTMOVE
|0x8000 },
2261 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_RESTORED
},
2264 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2265 { WM_NCCALCSIZE
, sent
|wparam
|defwinproc
, 1 },
2266 { WM_WINDOWPOSCHANGED
, sent
|wparam
|defwinproc
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
2267 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
2270 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2271 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2272 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2273 { WM_MOVE
, sent
|defwinproc
},
2274 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_RESTORED
},
2277 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOACTIVATE
},
2278 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2279 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOACTIVATE
|SWP_NOMOVE
|SWP_NOCLIENTMOVE
},
2280 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
2281 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
2282 { WM_NCCALCSIZE
, sent
|wparam
|optional
, 1 }, /* XP */
2283 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI client */
2284 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
2285 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* XP sends a duplicate */
2287 { HCBT_SETFOCUS
, hook
},
2288 { WM_KILLFOCUS
, sent
},
2289 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 },
2290 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 }, /* in MDI client */
2291 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
2292 { WM_SETFOCUS
, sent
}, /* in MDI client */
2294 { WM_MDIREFRESHMENU
, sent
}, /* in MDI client */
2296 { HCBT_DESTROYWND
, hook
},
2297 /* Win2k sends wparam set to
2298 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
2299 * while Win9x doesn't bother to set child window id according to
2300 * CLIENTCREATESTRUCT.idFirstChild
2302 { WM_PARENTNOTIFY
, sent
/*|wparam, WM_DESTROY*/ }, /* in MDI client */
2304 { WM_SHOWWINDOW
, sent
|wparam
, 0 },
2305 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2306 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, 0, 0 },
2307 { WM_ERASEBKGND
, sent
|parent
|optional
},
2308 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
2310 { EVENT_OBJECT_DESTROY
, winevent_hook
|wparam
|lparam
, 0, 0 },
2311 { WM_DESTROY
, sent
},
2312 { WM_NCDESTROY
, sent
},
2315 /* ShowWindow(SW_MAXIMIZE) for a not visible MDI child window */
2316 static const struct message WmMaximizeMDIchildInvisibleSeq
[] = {
2317 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MAXIMIZE
},
2318 { WM_GETMINMAXINFO
, sent
},
2319 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|0x8000 },
2320 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2321 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
2322 { WM_CHILDACTIVATE
, sent
|wparam
|lparam
, 0, 0 },
2324 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2325 { WM_NCACTIVATE
, sent
|wparam
|defwinproc
, 1 },
2326 { HCBT_SETFOCUS
, hook
},
2327 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 }, /* in MDI client */
2328 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
2329 { WM_SETFOCUS
, sent
}, /* in MDI client */
2330 { HCBT_SETFOCUS
, hook
},
2331 { WM_KILLFOCUS
, sent
}, /* in MDI client */
2332 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 }, /* in MDI client */
2333 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
2334 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
2335 { WM_SETFOCUS
, sent
|defwinproc
},
2336 { WM_MDIACTIVATE
, sent
|defwinproc
},
2337 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
|0x8000 },
2338 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
2340 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2341 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2342 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
2343 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
2344 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
2347 /* ShowWindow(SW_MAXIMIZE) for a not visible maximized MDI child window */
2348 static const struct message WmMaximizeMDIchildInvisibleSeq2
[] = {
2349 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MAXIMIZE
},
2350 { WM_GETMINMAXINFO
, sent
},
2351 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
},
2352 { WM_GETMINMAXINFO
, sent
|defwinproc
},
2353 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2354 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
2355 { WM_CHILDACTIVATE
, sent
|wparam
|lparam
, 0, 0 },
2357 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2358 { WM_NCACTIVATE
, sent
|wparam
|defwinproc
, 1 },
2359 { HCBT_SETFOCUS
, hook
},
2360 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 }, /* in MDI client */
2361 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
2362 { WM_SETFOCUS
, sent
}, /* in MDI client */
2363 { HCBT_SETFOCUS
, hook
},
2364 { WM_KILLFOCUS
, sent
}, /* in MDI client */
2365 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 }, /* in MDI client */
2366 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
2367 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
2368 { WM_SETFOCUS
, sent
|defwinproc
},
2369 { WM_MDIACTIVATE
, sent
|defwinproc
},
2370 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
2371 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
2374 /* WM_MDIMAXIMIZE for an MDI child window with invisible parent */
2375 static const struct message WmMaximizeMDIchildInvisibleParentSeq
[] = {
2376 { WM_MDIMAXIMIZE
, sent
}, /* in MDI client */
2377 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MAXIMIZE
},
2378 { WM_GETMINMAXINFO
, sent
},
2379 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|0x8000 },
2380 { WM_GETMINMAXINFO
, sent
|defwinproc
},
2381 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2382 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
2383 { WM_CHILDACTIVATE
, sent
|wparam
|lparam
, 0, 0 },
2384 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOREDRAW
|0x8000 },
2385 { WM_MOVE
, sent
|defwinproc
},
2386 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
2388 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2389 { WM_NCCALCSIZE
, sent
|wparam
|defwinproc
, 1 },
2390 { WM_WINDOWPOSCHANGED
, sent
|wparam
|defwinproc
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOREDRAW
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
2391 { WM_NCCALCSIZE
, sent
|wparam
|defwinproc
|optional
, 1 },
2393 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2394 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2395 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2396 { WM_MOVE
, sent
|defwinproc
},
2397 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_RESTORED
},
2398 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
2400 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOACTIVATE
},
2401 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2402 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOACTIVATE
|SWP_NOMOVE
|SWP_NOREDRAW
|SWP_NOCLIENTMOVE
},
2403 { WM_SIZE
, sent
|wparam
, SIZE_RESTORED
},
2405 { WM_WINDOWPOSCHANGING
, sent
|wparam
|defwinproc
, SWP_NOACTIVATE
},
2406 { WM_GETMINMAXINFO
, sent
|defwinproc
},
2407 { WM_NCCALCSIZE
, sent
|wparam
|defwinproc
, 1 },
2408 { WM_WINDOWPOSCHANGED
, sent
|wparam
|defwinproc
, SWP_NOACTIVATE
|SWP_NOMOVE
|SWP_NOREDRAW
|SWP_NOCLIENTMOVE
},
2409 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
2410 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
2411 { WM_NCCALCSIZE
, sent
|wparam
|defwinproc
|optional
, 1 },
2413 { WM_NCCALCSIZE
, sent
|wparam
|optional
, 1 },
2416 /* ShowWindow(SW_MAXIMIZE) for a visible MDI child window */
2417 static const struct message WmMaximizeMDIchildVisibleSeq
[] = {
2418 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MAXIMIZE
},
2419 { WM_GETMINMAXINFO
, sent
},
2420 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|0x8000 },
2421 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2422 { WM_CHILDACTIVATE
, sent
|wparam
|lparam
, 0, 0 },
2423 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
|0x8000 },
2424 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_MAXIMIZED
},
2426 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2427 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2428 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
2429 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
2430 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
2433 /* ShowWindow(SW_RESTORE) for a visible MDI child window */
2434 static const struct message WmRestoreMDIchildVisibleSeq
[] = {
2435 { HCBT_MINMAX
, hook
|lparam
, 0, SW_RESTORE
},
2436 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|0x8000 },
2437 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2438 { WM_CHILDACTIVATE
, sent
|wparam
|lparam
, 0, 0 },
2439 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
|0x8000 },
2440 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_RESTORED
},
2442 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2443 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2444 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
2445 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
2446 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
2449 /* ShowWindow(SW_RESTORE) for a not visible MDI child window */
2450 static const struct message WmRestoreMDIchildInisibleSeq
[] = {
2451 { HCBT_MINMAX
, hook
|lparam
, 0, SW_RESTORE
},
2452 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|0x8000 },
2453 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2454 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, 0, 0 },
2455 { WM_CHILDACTIVATE
, sent
|wparam
|lparam
, 0, 0 },
2456 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
|0x8000 },
2457 { WM_SIZE
, sent
|defwinproc
|wparam
, SIZE_RESTORED
},
2459 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
2460 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
2461 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
2462 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI frame */
2463 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* MDI child */
2467 static HWND mdi_client
;
2468 static WNDPROC old_mdi_client_proc
;
2470 static LRESULT WINAPI
mdi_client_hook_proc(HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2474 /* do not log painting messages */
2475 if (message
!= WM_PAINT
&&
2476 message
!= WM_NCPAINT
&&
2477 message
!= WM_SYNCPAINT
&&
2478 message
!= WM_ERASEBKGND
&&
2479 message
!= WM_NCPAINT
&&
2480 message
!= WM_NCHITTEST
&&
2481 message
!= WM_GETTEXT
&&
2482 message
!= WM_MDIGETACTIVE
&&
2483 message
!= WM_GETICON
&&
2484 message
!= WM_DEVICECHANGE
)
2486 trace("mdi client: %p, %04x, %08x, %08lx\n", hwnd
, message
, wParam
, lParam
);
2490 case WM_WINDOWPOSCHANGING
:
2491 case WM_WINDOWPOSCHANGED
:
2493 WINDOWPOS
*winpos
= (WINDOWPOS
*)lParam
;
2495 trace("%s\n", (message
== WM_WINDOWPOSCHANGING
) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
2496 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
2497 winpos
->hwnd
, winpos
->hwndInsertAfter
,
2498 winpos
->x
, winpos
->y
, winpos
->cx
, winpos
->cy
, winpos
->flags
);
2499 dump_winpos_flags(winpos
->flags
);
2501 /* Log only documented flags, win2k uses 0x1000 and 0x2000
2502 * in the high word for internal purposes
2504 wParam
= winpos
->flags
& 0xffff;
2505 /* We are not interested in the flags that don't match under XP and Win9x */
2506 wParam
&= ~(SWP_NOZORDER
);
2511 msg
.message
= message
;
2512 msg
.flags
= sent
|wparam
|lparam
;
2513 msg
.wParam
= wParam
;
2514 msg
.lParam
= lParam
;
2518 return CallWindowProcA(old_mdi_client_proc
, hwnd
, message
, wParam
, lParam
);
2521 static LRESULT WINAPI
mdi_child_wnd_proc(HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2523 static long defwndproc_counter
= 0;
2527 /* do not log painting messages */
2528 if (message
!= WM_PAINT
&&
2529 message
!= WM_NCPAINT
&&
2530 message
!= WM_SYNCPAINT
&&
2531 message
!= WM_ERASEBKGND
&&
2532 message
!= WM_NCPAINT
&&
2533 message
!= WM_NCHITTEST
&&
2534 message
!= WM_GETTEXT
&&
2535 message
!= WM_GETICON
&&
2536 message
!= WM_DEVICECHANGE
)
2538 trace("mdi child: %p, %04x, %08x, %08lx\n", hwnd
, message
, wParam
, lParam
);
2542 case WM_WINDOWPOSCHANGING
:
2543 case WM_WINDOWPOSCHANGED
:
2545 WINDOWPOS
*winpos
= (WINDOWPOS
*)lParam
;
2547 trace("%s\n", (message
== WM_WINDOWPOSCHANGING
) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
2548 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
2549 winpos
->hwnd
, winpos
->hwndInsertAfter
,
2550 winpos
->x
, winpos
->y
, winpos
->cx
, winpos
->cy
, winpos
->flags
);
2551 dump_winpos_flags(winpos
->flags
);
2553 /* Log only documented flags, win2k uses 0x1000 and 0x2000
2554 * in the high word for internal purposes
2556 wParam
= winpos
->flags
& 0xffff;
2557 /* We are not interested in the flags that don't match under XP and Win9x */
2558 wParam
&= ~(SWP_NOZORDER
);
2562 case WM_MDIACTIVATE
:
2564 HWND active
, client
= GetParent(hwnd
);
2566 active
= (HWND
)SendMessageA(client
, WM_MDIGETACTIVE
, 0, 0);
2568 if (hwnd
== (HWND
)lParam
) /* if we are being activated */
2569 ok (active
== (HWND
)lParam
, "new active %p != active %p\n", (HWND
)lParam
, active
);
2571 ok (active
== (HWND
)wParam
, "old active %p != active %p\n", (HWND
)wParam
, active
);
2576 msg
.message
= message
;
2577 msg
.flags
= sent
|wparam
|lparam
;
2578 if (defwndproc_counter
) msg
.flags
|= defwinproc
;
2579 msg
.wParam
= wParam
;
2580 msg
.lParam
= lParam
;
2584 defwndproc_counter
++;
2585 ret
= DefMDIChildProcA(hwnd
, message
, wParam
, lParam
);
2586 defwndproc_counter
--;
2591 static LRESULT WINAPI
mdi_frame_wnd_proc(HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2593 static long defwndproc_counter
= 0;
2597 /* do not log painting messages */
2598 if (message
!= WM_PAINT
&&
2599 message
!= WM_NCPAINT
&&
2600 message
!= WM_SYNCPAINT
&&
2601 message
!= WM_ERASEBKGND
&&
2602 message
!= WM_NCPAINT
&&
2603 message
!= WM_NCHITTEST
&&
2604 message
!= WM_GETTEXT
&&
2605 message
!= WM_GETICON
&&
2606 message
!= WM_DEVICECHANGE
)
2608 trace("mdi frame: %p, %04x, %08x, %08lx\n", hwnd
, message
, wParam
, lParam
);
2612 case WM_WINDOWPOSCHANGING
:
2613 case WM_WINDOWPOSCHANGED
:
2615 WINDOWPOS
*winpos
= (WINDOWPOS
*)lParam
;
2617 trace("%s\n", (message
== WM_WINDOWPOSCHANGING
) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
2618 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
2619 winpos
->hwnd
, winpos
->hwndInsertAfter
,
2620 winpos
->x
, winpos
->y
, winpos
->cx
, winpos
->cy
, winpos
->flags
);
2621 dump_winpos_flags(winpos
->flags
);
2623 /* Log only documented flags, win2k uses 0x1000 and 0x2000
2624 * in the high word for internal purposes
2626 wParam
= winpos
->flags
& 0xffff;
2627 /* We are not interested in the flags that don't match under XP and Win9x */
2628 wParam
&= ~(SWP_NOZORDER
);
2633 msg
.message
= message
;
2634 msg
.flags
= sent
|wparam
|lparam
;
2635 if (defwndproc_counter
) msg
.flags
|= defwinproc
;
2636 msg
.wParam
= wParam
;
2637 msg
.lParam
= lParam
;
2641 defwndproc_counter
++;
2642 ret
= DefFrameProcA(hwnd
, mdi_client
, message
, wParam
, lParam
);
2643 defwndproc_counter
--;
2648 static BOOL
mdi_RegisterWindowClasses(void)
2653 cls
.lpfnWndProc
= mdi_frame_wnd_proc
;
2656 cls
.hInstance
= GetModuleHandleA(0);
2658 cls
.hCursor
= LoadCursorA(0, (LPSTR
)IDC_ARROW
);
2659 cls
.hbrBackground
= GetStockObject(WHITE_BRUSH
);
2660 cls
.lpszMenuName
= NULL
;
2661 cls
.lpszClassName
= "MDI_frame_class";
2662 if (!RegisterClassA(&cls
)) return FALSE
;
2664 cls
.lpfnWndProc
= mdi_child_wnd_proc
;
2665 cls
.lpszClassName
= "MDI_child_class";
2666 if (!RegisterClassA(&cls
)) return FALSE
;
2668 if (!GetClassInfoA(0, "MDIClient", &cls
)) assert(0);
2669 old_mdi_client_proc
= cls
.lpfnWndProc
;
2670 cls
.hInstance
= GetModuleHandleA(0);
2671 cls
.lpfnWndProc
= mdi_client_hook_proc
;
2672 cls
.lpszClassName
= "MDI_client_class";
2673 if (!RegisterClassA(&cls
)) assert(0);
2678 static void test_mdi_messages(void)
2680 MDICREATESTRUCTA mdi_cs
;
2681 CLIENTCREATESTRUCT client_cs
;
2682 HWND mdi_frame
, mdi_child
, mdi_child2
, active_child
;
2684 HMENU hMenu
= CreateMenu();
2686 assert(mdi_RegisterWindowClasses());
2690 trace("creating MDI frame window\n");
2691 mdi_frame
= CreateWindowExA(0, "MDI_frame_class", "MDI frame window",
2692 WS_CAPTION
| WS_SYSMENU
| WS_MINIMIZEBOX
|
2693 WS_MAXIMIZEBOX
| WS_VISIBLE
,
2694 100, 100, CW_USEDEFAULT
, CW_USEDEFAULT
,
2695 GetDesktopWindow(), hMenu
,
2696 GetModuleHandleA(0), NULL
);
2698 ok_sequence(WmCreateMDIframeSeq
, "Create MDI frame window", FALSE
);
2700 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2701 ok(GetFocus() == mdi_frame
, "wrong focus window %p\n", GetFocus());
2703 trace("creating MDI client window\n");
2704 client_cs
.hWindowMenu
= 0;
2705 client_cs
.idFirstChild
= MDI_FIRST_CHILD_ID
;
2706 mdi_client
= CreateWindowExA(0, "MDI_client_class",
2708 WS_CHILD
| WS_VISIBLE
| MDIS_ALLCHILDSTYLES
,
2710 mdi_frame
, 0, GetModuleHandleA(0), &client_cs
);
2712 ok_sequence(WmCreateMDIclientSeq
, "Create visible MDI client window", FALSE
);
2714 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2715 ok(GetFocus() == mdi_frame
, "input focus should be on MDI frame not on %p\n", GetFocus());
2717 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
2718 ok(!active_child
, "wrong active MDI child %p\n", active_child
);
2719 ok(!zoomed
, "wrong zoomed state %d\n", zoomed
);
2724 trace("creating invisible MDI child window\n");
2725 mdi_child
= CreateWindowExA(WS_EX_MDICHILD
, "MDI_child_class", "MDI child",
2727 0, 0, CW_USEDEFAULT
, CW_USEDEFAULT
,
2728 mdi_client
, 0, GetModuleHandleA(0), NULL
);
2732 ShowWindow(mdi_child
, SW_SHOWNORMAL
);
2733 ok_sequence(WmShowChildSeq
, "ShowWindow(SW_SHOWNORMAL) MDI child window", FALSE
);
2735 ok(GetWindowLongA(mdi_child
, GWL_STYLE
) & WS_VISIBLE
, "MDI child should be visible\n");
2736 ok(IsWindowVisible(mdi_child
), "MDI child should be visible\n");
2738 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2739 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2741 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
2742 ok(!active_child
, "wrong active MDI child %p\n", active_child
);
2743 ok(!zoomed
, "wrong zoomed state %d\n", zoomed
);
2745 ShowWindow(mdi_child
, SW_HIDE
);
2746 ok_sequence(WmHideChildSeq
, "ShowWindow(SW_HIDE) MDI child window", FALSE
);
2749 ShowWindow(mdi_child
, SW_SHOW
);
2750 ok_sequence(WmShowChildSeq
, "ShowWindow(SW_SHOW) MDI child window", FALSE
);
2752 ok(GetWindowLongA(mdi_child
, GWL_STYLE
) & WS_VISIBLE
, "MDI child should be visible\n");
2753 ok(IsWindowVisible(mdi_child
), "MDI child should be visible\n");
2755 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2756 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2758 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
2759 ok(!active_child
, "wrong active MDI child %p\n", active_child
);
2760 ok(!zoomed
, "wrong zoomed state %d\n", zoomed
);
2762 DestroyWindow(mdi_child
);
2765 trace("creating visible MDI child window\n");
2766 mdi_child
= CreateWindowExA(WS_EX_MDICHILD
, "MDI_child_class", "MDI child",
2767 WS_CHILD
| WS_VISIBLE
,
2768 0, 0, CW_USEDEFAULT
, CW_USEDEFAULT
,
2769 mdi_client
, 0, GetModuleHandleA(0), NULL
);
2771 ok_sequence(WmCreateMDIchildVisibleSeq
, "Create visible MDI child window", FALSE
);
2773 ok(GetWindowLongA(mdi_child
, GWL_STYLE
) & WS_VISIBLE
, "MDI child should be visible\n");
2774 ok(IsWindowVisible(mdi_child
), "MDI child should be visible\n");
2776 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2777 ok(GetFocus() == mdi_child
, "wrong focus window %p\n", GetFocus());
2779 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
2780 ok(active_child
== mdi_child
, "wrong active MDI child %p\n", active_child
);
2781 ok(!zoomed
, "wrong zoomed state %d\n", zoomed
);
2784 DestroyWindow(mdi_child
);
2785 ok_sequence(WmDestroyMDIchildVisibleSeq
, "Destroy visible MDI child window", TRUE
);
2787 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2788 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2790 /* Win2k: MDI client still returns a just destroyed child as active
2791 * Win9x: MDI client returns 0
2793 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
2794 ok(active_child
== mdi_child
|| /* win2k */
2795 !active_child
, /* win9x */
2796 "wrong active MDI child %p\n", active_child
);
2797 ok(!zoomed
, "wrong zoomed state %d\n", zoomed
);
2801 trace("creating invisible MDI child window\n");
2802 mdi_child2
= CreateWindowExA(WS_EX_MDICHILD
, "MDI_child_class", "MDI child",
2804 0, 0, CW_USEDEFAULT
, CW_USEDEFAULT
,
2805 mdi_client
, 0, GetModuleHandleA(0), NULL
);
2807 ok_sequence(WmCreateMDIchildInvisibleSeq
, "Create invisible MDI child window", FALSE
);
2809 ok(!(GetWindowLongA(mdi_child2
, GWL_STYLE
) & WS_VISIBLE
), "MDI child should not be visible\n");
2810 ok(!IsWindowVisible(mdi_child2
), "MDI child should not be visible\n");
2812 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2813 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2815 /* Win2k: MDI client still returns a just destroyed child as active
2816 * Win9x: MDI client returns mdi_child2
2818 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
2819 ok(active_child
== mdi_child
|| /* win2k */
2820 active_child
== mdi_child2
, /* win9x */
2821 "wrong active MDI child %p\n", active_child
);
2822 ok(!zoomed
, "wrong zoomed state %d\n", zoomed
);
2825 ShowWindow(mdi_child2
, SW_MAXIMIZE
);
2826 ok_sequence(WmMaximizeMDIchildInvisibleSeq
, "ShowWindow(SW_MAXIMIZE):invisible MDI child", FALSE
);
2828 ok(GetWindowLongA(mdi_child2
, GWL_STYLE
) & WS_VISIBLE
, "MDI child should be visible\n");
2829 ok(IsWindowVisible(mdi_child2
), "MDI child should be visible\n");
2831 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
2832 ok(active_child
== mdi_child2
, "wrong active MDI child %p\n", active_child
);
2833 ok(zoomed
, "wrong zoomed state %d\n", zoomed
);
2836 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2837 ok(GetFocus() == mdi_child2
|| /* win2k */
2838 GetFocus() == 0, /* win9x */
2839 "wrong focus window %p\n", GetFocus());
2844 ShowWindow(mdi_child2
, SW_HIDE
);
2845 ok_sequence(WmHideChildSeq
, "ShowWindow(SW_HIDE):MDI child", FALSE
);
2847 ShowWindow(mdi_child2
, SW_RESTORE
);
2848 ok_sequence(WmRestoreMDIchildInisibleSeq
, "ShowWindow(SW_RESTORE):invisible MDI child", FALSE
);
2851 ok(GetWindowLongA(mdi_child2
, GWL_STYLE
) & WS_VISIBLE
, "MDI child should be visible\n");
2852 ok(IsWindowVisible(mdi_child2
), "MDI child should be visible\n");
2854 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
2855 ok(active_child
== mdi_child2
, "wrong active MDI child %p\n", active_child
);
2856 ok(!zoomed
, "wrong zoomed state %d\n", zoomed
);
2862 ShowWindow(mdi_child2
, SW_HIDE
);
2863 ok_sequence(WmHideChildSeq
, "ShowWindow(SW_HIDE):MDI child", FALSE
);
2865 ShowWindow(mdi_child2
, SW_SHOW
);
2866 ok_sequence(WmShowChildSeq
, "ShowWindow(SW_SHOW):MDI child", FALSE
);
2868 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2869 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2871 ShowWindow(mdi_child2
, SW_MAXIMIZE
);
2872 ok_sequence(WmMaximizeMDIchildVisibleSeq
, "ShowWindow(SW_MAXIMIZE):MDI child", FALSE
);
2874 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2875 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2877 ShowWindow(mdi_child2
, SW_RESTORE
);
2878 ok_sequence(WmRestoreMDIchildVisibleSeq
, "ShowWindow(SW_RESTORE):MDI child", FALSE
);
2880 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2881 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2886 ShowWindow(mdi_child2
, SW_HIDE
);
2887 ok_sequence(WmHideChildSeq
, "ShowWindow(SW_HIDE):MDI child", FALSE
);
2889 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2890 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2892 DestroyWindow(mdi_child2
);
2893 ok_sequence(WmDestroyMDIchildInvisibleSeq
, "Destroy invisible MDI child window", FALSE
);
2895 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2896 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2898 /* test for maximized MDI children */
2899 trace("creating maximized visible MDI child window 1\n");
2900 mdi_child
= CreateWindowExA(WS_EX_MDICHILD
, "MDI_child_class", "MDI child",
2901 WS_CHILD
| WS_VISIBLE
| WS_MAXIMIZEBOX
| WS_MAXIMIZE
,
2902 0, 0, CW_USEDEFAULT
, CW_USEDEFAULT
,
2903 mdi_client
, 0, GetModuleHandleA(0), NULL
);
2905 ok_sequence(WmCreateMDIchildVisibleMaxSeq1
, "Create maximized visible 1st MDI child window", TRUE
);
2906 ok(IsZoomed(mdi_child
), "1st MDI child should be maximized\n");
2908 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2909 ok(GetFocus() == mdi_child
|| /* win2k */
2910 GetFocus() == 0, /* win9x */
2911 "wrong focus window %p\n", GetFocus());
2913 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
2914 ok(active_child
== mdi_child
, "wrong active MDI child %p\n", active_child
);
2915 ok(zoomed
, "wrong zoomed state %d\n", zoomed
);
2918 trace("creating maximized visible MDI child window 2\n");
2919 mdi_child2
= CreateWindowExA(WS_EX_MDICHILD
, "MDI_child_class", "MDI child",
2920 WS_CHILD
| WS_VISIBLE
| WS_MAXIMIZEBOX
| WS_MAXIMIZE
,
2921 0, 0, CW_USEDEFAULT
, CW_USEDEFAULT
,
2922 mdi_client
, 0, GetModuleHandleA(0), NULL
);
2924 ok_sequence(WmCreateMDIchildVisibleMaxSeq2
, "Create maximized visible 2nd MDI child 2 window", TRUE
);
2925 ok(IsZoomed(mdi_child2
), "2nd MDI child should be maximized\n");
2926 ok(!IsZoomed(mdi_child
), "1st MDI child should NOT be maximized\n");
2928 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2929 ok(GetFocus() == mdi_child2
, "wrong focus window %p\n", GetFocus());
2931 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
2932 ok(active_child
== mdi_child2
, "wrong active MDI child %p\n", active_child
);
2933 ok(zoomed
, "wrong zoomed state %d\n", zoomed
);
2936 trace("destroying maximized visible MDI child window 2\n");
2937 DestroyWindow(mdi_child2
);
2938 ok_sequence(WmDestroyMDIchildVisibleSeq
, "Destroy visible MDI child window", TRUE
);
2940 ok(!IsZoomed(mdi_child
), "1st MDI child should NOT be maximized\n");
2942 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2943 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2945 /* Win2k: MDI client still returns a just destroyed child as active
2946 * Win9x: MDI client returns 0
2948 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
2949 ok(active_child
== mdi_child2
|| /* win2k */
2950 !active_child
, /* win9x */
2951 "wrong active MDI child %p\n", active_child
);
2954 ShowWindow(mdi_child
, SW_MAXIMIZE
);
2955 ok(IsZoomed(mdi_child
), "1st MDI child should be maximized\n");
2958 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2959 ok(GetFocus() == mdi_child
, "wrong focus window %p\n", GetFocus());
2961 trace("re-creating maximized visible MDI child window 2\n");
2962 mdi_child2
= CreateWindowExA(WS_EX_MDICHILD
, "MDI_child_class", "MDI child",
2963 WS_CHILD
| WS_VISIBLE
| WS_MAXIMIZEBOX
| WS_MAXIMIZE
,
2964 0, 0, CW_USEDEFAULT
, CW_USEDEFAULT
,
2965 mdi_client
, 0, GetModuleHandleA(0), NULL
);
2967 ok_sequence(WmCreateMDIchildVisibleMaxSeq2
, "Create maximized visible 2nd MDI child 2 window", TRUE
);
2968 ok(IsZoomed(mdi_child2
), "2nd MDI child should be maximized\n");
2969 ok(!IsZoomed(mdi_child
), "1st MDI child should NOT be maximized\n");
2971 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2972 ok(GetFocus() == mdi_child2
, "wrong focus window %p\n", GetFocus());
2974 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
2975 ok(active_child
== mdi_child2
, "wrong active MDI child %p\n", active_child
);
2976 ok(zoomed
, "wrong zoomed state %d\n", zoomed
);
2979 SendMessageA(mdi_child2
, WM_SYSCOMMAND
, SC_CLOSE
, 0);
2980 ok_sequence(WmDestroyMDIchildVisibleMaxSeq2
, "WM_SYSCOMMAND/SC_CLOSE on a visible maximized MDI child window", TRUE
);
2981 ok(!IsWindow(mdi_child2
), "MDI child 2 should be destroyed\n");
2983 ok(IsZoomed(mdi_child
), "1st MDI child should be maximized\n");
2984 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2985 ok(GetFocus() == mdi_child
, "wrong focus window %p\n", GetFocus());
2987 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
2988 ok(active_child
== mdi_child
, "wrong active MDI child %p\n", active_child
);
2989 ok(zoomed
, "wrong zoomed state %d\n", zoomed
);
2992 DestroyWindow(mdi_child
);
2993 ok_sequence(WmDestroyMDIchildVisibleSeq
, "Destroy visible MDI child window", TRUE
);
2995 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
2996 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2998 /* Win2k: MDI client still returns a just destroyed child as active
2999 * Win9x: MDI client returns 0
3001 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
3002 ok(active_child
== mdi_child
|| /* win2k */
3003 !active_child
, /* win9x */
3004 "wrong active MDI child %p\n", active_child
);
3007 trace("creating maximized invisible MDI child window\n");
3008 mdi_child2
= CreateWindowExA(WS_EX_MDICHILD
, "MDI_child_class", "MDI child",
3009 WS_CHILD
| WS_MAXIMIZE
| WS_CAPTION
| WS_THICKFRAME
,
3010 0, 0, CW_USEDEFAULT
, CW_USEDEFAULT
,
3011 mdi_client
, 0, GetModuleHandleA(0), NULL
);
3013 ok_sequence(WmCreateMDIchildInvisibleMaxSeq4
, "Create maximized invisible MDI child window", TRUE
);
3014 ok(IsZoomed(mdi_child2
), "MDI child should be maximized\n");
3015 ok(!(GetWindowLongA(mdi_child2
, GWL_STYLE
) & WS_VISIBLE
), "MDI child should be not visible\n");
3016 ok(!IsWindowVisible(mdi_child2
), "MDI child should be not visible\n");
3018 /* Win2k: MDI client still returns a just destroyed child as active
3019 * Win9x: MDI client returns 0
3021 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
3022 ok(active_child
== mdi_child
|| /* win2k */
3023 !active_child
, /* win9x */
3024 "wrong active MDI child %p\n", active_child
);
3027 trace("call ShowWindow(mdi_child, SW_MAXIMIZE)\n");
3028 ShowWindow(mdi_child2
, SW_MAXIMIZE
);
3029 ok_sequence(WmMaximizeMDIchildInvisibleSeq2
, "ShowWindow(SW_MAXIMIZE):invisible maximized MDI child", FALSE
);
3030 ok(IsZoomed(mdi_child2
), "MDI child should be maximized\n");
3031 ok(GetWindowLongA(mdi_child2
, GWL_STYLE
) & WS_VISIBLE
, "MDI child should be visible\n");
3032 ok(IsWindowVisible(mdi_child2
), "MDI child should be visible\n");
3034 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
3035 ok(active_child
== mdi_child2
, "wrong active MDI child %p\n", active_child
);
3036 ok(zoomed
, "wrong zoomed state %d\n", zoomed
);
3039 SendMessageA(mdi_client
, WM_MDIDESTROY
, (WPARAM
)mdi_child2
, 0);
3042 /* end of test for maximized MDI children */
3044 mdi_cs
.szClass
= "MDI_child_Class";
3045 mdi_cs
.szTitle
= "MDI child";
3046 mdi_cs
.hOwner
= GetModuleHandleA(0);
3049 mdi_cs
.cx
= CW_USEDEFAULT
;
3050 mdi_cs
.cy
= CW_USEDEFAULT
;
3051 mdi_cs
.style
= WS_CHILD
| WS_SYSMENU
| WS_VISIBLE
| WS_MAXIMIZEBOX
| WS_MAXIMIZE
;
3053 mdi_child
= (HWND
)SendMessageA(mdi_client
, WM_MDICREATE
, 0, (LPARAM
)&mdi_cs
);
3054 ok(mdi_child
!= 0, "MDI child creation failed\n");
3055 ok_sequence(WmCreateMDIchildVisibleMaxSeq3
, "WM_MDICREATE for maximized visible MDI child window", TRUE
);
3057 ok(GetMenuItemID(hMenu
, GetMenuItemCount(hMenu
) - 1) == SC_CLOSE
, "SC_CLOSE menu item not found\n");
3059 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
3060 ok(active_child
== mdi_child
, "wrong active MDI child %p\n", active_child
);
3062 ok(IsZoomed(mdi_child
), "MDI child should be maximized\n");
3063 ok(GetActiveWindow() == mdi_frame
, "wrong active window %p\n", GetActiveWindow());
3064 ok(GetFocus() == mdi_child
, "wrong focus window %p\n", GetFocus());
3066 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
3067 ok(active_child
== mdi_child
, "wrong active MDI child %p\n", active_child
);
3068 ok(zoomed
, "wrong zoomed state %d\n", zoomed
);
3071 SendMessageA(mdi_client
, WM_MDIDESTROY
, (WPARAM
)mdi_child
, 0);
3072 ok_sequence(WmDestroyMDIchildVisibleMaxSeq1
, "Destroy visible maximized MDI child window", TRUE
);
3074 ok(!IsWindow(mdi_child
), "MDI child should be destroyed\n");
3075 active_child
= (HWND
)SendMessageA(mdi_client
, WM_MDIGETACTIVE
, 0, (LPARAM
)&zoomed
);
3076 ok(!active_child
, "wrong active MDI child %p\n", active_child
);
3081 DestroyWindow(mdi_client
);
3082 ok_sequence(WmDestroyMDIclientSeq
, "Destroy MDI client window", FALSE
);
3084 /* test maximization of MDI child with invisible parent */
3085 client_cs
.hWindowMenu
= 0;
3086 mdi_client
= CreateWindow("MDI_client_class",
3088 WS_CHILD
| WS_CLIPCHILDREN
| WS_VSCROLL
| WS_HSCROLL
| WS_VISIBLE
,
3090 mdi_frame
, 0, GetModuleHandleA(0), &client_cs
);
3091 ok_sequence(WmCreateMDIclientSeq
, "Create MDI client window", FALSE
);
3093 ShowWindow(mdi_client
, SW_HIDE
);
3094 ok_sequence(WmHideMDIclientSeq
, "Hide MDI client window", FALSE
);
3096 mdi_child
= CreateWindowExA(WS_EX_MDICHILD
, "MDI_child_class", "MDI child",
3097 WS_CHILD
| WS_CLIPCHILDREN
| WS_VSCROLL
| WS_HSCROLL
,
3099 mdi_client
, 0, GetModuleHandleA(0), NULL
);
3100 ok_sequence(WmCreateMDIchildInvisibleParentSeq
, "Create MDI child window with invisible parent", FALSE
);
3102 SendMessage(mdi_client
, WM_MDIMAXIMIZE
, (WPARAM
) mdi_child
, 0);
3103 ok_sequence(WmMaximizeMDIchildInvisibleParentSeq
, "Maximize MDI child window with invisible parent", TRUE
);
3104 zoomed
= IsZoomed(mdi_child
);
3105 ok(zoomed
, "wrong zoomed state %d\n", zoomed
);
3107 ShowWindow(mdi_client
, SW_SHOW
);
3108 ok_sequence(WmShowMDIclientSeq
, "Show MDI client window", FALSE
);
3110 DestroyWindow(mdi_child
);
3111 ok_sequence(WmDestroyMDIchildVisibleSeq
, "Destroy visible maximized MDI child window", TRUE
);
3113 DestroyWindow(mdi_client
);
3114 ok_sequence(WmDestroyMDIclientSeq
, "Destroy MDI client window", FALSE
);
3115 /* end of test for maximization of MDI child with invisible parent */
3117 DestroyWindow(mdi_frame
);
3118 ok_sequence(WmDestroyMDIframeSeq
, "Destroy MDI frame window", FALSE
);
3120 /************************* End of MDI test **********************************/
3122 static void test_WM_SETREDRAW(HWND hwnd
)
3124 DWORD style
= GetWindowLongA(hwnd
, GWL_STYLE
);
3128 SendMessageA(hwnd
, WM_SETREDRAW
, FALSE
, 0);
3129 ok_sequence(WmSetRedrawFalseSeq
, "SetRedraw:FALSE", FALSE
);
3131 ok(!(GetWindowLongA(hwnd
, GWL_STYLE
) & WS_VISIBLE
), "WS_VISIBLE should NOT be set\n");
3132 ok(!IsWindowVisible(hwnd
), "IsWindowVisible() should return FALSE\n");
3135 SendMessageA(hwnd
, WM_SETREDRAW
, TRUE
, 0);
3136 ok_sequence(WmSetRedrawTrueSeq
, "SetRedraw:TRUE", FALSE
);
3138 ok(GetWindowLongA(hwnd
, GWL_STYLE
) & WS_VISIBLE
, "WS_VISIBLE should be set\n");
3139 ok(IsWindowVisible(hwnd
), "IsWindowVisible() should return TRUE\n");
3141 /* restore original WS_VISIBLE state */
3142 SetWindowLongA(hwnd
, GWL_STYLE
, style
);
3147 static INT_PTR CALLBACK
TestModalDlgProcA(HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
3151 trace("dialog: %p, %04x, %08x, %08lx\n", hwnd
, message
, wParam
, lParam
);
3153 /* explicitly ignore WM_GETICON message */
3154 if (message
== WM_GETICON
) return 0;
3161 case WM_DEVICECHANGE
:
3166 case WM_WINDOWPOSCHANGING
:
3167 case WM_WINDOWPOSCHANGED
:
3169 WINDOWPOS
*winpos
= (WINDOWPOS
*)lParam
;
3171 trace("%s\n", (message
== WM_WINDOWPOSCHANGING
) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
3172 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
3173 winpos
->hwnd
, winpos
->hwndInsertAfter
,
3174 winpos
->x
, winpos
->y
, winpos
->cx
, winpos
->cy
, winpos
->flags
);
3175 dump_winpos_flags(winpos
->flags
);
3177 /* Log only documented flags, win2k uses 0x1000 and 0x2000
3178 * in the high word for internal purposes
3180 wParam
= winpos
->flags
& 0xffff;
3181 /* We are not interested in the flags that don't match under XP and Win9x */
3182 wParam
&= ~(SWP_NOZORDER
);
3187 msg
.message
= message
;
3188 msg
.flags
= sent
|wparam
|lparam
;
3189 msg
.wParam
= wParam
;
3190 msg
.lParam
= lParam
;
3193 if (message
== WM_INITDIALOG
) SetTimer( hwnd
, 1, 100, NULL
);
3194 if (message
== WM_TIMER
) EndDialog( hwnd
, 0 );
3198 static void test_hv_scroll_1(HWND hwnd
, INT ctl
, DWORD clear
, DWORD set
, INT min
, INT max
)
3200 DWORD style
, exstyle
;
3204 exstyle
= GetWindowLongA(hwnd
, GWL_EXSTYLE
);
3205 style
= GetWindowLongA(hwnd
, GWL_STYLE
);
3206 /* do not be confused by WS_DLGFRAME set */
3207 if ((style
& WS_CAPTION
) == WS_CAPTION
) style
&= ~WS_CAPTION
;
3209 if (clear
) ok(style
& clear
, "style %08x should be set\n", clear
);
3210 if (set
) ok(!(style
& set
), "style %08x should not be set\n", set
);
3212 ret
= SetScrollRange(hwnd
, ctl
, min
, max
, FALSE
);
3213 ok( ret
, "SetScrollRange(%d) error %d\n", ctl
, GetLastError());
3214 if ((style
& (WS_DLGFRAME
| WS_BORDER
| WS_THICKFRAME
)) || (exstyle
& WS_EX_DLGMODALFRAME
))
3215 ok_sequence(WmSetScrollRangeHV_NC_Seq
, "SetScrollRange(SB_HORZ/SB_VERT) NC", FALSE
);
3217 ok_sequence(WmSetScrollRangeHVSeq
, "SetScrollRange(SB_HORZ/SB_VERT)", FALSE
);
3219 style
= GetWindowLongA(hwnd
, GWL_STYLE
);
3220 if (set
) ok(style
& set
, "style %08x should be set\n", set
);
3221 if (clear
) ok(!(style
& clear
), "style %08x should not be set\n", clear
);
3223 /* a subsequent call should do nothing */
3224 ret
= SetScrollRange(hwnd
, ctl
, min
, max
, FALSE
);
3225 ok( ret
, "SetScrollRange(%d) error %d\n", ctl
, GetLastError());
3226 ok_sequence(WmEmptySeq
, "SetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE
);
3230 trace("Ignore GetScrollRange error below if you are on Win9x\n");
3231 ret
= GetScrollRange(hwnd
, ctl
, &xmin
, &xmax
);
3232 ok( ret
, "GetScrollRange(%d) error %d\n", ctl
, GetLastError());
3233 ok_sequence(WmEmptySeq
, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE
);
3234 ok(xmin
== min
, "unexpected min scroll value %d\n", xmin
);
3235 ok(xmax
== max
, "unexpected max scroll value %d\n", xmax
);
3238 static void test_hv_scroll_2(HWND hwnd
, INT ctl
, DWORD clear
, DWORD set
, INT min
, INT max
)
3240 DWORD style
, exstyle
;
3244 exstyle
= GetWindowLongA(hwnd
, GWL_EXSTYLE
);
3245 style
= GetWindowLongA(hwnd
, GWL_STYLE
);
3246 /* do not be confused by WS_DLGFRAME set */
3247 if ((style
& WS_CAPTION
) == WS_CAPTION
) style
&= ~WS_CAPTION
;
3249 if (clear
) ok(style
& clear
, "style %08x should be set\n", clear
);
3250 if (set
) ok(!(style
& set
), "style %08x should not be set\n", set
);
3252 si
.cbSize
= sizeof(si
);
3253 si
.fMask
= SIF_RANGE
;
3256 SetScrollInfo(hwnd
, ctl
, &si
, TRUE
);
3257 if ((style
& (WS_DLGFRAME
| WS_BORDER
| WS_THICKFRAME
)) || (exstyle
& WS_EX_DLGMODALFRAME
))
3258 ok_sequence(WmSetScrollRangeHV_NC_Seq
, "SetScrollInfo(SB_HORZ/SB_VERT) NC", FALSE
);
3260 ok_sequence(WmSetScrollRangeHVSeq
, "SetScrollInfo(SB_HORZ/SB_VERT)", FALSE
);
3262 style
= GetWindowLongA(hwnd
, GWL_STYLE
);
3263 if (set
) ok(style
& set
, "style %08x should be set\n", set
);
3264 if (clear
) ok(!(style
& clear
), "style %08x should not be set\n", clear
);
3266 /* a subsequent call should do nothing */
3267 SetScrollInfo(hwnd
, ctl
, &si
, TRUE
);
3268 if (style
& WS_HSCROLL
)
3269 ok_sequence(WmSetScrollRangeHSeq_empty
, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE
);
3270 else if (style
& WS_VSCROLL
)
3271 ok_sequence(WmSetScrollRangeVSeq_empty
, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE
);
3273 ok_sequence(WmEmptySeq
, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE
);
3275 si
.fMask
= SIF_PAGE
;
3277 SetScrollInfo(hwnd
, ctl
, &si
, FALSE
);
3278 ok_sequence(WmEmptySeq
, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE
);
3282 SetScrollInfo(hwnd
, ctl
, &si
, FALSE
);
3283 ok_sequence(WmEmptySeq
, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE
);
3285 si
.fMask
= SIF_RANGE
;
3286 si
.nMin
= 0xdeadbeef;
3287 si
.nMax
= 0xdeadbeef;
3288 ret
= GetScrollInfo(hwnd
, ctl
, &si
);
3289 ok( ret
, "GetScrollInfo error %d\n", GetLastError());
3290 ok_sequence(WmEmptySeq
, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE
);
3291 ok(si
.nMin
== min
, "unexpected min scroll value %d\n", si
.nMin
);
3292 ok(si
.nMax
== max
, "unexpected max scroll value %d\n", si
.nMax
);
3295 /* Win9x sends WM_USER+xxx while and NT versions send SBM_xxx messages */
3296 static void test_scroll_messages(HWND hwnd
)
3304 ret
= GetScrollRange(hwnd
, SB_CTL
, &min
, &max
);
3305 ok( ret
, "GetScrollRange error %d\n", GetLastError());
3306 if (sequence
->message
!= WmGetScrollRangeSeq
[0].message
)
3307 trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence
->message
);
3308 /* values of min and max are undefined */
3311 ret
= SetScrollRange(hwnd
, SB_CTL
, 10, 150, FALSE
);
3312 ok( ret
, "SetScrollRange error %d\n", GetLastError());
3313 if (sequence
->message
!= WmSetScrollRangeSeq
[0].message
)
3314 trace("SetScrollRange(SB_CTL) generated unknown message %04x\n", sequence
->message
);
3319 ret
= GetScrollRange(hwnd
, SB_CTL
, &min
, &max
);
3320 ok( ret
, "GetScrollRange error %d\n", GetLastError());
3321 if (sequence
->message
!= WmGetScrollRangeSeq
[0].message
)
3322 trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence
->message
);
3323 /* values of min and max are undefined */
3326 si
.cbSize
= sizeof(si
);
3327 si
.fMask
= SIF_RANGE
;
3330 SetScrollInfo(hwnd
, SB_CTL
, &si
, FALSE
);
3331 if (sequence
->message
!= WmSetScrollRangeSeq
[0].message
)
3332 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence
->message
);
3335 si
.fMask
= SIF_PAGE
;
3337 SetScrollInfo(hwnd
, SB_CTL
, &si
, FALSE
);
3338 if (sequence
->message
!= WmSetScrollRangeSeq
[0].message
)
3339 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence
->message
);
3344 SetScrollInfo(hwnd
, SB_CTL
, &si
, FALSE
);
3345 if (sequence
->message
!= WmSetScrollRangeSeq
[0].message
)
3346 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence
->message
);
3349 si
.fMask
= SIF_RANGE
;
3350 si
.nMin
= 0xdeadbeef;
3351 si
.nMax
= 0xdeadbeef;
3352 ret
= GetScrollInfo(hwnd
, SB_CTL
, &si
);
3353 ok( ret
, "GetScrollInfo error %d\n", GetLastError());
3354 if (sequence
->message
!= WmGetScrollInfoSeq
[0].message
)
3355 trace("GetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence
->message
);
3356 /* values of min and max are undefined */
3359 /* set WS_HSCROLL */
3360 test_hv_scroll_1(hwnd
, SB_HORZ
, 0, WS_HSCROLL
, 10, 150);
3361 /* clear WS_HSCROLL */
3362 test_hv_scroll_1(hwnd
, SB_HORZ
, WS_HSCROLL
, 0, 0, 0);
3364 /* set WS_HSCROLL */
3365 test_hv_scroll_2(hwnd
, SB_HORZ
, 0, WS_HSCROLL
, 10, 150);
3366 /* clear WS_HSCROLL */
3367 test_hv_scroll_2(hwnd
, SB_HORZ
, WS_HSCROLL
, 0, 0, 0);
3369 /* set WS_VSCROLL */
3370 test_hv_scroll_1(hwnd
, SB_VERT
, 0, WS_VSCROLL
, 10, 150);
3371 /* clear WS_VSCROLL */
3372 test_hv_scroll_1(hwnd
, SB_VERT
, WS_VSCROLL
, 0, 0, 0);
3374 /* set WS_VSCROLL */
3375 test_hv_scroll_2(hwnd
, SB_VERT
, 0, WS_VSCROLL
, 10, 150);
3376 /* clear WS_VSCROLL */
3377 test_hv_scroll_2(hwnd
, SB_VERT
, WS_VSCROLL
, 0, 0, 0);
3380 static void test_showwindow(void)
3385 hwnd
= CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW
,
3386 100, 100, 200, 200, 0, 0, 0, NULL
);
3387 ok (hwnd
!= 0, "Failed to create overlapped window\n");
3388 hchild
= CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD
,
3389 0, 0, 10, 10, hwnd
, 0, 0, NULL
);
3390 ok (hchild
!= 0, "Failed to create child\n");
3393 /* ShowWindow( SW_SHOWNA) for invisible top level window */
3394 trace("calling ShowWindow( SW_SHOWNA) for invisible top level window\n");
3395 ok( ShowWindow(hwnd
, SW_SHOWNA
) == FALSE
, "ShowWindow: window was visible\n" );
3396 ok_sequence(WmSHOWNATopInvisible
, "ShowWindow(SW_SHOWNA) on invisible top level window", TRUE
);
3399 /* ShowWindow( SW_SHOWNA) for now visible top level window */
3400 trace("calling ShowWindow( SW_SHOWNA) for now visible top level window\n");
3401 ok( ShowWindow(hwnd
, SW_SHOWNA
) != FALSE
, "ShowWindow: window was invisible\n" );
3402 ok_sequence(WmSHOWNATopVisible
, "ShowWindow(SW_SHOWNA) on visible top level window", FALSE
);
3404 /* back to invisible */
3405 ShowWindow(hchild
, SW_HIDE
);
3406 ShowWindow(hwnd
, SW_HIDE
);
3408 /* ShowWindow(SW_SHOWNA) with child and parent invisible */
3409 trace("calling ShowWindow( SW_SHOWNA) for invisible child with invisible parent\n");
3410 ok( ShowWindow(hchild
, SW_SHOWNA
) == FALSE
, "ShowWindow: window was visible\n" );
3411 ok_sequence(WmSHOWNAChildInvisParInvis
, "ShowWindow(SW_SHOWNA) invisible child and parent", FALSE
);
3413 /* ShowWindow(SW_SHOWNA) with child visible and parent invisible */
3414 ok( ShowWindow(hchild
, SW_SHOW
) != FALSE
, "ShowWindow: window was invisible\n" );
3416 trace("calling ShowWindow( SW_SHOWNA) for the visible child and invisible parent\n");
3417 ok( ShowWindow(hchild
, SW_SHOWNA
) != FALSE
, "ShowWindow: window was invisible\n" );
3418 ok_sequence(WmSHOWNAChildVisParInvis
, "ShowWindow(SW_SHOWNA) visible child and invisible parent", FALSE
);
3420 /* ShowWindow(SW_SHOWNA) with child visible and parent visible */
3421 ShowWindow( hwnd
, SW_SHOW
);
3423 trace("calling ShowWindow( SW_SHOWNA) for the visible child and parent\n");
3424 ok( ShowWindow(hchild
, SW_SHOWNA
) != FALSE
, "ShowWindow: window was invisible\n" );
3425 ok_sequence(WmSHOWNAChildVisParVis
, "ShowWindow(SW_SHOWNA) for the visible child and parent", FALSE
);
3428 /* ShowWindow(SW_SHOWNA) with child invisible and parent visible */
3429 ShowWindow( hchild
, SW_HIDE
);
3431 trace("calling ShowWindow( SW_SHOWNA) for the invisible child and visible parent\n");
3432 ok( ShowWindow(hchild
, SW_SHOWNA
) == FALSE
, "ShowWindow: window was visible\n" );
3433 ok_sequence(WmSHOWNAChildInvisParVis
, "ShowWindow(SW_SHOWNA) for the invisible child and visible parent", FALSE
);
3437 ok(GetCapture() == hchild
, "wrong capture window %p\n", GetCapture());
3438 DestroyWindow(hchild
);
3439 ok(!GetCapture(), "wrong capture window %p\n", GetCapture());
3441 DestroyWindow(hwnd
);
3446 * 1. Create invisible maximized popup window.
3447 * 2. Move and resize it.
3448 * 3. Show it maximized.
3450 trace("calling CreateWindowExA( WS_MAXIMIZE ) for invisible maximized popup window\n");
3451 hwnd
= CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP
| WS_MAXIMIZE
,
3452 100, 100, 200, 200, 0, 0, 0, NULL
);
3453 ok (hwnd
!= 0, "Failed to create popup window\n");
3454 ok(IsZoomed(hwnd
), "window should be maximized\n");
3455 ok_sequence(WmCreateInvisibleMaxPopupSeq
, "CreateWindow(WS_MAXIMIZED):popup", FALSE
);
3458 GetWindowRect(hwnd
, &rc
);
3459 ok( rc
.right
-rc
.left
== GetSystemMetrics(SM_CXSCREEN
) &&
3460 rc
.bottom
-rc
.top
== GetSystemMetrics(SM_CYSCREEN
),
3461 "Invalid maximized size before ShowWindow (%d,%d)-(%d,%d)\n",
3462 rc
.left
, rc
.top
, rc
.right
, rc
.bottom
);
3463 /* Reset window's size & position */
3464 SetWindowPos(hwnd
, 0, 10, 10, 200, 200, SWP_NOZORDER
| SWP_NOACTIVATE
);
3465 ok(IsZoomed(hwnd
), "window should be maximized\n");
3468 trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for invisible maximized popup window\n");
3469 ShowWindow(hwnd
, SW_SHOWMAXIMIZED
);
3470 ok(IsZoomed(hwnd
), "window should be maximized\n");
3471 ok_sequence(WmShowMaxPopupResizedSeq
, "ShowWindow(SW_SHOWMAXIMIZED):invisible maximized and resized popup", FALSE
);
3474 GetWindowRect(hwnd
, &rc
);
3475 ok( rc
.right
-rc
.left
== GetSystemMetrics(SM_CXSCREEN
) &&
3476 rc
.bottom
-rc
.top
== GetSystemMetrics(SM_CYSCREEN
),
3477 "Invalid maximized size after ShowWindow (%d,%d)-(%d,%d)\n",
3478 rc
.left
, rc
.top
, rc
.right
, rc
.bottom
);
3479 DestroyWindow(hwnd
);
3483 * 1. Create invisible maximized popup window.
3484 * 2. Show it maximized.
3486 trace("calling CreateWindowExA( WS_MAXIMIZE ) for invisible maximized popup window\n");
3487 hwnd
= CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP
| WS_MAXIMIZE
,
3488 100, 100, 200, 200, 0, 0, 0, NULL
);
3489 ok (hwnd
!= 0, "Failed to create popup window\n");
3490 ok(IsZoomed(hwnd
), "window should be maximized\n");
3491 ok_sequence(WmCreateInvisibleMaxPopupSeq
, "CreateWindow(WS_MAXIMIZED):popup", FALSE
);
3494 trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for invisible maximized popup window\n");
3495 ShowWindow(hwnd
, SW_SHOWMAXIMIZED
);
3496 ok(IsZoomed(hwnd
), "window should be maximized\n");
3497 ok_sequence(WmShowMaxPopupSeq
, "ShowWindow(SW_SHOWMAXIMIZED):invisible maximized popup", FALSE
);
3499 DestroyWindow(hwnd
);
3503 * 1. Create visible maximized popup window.
3505 trace("calling CreateWindowExA( WS_MAXIMIZE ) for maximized popup window\n");
3506 hwnd
= CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP
| WS_MAXIMIZE
| WS_VISIBLE
,
3507 100, 100, 200, 200, 0, 0, 0, NULL
);
3508 ok (hwnd
!= 0, "Failed to create popup window\n");
3509 ok(IsZoomed(hwnd
), "window should be maximized\n");
3510 ok_sequence(WmCreateMaxPopupSeq
, "CreateWindow(WS_MAXIMIZED):popup", FALSE
);
3512 DestroyWindow(hwnd
);
3516 * 1. Create visible popup window.
3519 trace("calling CreateWindowExA( WS_VISIBLE ) for popup window\n");
3520 hwnd
= CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP
| WS_VISIBLE
,
3521 100, 100, 200, 200, 0, 0, 0, NULL
);
3522 ok (hwnd
!= 0, "Failed to create popup window\n");
3523 ok(!IsZoomed(hwnd
), "window should NOT be maximized\n");
3524 ok_sequence(WmCreatePopupSeq
, "CreateWindow(WS_VISIBLE):popup", TRUE
);
3527 trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for visible popup window\n");
3528 ShowWindow(hwnd
, SW_SHOWMAXIMIZED
);
3529 ok(IsZoomed(hwnd
), "window should be maximized\n");
3530 ok_sequence(WmShowVisMaxPopupSeq
, "ShowWindow(SW_SHOWMAXIMIZED):popup", FALSE
);
3532 DestroyWindow(hwnd
);
3536 static void test_sys_menu(void)
3542 hwnd
= CreateWindowExA(0, "TestWindowClass", NULL
, WS_OVERLAPPEDWINDOW
,
3543 100, 100, 200, 200, 0, 0, 0, NULL
);
3544 ok (hwnd
!= 0, "Failed to create overlapped window\n");
3548 /* test existing window without CS_NOCLOSE style */
3549 hmenu
= GetSystemMenu(hwnd
, FALSE
);
3550 ok(hmenu
!= 0, "GetSystemMenu error %d\n", GetLastError());
3552 state
= GetMenuState(hmenu
, SC_CLOSE
, MF_BYCOMMAND
);
3553 ok(state
!= 0xffffffff, "wrong SC_CLOSE state %x\n", state
);
3554 ok(!(state
& (MF_DISABLED
| MF_GRAYED
)), "wrong SC_CLOSE state %x\n", state
);
3556 EnableMenuItem(hmenu
, SC_CLOSE
, MF_BYCOMMAND
| MF_GRAYED
);
3557 ok_sequence(WmEmptySeq
, "WmEnableMenuItem", FALSE
);
3559 state
= GetMenuState(hmenu
, SC_CLOSE
, MF_BYCOMMAND
);
3560 ok(state
!= 0xffffffff, "wrong SC_CLOSE state %x\n", state
);
3561 ok((state
& (MF_DISABLED
| MF_GRAYED
)) == MF_GRAYED
, "wrong SC_CLOSE state %x\n", state
);
3563 EnableMenuItem(hmenu
, SC_CLOSE
, 0);
3564 ok_sequence(WmEmptySeq
, "WmEnableMenuItem", FALSE
);
3566 state
= GetMenuState(hmenu
, SC_CLOSE
, MF_BYCOMMAND
);
3567 ok(state
!= 0xffffffff, "wrong SC_CLOSE state %x\n", state
);
3568 ok(!(state
& (MF_DISABLED
| MF_GRAYED
)), "wrong SC_CLOSE state %x\n", state
);
3570 /* test whether removing WS_SYSMENU destroys a system menu */
3571 SetWindowLongW(hwnd
, GWL_STYLE
, WS_POPUP
);
3572 SetWindowPos(hwnd
, 0, 0, 0, 0, 0, SWP_NOZORDER
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_FRAMECHANGED
);
3574 hmenu
= GetSystemMenu(hwnd
, FALSE
);
3575 ok(hmenu
!= 0, "GetSystemMenu error %d\n", GetLastError());
3577 DestroyWindow(hwnd
);
3579 /* test new window with CS_NOCLOSE style */
3580 hwnd
= CreateWindowExA(0, "NoCloseWindowClass", NULL
, WS_OVERLAPPEDWINDOW
,
3581 100, 100, 200, 200, 0, 0, 0, NULL
);
3582 ok (hwnd
!= 0, "Failed to create overlapped window\n");
3584 hmenu
= GetSystemMenu(hwnd
, FALSE
);
3585 ok(hmenu
!= 0, "GetSystemMenu error %d\n", GetLastError());
3587 state
= GetMenuState(hmenu
, SC_CLOSE
, MF_BYCOMMAND
);
3588 ok(state
== 0xffffffff, "wrong SC_CLOSE state %x\n", state
);
3590 DestroyWindow(hwnd
);
3592 /* test new window without WS_SYSMENU style */
3593 hwnd
= CreateWindowExA(0, "NoCloseWindowClass", NULL
, WS_OVERLAPPEDWINDOW
& ~WS_SYSMENU
,
3594 100, 100, 200, 200, 0, 0, 0, NULL
);
3595 ok(hwnd
!= 0, "Failed to create overlapped window\n");
3597 hmenu
= GetSystemMenu(hwnd
, FALSE
);
3598 ok(!hmenu
, "GetSystemMenu error %d\n", GetLastError());
3600 DestroyWindow(hwnd
);
3603 /* test if we receive the right sequence of messages */
3604 static void test_messages(void)
3606 HWND hwnd
, hparent
, hchild
;
3607 HWND hchild2
, hbutton
;
3614 hwnd
= CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW
,
3615 100, 100, 200, 200, 0, 0, 0, NULL
);
3616 ok (hwnd
!= 0, "Failed to create overlapped window\n");
3617 ok_sequence(WmCreateOverlappedSeq
, "CreateWindow:overlapped", FALSE
);
3619 /* test ShowWindow(SW_HIDE) on a newly created invisible window */
3620 ok( ShowWindow(hwnd
, SW_HIDE
) == FALSE
, "ShowWindow: window was visible\n" );
3621 ok_sequence(WmEmptySeq
, "ShowWindow(SW_HIDE):overlapped, invisible", FALSE
);
3623 /* test WM_SETREDRAW on a not visible top level window */
3624 test_WM_SETREDRAW(hwnd
);
3626 SetWindowPos(hwnd
, 0,0,0,0,0, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
);
3627 ok_sequence(WmSWP_ShowOverlappedSeq
, "SetWindowPos:SWP_SHOWWINDOW:overlapped", FALSE
);
3628 ok(IsWindowVisible(hwnd
), "window should be visible at this point\n");
3630 ok(GetActiveWindow() == hwnd
, "window should be active\n");
3631 ok(GetFocus() == hwnd
, "window should have input focus\n");
3632 ShowWindow(hwnd
, SW_HIDE
);
3633 ok_sequence(WmHideOverlappedSeq
, "ShowWindow(SW_HIDE):overlapped", TRUE
);
3635 ShowWindow(hwnd
, SW_SHOW
);
3636 ok_sequence(WmShowOverlappedSeq
, "ShowWindow(SW_SHOW):overlapped", TRUE
);
3638 ShowWindow(hwnd
, SW_HIDE
);
3639 ok_sequence(WmHideOverlappedSeq
, "ShowWindow(SW_HIDE):overlapped", FALSE
);
3641 ShowWindow(hwnd
, SW_SHOWMAXIMIZED
);
3642 ok_sequence(WmShowMaxOverlappedSeq
, "ShowWindow(SW_SHOWMAXIMIZED):overlapped", TRUE
);
3644 ShowWindow(hwnd
, SW_RESTORE
);
3645 /* FIXME: add ok_sequence() here */
3648 ShowWindow(hwnd
, SW_SHOW
);
3649 ok_sequence(WmEmptySeq
, "ShowWindow(SW_SHOW):overlapped already visible", FALSE
);
3651 ok(GetActiveWindow() == hwnd
, "window should be active\n");
3652 ok(GetFocus() == hwnd
, "window should have input focus\n");
3653 SetWindowPos(hwnd
, 0,0,0,0,0, SWP_HIDEWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
);
3654 ok_sequence(WmSWP_HideOverlappedSeq
, "SetWindowPos:SWP_HIDEWINDOW:overlapped", FALSE
);
3655 ok(!IsWindowVisible(hwnd
), "window should not be visible at this point\n");
3656 ok(GetActiveWindow() == hwnd
, "window should still be active\n");
3658 /* test WM_SETREDRAW on a visible top level window */
3659 ShowWindow(hwnd
, SW_SHOW
);
3660 test_WM_SETREDRAW(hwnd
);
3662 trace("testing scroll APIs on a visible top level window %p\n", hwnd
);
3663 test_scroll_messages(hwnd
);
3665 /* test resizing and moving */
3666 SetWindowPos( hwnd
, 0, 0, 0, 300, 300, SWP_NOMOVE
|SWP_NOACTIVATE
);
3667 ok_sequence(WmSWP_ResizeSeq
, "SetWindowPos:Resize", FALSE
);
3668 SetWindowPos( hwnd
, 0, 200, 200, 0, 0, SWP_NOSIZE
|SWP_NOACTIVATE
);
3669 ok_sequence(WmSWP_MoveSeq
, "SetWindowPos:Move", FALSE
);
3671 /* popups don't get WM_GETMINMAXINFO */
3672 SetWindowLongW( hwnd
, GWL_STYLE
, WS_VISIBLE
|WS_POPUP
);
3673 SetWindowPos( hwnd
, 0, 0, 0, 0, 0, SWP_NOZORDER
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_FRAMECHANGED
);
3675 SetWindowPos( hwnd
, 0, 0, 0, 200, 200, SWP_NOMOVE
|SWP_NOACTIVATE
);
3676 ok_sequence(WmSWP_ResizePopupSeq
, "SetWindowPos:ResizePopup", FALSE
);
3678 DestroyWindow(hwnd
);
3679 ok_sequence(WmDestroyOverlappedSeq
, "DestroyWindow:overlapped", FALSE
);
3681 hparent
= CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW
| WS_VISIBLE
,
3682 100, 100, 200, 200, 0, 0, 0, NULL
);
3683 ok (hparent
!= 0, "Failed to create parent window\n");
3686 hchild
= CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD
| WS_MAXIMIZE
,
3687 0, 0, 10, 10, hparent
, 0, 0, NULL
);
3688 ok (hchild
!= 0, "Failed to create child window\n");
3689 ok_sequence(WmCreateMaximizedChildSeq
, "CreateWindow:maximized child", FALSE
);
3690 DestroyWindow(hchild
);
3693 /* visible child window with a caption */
3694 hchild
= CreateWindowExA(0, "TestWindowClass", "Test child",
3695 WS_CHILD
| WS_VISIBLE
| WS_CAPTION
,
3696 0, 0, 10, 10, hparent
, 0, 0, NULL
);
3697 ok (hchild
!= 0, "Failed to create child window\n");
3698 ok_sequence(WmCreateVisibleChildSeq
, "CreateWindow:visible child", FALSE
);
3700 trace("testing scroll APIs on a visible child window %p\n", hchild
);
3701 test_scroll_messages(hchild
);
3703 SetWindowPos(hchild
, 0,0,0,0,0, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
);
3704 ok_sequence(WmShowChildSeq_4
, "SetWindowPos(SWP_SHOWWINDOW):child with a caption", FALSE
);
3706 DestroyWindow(hchild
);
3709 hchild
= CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD
,
3710 0, 0, 10, 10, hparent
, 0, 0, NULL
);
3711 ok (hchild
!= 0, "Failed to create child window\n");
3712 ok_sequence(WmCreateChildSeq
, "CreateWindow:child", FALSE
);
3714 hchild2
= CreateWindowExA(0, "SimpleWindowClass", "Test child2", WS_CHILD
,
3715 100, 100, 50, 50, hparent
, 0, 0, NULL
);
3716 ok (hchild2
!= 0, "Failed to create child2 window\n");
3719 hbutton
= CreateWindowExA(0, "TestWindowClass", "Test button", WS_CHILD
,
3720 0, 100, 50, 50, hchild
, 0, 0, NULL
);
3721 ok (hbutton
!= 0, "Failed to create button window\n");
3723 /* test WM_SETREDRAW on a not visible child window */
3724 test_WM_SETREDRAW(hchild
);
3726 ShowWindow(hchild
, SW_SHOW
);
3727 ok_sequence(WmShowChildSeq
, "ShowWindow(SW_SHOW):child", FALSE
);
3729 ShowWindow(hchild
, SW_HIDE
);
3730 ok_sequence(WmHideChildSeq
, "ShowWindow(SW_HIDE):child", FALSE
);
3732 ShowWindow(hchild
, SW_SHOW
);
3733 ok_sequence(WmShowChildSeq
, "ShowWindow(SW_SHOW):child", FALSE
);
3735 /* test WM_SETREDRAW on a visible child window */
3736 test_WM_SETREDRAW(hchild
);
3738 MoveWindow(hchild
, 10, 10, 20, 20, TRUE
);
3739 ok_sequence(WmResizingChildWithMoveWindowSeq
, "MoveWindow:child", FALSE
);
3741 ShowWindow(hchild
, SW_HIDE
);
3743 SetWindowPos(hchild
, 0,0,0,0,0, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
);
3744 ok_sequence(WmShowChildSeq_2
, "SetWindowPos:show_child_2", FALSE
);
3746 ShowWindow(hchild
, SW_HIDE
);
3748 SetWindowPos(hchild
, 0,0,0,0,0, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
);
3749 ok_sequence(WmShowChildSeq_3
, "SetWindowPos:show_child_3", FALSE
);
3751 /* DestroyWindow sequence below expects that a child has focus */
3755 DestroyWindow(hchild
);
3756 ok_sequence(WmDestroyChildSeq
, "DestroyWindow:child", FALSE
);
3757 DestroyWindow(hchild2
);
3758 DestroyWindow(hbutton
);
3761 hchild
= CreateWindowExA(0, "TestWindowClass", "Test Child Popup", WS_CHILD
| WS_POPUP
,
3762 0, 0, 100, 100, hparent
, 0, 0, NULL
);
3763 ok (hchild
!= 0, "Failed to create child popup window\n");
3764 ok_sequence(WmCreateChildPopupSeq
, "CreateWindow:child_popup", FALSE
);
3765 DestroyWindow(hchild
);
3767 /* test what happens to a window which sets WS_VISIBLE in WM_CREATE */
3769 hchild
= CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP
,
3770 0, 0, 100, 100, hparent
, 0, 0, NULL
);
3771 ok (hchild
!= 0, "Failed to create popup window\n");
3772 ok_sequence(WmCreateInvisiblePopupSeq
, "CreateWindow:invisible_popup", FALSE
);
3773 ok(GetWindowLongA(hchild
, GWL_STYLE
) & WS_VISIBLE
, "WS_VISIBLE should be set\n");
3774 ok(IsWindowVisible(hchild
), "IsWindowVisible() should return TRUE\n");
3776 ShowWindow(hchild
, SW_SHOW
);
3777 ok_sequence(WmEmptySeq
, "ShowWindow:show_visible_popup", FALSE
);
3779 SetWindowPos(hchild
, 0,0,0,0,0, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
|SWP_NOZORDER
);
3780 ok_sequence(WmShowVisiblePopupSeq_2
, "SetWindowPos:show_visible_popup_2", FALSE
);
3782 SetWindowPos(hchild
, 0,0,0,0,0, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
);
3783 ok_sequence(WmShowVisiblePopupSeq_3
, "SetWindowPos:show_visible_popup_3", FALSE
);
3784 DestroyWindow(hchild
);
3786 /* this time add WS_VISIBLE for CreateWindowEx, but this fact actually
3787 * changes nothing in message sequences.
3790 hchild
= CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP
| WS_VISIBLE
,
3791 0, 0, 100, 100, hparent
, 0, 0, NULL
);
3792 ok (hchild
!= 0, "Failed to create popup window\n");
3793 ok_sequence(WmCreateInvisiblePopupSeq
, "CreateWindow:invisible_popup", FALSE
);
3794 ok(GetWindowLongA(hchild
, GWL_STYLE
) & WS_VISIBLE
, "WS_VISIBLE should be set\n");
3795 ok(IsWindowVisible(hchild
), "IsWindowVisible() should return TRUE\n");
3797 ShowWindow(hchild
, SW_SHOW
);
3798 ok_sequence(WmEmptySeq
, "ShowWindow:show_visible_popup", FALSE
);
3800 SetWindowPos(hchild
, 0,0,0,0,0, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
|SWP_NOZORDER
);
3801 ok_sequence(WmShowVisiblePopupSeq_2
, "SetWindowPos:show_visible_popup_2", FALSE
);
3802 DestroyWindow(hchild
);
3805 hwnd
= CreateWindowExA(WS_EX_DLGMODALFRAME
, "TestDialogClass", NULL
, WS_VISIBLE
|WS_CAPTION
|WS_SYSMENU
|WS_DLGFRAME
,
3806 0, 0, 100, 100, hparent
, 0, 0, NULL
);
3807 ok(hwnd
!= 0, "Failed to create custom dialog window\n");
3808 ok_sequence(WmCreateCustomDialogSeq
, "CreateCustomDialog", TRUE
);
3811 trace("testing scroll APIs on a visible dialog %p\n", hwnd);
3812 test_scroll_messages(hwnd);
3816 after_end_dialog
= 1;
3817 EndDialog( hwnd
, 0 );
3818 ok_sequence(WmEndCustomDialogSeq
, "EndCustomDialog", FALSE
);
3820 DestroyWindow(hwnd
);
3821 after_end_dialog
= 0;
3823 hwnd
= CreateWindowExA(0, "TestDialogClass", NULL
, WS_POPUP
,
3824 0, 0, 100, 100, 0, 0, GetModuleHandleA(0), NULL
);
3825 ok(hwnd
!= 0, "Failed to create custom dialog window\n");
3827 trace("call ShowWindow(%p, SW_SHOW)\n", hwnd
);
3828 ShowWindow(hwnd
, SW_SHOW
);
3829 ok_sequence(WmShowCustomDialogSeq
, "ShowCustomDialog", TRUE
);
3830 DestroyWindow(hwnd
);
3833 DialogBoxA( 0, "TEST_DIALOG", hparent
, TestModalDlgProcA
);
3834 ok_sequence(WmModalDialogSeq
, "ModalDialog", TRUE
);
3836 DestroyWindow(hparent
);
3839 /* Message sequence for SetMenu */
3840 ok(!DrawMenuBar(hwnd
), "DrawMenuBar should return FALSE for a window without a menu\n");
3841 ok_sequence(WmEmptySeq
, "DrawMenuBar for a window without a menu", FALSE
);
3843 hmenu
= CreateMenu();
3844 ok (hmenu
!= 0, "Failed to create menu\n");
3845 ok (InsertMenuA(hmenu
, -1, MF_BYPOSITION
, 0x1000, "foo"), "InsertMenu failed\n");
3846 hwnd
= CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW
,
3847 100, 100, 200, 200, 0, hmenu
, 0, NULL
);
3848 ok_sequence(WmCreateOverlappedSeq
, "CreateWindow:overlapped", FALSE
);
3849 ok (SetMenu(hwnd
, 0), "SetMenu\n");
3850 ok_sequence(WmSetMenuNonVisibleSizeChangeSeq
, "SetMenu:NonVisibleSizeChange", FALSE
);
3851 ok (SetMenu(hwnd
, 0), "SetMenu\n");
3852 ok_sequence(WmSetMenuNonVisibleNoSizeChangeSeq
, "SetMenu:NonVisibleNoSizeChange", FALSE
);
3853 ShowWindow(hwnd
, SW_SHOW
);
3854 UpdateWindow( hwnd
);
3855 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
3857 ok (SetMenu(hwnd
, 0), "SetMenu\n");
3858 ok_sequence(WmSetMenuVisibleNoSizeChangeSeq
, "SetMenu:VisibleNoSizeChange", FALSE
);
3859 ok (SetMenu(hwnd
, hmenu
), "SetMenu\n");
3860 ok_sequence(WmSetMenuVisibleSizeChangeSeq
, "SetMenu:VisibleSizeChange", FALSE
);
3862 UpdateWindow( hwnd
);
3863 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
3865 ok(DrawMenuBar(hwnd
), "DrawMenuBar\n");
3866 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
3867 ok_sequence(WmDrawMenuBarSeq
, "DrawMenuBar", FALSE
);
3869 DestroyWindow(hwnd
);
3872 /* Message sequence for EnableWindow */
3873 hparent
= CreateWindowExA(0, "TestWindowClass", "Test parent", WS_OVERLAPPEDWINDOW
| WS_VISIBLE
,
3874 100, 100, 200, 200, 0, 0, 0, NULL
);
3875 ok (hparent
!= 0, "Failed to create parent window\n");
3876 hchild
= CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD
| WS_VISIBLE
,
3877 0, 0, 10, 10, hparent
, 0, 0, NULL
);
3878 ok (hchild
!= 0, "Failed to create child window\n");
3884 EnableWindow(hparent
, FALSE
);
3885 ok_sequence(WmEnableWindowSeq_1
, "EnableWindow(FALSE)", FALSE
);
3887 EnableWindow(hparent
, TRUE
);
3888 ok_sequence(WmEnableWindowSeq_2
, "EnableWindow(TRUE)", FALSE
);
3890 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
3893 /* MsgWaitForMultipleObjects test */
3894 ret
= MsgWaitForMultipleObjects(0, NULL
, FALSE
, 0, QS_POSTMESSAGE
);
3895 ok(ret
== WAIT_TIMEOUT
, "MsgWaitForMultipleObjects returned %x\n", ret
);
3897 PostMessageA(hparent
, WM_USER
, 0, 0);
3899 ret
= MsgWaitForMultipleObjects(0, NULL
, FALSE
, 0, QS_POSTMESSAGE
);
3900 ok(ret
== WAIT_OBJECT_0
, "MsgWaitForMultipleObjects returned %x\n", ret
);
3902 ok(PeekMessageW( &msg
, 0, 0, 0, PM_REMOVE
), "PeekMessage should succeed\n");
3903 ok(msg
.message
== WM_USER
, "got %04x instead of WM_USER\n", msg
.message
);
3905 ret
= MsgWaitForMultipleObjects(0, NULL
, FALSE
, 0, QS_POSTMESSAGE
);
3906 ok(ret
== WAIT_TIMEOUT
, "MsgWaitForMultipleObjects returned %x\n", ret
);
3907 /* end of MsgWaitForMultipleObjects test */
3909 /* the following test causes an exception in user.exe under win9x */
3910 if (!PostMessageW( hparent
, WM_USER
, 0, 0 ))
3912 DestroyWindow(hparent
);
3916 PostMessageW( hparent
, WM_USER
+1, 0, 0 );
3917 /* PeekMessage(NULL) fails, but still removes the message */
3918 SetLastError(0xdeadbeef);
3919 ok( !PeekMessageW( NULL
, 0, 0, 0, PM_REMOVE
), "PeekMessage(NULL) should fail\n" );
3920 ok( GetLastError() == ERROR_NOACCESS
|| /* Win2k */
3921 GetLastError() == 0xdeadbeef, /* NT4 */
3922 "last error is %d\n", GetLastError() );
3923 ok( PeekMessageW( &msg
, 0, 0, 0, PM_REMOVE
), "PeekMessage should succeed\n" );
3924 ok( msg
.message
== WM_USER
+1, "got %x instead of WM_USER+1\n", msg
.message
);
3926 DestroyWindow(hchild
);
3927 DestroyWindow(hparent
);
3931 static void invisible_parent_tests(void)
3933 HWND hparent
, hchild
;
3935 hparent
= CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW
,
3936 100, 100, 200, 200, 0, 0, 0, NULL
);
3937 ok (hparent
!= 0, "Failed to create parent window\n");
3940 /* test showing child with hidden parent */
3942 hchild
= CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD
,
3943 0, 0, 10, 10, hparent
, 0, 0, NULL
);
3944 ok (hchild
!= 0, "Failed to create child window\n");
3945 ok_sequence(WmCreateChildSeq
, "CreateWindow:child", FALSE
);
3947 ShowWindow( hchild
, SW_MINIMIZE
);
3948 ok_sequence(WmShowChildInvisibleParentSeq_1
, "ShowWindow(SW_MINIMIZE) child with invisible parent", FALSE
);
3949 ok(GetWindowLongA(hchild
, GWL_STYLE
) & WS_VISIBLE
, "WS_VISIBLE should be set\n");
3950 ok(!IsWindowVisible(hchild
), "IsWindowVisible() should return FALSE\n");
3955 ShowWindow( hchild
, SW_MINIMIZE
);
3956 ok_sequence(WmShowChildInvisibleParentSeq_1r
, "ShowWindow(SW_MINIMIZE) child with invisible parent", FALSE
);
3958 DestroyWindow(hchild
);
3959 hchild
= CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD
,
3960 0, 0, 10, 10, hparent
, 0, 0, NULL
);
3963 ShowWindow( hchild
, SW_MAXIMIZE
);
3964 ok_sequence(WmShowChildInvisibleParentSeq_2
, "ShowWindow(SW_MAXIMIZE) child with invisible parent", FALSE
);
3965 ok(GetWindowLongA(hchild
, GWL_STYLE
) & WS_VISIBLE
, "WS_VISIBLE should be set\n");
3966 ok(!IsWindowVisible(hchild
), "IsWindowVisible() should return FALSE\n");
3971 ShowWindow( hchild
, SW_MAXIMIZE
);
3972 ok_sequence(WmShowChildInvisibleParentSeq_2r
, "ShowWindow(SW_MAXIMIZE) child with invisible parent", FALSE
);
3974 DestroyWindow(hchild
);
3975 hchild
= CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD
,
3976 0, 0, 10, 10, hparent
, 0, 0, NULL
);
3979 ShowWindow( hchild
, SW_RESTORE
);
3980 ok_sequence(WmShowChildInvisibleParentSeq_5
, "ShowWindow(SW_RESTORE) child with invisible parent", FALSE
);
3981 ok(GetWindowLongA(hchild
, GWL_STYLE
) & WS_VISIBLE
, "WS_VISIBLE should be set\n");
3982 ok(!IsWindowVisible(hchild
), "IsWindowVisible() should return FALSE\n");
3984 DestroyWindow(hchild
);
3985 hchild
= CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD
,
3986 0, 0, 10, 10, hparent
, 0, 0, NULL
);
3989 ShowWindow( hchild
, SW_SHOWMINIMIZED
);
3990 ok_sequence(WmShowChildInvisibleParentSeq_3
, "ShowWindow(SW_SHOWMINIMIZED) child with invisible parent", FALSE
);
3991 ok(GetWindowLongA(hchild
, GWL_STYLE
) & WS_VISIBLE
, "WS_VISIBLE should be set\n");
3992 ok(!IsWindowVisible(hchild
), "IsWindowVisible() should return FALSE\n");
3997 ShowWindow( hchild
, SW_SHOWMINIMIZED
);
3998 ok_sequence(WmShowChildInvisibleParentSeq_3r
, "ShowWindow(SW_SHOWMINIMIZED) child with invisible parent", FALSE
);
4000 DestroyWindow(hchild
);
4001 hchild
= CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD
,
4002 0, 0, 10, 10, hparent
, 0, 0, NULL
);
4005 /* same as ShowWindow( hchild, SW_MAXIMIZE ); */
4006 ShowWindow( hchild
, SW_SHOWMAXIMIZED
);
4007 ok_sequence(WmShowChildInvisibleParentSeq_2
, "ShowWindow(SW_SHOWMAXIMIZED) child with invisible parent", FALSE
);
4008 ok(GetWindowLongA(hchild
, GWL_STYLE
) & WS_VISIBLE
, "WS_VISIBLE should be set\n");
4009 ok(!IsWindowVisible(hchild
), "IsWindowVisible() should return FALSE\n");
4011 DestroyWindow(hchild
);
4012 hchild
= CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD
,
4013 0, 0, 10, 10, hparent
, 0, 0, NULL
);
4016 ShowWindow( hchild
, SW_SHOWMINNOACTIVE
);
4017 ok_sequence(WmShowChildInvisibleParentSeq_4
, "ShowWindow(SW_SHOWMINNOACTIVE) child with invisible parent", FALSE
);
4018 ok(GetWindowLongA(hchild
, GWL_STYLE
) & WS_VISIBLE
, "WS_VISIBLE should be set\n");
4019 ok(!IsWindowVisible(hchild
), "IsWindowVisible() should return FALSE\n");
4024 ShowWindow( hchild
, SW_SHOWMINNOACTIVE
);
4025 ok_sequence(WmShowChildInvisibleParentSeq_4r
, "ShowWindow(SW_SHOWMINNOACTIVE) child with invisible parent", FALSE
);
4027 DestroyWindow(hchild
);
4028 hchild
= CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD
,
4029 0, 0, 10, 10, hparent
, 0, 0, NULL
);
4032 /* FIXME: looks like XP SP2 doesn't know about SW_FORCEMINIMIZE at all */
4033 ShowWindow( hchild
, SW_FORCEMINIMIZE
);
4034 ok_sequence(WmEmptySeq
, "ShowWindow(SW_FORCEMINIMIZE) child with invisible parent", TRUE
);
4036 ok(!(GetWindowLongA(hchild
, GWL_STYLE
) & WS_VISIBLE
), "WS_VISIBLE should be not set\n");
4038 ok(!IsWindowVisible(hchild
), "IsWindowVisible() should return FALSE\n");
4040 DestroyWindow(hchild
);
4041 hchild
= CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD
,
4042 0, 0, 10, 10, hparent
, 0, 0, NULL
);
4045 ShowWindow( hchild
, SW_SHOWNA
);
4046 ok_sequence(WmShowChildInvisibleParentSeq_5
, "ShowWindow(SW_SHOWNA) child with invisible parent", FALSE
);
4047 ok(GetWindowLongA(hchild
, GWL_STYLE
) & WS_VISIBLE
, "WS_VISIBLE should be set\n");
4048 ok(!IsWindowVisible(hchild
), "IsWindowVisible() should return FALSE\n");
4053 ShowWindow( hchild
, SW_SHOWNA
);
4054 ok_sequence(WmShowChildInvisibleParentSeq_5
, "ShowWindow(SW_SHOWNA) child with invisible parent", FALSE
);
4056 DestroyWindow(hchild
);
4057 hchild
= CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD
,
4058 0, 0, 10, 10, hparent
, 0, 0, NULL
);
4061 ShowWindow( hchild
, SW_SHOW
);
4062 ok_sequence(WmShowChildInvisibleParentSeq_5
, "ShowWindow(SW_SHOW) child with invisible parent", FALSE
);
4063 ok(GetWindowLongA(hchild
, GWL_STYLE
) & WS_VISIBLE
, "WS_VISIBLE should be set\n");
4064 ok(!IsWindowVisible(hchild
), "IsWindowVisible() should return FALSE\n");
4069 ShowWindow( hchild
, SW_SHOW
);
4070 ok_sequence(WmEmptySeq
, "ShowWindow(SW_SHOW) child with invisible parent", FALSE
);
4072 ShowWindow( hchild
, SW_HIDE
);
4073 ok_sequence(WmHideChildInvisibleParentSeq
, "ShowWindow:hide child with invisible parent", FALSE
);
4074 ok(!(GetWindowLongA(hchild
, GWL_STYLE
) & WS_VISIBLE
), "WS_VISIBLE should be not set\n");
4075 ok(!IsWindowVisible(hchild
), "IsWindowVisible() should return FALSE\n");
4077 SetWindowPos(hchild
, 0,0,0,0,0, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
|SWP_NOZORDER
);
4078 ok_sequence(WmShowChildInvisibleParentSeq_6
, "SetWindowPos:show child with invisible parent", FALSE
);
4079 ok(GetWindowLongA(hchild
, GWL_STYLE
) & WS_VISIBLE
, "WS_VISIBLE should be set\n");
4080 ok(!IsWindowVisible(hchild
), "IsWindowVisible() should return FALSE\n");
4082 SetWindowPos(hchild
, 0,0,0,0,0, SWP_HIDEWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
|SWP_NOZORDER
);
4083 ok_sequence(WmHideChildInvisibleParentSeq_2
, "SetWindowPos:hide child with invisible parent", FALSE
);
4084 ok(!(GetWindowLongA(hchild
, GWL_STYLE
) & WS_VISIBLE
), "WS_VISIBLE should not be set\n");
4085 ok(!IsWindowVisible(hchild
), "IsWindowVisible() should return FALSE\n");
4087 SetWindowPos(hchild
, 0,0,0,0,0, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOACTIVATE
|SWP_NOZORDER
);
4089 DestroyWindow(hchild
);
4090 ok_sequence(WmDestroyInvisibleChildSeq
, "DestroyInvisibleChildSeq", FALSE
);
4092 DestroyWindow(hparent
);
4096 /****************** button message test *************************/
4097 static const struct message WmSetFocusButtonSeq
[] =
4099 { HCBT_SETFOCUS
, hook
},
4100 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 },
4101 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 2 },
4102 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
4103 { WM_SETFOCUS
, sent
|wparam
, 0 },
4104 { WM_CTLCOLORBTN
, sent
|defwinproc
},
4107 static const struct message WmKillFocusButtonSeq
[] =
4109 { HCBT_SETFOCUS
, hook
},
4110 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
4111 { WM_KILLFOCUS
, sent
|wparam
, 0 },
4112 { WM_CTLCOLORBTN
, sent
|defwinproc
},
4113 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 },
4114 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 1 },
4117 static const struct message WmSetFocusStaticSeq
[] =
4119 { HCBT_SETFOCUS
, hook
},
4120 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 },
4121 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 2 },
4122 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
4123 { WM_SETFOCUS
, sent
|wparam
, 0 },
4124 { WM_CTLCOLORSTATIC
, sent
|defwinproc
},
4127 static const struct message WmKillFocusStaticSeq
[] =
4129 { HCBT_SETFOCUS
, hook
},
4130 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
4131 { WM_KILLFOCUS
, sent
|wparam
, 0 },
4132 { WM_CTLCOLORSTATIC
, sent
|defwinproc
},
4133 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 },
4134 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 1 },
4137 static const struct message WmLButtonDownSeq
[] =
4139 { WM_LBUTTONDOWN
, sent
|wparam
|lparam
, 0, 0 },
4140 { EVENT_SYSTEM_CAPTURESTART
, winevent_hook
|wparam
|lparam
, 0, 0 },
4141 { HCBT_SETFOCUS
, hook
},
4142 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
4143 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 2 },
4144 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
4145 { WM_SETFOCUS
, sent
|wparam
|defwinproc
, 0 },
4146 { WM_CTLCOLORBTN
, sent
|defwinproc
},
4147 { BM_SETSTATE
, sent
|wparam
|defwinproc
, TRUE
},
4148 { WM_CTLCOLORBTN
, sent
|defwinproc
},
4149 { EVENT_OBJECT_STATECHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
4152 static const struct message WmLButtonUpSeq
[] =
4154 { WM_LBUTTONUP
, sent
|wparam
|lparam
, 0, 0 },
4155 { BM_SETSTATE
, sent
|wparam
|defwinproc
, FALSE
},
4156 { WM_CTLCOLORBTN
, sent
|defwinproc
},
4157 { EVENT_OBJECT_STATECHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
4158 { EVENT_SYSTEM_CAPTUREEND
, winevent_hook
|wparam
|lparam
, 0, 0 },
4159 { WM_CAPTURECHANGED
, sent
|wparam
|defwinproc
, 0 },
4163 static WNDPROC old_button_proc
;
4165 static LRESULT CALLBACK
button_hook_proc(HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
4167 static long defwndproc_counter
= 0;
4171 trace("button: %p, %04x, %08x, %08lx\n", hwnd
, message
, wParam
, lParam
);
4173 /* explicitly ignore WM_GETICON message */
4174 if (message
== WM_GETICON
) return 0;
4176 msg
.message
= message
;
4177 msg
.flags
= sent
|wparam
|lparam
;
4178 if (defwndproc_counter
) msg
.flags
|= defwinproc
;
4179 msg
.wParam
= wParam
;
4180 msg
.lParam
= lParam
;
4183 if (message
== BM_SETSTATE
)
4184 ok(GetCapture() == hwnd
, "GetCapture() = %p\n", GetCapture());
4186 defwndproc_counter
++;
4187 ret
= CallWindowProcA(old_button_proc
, hwnd
, message
, wParam
, lParam
);
4188 defwndproc_counter
--;
4193 static void subclass_button(void)
4197 if (!GetClassInfoA(0, "button", &cls
)) assert(0);
4199 old_button_proc
= cls
.lpfnWndProc
;
4201 cls
.hInstance
= GetModuleHandle(0);
4202 cls
.lpfnWndProc
= button_hook_proc
;
4203 cls
.lpszClassName
= "my_button_class";
4204 if (!RegisterClassA(&cls
)) assert(0);
4207 static void test_button_messages(void)
4213 const struct message
*setfocus
;
4214 const struct message
*killfocus
;
4216 { BS_PUSHBUTTON
, DLGC_BUTTON
| DLGC_UNDEFPUSHBUTTON
,
4217 WmSetFocusButtonSeq
, WmKillFocusButtonSeq
},
4218 { BS_DEFPUSHBUTTON
, DLGC_BUTTON
| DLGC_DEFPUSHBUTTON
,
4219 WmSetFocusButtonSeq
, WmKillFocusButtonSeq
},
4220 { BS_CHECKBOX
, DLGC_BUTTON
,
4221 WmSetFocusStaticSeq
, WmKillFocusStaticSeq
},
4222 { BS_AUTOCHECKBOX
, DLGC_BUTTON
,
4223 WmSetFocusStaticSeq
, WmKillFocusStaticSeq
},
4224 { BS_RADIOBUTTON
, DLGC_BUTTON
| DLGC_RADIOBUTTON
,
4225 WmSetFocusStaticSeq
, WmKillFocusStaticSeq
},
4226 { BS_3STATE
, DLGC_BUTTON
,
4227 WmSetFocusStaticSeq
, WmKillFocusStaticSeq
},
4228 { BS_AUTO3STATE
, DLGC_BUTTON
,
4229 WmSetFocusStaticSeq
, WmKillFocusStaticSeq
},
4230 { BS_GROUPBOX
, DLGC_STATIC
,
4231 WmSetFocusStaticSeq
, WmKillFocusStaticSeq
},
4232 { BS_USERBUTTON
, DLGC_BUTTON
| DLGC_UNDEFPUSHBUTTON
,
4233 WmSetFocusButtonSeq
, WmKillFocusButtonSeq
},
4234 { BS_AUTORADIOBUTTON
, DLGC_BUTTON
| DLGC_RADIOBUTTON
,
4235 WmSetFocusStaticSeq
, WmKillFocusStaticSeq
},
4236 { BS_OWNERDRAW
, DLGC_BUTTON
,
4237 WmSetFocusButtonSeq
, WmKillFocusButtonSeq
}
4245 for (i
= 0; i
< sizeof(button
)/sizeof(button
[0]); i
++)
4247 hwnd
= CreateWindowExA(0, "my_button_class", "test", button
[i
].style
| WS_POPUP
,
4248 0, 0, 50, 14, 0, 0, 0, NULL
);
4249 ok(hwnd
!= 0, "Failed to create button window\n");
4251 dlg_code
= SendMessageA(hwnd
, WM_GETDLGCODE
, 0, 0);
4252 ok(dlg_code
== button
[i
].dlg_code
, "%u: wrong dlg_code %08x\n", i
, dlg_code
);
4254 ShowWindow(hwnd
, SW_SHOW
);
4259 trace("button style %08x\n", button
[i
].style
);
4261 ok_sequence(button
[i
].setfocus
, "SetFocus(hwnd) on a button", FALSE
);
4264 ok_sequence(button
[i
].killfocus
, "SetFocus(0) on a button", FALSE
);
4266 DestroyWindow(hwnd
);
4269 hwnd
= CreateWindowExA(0, "my_button_class", "test", BS_PUSHBUTTON
| WS_POPUP
| WS_VISIBLE
,
4270 0, 0, 50, 14, 0, 0, 0, NULL
);
4271 ok(hwnd
!= 0, "Failed to create button window\n");
4276 SendMessageA(hwnd
, WM_LBUTTONDOWN
, 0, 0);
4277 ok_sequence(WmLButtonDownSeq
, "WM_LBUTTONDOWN on a button", FALSE
);
4279 SendMessageA(hwnd
, WM_LBUTTONUP
, 0, 0);
4280 ok_sequence(WmLButtonUpSeq
, "WM_LBUTTONUP on a button", FALSE
);
4281 DestroyWindow(hwnd
);
4284 /****************** static message test *************************/
4285 static const struct message WmSetFontStaticSeq
[] =
4287 { WM_SETFONT
, sent
},
4288 { WM_PAINT
, sent
|defwinproc
},
4289 { WM_ERASEBKGND
, sent
|defwinproc
},
4290 { WM_CTLCOLORSTATIC
, sent
|defwinproc
},
4294 static WNDPROC old_static_proc
;
4296 static LRESULT CALLBACK
static_hook_proc(HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
4298 static long defwndproc_counter
= 0;
4302 trace("static: %p, %04x, %08x, %08lx\n", hwnd
, message
, wParam
, lParam
);
4304 /* explicitly ignore WM_GETICON message */
4305 if (message
== WM_GETICON
) return 0;
4307 msg
.message
= message
;
4308 msg
.flags
= sent
|wparam
|lparam
;
4309 if (defwndproc_counter
) msg
.flags
|= defwinproc
;
4310 msg
.wParam
= wParam
;
4311 msg
.lParam
= lParam
;
4315 defwndproc_counter
++;
4316 ret
= CallWindowProcA(old_static_proc
, hwnd
, message
, wParam
, lParam
);
4317 defwndproc_counter
--;
4322 static void subclass_static(void)
4326 if (!GetClassInfoA(0, "static", &cls
)) assert(0);
4328 old_static_proc
= cls
.lpfnWndProc
;
4330 cls
.hInstance
= GetModuleHandle(0);
4331 cls
.lpfnWndProc
= static_hook_proc
;
4332 cls
.lpszClassName
= "my_static_class";
4333 if (!RegisterClassA(&cls
)) assert(0);
4336 static void test_static_messages(void)
4338 /* FIXME: make as comprehensive as the button message test */
4343 const struct message
*setfont
;
4345 { SS_LEFT
, DLGC_STATIC
,
4346 WmSetFontStaticSeq
}
4354 for (i
= 0; i
< sizeof(static_ctrl
)/sizeof(static_ctrl
[0]); i
++)
4356 hwnd
= CreateWindowExA(0, "my_static_class", "test", static_ctrl
[i
].style
| WS_POPUP
,
4357 0, 0, 50, 14, 0, 0, 0, NULL
);
4358 ok(hwnd
!= 0, "Failed to create static window\n");
4360 dlg_code
= SendMessageA(hwnd
, WM_GETDLGCODE
, 0, 0);
4361 ok(dlg_code
== static_ctrl
[i
].dlg_code
, "%u: wrong dlg_code %08x\n", i
, dlg_code
);
4363 ShowWindow(hwnd
, SW_SHOW
);
4368 trace("static style %08x\n", static_ctrl
[i
].style
);
4369 SendMessage(hwnd
, WM_SETFONT
, (WPARAM
)GetStockObject(DEFAULT_GUI_FONT
), TRUE
);
4370 ok_sequence(static_ctrl
[i
].setfont
, "WM_SETFONT on a static", FALSE
);
4372 DestroyWindow(hwnd
);
4376 /************* painting message test ********************/
4378 void dump_region(HRGN hrgn
)
4381 RGNDATA
*data
= NULL
;
4386 printf( "null region\n" );
4389 if (!(size
= GetRegionData( hrgn
, 0, NULL
))) return;
4390 if (!(data
= HeapAlloc( GetProcessHeap(), 0, size
))) return;
4391 GetRegionData( hrgn
, size
, data
);
4392 printf("%d rects:", data
->rdh
.nCount
);
4393 for (i
= 0, rect
= (RECT
*)data
->Buffer
; i
< data
->rdh
.nCount
; i
++, rect
++)
4394 printf( " (%d,%d)-(%d,%d)", rect
->left
, rect
->top
, rect
->right
, rect
->bottom
);
4396 HeapFree( GetProcessHeap(), 0, data
);
4399 static void check_update_rgn( HWND hwnd
, HRGN hrgn
)
4403 HRGN tmp
= CreateRectRgn( 0, 0, 0, 0 );
4404 HRGN update
= CreateRectRgn( 0, 0, 0, 0 );
4406 ret
= GetUpdateRgn( hwnd
, update
, FALSE
);
4407 ok( ret
!= ERROR
, "GetUpdateRgn failed\n" );
4408 if (ret
== NULLREGION
)
4410 ok( !hrgn
, "Update region shouldn't be empty\n" );
4414 if (CombineRgn( tmp
, hrgn
, update
, RGN_XOR
) != NULLREGION
)
4416 ok( 0, "Regions are different\n" );
4417 if (winetest_debug
> 0)
4419 printf( "Update region: " );
4420 dump_region( update
);
4421 printf( "Wanted region: " );
4422 dump_region( hrgn
);
4426 GetRgnBox( update
, &r1
);
4427 GetUpdateRect( hwnd
, &r2
, FALSE
);
4428 ok( r1
.left
== r2
.left
&& r1
.top
== r2
.top
&& r1
.right
== r2
.right
&& r1
.bottom
== r2
.bottom
,
4429 "Rectangles are different: %d,%d-%d,%d / %d,%d-%d,%d\n",
4430 r1
.left
, r1
.top
, r1
.right
, r1
.bottom
, r2
.left
, r2
.top
, r2
.right
, r2
.bottom
);
4432 DeleteObject( tmp
);
4433 DeleteObject( update
);
4436 static const struct message WmInvalidateRgn
[] = {
4437 { WM_NCPAINT
, sent
},
4438 { WM_GETTEXT
, sent
|defwinproc
|optional
},
4442 static const struct message WmGetUpdateRect
[] = {
4443 { WM_NCPAINT
, sent
},
4444 { WM_GETTEXT
, sent
|defwinproc
|optional
},
4449 static const struct message WmInvalidateFull
[] = {
4450 { WM_NCPAINT
, sent
|wparam
, 1 },
4451 { WM_GETTEXT
, sent
|defwinproc
|optional
},
4455 static const struct message WmInvalidateErase
[] = {
4456 { WM_NCPAINT
, sent
|wparam
, 1 },
4457 { WM_GETTEXT
, sent
|defwinproc
|optional
},
4458 { WM_ERASEBKGND
, sent
},
4462 static const struct message WmInvalidatePaint
[] = {
4464 { WM_NCPAINT
, sent
|wparam
|beginpaint
, 1 },
4465 { WM_GETTEXT
, sent
|beginpaint
|defwinproc
|optional
},
4469 static const struct message WmInvalidateErasePaint
[] = {
4471 { WM_NCPAINT
, sent
|wparam
|beginpaint
, 1 },
4472 { WM_GETTEXT
, sent
|beginpaint
|defwinproc
|optional
},
4473 { WM_ERASEBKGND
, sent
|beginpaint
},
4477 static const struct message WmInvalidateErasePaint2
[] = {
4479 { WM_NCPAINT
, sent
|beginpaint
},
4480 { WM_GETTEXT
, sent
|beginpaint
|defwinproc
|optional
},
4481 { WM_ERASEBKGND
, sent
|beginpaint
},
4485 static const struct message WmErase
[] = {
4486 { WM_ERASEBKGND
, sent
},
4490 static const struct message WmPaint
[] = {
4495 static const struct message WmParentOnlyPaint
[] = {
4496 { WM_PAINT
, sent
|parent
},
4500 static const struct message WmInvalidateParent
[] = {
4501 { WM_NCPAINT
, sent
|parent
},
4502 { WM_GETTEXT
, sent
|defwinproc
|parent
|optional
},
4503 { WM_ERASEBKGND
, sent
|parent
},
4507 static const struct message WmInvalidateParentChild
[] = {
4508 { WM_NCPAINT
, sent
|parent
},
4509 { WM_GETTEXT
, sent
|defwinproc
|parent
|optional
},
4510 { WM_ERASEBKGND
, sent
|parent
},
4511 { WM_NCPAINT
, sent
},
4512 { WM_GETTEXT
, sent
|defwinproc
|optional
},
4513 { WM_ERASEBKGND
, sent
},
4517 static const struct message WmInvalidateParentChild2
[] = {
4518 { WM_ERASEBKGND
, sent
|parent
},
4519 { WM_NCPAINT
, sent
},
4520 { WM_GETTEXT
, sent
|defwinproc
|optional
},
4521 { WM_ERASEBKGND
, sent
},
4525 static const struct message WmParentPaint
[] = {
4526 { WM_PAINT
, sent
|parent
},
4531 static const struct message WmParentPaintNc
[] = {
4532 { WM_PAINT
, sent
|parent
},
4534 { WM_NCPAINT
, sent
|beginpaint
},
4535 { WM_GETTEXT
, sent
|beginpaint
|defwinproc
|optional
},
4536 { WM_ERASEBKGND
, sent
|beginpaint
},
4540 static const struct message WmChildPaintNc
[] = {
4542 { WM_NCPAINT
, sent
|beginpaint
},
4543 { WM_GETTEXT
, sent
|beginpaint
|defwinproc
|optional
},
4544 { WM_ERASEBKGND
, sent
|beginpaint
},
4548 static const struct message WmParentErasePaint
[] = {
4549 { WM_PAINT
, sent
|parent
},
4550 { WM_NCPAINT
, sent
|parent
|beginpaint
},
4551 { WM_GETTEXT
, sent
|parent
|beginpaint
|defwinproc
|optional
},
4552 { WM_ERASEBKGND
, sent
|parent
|beginpaint
},
4554 { WM_NCPAINT
, sent
|beginpaint
},
4555 { WM_GETTEXT
, sent
|beginpaint
|defwinproc
|optional
},
4556 { WM_ERASEBKGND
, sent
|beginpaint
},
4560 static const struct message WmParentOnlyNcPaint
[] = {
4561 { WM_PAINT
, sent
|parent
},
4562 { WM_NCPAINT
, sent
|parent
|beginpaint
},
4563 { WM_GETTEXT
, sent
|parent
|beginpaint
|defwinproc
|optional
},
4567 static const struct message WmSetParentStyle
[] = {
4568 { WM_STYLECHANGING
, sent
|parent
},
4569 { WM_STYLECHANGED
, sent
|parent
},
4573 static void test_paint_messages(void)
4579 HWND hparent
, hchild
;
4580 HRGN hrgn
= CreateRectRgn( 0, 0, 0, 0 );
4581 HRGN hrgn2
= CreateRectRgn( 0, 0, 0, 0 );
4582 HWND hwnd
= CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW
,
4583 100, 100, 200, 200, 0, 0, 0, NULL
);
4584 ok (hwnd
!= 0, "Failed to create overlapped window\n");
4586 ShowWindow( hwnd
, SW_SHOW
);
4587 UpdateWindow( hwnd
);
4591 check_update_rgn( hwnd
, 0 );
4592 SetRectRgn( hrgn
, 10, 10, 20, 20 );
4593 ret
= RedrawWindow( hwnd
, NULL
, hrgn
, RDW_INVALIDATE
);
4594 ok(ret
, "RedrawWindow returned %d instead of TRUE\n", ret
);
4595 check_update_rgn( hwnd
, hrgn
);
4596 SetRectRgn( hrgn2
, 20, 20, 30, 30 );
4597 ret
= RedrawWindow( hwnd
, NULL
, hrgn2
, RDW_INVALIDATE
);
4598 ok(ret
, "RedrawWindow returned %d instead of TRUE\n", ret
);
4599 CombineRgn( hrgn
, hrgn
, hrgn2
, RGN_OR
);
4600 check_update_rgn( hwnd
, hrgn
);
4601 /* validate everything */
4602 ret
= RedrawWindow( hwnd
, NULL
, NULL
, RDW_VALIDATE
);
4603 ok(ret
, "RedrawWindow returned %d instead of TRUE\n", ret
);
4604 check_update_rgn( hwnd
, 0 );
4606 /* test empty region */
4607 SetRectRgn( hrgn
, 10, 10, 10, 15 );
4608 ret
= RedrawWindow( hwnd
, NULL
, hrgn
, RDW_INVALIDATE
);
4609 ok(ret
, "RedrawWindow returned %d instead of TRUE\n", ret
);
4610 check_update_rgn( hwnd
, 0 );
4611 /* test empty rect */
4612 SetRect( &rect
, 10, 10, 10, 15 );
4613 ret
= RedrawWindow( hwnd
, &rect
, NULL
, RDW_INVALIDATE
);
4614 ok(ret
, "RedrawWindow returned %d instead of TRUE\n", ret
);
4615 check_update_rgn( hwnd
, 0 );
4617 /* flush pending messages */
4618 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4621 GetClientRect( hwnd
, &rect
);
4622 SetRectRgn( hrgn
, 0, 0, rect
.right
- rect
.left
, rect
.bottom
- rect
.top
);
4623 /* MSDN: if hwnd parameter is NULL, InvalidateRect invalidates and redraws
4624 * all windows and sends WM_ERASEBKGND and WM_NCPAINT.
4626 trace("testing InvalidateRect(0, NULL, FALSE)\n");
4627 SetRectEmpty( &rect
);
4628 ok(InvalidateRect(0, &rect
, FALSE
), "InvalidateRect(0, &rc, FALSE) should fail\n");
4629 check_update_rgn( hwnd
, hrgn
);
4630 ok_sequence( WmInvalidateErase
, "InvalidateErase", FALSE
);
4631 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4632 ok_sequence( WmPaint
, "Paint", FALSE
);
4633 RedrawWindow( hwnd
, NULL
, NULL
, RDW_VALIDATE
);
4634 check_update_rgn( hwnd
, 0 );
4636 /* MSDN: if hwnd parameter is NULL, ValidateRect invalidates and redraws
4637 * all windows and sends WM_ERASEBKGND and WM_NCPAINT.
4639 trace("testing ValidateRect(0, NULL)\n");
4640 SetRectEmpty( &rect
);
4641 ok(ValidateRect(0, &rect
), "ValidateRect(0, &rc) should not fail\n");
4642 check_update_rgn( hwnd
, hrgn
);
4643 ok_sequence( WmInvalidateErase
, "InvalidateErase", FALSE
);
4644 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4645 ok_sequence( WmPaint
, "Paint", FALSE
);
4646 RedrawWindow( hwnd
, NULL
, NULL
, RDW_VALIDATE
);
4647 check_update_rgn( hwnd
, 0 );
4649 trace("testing InvalidateRgn(0, NULL, FALSE)\n");
4650 SetLastError(0xdeadbeef);
4651 ok(!InvalidateRgn(0, NULL
, FALSE
), "InvalidateRgn(0, NULL, FALSE) should fail\n");
4652 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE
, "wrong error code %d\n", GetLastError());
4653 check_update_rgn( hwnd
, 0 );
4654 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4655 ok_sequence( WmEmptySeq
, "WmEmptySeq", FALSE
);
4657 trace("testing ValidateRgn(0, NULL)\n");
4658 SetLastError(0xdeadbeef);
4659 ok(!ValidateRgn(0, NULL
), "ValidateRgn(0, NULL) should fail\n");
4660 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE
, "wrong error code %d\n", GetLastError());
4661 check_update_rgn( hwnd
, 0 );
4662 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4663 ok_sequence( WmEmptySeq
, "WmEmptySeq", FALSE
);
4665 /* now with frame */
4666 SetRectRgn( hrgn
, -5, -5, 20, 20 );
4668 /* flush pending messages */
4669 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4672 RedrawWindow( hwnd
, NULL
, hrgn
, RDW_INVALIDATE
| RDW_FRAME
);
4673 ok_sequence( WmEmptySeq
, "EmptySeq", FALSE
);
4675 SetRectRgn( hrgn
, 0, 0, 20, 20 ); /* GetUpdateRgn clips to client area */
4676 check_update_rgn( hwnd
, hrgn
);
4679 RedrawWindow( hwnd
, NULL
, hrgn
, RDW_INVALIDATE
| RDW_FRAME
| RDW_ERASENOW
);
4680 ok_sequence( WmInvalidateRgn
, "InvalidateRgn", FALSE
);
4683 RedrawWindow( hwnd
, NULL
, NULL
, RDW_INVALIDATE
| RDW_FRAME
| RDW_ERASENOW
);
4684 ok_sequence( WmInvalidateFull
, "InvalidateFull", FALSE
);
4686 GetClientRect( hwnd
, &rect
);
4687 SetRectRgn( hrgn
, rect
.left
, rect
.top
, rect
.right
, rect
.bottom
);
4688 check_update_rgn( hwnd
, hrgn
);
4691 RedrawWindow( hwnd
, NULL
, NULL
, RDW_INVALIDATE
| RDW_FRAME
| RDW_ERASE
| RDW_ERASENOW
);
4692 ok_sequence( WmInvalidateErase
, "InvalidateErase", FALSE
);
4695 RedrawWindow( hwnd
, NULL
, NULL
, RDW_INVALIDATE
| RDW_FRAME
| RDW_ERASENOW
| RDW_UPDATENOW
);
4696 ok_sequence( WmInvalidatePaint
, "InvalidatePaint", FALSE
);
4697 check_update_rgn( hwnd
, 0 );
4700 RedrawWindow( hwnd
, NULL
, NULL
, RDW_INVALIDATE
| RDW_FRAME
| RDW_ERASE
| RDW_UPDATENOW
);
4701 ok_sequence( WmInvalidateErasePaint
, "InvalidateErasePaint", FALSE
);
4702 check_update_rgn( hwnd
, 0 );
4705 SetRectRgn( hrgn
, 0, 0, 100, 100 );
4706 RedrawWindow( hwnd
, NULL
, hrgn
, RDW_INVALIDATE
);
4707 SetRectRgn( hrgn
, 0, 0, 50, 100 );
4708 RedrawWindow( hwnd
, NULL
, hrgn
, RDW_VALIDATE
);
4709 SetRectRgn( hrgn
, 50, 0, 100, 100 );
4710 check_update_rgn( hwnd
, hrgn
);
4711 RedrawWindow( hwnd
, NULL
, hrgn
, RDW_VALIDATE
| RDW_ERASENOW
);
4712 ok_sequence( WmEmptySeq
, "EmptySeq", FALSE
); /* must not generate messages, everything is valid */
4713 check_update_rgn( hwnd
, 0 );
4716 SetRectRgn( hrgn
, 0, 0, 100, 100 );
4717 RedrawWindow( hwnd
, NULL
, hrgn
, RDW_INVALIDATE
| RDW_ERASE
);
4718 SetRectRgn( hrgn
, 0, 0, 100, 50 );
4719 RedrawWindow( hwnd
, NULL
, hrgn
, RDW_VALIDATE
| RDW_ERASENOW
);
4720 ok_sequence( WmErase
, "Erase", FALSE
);
4721 SetRectRgn( hrgn
, 0, 50, 100, 100 );
4722 check_update_rgn( hwnd
, hrgn
);
4725 SetRectRgn( hrgn
, 0, 0, 100, 100 );
4726 RedrawWindow( hwnd
, NULL
, hrgn
, RDW_INVALIDATE
| RDW_ERASE
);
4727 SetRectRgn( hrgn
, 0, 0, 50, 50 );
4728 RedrawWindow( hwnd
, NULL
, hrgn
, RDW_VALIDATE
| RDW_NOERASE
| RDW_UPDATENOW
);
4729 ok_sequence( WmPaint
, "Paint", FALSE
);
4732 SetRectRgn( hrgn
, -4, -4, -2, -2 );
4733 RedrawWindow( hwnd
, NULL
, hrgn
, RDW_INVALIDATE
| RDW_FRAME
);
4734 SetRectRgn( hrgn
, -200, -200, -198, -198 );
4735 RedrawWindow( hwnd
, NULL
, hrgn
, RDW_VALIDATE
| RDW_NOFRAME
| RDW_ERASENOW
);
4736 ok_sequence( WmEmptySeq
, "EmptySeq", FALSE
);
4739 SetRectRgn( hrgn
, -4, -4, -2, -2 );
4740 RedrawWindow( hwnd
, NULL
, hrgn
, RDW_INVALIDATE
| RDW_FRAME
);
4741 SetRectRgn( hrgn
, -4, -4, -3, -3 );
4742 RedrawWindow( hwnd
, NULL
, hrgn
, RDW_VALIDATE
| RDW_NOFRAME
);
4743 SetRectRgn( hrgn
, 0, 0, 1, 1 );
4744 RedrawWindow( hwnd
, NULL
, hrgn
, RDW_INVALIDATE
| RDW_UPDATENOW
);
4745 ok_sequence( WmPaint
, "Paint", FALSE
);
4748 SetRectRgn( hrgn
, -4, -4, -1, -1 );
4749 RedrawWindow( hwnd
, NULL
, hrgn
, RDW_INVALIDATE
| RDW_FRAME
);
4750 RedrawWindow( hwnd
, NULL
, 0, RDW_ERASENOW
);
4751 /* make sure no WM_PAINT was generated */
4752 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4753 ok_sequence( WmInvalidateRgn
, "InvalidateRgn", FALSE
);
4756 SetRectRgn( hrgn
, -4, -4, -1, -1 );
4757 RedrawWindow( hwnd
, NULL
, hrgn
, RDW_INVALIDATE
| RDW_FRAME
);
4758 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
))
4760 if (msg
.hwnd
== hwnd
&& msg
.message
== WM_PAINT
)
4762 /* GetUpdateRgn must return empty region since only nonclient area is invalidated */
4763 INT ret
= GetUpdateRgn( hwnd
, hrgn
, FALSE
);
4764 ok( ret
== NULLREGION
, "Invalid GetUpdateRgn result %d\n", ret
);
4765 ret
= GetUpdateRect( hwnd
, &rect
, FALSE
);
4766 ok( ret
, "Invalid GetUpdateRect result %d\n", ret
);
4767 /* this will send WM_NCPAINT and validate the non client area */
4768 ret
= GetUpdateRect( hwnd
, &rect
, TRUE
);
4769 ok( !ret
, "Invalid GetUpdateRect result %d\n", ret
);
4771 DispatchMessage( &msg
);
4773 ok_sequence( WmGetUpdateRect
, "GetUpdateRect", FALSE
);
4775 DestroyWindow( hwnd
);
4777 /* now test with a child window */
4779 hparent
= CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW
,
4780 100, 100, 200, 200, 0, 0, 0, NULL
);
4781 ok (hparent
!= 0, "Failed to create parent window\n");
4783 hchild
= CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD
| WS_VISIBLE
| WS_BORDER
,
4784 10, 10, 100, 100, hparent
, 0, 0, NULL
);
4785 ok (hchild
!= 0, "Failed to create child window\n");
4787 ShowWindow( hparent
, SW_SHOW
);
4788 UpdateWindow( hparent
);
4789 UpdateWindow( hchild
);
4792 log_all_parent_messages
++;
4794 SetRect( &rect
, 0, 0, 50, 50 );
4795 RedrawWindow( hparent
, &rect
, 0, RDW_INVALIDATE
| RDW_ERASE
| RDW_FRAME
);
4796 RedrawWindow( hparent
, NULL
, 0, RDW_ERASENOW
| RDW_ALLCHILDREN
);
4797 ok_sequence( WmInvalidateParentChild
, "InvalidateParentChild", FALSE
);
4799 RedrawWindow( hparent
, &rect
, 0, RDW_INVALIDATE
| RDW_ERASE
| RDW_FRAME
);
4801 MapWindowPoints( hchild
, hparent
, &pt
, 1 );
4802 SetRectRgn( hrgn
, 0, 0, 50 - pt
.x
, 50 - pt
.y
);
4803 check_update_rgn( hchild
, hrgn
);
4804 SetRectRgn( hrgn
, 0, 0, 50, 50 );
4805 check_update_rgn( hparent
, hrgn
);
4806 RedrawWindow( hparent
, NULL
, 0, RDW_ERASENOW
);
4807 ok_sequence( WmInvalidateParent
, "InvalidateParent", FALSE
);
4808 RedrawWindow( hchild
, NULL
, 0, RDW_ERASENOW
);
4809 ok_sequence( WmEmptySeq
, "EraseNow child", FALSE
);
4811 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4812 ok_sequence( WmParentPaintNc
, "WmParentPaintNc", FALSE
);
4814 RedrawWindow( hparent
, &rect
, 0, RDW_INVALIDATE
| RDW_ERASE
| RDW_FRAME
| RDW_ALLCHILDREN
);
4815 RedrawWindow( hparent
, NULL
, 0, RDW_ERASENOW
);
4816 ok_sequence( WmInvalidateParent
, "InvalidateParent2", FALSE
);
4817 RedrawWindow( hchild
, NULL
, 0, RDW_ERASENOW
);
4818 ok_sequence( WmEmptySeq
, "EraseNow child", FALSE
);
4820 RedrawWindow( hparent
, &rect
, 0, RDW_INVALIDATE
| RDW_ERASE
);
4821 RedrawWindow( hparent
, NULL
, 0, RDW_ERASENOW
| RDW_ALLCHILDREN
);
4822 ok_sequence( WmInvalidateParentChild2
, "InvalidateParentChild2", FALSE
);
4824 SetWindowLong( hparent
, GWL_STYLE
, GetWindowLong(hparent
,GWL_STYLE
) | WS_CLIPCHILDREN
);
4826 RedrawWindow( hparent
, &rect
, 0, RDW_INVALIDATE
| RDW_ERASE
| RDW_FRAME
| RDW_ALLCHILDREN
);
4827 RedrawWindow( hparent
, NULL
, 0, RDW_ERASENOW
);
4828 ok_sequence( WmInvalidateParentChild
, "InvalidateParentChild3", FALSE
);
4830 /* flush all paint messages */
4831 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4834 /* RDW_UPDATENOW on child with WS_CLIPCHILDREN doesn't change corresponding parent area */
4835 RedrawWindow( hparent
, &rect
, 0, RDW_INVALIDATE
| RDW_ERASE
| RDW_FRAME
| RDW_ALLCHILDREN
);
4836 SetRectRgn( hrgn
, 0, 0, 50, 50 );
4837 check_update_rgn( hparent
, hrgn
);
4838 RedrawWindow( hchild
, NULL
, 0, RDW_UPDATENOW
);
4839 ok_sequence( WmInvalidateErasePaint2
, "WmInvalidateErasePaint2", FALSE
);
4840 SetRectRgn( hrgn
, 0, 0, 50, 50 );
4841 check_update_rgn( hparent
, hrgn
);
4843 /* flush all paint messages */
4844 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4845 SetWindowLong( hparent
, GWL_STYLE
, GetWindowLong(hparent
,GWL_STYLE
) & ~WS_CLIPCHILDREN
);
4848 /* RDW_UPDATENOW on child without WS_CLIPCHILDREN will validate corresponding parent area */
4849 RedrawWindow( hparent
, &rect
, 0, RDW_INVALIDATE
| RDW_ERASE
| RDW_FRAME
);
4850 SetRectRgn( hrgn
, 0, 0, 50, 50 );
4851 check_update_rgn( hparent
, hrgn
);
4852 RedrawWindow( hchild
, NULL
, 0, RDW_UPDATENOW
);
4853 ok_sequence( WmInvalidateErasePaint2
, "WmInvalidateErasePaint2", FALSE
);
4854 SetRectRgn( hrgn2
, 10, 10, 50, 50 );
4855 CombineRgn( hrgn
, hrgn
, hrgn2
, RGN_DIFF
);
4856 check_update_rgn( hparent
, hrgn
);
4857 /* flush all paint messages */
4858 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4861 /* same as above but parent gets completely validated */
4862 SetRect( &rect
, 20, 20, 30, 30 );
4863 RedrawWindow( hparent
, &rect
, 0, RDW_INVALIDATE
| RDW_ERASE
| RDW_FRAME
);
4864 SetRectRgn( hrgn
, 20, 20, 30, 30 );
4865 check_update_rgn( hparent
, hrgn
);
4866 RedrawWindow( hchild
, NULL
, 0, RDW_UPDATENOW
);
4867 ok_sequence( WmInvalidateErasePaint2
, "WmInvalidateErasePaint2", FALSE
);
4868 check_update_rgn( hparent
, 0 ); /* no update region */
4869 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4870 ok_sequence( WmEmptySeq
, "WmEmpty", FALSE
); /* and no paint messages */
4872 /* make sure RDW_VALIDATE on child doesn't have the same effect */
4874 RedrawWindow( hparent
, &rect
, 0, RDW_INVALIDATE
| RDW_ERASE
| RDW_FRAME
);
4875 SetRectRgn( hrgn
, 20, 20, 30, 30 );
4876 check_update_rgn( hparent
, hrgn
);
4877 RedrawWindow( hchild
, NULL
, 0, RDW_VALIDATE
| RDW_NOERASE
);
4878 SetRectRgn( hrgn
, 20, 20, 30, 30 );
4879 check_update_rgn( hparent
, hrgn
);
4881 /* same as above but normal WM_PAINT doesn't validate parent */
4883 SetRect( &rect
, 20, 20, 30, 30 );
4884 RedrawWindow( hparent
, &rect
, 0, RDW_INVALIDATE
| RDW_ERASE
| RDW_FRAME
);
4885 SetRectRgn( hrgn
, 20, 20, 30, 30 );
4886 check_update_rgn( hparent
, hrgn
);
4887 /* no WM_PAINT in child while parent still pending */
4888 while (PeekMessage( &msg
, hchild
, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4889 ok_sequence( WmEmptySeq
, "No WM_PAINT", FALSE
);
4890 while (PeekMessage( &msg
, hparent
, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4891 ok_sequence( WmParentErasePaint
, "WmParentErasePaint", FALSE
);
4894 RedrawWindow( hparent
, &rect
, 0, RDW_INVALIDATE
| RDW_ERASE
| RDW_FRAME
);
4895 /* no WM_PAINT in child while parent still pending */
4896 while (PeekMessage( &msg
, hchild
, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4897 ok_sequence( WmEmptySeq
, "No WM_PAINT", FALSE
);
4898 RedrawWindow( hparent
, &rect
, 0, RDW_VALIDATE
| RDW_NOERASE
| RDW_NOCHILDREN
);
4899 /* now that parent is valid child should get WM_PAINT */
4900 while (PeekMessage( &msg
, hchild
, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4901 ok_sequence( WmInvalidateErasePaint2
, "WmInvalidateErasePaint2", FALSE
);
4902 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4903 ok_sequence( WmEmptySeq
, "No other message", FALSE
);
4905 /* same thing with WS_CLIPCHILDREN in parent */
4907 SetWindowLong( hparent
, GWL_STYLE
, GetWindowLong(hparent
,GWL_STYLE
) | WS_CLIPCHILDREN
);
4908 ok_sequence( WmSetParentStyle
, "WmSetParentStyle", FALSE
);
4909 /* changing style invalidates non client area, but we need to invalidate something else to see it */
4910 RedrawWindow( hparent
, &rect
, 0, RDW_UPDATENOW
);
4911 ok_sequence( WmEmptySeq
, "No message", FALSE
);
4912 RedrawWindow( hparent
, &rect
, 0, RDW_INVALIDATE
| RDW_UPDATENOW
);
4913 ok_sequence( WmParentOnlyNcPaint
, "WmParentOnlyNcPaint", FALSE
);
4916 RedrawWindow( hparent
, &rect
, 0, RDW_INVALIDATE
| RDW_ERASE
| RDW_ALLCHILDREN
);
4917 SetRectRgn( hrgn
, 20, 20, 30, 30 );
4918 check_update_rgn( hparent
, hrgn
);
4919 /* no WM_PAINT in child while parent still pending */
4920 while (PeekMessage( &msg
, hchild
, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4921 ok_sequence( WmEmptySeq
, "No WM_PAINT", FALSE
);
4922 /* WM_PAINT in parent first */
4923 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4924 ok_sequence( WmParentPaintNc
, "WmParentPaintNc2", FALSE
);
4926 /* no RDW_ERASE in parent still causes RDW_ERASE and RDW_FRAME in child */
4928 SetRect( &rect
, 0, 0, 30, 30 );
4929 RedrawWindow( hparent
, &rect
, 0, RDW_INVALIDATE
| RDW_ALLCHILDREN
);
4930 SetRectRgn( hrgn
, 0, 0, 30, 30 );
4931 check_update_rgn( hparent
, hrgn
);
4932 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4933 ok_sequence( WmParentPaintNc
, "WmParentPaintNc3", FALSE
);
4935 /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
4937 SetRect( &rect
, -10, 0, 30, 30 );
4938 RedrawWindow( hchild
, &rect
, 0, RDW_INVALIDATE
| RDW_FRAME
| RDW_ERASE
);
4939 SetRect( &rect
, 0, 0, 20, 20 );
4940 RedrawWindow( hparent
, &rect
, 0, RDW_VALIDATE
| RDW_ALLCHILDREN
);
4941 RedrawWindow( hparent
, NULL
, 0, RDW_UPDATENOW
);
4942 ok_sequence( WmChildPaintNc
, "WmChildPaintNc", FALSE
);
4944 /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
4946 SetRect( &rect
, -10, 0, 30, 30 );
4947 RedrawWindow( hchild
, &rect
, 0, RDW_INVALIDATE
| RDW_FRAME
| RDW_ERASE
);
4948 SetRect( &rect
, 0, 0, 100, 100 );
4949 RedrawWindow( hparent
, &rect
, 0, RDW_VALIDATE
| RDW_ALLCHILDREN
);
4950 RedrawWindow( hparent
, NULL
, 0, RDW_UPDATENOW
);
4951 ok_sequence( WmEmptySeq
, "WmChildPaintNc2", FALSE
);
4952 RedrawWindow( hparent
, NULL
, 0, RDW_ERASENOW
);
4953 ok_sequence( WmEmptySeq
, "WmChildPaintNc3", FALSE
);
4955 /* test RDW_INTERNALPAINT behavior */
4958 RedrawWindow( hparent
, NULL
, 0, RDW_INTERNALPAINT
| RDW_NOCHILDREN
);
4959 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4960 ok_sequence( WmParentOnlyPaint
, "WmParentOnlyPaint", FALSE
);
4962 RedrawWindow( hparent
, NULL
, 0, RDW_INTERNALPAINT
| RDW_ALLCHILDREN
);
4963 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4964 ok_sequence( WmParentPaint
, "WmParentPaint", FALSE
);
4966 RedrawWindow( hparent
, NULL
, 0, RDW_INTERNALPAINT
);
4967 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4968 ok_sequence( WmParentOnlyPaint
, "WmParentOnlyPaint", FALSE
);
4970 assert( GetWindowLong(hparent
, GWL_STYLE
) & WS_CLIPCHILDREN
);
4971 UpdateWindow( hparent
);
4972 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4974 trace("testing SWP_FRAMECHANGED on parent with WS_CLIPCHILDREN\n");
4975 RedrawWindow( hchild
, NULL
, 0, RDW_INVALIDATE
| RDW_ERASE
| RDW_FRAME
);
4976 SetWindowPos( hparent
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
|
4977 SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
4978 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4979 ok_sequence(WmSWP_FrameChanged_clip
, "SetWindowPos:FrameChanged_clip", FALSE
);
4981 UpdateWindow( hparent
);
4982 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4984 trace("testing SWP_FRAMECHANGED|SWP_DEFERERASE on parent with WS_CLIPCHILDREN\n");
4985 RedrawWindow( hchild
, NULL
, 0, RDW_INVALIDATE
| RDW_ERASE
| RDW_FRAME
);
4986 SetWindowPos( hparent
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
| SWP_DEFERERASE
|
4987 SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
4988 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4989 ok_sequence(WmSWP_FrameChangedDeferErase
, "SetWindowPos:FrameChangedDeferErase", FALSE
);
4991 SetWindowLong( hparent
, GWL_STYLE
, GetWindowLong(hparent
,GWL_STYLE
) & ~WS_CLIPCHILDREN
);
4992 ok_sequence( WmSetParentStyle
, "WmSetParentStyle", FALSE
);
4993 RedrawWindow( hparent
, NULL
, 0, RDW_INTERNALPAINT
);
4994 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
4995 ok_sequence( WmParentPaint
, "WmParentPaint", FALSE
);
4997 assert( !(GetWindowLong(hparent
, GWL_STYLE
) & WS_CLIPCHILDREN
) );
4998 UpdateWindow( hparent
);
4999 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
5001 trace("testing SWP_FRAMECHANGED on parent without WS_CLIPCHILDREN\n");
5002 RedrawWindow( hchild
, NULL
, 0, RDW_INVALIDATE
| RDW_ERASE
| RDW_FRAME
);
5003 SetWindowPos( hparent
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
|
5004 SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
5005 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
5006 ok_sequence(WmSWP_FrameChanged_noclip
, "SetWindowPos:FrameChanged_noclip", FALSE
);
5008 UpdateWindow( hparent
);
5009 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
5011 trace("testing SWP_FRAMECHANGED|SWP_DEFERERASE on parent without WS_CLIPCHILDREN\n");
5012 RedrawWindow( hchild
, NULL
, 0, RDW_INVALIDATE
| RDW_ERASE
| RDW_FRAME
);
5013 SetWindowPos( hparent
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
| SWP_DEFERERASE
|
5014 SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
5015 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
5016 ok_sequence(WmSWP_FrameChangedDeferErase
, "SetWindowPos:FrameChangedDeferErase", FALSE
);
5018 log_all_parent_messages
--;
5019 DestroyWindow( hparent
);
5020 ok(!IsWindow(hchild
), "child must be destroyed with its parent\n");
5022 DeleteObject( hrgn
);
5023 DeleteObject( hrgn2
);
5032 static DWORD WINAPI
thread_proc(void *param
)
5035 struct wnd_event
*wnd_event
= (struct wnd_event
*)param
;
5037 wnd_event
->hwnd
= CreateWindowExA(0, "TestWindowClass", "window caption text", WS_OVERLAPPEDWINDOW
,
5038 100, 100, 200, 200, 0, 0, 0, NULL
);
5039 ok(wnd_event
->hwnd
!= 0, "Failed to create overlapped window\n");
5041 SetEvent(wnd_event
->event
);
5043 while (GetMessage(&msg
, 0, 0, 0))
5045 TranslateMessage(&msg
);
5046 DispatchMessage(&msg
);
5049 ok(IsWindow(wnd_event
->hwnd
), "window should still exist\n");
5054 static void test_interthread_messages(void)
5061 int len
, expected_len
;
5062 struct wnd_event wnd_event
;
5065 wnd_event
.event
= CreateEventW(NULL
, 0, 0, NULL
);
5066 if (!wnd_event
.event
)
5068 trace("skipping interthread message test under win9x\n");
5072 hThread
= CreateThread(NULL
, 0, thread_proc
, &wnd_event
, 0, &tid
);
5073 ok(hThread
!= NULL
, "CreateThread failed, error %d\n", GetLastError());
5075 ok(WaitForSingleObject(wnd_event
.event
, INFINITE
) == WAIT_OBJECT_0
, "WaitForSingleObject failed\n");
5077 CloseHandle(wnd_event
.event
);
5079 SetLastError(0xdeadbeef);
5080 ok(!DestroyWindow(wnd_event
.hwnd
), "DestroyWindow succeded\n");
5081 ok(GetLastError() == ERROR_ACCESS_DENIED
, "wrong error code %d\n", GetLastError());
5083 proc
= (WNDPROC
)GetWindowLongPtrA(wnd_event
.hwnd
, GWLP_WNDPROC
);
5084 ok(proc
!= NULL
, "GetWindowLongPtrA(GWLP_WNDPROC) error %d\n", GetLastError());
5086 expected_len
= lstrlenA("window caption text");
5087 memset(buf
, 0, sizeof(buf
));
5088 SetLastError(0xdeadbeef);
5089 len
= CallWindowProcA(proc
, wnd_event
.hwnd
, WM_GETTEXT
, sizeof(buf
), (LPARAM
)buf
);
5090 ok(len
== expected_len
, "CallWindowProcA(WM_GETTEXT) error %d, len %d, expected len %d\n", GetLastError(), len
, expected_len
);
5091 ok(!lstrcmpA(buf
, "window caption text"), "window text mismatch\n");
5093 msg
.hwnd
= wnd_event
.hwnd
;
5094 msg
.message
= WM_GETTEXT
;
5095 msg
.wParam
= sizeof(buf
);
5096 msg
.lParam
= (LPARAM
)buf
;
5097 memset(buf
, 0, sizeof(buf
));
5098 SetLastError(0xdeadbeef);
5099 len
= DispatchMessageA(&msg
);
5100 ok(!len
&& GetLastError() == ERROR_MESSAGE_SYNC_ONLY
,
5101 "DispatchMessageA(WM_GETTEXT) succeded on another thread window: ret %d, error %d\n", len
, GetLastError());
5103 /* the following test causes an exception in user.exe under win9x */
5104 msg
.hwnd
= wnd_event
.hwnd
;
5105 msg
.message
= WM_TIMER
;
5107 msg
.lParam
= GetWindowLongPtrA(wnd_event
.hwnd
, GWLP_WNDPROC
);
5108 SetLastError(0xdeadbeef);
5109 len
= DispatchMessageA(&msg
);
5110 ok(!len
&& GetLastError() == 0xdeadbeef,
5111 "DispatchMessageA(WM_TIMER) failed on another thread window: ret %d, error %d\n", len
, GetLastError());
5113 ret
= PostMessageA(wnd_event
.hwnd
, WM_QUIT
, 0, 0);
5114 ok( ret
, "PostMessageA(WM_QUIT) error %d\n", GetLastError());
5116 ok(WaitForSingleObject(hThread
, INFINITE
) == WAIT_OBJECT_0
, "WaitForSingleObject failed\n");
5117 CloseHandle(hThread
);
5119 ok(!IsWindow(wnd_event
.hwnd
), "window should be destroyed on thread exit\n");
5123 static const struct message WmVkN
[] = {
5124 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 1 }, /* XP */
5125 { WM_KEYDOWN
, wparam
|lparam
, 'N', 1 },
5126 { WM_KEYDOWN
, sent
|wparam
|lparam
, 'N', 1 },
5127 { WM_CHAR
, wparam
|lparam
, 'n', 1 },
5128 { WM_COMMAND
, sent
|wparam
|lparam
, MAKEWPARAM(1002,1), 0 },
5129 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 0xc0000001 }, /* XP */
5130 { WM_KEYUP
, wparam
|lparam
, 'N', 0xc0000001 },
5131 { WM_KEYUP
, sent
|wparam
|lparam
, 'N', 0xc0000001 },
5134 static const struct message WmShiftVkN
[] = {
5135 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_SHIFT
, 1 }, /* XP */
5136 { WM_KEYDOWN
, wparam
|lparam
, VK_SHIFT
, 1 },
5137 { WM_KEYDOWN
, sent
|wparam
|lparam
, VK_SHIFT
, 1 },
5138 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 1 }, /* XP */
5139 { WM_KEYDOWN
, wparam
|lparam
, 'N', 1 },
5140 { WM_KEYDOWN
, sent
|wparam
|lparam
, 'N', 1 },
5141 { WM_CHAR
, wparam
|lparam
, 'N', 1 },
5142 { WM_COMMAND
, sent
|wparam
|lparam
, MAKEWPARAM(1001,1), 0 },
5143 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 0xc0000001 }, /* XP */
5144 { WM_KEYUP
, wparam
|lparam
, 'N', 0xc0000001 },
5145 { WM_KEYUP
, sent
|wparam
|lparam
, 'N', 0xc0000001 },
5146 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_SHIFT
, 0xc0000001 }, /* XP */
5147 { WM_KEYUP
, wparam
|lparam
, VK_SHIFT
, 0xc0000001 },
5148 { WM_KEYUP
, sent
|wparam
|lparam
, VK_SHIFT
, 0xc0000001 },
5151 static const struct message WmCtrlVkN
[] = {
5152 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_CONTROL
, 1 }, /* XP */
5153 { WM_KEYDOWN
, wparam
|lparam
, VK_CONTROL
, 1 },
5154 { WM_KEYDOWN
, sent
|wparam
|lparam
, VK_CONTROL
, 1 },
5155 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 1 }, /* XP */
5156 { WM_KEYDOWN
, wparam
|lparam
, 'N', 1 },
5157 { WM_KEYDOWN
, sent
|wparam
|lparam
, 'N', 1 },
5158 { WM_CHAR
, wparam
|lparam
, 0x000e, 1 },
5159 { WM_COMMAND
, sent
|wparam
|lparam
, MAKEWPARAM(1000,1), 0 },
5160 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 0xc0000001 }, /* XP */
5161 { WM_KEYUP
, wparam
|lparam
, 'N', 0xc0000001 },
5162 { WM_KEYUP
, sent
|wparam
|lparam
, 'N', 0xc0000001 },
5163 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_CONTROL
, 0xc0000001 }, /* XP */
5164 { WM_KEYUP
, wparam
|lparam
, VK_CONTROL
, 0xc0000001 },
5165 { WM_KEYUP
, sent
|wparam
|lparam
, VK_CONTROL
, 0xc0000001 },
5168 static const struct message WmCtrlVkN_2
[] = {
5169 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_CONTROL
, 1 }, /* XP */
5170 { WM_KEYDOWN
, wparam
|lparam
, VK_CONTROL
, 1 },
5171 { WM_KEYDOWN
, sent
|wparam
|lparam
, VK_CONTROL
, 1 },
5172 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 1 }, /* XP */
5173 { WM_KEYDOWN
, wparam
|lparam
, 'N', 1 },
5174 { WM_COMMAND
, sent
|wparam
|lparam
, MAKEWPARAM(1000,1), 0 },
5175 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 0xc0000001 }, /* XP */
5176 { WM_KEYUP
, wparam
|lparam
, 'N', 0xc0000001 },
5177 { WM_KEYUP
, sent
|wparam
|lparam
, 'N', 0xc0000001 },
5178 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_CONTROL
, 0xc0000001 }, /* XP */
5179 { WM_KEYUP
, wparam
|lparam
, VK_CONTROL
, 0xc0000001 },
5180 { WM_KEYUP
, sent
|wparam
|lparam
, VK_CONTROL
, 0xc0000001 },
5183 static const struct message WmAltVkN
[] = {
5184 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_MENU
, 0x20000001 }, /* XP */
5185 { WM_SYSKEYDOWN
, wparam
|lparam
, VK_MENU
, 0x20000001 },
5186 { WM_SYSKEYDOWN
, sent
|wparam
|lparam
, VK_MENU
, 0x20000001 },
5187 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 0x20000001 }, /* XP */
5188 { WM_SYSKEYDOWN
, wparam
|lparam
, 'N', 0x20000001 },
5189 { WM_SYSKEYDOWN
, sent
|wparam
|lparam
, 'N', 0x20000001 },
5190 { WM_SYSCHAR
, wparam
|lparam
, 'n', 0x20000001 },
5191 { WM_SYSCHAR
, sent
|wparam
|lparam
, 'n', 0x20000001 },
5192 { WM_SYSCOMMAND
, sent
|defwinproc
|wparam
|lparam
, SC_KEYMENU
, 'n' },
5193 { HCBT_SYSCOMMAND
, hook
},
5194 { WM_ENTERMENULOOP
, sent
|defwinproc
|wparam
|lparam
, 0, 0 },
5195 { EVENT_SYSTEM_CAPTURESTART
, winevent_hook
|wparam
|lparam
, 0, 0 },
5196 { 0x00AE, sent
|defwinproc
|optional
}, /* XP */
5197 { WM_GETTEXT
, sent
|defwinproc
|optional
}, /* XP */
5198 { WM_INITMENU
, sent
|defwinproc
},
5199 { EVENT_SYSTEM_MENUSTART
, winevent_hook
|wparam
|lparam
, OBJID_SYSMENU
, 0 },
5200 { WM_MENUCHAR
, sent
|defwinproc
|wparam
, MAKEWPARAM('n',MF_SYSMENU
) },
5201 { EVENT_SYSTEM_CAPTUREEND
, winevent_hook
|wparam
|lparam
, 0, 0 },
5202 { WM_CAPTURECHANGED
, sent
|defwinproc
},
5203 { WM_MENUSELECT
, sent
|defwinproc
|wparam
, MAKEWPARAM(0,0xffff) },
5204 { EVENT_SYSTEM_MENUEND
, winevent_hook
|wparam
|lparam
, OBJID_SYSMENU
, 0 },
5205 { WM_EXITMENULOOP
, sent
|defwinproc
},
5206 { WM_MENUSELECT
, sent
|defwinproc
|wparam
|optional
, MAKEWPARAM(0,0xffff) }, /* Win95 bug */
5207 { WM_EXITMENULOOP
, sent
|defwinproc
|optional
}, /* Win95 bug */
5208 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 0xe0000001 }, /* XP */
5209 { WM_SYSKEYUP
, wparam
|lparam
, 'N', 0xe0000001 },
5210 { WM_SYSKEYUP
, sent
|wparam
|lparam
, 'N', 0xe0000001 },
5211 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_MENU
, 0xc0000001 }, /* XP */
5212 { WM_KEYUP
, wparam
|lparam
, VK_MENU
, 0xc0000001 },
5213 { WM_KEYUP
, sent
|wparam
|lparam
, VK_MENU
, 0xc0000001 },
5216 static const struct message WmAltVkN_2
[] = {
5217 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_MENU
, 0x20000001 }, /* XP */
5218 { WM_SYSKEYDOWN
, wparam
|lparam
, VK_MENU
, 0x20000001 },
5219 { WM_SYSKEYDOWN
, sent
|wparam
|lparam
, VK_MENU
, 0x20000001 },
5220 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 0x20000001 }, /* XP */
5221 { WM_SYSKEYDOWN
, wparam
|lparam
, 'N', 0x20000001 },
5222 { WM_COMMAND
, sent
|wparam
|lparam
, MAKEWPARAM(1003,1), 0 },
5223 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 0xe0000001 }, /* XP */
5224 { WM_SYSKEYUP
, wparam
|lparam
, 'N', 0xe0000001 },
5225 { WM_SYSKEYUP
, sent
|wparam
|lparam
, 'N', 0xe0000001 },
5226 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_MENU
, 0xc0000001 }, /* XP */
5227 { WM_KEYUP
, wparam
|lparam
, VK_MENU
, 0xc0000001 },
5228 { WM_KEYUP
, sent
|wparam
|lparam
, VK_MENU
, 0xc0000001 },
5231 static const struct message WmCtrlAltVkN
[] = {
5232 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_CONTROL
, 1 }, /* XP */
5233 { WM_KEYDOWN
, wparam
|lparam
, VK_CONTROL
, 1 },
5234 { WM_KEYDOWN
, sent
|wparam
|lparam
, VK_CONTROL
, 1 },
5235 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_MENU
, 0x20000001 }, /* XP */
5236 { WM_KEYDOWN
, wparam
|lparam
, VK_MENU
, 0x20000001 },
5237 { WM_KEYDOWN
, sent
|wparam
|lparam
, VK_MENU
, 0x20000001 },
5238 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 0x20000001 }, /* XP */
5239 { WM_KEYDOWN
, wparam
|lparam
, 'N', 0x20000001 },
5240 { WM_KEYDOWN
, sent
|wparam
|lparam
, 'N', 0x20000001 },
5241 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 0xe0000001 }, /* XP */
5242 { WM_KEYUP
, wparam
|lparam
, 'N', 0xe0000001 },
5243 { WM_KEYUP
, sent
|wparam
|lparam
, 'N', 0xe0000001 },
5244 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_MENU
, 0xc0000001 }, /* XP */
5245 { WM_KEYUP
, wparam
|lparam
, VK_MENU
, 0xc0000001 },
5246 { WM_KEYUP
, sent
|wparam
|lparam
, VK_MENU
, 0xc0000001 },
5247 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_CONTROL
, 0xc0000001 }, /* XP */
5248 { WM_KEYUP
, wparam
|lparam
, VK_CONTROL
, 0xc0000001 },
5249 { WM_KEYUP
, sent
|wparam
|lparam
, VK_CONTROL
, 0xc0000001 },
5252 static const struct message WmCtrlShiftVkN
[] = {
5253 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_CONTROL
, 1 }, /* XP */
5254 { WM_KEYDOWN
, wparam
|lparam
, VK_CONTROL
, 1 },
5255 { WM_KEYDOWN
, sent
|wparam
|lparam
, VK_CONTROL
, 1 },
5256 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_SHIFT
, 1 }, /* XP */
5257 { WM_KEYDOWN
, wparam
|lparam
, VK_SHIFT
, 1 },
5258 { WM_KEYDOWN
, sent
|wparam
|lparam
, VK_SHIFT
, 1 },
5259 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 1 }, /* XP */
5260 { WM_KEYDOWN
, wparam
|lparam
, 'N', 1 },
5261 { WM_COMMAND
, sent
|wparam
|lparam
, MAKEWPARAM(1004,1), 0 },
5262 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 0xc0000001 }, /* XP */
5263 { WM_KEYUP
, wparam
|lparam
, 'N', 0xc0000001 },
5264 { WM_KEYUP
, sent
|wparam
|lparam
, 'N', 0xc0000001 },
5265 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_SHIFT
, 0xc0000001 }, /* XP */
5266 { WM_KEYUP
, wparam
|lparam
, VK_SHIFT
, 0xc0000001 },
5267 { WM_KEYUP
, sent
|wparam
|lparam
, VK_SHIFT
, 0xc0000001 },
5268 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_CONTROL
, 0xc0000001 }, /* XP */
5269 { WM_KEYUP
, wparam
|lparam
, VK_CONTROL
, 0xc0000001 },
5270 { WM_KEYUP
, sent
|wparam
|lparam
, VK_CONTROL
, 0xc0000001 },
5273 static const struct message WmCtrlAltShiftVkN
[] = {
5274 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_CONTROL
, 1 }, /* XP */
5275 { WM_KEYDOWN
, wparam
|lparam
, VK_CONTROL
, 1 },
5276 { WM_KEYDOWN
, sent
|wparam
|lparam
, VK_CONTROL
, 1 },
5277 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_MENU
, 0x20000001 }, /* XP */
5278 { WM_KEYDOWN
, wparam
|lparam
, VK_MENU
, 0x20000001 },
5279 { WM_KEYDOWN
, sent
|wparam
|lparam
, VK_MENU
, 0x20000001 },
5280 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_SHIFT
, 0x20000001 }, /* XP */
5281 { WM_KEYDOWN
, wparam
|lparam
, VK_SHIFT
, 0x20000001 },
5282 { WM_KEYDOWN
, sent
|wparam
|lparam
, VK_SHIFT
, 0x20000001 },
5283 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 0x20000001 }, /* XP */
5284 { WM_KEYDOWN
, wparam
|lparam
, 'N', 0x20000001 },
5285 { WM_COMMAND
, sent
|wparam
|lparam
, MAKEWPARAM(1005,1), 0 },
5286 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 0xe0000001 }, /* XP */
5287 { WM_KEYUP
, wparam
|lparam
, 'N', 0xe0000001 },
5288 { WM_KEYUP
, sent
|wparam
|lparam
, 'N', 0xe0000001 },
5289 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_SHIFT
, 0xe0000001 }, /* XP */
5290 { WM_KEYUP
, wparam
|lparam
, VK_SHIFT
, 0xe0000001 },
5291 { WM_KEYUP
, sent
|wparam
|lparam
, VK_SHIFT
, 0xe0000001 },
5292 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_MENU
, 0xc0000001 }, /* XP */
5293 { WM_KEYUP
, wparam
|lparam
, VK_MENU
, 0xc0000001 },
5294 { WM_KEYUP
, sent
|wparam
|lparam
, VK_MENU
, 0xc0000001 },
5295 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_CONTROL
, 0xc0000001 }, /* XP */
5296 { WM_KEYUP
, wparam
|lparam
, VK_CONTROL
, 0xc0000001 },
5297 { WM_KEYUP
, sent
|wparam
|lparam
, VK_CONTROL
, 0xc0000001 },
5300 static const struct message WmAltPressRelease
[] = {
5301 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_MENU
, 0x20000001 }, /* XP */
5302 { WM_SYSKEYDOWN
, wparam
|lparam
, VK_MENU
, 0x20000001 },
5303 { WM_SYSKEYDOWN
, sent
|wparam
|lparam
, VK_MENU
, 0x20000001 },
5304 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_MENU
, 0xc0000001 }, /* XP */
5305 { WM_SYSKEYUP
, wparam
|lparam
, VK_MENU
, 0xc0000001 },
5306 { WM_SYSKEYUP
, sent
|wparam
|lparam
, VK_MENU
, 0xc0000001 },
5307 { WM_SYSCOMMAND
, sent
|defwinproc
|wparam
|lparam
, SC_KEYMENU
, 0 },
5308 { HCBT_SYSCOMMAND
, hook
},
5309 { WM_ENTERMENULOOP
, sent
|defwinproc
|wparam
|lparam
, 0, 0 },
5310 { EVENT_SYSTEM_CAPTURESTART
, winevent_hook
|wparam
|lparam
, 0, 0 },
5311 { WM_INITMENU
, sent
|defwinproc
},
5312 { EVENT_SYSTEM_MENUSTART
, winevent_hook
|wparam
|lparam
, OBJID_SYSMENU
, 0 },
5313 { WM_MENUSELECT
, sent
|defwinproc
|wparam
, MAKEWPARAM(0,MF_SYSMENU
|MF_POPUP
|MF_HILITE
) },
5314 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_SYSMENU
, 1 },
5316 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_MENU
, 0x30000001 }, /* XP */
5318 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_SYSMENU
, 0 },
5319 { EVENT_SYSTEM_CAPTUREEND
, winevent_hook
|wparam
|lparam
, 0, 0, },
5320 { WM_CAPTURECHANGED
, sent
|defwinproc
},
5321 { WM_MENUSELECT
, sent
|defwinproc
|wparam
|optional
, MAKEWPARAM(0,0xffff) },
5322 { EVENT_SYSTEM_MENUEND
, winevent_hook
|wparam
|lparam
, OBJID_SYSMENU
, 0 },
5323 { WM_EXITMENULOOP
, sent
|defwinproc
},
5324 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_MENU
, 0xc0000001 }, /* XP */
5325 { WM_SYSKEYUP
, wparam
|lparam
, VK_MENU
, 0xc0000001 },
5326 { WM_SYSKEYUP
, sent
|wparam
|lparam
, VK_MENU
, 0xc0000001 },
5329 static const struct message WmAltMouseButton
[] = {
5330 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_MENU
, 0x20000001 }, /* XP */
5331 { WM_SYSKEYDOWN
, wparam
|lparam
, VK_MENU
, 0x20000001 },
5332 { WM_SYSKEYDOWN
, sent
|wparam
|lparam
, VK_MENU
, 0x20000001 },
5333 { WM_MOUSEMOVE
, wparam
|optional
, 0, 0 },
5334 { WM_MOUSEMOVE
, sent
|wparam
|optional
, 0, 0 },
5335 { WM_LBUTTONDOWN
, wparam
, MK_LBUTTON
, 0 },
5336 { WM_LBUTTONDOWN
, sent
|wparam
, MK_LBUTTON
, 0 },
5337 { WM_LBUTTONUP
, wparam
, 0, 0 },
5338 { WM_LBUTTONUP
, sent
|wparam
, 0, 0 },
5339 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_MENU
, 0xc0000001 }, /* XP */
5340 { WM_SYSKEYUP
, wparam
|lparam
, VK_MENU
, 0xc0000001 },
5341 { WM_SYSKEYUP
, sent
|wparam
|lparam
, VK_MENU
, 0xc0000001 },
5344 static const struct message WmF1Seq
[] = {
5345 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_F1
, 1 }, /* XP */
5346 { WM_KEYDOWN
, wparam
|lparam
, VK_F1
, 1 },
5347 { WM_KEYDOWN
, sent
|wparam
|lparam
, VK_F1
, 0x00000001 },
5348 { 0x4d, wparam
|lparam
, 0, 0 },
5349 { 0x4d, sent
|wparam
|lparam
, 0, 0 },
5350 { WM_HELP
, sent
|defwinproc
},
5351 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_F1
, 0xc0000001 }, /* XP */
5352 { WM_KEYUP
, wparam
|lparam
, VK_F1
, 0xc0000001 },
5353 { WM_KEYUP
, sent
|wparam
|lparam
, VK_F1
, 0xc0000001 },
5356 static const struct message WmVkAppsSeq
[] = {
5357 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_APPS
, 1 }, /* XP */
5358 { WM_KEYDOWN
, wparam
|lparam
, VK_APPS
, 1 },
5359 { WM_KEYDOWN
, sent
|wparam
|lparam
, VK_APPS
, 0x00000001 },
5360 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, VK_APPS
, 0xc0000001 }, /* XP */
5361 { WM_KEYUP
, wparam
|lparam
, VK_APPS
, 0xc0000001 },
5362 { WM_KEYUP
, sent
|wparam
|lparam
, VK_APPS
, 0xc0000001 },
5363 { WM_CONTEXTMENU
, lparam
, /*hwnd*/0, (LPARAM
)-1 },
5364 { WM_CONTEXTMENU
, sent
|lparam
, /*hwnd*/0, (LPARAM
)-1 },
5368 static void pump_msg_loop(HWND hwnd
, HACCEL hAccel
)
5372 while (PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
))
5374 struct message log_msg
;
5376 trace("accel: %p, %04x, %08x, %08lx\n", msg
.hwnd
, msg
.message
, msg
.wParam
, msg
.lParam
);
5378 /* ignore some unwanted messages */
5379 if (msg
.message
== WM_MOUSEMOVE
||
5380 msg
.message
== WM_GETICON
||
5381 msg
.message
== WM_DEVICECHANGE
)
5384 log_msg
.message
= msg
.message
;
5385 log_msg
.flags
= wparam
|lparam
;
5386 log_msg
.wParam
= msg
.wParam
;
5387 log_msg
.lParam
= msg
.lParam
;
5388 add_message(&log_msg
);
5390 if (!hAccel
|| !TranslateAccelerator(hwnd
, hAccel
, &msg
))
5392 TranslateMessage(&msg
);
5393 DispatchMessage(&msg
);
5398 static void test_accelerators(void)
5403 HWND hwnd
= CreateWindowExA(0, "TestWindowClass", NULL
, WS_OVERLAPPEDWINDOW
| WS_VISIBLE
,
5404 100, 100, 200, 200, 0, 0, 0, NULL
);
5413 ok(GetFocus() == hwnd
, "wrong focus window %p\n", GetFocus());
5415 state
= GetKeyState(VK_SHIFT
);
5416 ok(!(state
& 0x8000), "wrong Shift state %04x\n", state
);
5417 state
= GetKeyState(VK_CAPITAL
);
5418 ok(state
== 0, "wrong CapsLock state %04x\n", state
);
5420 hAccel
= LoadAccelerators(GetModuleHandleA(0), MAKEINTRESOURCE(1));
5421 assert(hAccel
!= 0);
5423 pump_msg_loop(hwnd
, 0);
5426 trace("testing VK_N press/release\n");
5428 keybd_event('N', 0, 0, 0);
5429 keybd_event('N', 0, KEYEVENTF_KEYUP
, 0);
5430 pump_msg_loop(hwnd
, hAccel
);
5431 ok_sequence(WmVkN
, "VK_N press/release", FALSE
);
5433 trace("testing Shift+VK_N press/release\n");
5435 keybd_event(VK_SHIFT
, 0, 0, 0);
5436 keybd_event('N', 0, 0, 0);
5437 keybd_event('N', 0, KEYEVENTF_KEYUP
, 0);
5438 keybd_event(VK_SHIFT
, 0, KEYEVENTF_KEYUP
, 0);
5439 pump_msg_loop(hwnd
, hAccel
);
5440 ok_sequence(WmShiftVkN
, "Shift+VK_N press/release", FALSE
);
5442 trace("testing Ctrl+VK_N press/release\n");
5444 keybd_event(VK_CONTROL
, 0, 0, 0);
5445 keybd_event('N', 0, 0, 0);
5446 keybd_event('N', 0, KEYEVENTF_KEYUP
, 0);
5447 keybd_event(VK_CONTROL
, 0, KEYEVENTF_KEYUP
, 0);
5448 pump_msg_loop(hwnd
, hAccel
);
5449 ok_sequence(WmCtrlVkN
, "Ctrl+VK_N press/release", FALSE
);
5451 trace("testing Alt+VK_N press/release\n");
5453 keybd_event(VK_MENU
, 0, 0, 0);
5454 keybd_event('N', 0, 0, 0);
5455 keybd_event('N', 0, KEYEVENTF_KEYUP
, 0);
5456 keybd_event(VK_MENU
, 0, KEYEVENTF_KEYUP
, 0);
5457 pump_msg_loop(hwnd
, hAccel
);
5458 ok_sequence(WmAltVkN
, "Alt+VK_N press/release", FALSE
);
5460 trace("testing Ctrl+Alt+VK_N press/release 1\n");
5462 keybd_event(VK_CONTROL
, 0, 0, 0);
5463 keybd_event(VK_MENU
, 0, 0, 0);
5464 keybd_event('N', 0, 0, 0);
5465 keybd_event('N', 0, KEYEVENTF_KEYUP
, 0);
5466 keybd_event(VK_MENU
, 0, KEYEVENTF_KEYUP
, 0);
5467 keybd_event(VK_CONTROL
, 0, KEYEVENTF_KEYUP
, 0);
5468 pump_msg_loop(hwnd
, hAccel
);
5469 ok_sequence(WmCtrlAltVkN
, "Ctrl+Alt+VK_N press/release 1", FALSE
);
5471 ret
= DestroyAcceleratorTable(hAccel
);
5472 ok( ret
, "DestroyAcceleratorTable error %d\n", GetLastError());
5474 hAccel
= LoadAccelerators(GetModuleHandleA(0), MAKEINTRESOURCE(2));
5475 assert(hAccel
!= 0);
5477 trace("testing VK_N press/release\n");
5479 keybd_event('N', 0, 0, 0);
5480 keybd_event('N', 0, KEYEVENTF_KEYUP
, 0);
5481 pump_msg_loop(hwnd
, hAccel
);
5482 ok_sequence(WmVkN
, "VK_N press/release", FALSE
);
5484 trace("testing Shift+VK_N press/release\n");
5486 keybd_event(VK_SHIFT
, 0, 0, 0);
5487 keybd_event('N', 0, 0, 0);
5488 keybd_event('N', 0, KEYEVENTF_KEYUP
, 0);
5489 keybd_event(VK_SHIFT
, 0, KEYEVENTF_KEYUP
, 0);
5490 pump_msg_loop(hwnd
, hAccel
);
5491 ok_sequence(WmShiftVkN
, "Shift+VK_N press/release", FALSE
);
5493 trace("testing Ctrl+VK_N press/release 2\n");
5495 keybd_event(VK_CONTROL
, 0, 0, 0);
5496 keybd_event('N', 0, 0, 0);
5497 keybd_event('N', 0, KEYEVENTF_KEYUP
, 0);
5498 keybd_event(VK_CONTROL
, 0, KEYEVENTF_KEYUP
, 0);
5499 pump_msg_loop(hwnd
, hAccel
);
5500 ok_sequence(WmCtrlVkN_2
, "Ctrl+VK_N press/release 2", FALSE
);
5502 trace("testing Alt+VK_N press/release 2\n");
5504 keybd_event(VK_MENU
, 0, 0, 0);
5505 keybd_event('N', 0, 0, 0);
5506 keybd_event('N', 0, KEYEVENTF_KEYUP
, 0);
5507 keybd_event(VK_MENU
, 0, KEYEVENTF_KEYUP
, 0);
5508 pump_msg_loop(hwnd
, hAccel
);
5509 ok_sequence(WmAltVkN_2
, "Alt+VK_N press/release 2", FALSE
);
5511 trace("testing Ctrl+Alt+VK_N press/release 2\n");
5513 keybd_event(VK_CONTROL
, 0, 0, 0);
5514 keybd_event(VK_MENU
, 0, 0, 0);
5515 keybd_event('N', 0, 0, 0);
5516 keybd_event('N', 0, KEYEVENTF_KEYUP
, 0);
5517 keybd_event(VK_MENU
, 0, KEYEVENTF_KEYUP
, 0);
5518 keybd_event(VK_CONTROL
, 0, KEYEVENTF_KEYUP
, 0);
5519 pump_msg_loop(hwnd
, hAccel
);
5520 ok_sequence(WmCtrlAltVkN
, "Ctrl+Alt+VK_N press/release 2", FALSE
);
5522 trace("testing Ctrl+Shift+VK_N press/release\n");
5524 keybd_event(VK_CONTROL
, 0, 0, 0);
5525 keybd_event(VK_SHIFT
, 0, 0, 0);
5526 keybd_event('N', 0, 0, 0);
5527 keybd_event('N', 0, KEYEVENTF_KEYUP
, 0);
5528 keybd_event(VK_SHIFT
, 0, KEYEVENTF_KEYUP
, 0);
5529 keybd_event(VK_CONTROL
, 0, KEYEVENTF_KEYUP
, 0);
5530 pump_msg_loop(hwnd
, hAccel
);
5531 ok_sequence(WmCtrlShiftVkN
, "Ctrl+Shift+VK_N press/release", FALSE
);
5533 trace("testing Ctrl+Alt+Shift+VK_N press/release\n");
5535 keybd_event(VK_CONTROL
, 0, 0, 0);
5536 keybd_event(VK_MENU
, 0, 0, 0);
5537 keybd_event(VK_SHIFT
, 0, 0, 0);
5538 keybd_event('N', 0, 0, 0);
5539 keybd_event('N', 0, KEYEVENTF_KEYUP
, 0);
5540 keybd_event(VK_SHIFT
, 0, KEYEVENTF_KEYUP
, 0);
5541 keybd_event(VK_MENU
, 0, KEYEVENTF_KEYUP
, 0);
5542 keybd_event(VK_CONTROL
, 0, KEYEVENTF_KEYUP
, 0);
5543 pump_msg_loop(hwnd
, hAccel
);
5544 ok_sequence(WmCtrlAltShiftVkN
, "Ctrl+Alt+Shift+VK_N press/release", FALSE
);
5546 ret
= DestroyAcceleratorTable(hAccel
);
5547 ok( ret
, "DestroyAcceleratorTable error %d\n", GetLastError());
5549 trace("testing Alt press/release\n");
5551 keybd_event(VK_MENU
, 0, 0, 0);
5552 keybd_event(VK_MENU
, 0, KEYEVENTF_KEYUP
, 0);
5553 keybd_event(VK_MENU
, 0, 0, 0);
5554 keybd_event(VK_MENU
, 0, KEYEVENTF_KEYUP
, 0);
5555 pump_msg_loop(hwnd
, 0);
5556 /* this test doesn't pass in Wine for managed windows */
5557 ok_sequence(WmAltPressRelease
, "Alt press/release", TRUE
);
5559 trace("testing Alt+MouseButton press/release\n");
5560 /* first, move mouse pointer inside of the window client area */
5561 GetClientRect(hwnd
, &rc
);
5562 MapWindowPoints(hwnd
, 0, (LPPOINT
)&rc
, 2);
5563 rc
.left
+= (rc
.right
- rc
.left
)/2;
5564 rc
.top
+= (rc
.bottom
- rc
.top
)/2;
5565 SetCursorPos(rc
.left
, rc
.top
);
5567 pump_msg_loop(hwnd
, 0);
5569 keybd_event(VK_MENU
, 0, 0, 0);
5570 mouse_event(MOUSEEVENTF_LEFTDOWN
, 0, 0, 0, 0);
5571 mouse_event(MOUSEEVENTF_LEFTUP
, 0, 0, 0, 0);
5572 keybd_event(VK_MENU
, 0, KEYEVENTF_KEYUP
, 0);
5573 pump_msg_loop(hwnd
, 0);
5574 ok_sequence(WmAltMouseButton
, "Alt+MouseButton press/release", FALSE
);
5576 trace("testing VK_F1 press/release\n");
5577 keybd_event(VK_F1
, 0, 0, 0);
5578 keybd_event(VK_F1
, 0, KEYEVENTF_KEYUP
, 0);
5579 pump_msg_loop(hwnd
, 0);
5580 ok_sequence(WmF1Seq
, "F1 press/release", TRUE
);
5582 trace("testing VK_APPS press/release\n");
5583 keybd_event(VK_APPS
, 0, 0, 0);
5584 keybd_event(VK_APPS
, 0, KEYEVENTF_KEYUP
, 0);
5585 pump_msg_loop(hwnd
, 0);
5586 ok_sequence(WmVkAppsSeq
, "VK_APPS press/release", FALSE
);
5588 DestroyWindow(hwnd
);
5591 /************* window procedures ********************/
5593 static LRESULT
MsgCheckProc (BOOL unicode
, HWND hwnd
, UINT message
,
5594 WPARAM wParam
, LPARAM lParam
)
5596 static long defwndproc_counter
= 0;
5597 static long beginpaint_counter
= 0;
5601 trace("%p, %04x, %08x, %08lx\n", hwnd
, message
, wParam
, lParam
);
5603 /* explicitly ignore WM_GETICON message */
5604 if (message
== WM_GETICON
) return 0;
5610 LONG style
= GetWindowLongA(hwnd
, GWL_STYLE
);
5611 ok((BOOL
)wParam
== !(style
& WS_DISABLED
),
5612 "wrong WS_DISABLED state: %d != %d\n", wParam
, !(style
& WS_DISABLED
));
5616 case WM_CAPTURECHANGED
:
5617 if (test_DestroyWindow_flag
)
5619 DWORD style
= GetWindowLongA(hwnd
, GWL_STYLE
);
5620 if (style
& WS_CHILD
)
5621 lParam
= GetWindowLongPtrA(hwnd
, GWLP_ID
);
5622 else if (style
& WS_POPUP
)
5623 lParam
= WND_POPUP_ID
;
5625 lParam
= WND_PARENT_ID
;
5633 ok(!GetWindow(hwnd
, GW_CHILD
), "children should be unlinked at this point\n");
5634 capture
= GetCapture();
5637 ok(capture
== hwnd
, "capture should NOT be released at this point (capture %p)\n", capture
);
5638 trace("current capture %p, releasing...\n", capture
);
5645 ok(pGetAncestor(hwnd
, GA_PARENT
) != 0, "parent should NOT be unlinked at this point\n");
5646 if (test_DestroyWindow_flag
)
5648 DWORD style
= GetWindowLongA(hwnd
, GWL_STYLE
);
5649 if (style
& WS_CHILD
)
5650 lParam
= GetWindowLongPtrA(hwnd
, GWLP_ID
);
5651 else if (style
& WS_POPUP
)
5652 lParam
= WND_POPUP_ID
;
5654 lParam
= WND_PARENT_ID
;
5658 /* test_accelerators() depends on this */
5665 case WM_DEVICECHANGE
:
5668 case WM_WINDOWPOSCHANGING
:
5669 case WM_WINDOWPOSCHANGED
:
5671 WINDOWPOS
*winpos
= (WINDOWPOS
*)lParam
;
5673 trace("%s\n", (message
== WM_WINDOWPOSCHANGING
) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
5674 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
5675 winpos
->hwnd
, winpos
->hwndInsertAfter
,
5676 winpos
->x
, winpos
->y
, winpos
->cx
, winpos
->cy
, winpos
->flags
);
5677 dump_winpos_flags(winpos
->flags
);
5679 /* Log only documented flags, win2k uses 0x1000 and 0x2000
5680 * in the high word for internal purposes
5682 wParam
= winpos
->flags
& 0xffff;
5683 /* We are not interested in the flags that don't match under XP and Win9x */
5684 wParam
&= ~(SWP_NOZORDER
);
5689 msg
.message
= message
;
5690 msg
.flags
= sent
|wparam
|lparam
;
5691 if (defwndproc_counter
) msg
.flags
|= defwinproc
;
5692 if (beginpaint_counter
) msg
.flags
|= beginpaint
;
5693 msg
.wParam
= wParam
;
5694 msg
.lParam
= lParam
;
5697 if (message
== WM_GETMINMAXINFO
&& (GetWindowLongA(hwnd
, GWL_STYLE
) & WS_CHILD
))
5699 HWND parent
= GetParent(hwnd
);
5701 MINMAXINFO
*minmax
= (MINMAXINFO
*)lParam
;
5703 GetClientRect(parent
, &rc
);
5704 trace("parent %p client size = (%d x %d)\n", parent
, rc
.right
, rc
.bottom
);
5706 trace("ptReserved = (%d,%d)\n"
5707 "ptMaxSize = (%d,%d)\n"
5708 "ptMaxPosition = (%d,%d)\n"
5709 "ptMinTrackSize = (%d,%d)\n"
5710 "ptMaxTrackSize = (%d,%d)\n",
5711 minmax
->ptReserved
.x
, minmax
->ptReserved
.y
,
5712 minmax
->ptMaxSize
.x
, minmax
->ptMaxSize
.y
,
5713 minmax
->ptMaxPosition
.x
, minmax
->ptMaxPosition
.y
,
5714 minmax
->ptMinTrackSize
.x
, minmax
->ptMinTrackSize
.y
,
5715 minmax
->ptMaxTrackSize
.x
, minmax
->ptMaxTrackSize
.y
);
5717 ok(minmax
->ptMaxSize
.x
== rc
.right
, "default width of maximized child %d != %d\n",
5718 minmax
->ptMaxSize
.x
, rc
.right
);
5719 ok(minmax
->ptMaxSize
.y
== rc
.bottom
, "default height of maximized child %d != %d\n",
5720 minmax
->ptMaxSize
.y
, rc
.bottom
);
5723 if (message
== WM_PAINT
)
5726 beginpaint_counter
++;
5727 BeginPaint( hwnd
, &ps
);
5728 beginpaint_counter
--;
5729 EndPaint( hwnd
, &ps
);
5733 defwndproc_counter
++;
5734 ret
= unicode
? DefWindowProcW(hwnd
, message
, wParam
, lParam
)
5735 : DefWindowProcA(hwnd
, message
, wParam
, lParam
);
5736 defwndproc_counter
--;
5741 static LRESULT WINAPI
MsgCheckProcA(HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
5743 return MsgCheckProc (FALSE
, hwnd
, message
, wParam
, lParam
);
5746 static LRESULT WINAPI
MsgCheckProcW(HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
5748 return MsgCheckProc (TRUE
, hwnd
, message
, wParam
, lParam
);
5751 static LRESULT WINAPI
PopupMsgCheckProcA(HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
5753 static long defwndproc_counter
= 0;
5757 trace("popup: %p, %04x, %08x, %08lx\n", hwnd
, message
, wParam
, lParam
);
5759 /* explicitly ignore WM_GETICON message */
5760 if (message
== WM_GETICON
) return 0;
5762 msg
.message
= message
;
5763 msg
.flags
= sent
|wparam
|lparam
;
5764 if (defwndproc_counter
) msg
.flags
|= defwinproc
;
5765 msg
.wParam
= wParam
;
5766 msg
.lParam
= lParam
;
5769 if (message
== WM_CREATE
)
5771 DWORD style
= GetWindowLongA(hwnd
, GWL_STYLE
) | WS_VISIBLE
;
5772 SetWindowLongA(hwnd
, GWL_STYLE
, style
);
5775 defwndproc_counter
++;
5776 ret
= DefWindowProcA(hwnd
, message
, wParam
, lParam
);
5777 defwndproc_counter
--;
5782 static LRESULT WINAPI
ParentMsgCheckProcA(HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
5784 static long defwndproc_counter
= 0;
5785 static long beginpaint_counter
= 0;
5789 trace("parent: %p, %04x, %08x, %08lx\n", hwnd
, message
, wParam
, lParam
);
5791 /* explicitly ignore WM_GETICON message */
5792 if (message
== WM_GETICON
) return 0;
5794 if (log_all_parent_messages
||
5795 message
== WM_PARENTNOTIFY
|| message
== WM_CANCELMODE
||
5796 message
== WM_SETFOCUS
|| message
== WM_KILLFOCUS
||
5797 message
== WM_ENABLE
|| message
== WM_ENTERIDLE
||
5798 message
== WM_IME_SETCONTEXT
)
5812 INT ret
= GetClipBox((HDC
)wParam
, &rc
);
5814 trace("WM_ERASEBKGND: GetClipBox()=%d, (%d,%d-%d,%d)\n",
5815 ret
, rc
.left
, rc
.top
, rc
.right
, rc
.bottom
);
5819 case WM_WINDOWPOSCHANGING
:
5820 case WM_WINDOWPOSCHANGED
:
5822 WINDOWPOS
*winpos
= (WINDOWPOS
*)lParam
;
5824 trace("%s\n", (message
== WM_WINDOWPOSCHANGING
) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
5825 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
5826 winpos
->hwnd
, winpos
->hwndInsertAfter
,
5827 winpos
->x
, winpos
->y
, winpos
->cx
, winpos
->cy
, winpos
->flags
);
5828 dump_winpos_flags(winpos
->flags
);
5830 /* Log only documented flags, win2k uses 0x1000 and 0x2000
5831 * in the high word for internal purposes
5833 wParam
= winpos
->flags
& 0xffff;
5834 /* We are not interested in the flags that don't match under XP and Win9x */
5835 wParam
&= ~(SWP_NOZORDER
);
5840 msg
.message
= message
;
5841 msg
.flags
= sent
|parent
|wparam
|lparam
;
5842 if (defwndproc_counter
) msg
.flags
|= defwinproc
;
5843 if (beginpaint_counter
) msg
.flags
|= beginpaint
;
5844 msg
.wParam
= wParam
;
5845 msg
.lParam
= lParam
;
5849 if (message
== WM_PAINT
)
5852 beginpaint_counter
++;
5853 BeginPaint( hwnd
, &ps
);
5854 beginpaint_counter
--;
5855 EndPaint( hwnd
, &ps
);
5859 defwndproc_counter
++;
5860 ret
= DefWindowProcA(hwnd
, message
, wParam
, lParam
);
5861 defwndproc_counter
--;
5866 static LRESULT WINAPI
TestDlgProcA(HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
5868 static long defwndproc_counter
= 0;
5872 trace("dialog: %p, %04x, %08x, %08lx\n", hwnd
, message
, wParam
, lParam
);
5874 /* explicitly ignore WM_GETICON message */
5875 if (message
== WM_GETICON
) return 0;
5877 DefDlgProcA(hwnd
, DM_SETDEFID
, 1, 0);
5878 ret
= DefDlgProcA(hwnd
, DM_GETDEFID
, 0, 0);
5879 if (after_end_dialog
)
5880 ok( ret
== 0, "DM_GETDEFID should return 0 after EndDialog, got %lx\n", ret
);
5882 ok(HIWORD(ret
) == DC_HASDEFID
, "DM_GETDEFID should return DC_HASDEFID, got %lx\n", ret
);
5886 case WM_WINDOWPOSCHANGING
:
5887 case WM_WINDOWPOSCHANGED
:
5889 WINDOWPOS
*winpos
= (WINDOWPOS
*)lParam
;
5891 trace("%s\n", (message
== WM_WINDOWPOSCHANGING
) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
5892 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
5893 winpos
->hwnd
, winpos
->hwndInsertAfter
,
5894 winpos
->x
, winpos
->y
, winpos
->cx
, winpos
->cy
, winpos
->flags
);
5895 dump_winpos_flags(winpos
->flags
);
5897 /* Log only documented flags, win2k uses 0x1000 and 0x2000
5898 * in the high word for internal purposes
5900 wParam
= winpos
->flags
& 0xffff;
5901 /* We are not interested in the flags that don't match under XP and Win9x */
5902 wParam
&= ~(SWP_NOZORDER
);
5907 msg
.message
= message
;
5908 msg
.flags
= sent
|wparam
|lparam
;
5909 if (defwndproc_counter
) msg
.flags
|= defwinproc
;
5910 msg
.wParam
= wParam
;
5911 msg
.lParam
= lParam
;
5914 defwndproc_counter
++;
5915 ret
= DefDlgProcA(hwnd
, message
, wParam
, lParam
);
5916 defwndproc_counter
--;
5921 static void dump_winpos_flags(UINT flags
)
5923 if (!winetest_debug
) return;
5925 if (flags
& SWP_SHOWWINDOW
) printf("|SWP_SHOWWINDOW");
5926 if (flags
& SWP_HIDEWINDOW
) printf("|SWP_HIDEWINDOW");
5927 if (flags
& SWP_NOACTIVATE
) printf("|SWP_NOACTIVATE");
5928 if (flags
& SWP_FRAMECHANGED
) printf("|SWP_FRAMECHANGED");
5929 if (flags
& SWP_NOCOPYBITS
) printf("|SWP_NOCOPYBITS");
5930 if (flags
& SWP_NOOWNERZORDER
) printf("|SWP_NOOWNERZORDER");
5931 if (flags
& SWP_NOSENDCHANGING
) printf("|SWP_NOSENDCHANGING");
5932 if (flags
& SWP_DEFERERASE
) printf("|SWP_DEFERERASE");
5933 if (flags
& SWP_ASYNCWINDOWPOS
) printf("|SWP_ASYNCWINDOWPOS");
5934 if (flags
& SWP_NOZORDER
) printf("|SWP_NOZORDER");
5935 if (flags
& SWP_NOREDRAW
) printf("|SWP_NOREDRAW");
5936 if (flags
& SWP_NOSIZE
) printf("|SWP_NOSIZE");
5937 if (flags
& SWP_NOMOVE
) printf("|SWP_NOMOVE");
5938 if (flags
& SWP_NOCLIENTSIZE
) printf("|SWP_NOCLIENTSIZE");
5939 if (flags
& SWP_NOCLIENTMOVE
) printf("|SWP_NOCLIENTMOVE");
5941 #define DUMPED_FLAGS \
5947 SWP_FRAMECHANGED | \
5951 SWP_NOOWNERZORDER | \
5952 SWP_NOSENDCHANGING | \
5954 SWP_ASYNCWINDOWPOS | \
5955 SWP_NOCLIENTSIZE | \
5958 if(flags
& ~DUMPED_FLAGS
) printf("|0x%04x", flags
& ~DUMPED_FLAGS
);
5963 static LRESULT WINAPI
ShowWindowProcA(HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
5965 static long defwndproc_counter
= 0;
5969 /* log only specific messages we are interested in */
5972 #if 0 /* probably log these as well */
5978 trace("WM_SHOWWINDOW %d\n", wParam
);
5981 trace("WM_SIZE %d\n", wParam
);
5986 case WM_GETMINMAXINFO
:
5987 trace("WM_GETMINMAXINFO\n");
5990 case WM_WINDOWPOSCHANGING
:
5991 case WM_WINDOWPOSCHANGED
:
5993 WINDOWPOS
*winpos
= (WINDOWPOS
*)lParam
;
5995 trace("%s\n", (message
== WM_WINDOWPOSCHANGING
) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
5996 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
5997 winpos
->hwnd
, winpos
->hwndInsertAfter
,
5998 winpos
->x
, winpos
->y
, winpos
->cx
, winpos
->cy
, winpos
->flags
);
6000 dump_winpos_flags(winpos
->flags
);
6002 /* Log only documented flags, win2k uses 0x1000 and 0x2000
6003 * in the high word for internal purposes
6005 wParam
= winpos
->flags
& 0xffff;
6006 /* We are not interested in the flags that don't match under XP and Win9x */
6007 wParam
&= ~(SWP_NOZORDER
);
6011 default: /* ignore */
6012 /*trace("showwindow: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);*/
6013 return DefWindowProcA(hwnd
, message
, wParam
, lParam
);
6016 msg
.message
= message
;
6017 msg
.flags
= sent
|wparam
|lparam
;
6018 if (defwndproc_counter
) msg
.flags
|= defwinproc
;
6019 msg
.wParam
= wParam
;
6020 msg
.lParam
= lParam
;
6023 defwndproc_counter
++;
6024 ret
= DefWindowProcA(hwnd
, message
, wParam
, lParam
);
6025 defwndproc_counter
--;
6030 static BOOL
RegisterWindowClasses(void)
6035 cls
.lpfnWndProc
= MsgCheckProcA
;
6038 cls
.hInstance
= GetModuleHandleA(0);
6040 cls
.hCursor
= LoadCursorA(0, (LPSTR
)IDC_ARROW
);
6041 cls
.hbrBackground
= GetStockObject(WHITE_BRUSH
);
6042 cls
.lpszMenuName
= NULL
;
6043 cls
.lpszClassName
= "TestWindowClass";
6044 if(!RegisterClassA(&cls
)) return FALSE
;
6046 cls
.lpfnWndProc
= ShowWindowProcA
;
6047 cls
.lpszClassName
= "ShowWindowClass";
6048 if(!RegisterClassA(&cls
)) return FALSE
;
6050 cls
.lpfnWndProc
= PopupMsgCheckProcA
;
6051 cls
.lpszClassName
= "TestPopupClass";
6052 if(!RegisterClassA(&cls
)) return FALSE
;
6054 cls
.lpfnWndProc
= ParentMsgCheckProcA
;
6055 cls
.lpszClassName
= "TestParentClass";
6056 if(!RegisterClassA(&cls
)) return FALSE
;
6058 cls
.lpfnWndProc
= DefWindowProcA
;
6059 cls
.lpszClassName
= "SimpleWindowClass";
6060 if(!RegisterClassA(&cls
)) return FALSE
;
6062 cls
.style
= CS_NOCLOSE
;
6063 cls
.lpszClassName
= "NoCloseWindowClass";
6064 if(!RegisterClassA(&cls
)) return FALSE
;
6066 ok(GetClassInfoA(0, "#32770", &cls
), "GetClassInfo failed\n");
6068 cls
.hInstance
= GetModuleHandleA(0);
6069 cls
.hbrBackground
= 0;
6070 cls
.lpfnWndProc
= TestDlgProcA
;
6071 cls
.lpszClassName
= "TestDialogClass";
6072 if(!RegisterClassA(&cls
)) return FALSE
;
6077 static HHOOK hCBT_hook
;
6078 static DWORD cbt_hook_thread_id
;
6080 static LRESULT CALLBACK
cbt_hook_proc(int nCode
, WPARAM wParam
, LPARAM lParam
)
6082 static const char * const CBT_code_name
[10] = {
6089 "HCBT_CLICKSKIPPED",
6093 const char *code_name
= (nCode
>= 0 && nCode
<= HCBT_SETFOCUS
) ? CBT_code_name
[nCode
] : "Unknown";
6097 trace("CBT: %d (%s), %08x, %08lx\n", nCode
, code_name
, wParam
, lParam
);
6099 ok(cbt_hook_thread_id
== GetCurrentThreadId(), "we didn't ask for events from other threads\n");
6101 if (nCode
== HCBT_CLICKSKIPPED
)
6103 /* ignore this event, XP sends it a lot when switching focus between windows */
6104 return CallNextHookEx(hCBT_hook
, nCode
, wParam
, lParam
);
6107 if (nCode
== HCBT_SYSCOMMAND
|| nCode
== HCBT_KEYSKIPPED
)
6111 msg
.message
= nCode
;
6112 msg
.flags
= hook
|wparam
|lparam
;
6113 msg
.wParam
= wParam
;
6114 msg
.lParam
= lParam
;
6117 return CallNextHookEx(hCBT_hook
, nCode
, wParam
, lParam
);
6120 if (nCode
== HCBT_DESTROYWND
)
6122 if (test_DestroyWindow_flag
)
6124 DWORD style
= GetWindowLongA((HWND
)wParam
, GWL_STYLE
);
6125 if (style
& WS_CHILD
)
6126 lParam
= GetWindowLongPtrA((HWND
)wParam
, GWLP_ID
);
6127 else if (style
& WS_POPUP
)
6128 lParam
= WND_POPUP_ID
;
6130 lParam
= WND_PARENT_ID
;
6134 /* Log also SetFocus(0) calls */
6135 hwnd
= wParam
? (HWND
)wParam
: (HWND
)lParam
;
6137 if (GetClassNameA(hwnd
, buf
, sizeof(buf
)))
6139 if (!lstrcmpiA(buf
, "TestWindowClass") ||
6140 !lstrcmpiA(buf
, "ShowWindowClass") ||
6141 !lstrcmpiA(buf
, "TestParentClass") ||
6142 !lstrcmpiA(buf
, "TestPopupClass") ||
6143 !lstrcmpiA(buf
, "SimpleWindowClass") ||
6144 !lstrcmpiA(buf
, "TestDialogClass") ||
6145 !lstrcmpiA(buf
, "MDI_frame_class") ||
6146 !lstrcmpiA(buf
, "MDI_client_class") ||
6147 !lstrcmpiA(buf
, "MDI_child_class") ||
6148 !lstrcmpiA(buf
, "my_button_class") ||
6149 !lstrcmpiA(buf
, "my_edit_class") ||
6150 !lstrcmpiA(buf
, "static") ||
6151 !lstrcmpiA(buf
, "#32770"))
6155 msg
.message
= nCode
;
6156 msg
.flags
= hook
|wparam
|lparam
;
6157 msg
.wParam
= wParam
;
6158 msg
.lParam
= lParam
;
6162 return CallNextHookEx(hCBT_hook
, nCode
, wParam
, lParam
);
6165 static void CALLBACK
win_event_proc(HWINEVENTHOOK hevent
,
6175 trace("WEH:%p,event %08x,hwnd %p,obj %08x,id %08x,thread %08x,time %08x\n",
6176 hevent
, event
, hwnd
, object_id
, child_id
, thread_id
, event_time
);
6178 ok(thread_id
== GetCurrentThreadId(), "we didn't ask for events from other threads\n");
6180 /* ignore mouse cursor events */
6181 if (object_id
== OBJID_CURSOR
) return;
6183 if (!hwnd
|| GetClassNameA(hwnd
, buf
, sizeof(buf
)))
6186 !lstrcmpiA(buf
, "TestWindowClass") ||
6187 !lstrcmpiA(buf
, "TestParentClass") ||
6188 !lstrcmpiA(buf
, "TestPopupClass") ||
6189 !lstrcmpiA(buf
, "SimpleWindowClass") ||
6190 !lstrcmpiA(buf
, "TestDialogClass") ||
6191 !lstrcmpiA(buf
, "MDI_frame_class") ||
6192 !lstrcmpiA(buf
, "MDI_client_class") ||
6193 !lstrcmpiA(buf
, "MDI_child_class") ||
6194 !lstrcmpiA(buf
, "my_button_class") ||
6195 !lstrcmpiA(buf
, "my_edit_class") ||
6196 !lstrcmpiA(buf
, "static") ||
6197 !lstrcmpiA(buf
, "#32770"))
6201 msg
.message
= event
;
6202 msg
.flags
= winevent_hook
|wparam
|lparam
;
6203 msg
.wParam
= object_id
;
6204 msg
.lParam
= child_id
;
6210 static const WCHAR wszUnicode
[] = {'U','n','i','c','o','d','e',0};
6211 static const WCHAR wszAnsi
[] = {'U',0};
6213 static LRESULT CALLBACK
MsgConversionProcW(HWND hwnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
6217 case CB_FINDSTRINGEXACT
:
6218 trace("String: %p\n", (LPCWSTR
)lParam
);
6219 if (!lstrcmpW((LPCWSTR
)lParam
, wszUnicode
))
6221 if (!lstrcmpW((LPCWSTR
)lParam
, wszAnsi
))
6225 return DefWindowProcW(hwnd
, uMsg
, wParam
, lParam
);
6228 static const struct message WmGetTextLengthAfromW
[] = {
6229 { WM_GETTEXTLENGTH
, sent
},
6230 { WM_GETTEXT
, sent
},
6234 static const WCHAR testWindowClassW
[] =
6235 { 'T','e','s','t','W','i','n','d','o','w','C','l','a','s','s','W',0 };
6237 static const WCHAR dummy_window_text
[] = {'d','u','m','m','y',' ','t','e','x','t',0};
6239 /* dummy window proc for WM_GETTEXTLENGTH test */
6240 static LRESULT CALLBACK
get_text_len_proc( HWND hwnd
, UINT msg
, WPARAM wp
, LPARAM lp
)
6244 case WM_GETTEXTLENGTH
:
6245 return lstrlenW(dummy_window_text
) + 37; /* some random length */
6247 lstrcpynW( (LPWSTR
)lp
, dummy_window_text
, wp
);
6248 return lstrlenW( (LPWSTR
)lp
);
6250 return DefWindowProcW( hwnd
, msg
, wp
, lp
);
6254 static void test_message_conversion(void)
6256 static const WCHAR wszMsgConversionClass
[] =
6257 {'M','s','g','C','o','n','v','e','r','s','i','o','n','C','l','a','s','s',0};
6261 WNDPROC wndproc
, newproc
;
6265 cls
.lpfnWndProc
= MsgConversionProcW
;
6268 cls
.hInstance
= GetModuleHandleW(NULL
);
6270 cls
.hCursor
= LoadCursorW(NULL
, (LPWSTR
)IDC_ARROW
);
6271 cls
.hbrBackground
= (HBRUSH
)(COLOR_BTNFACE
+1);
6272 cls
.lpszMenuName
= NULL
;
6273 cls
.lpszClassName
= wszMsgConversionClass
;
6274 /* this call will fail on Win9x, but that doesn't matter as this test is
6275 * meaningless on those platforms */
6276 if(!RegisterClassW(&cls
)) return;
6279 cls
.lpfnWndProc
= MsgCheckProcW
;
6282 cls
.hInstance
= GetModuleHandleW(0);
6284 cls
.hCursor
= LoadCursorW(0, (LPWSTR
)IDC_ARROW
);
6285 cls
.hbrBackground
= GetStockObject(WHITE_BRUSH
);
6286 cls
.lpszMenuName
= NULL
;
6287 cls
.lpszClassName
= testWindowClassW
;
6288 if(!RegisterClassW(&cls
)) return;
6290 hwnd
= CreateWindowExW(0, wszMsgConversionClass
, NULL
, WS_OVERLAPPED
,
6291 100, 100, 200, 200, 0, 0, 0, NULL
);
6292 ok(hwnd
!= NULL
, "Window creation failed\n");
6296 wndproc
= (WNDPROC
)GetWindowLongPtrA(hwnd
, GWLP_WNDPROC
);
6297 lRes
= CallWindowProcA(wndproc
, hwnd
, CB_FINDSTRINGEXACT
, 0, (LPARAM
)wszUnicode
);
6298 ok(lRes
== 0, "String should have been converted\n");
6299 lRes
= CallWindowProcW(wndproc
, hwnd
, CB_FINDSTRINGEXACT
, 0, (LPARAM
)wszUnicode
);
6300 ok(lRes
== 1, "String shouldn't have been converted\n");
6304 wndproc
= (WNDPROC
)GetWindowLongPtrW(hwnd
, GWLP_WNDPROC
);
6305 lRes
= CallWindowProcA(wndproc
, hwnd
, CB_FINDSTRINGEXACT
, 0, (LPARAM
)wszUnicode
);
6306 ok(lRes
== 1, "String shouldn't have been converted\n");
6307 lRes
= CallWindowProcW(wndproc
, hwnd
, CB_FINDSTRINGEXACT
, 0, (LPARAM
)wszUnicode
);
6308 ok(lRes
== 1, "String shouldn't have been converted\n");
6310 /* Synchronous messages */
6312 lRes
= SendMessageA(hwnd
, CB_FINDSTRINGEXACT
, 0, (LPARAM
)wszUnicode
);
6313 ok(lRes
== 0, "String should have been converted\n");
6314 lRes
= SendMessageW(hwnd
, CB_FINDSTRINGEXACT
, 0, (LPARAM
)wszUnicode
);
6315 ok(lRes
== 1, "String shouldn't have been converted\n");
6317 /* Asynchronous messages */
6320 lRes
= PostMessageA(hwnd
, CB_FINDSTRINGEXACT
, 0, (LPARAM
)wszUnicode
);
6321 ok(lRes
== 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY
|| GetLastError() == ERROR_INVALID_PARAMETER
),
6322 "PostMessage on sync only message returned %ld, last error %d\n", lRes
, GetLastError());
6324 lRes
= PostMessageW(hwnd
, CB_FINDSTRINGEXACT
, 0, (LPARAM
)wszUnicode
);
6325 ok(lRes
== 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY
|| GetLastError() == ERROR_INVALID_PARAMETER
),
6326 "PostMessage on sync only message returned %ld, last error %d\n", lRes
, GetLastError());
6328 lRes
= PostThreadMessageA(GetCurrentThreadId(), CB_FINDSTRINGEXACT
, 0, (LPARAM
)wszUnicode
);
6329 ok(lRes
== 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY
|| GetLastError() == ERROR_INVALID_PARAMETER
),
6330 "PosThreadtMessage on sync only message returned %ld, last error %d\n", lRes
, GetLastError());
6332 lRes
= PostThreadMessageW(GetCurrentThreadId(), CB_FINDSTRINGEXACT
, 0, (LPARAM
)wszUnicode
);
6333 ok(lRes
== 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY
|| GetLastError() == ERROR_INVALID_PARAMETER
),
6334 "PosThreadtMessage on sync only message returned %ld, last error %d\n", lRes
, GetLastError());
6336 lRes
= SendNotifyMessageA(hwnd
, CB_FINDSTRINGEXACT
, 0, (LPARAM
)wszUnicode
);
6337 ok(lRes
== 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY
|| GetLastError() == ERROR_INVALID_PARAMETER
),
6338 "SendNotifyMessage on sync only message returned %ld, last error %d\n", lRes
, GetLastError());
6340 lRes
= SendNotifyMessageW(hwnd
, CB_FINDSTRINGEXACT
, 0, (LPARAM
)wszUnicode
);
6341 ok(lRes
== 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY
|| GetLastError() == ERROR_INVALID_PARAMETER
),
6342 "SendNotifyMessage on sync only message returned %ld, last error %d\n", lRes
, GetLastError());
6344 lRes
= SendMessageCallbackA(hwnd
, CB_FINDSTRINGEXACT
, 0, (LPARAM
)wszUnicode
, NULL
, 0);
6345 ok(lRes
== 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY
|| GetLastError() == ERROR_INVALID_PARAMETER
),
6346 "SendMessageCallback on sync only message returned %ld, last error %d\n", lRes
, GetLastError());
6348 lRes
= SendMessageCallbackW(hwnd
, CB_FINDSTRINGEXACT
, 0, (LPARAM
)wszUnicode
, NULL
, 0);
6349 ok(lRes
== 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY
|| GetLastError() == ERROR_INVALID_PARAMETER
),
6350 "SendMessageCallback on sync only message returned %ld, last error %d\n", lRes
, GetLastError());
6352 /* Check WM_GETTEXTLENGTH A->W behaviour, whether WM_GETTEXT is also sent or not */
6354 hwnd
= CreateWindowW (testWindowClassW
, wszUnicode
,
6355 WS_OVERLAPPEDWINDOW
,
6356 100, 100, 200, 200, 0, 0, 0, NULL
);
6359 lRes
= SendMessageA (hwnd
, WM_GETTEXTLENGTH
, 0, 0);
6360 ok_sequence(WmGetTextLengthAfromW
, "ANSI WM_GETTEXTLENGTH to Unicode window", FALSE
);
6361 ok( lRes
== WideCharToMultiByte( CP_ACP
, 0, wszUnicode
, lstrlenW(wszUnicode
), NULL
, 0, NULL
, NULL
),
6362 "got bad length %ld\n", lRes
);
6365 lRes
= CallWindowProcA( (WNDPROC
)GetWindowLongPtrA( hwnd
, GWLP_WNDPROC
),
6366 hwnd
, WM_GETTEXTLENGTH
, 0, 0);
6367 ok_sequence(WmGetTextLengthAfromW
, "ANSI WM_GETTEXTLENGTH to Unicode window", FALSE
);
6368 ok( lRes
== WideCharToMultiByte( CP_ACP
, 0, wszUnicode
, lstrlenW(wszUnicode
), NULL
, 0, NULL
, NULL
),
6369 "got bad length %ld\n", lRes
);
6371 wndproc
= (WNDPROC
)SetWindowLongPtrW( hwnd
, GWLP_WNDPROC
, (LONG_PTR
)get_text_len_proc
);
6372 newproc
= (WNDPROC
)GetWindowLongPtrA( hwnd
, GWLP_WNDPROC
);
6373 lRes
= CallWindowProcA( newproc
, hwnd
, WM_GETTEXTLENGTH
, 0, 0 );
6374 ok( lRes
== WideCharToMultiByte( CP_ACP
, 0, dummy_window_text
, lstrlenW(dummy_window_text
),
6375 NULL
, 0, NULL
, NULL
),
6376 "got bad length %ld\n", lRes
);
6378 SetWindowLongPtrW( hwnd
, GWLP_WNDPROC
, (LONG_PTR
)wndproc
); /* restore old wnd proc */
6379 lRes
= CallWindowProcA( newproc
, hwnd
, WM_GETTEXTLENGTH
, 0, 0 );
6380 ok( lRes
== WideCharToMultiByte( CP_ACP
, 0, dummy_window_text
, lstrlenW(dummy_window_text
),
6381 NULL
, 0, NULL
, NULL
),
6382 "got bad length %ld\n", lRes
);
6384 ret
= DestroyWindow(hwnd
);
6385 ok( ret
, "DestroyWindow() error %d\n", GetLastError());
6395 static VOID CALLBACK
tfunc(HWND hwnd
, UINT uMsg
, UINT id
, DWORD dwTime
)
6399 #define TIMER_ID 0x19
6401 static DWORD WINAPI
timer_thread_proc(LPVOID x
)
6403 struct timer_info
*info
= x
;
6406 r
= KillTimer(info
->hWnd
, 0x19);
6407 ok(r
,"KillTimer failed in thread\n");
6408 r
= SetTimer(info
->hWnd
,TIMER_ID
,10000,tfunc
);
6409 ok(r
,"SetTimer failed in thread\n");
6410 ok(r
==TIMER_ID
,"SetTimer id different\n");
6411 r
= SetEvent(info
->handles
[0]);
6412 ok(r
,"SetEvent failed in thread\n");
6416 static void test_timers(void)
6418 struct timer_info info
;
6421 info
.hWnd
= CreateWindow ("TestWindowClass", NULL
,
6422 WS_OVERLAPPEDWINDOW
,
6423 CW_USEDEFAULT
, CW_USEDEFAULT
, 300, 300, 0,
6426 info
.id
= SetTimer(info
.hWnd
,TIMER_ID
,10000,tfunc
);
6427 ok(info
.id
, "SetTimer failed\n");
6428 ok(info
.id
==TIMER_ID
, "SetTimer timer ID different\n");
6429 info
.handles
[0] = CreateEvent(NULL
,0,0,NULL
);
6430 info
.handles
[1] = CreateThread(NULL
,0,timer_thread_proc
,&info
,0,&id
);
6432 WaitForMultipleObjects(2, info
.handles
, FALSE
, INFINITE
);
6434 WaitForSingleObject(info
.handles
[1], INFINITE
);
6436 CloseHandle(info
.handles
[0]);
6437 CloseHandle(info
.handles
[1]);
6439 ok( KillTimer(info
.hWnd
, TIMER_ID
), "KillTimer failed\n");
6441 ok(DestroyWindow(info
.hWnd
), "failed to destroy window\n");
6444 /* Various win events with arbitrary parameters */
6445 static const struct message WmWinEventsSeq
[] = {
6446 { EVENT_SYSTEM_SOUND
, winevent_hook
|wparam
|lparam
, OBJID_WINDOW
, 0 },
6447 { EVENT_SYSTEM_ALERT
, winevent_hook
|wparam
|lparam
, OBJID_SYSMENU
, 1 },
6448 { EVENT_SYSTEM_FOREGROUND
, winevent_hook
|wparam
|lparam
, OBJID_TITLEBAR
, 2 },
6449 { EVENT_SYSTEM_MENUSTART
, winevent_hook
|wparam
|lparam
, OBJID_MENU
, 3 },
6450 { EVENT_SYSTEM_MENUEND
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 4 },
6451 { EVENT_SYSTEM_MENUPOPUPSTART
, winevent_hook
|wparam
|lparam
, OBJID_VSCROLL
, 5 },
6452 { EVENT_SYSTEM_MENUPOPUPEND
, winevent_hook
|wparam
|lparam
, OBJID_HSCROLL
, 6 },
6453 { EVENT_SYSTEM_CAPTURESTART
, winevent_hook
|wparam
|lparam
, OBJID_SIZEGRIP
, 7 },
6454 { EVENT_SYSTEM_CAPTUREEND
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 8 },
6455 /* our win event hook ignores OBJID_CURSOR events */
6456 /*{ EVENT_SYSTEM_MOVESIZESTART, winevent_hook|wparam|lparam, OBJID_CURSOR, 9 },*/
6457 { EVENT_SYSTEM_MOVESIZEEND
, winevent_hook
|wparam
|lparam
, OBJID_ALERT
, 10 },
6458 { EVENT_SYSTEM_CONTEXTHELPSTART
, winevent_hook
|wparam
|lparam
, OBJID_SOUND
, 11 },
6459 { EVENT_SYSTEM_CONTEXTHELPEND
, winevent_hook
|wparam
|lparam
, OBJID_QUERYCLASSNAMEIDX
, 12 },
6460 { EVENT_SYSTEM_DRAGDROPSTART
, winevent_hook
|wparam
|lparam
, OBJID_NATIVEOM
, 13 },
6461 { EVENT_SYSTEM_DRAGDROPEND
, winevent_hook
|wparam
|lparam
, OBJID_WINDOW
, 0 },
6462 { EVENT_SYSTEM_DIALOGSTART
, winevent_hook
|wparam
|lparam
, OBJID_SYSMENU
, 1 },
6463 { EVENT_SYSTEM_DIALOGEND
, winevent_hook
|wparam
|lparam
, OBJID_TITLEBAR
, 2 },
6464 { EVENT_SYSTEM_SCROLLINGSTART
, winevent_hook
|wparam
|lparam
, OBJID_MENU
, 3 },
6465 { EVENT_SYSTEM_SCROLLINGEND
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 4 },
6466 { EVENT_SYSTEM_SWITCHSTART
, winevent_hook
|wparam
|lparam
, OBJID_VSCROLL
, 5 },
6467 { EVENT_SYSTEM_SWITCHEND
, winevent_hook
|wparam
|lparam
, OBJID_HSCROLL
, 6 },
6468 { EVENT_SYSTEM_MINIMIZESTART
, winevent_hook
|wparam
|lparam
, OBJID_SIZEGRIP
, 7 },
6469 { EVENT_SYSTEM_MINIMIZEEND
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 8 },
6472 static const struct message WmWinEventCaretSeq
[] = {
6473 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 }, /* hook 1 */
6474 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 }, /* hook 1 */
6475 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 }, /* hook 2 */
6476 { EVENT_OBJECT_NAMECHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 }, /* hook 1 */
6479 static const struct message WmWinEventCaretSeq_2
[] = {
6480 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 }, /* hook 1/2 */
6481 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 }, /* hook 1/2 */
6482 { EVENT_OBJECT_NAMECHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 }, /* hook 1/2 */
6485 static const struct message WmWinEventAlertSeq
[] = {
6486 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_ALERT
, 0 },
6489 static const struct message WmWinEventAlertSeq_2
[] = {
6490 /* create window in the thread proc */
6491 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, OBJID_WINDOW
, 2 },
6492 /* our test event */
6493 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_ALERT
, 2 },
6496 static const struct message WmGlobalHookSeq_1
[] = {
6497 /* create window in the thread proc */
6498 { HCBT_CREATEWND
, hook
|lparam
, 0, 2 },
6499 /* our test events */
6500 { HCBT_SYSCOMMAND
, hook
|wparam
|lparam
, SC_PREVWINDOW
, 2 },
6501 { HCBT_SYSCOMMAND
, hook
|wparam
|lparam
, SC_NEXTWINDOW
, 2 },
6504 static const struct message WmGlobalHookSeq_2
[] = {
6505 { HCBT_SYSCOMMAND
, hook
|wparam
|lparam
, SC_NEXTWINDOW
, 0 }, /* old local hook */
6506 { HCBT_SYSCOMMAND
, hook
|wparam
|lparam
, SC_NEXTWINDOW
, 2 }, /* new global hook */
6507 { HCBT_SYSCOMMAND
, hook
|wparam
|lparam
, SC_PREVWINDOW
, 0 }, /* old local hook */
6508 { HCBT_SYSCOMMAND
, hook
|wparam
|lparam
, SC_PREVWINDOW
, 2 }, /* new global hook */
6512 static const struct message WmMouseLLHookSeq
[] = {
6513 { WM_MOUSEMOVE
, hook
},
6514 { WM_LBUTTONUP
, hook
},
6515 { WM_MOUSEMOVE
, hook
},
6519 static void CALLBACK
win_event_global_hook_proc(HWINEVENTHOOK hevent
,
6529 trace("WEH_2:%p,event %08x,hwnd %p,obj %08x,id %08x,thread %08x,time %08x\n",
6530 hevent
, event
, hwnd
, object_id
, child_id
, thread_id
, event_time
);
6532 if (GetClassNameA(hwnd
, buf
, sizeof(buf
)))
6534 if (!lstrcmpiA(buf
, "TestWindowClass") ||
6535 !lstrcmpiA(buf
, "static"))
6539 msg
.message
= event
;
6540 msg
.flags
= winevent_hook
|wparam
|lparam
;
6541 msg
.wParam
= object_id
;
6542 msg
.lParam
= (thread_id
== GetCurrentThreadId()) ? child_id
: (child_id
+ 2);
6548 static HHOOK hCBT_global_hook
;
6549 static DWORD cbt_global_hook_thread_id
;
6551 static LRESULT CALLBACK
cbt_global_hook_proc(int nCode
, WPARAM wParam
, LPARAM lParam
)
6556 trace("CBT_2: %d, %08x, %08lx\n", nCode
, wParam
, lParam
);
6558 if (nCode
== HCBT_SYSCOMMAND
)
6562 msg
.message
= nCode
;
6563 msg
.flags
= hook
|wparam
|lparam
;
6564 msg
.wParam
= wParam
;
6565 msg
.lParam
= (cbt_global_hook_thread_id
== GetCurrentThreadId()) ? 1 : 2;
6568 return CallNextHookEx(hCBT_global_hook
, nCode
, wParam
, lParam
);
6570 /* WH_MOUSE_LL hook */
6571 if (nCode
== HC_ACTION
)
6574 MSLLHOOKSTRUCT
*mhll
= (MSLLHOOKSTRUCT
*)lParam
;
6576 /* we can't test for real mouse events */
6577 if (mhll
->flags
& LLMHF_INJECTED
)
6579 msg
.message
= wParam
;
6583 return CallNextHookEx(hCBT_global_hook
, nCode
, wParam
, lParam
);
6586 /* Log also SetFocus(0) calls */
6587 hwnd
= wParam
? (HWND
)wParam
: (HWND
)lParam
;
6589 if (GetClassNameA(hwnd
, buf
, sizeof(buf
)))
6591 if (!lstrcmpiA(buf
, "TestWindowClass") ||
6592 !lstrcmpiA(buf
, "static"))
6596 msg
.message
= nCode
;
6597 msg
.flags
= hook
|wparam
|lparam
;
6598 msg
.wParam
= wParam
;
6599 msg
.lParam
= (cbt_global_hook_thread_id
== GetCurrentThreadId()) ? 1 : 2;
6603 return CallNextHookEx(hCBT_global_hook
, nCode
, wParam
, lParam
);
6606 static DWORD WINAPI
win_event_global_thread_proc(void *param
)
6610 HANDLE hevent
= *(HANDLE
*)param
;
6611 HMODULE user32
= GetModuleHandleA("user32.dll");
6612 FARPROC pNotifyWinEvent
= GetProcAddress(user32
, "NotifyWinEvent");
6614 assert(pNotifyWinEvent
);
6616 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
, 0,0,0,0,0,0,0, NULL
);
6618 trace("created thread window %p\n", hwnd
);
6620 *(HWND
*)param
= hwnd
;
6623 /* this event should be received only by our new hook proc,
6624 * an old one does not expect an event from another thread.
6626 pNotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE
, hwnd
, OBJID_ALERT
, 0);
6629 while (GetMessage(&msg
, 0, 0, 0))
6631 TranslateMessage(&msg
);
6632 DispatchMessage(&msg
);
6637 static DWORD WINAPI
cbt_global_hook_thread_proc(void *param
)
6641 HANDLE hevent
= *(HANDLE
*)param
;
6644 /* these events should be received only by our new hook proc,
6645 * an old one does not expect an event from another thread.
6648 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
, 0,0,0,0,0,0,0, NULL
);
6650 trace("created thread window %p\n", hwnd
);
6652 *(HWND
*)param
= hwnd
;
6654 /* Windows doesn't like when a thread plays games with the focus,
6655 that leads to all kinds of misbehaviours and failures to activate
6656 a window. So, better keep next lines commented out.
6660 DefWindowProcA(hwnd
, WM_SYSCOMMAND
, SC_PREVWINDOW
, 0);
6661 DefWindowProcA(hwnd
, WM_SYSCOMMAND
, SC_NEXTWINDOW
, 0);
6665 while (GetMessage(&msg
, 0, 0, 0))
6667 TranslateMessage(&msg
);
6668 DispatchMessage(&msg
);
6673 static DWORD WINAPI
mouse_ll_global_thread_proc(void *param
)
6677 HANDLE hevent
= *(HANDLE
*)param
;
6679 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
, 0,0,0,0,0,0,0, NULL
);
6681 trace("created thread window %p\n", hwnd
);
6683 *(HWND
*)param
= hwnd
;
6687 /* Windows doesn't like when a thread plays games with the focus,
6688 * that leads to all kinds of misbehaviours and failures to activate
6689 * a window. So, better don't generate a mouse click message below.
6691 mouse_event(MOUSEEVENTF_MOVE
, -1, 0, 0, 0);
6692 mouse_event(MOUSEEVENTF_LEFTUP
, 0, 0, 0, 0);
6693 mouse_event(MOUSEEVENTF_MOVE
, 1, 0, 0, 0);
6696 while (GetMessage(&msg
, 0, 0, 0))
6698 TranslateMessage(&msg
);
6699 DispatchMessage(&msg
);
6704 static void test_winevents(void)
6710 HANDLE hthread
, hevent
;
6712 HWINEVENTHOOK hhook
;
6713 const struct message
*events
= WmWinEventsSeq
;
6714 HMODULE user32
= GetModuleHandleA("user32.dll");
6715 FARPROC pSetWinEventHook
= GetProcAddress(user32
, "SetWinEventHook");
6716 FARPROC pUnhookWinEvent
= GetProcAddress(user32
, "UnhookWinEvent");
6717 FARPROC pNotifyWinEvent
= GetProcAddress(user32
, "NotifyWinEvent");
6719 hwnd
= CreateWindowExA(0, "TestWindowClass", NULL
,
6720 WS_OVERLAPPEDWINDOW
,
6721 CW_USEDEFAULT
, CW_USEDEFAULT
, 300, 300, 0,
6725 /****** start of global hook test *************/
6726 hCBT_global_hook
= SetWindowsHookExA(WH_CBT
, cbt_global_hook_proc
, GetModuleHandleA(0), 0);
6727 assert(hCBT_global_hook
);
6729 hevent
= CreateEventA(NULL
, 0, 0, NULL
);
6731 hwnd2
= (HWND
)hevent
;
6733 hthread
= CreateThread(NULL
, 0, cbt_global_hook_thread_proc
, &hwnd2
, 0, &tid
);
6734 ok(hthread
!= NULL
, "CreateThread failed, error %d\n", GetLastError());
6736 ok(WaitForSingleObject(hevent
, INFINITE
) == WAIT_OBJECT_0
, "WaitForSingleObject failed\n");
6738 ok_sequence(WmGlobalHookSeq_1
, "global hook 1", FALSE
);
6741 /* this one should be received only by old hook proc */
6742 DefWindowProcA(hwnd
, WM_SYSCOMMAND
, SC_NEXTWINDOW
, 0);
6743 /* this one should be received only by old hook proc */
6744 DefWindowProcA(hwnd
, WM_SYSCOMMAND
, SC_PREVWINDOW
, 0);
6746 ok_sequence(WmGlobalHookSeq_2
, "global hook 2", FALSE
);
6748 ret
= UnhookWindowsHookEx(hCBT_global_hook
);
6749 ok( ret
, "UnhookWindowsHookEx error %d\n", GetLastError());
6751 PostThreadMessageA(tid
, WM_QUIT
, 0, 0);
6752 ok(WaitForSingleObject(hthread
, INFINITE
) == WAIT_OBJECT_0
, "WaitForSingleObject failed\n");
6753 CloseHandle(hthread
);
6754 CloseHandle(hevent
);
6755 ok(!IsWindow(hwnd2
), "window should be destroyed on thread exit\n");
6756 /****** end of global hook test *************/
6758 if (!pSetWinEventHook
|| !pNotifyWinEvent
|| !pUnhookWinEvent
)
6760 ok(DestroyWindow(hwnd
), "failed to destroy window\n");
6768 /* this test doesn't pass under Win9x */
6769 /* win2k ignores events with hwnd == 0 */
6770 SetLastError(0xdeadbeef);
6771 pNotifyWinEvent(events
[0].message
, 0, events
[0].wParam
, events
[0].lParam
);
6772 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE
|| /* Win2k */
6773 GetLastError() == 0xdeadbeef, /* Win9x */
6774 "unexpected error %d\n", GetLastError());
6775 ok_sequence(WmEmptySeq
, "empty notify winevents", FALSE
);
6778 for (i
= 0; i
< sizeof(WmWinEventsSeq
)/sizeof(WmWinEventsSeq
[0]); i
++)
6779 pNotifyWinEvent(events
[i
].message
, hwnd
, events
[i
].wParam
, events
[i
].lParam
);
6781 ok_sequence(WmWinEventsSeq
, "notify winevents", FALSE
);
6783 /****** start of event filtering test *************/
6784 hhook
= (HWINEVENTHOOK
)pSetWinEventHook(
6785 EVENT_OBJECT_SHOW
, /* 0x8002 */
6786 EVENT_OBJECT_LOCATIONCHANGE
, /* 0x800B */
6787 GetModuleHandleA(0), win_event_global_hook_proc
,
6788 GetCurrentProcessId(), 0,
6789 WINEVENT_INCONTEXT
);
6790 ok(hhook
!= 0, "SetWinEventHook error %d\n", GetLastError());
6792 hevent
= CreateEventA(NULL
, 0, 0, NULL
);
6794 hwnd2
= (HWND
)hevent
;
6796 hthread
= CreateThread(NULL
, 0, win_event_global_thread_proc
, &hwnd2
, 0, &tid
);
6797 ok(hthread
!= NULL
, "CreateThread failed, error %d\n", GetLastError());
6799 ok(WaitForSingleObject(hevent
, INFINITE
) == WAIT_OBJECT_0
, "WaitForSingleObject failed\n");
6801 ok_sequence(WmWinEventAlertSeq
, "alert winevent", FALSE
);
6804 /* this one should be received only by old hook proc */
6805 pNotifyWinEvent(EVENT_OBJECT_CREATE
, hwnd
, OBJID_CARET
, 0); /* 0x8000 */
6806 pNotifyWinEvent(EVENT_OBJECT_SHOW
, hwnd
, OBJID_CARET
, 0); /* 0x8002 */
6807 /* this one should be received only by old hook proc */
6808 pNotifyWinEvent(EVENT_OBJECT_NAMECHANGE
, hwnd
, OBJID_CARET
, 0); /* 0x800C */
6810 ok_sequence(WmWinEventCaretSeq
, "caret winevent", FALSE
);
6812 ret
= pUnhookWinEvent(hhook
);
6813 ok( ret
, "UnhookWinEvent error %d\n", GetLastError());
6815 PostThreadMessageA(tid
, WM_QUIT
, 0, 0);
6816 ok(WaitForSingleObject(hthread
, INFINITE
) == WAIT_OBJECT_0
, "WaitForSingleObject failed\n");
6817 CloseHandle(hthread
);
6818 CloseHandle(hevent
);
6819 ok(!IsWindow(hwnd2
), "window should be destroyed on thread exit\n");
6820 /****** end of event filtering test *************/
6822 /****** start of out of context event test *************/
6823 hhook
= (HWINEVENTHOOK
)pSetWinEventHook(
6824 EVENT_MIN
, EVENT_MAX
,
6825 0, win_event_global_hook_proc
,
6826 GetCurrentProcessId(), 0,
6827 WINEVENT_OUTOFCONTEXT
);
6828 ok(hhook
!= 0, "SetWinEventHook error %d\n", GetLastError());
6830 hevent
= CreateEventA(NULL
, 0, 0, NULL
);
6832 hwnd2
= (HWND
)hevent
;
6836 hthread
= CreateThread(NULL
, 0, win_event_global_thread_proc
, &hwnd2
, 0, &tid
);
6837 ok(hthread
!= NULL
, "CreateThread failed, error %d\n", GetLastError());
6839 ok(WaitForSingleObject(hevent
, INFINITE
) == WAIT_OBJECT_0
, "WaitForSingleObject failed\n");
6841 ok_sequence(WmEmptySeq
, "empty notify winevents", FALSE
);
6842 /* process pending winevent messages */
6843 ok(!PeekMessageA(&msg
, 0, 0, 0, PM_NOREMOVE
), "msg queue should be empty\n");
6844 ok_sequence(WmWinEventAlertSeq_2
, "alert winevent for out of context proc", FALSE
);
6847 /* this one should be received only by old hook proc */
6848 pNotifyWinEvent(EVENT_OBJECT_CREATE
, hwnd
, OBJID_CARET
, 0); /* 0x8000 */
6849 pNotifyWinEvent(EVENT_OBJECT_SHOW
, hwnd
, OBJID_CARET
, 0); /* 0x8002 */
6850 /* this one should be received only by old hook proc */
6851 pNotifyWinEvent(EVENT_OBJECT_NAMECHANGE
, hwnd
, OBJID_CARET
, 0); /* 0x800C */
6853 ok_sequence(WmWinEventCaretSeq_2
, "caret winevent for incontext proc", FALSE
);
6854 /* process pending winevent messages */
6855 ok(!PeekMessageA(&msg
, 0, 0, 0, PM_NOREMOVE
), "msg queue should be empty\n");
6856 ok_sequence(WmWinEventCaretSeq_2
, "caret winevent for out of context proc", FALSE
);
6858 ret
= pUnhookWinEvent(hhook
);
6859 ok( ret
, "UnhookWinEvent error %d\n", GetLastError());
6861 PostThreadMessageA(tid
, WM_QUIT
, 0, 0);
6862 ok(WaitForSingleObject(hthread
, INFINITE
) == WAIT_OBJECT_0
, "WaitForSingleObject failed\n");
6863 CloseHandle(hthread
);
6864 CloseHandle(hevent
);
6865 ok(!IsWindow(hwnd2
), "window should be destroyed on thread exit\n");
6866 /****** end of out of context event test *************/
6868 /****** start of MOUSE_LL hook test *************/
6869 hCBT_global_hook
= SetWindowsHookExA(WH_MOUSE_LL
, cbt_global_hook_proc
, GetModuleHandleA(0), 0);
6870 /* WH_MOUSE_LL is not supported on Win9x platforms */
6871 if (!hCBT_global_hook
)
6873 trace("Skipping WH_MOUSE_LL test on this platform\n");
6874 goto skip_mouse_ll_hook_test
;
6877 hevent
= CreateEventA(NULL
, 0, 0, NULL
);
6879 hwnd2
= (HWND
)hevent
;
6881 hthread
= CreateThread(NULL
, 0, mouse_ll_global_thread_proc
, &hwnd2
, 0, &tid
);
6882 ok(hthread
!= NULL
, "CreateThread failed, error %d\n", GetLastError());
6884 while (WaitForSingleObject(hevent
, 100) == WAIT_TIMEOUT
)
6885 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
6887 ok_sequence(WmMouseLLHookSeq
, "MOUSE_LL hook other thread", FALSE
);
6890 mouse_event(MOUSEEVENTF_MOVE
, -1, 0, 0, 0);
6891 mouse_event(MOUSEEVENTF_LEFTUP
, 0, 0, 0, 0);
6892 mouse_event(MOUSEEVENTF_MOVE
, 1, 0, 0, 0);
6894 ok_sequence(WmMouseLLHookSeq
, "MOUSE_LL hook same thread", FALSE
);
6896 ret
= UnhookWindowsHookEx(hCBT_global_hook
);
6897 ok( ret
, "UnhookWindowsHookEx error %d\n", GetLastError());
6899 PostThreadMessageA(tid
, WM_QUIT
, 0, 0);
6900 ok(WaitForSingleObject(hthread
, INFINITE
) == WAIT_OBJECT_0
, "WaitForSingleObject failed\n");
6901 CloseHandle(hthread
);
6902 CloseHandle(hevent
);
6903 ok(!IsWindow(hwnd2
), "window should be destroyed on thread exit\n");
6904 /****** end of MOUSE_LL hook test *************/
6905 skip_mouse_ll_hook_test
:
6907 ok(DestroyWindow(hwnd
), "failed to destroy window\n");
6910 static void test_set_hook(void)
6914 HWINEVENTHOOK hwinevent_hook
;
6915 HMODULE user32
= GetModuleHandleA("user32.dll");
6916 FARPROC pSetWinEventHook
= GetProcAddress(user32
, "SetWinEventHook");
6917 FARPROC pUnhookWinEvent
= GetProcAddress(user32
, "UnhookWinEvent");
6919 hhook
= SetWindowsHookExA(WH_CBT
, cbt_hook_proc
, GetModuleHandleA(0), GetCurrentThreadId());
6920 ok(hhook
!= 0, "local hook does not require hModule set to 0\n");
6921 UnhookWindowsHookEx(hhook
);
6925 /* this test doesn't pass under Win9x: BUG! */
6926 SetLastError(0xdeadbeef);
6927 hhook
= SetWindowsHookExA(WH_CBT
, cbt_hook_proc
, 0, 0);
6928 ok(!hhook
, "global hook requires hModule != 0\n");
6929 ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD
, "unexpected error %d\n", GetLastError());
6932 SetLastError(0xdeadbeef);
6933 hhook
= SetWindowsHookExA(WH_CBT
, 0, GetModuleHandleA(0), GetCurrentThreadId());
6934 ok(!hhook
, "SetWinEventHook with invalid proc should fail\n");
6935 ok(GetLastError() == ERROR_INVALID_FILTER_PROC
|| /* Win2k */
6936 GetLastError() == 0xdeadbeef, /* Win9x */
6937 "unexpected error %d\n", GetLastError());
6939 SetLastError(0xdeadbeef);
6940 ok(!UnhookWindowsHookEx((HHOOK
)0xdeadbeef), "UnhookWindowsHookEx succeeded\n");
6941 ok(GetLastError() == ERROR_INVALID_HOOK_HANDLE
|| /* Win2k */
6942 GetLastError() == 0xdeadbeef, /* Win9x */
6943 "unexpected error %d\n", GetLastError());
6945 if (!pSetWinEventHook
|| !pUnhookWinEvent
) return;
6947 /* even process local incontext hooks require hmodule */
6948 SetLastError(0xdeadbeef);
6949 hwinevent_hook
= (HWINEVENTHOOK
)pSetWinEventHook(EVENT_MIN
, EVENT_MAX
,
6950 0, win_event_proc
, GetCurrentProcessId(), 0, WINEVENT_INCONTEXT
);
6951 ok(!hwinevent_hook
, "WINEVENT_INCONTEXT requires hModule != 0\n");
6952 ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD
|| /* Win2k */
6953 GetLastError() == 0xdeadbeef, /* Win9x */
6954 "unexpected error %d\n", GetLastError());
6956 /* even thread local incontext hooks require hmodule */
6957 SetLastError(0xdeadbeef);
6958 hwinevent_hook
= (HWINEVENTHOOK
)pSetWinEventHook(EVENT_MIN
, EVENT_MAX
,
6959 0, win_event_proc
, GetCurrentProcessId(), GetCurrentThreadId(), WINEVENT_INCONTEXT
);
6960 ok(!hwinevent_hook
, "WINEVENT_INCONTEXT requires hModule != 0\n");
6961 ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD
|| /* Win2k */
6962 GetLastError() == 0xdeadbeef, /* Win9x */
6963 "unexpected error %d\n", GetLastError());
6967 /* these 3 tests don't pass under Win9x */
6968 SetLastError(0xdeadbeef);
6969 hwinevent_hook
= (HWINEVENTHOOK
)pSetWinEventHook(1, 0,
6970 0, win_event_proc
, GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT
);
6971 ok(!hwinevent_hook
, "SetWinEventHook with invalid event range should fail\n");
6972 ok(GetLastError() == ERROR_INVALID_HOOK_FILTER
, "unexpected error %d\n", GetLastError());
6974 SetLastError(0xdeadbeef);
6975 hwinevent_hook
= (HWINEVENTHOOK
)pSetWinEventHook(-1, 1,
6976 0, win_event_proc
, GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT
);
6977 ok(!hwinevent_hook
, "SetWinEventHook with invalid event range should fail\n");
6978 ok(GetLastError() == ERROR_INVALID_HOOK_FILTER
, "unexpected error %d\n", GetLastError());
6980 SetLastError(0xdeadbeef);
6981 hwinevent_hook
= (HWINEVENTHOOK
)pSetWinEventHook(EVENT_MIN
, EVENT_MAX
,
6982 0, win_event_proc
, 0, 0xdeadbeef, WINEVENT_OUTOFCONTEXT
);
6983 ok(!hwinevent_hook
, "SetWinEventHook with invalid tid should fail\n");
6984 ok(GetLastError() == ERROR_INVALID_THREAD_ID
, "unexpected error %d\n", GetLastError());
6987 SetLastError(0xdeadbeef);
6988 hwinevent_hook
= (HWINEVENTHOOK
)pSetWinEventHook(0, 0,
6989 0, win_event_proc
, GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT
);
6990 ok(hwinevent_hook
!= 0, "SetWinEventHook error %d\n", GetLastError());
6991 ok(GetLastError() == 0xdeadbeef, "unexpected error %d\n", GetLastError());
6992 ret
= pUnhookWinEvent(hwinevent_hook
);
6993 ok( ret
, "UnhookWinEvent error %d\n", GetLastError());
6996 /* This call succeeds under win2k SP4, but fails under Wine.
6997 Does win2k test/use passed process id? */
6998 SetLastError(0xdeadbeef);
6999 hwinevent_hook
= (HWINEVENTHOOK
)pSetWinEventHook(EVENT_MIN
, EVENT_MAX
,
7000 0, win_event_proc
, 0xdeadbeef, 0, WINEVENT_OUTOFCONTEXT
);
7001 ok(hwinevent_hook
!= 0, "SetWinEventHook error %d\n", GetLastError());
7002 ok(GetLastError() == 0xdeadbeef, "unexpected error %d\n", GetLastError());
7003 ret
= pUnhookWinEvent(hwinevent_hook
);
7004 ok( ret
, "UnhookWinEvent error %d\n", GetLastError());
7007 SetLastError(0xdeadbeef);
7008 ok(!pUnhookWinEvent((HWINEVENTHOOK
)0xdeadbeef), "UnhookWinEvent succeeded\n");
7009 ok(GetLastError() == ERROR_INVALID_HANDLE
|| /* Win2k */
7010 GetLastError() == 0xdeadbeef, /* Win9x */
7011 "unexpected error %d\n", GetLastError());
7014 static const struct message ScrollWindowPaint1
[] = {
7016 { WM_ERASEBKGND
, sent
|beginpaint
},
7020 static const struct message ScrollWindowPaint2
[] = {
7025 static void test_scrollwindowex(void)
7028 RECT rect
={0,0,130,130};
7031 hwnd
= CreateWindowExA(0, "TestWindowClass", "Test Scroll",
7032 WS_VISIBLE
|WS_OVERLAPPEDWINDOW
,
7033 100, 100, 200, 200, 0, 0, 0, NULL
);
7034 ok (hwnd
!= 0, "Failed to create overlapped window\n");
7035 hchild
= CreateWindowExA(0, "TestWindowClass", "Test child",
7036 WS_VISIBLE
|WS_CAPTION
|WS_CHILD
,
7037 10, 10, 150, 150, hwnd
, 0, 0, NULL
);
7038 ok (hchild
!= 0, "Failed to create child\n");
7043 /* scroll without the child window */
7044 trace("start scroll\n");
7045 ScrollWindowEx( hwnd
, 10, 10, &rect
, NULL
, NULL
, NULL
,
7046 SW_ERASE
|SW_INVALIDATE
);
7047 ok_sequence(WmEmptySeq
, "ScrollWindowEx", 0);
7048 trace("end scroll\n");
7050 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
7051 ok_sequence(ScrollWindowPaint1
, "ScrollWindowEx", 0);
7055 /* Now without the SW_ERASE flag */
7056 trace("start scroll\n");
7057 ScrollWindowEx( hwnd
, 10, 10, &rect
, NULL
, NULL
, NULL
, SW_INVALIDATE
);
7058 ok_sequence(WmEmptySeq
, "ScrollWindowEx", 0);
7059 trace("end scroll\n");
7061 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
7062 ok_sequence(ScrollWindowPaint2
, "ScrollWindowEx", 0);
7066 /* now scroll the child window as well */
7067 trace("start scroll\n");
7068 ScrollWindowEx( hwnd
, 10, 10, &rect
, NULL
, NULL
, NULL
,
7069 SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
7070 todo_wine
{ /* wine sends WM_POSCHANGING, WM_POSCHANGED messages */
7071 /* windows sometimes a WM_MOVE */
7072 ok_sequence(WmEmptySeq
, "ScrollWindowEx", 0);
7074 trace("end scroll\n");
7076 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
7077 ok_sequence(ScrollWindowPaint1
, "ScrollWindowEx", 0);
7081 /* now scroll with ScrollWindow() */
7082 trace("start scroll with ScrollWindow\n");
7083 ScrollWindow( hwnd
, 5, 5, NULL
, NULL
);
7084 trace("end scroll\n");
7086 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
7087 ok_sequence(ScrollWindowPaint1
, "ScrollWindow", 0);
7089 ok(DestroyWindow(hchild
), "failed to destroy window\n");
7090 ok(DestroyWindow(hwnd
), "failed to destroy window\n");
7094 static const struct message destroy_window_with_children
[] = {
7095 { EVENT_SYSTEM_CAPTURESTART
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* popup */
7096 { HCBT_DESTROYWND
, hook
|lparam
, 0, WND_PARENT_ID
}, /* parent */
7097 { HCBT_DESTROYWND
, hook
|lparam
, 0, WND_POPUP_ID
}, /* popup */
7098 { EVENT_OBJECT_DESTROY
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* popup */
7099 { WM_DESTROY
, sent
|wparam
|lparam
, 0, WND_POPUP_ID
}, /* popup */
7100 { WM_CAPTURECHANGED
, sent
|wparam
|lparam
, 0, WND_POPUP_ID
}, /* popup */
7101 { WM_NCDESTROY
, sent
|wparam
|lparam
, 0, WND_POPUP_ID
}, /* popup */
7102 { EVENT_OBJECT_DESTROY
, winevent_hook
|wparam
|lparam
, 0, 0 }, /* parent */
7103 { WM_DESTROY
, sent
|wparam
|lparam
, 0, WND_PARENT_ID
}, /* parent */
7104 { WM_DESTROY
, sent
|wparam
|lparam
, 0, WND_CHILD_ID
+ 2 }, /* child2 */
7105 { WM_DESTROY
, sent
|wparam
|lparam
, 0, WND_CHILD_ID
+ 1 }, /* child1 */
7106 { WM_DESTROY
, sent
|wparam
|lparam
, 0, WND_CHILD_ID
+ 3 }, /* child3 */
7107 { WM_NCDESTROY
, sent
|wparam
|lparam
, 0, WND_CHILD_ID
+ 2 }, /* child2 */
7108 { WM_NCDESTROY
, sent
|wparam
|lparam
, 0, WND_CHILD_ID
+ 3 }, /* child3 */
7109 { WM_NCDESTROY
, sent
|wparam
|lparam
, 0, WND_CHILD_ID
+ 1 }, /* child1 */
7110 { WM_NCDESTROY
, sent
|wparam
|lparam
, 0, WND_PARENT_ID
}, /* parent */
7114 static void test_DestroyWindow(void)
7117 HWND parent
, child1
, child2
, child3
, child4
, test
;
7118 UINT child_id
= WND_CHILD_ID
+ 1;
7120 parent
= CreateWindowExA(0, "TestWindowClass", NULL
, WS_OVERLAPPEDWINDOW
,
7121 100, 100, 200, 200, 0, 0, 0, NULL
);
7122 assert(parent
!= 0);
7123 child1
= CreateWindowExA(0, "TestWindowClass", NULL
, WS_CHILD
,
7124 0, 0, 50, 50, parent
, (HMENU
)child_id
++, 0, NULL
);
7125 assert(child1
!= 0);
7126 child2
= CreateWindowExA(0, "TestWindowClass", NULL
, WS_CHILD
,
7127 0, 0, 50, 50, GetDesktopWindow(), (HMENU
)child_id
++, 0, NULL
);
7128 assert(child2
!= 0);
7129 child3
= CreateWindowExA(0, "TestWindowClass", NULL
, WS_CHILD
,
7130 0, 0, 50, 50, child1
, (HMENU
)child_id
++, 0, NULL
);
7131 assert(child3
!= 0);
7132 child4
= CreateWindowExA(0, "TestWindowClass", NULL
, WS_POPUP
,
7133 0, 0, 50, 50, parent
, 0, 0, NULL
);
7134 assert(child4
!= 0);
7136 /* test owner/parent of child2 */
7137 test
= GetParent(child2
);
7138 ok(test
== GetDesktopWindow(), "wrong parent %p\n", test
);
7139 ok(!IsChild(parent
, child2
), "wrong parent/child %p/%p\n", parent
, child2
);
7141 test
= pGetAncestor(child2
, GA_PARENT
);
7142 ok(test
== GetDesktopWindow(), "wrong parent %p\n", test
);
7144 test
= GetWindow(child2
, GW_OWNER
);
7145 ok(!test
, "wrong owner %p\n", test
);
7147 test
= SetParent(child2
, parent
);
7148 ok(test
== GetDesktopWindow(), "wrong old parent %p\n", test
);
7150 /* test owner/parent of the parent */
7151 test
= GetParent(parent
);
7152 ok(!test
, "wrong parent %p\n", test
);
7154 ok(!IsChild(GetDesktopWindow(), parent
), "wrong parent/child %p/%p\n", GetDesktopWindow(), parent
);
7157 test
= pGetAncestor(parent
, GA_PARENT
);
7158 ok(test
== GetDesktopWindow(), "wrong parent %p\n", test
);
7160 test
= GetWindow(parent
, GW_OWNER
);
7161 ok(!test
, "wrong owner %p\n", test
);
7163 /* test owner/parent of child1 */
7164 test
= GetParent(child1
);
7165 ok(test
== parent
, "wrong parent %p\n", test
);
7166 ok(IsChild(parent
, child1
), "wrong parent/child %p/%p\n", parent
, child1
);
7168 test
= pGetAncestor(child1
, GA_PARENT
);
7169 ok(test
== parent
, "wrong parent %p\n", test
);
7171 test
= GetWindow(child1
, GW_OWNER
);
7172 ok(!test
, "wrong owner %p\n", test
);
7174 /* test owner/parent of child2 */
7175 test
= GetParent(child2
);
7176 ok(test
== parent
, "wrong parent %p\n", test
);
7177 ok(IsChild(parent
, child2
), "wrong parent/child %p/%p\n", parent
, child2
);
7179 test
= pGetAncestor(child2
, GA_PARENT
);
7180 ok(test
== parent
, "wrong parent %p\n", test
);
7182 test
= GetWindow(child2
, GW_OWNER
);
7183 ok(!test
, "wrong owner %p\n", test
);
7185 /* test owner/parent of child3 */
7186 test
= GetParent(child3
);
7187 ok(test
== child1
, "wrong parent %p\n", test
);
7188 ok(IsChild(parent
, child3
), "wrong parent/child %p/%p\n", parent
, child3
);
7190 test
= pGetAncestor(child3
, GA_PARENT
);
7191 ok(test
== child1
, "wrong parent %p\n", test
);
7193 test
= GetWindow(child3
, GW_OWNER
);
7194 ok(!test
, "wrong owner %p\n", test
);
7196 /* test owner/parent of child4 */
7197 test
= GetParent(child4
);
7198 ok(test
== parent
, "wrong parent %p\n", test
);
7199 ok(!IsChild(parent
, child4
), "wrong parent/child %p/%p\n", parent
, child4
);
7201 test
= pGetAncestor(child4
, GA_PARENT
);
7202 ok(test
== GetDesktopWindow(), "wrong parent %p\n", test
);
7204 test
= GetWindow(child4
, GW_OWNER
);
7205 ok(test
== parent
, "wrong owner %p\n", test
);
7209 trace("parent %p, child1 %p, child2 %p, child3 %p, child4 %p\n",
7210 parent
, child1
, child2
, child3
, child4
);
7213 test
= GetCapture();
7214 ok(test
== child4
, "wrong capture window %p\n", test
);
7216 test_DestroyWindow_flag
= TRUE
;
7217 ret
= DestroyWindow(parent
);
7218 ok( ret
, "DestroyWindow() error %d\n", GetLastError());
7219 test_DestroyWindow_flag
= FALSE
;
7220 ok_sequence(destroy_window_with_children
, "destroy window with children", 0);
7222 ok(!IsWindow(parent
), "parent still exists\n");
7223 ok(!IsWindow(child1
), "child1 still exists\n");
7224 ok(!IsWindow(child2
), "child2 still exists\n");
7225 ok(!IsWindow(child3
), "child3 still exists\n");
7226 ok(!IsWindow(child4
), "child4 still exists\n");
7228 test
= GetCapture();
7229 ok(!test
, "wrong capture window %p\n", test
);
7233 static const struct message WmDispatchPaint
[] = {
7234 { WM_NCPAINT
, sent
},
7235 { WM_GETTEXT
, sent
|defwinproc
|optional
},
7236 { WM_GETTEXT
, sent
|defwinproc
|optional
},
7237 { WM_ERASEBKGND
, sent
},
7241 static LRESULT WINAPI
DispatchMessageCheckProc(HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
7243 if (message
== WM_PAINT
) return 0;
7244 return MsgCheckProcA( hwnd
, message
, wParam
, lParam
);
7247 static void test_DispatchMessage(void)
7252 HWND hwnd
= CreateWindowA( "TestWindowClass", NULL
, WS_OVERLAPPEDWINDOW
,
7253 100, 100, 200, 200, 0, 0, 0, NULL
);
7254 ShowWindow( hwnd
, SW_SHOW
);
7255 UpdateWindow( hwnd
);
7256 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
7258 SetWindowLongPtrA( hwnd
, GWLP_WNDPROC
, (LONG_PTR
)DispatchMessageCheckProc
);
7260 SetRect( &rect
, -5, -5, 5, 5 );
7261 RedrawWindow( hwnd
, &rect
, 0, RDW_INVALIDATE
|RDW_ERASE
|RDW_FRAME
);
7263 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
))
7265 if (msg
.message
!= WM_PAINT
) DispatchMessage( &msg
);
7269 DispatchMessage( &msg
);
7270 /* DispatchMessage will send WM_NCPAINT if non client area is still invalid after WM_PAINT */
7271 if (!count
) ok_sequence( WmDispatchPaint
, "WmDispatchPaint", FALSE
);
7272 else ok_sequence( WmEmptySeq
, "WmEmpty", FALSE
);
7273 if (++count
> 10) break;
7276 ok( msg
.message
== WM_PAINT
&& count
> 10, "WM_PAINT messages stopped\n" );
7278 trace("now without DispatchMessage\n");
7280 RedrawWindow( hwnd
, &rect
, 0, RDW_INVALIDATE
|RDW_ERASE
|RDW_FRAME
);
7282 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
))
7284 if (msg
.message
!= WM_PAINT
) DispatchMessage( &msg
);
7287 HRGN hrgn
= CreateRectRgn( 0, 0, 0, 0 );
7289 /* this will send WM_NCCPAINT just like DispatchMessage does */
7290 GetUpdateRgn( hwnd
, hrgn
, TRUE
);
7291 ok_sequence( WmDispatchPaint
, "WmDispatchPaint", FALSE
);
7292 DeleteObject( hrgn
);
7293 GetClientRect( hwnd
, &rect
);
7294 ValidateRect( hwnd
, &rect
); /* this will stop WM_PAINTs */
7295 ok( !count
, "Got multiple WM_PAINTs\n" );
7296 if (++count
> 10) break;
7299 DestroyWindow(hwnd
);
7303 static const struct message WmUser
[] = {
7315 static DWORD CALLBACK
send_msg_thread( LPVOID arg
)
7317 struct sendmsg_info
*info
= arg
;
7318 info
->ret
= SendMessageTimeoutA( info
->hwnd
, WM_USER
, 0, 0, 0, info
->timeout
, NULL
);
7319 if (!info
->ret
) ok( GetLastError() == ERROR_TIMEOUT
, "unexpected error %d\n", GetLastError());
7323 static void wait_for_thread( HANDLE thread
)
7325 while (MsgWaitForMultipleObjects(1, &thread
, FALSE
, INFINITE
, QS_SENDMESSAGE
) != WAIT_OBJECT_0
)
7328 while (PeekMessageA( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage(&msg
);
7332 static LRESULT WINAPI
send_msg_delay_proc(HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
7334 if (message
== WM_USER
) Sleep(200);
7335 return MsgCheckProcA( hwnd
, message
, wParam
, lParam
);
7338 static void test_SendMessageTimeout(void)
7342 struct sendmsg_info info
;
7345 info
.hwnd
= CreateWindowA( "TestWindowClass", NULL
, WS_OVERLAPPEDWINDOW
,
7346 100, 100, 200, 200, 0, 0, 0, NULL
);
7347 while (PeekMessageA( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage( &msg
);
7350 info
.timeout
= 1000;
7351 info
.ret
= 0xdeadbeef;
7352 thread
= CreateThread( NULL
, 0, send_msg_thread
, &info
, 0, &tid
);
7353 wait_for_thread( thread
);
7354 CloseHandle( thread
);
7355 ok( info
.ret
== 1, "SendMessageTimeout failed\n" );
7356 ok_sequence( WmUser
, "WmUser", FALSE
);
7359 info
.ret
= 0xdeadbeef;
7360 thread
= CreateThread( NULL
, 0, send_msg_thread
, &info
, 0, &tid
);
7361 Sleep(100); /* SendMessageTimeout should timeout here */
7362 wait_for_thread( thread
);
7363 CloseHandle( thread
);
7364 ok( info
.ret
== 0, "SendMessageTimeout succeeded\n" );
7365 ok_sequence( WmEmptySeq
, "WmEmptySeq", FALSE
);
7367 /* 0 means infinite timeout */
7369 info
.ret
= 0xdeadbeef;
7370 thread
= CreateThread( NULL
, 0, send_msg_thread
, &info
, 0, &tid
);
7372 wait_for_thread( thread
);
7373 CloseHandle( thread
);
7374 ok( info
.ret
== 1, "SendMessageTimeout failed\n" );
7375 ok_sequence( WmUser
, "WmUser", FALSE
);
7377 /* timeout is treated as signed despite the prototype */
7378 info
.timeout
= 0x7fffffff;
7379 info
.ret
= 0xdeadbeef;
7380 thread
= CreateThread( NULL
, 0, send_msg_thread
, &info
, 0, &tid
);
7382 wait_for_thread( thread
);
7383 CloseHandle( thread
);
7384 ok( info
.ret
== 1, "SendMessageTimeout failed\n" );
7385 ok_sequence( WmUser
, "WmUser", FALSE
);
7387 info
.timeout
= 0x80000000;
7388 info
.ret
= 0xdeadbeef;
7389 thread
= CreateThread( NULL
, 0, send_msg_thread
, &info
, 0, &tid
);
7391 wait_for_thread( thread
);
7392 CloseHandle( thread
);
7393 ok( info
.ret
== 0, "SendMessageTimeout succeeded\n" );
7394 ok_sequence( WmEmptySeq
, "WmEmptySeq", FALSE
);
7396 /* now check for timeout during message processing */
7397 SetWindowLongPtrA( info
.hwnd
, GWLP_WNDPROC
, (LONG_PTR
)send_msg_delay_proc
);
7399 info
.ret
= 0xdeadbeef;
7400 thread
= CreateThread( NULL
, 0, send_msg_thread
, &info
, 0, &tid
);
7401 wait_for_thread( thread
);
7402 CloseHandle( thread
);
7403 /* we should timeout but still get the message */
7404 ok( info
.ret
== 0, "SendMessageTimeout failed\n" );
7405 ok_sequence( WmUser
, "WmUser", FALSE
);
7407 DestroyWindow( info
.hwnd
);
7411 /****************** edit message test *************************/
7412 #define ID_EDIT 0x1234
7413 static const struct message sl_edit_setfocus
[] =
7415 { HCBT_SETFOCUS
, hook
},
7416 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 },
7417 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 2 },
7418 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
7419 { WM_SETFOCUS
, sent
|wparam
, 0 },
7420 { WM_CTLCOLOREDIT
, sent
|parent
},
7421 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 },
7422 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 },
7423 { WM_COMMAND
, sent
|parent
|wparam
, MAKEWPARAM(ID_EDIT
, EN_SETFOCUS
) },
7426 static const struct message ml_edit_setfocus
[] =
7428 { HCBT_SETFOCUS
, hook
},
7429 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 1 },
7430 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 2 },
7431 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
7432 { WM_SETFOCUS
, sent
|wparam
, 0 },
7433 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 },
7434 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 },
7435 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 },
7436 { WM_COMMAND
, sent
|parent
|wparam
, MAKEWPARAM(ID_EDIT
, EN_SETFOCUS
) },
7439 static const struct message sl_edit_killfocus
[] =
7441 { HCBT_SETFOCUS
, hook
},
7442 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
7443 { WM_KILLFOCUS
, sent
|wparam
, 0 },
7444 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 },
7445 { EVENT_OBJECT_DESTROY
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 },
7446 { WM_COMMAND
, sent
|parent
|wparam
, MAKEWPARAM(ID_EDIT
, EN_KILLFOCUS
) },
7447 { WM_IME_SETCONTEXT
, sent
|wparam
|optional
, 0 },
7448 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 1 },
7451 static const struct message sl_edit_lbutton_dblclk
[] =
7453 { WM_LBUTTONDBLCLK
, sent
},
7454 { EVENT_SYSTEM_CAPTURESTART
, winevent_hook
|wparam
|lparam
, 0, 0 },
7457 static const struct message sl_edit_lbutton_down
[] =
7459 { WM_LBUTTONDOWN
, sent
|wparam
|lparam
, 0, 0 },
7460 { HCBT_SETFOCUS
, hook
},
7461 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
7462 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 2 },
7463 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
7464 { WM_SETFOCUS
, sent
|wparam
|defwinproc
, 0 },
7465 { WM_CTLCOLOREDIT
, sent
|parent
},
7466 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 },
7467 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 },
7468 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 },
7469 { WM_COMMAND
, sent
|parent
|wparam
, MAKEWPARAM(ID_EDIT
, EN_SETFOCUS
) },
7470 { EVENT_SYSTEM_CAPTURESTART
, winevent_hook
|wparam
|lparam
, 0, 0 },
7471 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 },
7472 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 },
7473 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 },
7476 static const struct message ml_edit_lbutton_down
[] =
7478 { WM_LBUTTONDOWN
, sent
|wparam
|lparam
, 0, 0 },
7479 { EVENT_SYSTEM_CAPTURESTART
, winevent_hook
|wparam
|lparam
, 0, 0 },
7480 { HCBT_SETFOCUS
, hook
},
7481 { WM_IME_SETCONTEXT
, sent
|wparam
|defwinproc
|optional
, 1 },
7482 { WM_IME_NOTIFY
, sent
|wparam
|defwinproc
|optional
, 2 },
7483 { EVENT_OBJECT_FOCUS
, winevent_hook
|wparam
|lparam
, OBJID_CLIENT
, 0 },
7484 { WM_SETFOCUS
, sent
|wparam
|defwinproc
, 0 },
7485 { EVENT_OBJECT_CREATE
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 },
7486 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 },
7487 { WM_COMMAND
, sent
|parent
|wparam
, MAKEWPARAM(ID_EDIT
, EN_SETFOCUS
) },
7490 static const struct message sl_edit_lbutton_up
[] =
7492 { WM_LBUTTONUP
, sent
|wparam
|lparam
, 0, 0 },
7493 { EVENT_OBJECT_HIDE
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 },
7494 { EVENT_SYSTEM_CAPTUREEND
, winevent_hook
|wparam
|lparam
, 0, 0 },
7495 { WM_CAPTURECHANGED
, sent
|defwinproc
},
7496 { EVENT_OBJECT_SHOW
, winevent_hook
|wparam
|lparam
, OBJID_CARET
, 0 },
7499 static const struct message ml_edit_lbutton_up
[] =
7501 { WM_LBUTTONUP
, sent
|wparam
|lparam
, 0, 0 },
7502 { EVENT_SYSTEM_CAPTUREEND
, winevent_hook
|wparam
|lparam
, 0, 0 },
7503 { WM_CAPTURECHANGED
, sent
|defwinproc
},
7507 static WNDPROC old_edit_proc
;
7509 static LRESULT CALLBACK
edit_hook_proc(HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
7511 static long defwndproc_counter
= 0;
7515 trace("edit: %p, %04x, %08x, %08lx\n", hwnd
, message
, wParam
, lParam
);
7517 /* explicitly ignore WM_GETICON message */
7518 if (message
== WM_GETICON
) return 0;
7520 msg
.message
= message
;
7521 msg
.flags
= sent
|wparam
|lparam
;
7522 if (defwndproc_counter
) msg
.flags
|= defwinproc
;
7523 msg
.wParam
= wParam
;
7524 msg
.lParam
= lParam
;
7527 defwndproc_counter
++;
7528 ret
= CallWindowProcA(old_edit_proc
, hwnd
, message
, wParam
, lParam
);
7529 defwndproc_counter
--;
7534 static void subclass_edit(void)
7538 if (!GetClassInfoA(0, "edit", &cls
)) assert(0);
7540 old_edit_proc
= cls
.lpfnWndProc
;
7542 cls
.hInstance
= GetModuleHandle(0);
7543 cls
.lpfnWndProc
= edit_hook_proc
;
7544 cls
.lpszClassName
= "my_edit_class";
7545 if (!RegisterClassA(&cls
)) assert(0);
7548 static void test_edit_messages(void)
7554 log_all_parent_messages
++;
7556 parent
= CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW
| WS_VISIBLE
,
7557 100, 100, 200, 200, 0, 0, 0, NULL
);
7558 ok (parent
!= 0, "Failed to create parent window\n");
7560 /* test single line edit */
7561 hwnd
= CreateWindowExA(0, "my_edit_class", "test", WS_CHILD
,
7562 0, 0, 80, 20, parent
, (HMENU
)ID_EDIT
, 0, NULL
);
7563 ok(hwnd
!= 0, "Failed to create edit window\n");
7565 dlg_code
= SendMessageA(hwnd
, WM_GETDLGCODE
, 0, 0);
7566 ok(dlg_code
== (DLGC_WANTCHARS
|DLGC_HASSETSEL
|DLGC_WANTARROWS
), "wrong dlg_code %08x\n", dlg_code
);
7568 ShowWindow(hwnd
, SW_SHOW
);
7574 ok_sequence(sl_edit_setfocus
, "SetFocus(hwnd) on an edit", FALSE
);
7577 ok_sequence(sl_edit_killfocus
, "SetFocus(0) on an edit", FALSE
);
7583 SendMessageA(hwnd
, WM_LBUTTONDBLCLK
, 0, 0);
7584 ok_sequence(sl_edit_lbutton_dblclk
, "WM_LBUTTONDBLCLK on an edit", FALSE
);
7590 SendMessageA(hwnd
, WM_LBUTTONDOWN
, 0, 0);
7591 ok_sequence(sl_edit_lbutton_down
, "WM_LBUTTONDOWN on an edit", FALSE
);
7593 SendMessageA(hwnd
, WM_LBUTTONUP
, 0, 0);
7594 ok_sequence(sl_edit_lbutton_up
, "WM_LBUTTONUP on an edit", FALSE
);
7596 DestroyWindow(hwnd
);
7598 /* test multiline edit */
7599 hwnd
= CreateWindowExA(0, "my_edit_class", "test", WS_CHILD
| ES_MULTILINE
,
7600 0, 0, 80, 20, parent
, (HMENU
)ID_EDIT
, 0, NULL
);
7601 ok(hwnd
!= 0, "Failed to create edit window\n");
7603 dlg_code
= SendMessageA(hwnd
, WM_GETDLGCODE
, 0, 0);
7604 ok(dlg_code
== (DLGC_WANTCHARS
|DLGC_HASSETSEL
|DLGC_WANTARROWS
|DLGC_WANTALLKEYS
),
7605 "wrong dlg_code %08x\n", dlg_code
);
7607 ShowWindow(hwnd
, SW_SHOW
);
7613 ok_sequence(ml_edit_setfocus
, "SetFocus(hwnd) on multiline edit", FALSE
);
7616 ok_sequence(sl_edit_killfocus
, "SetFocus(0) on multiline edit", FALSE
);
7622 SendMessageA(hwnd
, WM_LBUTTONDBLCLK
, 0, 0);
7623 ok_sequence(sl_edit_lbutton_dblclk
, "WM_LBUTTONDBLCLK on multiline edit", FALSE
);
7629 SendMessageA(hwnd
, WM_LBUTTONDOWN
, 0, 0);
7630 ok_sequence(ml_edit_lbutton_down
, "WM_LBUTTONDOWN on multiline edit", FALSE
);
7632 SendMessageA(hwnd
, WM_LBUTTONUP
, 0, 0);
7633 ok_sequence(ml_edit_lbutton_up
, "WM_LBUTTONUP on multiline edit", FALSE
);
7635 DestroyWindow(hwnd
);
7636 DestroyWindow(parent
);
7638 log_all_parent_messages
--;
7641 /**************************** End of Edit test ******************************/
7643 static const struct message WmKeyDownSkippedSeq
[] =
7645 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 1 }, /* XP */
7648 static const struct message WmKeyUpSkippedSeq
[] =
7650 { HCBT_KEYSKIPPED
, hook
|wparam
|lparam
|optional
, 'N', 0xc0000001 }, /* XP */
7654 #define EV_START_STOP 0
7655 #define EV_SENDMSG 1
7661 HANDLE hevent
[3]; /* 0 - start/stop, 1 - SendMessage, 2 - ack */
7664 static DWORD CALLBACK
send_msg_thread_2(void *param
)
7667 struct peekmsg_info
*info
= param
;
7669 trace("thread: waiting for start\n");
7670 WaitForSingleObject(info
->hevent
[EV_START_STOP
], INFINITE
);
7671 trace("thread: looping\n");
7675 ret
= WaitForMultipleObjects(2, info
->hevent
, FALSE
, INFINITE
);
7679 case WAIT_OBJECT_0
+ EV_START_STOP
:
7680 trace("thread: exiting\n");
7683 case WAIT_OBJECT_0
+ EV_SENDMSG
:
7684 trace("thread: sending message\n");
7685 SendNotifyMessageA(info
->hwnd
, WM_USER
, 0, 0);
7686 SetEvent(info
->hevent
[EV_ACK
]);
7690 trace("unexpected return: %04x\n", ret
);
7698 static void test_PeekMessage(void)
7703 UINT qs_all_input
= QS_ALLINPUT
;
7704 UINT qs_input
= QS_INPUT
;
7706 struct peekmsg_info info
;
7708 info
.hwnd
= CreateWindowA("TestWindowClass", NULL
, WS_OVERLAPPEDWINDOW
,
7709 100, 100, 200, 200, 0, 0, 0, NULL
);
7711 ShowWindow(info
.hwnd
, SW_SHOW
);
7712 UpdateWindow(info
.hwnd
);
7713 SetFocus(info
.hwnd
);
7715 info
.hevent
[EV_START_STOP
] = CreateEventA(NULL
, 0, 0, NULL
);
7716 info
.hevent
[EV_SENDMSG
] = CreateEventA(NULL
, 0, 0, NULL
);
7717 info
.hevent
[EV_ACK
] = CreateEventA(NULL
, 0, 0, NULL
);
7719 hthread
= CreateThread(NULL
, 0, send_msg_thread_2
, &info
, 0, &tid
);
7722 trace("signalling to start looping\n");
7723 SetEvent(info
.hevent
[EV_START_STOP
]);
7725 while (PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessageA(&msg
);
7728 SetLastError(0xdeadbeef);
7729 qstatus
= GetQueueStatus(qs_all_input
);
7730 if (GetLastError() == ERROR_INVALID_FLAGS
)
7732 trace("QS_RAWINPUT not supported on this platform\n");
7733 qs_all_input
&= ~QS_RAWINPUT
;
7734 qs_input
&= ~QS_RAWINPUT
;
7736 ok(qstatus
== 0, "wrong qstatus %08x\n", qstatus
);
7738 trace("signalling to send message\n");
7739 SetEvent(info
.hevent
[EV_SENDMSG
]);
7740 WaitForSingleObject(info
.hevent
[EV_ACK
], INFINITE
);
7742 /* pass invalid QS_xxxx flags */
7743 SetLastError(0xdeadbeef);
7744 qstatus
= GetQueueStatus(0xffffffff);
7745 ok(qstatus
== 0, "GetQueueStatus should fail: %08x\n", qstatus
);
7746 ok(GetLastError() == ERROR_INVALID_FLAGS
, "wrong error %d\n", GetLastError());
7748 qstatus
= GetQueueStatus(qs_all_input
);
7749 ok(qstatus
== MAKELONG(QS_SENDMESSAGE
, QS_SENDMESSAGE
),
7750 "wrong qstatus %08x\n", qstatus
);
7753 ret
= PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
);
7755 "PeekMessageA should have returned FALSE instead of msg %04x\n",
7757 ok_sequence(WmUser
, "WmUser", FALSE
);
7759 qstatus
= GetQueueStatus(qs_all_input
);
7760 ok(qstatus
== 0, "wrong qstatus %08x\n", qstatus
);
7762 keybd_event('N', 0, 0, 0);
7763 keybd_event('N', 0, KEYEVENTF_KEYUP
, 0);
7764 qstatus
= GetQueueStatus(qs_all_input
);
7765 ok(qstatus
== MAKELONG(QS_KEY
, QS_KEY
),
7766 "wrong qstatus %08x\n", qstatus
);
7768 PostMessageA(info
.hwnd
, WM_CHAR
, 'z', 0);
7769 qstatus
= GetQueueStatus(qs_all_input
);
7770 ok(qstatus
== MAKELONG(QS_POSTMESSAGE
, QS_POSTMESSAGE
|QS_KEY
),
7771 "wrong qstatus %08x\n", qstatus
);
7773 InvalidateRect(info
.hwnd
, NULL
, FALSE
);
7774 qstatus
= GetQueueStatus(qs_all_input
);
7775 ok(qstatus
== MAKELONG(QS_PAINT
, QS_PAINT
|QS_POSTMESSAGE
|QS_KEY
),
7776 "wrong qstatus %08x\n", qstatus
);
7778 trace("signalling to send message\n");
7779 SetEvent(info
.hevent
[EV_SENDMSG
]);
7780 WaitForSingleObject(info
.hevent
[EV_ACK
], INFINITE
);
7782 qstatus
= GetQueueStatus(qs_all_input
);
7783 ok(qstatus
== MAKELONG(QS_SENDMESSAGE
, QS_SENDMESSAGE
|QS_PAINT
|QS_POSTMESSAGE
|QS_KEY
),
7784 "wrong qstatus %08x\n", qstatus
);
7787 ret
= PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
| (qs_input
<< 16));
7790 "PeekMessageA should have returned FALSE instead of msg %04x\n",
7793 ok_sequence(WmUser
, "WmUser", FALSE
);
7795 qstatus
= GetQueueStatus(qs_all_input
);
7797 ok(qstatus
== MAKELONG(0, QS_PAINT
|QS_POSTMESSAGE
|QS_KEY
),
7798 "wrong qstatus %08x\n", qstatus
);
7801 trace("signalling to send message\n");
7802 SetEvent(info
.hevent
[EV_SENDMSG
]);
7803 WaitForSingleObject(info
.hevent
[EV_ACK
], INFINITE
);
7805 qstatus
= GetQueueStatus(qs_all_input
);
7807 ok(qstatus
== MAKELONG(QS_SENDMESSAGE
, QS_SENDMESSAGE
|QS_PAINT
|QS_POSTMESSAGE
|QS_KEY
),
7808 "wrong qstatus %08x\n", qstatus
);
7812 ret
= PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
| PM_QS_POSTMESSAGE
);
7815 "PeekMessageA should have returned FALSE instead of msg %04x\n",
7818 ok_sequence(WmUser
, "WmUser", FALSE
);
7820 qstatus
= GetQueueStatus(qs_all_input
);
7822 ok(qstatus
== MAKELONG(0, QS_PAINT
|QS_POSTMESSAGE
|QS_KEY
),
7823 "wrong qstatus %08x\n", qstatus
);
7827 ret
= PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
| PM_QS_POSTMESSAGE
);
7829 ok(ret
&& msg
.message
== WM_CHAR
&& msg
.wParam
== 'z',
7830 "got %d and %04x wParam %08x instead of TRUE and WM_CHAR wParam 'z'\n",
7831 ret
, msg
.message
, msg
.wParam
);
7833 ok_sequence(WmEmptySeq
, "WmEmptySeq", FALSE
);
7835 qstatus
= GetQueueStatus(qs_all_input
);
7837 ok(qstatus
== MAKELONG(0, QS_PAINT
|QS_KEY
),
7838 "wrong qstatus %08x\n", qstatus
);
7842 ret
= PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
| PM_QS_POSTMESSAGE
);
7845 "PeekMessageA should have returned FALSE instead of msg %04x\n",
7848 ok_sequence(WmEmptySeq
, "WmEmptySeq", FALSE
);
7850 qstatus
= GetQueueStatus(qs_all_input
);
7852 ok(qstatus
== MAKELONG(0, QS_PAINT
|QS_KEY
),
7853 "wrong qstatus %08x\n", qstatus
);
7857 ret
= PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
| PM_QS_PAINT
);
7858 ok(ret
&& msg
.message
== WM_PAINT
,
7859 "got %d and %04x instead of TRUE and WM_PAINT\n", ret
, msg
.message
);
7860 DispatchMessageA(&msg
);
7861 ok_sequence(WmPaint
, "WmPaint", FALSE
);
7863 qstatus
= GetQueueStatus(qs_all_input
);
7865 ok(qstatus
== MAKELONG(0, QS_KEY
),
7866 "wrong qstatus %08x\n", qstatus
);
7870 ret
= PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
| PM_QS_PAINT
);
7872 "PeekMessageA should have returned FALSE instead of msg %04x\n",
7874 ok_sequence(WmEmptySeq
, "WmEmptySeq", FALSE
);
7876 qstatus
= GetQueueStatus(qs_all_input
);
7878 ok(qstatus
== MAKELONG(0, QS_KEY
),
7879 "wrong qstatus %08x\n", qstatus
);
7882 trace("signalling to send message\n");
7883 SetEvent(info
.hevent
[EV_SENDMSG
]);
7884 WaitForSingleObject(info
.hevent
[EV_ACK
], INFINITE
);
7886 qstatus
= GetQueueStatus(qs_all_input
);
7888 ok(qstatus
== MAKELONG(QS_SENDMESSAGE
, QS_SENDMESSAGE
|QS_KEY
),
7889 "wrong qstatus %08x\n", qstatus
);
7892 PostMessageA(info
.hwnd
, WM_CHAR
, 'z', 0);
7894 qstatus
= GetQueueStatus(qs_all_input
);
7896 ok(qstatus
== MAKELONG(QS_POSTMESSAGE
, QS_SENDMESSAGE
|QS_POSTMESSAGE
|QS_KEY
),
7897 "wrong qstatus %08x\n", qstatus
);
7901 ret
= PeekMessageA(&msg
, 0, WM_CHAR
, WM_CHAR
, PM_REMOVE
);
7902 ok(ret
&& msg
.message
== WM_CHAR
&& msg
.wParam
== 'z',
7903 "got %d and %04x wParam %08x instead of TRUE and WM_CHAR wParam 'z'\n",
7904 ret
, msg
.message
, msg
.wParam
);
7905 ok_sequence(WmUser
, "WmUser", FALSE
);
7907 qstatus
= GetQueueStatus(qs_all_input
);
7909 ok(qstatus
== MAKELONG(0, QS_KEY
),
7910 "wrong qstatus %08x\n", qstatus
);
7914 ret
= PeekMessageA(&msg
, 0, WM_CHAR
, WM_CHAR
, PM_REMOVE
);
7916 "PeekMessageA should have returned FALSE instead of msg %04x\n",
7918 ok_sequence(WmEmptySeq
, "WmEmptySeq", FALSE
);
7920 qstatus
= GetQueueStatus(qs_all_input
);
7922 ok(qstatus
== MAKELONG(0, QS_KEY
),
7923 "wrong qstatus %08x\n", qstatus
);
7926 PostMessageA(info
.hwnd
, WM_CHAR
, 'z', 0);
7928 qstatus
= GetQueueStatus(qs_all_input
);
7930 ok(qstatus
== MAKELONG(QS_POSTMESSAGE
, QS_POSTMESSAGE
|QS_KEY
),
7931 "wrong qstatus %08x\n", qstatus
);
7934 trace("signalling to send message\n");
7935 SetEvent(info
.hevent
[EV_SENDMSG
]);
7936 WaitForSingleObject(info
.hevent
[EV_ACK
], INFINITE
);
7938 qstatus
= GetQueueStatus(qs_all_input
);
7940 ok(qstatus
== MAKELONG(QS_SENDMESSAGE
, QS_SENDMESSAGE
|QS_POSTMESSAGE
|QS_KEY
),
7941 "wrong qstatus %08x\n", qstatus
);
7945 ret
= PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
| (QS_KEY
<< 16));
7948 "PeekMessageA should have returned FALSE instead of msg %04x\n",
7951 ok_sequence(WmUser
, "WmUser", FALSE
);
7953 qstatus
= GetQueueStatus(qs_all_input
);
7955 ok(qstatus
== MAKELONG(0, QS_POSTMESSAGE
|QS_KEY
),
7956 "wrong qstatus %08x\n", qstatus
);
7960 ret
= PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
| (QS_RAWINPUT
<< 16));
7962 ok(ret
&& msg
.message
== WM_KEYDOWN
&& msg
.wParam
== 'N',
7963 "got %d and %04x wParam %08x instead of TRUE and WM_KEYDOWN wParam 'N'\n",
7964 ret
, msg
.message
, msg
.wParam
);
7965 ok_sequence(WmKeyDownSkippedSeq
, "WmKeyDownSkippedSeq", FALSE
);
7968 qstatus
= GetQueueStatus(qs_all_input
);
7970 ok(qstatus
== MAKELONG(0, QS_POSTMESSAGE
|QS_KEY
),
7971 "wrong qstatus %08x\n", qstatus
);
7975 ret
= PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
| (QS_RAWINPUT
<< 16));
7977 ok(ret
&& msg
.message
== WM_KEYUP
&& msg
.wParam
== 'N',
7978 "got %d and %04x wParam %08x instead of TRUE and WM_KEYUP wParam 'N'\n",
7979 ret
, msg
.message
, msg
.wParam
);
7980 ok_sequence(WmKeyUpSkippedSeq
, "WmKeyUpSkippedSeq", FALSE
);
7983 qstatus
= GetQueueStatus(qs_all_input
);
7985 ok(qstatus
== MAKELONG(0, QS_POSTMESSAGE
),
7986 "wrong qstatus %08x\n", qstatus
);
7990 ret
= PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
| PM_QS_SENDMESSAGE
);
7992 "PeekMessageA should have returned FALSE instead of msg %04x\n",
7994 ok_sequence(WmEmptySeq
, "WmEmptySeq", FALSE
);
7996 qstatus
= GetQueueStatus(qs_all_input
);
7998 ok(qstatus
== MAKELONG(0, QS_POSTMESSAGE
),
7999 "wrong qstatus %08x\n", qstatus
);
8003 ret
= PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
);
8005 ok(ret
&& msg
.message
== WM_CHAR
&& msg
.wParam
== 'z',
8006 "got %d and %04x wParam %08x instead of TRUE and WM_CHAR wParam 'z'\n",
8007 ret
, msg
.message
, msg
.wParam
);
8009 ok_sequence(WmEmptySeq
, "WmEmptySeq", FALSE
);
8011 qstatus
= GetQueueStatus(qs_all_input
);
8013 "wrong qstatus %08x\n", qstatus
);
8016 ret
= PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
);
8018 "PeekMessageA should have returned FALSE instead of msg %04x\n",
8020 ok_sequence(WmEmptySeq
, "WmEmptySeq", FALSE
);
8022 qstatus
= GetQueueStatus(qs_all_input
);
8024 "wrong qstatus %08x\n", qstatus
);
8026 /* test whether presence of the quit flag in the queue affects
8029 PostQuitMessage(0x1234abcd);
8031 qstatus
= GetQueueStatus(qs_all_input
);
8032 ok(qstatus
== MAKELONG(QS_POSTMESSAGE
, QS_POSTMESSAGE
),
8033 "wrong qstatus %08x\n", qstatus
);
8035 PostMessageA(info
.hwnd
, WM_USER
, 0, 0);
8037 qstatus
= GetQueueStatus(qs_all_input
);
8038 ok(qstatus
== MAKELONG(QS_POSTMESSAGE
, QS_POSTMESSAGE
),
8039 "wrong qstatus %08x\n", qstatus
);
8042 ret
= PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
);
8043 ok(ret
&& msg
.message
== WM_USER
,
8044 "got %d and %04x instead of TRUE and WM_USER\n", ret
, msg
.message
);
8045 ok_sequence(WmEmptySeq
, "WmEmptySeq", FALSE
);
8047 qstatus
= GetQueueStatus(qs_all_input
);
8048 ok(qstatus
== MAKELONG(0, QS_POSTMESSAGE
),
8049 "wrong qstatus %08x\n", qstatus
);
8052 ret
= PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
);
8053 ok(ret
&& msg
.message
== WM_QUIT
,
8054 "got %d and %04x instead of TRUE and WM_QUIT\n", ret
, msg
.message
);
8055 ok(msg
.wParam
== 0x1234abcd, "got wParam %08x instead of 0x1234abcd\n", msg
.wParam
);
8056 ok(msg
.lParam
== 0, "got lParam %08lx instead of 0\n", msg
.lParam
);
8057 ok_sequence(WmEmptySeq
, "WmEmptySeq", FALSE
);
8059 qstatus
= GetQueueStatus(qs_all_input
);
8061 ok(qstatus
== MAKELONG(0, QS_POSTMESSAGE
),
8062 "wrong qstatus %08x\n", qstatus
);
8066 ret
= PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
);
8068 "PeekMessageA should have returned FALSE instead of msg %04x\n",
8070 ok_sequence(WmEmptySeq
, "WmEmptySeq", FALSE
);
8072 qstatus
= GetQueueStatus(qs_all_input
);
8074 "wrong qstatus %08x\n", qstatus
);
8076 trace("signalling to exit\n");
8077 SetEvent(info
.hevent
[EV_START_STOP
]);
8079 WaitForSingleObject(hthread
, INFINITE
);
8081 CloseHandle(hthread
);
8082 CloseHandle(info
.hevent
[0]);
8083 CloseHandle(info
.hevent
[1]);
8084 CloseHandle(info
.hevent
[2]);
8086 DestroyWindow(info
.hwnd
);
8090 static void test_quit_message(void)
8095 /* test using PostQuitMessage */
8096 PostQuitMessage(0xbeef);
8098 ret
= PeekMessage(&msg
, NULL
, 0, 0, PM_NOREMOVE
);
8099 ok(ret
, "PeekMessage failed with error %d\n", GetLastError());
8100 ok(msg
.message
== WM_QUIT
, "Received message 0x%04x instead of WM_QUIT\n", msg
.message
);
8101 ok(msg
.wParam
== 0xbeef, "wParam was 0x%x instead of 0xbeef\n", msg
.wParam
);
8103 ret
= PostThreadMessage(GetCurrentThreadId(), WM_USER
, 0, 0);
8104 ok(ret
, "PostMessage failed with error %d\n", GetLastError());
8106 ret
= GetMessage(&msg
, NULL
, 0, 0);
8107 ok(ret
> 0, "GetMessage failed with error %d\n", GetLastError());
8108 ok(msg
.message
== WM_USER
, "Received message 0x%04x instead of WM_USER\n", msg
.message
);
8110 /* note: WM_QUIT message received after WM_USER message */
8111 ret
= GetMessage(&msg
, NULL
, 0, 0);
8112 ok(!ret
, "GetMessage return %d with error %d instead of FALSE\n", ret
, GetLastError());
8113 ok(msg
.message
== WM_QUIT
, "Received message 0x%04x instead of WM_QUIT\n", msg
.message
);
8114 ok(msg
.wParam
== 0xbeef, "wParam was 0x%x instead of 0xbeef\n", msg
.wParam
);
8116 ret
= PeekMessage(&msg
, NULL
, 0, 0, PM_REMOVE
);
8117 ok( !ret
|| msg
.message
!= WM_QUIT
, "Received WM_QUIT again\n" );
8119 /* now test with PostThreadMessage - different behaviour! */
8120 PostThreadMessage(GetCurrentThreadId(), WM_QUIT
, 0xdead, 0);
8122 ret
= PeekMessage(&msg
, NULL
, 0, 0, PM_NOREMOVE
);
8123 ok(ret
, "PeekMessage failed with error %d\n", GetLastError());
8124 ok(msg
.message
== WM_QUIT
, "Received message 0x%04x instead of WM_QUIT\n", msg
.message
);
8125 ok(msg
.wParam
== 0xdead, "wParam was 0x%x instead of 0xdead\n", msg
.wParam
);
8127 ret
= PostThreadMessage(GetCurrentThreadId(), WM_USER
, 0, 0);
8128 ok(ret
, "PostMessage failed with error %d\n", GetLastError());
8130 /* note: we receive the WM_QUIT message first this time */
8131 ret
= GetMessage(&msg
, NULL
, 0, 0);
8132 ok(!ret
, "GetMessage return %d with error %d instead of FALSE\n", ret
, GetLastError());
8133 ok(msg
.message
== WM_QUIT
, "Received message 0x%04x instead of WM_QUIT\n", msg
.message
);
8134 ok(msg
.wParam
== 0xdead, "wParam was 0x%x instead of 0xdead\n", msg
.wParam
);
8136 ret
= GetMessage(&msg
, NULL
, 0, 0);
8137 ok(ret
> 0, "GetMessage failed with error %d\n", GetLastError());
8138 ok(msg
.message
== WM_USER
, "Received message 0x%04x instead of WM_USER\n", msg
.message
);
8141 static const struct message WmMouseHoverSeq
[] = {
8142 { WM_TIMER
, sent
|optional
}, /* XP sends it */
8143 { WM_SYSTIMER
, sent
},
8144 { WM_MOUSEHOVER
, sent
|wparam
, 0 },
8148 static void pump_msg_loop_timeout(DWORD timeout
, BOOL inject_mouse_move
)
8151 DWORD start_ticks
, end_ticks
;
8153 start_ticks
= GetTickCount();
8154 /* add some deviation (5%) to cover not expected delays */
8155 start_ticks
+= timeout
/ 20;
8159 while (PeekMessage(&msg
, 0, 0, 0, PM_REMOVE
))
8161 /* Timer proc messages are not dispatched to the window proc,
8162 * and therefore not logged.
8164 if (msg
.message
== WM_TIMER
|| msg
.message
== WM_SYSTIMER
)
8166 struct message s_msg
;
8168 s_msg
.message
= msg
.message
;
8169 s_msg
.flags
= sent
|wparam
|lparam
;
8170 s_msg
.wParam
= msg
.wParam
;
8171 s_msg
.lParam
= msg
.lParam
;
8172 add_message(&s_msg
);
8174 DispatchMessage(&msg
);
8177 end_ticks
= GetTickCount();
8179 /* inject WM_MOUSEMOVE to see how it changes tracking */
8180 if (inject_mouse_move
&& start_ticks
+ timeout
/ 2 >= end_ticks
)
8182 mouse_event(MOUSEEVENTF_MOVE
, -1, 0, 0, 0);
8183 mouse_event(MOUSEEVENTF_MOVE
, 1, 0, 0, 0);
8185 inject_mouse_move
= FALSE
;
8187 } while (start_ticks
+ timeout
>= end_ticks
);
8190 static void test_TrackMouseEvent(void)
8193 TRACKMOUSEEVENT tme
;
8196 RECT rc_parent
, rc_child
;
8197 UINT default_hover_time
, hover_width
= 0, hover_height
= 0;
8199 #define track_hover(track_hwnd, track_hover_time) \
8200 tme.cbSize = sizeof(tme); \
8201 tme.dwFlags = TME_HOVER; \
8202 tme.hwndTrack = track_hwnd; \
8203 tme.dwHoverTime = track_hover_time; \
8204 SetLastError(0xdeadbeef); \
8205 ret = TrackMouseEvent(&tme); \
8206 ok(ret, "TrackMouseEvent(TME_HOVER) error %d\n", GetLastError())
8208 #define track_query(expected_track_flags, expected_track_hwnd, expected_hover_time) \
8209 tme.cbSize = sizeof(tme); \
8210 tme.dwFlags = TME_QUERY; \
8211 tme.hwndTrack = (HWND)0xdeadbeef; \
8212 tme.dwHoverTime = 0xdeadbeef; \
8213 SetLastError(0xdeadbeef); \
8214 ret = TrackMouseEvent(&tme); \
8215 ok(ret, "TrackMouseEvent(TME_QUERY) error %d\n", GetLastError());\
8216 ok(tme.cbSize == sizeof(tme), "wrong tme.cbSize %u\n", tme.cbSize); \
8217 ok(tme.dwFlags == (expected_track_flags), \
8218 "wrong tme.dwFlags %08x, expected %08x\n", tme.dwFlags, (expected_track_flags)); \
8219 ok(tme.hwndTrack == (expected_track_hwnd), \
8220 "wrong tme.hwndTrack %p, expected %p\n", tme.hwndTrack, (expected_track_hwnd)); \
8221 ok(tme.dwHoverTime == (expected_hover_time), \
8222 "wrong tme.dwHoverTime %u, expected %u\n", tme.dwHoverTime, (expected_hover_time))
8224 #define track_hover_cancel(track_hwnd) \
8225 tme.cbSize = sizeof(tme); \
8226 tme.dwFlags = TME_HOVER | TME_CANCEL; \
8227 tme.hwndTrack = track_hwnd; \
8228 tme.dwHoverTime = 0xdeadbeef; \
8229 SetLastError(0xdeadbeef); \
8230 ret = TrackMouseEvent(&tme); \
8231 ok(ret, "TrackMouseEvent(TME_HOVER | TME_CANCEL) error %d\n", GetLastError())
8233 default_hover_time
= 0xdeadbeef;
8234 SetLastError(0xdeadbeef);
8235 ret
= SystemParametersInfo(SPI_GETMOUSEHOVERTIME
, 0, &default_hover_time
, 0);
8236 ok(ret
, "SystemParametersInfo(SPI_GETMOUSEHOVERTIME) error %u\n", GetLastError());
8237 if (!ret
) default_hover_time
= 400;
8238 trace("SPI_GETMOUSEHOVERTIME returned %u ms\n", default_hover_time
);
8240 SetLastError(0xdeadbeef);
8241 ret
= SystemParametersInfo(SPI_GETMOUSEHOVERWIDTH
, 0, &hover_width
, 0);
8242 ok(ret
, "SystemParametersInfo(SPI_GETMOUSEHOVERWIDTH) error %u\n", GetLastError());
8243 if (!ret
) hover_width
= 4;
8244 SetLastError(0xdeadbeef);
8245 ret
= SystemParametersInfo(SPI_GETMOUSEHOVERHEIGHT
, 0, &hover_height
, 0);
8246 ok(ret
, "SystemParametersInfo(SPI_GETMOUSEHOVERHEIGHT) error %u\n", GetLastError());
8247 if (!ret
) hover_height
= 4;
8248 trace("hover rect is %u x %d\n", hover_width
, hover_height
);
8250 hwnd
= CreateWindowEx(0, "TestWindowClass", NULL
,
8251 WS_OVERLAPPEDWINDOW
| WS_VISIBLE
,
8252 CW_USEDEFAULT
, CW_USEDEFAULT
, 300, 300, 0,
8256 hchild
= CreateWindowEx(0, "TestWindowClass", NULL
,
8257 WS_CHILD
| WS_BORDER
| WS_VISIBLE
,
8258 50, 50, 200, 200, hwnd
,
8266 tme
.dwFlags
= TME_QUERY
;
8267 tme
.hwndTrack
= (HWND
)0xdeadbeef;
8268 tme
.dwHoverTime
= 0xdeadbeef;
8269 SetLastError(0xdeadbeef);
8270 ret
= TrackMouseEvent(&tme
);
8271 ok(!ret
, "TrackMouseEvent should fail\n");
8272 ok(GetLastError() == ERROR_INVALID_PARAMETER
, "not expected error %d\n", GetLastError());
8274 tme
.cbSize
= sizeof(tme
);
8275 tme
.dwFlags
= TME_HOVER
;
8276 tme
.hwndTrack
= (HWND
)0xdeadbeef;
8277 tme
.dwHoverTime
= 0xdeadbeef;
8278 SetLastError(0xdeadbeef);
8279 ret
= TrackMouseEvent(&tme
);
8280 ok(!ret
, "TrackMouseEvent should fail\n");
8281 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE
, "not expected error %d\n", GetLastError());
8283 tme
.cbSize
= sizeof(tme
);
8284 tme
.dwFlags
= TME_HOVER
| TME_CANCEL
;
8285 tme
.hwndTrack
= (HWND
)0xdeadbeef;
8286 tme
.dwHoverTime
= 0xdeadbeef;
8287 SetLastError(0xdeadbeef);
8288 ret
= TrackMouseEvent(&tme
);
8289 ok(!ret
, "TrackMouseEvent should fail\n");
8290 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE
, "not expected error %d\n", GetLastError());
8292 GetWindowRect(hwnd
, &rc_parent
);
8293 GetWindowRect(hchild
, &rc_child
);
8294 SetCursorPos(rc_child
.left
- 10, rc_child
.top
- 10);
8296 /* Process messages so that the system updates its internal current
8297 * window and hittest, otherwise TrackMouseEvent calls don't have any
8300 while (PeekMessage(&msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage(&msg
);
8303 track_query(0, NULL
, 0);
8304 track_hover(hchild
, 0);
8305 track_query(0, NULL
, 0);
8307 while (PeekMessage(&msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessage(&msg
);
8310 track_hover(hwnd
, 0);
8311 track_query(TME_HOVER
, hwnd
, default_hover_time
);
8313 pump_msg_loop_timeout(default_hover_time
, FALSE
);
8314 ok_sequence(WmMouseHoverSeq
, "WmMouseHoverSeq", FALSE
);
8316 track_query(0, NULL
, 0);
8318 track_hover(hwnd
, HOVER_DEFAULT
);
8319 track_query(TME_HOVER
, hwnd
, default_hover_time
);
8321 Sleep(default_hover_time
/ 2);
8322 mouse_event(MOUSEEVENTF_MOVE
, -1, 0, 0, 0);
8323 mouse_event(MOUSEEVENTF_MOVE
, 1, 0, 0, 0);
8325 track_query(TME_HOVER
, hwnd
, default_hover_time
);
8327 pump_msg_loop_timeout(default_hover_time
/ 2, FALSE
);
8328 ok_sequence(WmMouseHoverSeq
, "WmMouseHoverSeq", FALSE
);
8330 track_query(0, NULL
, 0);
8332 track_hover(hwnd
, HOVER_DEFAULT
);
8333 track_query(TME_HOVER
, hwnd
, default_hover_time
);
8335 pump_msg_loop_timeout(default_hover_time
, TRUE
);
8336 ok_sequence(WmMouseHoverSeq
, "WmMouseHoverSeq", FALSE
);
8338 track_query(0, NULL
, 0);
8340 track_hover(hwnd
, HOVER_DEFAULT
);
8341 track_query(TME_HOVER
, hwnd
, default_hover_time
);
8342 track_hover_cancel(hwnd
);
8344 DestroyWindow(hwnd
);
8348 #undef track_hover_cancel
8352 static const struct message WmSetWindowRgn
[] = {
8353 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOSIZE
|SWP_NOMOVE
},
8354 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
8355 { WM_NCPAINT
, sent
}, /* wparam != 1 */
8356 { WM_GETTEXT
, sent
|defwinproc
|optional
},
8357 { WM_ERASEBKGND
, sent
|optional
}, /* FIXME: remove optional once Wine is fixed */
8358 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOSIZE
|SWP_NOMOVE
},
8359 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
8363 static const struct message WmSetWindowRgn_no_redraw
[] = {
8364 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOREDRAW
},
8365 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
8366 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOREDRAW
},
8367 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
8371 static const struct message WmSetWindowRgn_clear
[] = {
8372 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOSIZE
|SWP_NOMOVE
},
8373 { WM_NCCALCSIZE
, sent
|wparam
, 1 },
8374 { WM_NCPAINT
, sent
}, /* wparam != 1 */
8375 { WM_GETTEXT
, sent
|defwinproc
|optional
},
8376 { WM_ERASEBKGND
, sent
|optional
}, /* FIXME: remove optional once Wine is fixed */
8377 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOSIZE
|SWP_NOMOVE
},
8378 { WM_NCCALCSIZE
, sent
|wparam
|optional
, 1 },
8379 { WM_NCPAINT
, sent
|optional
}, /* wparam != 1 */
8380 { WM_GETTEXT
, sent
|defwinproc
|optional
},
8381 { WM_ERASEBKGND
, sent
|optional
},
8382 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
8383 { EVENT_OBJECT_LOCATIONCHANGE
, winevent_hook
|wparam
|lparam
, 0, 0 },
8387 static void test_SetWindowRgn(void)
8390 HWND hwnd
= CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW
,
8391 100, 100, 200, 200, 0, 0, 0, NULL
);
8392 ok( hwnd
!= 0, "Failed to create overlapped window\n" );
8394 ShowWindow( hwnd
, SW_SHOW
);
8395 UpdateWindow( hwnd
);
8399 trace("testing SetWindowRgn\n");
8400 hrgn
= CreateRectRgn( 0, 0, 150, 150 );
8401 SetWindowRgn( hwnd
, hrgn
, TRUE
);
8402 ok_sequence( WmSetWindowRgn
, "WmSetWindowRgn", FALSE
);
8404 hrgn
= CreateRectRgn( 30, 30, 160, 160 );
8405 SetWindowRgn( hwnd
, hrgn
, FALSE
);
8406 ok_sequence( WmSetWindowRgn_no_redraw
, "WmSetWindowRgn_no_redraw", FALSE
);
8408 hrgn
= CreateRectRgn( 0, 0, 180, 180 );
8409 SetWindowRgn( hwnd
, hrgn
, TRUE
);
8410 ok_sequence( WmSetWindowRgn
, "WmSetWindowRgn2", FALSE
);
8412 SetWindowRgn( hwnd
, 0, TRUE
);
8413 ok_sequence( WmSetWindowRgn_clear
, "WmSetWindowRgn_clear", FALSE
);
8415 DestroyWindow( hwnd
);
8418 /*************************** ShowWindow() test ******************************/
8419 static const struct message WmShowNormal
[] = {
8420 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
8421 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
8422 { HCBT_ACTIVATE
, hook
},
8423 { WM_WINDOWPOSCHANGING
, sent
|wparam
|optional
, SWP_NOSIZE
|SWP_NOMOVE
}, /* win2003 doesn't send it */
8424 { HCBT_SETFOCUS
, hook
},
8425 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
8428 static const struct message WmShow
[] = {
8429 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
8430 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
8431 { HCBT_ACTIVATE
, hook
|optional
}, /* win2000 doesn't send it */
8432 { WM_WINDOWPOSCHANGING
, sent
|wparam
|optional
, SWP_NOSIZE
|SWP_NOMOVE
}, /* win2000 doesn't send it */
8433 { HCBT_SETFOCUS
, hook
|optional
}, /* win2000 doesn't send it */
8434 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
8437 static const struct message WmShowNoActivate_1
[] = {
8438 { HCBT_MINMAX
, hook
|lparam
, 0, SW_SHOWNOACTIVATE
},
8439 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
|0x8000 },
8440 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
|0x8000 },
8441 { WM_MOVE
, sent
|defwinproc
},
8442 { WM_SIZE
, sent
|wparam
|defwinproc
, SIZE_RESTORED
},
8445 static const struct message WmShowNoActivate_2
[] = {
8446 { HCBT_MINMAX
, hook
|lparam
, 0, SW_SHOWNOACTIVATE
},
8447 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
8448 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
8449 { WM_MOVE
, sent
|defwinproc
},
8450 { WM_SIZE
, sent
|wparam
|defwinproc
, SIZE_RESTORED
},
8451 { HCBT_SETFOCUS
, hook
},
8452 { HCBT_ACTIVATE
, hook
|optional
}, /* win2003 doesn't send it */
8453 { WM_WINDOWPOSCHANGING
, sent
|wparam
|optional
, SWP_NOSIZE
|SWP_NOMOVE
}, /* win2003 doesn't send it */
8454 { HCBT_SETFOCUS
, hook
|optional
}, /* win2003 doesn't send it */
8457 static const struct message WmShowNA_1
[] = {
8458 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
8459 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
8460 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
8463 static const struct message WmShowNA_2
[] = {
8464 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
8465 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
8468 static const struct message WmRestore_1
[] = {
8469 { HCBT_MINMAX
, hook
|lparam
, 0, SW_RESTORE
},
8470 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
8471 { HCBT_ACTIVATE
, hook
|optional
}, /* win2000 doesn't send it */
8472 { WM_WINDOWPOSCHANGING
, sent
|wparam
|optional
, SWP_NOSIZE
|SWP_NOMOVE
}, /* win2000 doesn't send it */
8473 { HCBT_SETFOCUS
, hook
|optional
}, /* win2000 doesn't send it */
8474 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
8475 { WM_MOVE
, sent
|defwinproc
},
8476 { WM_SIZE
, sent
|wparam
|defwinproc
, SIZE_RESTORED
},
8477 { HCBT_SETFOCUS
, hook
|optional
}, /* win2000 sends it */
8480 static const struct message WmRestore_2
[] = {
8481 { WM_SHOWWINDOW
, sent
|wparam
, 1 },
8482 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
8483 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
8486 static const struct message WmRestore_3
[] = {
8487 { HCBT_MINMAX
, hook
|lparam
, 0, SW_RESTORE
},
8488 { WM_GETMINMAXINFO
, sent
},
8489 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
8490 { HCBT_ACTIVATE
, hook
|optional
}, /* win2003 doesn't send it */
8491 { WM_WINDOWPOSCHANGING
, sent
|wparam
|optional
, SWP_NOSIZE
|SWP_NOMOVE
}, /* win2003 doesn't send it */
8492 { HCBT_SETFOCUS
, hook
|optional
}, /* win2003 doesn't send it */
8493 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
8494 { WM_MOVE
, sent
|defwinproc
},
8495 { WM_SIZE
, sent
|wparam
|defwinproc
, SIZE_MAXIMIZED
},
8496 { HCBT_SETFOCUS
, hook
|optional
}, /* win2003 sends it */
8499 static const struct message WmRestore_4
[] = {
8500 { HCBT_MINMAX
, hook
|lparam
, 0, SW_RESTORE
},
8501 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|0x8000 },
8502 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|0x8000 },
8503 { WM_MOVE
, sent
|defwinproc
},
8504 { WM_SIZE
, sent
|wparam
|defwinproc
, SIZE_RESTORED
},
8507 static const struct message WmRestore_5
[] = {
8508 { HCBT_MINMAX
, hook
|lparam
, 0, SW_SHOWNORMAL
},
8509 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|0x8000 },
8510 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|0x8000 },
8511 { WM_MOVE
, sent
|defwinproc
},
8512 { WM_SIZE
, sent
|wparam
|defwinproc
, SIZE_RESTORED
},
8515 static const struct message WmHide_1
[] = {
8516 { WM_SHOWWINDOW
, sent
|wparam
, 0 },
8517 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
8518 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
8519 { HCBT_SETFOCUS
, hook
|optional
}, /* win2000 sends it */
8522 static const struct message WmHide_2
[] = {
8523 { WM_SHOWWINDOW
, sent
|wparam
, 0 },
8524 { WM_WINDOWPOSCHANGING
, sent
/*|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE*/ }, /* win2000 doesn't add SWP_NOACTIVATE */
8525 { WM_WINDOWPOSCHANGED
, sent
/*|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ }, /* win2000 doesn't add SWP_NOACTIVATE */
8528 static const struct message WmHide_3
[] = {
8529 { WM_SHOWWINDOW
, sent
|wparam
, 0 },
8530 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
},
8531 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_HIDEWINDOW
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
8532 { HCBT_SETFOCUS
, hook
},
8535 static const struct message WmShowMinimized_1
[] = {
8536 { HCBT_MINMAX
, hook
|lparam
, 0, SW_SHOWMINIMIZED
},
8537 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
8538 { HCBT_ACTIVATE
, hook
|optional
}, /* win2000 doesn't send it */
8539 { WM_WINDOWPOSCHANGING
, sent
|wparam
|optional
, SWP_NOSIZE
|SWP_NOMOVE
}, /* win2000 doesn't send it */
8540 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
8541 { WM_MOVE
, sent
|defwinproc
},
8542 { WM_SIZE
, sent
|wparam
|defwinproc
, SIZE_MINIMIZED
},
8545 static const struct message WmMinimize_1
[] = {
8546 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MINIMIZE
},
8547 { HCBT_SETFOCUS
, hook
|optional
}, /* win2000 doesn't send it */
8548 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
8549 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
8550 { WM_MOVE
, sent
|defwinproc
},
8551 { WM_SIZE
, sent
|wparam
|defwinproc
, SIZE_MINIMIZED
},
8554 static const struct message WmMinimize_2
[] = {
8555 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MINIMIZE
},
8556 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
8557 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
8558 { WM_MOVE
, sent
|defwinproc
},
8559 { WM_SIZE
, sent
|wparam
|defwinproc
, SIZE_MINIMIZED
},
8562 static const struct message WmMinimize_3
[] = {
8563 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MINIMIZE
},
8564 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
8565 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
8566 { WM_MOVE
, sent
|defwinproc
},
8567 { WM_SIZE
, sent
|wparam
|defwinproc
, SIZE_MINIMIZED
},
8570 static const struct message WmShowMinNoActivate
[] = {
8571 { HCBT_MINMAX
, hook
|lparam
, 0, SW_SHOWMINNOACTIVE
},
8572 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
},
8573 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_NOACTIVATE
|SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
8576 static const struct message WmMinMax_1
[] = {
8577 { HCBT_MINMAX
, hook
|lparam
, 0, SW_SHOWMINIMIZED
},
8580 static const struct message WmMinMax_2
[] = {
8581 { HCBT_MINMAX
, hook
|lparam
, 0, SW_SHOWMAXIMIZED
},
8584 static const struct message WmMinMax_3
[] = {
8585 { HCBT_MINMAX
, hook
|lparam
, 0, SW_MINIMIZE
},
8588 static const struct message WmMinMax_4
[] = {
8589 { HCBT_MINMAX
, hook
|lparam
, 0, SW_SHOWMINNOACTIVE
},
8592 static const struct message WmShowMaximized_1
[] = {
8593 { HCBT_MINMAX
, hook
|lparam
, 0, SW_SHOWMAXIMIZED
},
8594 { WM_GETMINMAXINFO
, sent
},
8595 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
8596 { HCBT_ACTIVATE
, hook
|optional
}, /* win2000 doesn't send it */
8597 { WM_WINDOWPOSCHANGING
, sent
|wparam
|optional
, SWP_NOSIZE
|SWP_NOMOVE
}, /* win2000 doesn't send it */
8598 { HCBT_SETFOCUS
, hook
|optional
}, /* win2000 doesn't send it */
8599 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_SHOWWINDOW
|SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
8600 { WM_MOVE
, sent
|defwinproc
},
8601 { WM_SIZE
, sent
|wparam
|defwinproc
, SIZE_MAXIMIZED
},
8602 { HCBT_SETFOCUS
, hook
|optional
}, /* win2003 sends it */
8605 static const struct message WmShowMaximized_2
[] = {
8606 { HCBT_MINMAX
, hook
|lparam
, 0, SW_SHOWMAXIMIZED
},
8607 { WM_GETMINMAXINFO
, sent
},
8608 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_NOSIZE
|SWP_NOMOVE
},
8609 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
},
8610 { WM_MOVE
, sent
|optional
}, /* Win9x doesn't send it */
8611 { WM_SIZE
, sent
|wparam
|optional
, SIZE_MAXIMIZED
}, /* Win9x doesn't send it */
8612 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
8613 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|SWP_NOCOPYBITS
|0x8000 },
8614 { WM_MOVE
, sent
|defwinproc
},
8615 { WM_SIZE
, sent
|wparam
|defwinproc
, SIZE_MAXIMIZED
},
8616 { HCBT_SETFOCUS
, hook
},
8619 static const struct message WmShowMaximized_3
[] = {
8620 { HCBT_MINMAX
, hook
|lparam
, 0, SW_SHOWMAXIMIZED
},
8621 { WM_GETMINMAXINFO
, sent
},
8622 { WM_WINDOWPOSCHANGING
, sent
|wparam
, SWP_FRAMECHANGED
|0x8000 },
8623 { WM_WINDOWPOSCHANGED
, sent
|wparam
, SWP_FRAMECHANGED
|0x8000 },
8624 { WM_MOVE
, sent
|defwinproc
},
8625 { WM_SIZE
, sent
|wparam
|defwinproc
, SIZE_MAXIMIZED
},
8629 static void test_ShowWindow(void)
8631 /* ShowWindow commands in random order */
8634 INT cmd
; /* ShowWindow command */
8635 LPARAM ret
; /* ShowWindow return value */
8636 DWORD style
; /* window style after the command */
8637 const struct message
*msg
; /* message sequence the command produces */
8638 BOOL todo_msg
; /* message sequence doesn't match what Wine does */
8641 /* 1 */ { SW_SHOWNORMAL
, FALSE
, WS_VISIBLE
, WmShowNormal
, FALSE
},
8642 /* 2 */ { SW_SHOWNORMAL
, TRUE
, WS_VISIBLE
, WmEmptySeq
, FALSE
},
8643 /* 3 */ { SW_HIDE
, TRUE
, 0, WmHide_1
, FALSE
},
8644 /* 4 */ { SW_HIDE
, FALSE
, 0, WmEmptySeq
, FALSE
},
8645 /* 5 */ { SW_SHOWMINIMIZED
, FALSE
, WS_VISIBLE
|WS_MINIMIZE
, WmShowMinimized_1
, FALSE
},
8646 /* 6 */ { SW_SHOWMINIMIZED
, TRUE
, WS_VISIBLE
|WS_MINIMIZE
, WmMinMax_1
, FALSE
},
8647 /* 7 */ { SW_HIDE
, TRUE
, WS_MINIMIZE
, WmHide_1
, FALSE
},
8648 /* 8 */ { SW_HIDE
, FALSE
, WS_MINIMIZE
, WmEmptySeq
, FALSE
},
8649 /* 9 */ { SW_SHOWMAXIMIZED
, FALSE
, WS_VISIBLE
|WS_MAXIMIZE
, WmShowMaximized_1
, FALSE
},
8650 /* 10 */ { SW_SHOWMAXIMIZED
, TRUE
, WS_VISIBLE
|WS_MAXIMIZE
, WmMinMax_2
, FALSE
},
8651 /* 11 */ { SW_HIDE
, TRUE
, WS_MAXIMIZE
, WmHide_1
, FALSE
},
8652 /* 12 */ { SW_HIDE
, FALSE
, WS_MAXIMIZE
, WmEmptySeq
, FALSE
},
8653 /* 13 */ { SW_SHOWNOACTIVATE
, FALSE
, WS_VISIBLE
, WmShowNoActivate_1
, FALSE
},
8654 /* 14 */ { SW_SHOWNOACTIVATE
, TRUE
, WS_VISIBLE
, WmEmptySeq
, FALSE
},
8655 /* 15 */ { SW_HIDE
, TRUE
, 0, WmHide_2
, FALSE
},
8656 /* 16 */ { SW_HIDE
, FALSE
, 0, WmEmptySeq
, FALSE
},
8657 /* 17 */ { SW_SHOW
, FALSE
, WS_VISIBLE
, WmShow
, FALSE
},
8658 /* 18 */ { SW_SHOW
, TRUE
, WS_VISIBLE
, WmEmptySeq
, FALSE
},
8659 /* 19 */ { SW_MINIMIZE
, TRUE
, WS_VISIBLE
|WS_MINIMIZE
, WmMinimize_1
, TRUE
},
8660 /* 20 */ { SW_MINIMIZE
, TRUE
, WS_VISIBLE
|WS_MINIMIZE
, WmMinMax_3
, FALSE
},
8661 /* 21 */ { SW_HIDE
, TRUE
, WS_MINIMIZE
, WmHide_2
, FALSE
},
8662 /* 22 */ { SW_SHOWMINNOACTIVE
, FALSE
, WS_VISIBLE
|WS_MINIMIZE
, WmShowMinNoActivate
, TRUE
},
8663 /* 23 */ { SW_SHOWMINNOACTIVE
, TRUE
, WS_VISIBLE
|WS_MINIMIZE
, WmMinMax_4
, FALSE
},
8664 /* 24 */ { SW_HIDE
, TRUE
, WS_MINIMIZE
, WmHide_2
, FALSE
},
8665 /* 25 */ { SW_HIDE
, FALSE
, WS_MINIMIZE
, WmEmptySeq
, FALSE
},
8666 /* 26 */ { SW_SHOWNA
, FALSE
, WS_VISIBLE
|WS_MINIMIZE
, WmShowNA_1
, FALSE
},
8667 /* 27 */ { SW_SHOWNA
, TRUE
, WS_VISIBLE
|WS_MINIMIZE
, WmShowNA_2
, FALSE
},
8668 /* 28 */ { SW_HIDE
, TRUE
, WS_MINIMIZE
, WmHide_2
, FALSE
},
8669 /* 29 */ { SW_HIDE
, FALSE
, WS_MINIMIZE
, WmEmptySeq
, FALSE
},
8670 /* 30 */ { SW_RESTORE
, FALSE
, WS_VISIBLE
, WmRestore_1
, FALSE
},
8671 /* 31 */ { SW_RESTORE
, TRUE
, WS_VISIBLE
, WmEmptySeq
, FALSE
},
8672 /* 32 */ { SW_HIDE
, TRUE
, 0, WmHide_3
, TRUE
},
8673 /* 33 */ { SW_HIDE
, FALSE
, 0, WmEmptySeq
, FALSE
},
8674 /* 34 */ { SW_NORMALNA
, FALSE
, 0, WmEmptySeq
, TRUE
}, /* what does this mean?! */
8675 /* 35 */ { SW_NORMALNA
, FALSE
, 0, WmEmptySeq
, TRUE
},
8676 /* 36 */ { SW_HIDE
, FALSE
, 0, WmEmptySeq
, FALSE
},
8677 /* 37 */ { SW_RESTORE
, FALSE
, WS_VISIBLE
, WmRestore_2
, FALSE
},
8678 /* 38 */ { SW_RESTORE
, TRUE
, WS_VISIBLE
, WmEmptySeq
, FALSE
},
8679 /* 39 */ { SW_SHOWNOACTIVATE
, TRUE
, WS_VISIBLE
, WmEmptySeq
, FALSE
},
8680 /* 40 */ { SW_MINIMIZE
, TRUE
, WS_VISIBLE
|WS_MINIMIZE
, WmMinimize_2
, TRUE
},
8681 /* 41 */ { SW_MINIMIZE
, TRUE
, WS_VISIBLE
|WS_MINIMIZE
, WmMinMax_3
, FALSE
},
8682 /* 42 */ { SW_SHOWMAXIMIZED
, TRUE
, WS_VISIBLE
|WS_MAXIMIZE
, WmShowMaximized_2
, TRUE
},
8683 /* 43 */ { SW_SHOWMAXIMIZED
, TRUE
, WS_VISIBLE
|WS_MAXIMIZE
, WmMinMax_2
, FALSE
},
8684 /* 44 */ { SW_MINIMIZE
, TRUE
, WS_VISIBLE
|WS_MINIMIZE
, WmMinimize_1
, TRUE
},
8685 /* 45 */ { SW_MINIMIZE
, TRUE
, WS_VISIBLE
|WS_MINIMIZE
, WmMinMax_3
, FALSE
},
8686 /* 46 */ { SW_RESTORE
, TRUE
, WS_VISIBLE
|WS_MAXIMIZE
, WmRestore_3
, FALSE
},
8687 /* 47 */ { SW_RESTORE
, TRUE
, WS_VISIBLE
, WmRestore_4
, FALSE
},
8688 /* 48 */ { SW_SHOWMAXIMIZED
, TRUE
, WS_VISIBLE
|WS_MAXIMIZE
, WmShowMaximized_3
, FALSE
},
8689 /* 49 */ { SW_SHOW
, TRUE
, WS_VISIBLE
|WS_MAXIMIZE
, WmEmptySeq
, FALSE
},
8690 /* 50 */ { SW_SHOWNORMAL
, TRUE
, WS_VISIBLE
, WmRestore_5
, FALSE
},
8691 /* 51 */ { SW_SHOWNORMAL
, TRUE
, WS_VISIBLE
, WmEmptySeq
, FALSE
},
8692 /* 52 */ { SW_HIDE
, TRUE
, 0, WmHide_1
, FALSE
},
8693 /* 53 */ { SW_HIDE
, FALSE
, 0, WmEmptySeq
, FALSE
},
8694 /* 54 */ { SW_MINIMIZE
, FALSE
, WS_VISIBLE
|WS_MINIMIZE
, WmMinimize_3
, TRUE
},
8695 /* 55 */ { SW_HIDE
, TRUE
, WS_MINIMIZE
, WmHide_2
, FALSE
},
8696 /* 56 */ { SW_SHOWNOACTIVATE
, FALSE
, WS_VISIBLE
, WmShowNoActivate_2
, TRUE
},
8697 /* 57 */ { SW_SHOW
, TRUE
, WS_VISIBLE
, WmEmptySeq
, FALSE
}
8704 #define WS_BASE (WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_POPUP|WS_CLIPSIBLINGS)
8705 hwnd
= CreateWindowEx(0, "ShowWindowClass", NULL
, WS_BASE
,
8710 style
= GetWindowLong(hwnd
, GWL_STYLE
) & ~WS_BASE
;
8711 ok(style
== 0, "expected style 0, got %08x\n", style
);
8716 for (i
= 0; i
< sizeof(sw
)/sizeof(sw
[0]); i
++)
8718 static const char * const sw_cmd_name
[13] =
8720 "SW_HIDE", "SW_SHOWNORMAL", "SW_SHOWMINIMIZED", "SW_SHOWMAXIMIZED",
8721 "SW_SHOWNOACTIVATE", "SW_SHOW", "SW_MINIMIZE", "SW_SHOWMINNOACTIVE",
8722 "SW_SHOWNA", "SW_RESTORE", "SW_SHOWDEFAULT", "SW_FORCEMINIMIZE",
8723 "SW_NORMALNA" /* 0xCC */
8726 INT idx
; /* index into the above array of names */
8728 idx
= (sw
[i
].cmd
== SW_NORMALNA
) ? 12 : sw
[i
].cmd
;
8730 style
= GetWindowLong(hwnd
, GWL_STYLE
);
8731 trace("%d: sending %s, current window style %08x\n", i
+1, sw_cmd_name
[idx
], style
);
8732 ret
= ShowWindow(hwnd
, sw
[i
].cmd
);
8733 ok(!ret
== !sw
[i
].ret
, "%d: cmd %s: expected ret %lu, got %lu\n", i
+1, sw_cmd_name
[idx
], sw
[i
].ret
, ret
);
8734 style
= GetWindowLong(hwnd
, GWL_STYLE
) & ~WS_BASE
;
8735 ok(style
== sw
[i
].style
, "%d: expected style %08x, got %08x\n", i
+1, sw
[i
].style
, style
);
8737 sprintf(comment
, "%d: ShowWindow(%s)", i
+1, sw_cmd_name
[idx
]);
8738 ok_sequence(sw
[i
].msg
, comment
, sw
[i
].todo_msg
);
8744 DestroyWindow(hwnd
);
8750 HMODULE user32
= GetModuleHandleA("user32.dll");
8751 FARPROC pSetWinEventHook
= GetProcAddress(user32
, "SetWinEventHook");
8752 FARPROC pUnhookWinEvent
= GetProcAddress(user32
, "UnhookWinEvent");
8753 FARPROC pIsWinEventHookInstalled
= 0;/*GetProcAddress(user32, "IsWinEventHookInstalled");*/
8754 pGetAncestor
= (void*) GetProcAddress(user32
, "GetAncestor");
8756 if (!RegisterWindowClasses()) assert(0);
8758 if (pSetWinEventHook
)
8760 hEvent_hook
= (HWINEVENTHOOK
)pSetWinEventHook(EVENT_MIN
, EVENT_MAX
,
8761 GetModuleHandleA(0),
8764 GetCurrentThreadId(),
8765 WINEVENT_INCONTEXT
);
8766 assert(hEvent_hook
);
8768 if (pIsWinEventHookInstalled
)
8771 for (event
= EVENT_MIN
; event
<= EVENT_MAX
; event
++)
8772 ok(pIsWinEventHookInstalled(event
), "IsWinEventHookInstalled(%u) failed\n", event
);
8776 cbt_hook_thread_id
= GetCurrentThreadId();
8777 hCBT_hook
= SetWindowsHookExA(WH_CBT
, cbt_hook_proc
, 0, GetCurrentThreadId());
8782 /* Fix message sequences before removing 4 lines below */
8784 if (pUnhookWinEvent
&& hEvent_hook
)
8786 ret
= pUnhookWinEvent(hEvent_hook
);
8787 ok( ret
, "UnhookWinEvent error %d\n", GetLastError());
8788 pUnhookWinEvent
= 0;
8795 test_scrollwindowex();
8798 invisible_parent_tests();
8799 test_mdi_messages();
8800 test_button_messages();
8801 test_static_messages();
8802 test_paint_messages();
8803 test_interthread_messages();
8804 test_message_conversion();
8805 test_accelerators();
8808 test_DestroyWindow();
8809 test_DispatchMessage();
8810 test_SendMessageTimeout();
8811 test_edit_messages();
8812 test_quit_message();
8813 test_TrackMouseEvent();
8814 test_SetWindowRgn();
8817 UnhookWindowsHookEx(hCBT_hook
);
8818 if (pUnhookWinEvent
)
8820 ret
= pUnhookWinEvent(hEvent_hook
);
8821 ok( ret
, "UnhookWinEvent error %d\n", GetLastError());
8822 SetLastError(0xdeadbeef);
8823 ok(!pUnhookWinEvent(hEvent_hook
), "UnhookWinEvent succeeded\n");
8824 ok(GetLastError() == ERROR_INVALID_HANDLE
|| /* Win2k */
8825 GetLastError() == 0xdeadbeef, /* Win9x */
8826 "unexpected error %d\n", GetLastError());