?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix signed/unsigned comparison warnings.
[wine.git] / dlls / user / tests / win.c
blobd6866bc4046043e080ea9fa24ec8eb71c9f6a77a
1 /*
2 * Unit tests for window handling
3 *
4 * Copyright 2002 Bill Medland
5 * Copyright 2002 Alexandre Julliard
6 * Copyright 2003 Dmitry Timoshkov
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
23 /* To get ICON_SMALL2 with the MSVC headers */
24 #define _WIN32_WINNT 0x0501
25
26 #include <assert.h>
27 #include <stdlib.h>
28 #include <stdarg.h>
29 #include <stdio.h>
30
31 #include "windef.h"
32 #include "winbase.h"
33 #include "wingdi.h"
34 #include "winuser.h"
35
36 #include "wine/test.h"
37
38 #ifndef SPI_GETDESKWALLPAPER
39 #define SPI_GETDESKWALLPAPER 0x0073
40 #endif
41
42 #define LONG_PTR INT_PTR
43 #define ULONG_PTR UINT_PTR
44
45 static HWND (WINAPI *pGetAncestor)(HWND,UINT);
46 static BOOL (WINAPI *pGetWindowInfo)(HWND,WINDOWINFO*);
47
48 static HWND hwndMessage;
49 static HWND hwndMain, hwndMain2;
50 static HHOOK hhook;
51
52 /* check the values returned by the various parent/owner functions on a given window */
53 static void check_parents( HWND hwnd, HWND ga_parent, HWND gwl_parent, HWND get_parent,
54 HWND gw_owner, HWND ga_root, HWND ga_root_owner )
55 {
56 HWND res;
57
58 if (pGetAncestor)
59 {
60 res = pGetAncestor( hwnd, GA_PARENT );
61 ok( res == ga_parent, "Wrong result for GA_PARENT %p expected %p\n", res, ga_parent );
62 }
63 res = (HWND)GetWindowLongA( hwnd, GWL_HWNDPARENT );
64 ok( res == gwl_parent, "Wrong result for GWL_HWNDPARENT %p expected %p\n", res, gwl_parent );
65 res = GetParent( hwnd );
66 ok( res == get_parent, "Wrong result for GetParent %p expected %p\n", res, get_parent );
67 res = GetWindow( hwnd, GW_OWNER );
68 ok( res == gw_owner, "Wrong result for GW_OWNER %p expected %p\n", res, gw_owner );
69 if (pGetAncestor)
70 {
71 res = pGetAncestor( hwnd, GA_ROOT );
72 ok( res == ga_root, "Wrong result for GA_ROOT %p expected %p\n", res, ga_root );
73 res = pGetAncestor( hwnd, GA_ROOTOWNER );
74 ok( res == ga_root_owner, "Wrong result for GA_ROOTOWNER %p expected %p\n", res, ga_root_owner );
75 }
76 }
77
78
79 static HWND create_tool_window( LONG style, HWND parent )
80 {
81 HWND ret = CreateWindowExA(0, "ToolWindowClass", "Tool window 1", style,
82 0, 0, 100, 100, parent, 0, 0, NULL );
83 ok( ret != 0, "Creation failed\n" );
84 return ret;
85 }
86
87 /* test parent and owner values for various combinations */
88 static void test_parent_owner(void)
89 {
90 LONG style;
91 HWND test, owner, ret;
92 HWND desktop = GetDesktopWindow();
93 HWND child = create_tool_window( WS_CHILD, hwndMain );
94
95 trace( "main window %p main2 %p desktop %p child %p\n", hwndMain, hwndMain2, desktop, child );
96
97 /* child without parent, should fail */
98 test = CreateWindowExA(0, "ToolWindowClass", "Tool window 1",
99 WS_CHILD, 0, 0, 100, 100, 0, 0, 0, NULL );
100 ok( !test, "WS_CHILD without parent created\n" );
101
102 /* desktop window */
103 check_parents( desktop, 0, 0, 0, 0, 0, 0 );
104 style = GetWindowLongA( desktop, GWL_STYLE );
105 ok( !SetWindowLongA( desktop, GWL_STYLE, WS_POPUP ), "Set GWL_STYLE on desktop succeeded\n" );
106 ok( !SetWindowLongA( desktop, GWL_STYLE, 0 ), "Set GWL_STYLE on desktop succeeded\n" );
107 ok( GetWindowLongA( desktop, GWL_STYLE ) == style, "Desktop style changed\n" );
108
109 /* normal child window */
110 test = create_tool_window( WS_CHILD, hwndMain );
111 trace( "created child %p\n", test );
112 check_parents( test, hwndMain, hwndMain, hwndMain, 0, hwndMain, hwndMain );
113 SetWindowLongA( test, GWL_STYLE, 0 );
114 check_parents( test, hwndMain, hwndMain, 0, 0, hwndMain, test );
115 SetWindowLongA( test, GWL_STYLE, WS_POPUP );
116 check_parents( test, hwndMain, hwndMain, 0, 0, hwndMain, test );
117 SetWindowLongA( test, GWL_STYLE, WS_POPUP|WS_CHILD );
118 check_parents( test, hwndMain, hwndMain, 0, 0, hwndMain, test );
119 SetWindowLongA( test, GWL_STYLE, WS_CHILD );
120 DestroyWindow( test );
121
122 /* normal child window with WS_MAXIMIZE */
123 test = create_tool_window( WS_CHILD | WS_MAXIMIZE, hwndMain );
124 DestroyWindow( test );
125
126 /* normal child window with WS_THICKFRAME */
127 test = create_tool_window( WS_CHILD | WS_THICKFRAME, hwndMain );
128 DestroyWindow( test );
129
130 /* popup window with WS_THICKFRAME */
131 test = create_tool_window( WS_POPUP | WS_THICKFRAME, hwndMain );
132 DestroyWindow( test );
133
134 /* child of desktop */
135 test = create_tool_window( WS_CHILD, desktop );
136 trace( "created child of desktop %p\n", test );
137 check_parents( test, desktop, 0, desktop, 0, test, desktop );
138 SetWindowLongA( test, GWL_STYLE, WS_POPUP );
139 check_parents( test, desktop, 0, 0, 0, test, test );
140 SetWindowLongA( test, GWL_STYLE, 0 );
141 check_parents( test, desktop, 0, 0, 0, test, test );
142 DestroyWindow( test );
143
144 /* child of desktop with WS_MAXIMIZE */
145 test = create_tool_window( WS_CHILD | WS_MAXIMIZE, desktop );
146 DestroyWindow( test );
147
148 /* child of desktop with WS_MINIMIZE */
149 test = create_tool_window( WS_CHILD | WS_MINIMIZE, desktop );
150 DestroyWindow( test );
151
152 /* child of child */
153 test = create_tool_window( WS_CHILD, child );
154 trace( "created child of child %p\n", test );
155 check_parents( test, child, child, child, 0, hwndMain, hwndMain );
156 SetWindowLongA( test, GWL_STYLE, 0 );
157 check_parents( test, child, child, 0, 0, hwndMain, test );
158 SetWindowLongA( test, GWL_STYLE, WS_POPUP );
159 check_parents( test, child, child, 0, 0, hwndMain, test );
160 DestroyWindow( test );
161
162 /* child of child with WS_MAXIMIZE */
163 test = create_tool_window( WS_CHILD | WS_MAXIMIZE, child );
164 DestroyWindow( test );
165
166 /* child of child with WS_MINIMIZE */
167 test = create_tool_window( WS_CHILD | WS_MINIMIZE, child );
168 DestroyWindow( test );
169
170 /* not owned top-level window */
171 test = create_tool_window( 0, 0 );
172 trace( "created top-level %p\n", test );
173 check_parents( test, desktop, 0, 0, 0, test, test );
174 SetWindowLongA( test, GWL_STYLE, WS_POPUP );
175 check_parents( test, desktop, 0, 0, 0, test, test );
176 SetWindowLongA( test, GWL_STYLE, WS_CHILD );
177 check_parents( test, desktop, 0, desktop, 0, test, desktop );
178 DestroyWindow( test );
179
180 /* not owned top-level window with WS_MAXIMIZE */
181 test = create_tool_window( WS_MAXIMIZE, 0 );
182 DestroyWindow( test );
183
184 /* owned top-level window */
185 test = create_tool_window( 0, hwndMain );
186 trace( "created owned top-level %p\n", test );
187 check_parents( test, desktop, hwndMain, 0, hwndMain, test, test );
188 SetWindowLongA( test, GWL_STYLE, WS_POPUP );
189 check_parents( test, desktop, hwndMain, hwndMain, hwndMain, test, hwndMain );
190 SetWindowLongA( test, GWL_STYLE, WS_CHILD );
191 check_parents( test, desktop, hwndMain, desktop, hwndMain, test, desktop );
192 DestroyWindow( test );
193
194 /* owned top-level window with WS_MAXIMIZE */
195 test = create_tool_window( WS_MAXIMIZE, hwndMain );
196 DestroyWindow( test );
197
198 /* not owned popup */
199 test = create_tool_window( WS_POPUP, 0 );
200 trace( "created popup %p\n", test );
201 check_parents( test, desktop, 0, 0, 0, test, test );
202 SetWindowLongA( test, GWL_STYLE, WS_CHILD );
203 check_parents( test, desktop, 0, desktop, 0, test, desktop );
204 SetWindowLongA( test, GWL_STYLE, 0 );
205 check_parents( test, desktop, 0, 0, 0, test, test );
206 DestroyWindow( test );
207
208 /* not owned popup with WS_MAXIMIZE */
209 test = create_tool_window( WS_POPUP | WS_MAXIMIZE, 0 );
210 DestroyWindow( test );
211
212 /* owned popup */
213 test = create_tool_window( WS_POPUP, hwndMain );
214 trace( "created owned popup %p\n", test );
215 check_parents( test, desktop, hwndMain, hwndMain, hwndMain, test, hwndMain );
216 SetWindowLongA( test, GWL_STYLE, WS_CHILD );
217 check_parents( test, desktop, hwndMain, desktop, hwndMain, test, desktop );
218 SetWindowLongA( test, GWL_STYLE, 0 );
219 check_parents( test, desktop, hwndMain, 0, hwndMain, test, test );
220 DestroyWindow( test );
221
222 /* owned popup with WS_MAXIMIZE */
223 test = create_tool_window( WS_POPUP | WS_MAXIMIZE, hwndMain );
224 DestroyWindow( test );
225
226 /* top-level window owned by child (same as owned by top-level) */
227 test = create_tool_window( 0, child );
228 trace( "created top-level owned by child %p\n", test );
229 check_parents( test, desktop, hwndMain, 0, hwndMain, test, test );
230 DestroyWindow( test );
231
232 /* top-level window owned by child (same as owned by top-level) with WS_MAXIMIZE */
233 test = create_tool_window( WS_MAXIMIZE, child );
234 DestroyWindow( test );
235
236 /* popup owned by desktop (same as not owned) */
237 test = create_tool_window( WS_POPUP, desktop );
238 trace( "created popup owned by desktop %p\n", test );
239 check_parents( test, desktop, 0, 0, 0, test, test );
240 DestroyWindow( test );
241
242 /* popup owned by desktop (same as not owned) with WS_MAXIMIZE */
243 test = create_tool_window( WS_POPUP | WS_MAXIMIZE, desktop );
244 DestroyWindow( test );
245
246 /* popup owned by child (same as owned by top-level) */
247 test = create_tool_window( WS_POPUP, child );
248 trace( "created popup owned by child %p\n", test );
249 check_parents( test, desktop, hwndMain, hwndMain, hwndMain, test, hwndMain );
250 DestroyWindow( test );
251
252 /* popup owned by child (same as owned by top-level) with WS_MAXIMIZE */
253 test = create_tool_window( WS_POPUP | WS_MAXIMIZE, child );
254 DestroyWindow( test );
255
256 /* not owned popup with WS_CHILD (same as WS_POPUP only) */
257 test = create_tool_window( WS_POPUP | WS_CHILD, 0 );
258 trace( "created WS_CHILD popup %p\n", test );
259 check_parents( test, desktop, 0, 0, 0, test, test );
260 DestroyWindow( test );
261
262 /* not owned popup with WS_CHILD | WS_MAXIMIZE (same as WS_POPUP only) */
263 test = create_tool_window( WS_POPUP | WS_CHILD | WS_MAXIMIZE, 0 );
264 DestroyWindow( test );
265
266 /* owned popup with WS_CHILD (same as WS_POPUP only) */
267 test = create_tool_window( WS_POPUP | WS_CHILD, hwndMain );
268 trace( "created owned WS_CHILD popup %p\n", test );
269 check_parents( test, desktop, hwndMain, hwndMain, hwndMain, test, hwndMain );
270 DestroyWindow( test );
271
272 /* owned popup with WS_CHILD (same as WS_POPUP only) with WS_MAXIMIZE */
273 test = create_tool_window( WS_POPUP | WS_CHILD | WS_MAXIMIZE, hwndMain );
274 DestroyWindow( test );
275
276 /******************** parent changes *************************/
277 trace( "testing parent changes\n" );
278
279 /* desktop window */
280 check_parents( desktop, 0, 0, 0, 0, 0, 0 );
281 #if 0 /* this test succeeds on NT but crashes on win9x systems */
282 ret = (HWND)SetWindowLongA( test, GWL_HWNDPARENT, (LONG_PTR)hwndMain2 );
283 ok( !ret, "Set GWL_HWNDPARENT succeeded on desktop\n" );
284 check_parents( desktop, 0, 0, 0, 0, 0, 0 );
285 ok( !SetParent( desktop, hwndMain ), "SetParent succeeded on desktop\n" );
286 check_parents( desktop, 0, 0, 0, 0, 0, 0 );
287 #endif
288 /* normal child window */
289 test = create_tool_window( WS_CHILD, hwndMain );
290 trace( "created child %p\n", test );
291
292 ret = (HWND)SetWindowLongA( test, GWL_HWNDPARENT, (LONG_PTR)hwndMain2 );
293 ok( ret == hwndMain, "GWL_HWNDPARENT return value %p expected %p\n", ret, hwndMain );
294 check_parents( test, hwndMain2, hwndMain2, hwndMain2, 0, hwndMain2, hwndMain2 );
295
296 ret = (HWND)SetWindowLongA( test, GWL_HWNDPARENT, (LONG_PTR)child );
297 ok( ret == hwndMain2, "GWL_HWNDPARENT return value %p expected %p\n", ret, hwndMain2 );
298 check_parents( test, child, child, child, 0, hwndMain, hwndMain );
299
300 ret = (HWND)SetWindowLongA( test, GWL_HWNDPARENT, (LONG_PTR)desktop );
301 ok( ret == child, "GWL_HWNDPARENT return value %p expected %p\n", ret, child );
302 check_parents( test, desktop, 0, desktop, 0, test, desktop );
303
304 /* window is now child of desktop so GWL_HWNDPARENT changes owner from now on */
305 ret = (HWND)SetWindowLongA( test, GWL_HWNDPARENT, (LONG_PTR)child );
306 ok( ret == 0, "GWL_HWNDPARENT return value %p expected 0\n", ret );
307 check_parents( test, desktop, child, desktop, child, test, desktop );
308
309 ret = (HWND)SetWindowLongA( test, GWL_HWNDPARENT, 0 );
310 ok( ret == child, "GWL_HWNDPARENT return value %p expected %p\n", ret, child );
311 check_parents( test, desktop, 0, desktop, 0, test, desktop );
312 DestroyWindow( test );
313
314 /* not owned top-level window */
315 test = create_tool_window( 0, 0 );
316 trace( "created top-level %p\n", test );
317
318 ret = (HWND)SetWindowLongA( test, GWL_HWNDPARENT, (LONG_PTR)hwndMain2 );
319 ok( ret == 0, "GWL_HWNDPARENT return value %p expected 0\n", ret );
320 check_parents( test, desktop, hwndMain2, 0, hwndMain2, test, test );
321
322 ret = (HWND)SetWindowLongA( test, GWL_HWNDPARENT, (LONG_PTR)child );
323 ok( ret == hwndMain2, "GWL_HWNDPARENT return value %p expected %p\n", ret, hwndMain2 );
324 check_parents( test, desktop, child, 0, child, test, test );
325
326 ret = (HWND)SetWindowLongA( test, GWL_HWNDPARENT, 0 );
327 ok( ret == child, "GWL_HWNDPARENT return value %p expected %p\n", ret, child );
328 check_parents( test, desktop, 0, 0, 0, test, test );
329 DestroyWindow( test );
330
331 /* not owned popup */
332 test = create_tool_window( WS_POPUP, 0 );
333 trace( "created popup %p\n", test );
334
335 ret = (HWND)SetWindowLongA( test, GWL_HWNDPARENT, (LONG_PTR)hwndMain2 );
336 ok( ret == 0, "GWL_HWNDPARENT return value %p expected 0\n", ret );
337 check_parents( test, desktop, hwndMain2, hwndMain2, hwndMain2, test, hwndMain2 );
338
339 ret = (HWND)SetWindowLongA( test, GWL_HWNDPARENT, (LONG_PTR)child );
340 ok( ret == hwndMain2, "GWL_HWNDPARENT return value %p expected %p\n", ret, hwndMain2 );
341 check_parents( test, desktop, child, child, child, test, hwndMain );
342
343 ret = (HWND)SetWindowLongA( test, GWL_HWNDPARENT, 0 );
344 ok( ret == child, "GWL_HWNDPARENT return value %p expected %p\n", ret, child );
345 check_parents( test, desktop, 0, 0, 0, test, test );
346 DestroyWindow( test );
347
348 /* normal child window */
349 test = create_tool_window( WS_CHILD, hwndMain );
350 trace( "created child %p\n", test );
351
352 ret = SetParent( test, desktop );
353 ok( ret == hwndMain, "SetParent return value %p expected %p\n", ret, hwndMain );
354 check_parents( test, desktop, 0, desktop, 0, test, desktop );
355
356 ret = SetParent( test, child );
357 ok( ret == desktop, "SetParent return value %p expected %p\n", ret, desktop );
358 check_parents( test, child, child, child, 0, hwndMain, hwndMain );
359
360 ret = SetParent( test, hwndMain2 );
361 ok( ret == child, "SetParent return value %p expected %p\n", ret, child );
362 check_parents( test, hwndMain2, hwndMain2, hwndMain2, 0, hwndMain2, hwndMain2 );
363 DestroyWindow( test );
364
365 /* not owned top-level window */
366 test = create_tool_window( 0, 0 );
367 trace( "created top-level %p\n", test );
368
369 ret = SetParent( test, child );
370 ok( ret == desktop, "SetParent return value %p expected %p\n", ret, desktop );
371 check_parents( test, child, child, 0, 0, hwndMain, test );
372 DestroyWindow( test );
373
374 /* owned popup */
375 test = create_tool_window( WS_POPUP, hwndMain2 );
376 trace( "created owned popup %p\n", test );
377
378 ret = SetParent( test, child );
379 ok( ret == desktop, "SetParent return value %p expected %p\n", ret, desktop );
380 check_parents( test, child, child, hwndMain2, hwndMain2, hwndMain, hwndMain2 );
381
382 ret = (HWND)SetWindowLongA( test, GWL_HWNDPARENT, (ULONG_PTR)hwndMain );
383 ok( ret == child, "GWL_HWNDPARENT return value %p expected %p\n", ret, child );
384 check_parents( test, hwndMain, hwndMain, hwndMain2, hwndMain2, hwndMain, hwndMain2 );
385 DestroyWindow( test );
386
387 /**************** test owner destruction *******************/
388
389 /* owned child popup */
390 owner = create_tool_window( 0, 0 );
391 test = create_tool_window( WS_POPUP, owner );
392 trace( "created owner %p and popup %p\n", owner, test );
393 ret = SetParent( test, child );
394 ok( ret == desktop, "SetParent return value %p expected %p\n", ret, desktop );
395 check_parents( test, child, child, owner, owner, hwndMain, owner );
396 /* window is now child of 'child' but owned by 'owner' */
397 DestroyWindow( owner );
398 ok( IsWindow(test), "Window %p destroyed by owner destruction\n", test );
399 /* Win98 doesn't pass this test. It doesn't allow a destroyed owner,
400 * while Win95, Win2k, WinXP do.
401 */
402 /*check_parents( test, child, child, owner, owner, hwndMain, owner );*/
403 ok( !IsWindow(owner), "Owner %p not destroyed\n", owner );
404 DestroyWindow(test);
405
406 /* owned top-level popup */
407 owner = create_tool_window( 0, 0 );
408 test = create_tool_window( WS_POPUP, owner );
409 trace( "created owner %p and popup %p\n", owner, test );
410 check_parents( test, desktop, owner, owner, owner, test, owner );
411 DestroyWindow( owner );
412 ok( !IsWindow(test), "Window %p not destroyed by owner destruction\n", test );
413
414 /* top-level popup owned by child */
415 owner = create_tool_window( WS_CHILD, hwndMain2 );
416 test = create_tool_window( WS_POPUP, 0 );
417 trace( "created owner %p and popup %p\n", owner, test );
418 ret = (HWND)SetWindowLongA( test, GWL_HWNDPARENT, (ULONG_PTR)owner );
419 ok( ret == 0, "GWL_HWNDPARENT return value %p expected 0\n", ret );
420 check_parents( test, desktop, owner, owner, owner, test, hwndMain2 );
421 DestroyWindow( owner );
422 ok( IsWindow(test), "Window %p destroyed by owner destruction\n", test );
423 ok( !IsWindow(owner), "Owner %p not destroyed\n", owner );
424 /* Win98 doesn't pass this test. It doesn't allow a destroyed owner,
425 * while Win95, Win2k, WinXP do.
426 */
427 /*check_parents( test, desktop, owner, owner, owner, test, owner );*/
428 DestroyWindow(test);
429
430 /* final cleanup */
431 DestroyWindow(child);
432 }
433
434
435 static LRESULT WINAPI main_window_procA(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
436 {
437 switch (msg)
438 {
439 case WM_GETMINMAXINFO:
440 {
441 MINMAXINFO* minmax = (MINMAXINFO *)lparam;
442
443 trace("hwnd %p, WM_GETMINMAXINFO, %08x, %08lx\n", hwnd, wparam, lparam);
444 trace("ptReserved (%ld,%ld), ptMaxSize (%ld,%ld), ptMaxPosition (%ld,%ld)\n"
445 " ptMinTrackSize (%ld,%ld), ptMaxTrackSize (%ld,%ld)\n",
446 minmax->ptReserved.x, minmax->ptReserved.y,
447 minmax->ptMaxSize.x, minmax->ptMaxSize.y,
448 minmax->ptMaxPosition.x, minmax->ptMaxPosition.y,
449 minmax->ptMinTrackSize.x, minmax->ptMinTrackSize.y,
450 minmax->ptMaxTrackSize.x, minmax->ptMaxTrackSize.y);
451 SetWindowLongA(hwnd, GWL_USERDATA, 0x20031021);
452 break;
453 }
454 case WM_WINDOWPOSCHANGING:
455 {
456 BOOL is_win9x = GetWindowLongW(hwnd, GWL_WNDPROC) == 0;
457 WINDOWPOS *winpos = (WINDOWPOS *)lparam;
458 trace("main: WM_WINDOWPOSCHANGING\n");
459 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
460 winpos->hwnd, winpos->hwndInsertAfter,
461 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
462 if (!(winpos->flags & SWP_NOMOVE))
463 {
464 ok(winpos->x >= -32768 && winpos->x <= 32767, "bad winpos->x %d\n", winpos->x);
465 ok(winpos->y >= -32768 && winpos->y <= 32767, "bad winpos->y %d\n", winpos->y);
466 }
467 /* Win9x does not fixup cx/xy for WM_WINDOWPOSCHANGING */
468 if (!(winpos->flags & SWP_NOSIZE) && !is_win9x)
469 {
470 ok(winpos->cx >= 0 && winpos->cx <= 32767, "bad winpos->cx %d\n", winpos->cx);
471 ok(winpos->cy >= 0 && winpos->cy <= 32767, "bad winpos->cy %d\n", winpos->cy);
472 }
473 break;
474 }
475 case WM_WINDOWPOSCHANGED:
476 {
477 RECT rc1, rc2;
478 WINDOWPOS *winpos = (WINDOWPOS *)lparam;
479 trace("main: WM_WINDOWPOSCHANGED\n");
480 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
481 winpos->hwnd, winpos->hwndInsertAfter,
482 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
483 ok(winpos->x >= -32768 && winpos->x <= 32767, "bad winpos->x %d\n", winpos->x);
484 ok(winpos->y >= -32768 && winpos->y <= 32767, "bad winpos->y %d\n", winpos->y);
485
486 ok(winpos->cx >= 0 && winpos->cx <= 32767, "bad winpos->cx %d\n", winpos->cx);
487 ok(winpos->cy >= 0 && winpos->cy <= 32767, "bad winpos->cy %d\n", winpos->cy);
488
489 GetWindowRect(hwnd, &rc1);
490 trace("window: (%ld,%ld)-(%ld,%ld)\n", rc1.left, rc1.top, rc1.right, rc1.bottom);
491 SetRect(&rc2, winpos->x, winpos->y, winpos->x + winpos->cx, winpos->y + winpos->cy);
492 /* note: winpos coordinates are relative to parent */
493 MapWindowPoints(GetParent(hwnd), 0, (LPPOINT)&rc2, 2);
494 trace("pos: (%ld,%ld)-(%ld,%ld)\n", rc2.left, rc2.top, rc2.right, rc2.bottom);
495 #if 0 /* Uncomment this once the test succeeds in all cases */
496 ok(EqualRect(&rc1, &rc2), "rects do not match\n");
497 #endif
498
499 GetClientRect(hwnd, &rc2);
500 DefWindowProcA(hwnd, WM_NCCALCSIZE, 0, (LPARAM)&rc1);
501 MapWindowPoints(0, hwnd, (LPPOINT)&rc1, 2);
502 ok(EqualRect(&rc1, &rc2), "rects do not match\n");
503 break;
504 }
505 case WM_NCCREATE:
506 {
507 BOOL got_getminmaxinfo = GetWindowLongA(hwnd, GWL_USERDATA) == 0x20031021;
508 CREATESTRUCTA *cs = (CREATESTRUCTA *)lparam;
509
510 trace("WM_NCCREATE: hwnd %p, parent %p, style %08lx\n", hwnd, cs->hwndParent, cs->style);
511 if (got_getminmaxinfo)
512 trace("%p got WM_GETMINMAXINFO\n", hwnd);
513
514 if ((cs->style & WS_THICKFRAME) || !(cs->style & (WS_POPUP | WS_CHILD)))
515 ok(got_getminmaxinfo, "main: WM_GETMINMAXINFO should have been received before WM_NCCREATE\n");
516 else
517 ok(!got_getminmaxinfo, "main: WM_GETMINMAXINFO should NOT have been received before WM_NCCREATE\n");
518 break;
519 }
520 }
521
522 return DefWindowProcA(hwnd, msg, wparam, lparam);
523 }
524
525 static LRESULT WINAPI tool_window_procA(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
526 {
527 switch (msg)
528 {
529 case WM_GETMINMAXINFO:
530 {
531 MINMAXINFO* minmax = (MINMAXINFO *)lparam;
532
533 trace("hwnd %p, WM_GETMINMAXINFO, %08x, %08lx\n", hwnd, wparam, lparam);
534 trace("ptReserved (%ld,%ld), ptMaxSize (%ld,%ld), ptMaxPosition (%ld,%ld)\n"
535 " ptMinTrackSize (%ld,%ld), ptMaxTrackSize (%ld,%ld)\n",
536 minmax->ptReserved.x, minmax->ptReserved.y,
537 minmax->ptMaxSize.x, minmax->ptMaxSize.y,
538 minmax->ptMaxPosition.x, minmax->ptMaxPosition.y,
539 minmax->ptMinTrackSize.x, minmax->ptMinTrackSize.y,
540 minmax->ptMaxTrackSize.x, minmax->ptMaxTrackSize.y);
541 SetWindowLongA(hwnd, GWL_USERDATA, 0x20031021);
542 break;
543 }
544 case WM_NCCREATE:
545 {
546 BOOL got_getminmaxinfo = GetWindowLongA(hwnd, GWL_USERDATA) == 0x20031021;
547 CREATESTRUCTA *cs = (CREATESTRUCTA *)lparam;
548
549 trace("WM_NCCREATE: hwnd %p, parent %p, style %08lx\n", hwnd, cs->hwndParent, cs->style);
550 if (got_getminmaxinfo)
551 trace("%p got WM_GETMINMAXINFO\n", hwnd);
552
553 if ((cs->style & WS_THICKFRAME) || !(cs->style & (WS_POPUP | WS_CHILD)))
554 ok(got_getminmaxinfo, "tool: WM_GETMINMAXINFO should have been received before WM_NCCREATE\n");
555 else
556 ok(!got_getminmaxinfo, "tool: WM_GETMINMAXINFO should NOT have been received before WM_NCCREATE\n");
557 break;
558 }
559 }
560
561 return DefWindowProcA(hwnd, msg, wparam, lparam);
562 }
563
564 static BOOL RegisterWindowClasses(void)
565 {
566 WNDCLASSA cls;
567
568 cls.style = 0;
569 cls.lpfnWndProc = main_window_procA;
570 cls.cbClsExtra = 0;
571 cls.cbWndExtra = 0;
572 cls.hInstance = GetModuleHandleA(0);
573 cls.hIcon = 0;
574 cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
575 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
576 cls.lpszMenuName = NULL;
577 cls.lpszClassName = "MainWindowClass";
578
579 if(!RegisterClassA(&cls)) return FALSE;
580
581 cls.style = 0;
582 cls.lpfnWndProc = tool_window_procA;
583 cls.cbClsExtra = 0;
584 cls.cbWndExtra = 0;
585 cls.hInstance = GetModuleHandleA(0);
586 cls.hIcon = 0;
587 cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
588 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
589 cls.lpszMenuName = NULL;
590 cls.lpszClassName = "ToolWindowClass";
591
592 if(!RegisterClassA(&cls)) return FALSE;
593
594 return TRUE;
595 }
596
597 static void verify_window_info(HWND hwnd, const WINDOWINFO *info, BOOL test_borders)
598 {
599 RECT rcWindow, rcClient;
600 UINT border;
601 DWORD status;
602
603 ok(IsWindow(hwnd), "bad window handle\n");
604
605 GetWindowRect(hwnd, &rcWindow);
606 ok(EqualRect(&rcWindow, &info->rcWindow), "wrong rcWindow\n");
607
608 GetClientRect(hwnd, &rcClient);
609 /* translate to screen coordinates */
610 MapWindowPoints(hwnd, 0, (LPPOINT)&rcClient, 2);
611 ok(EqualRect(&rcClient, &info->rcClient), "wrong rcClient\n");
612
613 ok(info->dwStyle == (DWORD)GetWindowLongA(hwnd, GWL_STYLE), "wrong dwStyle\n");
614 ok(info->dwExStyle == (DWORD)GetWindowLongA(hwnd, GWL_EXSTYLE), "wrong dwExStyle\n");
615 status = (GetActiveWindow() == hwnd) ? WS_ACTIVECAPTION : 0;
616 ok(info->dwWindowStatus == status, "wrong dwWindowStatus\n");
617
618 if (test_borders && !IsRectEmpty(&rcWindow))
619 {
620 trace("rcWindow: %ld,%ld - %ld,%ld\n", rcWindow.left, rcWindow.top, rcWindow.right, rcWindow.bottom);
621 trace("rcClient: %ld,%ld - %ld,%ld\n", rcClient.left, rcClient.top, rcClient.right, rcClient.bottom);
622
623 ok(info->cxWindowBorders == (unsigned)(rcClient.left - rcWindow.left),
624 "wrong cxWindowBorders %d != %ld\n", info->cxWindowBorders, rcClient.left - rcWindow.left);
625 border = min(rcWindow.bottom - rcClient.bottom, rcClient.top - rcWindow.top);
626 ok(info->cyWindowBorders == border,
627 "wrong cyWindowBorders %d != %d\n", info->cyWindowBorders, border);
628 }
629
630 ok(info->atomWindowType == GetClassLongA(hwnd, GCW_ATOM), "wrong atomWindowType\n");
631 ok(info->wCreatorVersion == 0x0400, "wrong wCreatorVersion %04x\n", info->wCreatorVersion);
632 }
633
634 static void test_nonclient_area(HWND hwnd)
635 {
636 DWORD style, exstyle;
637 RECT rc_window, rc_client, rc;
638 BOOL menu;
639
640 style = GetWindowLongA(hwnd, GWL_STYLE);
641 exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
642 menu = !(style & WS_CHILD) && GetMenu(hwnd) != 0;
643
644 GetWindowRect(hwnd, &rc_window);
645 trace("window: (%ld,%ld)-(%ld,%ld)\n", rc_window.left, rc_window.top, rc_window.right, rc_window.bottom);
646 GetClientRect(hwnd, &rc_client);
647 trace("client: (%ld,%ld)-(%ld,%ld)\n", rc_client.left, rc_client.top, rc_client.right, rc_client.bottom);
648
649 /* avoid some cases when things go wrong */
650 if (IsRectEmpty(&rc_window) || IsRectEmpty(&rc_client) ||
651 rc_window.right > 32768 || rc_window.bottom > 32768) return;
652
653 CopyRect(&rc, &rc_client);
654 MapWindowPoints(hwnd, 0, (LPPOINT)&rc, 2);
655 AdjustWindowRectEx(&rc, style, menu, exstyle);
656 trace("calc window: (%ld,%ld)-(%ld,%ld)\n", rc.left, rc.top, rc.right, rc.bottom);
657 #if 0 /* Uncomment this once the test succeeds in all cases */
658 ok(EqualRect(&rc, &rc_window), "window rect does not match\n");
659 #endif
660
661 CopyRect(&rc, &rc_window);
662 DefWindowProcA(hwnd, WM_NCCALCSIZE, 0, (LPARAM)&rc);
663 MapWindowPoints(0, hwnd, (LPPOINT)&rc, 2);
664 trace("calc client: (%ld,%ld)-(%ld,%ld)\n", rc.left, rc.top, rc.right, rc.bottom);
665 #if 0 /* Uncomment this once the test succeeds in all cases */
666 ok(EqualRect(&rc, &rc_client), "client rect does not match\n");
667 #endif
668
669 /* and now test AdjustWindowRectEx and WM_NCCALCSIZE on synthetic data */
670 SetRect(&rc_client, 0, 0, 250, 150);
671 CopyRect(&rc_window, &rc_client);
672 MapWindowPoints(hwnd, 0, (LPPOINT)&rc_window, 2);
673 AdjustWindowRectEx(&rc_window, style, menu, exstyle);
674 trace("calc window: (%ld,%ld)-(%ld,%ld)\n",
675 rc_window.left, rc_window.top, rc_window.right, rc_window.bottom);
676
677 CopyRect(&rc, &rc_window);
678 DefWindowProcA(hwnd, WM_NCCALCSIZE, 0, (LPARAM)&rc);
679 MapWindowPoints(0, hwnd, (LPPOINT)&rc, 2);
680 trace("calc client: (%ld,%ld)-(%ld,%ld)\n", rc.left, rc.top, rc.right, rc.bottom);
681 #if 0 /* Uncomment this once the test succeeds in all cases */
682 ok(EqualRect(&rc, &rc_client), "client rect does not match\n");
683 #endif
684 }
685
686 static LRESULT CALLBACK cbt_hook_proc(int nCode, WPARAM wParam, LPARAM lParam)
687 {
688 static const char *CBT_code_name[10] = {
689 "HCBT_MOVESIZE",
690 "HCBT_MINMAX",
691 "HCBT_QS",
692 "HCBT_CREATEWND",
693 "HCBT_DESTROYWND",
694 "HCBT_ACTIVATE",
695 "HCBT_CLICKSKIPPED",
696 "HCBT_KEYSKIPPED",
697 "HCBT_SYSCOMMAND",
698 "HCBT_SETFOCUS" };
699 const char *code_name = (nCode >= 0 && nCode <= HCBT_SETFOCUS) ? CBT_code_name[nCode] : "Unknown";
700
701 trace("CBT: %d (%s), %08x, %08lx\n", nCode, code_name, wParam, lParam);
702
703 /* on HCBT_DESTROYWND window state is undefined */
704 if (nCode != HCBT_DESTROYWND && wParam)
705 {
706 BOOL is_win9x = GetWindowLongW((HWND)wParam, GWL_WNDPROC) == 0;
707 if (is_win9x && nCode == HCBT_CREATEWND)
708 /* Win9x doesn't like WM_NCCALCSIZE with synthetic data and crashes */;
709 else
710 test_nonclient_area((HWND)wParam);
711
712 if (pGetWindowInfo)
713 {
714 WINDOWINFO info;
715
716 /* Win98 actually does check the info.cbSize and doesn't allow
717 * it to be anything except sizeof(WINDOWINFO), while Win95, Win2k,
718 * WinXP do not check it at all.
719 */
720 info.cbSize = sizeof(WINDOWINFO);
721 ok(pGetWindowInfo((HWND)wParam, &info), "GetWindowInfo should not fail\n");
722 /* win2k SP4 returns broken border info if GetWindowInfo
723 * is being called from HCBT_DESTROYWND or HCBT_MINMAX hook proc.
724 */
725 verify_window_info((HWND)wParam, &info, nCode != HCBT_MINMAX);
726 }
727 }
728
729 switch (nCode)
730 {
731 case HCBT_CREATEWND:
732 {
733 #if 0 /* Uncomment this once the test succeeds in all cases */
734 static const RECT rc_null;
735 RECT rc;
736 #endif
737 LONG style;
738 CBT_CREATEWNDA *createwnd = (CBT_CREATEWNDA *)lParam;
739 trace("HCBT_CREATEWND: hwnd %p, parent %p, style %08lx\n",
740 (HWND)wParam, createwnd->lpcs->hwndParent, createwnd->lpcs->style);
741 ok(createwnd->hwndInsertAfter == HWND_TOP, "hwndInsertAfter should be always HWND_TOP\n");
742
743 /* WS_VISIBLE should be turned off yet */
744 style = createwnd->lpcs->style & ~WS_VISIBLE;
745 ok(style == GetWindowLongA((HWND)wParam, GWL_STYLE),
746 "style of hwnd and style in the CREATESTRUCT do not match: %08lx != %08lx\n",
747 GetWindowLongA((HWND)wParam, GWL_STYLE), style);
748
749 #if 0 /* Uncomment this once the test succeeds in all cases */
750 if ((style & (WS_CHILD|WS_POPUP)) == WS_CHILD)
751 {
752 ok(GetParent((HWND)wParam) == hwndMessage,
753 "wrong result from GetParent %p: message window %p\n",
754 GetParent((HWND)wParam), hwndMessage);
755 }
756 else
757 ok(!GetParent((HWND)wParam), "GetParent should return 0 at this point\n");
758
759 ok(!GetWindow((HWND)wParam, GW_OWNER), "GW_OWNER should be set to 0 at this point\n");
760 #endif
761 #if 0 /* while NT assigns GW_HWNDFIRST/LAST some values at this point,
762 * Win9x still has them set to 0.
763 */
764 ok(GetWindow((HWND)wParam, GW_HWNDFIRST) != 0, "GW_HWNDFIRST should not be set to 0 at this point\n");
765 ok(GetWindow((HWND)wParam, GW_HWNDLAST) != 0, "GW_HWNDLAST should not be set to 0 at this point\n");
766 #endif
767 ok(!GetWindow((HWND)wParam, GW_HWNDPREV), "GW_HWNDPREV should be set to 0 at this point\n");
768 ok(!GetWindow((HWND)wParam, GW_HWNDNEXT), "GW_HWNDNEXT should be set to 0 at this point\n");
769
770 #if 0 /* Uncomment this once the test succeeds in all cases */
771 if (pGetAncestor)
772 {
773 ok(pGetAncestor((HWND)wParam, GA_PARENT) == hwndMessage, "GA_PARENT should be set to hwndMessage at this point\n");
774 ok(pGetAncestor((HWND)wParam, GA_ROOT) == (HWND)wParam,
775 "GA_ROOT is set to %p, expected %p\n", pGetAncestor((HWND)wParam, GA_ROOT), (HWND)wParam);
776
777 if ((style & (WS_CHILD|WS_POPUP)) == WS_CHILD)
778 ok(pGetAncestor((HWND)wParam, GA_ROOTOWNER) == hwndMessage,
779 "GA_ROOTOWNER should be set to hwndMessage at this point\n");
780 else
781 ok(pGetAncestor((HWND)wParam, GA_ROOTOWNER) == (HWND)wParam,
782 "GA_ROOTOWNER is set to %p, expected %p\n", pGetAncestor((HWND)wParam, GA_ROOTOWNER), (HWND)wParam);
783 }
784
785 ok(GetWindowRect((HWND)wParam, &rc), "GetWindowRect failed\n");
786 ok(EqualRect(&rc, &rc_null), "window rect should be set to 0 HCBT_CREATEWND\n");
787 ok(GetClientRect((HWND)wParam, &rc), "GetClientRect failed\n");
788 ok(EqualRect(&rc, &rc_null), "client rect should be set to 0 on HCBT_CREATEWND\n");
789 #endif
790 break;
791 }
792 }
793
794 return CallNextHookEx(hhook, nCode, wParam, lParam);
795 }
796
797 static void test_shell_window()
798 {
799 BOOL ret;
800 DWORD error;
801 HMODULE hinst, hUser32;
802 BOOL (WINAPI*SetShellWindow)(HWND);
803 BOOL (WINAPI*SetShellWindowEx)(HWND, HWND);
804 HWND hwnd1, hwnd2, hwnd3, hwnd4, hwnd5;
805 HWND shellWindow, nextWnd;
806
807 shellWindow = GetShellWindow();
808 hinst = GetModuleHandle(0);
809 hUser32 = GetModuleHandleA("user32");
810
811 SetShellWindow = (void *)GetProcAddress(hUser32, "SetShellWindow");
812 SetShellWindowEx = (void *)GetProcAddress(hUser32, "SetShellWindowEx");
813
814 trace("previous shell window: %p\n", shellWindow);
815
816 if (shellWindow) {
817 DWORD pid;
818 HANDLE hProcess;
819
820 ret = DestroyWindow(shellWindow);
821 error = GetLastError();
822
823 ok(!ret, "DestroyWindow(shellWindow)\n");
824 /* passes on Win XP, but not on Win98
825 ok(error==ERROR_ACCESS_DENIED, "ERROR_ACCESS_DENIED after DestroyWindow(shellWindow)\n"); */
826
827 /* close old shell instance */
828 GetWindowThreadProcessId(shellWindow, &pid);
829 hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
830 ret = TerminateProcess(hProcess, 0);
831 ok(ret, "termination of previous shell process failed: GetLastError()=%ld\n", GetLastError());
832 WaitForSingleObject(hProcess, INFINITE); /* wait for termination */
833 CloseHandle(hProcess);
834 }
835
836 hwnd1 = CreateWindowEx(0, TEXT("#32770"), TEXT("TEST1"), WS_OVERLAPPEDWINDOW/*|WS_VISIBLE*/, 100, 100, 300, 200, 0, 0, hinst, 0);
837 trace("created window 1: %p\n", hwnd1);
838
839 ret = SetShellWindow(hwnd1);
840 ok(ret, "first call to SetShellWindow(hwnd1)\n");
841 shellWindow = GetShellWindow();
842 ok(shellWindow==hwnd1, "wrong shell window: %p\n", shellWindow);
843
844 ret = SetShellWindow(hwnd1);
845 ok(!ret, "second call to SetShellWindow(hwnd1)\n");
846
847 ret = SetShellWindow(0);
848 error = GetLastError();
849 /* passes on Win XP, but not on Win98
850 ok(!ret, "reset shell window by SetShellWindow(0)\n");
851 ok(error==ERROR_INVALID_WINDOW_HANDLE, "ERROR_INVALID_WINDOW_HANDLE after SetShellWindow(0)\n"); */
852
853 ret = SetShellWindow(hwnd1);
854 /* passes on Win XP, but not on Win98
855 ok(!ret, "third call to SetShellWindow(hwnd1)\n"); */
856
857 todo_wine
858 {
859 SetWindowLong(hwnd1, GWL_EXSTYLE, GetWindowLong(hwnd1,GWL_EXSTYLE)|WS_EX_TOPMOST);
860 ret = GetWindowLong(hwnd1,GWL_EXSTYLE)&WS_EX_TOPMOST? TRUE: FALSE;
861 ok(!ret, "SetWindowExStyle(hwnd1, WS_EX_TOPMOST)\n");
862 }
863
864 ret = DestroyWindow(hwnd1);
865 ok(ret, "DestroyWindow(hwnd1)\n");
866
867 hwnd2 = CreateWindowEx(WS_EX_TOPMOST, TEXT("#32770"), TEXT("TEST2"), WS_OVERLAPPEDWINDOW/*|WS_VISIBLE*/, 150, 250, 300, 200, 0, 0, hinst, 0);
868 trace("created window 2: %p\n", hwnd2);
869 ret = SetShellWindow(hwnd2);
870 ok(!ret, "SetShellWindow(hwnd2) with WS_EX_TOPMOST\n");
871
872 hwnd3 = CreateWindowEx(0, TEXT("#32770"), TEXT("TEST3"), WS_OVERLAPPEDWINDOW/*|WS_VISIBLE*/, 200, 400, 300, 200, 0, 0, hinst, 0);
873 trace("created window 3: %p\n", hwnd3);
874
875 hwnd4 = CreateWindowEx(0, TEXT("#32770"), TEXT("TEST4"), WS_OVERLAPPEDWINDOW/*|WS_VISIBLE*/, 250, 500, 300, 200, 0, 0, hinst, 0);
876 trace("created window 4: %p\n", hwnd4);
877
878 nextWnd = GetWindow(hwnd4, GW_HWNDNEXT);
879 ok(nextWnd==hwnd3, "wrong next window for hwnd4: %p - expected hwnd3\n", nextWnd);
880
881 ret = SetShellWindow(hwnd4);
882 ok(ret, "SetShellWindow(hwnd4)\n");
883 shellWindow = GetShellWindow();
884 ok(shellWindow==hwnd4, "wrong shell window: %p - expected hwnd4\n", shellWindow);
885
886 nextWnd = GetWindow(hwnd4, GW_HWNDNEXT);
887 ok(nextWnd==0, "wrong next window for hwnd4: %p - expected 0\n", nextWnd);
888
889 ret = SetWindowPos(hwnd4, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE);
890 ok(ret, "SetWindowPos(hwnd4, HWND_TOPMOST)\n");
891
892 ret = SetWindowPos(hwnd4, hwnd3, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE);
893 ok(ret, "SetWindowPos(hwnd4, hwnd3\n");
894
895 ret = SetShellWindow(hwnd3);
896 ok(!ret, "SetShellWindow(hwnd3)\n");
897 shellWindow = GetShellWindow();
898 ok(shellWindow==hwnd4, "wrong shell window: %p - expected hwnd4\n", shellWindow);
899
900 hwnd5 = CreateWindowEx(0, TEXT("#32770"), TEXT("TEST5"), WS_OVERLAPPEDWINDOW/*|WS_VISIBLE*/, 300, 600, 300, 200, 0, 0, hinst, 0);
901 trace("created window 5: %p\n", hwnd5);
902 ret = SetWindowPos(hwnd4, hwnd5, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE);
903 ok(ret, "SetWindowPos(hwnd4, hwnd5)\n");
904
905 todo_wine
906 {
907 nextWnd = GetWindow(hwnd4, GW_HWNDNEXT);
908 ok(nextWnd==0, "wrong next window for hwnd4 after SetWindowPos(): %p - expected 0\n", nextWnd);
909 }
910
911 /* destroy test windows */
912 DestroyWindow(hwnd2);
913 DestroyWindow(hwnd3);
914 DestroyWindow(hwnd4);
915 DestroyWindow(hwnd5);
916 }
917
918 /************** MDI test ****************/
919
920 static const char mdi_lParam_test_message[] = "just a test string";
921
922 static void test_MDI_create(HWND parent, HWND mdi_client)
923 {
924 MDICREATESTRUCTA mdi_cs;
925 HWND mdi_child;
926 static const WCHAR classW[] = {'M','D','I','_','c','h','i','l','d','_','C','l','a','s','s','_','1',0};
927 static const WCHAR titleW[] = {'M','D','I',' ','c','h','i','l','d',0};
928 BOOL isWin9x = FALSE;
929
930 mdi_cs.szClass = "MDI_child_Class_1";
931 mdi_cs.szTitle = "MDI child";
932 mdi_cs.hOwner = GetModuleHandle(0);
933 mdi_cs.x = CW_USEDEFAULT;
934 mdi_cs.y = CW_USEDEFAULT;
935 mdi_cs.cx = CW_USEDEFAULT;
936 mdi_cs.cy = CW_USEDEFAULT;
937 mdi_cs.style = 0;
938 mdi_cs.lParam = (LPARAM)mdi_lParam_test_message;
939 mdi_child = (HWND)SendMessageA(mdi_client, WM_MDICREATE, 0, (LPARAM)&mdi_cs);
940 ok(mdi_child != 0, "MDI child creation failed\n");
941 DestroyWindow(mdi_child);
942
943 mdi_cs.style = 0x7fffffff; /* without WS_POPUP */
944 mdi_child = (HWND)SendMessageA(mdi_client, WM_MDICREATE, 0, (LPARAM)&mdi_cs);
945 ok(mdi_child != 0, "MDI child creation failed\n");
946 DestroyWindow(mdi_child);
947
948 mdi_cs.style = 0xffffffff; /* with WS_POPUP */
949 mdi_child = (HWND)SendMessageA(mdi_client, WM_MDICREATE, 0, (LPARAM)&mdi_cs);
950 if (GetWindowLongA(mdi_client, GWL_STYLE) & MDIS_ALLCHILDSTYLES)
951 {
952 ok(!mdi_child, "MDI child with WS_POPUP and with MDIS_ALLCHILDSTYLES should fail\n");
953 DestroyWindow(mdi_child);
954 }
955 else
956 ok(mdi_child != 0, "MDI child creation failed\n");
957
958 /* test MDICREATESTRUCT A<->W mapping */
959 /* MDICREATESTRUCTA and MDICREATESTRUCTW have the same layout */
960 mdi_cs.style = 0;
961 mdi_cs.szClass = (LPCSTR)classW;
962 mdi_cs.szTitle = (LPCSTR)titleW;
963 SetLastError(0xdeadbeef);
964 mdi_child = (HWND)SendMessageW(mdi_client, WM_MDICREATE, 0, (LPARAM)&mdi_cs);
965 if (!mdi_child)
966 {
967 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
968 isWin9x = TRUE;
969 else
970 ok(mdi_child != 0, "MDI child creation failed\n");
971 }
972 DestroyWindow(mdi_child);
973
974 mdi_child = CreateMDIWindowA("MDI_child_Class_1", "MDI child",
975 0,
976 CW_USEDEFAULT, CW_USEDEFAULT,
977 CW_USEDEFAULT, CW_USEDEFAULT,
978 mdi_client, GetModuleHandle(0),
979 (LPARAM)mdi_lParam_test_message);
980 ok(mdi_child != 0, "MDI child creation failed\n");
981 DestroyWindow(mdi_child);
982
983 mdi_child = CreateMDIWindowA("MDI_child_Class_1", "MDI child",
984 0x7fffffff, /* without WS_POPUP */
985 CW_USEDEFAULT, CW_USEDEFAULT,
986 CW_USEDEFAULT, CW_USEDEFAULT,
987 mdi_client, GetModuleHandle(0),
988 (LPARAM)mdi_lParam_test_message);
989 ok(mdi_child != 0, "MDI child creation failed\n");
990 DestroyWindow(mdi_child);
991
992 mdi_child = CreateMDIWindowA("MDI_child_Class_1", "MDI child",
993 0xffffffff, /* with WS_POPUP */
994 CW_USEDEFAULT, CW_USEDEFAULT,
995 CW_USEDEFAULT, CW_USEDEFAULT,
996 mdi_client, GetModuleHandle(0),
997 (LPARAM)mdi_lParam_test_message);
998 if (GetWindowLongA(mdi_client, GWL_STYLE) & MDIS_ALLCHILDSTYLES)
999 {
1000 ok(!mdi_child, "MDI child with WS_POPUP and with MDIS_ALLCHILDSTYLES should fail\n");
1001 DestroyWindow(mdi_child);
1002 }
1003 else
1004 ok(mdi_child != 0, "MDI child creation failed\n");
1005
1006 /* test MDICREATESTRUCT A<->W mapping */
1007 SetLastError(0xdeadbeef);
1008 mdi_child = CreateMDIWindowW(classW, titleW,
1009 0,
1010 CW_USEDEFAULT, CW_USEDEFAULT,
1011 CW_USEDEFAULT, CW_USEDEFAULT,
1012 mdi_client, GetModuleHandle(0),
1013 (LPARAM)mdi_lParam_test_message);
1014 if (!mdi_child)
1015 {
1016 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1017 isWin9x = TRUE;
1018 else
1019 ok(mdi_child != 0, "MDI child creation failed\n");
1020 }
1021 DestroyWindow(mdi_child);
1022
1023 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_Class_1", "MDI child",
1024 0,
1025 CW_USEDEFAULT, CW_USEDEFAULT,
1026 CW_USEDEFAULT, CW_USEDEFAULT,
1027 mdi_client, 0, GetModuleHandle(0),
1028 (LPVOID)mdi_lParam_test_message);
1029 ok(mdi_child != 0, "MDI child creation failed\n");
1030 DestroyWindow(mdi_child);
1031
1032 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_Class_1", "MDI child",
1033 0x7fffffff, /* without WS_POPUP */
1034 CW_USEDEFAULT, CW_USEDEFAULT,
1035 CW_USEDEFAULT, CW_USEDEFAULT,
1036 mdi_client, 0, GetModuleHandle(0),
1037 (LPVOID)mdi_lParam_test_message);
1038 ok(mdi_child != 0, "MDI child creation failed\n");
1039 DestroyWindow(mdi_child);
1040
1041 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_Class_1", "MDI child",
1042 0xffffffff, /* with WS_POPUP */
1043 CW_USEDEFAULT, CW_USEDEFAULT,
1044 CW_USEDEFAULT, CW_USEDEFAULT,
1045 mdi_client, 0, GetModuleHandle(0),
1046 (LPVOID)mdi_lParam_test_message);
1047 if (GetWindowLongA(mdi_client, GWL_STYLE) & MDIS_ALLCHILDSTYLES)
1048 {
1049 ok(!mdi_child, "MDI child with WS_POPUP and with MDIS_ALLCHILDSTYLES should fail\n");
1050 DestroyWindow(mdi_child);
1051 }
1052 else
1053 ok(mdi_child != 0, "MDI child creation failed\n");
1054
1055 /* test MDICREATESTRUCT A<->W mapping */
1056 SetLastError(0xdeadbeef);
1057 mdi_child = CreateWindowExW(WS_EX_MDICHILD, classW, titleW,
1058 0,
1059 CW_USEDEFAULT, CW_USEDEFAULT,
1060 CW_USEDEFAULT, CW_USEDEFAULT,
1061 mdi_client, 0, GetModuleHandle(0),
1062 (LPVOID)mdi_lParam_test_message);
1063 if (!mdi_child)
1064 {
1065 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1066 isWin9x = TRUE;
1067 else
1068 ok(mdi_child != 0, "MDI child creation failed\n");
1069 }
1070 DestroyWindow(mdi_child);
1071
1072 /* This test fails on Win9x */
1073 if (!isWin9x)
1074 {
1075 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_Class_2", "MDI child",
1076 WS_CHILD,
1077 CW_USEDEFAULT, CW_USEDEFAULT,
1078 CW_USEDEFAULT, CW_USEDEFAULT,
1079 parent, 0, GetModuleHandle(0),
1080 (LPVOID)mdi_lParam_test_message);
1081 ok(!mdi_child, "WS_EX_MDICHILD with a not MDIClient parent should fail\n");
1082 }
1083
1084 mdi_child = CreateWindowExA(0, "MDI_child_Class_2", "MDI child",
1085 WS_CHILD, /* without WS_POPUP */
1086 CW_USEDEFAULT, CW_USEDEFAULT,
1087 CW_USEDEFAULT, CW_USEDEFAULT,
1088 mdi_client, 0, GetModuleHandle(0),
1089 (LPVOID)mdi_lParam_test_message);
1090 ok(mdi_child != 0, "MDI child creation failed\n");
1091 DestroyWindow(mdi_child);
1092
1093 mdi_child = CreateWindowExA(0, "MDI_child_Class_2", "MDI child",
1094 WS_CHILD | WS_POPUP, /* with WS_POPUP */
1095 CW_USEDEFAULT, CW_USEDEFAULT,
1096 CW_USEDEFAULT, CW_USEDEFAULT,
1097 mdi_client, 0, GetModuleHandle(0),
1098 (LPVOID)mdi_lParam_test_message);
1099 ok(mdi_child != 0, "MDI child creation failed\n");
1100 DestroyWindow(mdi_child);
1101
1102 /* maximized child */
1103 mdi_child = CreateWindowExA(0, "MDI_child_Class_2", "MDI child",
1104 WS_CHILD | WS_MAXIMIZE,
1105 CW_USEDEFAULT, CW_USEDEFAULT,
1106 CW_USEDEFAULT, CW_USEDEFAULT,
1107 mdi_client, 0, GetModuleHandle(0),
1108 (LPVOID)mdi_lParam_test_message);
1109 ok(mdi_child != 0, "MDI child creation failed\n");
1110 DestroyWindow(mdi_child);
1111
1112 trace("Creating maximized child with a caption\n");
1113 mdi_child = CreateWindowExA(0, "MDI_child_Class_2", "MDI child",
1114 WS_CHILD | WS_MAXIMIZE | WS_CAPTION,
1115 CW_USEDEFAULT, CW_USEDEFAULT,
1116 CW_USEDEFAULT, CW_USEDEFAULT,
1117 mdi_client, 0, GetModuleHandle(0),
1118 (LPVOID)mdi_lParam_test_message);
1119 ok(mdi_child != 0, "MDI child creation failed\n");
1120 DestroyWindow(mdi_child);
1121
1122 trace("Creating maximized child with a caption and a thick frame\n");
1123 mdi_child = CreateWindowExA(0, "MDI_child_Class_2", "MDI child",
1124 WS_CHILD | WS_MAXIMIZE | WS_CAPTION | WS_THICKFRAME,
1125 CW_USEDEFAULT, CW_USEDEFAULT,
1126 CW_USEDEFAULT, CW_USEDEFAULT,
1127 mdi_client, 0, GetModuleHandle(0),
1128 (LPVOID)mdi_lParam_test_message);
1129 ok(mdi_child != 0, "MDI child creation failed\n");
1130 DestroyWindow(mdi_child);
1131 }
1132
1133 /**********************************************************************
1134 * MDI_ChildGetMinMaxInfo (copied from windows/mdi.c)
1135 *
1136 * Note: The rule here is that client rect of the maximized MDI child
1137 * is equal to the client rect of the MDI client window.
1138 */
1139 static void MDI_ChildGetMinMaxInfo( HWND client, HWND hwnd, MINMAXINFO* lpMinMax )
1140 {
1141 RECT rect;
1142
1143 GetClientRect( client, &rect );
1144 AdjustWindowRectEx( &rect, GetWindowLongA( hwnd, GWL_STYLE ),
1145 0, GetWindowLongA( hwnd, GWL_EXSTYLE ));
1146
1147 rect.right -= rect.left;
1148 rect.bottom -= rect.top;
1149 lpMinMax->ptMaxSize.x = rect.right;
1150 lpMinMax->ptMaxSize.y = rect.bottom;
1151
1152 lpMinMax->ptMaxPosition.x = rect.left;
1153 lpMinMax->ptMaxPosition.y = rect.top;
1154
1155 trace("max rect (%ld,%ld - %ld, %ld)\n",
1156 rect.left, rect.top, rect.right, rect.bottom);
1157 }
1158
1159 static LRESULT WINAPI mdi_child_wnd_proc_1(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
1160 {
1161 switch (msg)
1162 {
1163 case WM_NCCREATE:
1164 case WM_CREATE:
1165 {
1166 CREATESTRUCTA *cs = (CREATESTRUCTA *)lparam;
1167 MDICREATESTRUCTA *mdi_cs = (MDICREATESTRUCTA *)cs->lpCreateParams;
1168
1169 ok(cs->dwExStyle & WS_EX_MDICHILD, "WS_EX_MDICHILD should be set\n");
1170 ok(mdi_cs->lParam == (LPARAM)mdi_lParam_test_message, "wrong mdi_cs->lParam\n");
1171
1172 ok(!lstrcmpA(cs->lpszClass, "MDI_child_Class_1"), "wrong class name\n");
1173 ok(!lstrcmpA(cs->lpszClass, mdi_cs->szClass), "class name does not match\n");
1174 ok(!lstrcmpA(cs->lpszName, "MDI child"), "wrong title\n");
1175 ok(!lstrcmpA(cs->lpszName, mdi_cs->szTitle), "title does not match\n");
1176 ok(cs->hInstance == mdi_cs->hOwner, "%p != %p\n", cs->hInstance, mdi_cs->hOwner);
1177
1178 /* MDICREATESTRUCT should have original values */
1179 ok(mdi_cs->style == 0 || mdi_cs->style == 0x7fffffff || mdi_cs->style == 0xffffffff,
1180 "mdi_cs->style does not match (%08lx)\n", mdi_cs->style);
1181 ok(mdi_cs->x == CW_USEDEFAULT, "%d != CW_USEDEFAULT\n", mdi_cs->x);
1182 ok(mdi_cs->y == CW_USEDEFAULT, "%d != CW_USEDEFAULT\n", mdi_cs->y);
1183 ok(mdi_cs->cx == CW_USEDEFAULT, "%d != CW_USEDEFAULT\n", mdi_cs->cx);
1184 ok(mdi_cs->cy == CW_USEDEFAULT, "%d != CW_USEDEFAULT\n", mdi_cs->cy);
1185
1186 /* CREATESTRUCT should have fixed values */
1187 ok(cs->x != CW_USEDEFAULT, "%d == CW_USEDEFAULT\n", cs->x);
1188 ok(cs->y != CW_USEDEFAULT, "%d == CW_USEDEFAULT\n", cs->y);
1189
1190 /* cx/cy == CW_USEDEFAULT are translated to NOT zero values */
1191 ok(cs->cx != CW_USEDEFAULT && cs->cx != 0, "%d == CW_USEDEFAULT\n", cs->cx);
1192 ok(cs->cy != CW_USEDEFAULT && cs->cy != 0, "%d == CW_USEDEFAULT\n", cs->cy);
1193
1194 ok(!(cs->style & WS_POPUP), "WS_POPUP is not allowed\n");
1195
1196 if (GetWindowLongA(cs->hwndParent, GWL_STYLE) & MDIS_ALLCHILDSTYLES)
1197 {
1198 LONG style = mdi_cs->style | WS_CHILD | WS_CLIPSIBLINGS;
1199 ok(cs->style == style,
1200 "cs->style does not match (%08lx)\n", cs->style);
1201 }
1202 else
1203 {
1204 LONG style = mdi_cs->style;
1205 style &= ~WS_POPUP;
1206 style |= WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CAPTION |
1207 WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
1208 ok(cs->style == style,
1209 "cs->style does not match (%08lx)\n", cs->style);
1210 }
1211 break;
1212 }
1213
1214 case WM_GETMINMAXINFO:
1215 {
1216 HWND client = GetParent(hwnd);
1217 RECT rc;
1218 MINMAXINFO *minmax = (MINMAXINFO *)lparam;
1219 MINMAXINFO my_minmax;
1220 LONG style, exstyle;
1221
1222 style = GetWindowLongA(hwnd, GWL_STYLE);
1223 exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
1224
1225 GetWindowRect(client, &rc);
1226 trace("MDI client %p window size = (%ld x %ld)\n", client, rc.right-rc.left, rc.bottom-rc.top);
1227 GetClientRect(client, &rc);
1228 trace("MDI client %p client size = (%ld x %ld)\n", client, rc.right, rc.bottom);
1229 trace("screen size: %d x %d\n", GetSystemMetrics(SM_CXSCREEN),
1230 GetSystemMetrics(SM_CYSCREEN));
1231
1232 GetClientRect(client, &rc);
1233 if ((style & WS_CAPTION) == WS_CAPTION)
1234 style &= ~WS_BORDER; /* WS_CAPTION = WS_DLGFRAME | WS_BORDER */
1235 AdjustWindowRectEx(&rc, style, 0, exstyle);
1236 trace("MDI child: calculated max window size = (%ld x %ld)\n", rc.right-rc.left, rc.bottom-rc.top);
1237
1238 trace("ptReserved = (%ld,%ld)\n"
1239 "ptMaxSize = (%ld,%ld)\n"
1240 "ptMaxPosition = (%ld,%ld)\n"
1241 "ptMinTrackSize = (%ld,%ld)\n"
1242 "ptMaxTrackSize = (%ld,%ld)\n",
1243 minmax->ptReserved.x, minmax->ptReserved.y,
1244 minmax->ptMaxSize.x, minmax->ptMaxSize.y,
1245 minmax->ptMaxPosition.x, minmax->ptMaxPosition.y,
1246 minmax->ptMinTrackSize.x, minmax->ptMinTrackSize.y,
1247 minmax->ptMaxTrackSize.x, minmax->ptMaxTrackSize.y);
1248
1249 ok(minmax->ptMaxSize.x == rc.right - rc.left, "default width of maximized child %ld != %ld\n",
1250 minmax->ptMaxSize.x, rc.right - rc.left);
1251 ok(minmax->ptMaxSize.y == rc.bottom - rc.top, "default height of maximized child %ld != %ld\n",
1252 minmax->ptMaxSize.y, rc.bottom - rc.top);
1253
1254 DefMDIChildProcA(hwnd, msg, wparam, lparam);
1255
1256 trace("DefMDIChildProc returned:\n"
1257 "ptReserved = (%ld,%ld)\n"
1258 "ptMaxSize = (%ld,%ld)\n"
1259 "ptMaxPosition = (%ld,%ld)\n"
1260 "ptMinTrackSize = (%ld,%ld)\n"
1261 "ptMaxTrackSize = (%ld,%ld)\n",
1262 minmax->ptReserved.x, minmax->ptReserved.y,
1263 minmax->ptMaxSize.x, minmax->ptMaxSize.y,
1264 minmax->ptMaxPosition.x, minmax->ptMaxPosition.y,
1265 minmax->ptMinTrackSize.x, minmax->ptMinTrackSize.y,
1266 minmax->ptMaxTrackSize.x, minmax->ptMaxTrackSize.y);
1267
1268 MDI_ChildGetMinMaxInfo(client, hwnd, &my_minmax);
1269 ok(minmax->ptMaxSize.x == my_minmax.ptMaxSize.x, "default width of maximized child %ld != %ld\n",
1270 minmax->ptMaxSize.x, my_minmax.ptMaxSize.x);
1271 ok(minmax->ptMaxSize.y == my_minmax.ptMaxSize.y, "default height of maximized child %ld != %ld\n",
1272 minmax->ptMaxSize.y, my_minmax.ptMaxSize.y);
1273
1274 return 1;
1275 }
1276 }
1277 return DefMDIChildProcA(hwnd, msg, wparam, lparam);
1278 }
1279
1280 static LRESULT WINAPI mdi_child_wnd_proc_2(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
1281 {
1282 switch (msg)
1283 {
1284 case WM_NCCREATE:
1285 case WM_CREATE:
1286 {
1287 CREATESTRUCTA *cs = (CREATESTRUCTA *)lparam;
1288
1289 trace("%s\n", (msg == WM_NCCREATE) ? "WM_NCCREATE" : "WM_CREATE");
1290 trace("x %d, y %d, cx %d, cy %d\n", cs->x, cs->y, cs->cx, cs->cy);
1291
1292 ok(!(cs->dwExStyle & WS_EX_MDICHILD), "WS_EX_MDICHILD should not be set\n");
1293 ok(cs->lpCreateParams == mdi_lParam_test_message, "wrong cs->lpCreateParams\n");
1294
1295 ok(!lstrcmpA(cs->lpszClass, "MDI_child_Class_2"), "wrong class name\n");
1296 ok(!lstrcmpA(cs->lpszName, "MDI child"), "wrong title\n");
1297
1298 /* CREATESTRUCT should have fixed values */
1299 /* For some reason Win9x doesn't translate cs->x from CW_USEDEFAULT,
1300 while NT does. */
1301 /*ok(cs->x != CW_USEDEFAULT, "%d == CW_USEDEFAULT\n", cs->x);*/
1302 ok(cs->y != CW_USEDEFAULT, "%d == CW_USEDEFAULT\n", cs->y);
1303
1304 /* cx/cy == CW_USEDEFAULT are translated to 0 */
1305 /* For some reason Win98 doesn't translate cs->cx from CW_USEDEFAULT,
1306 while Win95, Win2k, WinXP do. */
1307 /*ok(cs->cx == 0, "%d != 0\n", cs->cx);*/
1308 ok(cs->cy == 0, "%d != 0\n", cs->cy);
1309 break;
1310 }
1311
1312 case WM_GETMINMAXINFO:
1313 {
1314 HWND parent = GetParent(hwnd);
1315 RECT rc;
1316 MINMAXINFO *minmax = (MINMAXINFO *)lparam;
1317 LONG style, exstyle;
1318
1319 trace("WM_GETMINMAXINFO\n");
1320
1321 style = GetWindowLongA(hwnd, GWL_STYLE);
1322 exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
1323
1324 GetClientRect(parent, &rc);
1325 trace("parent %p client size = (%ld x %ld)\n", parent, rc.right, rc.bottom);
1326
1327 GetClientRect(parent, &rc);
1328 if ((style & WS_CAPTION) == WS_CAPTION)
1329 style &= ~WS_BORDER; /* WS_CAPTION = WS_DLGFRAME | WS_BORDER */
1330 AdjustWindowRectEx(&rc, style, 0, exstyle);
1331 trace("calculated max child window size = (%ld x %ld)\n", rc.right-rc.left, rc.bottom-rc.top);
1332
1333 trace("ptReserved = (%ld,%ld)\n"
1334 "ptMaxSize = (%ld,%ld)\n"
1335 "ptMaxPosition = (%ld,%ld)\n"
1336 "ptMinTrackSize = (%ld,%ld)\n"
1337 "ptMaxTrackSize = (%ld,%ld)\n",
1338 minmax->ptReserved.x, minmax->ptReserved.y,
1339 minmax->ptMaxSize.x, minmax->ptMaxSize.y,
1340 minmax->ptMaxPosition.x, minmax->ptMaxPosition.y,
1341 minmax->ptMinTrackSize.x, minmax->ptMinTrackSize.y,
1342 minmax->ptMaxTrackSize.x, minmax->ptMaxTrackSize.y);
1343
1344 ok(minmax->ptMaxSize.x == rc.right - rc.left, "default width of maximized child %ld != %ld\n",
1345 minmax->ptMaxSize.x, rc.right - rc.left);
1346 ok(minmax->ptMaxSize.y == rc.bottom - rc.top, "default height of maximized child %ld != %ld\n",
1347 minmax->ptMaxSize.y, rc.bottom - rc.top);
1348 break;
1349 }
1350
1351 case WM_WINDOWPOSCHANGED:
1352 {
1353 WINDOWPOS *winpos = (WINDOWPOS *)lparam;
1354 RECT rc1, rc2;
1355
1356 GetWindowRect(hwnd, &rc1);
1357 trace("window: (%ld,%ld)-(%ld,%ld)\n", rc1.left, rc1.top, rc1.right, rc1.bottom);
1358 SetRect(&rc2, winpos->x, winpos->y, winpos->x + winpos->cx, winpos->y + winpos->cy);
1359 /* note: winpos coordinates are relative to parent */
1360 MapWindowPoints(GetParent(hwnd), 0, (LPPOINT)&rc2, 2);
1361 trace("pos: (%ld,%ld)-(%ld,%ld)\n", rc2.left, rc2.top, rc2.right, rc2.bottom);
1362 ok(EqualRect(&rc1, &rc2), "rects do not match\n");
1363
1364 GetWindowRect(hwnd, &rc1);
1365 GetClientRect(hwnd, &rc2);
1366 DefWindowProcA(hwnd, WM_NCCALCSIZE, 0, (LPARAM)&rc1);
1367 MapWindowPoints(0, hwnd, (LPPOINT)&rc1, 2);
1368 ok(EqualRect(&rc1, &rc2), "rects do not match\n");
1369 }
1370 /* fall through */
1371 case WM_WINDOWPOSCHANGING:
1372 {
1373 WINDOWPOS *winpos = (WINDOWPOS *)lparam;
1374 WINDOWPOS my_winpos = *winpos;
1375
1376 trace("%s\n", (msg == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
1377 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
1378 winpos->hwnd, winpos->hwndInsertAfter,
1379 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
1380
1381 DefWindowProcA(hwnd, msg, wparam, lparam);
1382
1383 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
1384 winpos->hwnd, winpos->hwndInsertAfter,
1385 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
1386
1387 ok(!memcmp(&my_winpos, winpos, sizeof(WINDOWPOS)),
1388 "DefWindowProc should not change WINDOWPOS values\n");
1389
1390 return 1;
1391 }
1392 }
1393 return DefWindowProcA(hwnd, msg, wparam, lparam);
1394 }
1395
1396 static LRESULT WINAPI mdi_main_wnd_procA(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
1397 {
1398 static HWND mdi_client;
1399
1400 switch (msg)
1401 {
1402 case WM_CREATE:
1403 {
1404 CLIENTCREATESTRUCT client_cs;
1405 RECT rc;
1406
1407 GetClientRect(hwnd, &rc);
1408
1409 client_cs.hWindowMenu = 0;
1410 client_cs.idFirstChild = 1;
1411
1412 /* MDIClient without MDIS_ALLCHILDSTYLES */
1413 mdi_client = CreateWindowExA(0, "mdiclient",
1414 NULL,
1415 WS_CHILD /*| WS_VISIBLE*/,
1416 /* tests depend on a not zero MDIClient size */
1417 0, 0, rc.right, rc.bottom,
1418 hwnd, 0, GetModuleHandle(0),
1419 (LPVOID)&client_cs);
1420 assert(mdi_client);
1421 test_MDI_create(hwnd, mdi_client);
1422 DestroyWindow(mdi_client);
1423
1424 /* MDIClient with MDIS_ALLCHILDSTYLES */
1425 mdi_client = CreateWindowExA(0, "mdiclient",
1426 NULL,
1427 WS_CHILD | MDIS_ALLCHILDSTYLES /*| WS_VISIBLE*/,
1428 /* tests depend on a not zero MDIClient size */
1429 0, 0, rc.right, rc.bottom,
1430 hwnd, 0, GetModuleHandle(0),
1431 (LPVOID)&client_cs);
1432 assert(mdi_client);
1433 test_MDI_create(hwnd, mdi_client);
1434 DestroyWindow(mdi_client);
1435 break;
1436 }
1437
1438 case WM_WINDOWPOSCHANGED:
1439 {
1440 WINDOWPOS *winpos = (WINDOWPOS *)lparam;
1441 RECT rc1, rc2;
1442
1443 GetWindowRect(hwnd, &rc1);
1444 trace("window: (%ld,%ld)-(%ld,%ld)\n", rc1.left, rc1.top, rc1.right, rc1.bottom);
1445 SetRect(&rc2, winpos->x, winpos->y, winpos->x + winpos->cx, winpos->y + winpos->cy);
1446 /* note: winpos coordinates are relative to parent */
1447 MapWindowPoints(GetParent(hwnd), 0, (LPPOINT)&rc2, 2);
1448 trace("pos: (%ld,%ld)-(%ld,%ld)\n", rc2.left, rc2.top, rc2.right, rc2.bottom);
1449 ok(EqualRect(&rc1, &rc2), "rects do not match\n");
1450
1451 GetWindowRect(hwnd, &rc1);
1452 GetClientRect(hwnd, &rc2);
1453 DefWindowProcA(hwnd, WM_NCCALCSIZE, 0, (LPARAM)&rc1);
1454 MapWindowPoints(0, hwnd, (LPPOINT)&rc1, 2);
1455 ok(EqualRect(&rc1, &rc2), "rects do not match\n");
1456 }
1457 /* fall through */
1458 case WM_WINDOWPOSCHANGING:
1459 {
1460 WINDOWPOS *winpos = (WINDOWPOS *)lparam;
1461 WINDOWPOS my_winpos = *winpos;
1462
1463 trace("%s\n", (msg == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
1464 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
1465 winpos->hwnd, winpos->hwndInsertAfter,
1466 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
1467
1468 DefWindowProcA(hwnd, msg, wparam, lparam);
1469
1470 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
1471 winpos->hwnd, winpos->hwndInsertAfter,
1472 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
1473
1474 ok(!memcmp(&my_winpos, winpos, sizeof(WINDOWPOS)),
1475 "DefWindowProc should not change WINDOWPOS values\n");
1476
1477 return 1;
1478 }
1479
1480 case WM_CLOSE:
1481 PostQuitMessage(0);
1482 break;
1483 }
1484 return DefFrameProcA(hwnd, mdi_client, msg, wparam, lparam);
1485 }
1486
1487 static BOOL mdi_RegisterWindowClasses(void)
1488 {
1489 WNDCLASSA cls;
1490
1491 cls.style = 0;
1492 cls.lpfnWndProc = mdi_main_wnd_procA;
1493 cls.cbClsExtra = 0;
1494 cls.cbWndExtra = 0;
1495 cls.hInstance = GetModuleHandleA(0);
1496 cls.hIcon = 0;
1497 cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
1498 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
1499 cls.lpszMenuName = NULL;
1500 cls.lpszClassName = "MDI_parent_Class";
1501 if(!RegisterClassA(&cls)) return FALSE;
1502
1503 cls.lpfnWndProc = mdi_child_wnd_proc_1;
1504 cls.lpszClassName = "MDI_child_Class_1";
1505 if(!RegisterClassA(&cls)) return FALSE;
1506
1507 cls.lpfnWndProc = mdi_child_wnd_proc_2;
1508 cls.lpszClassName = "MDI_child_Class_2";
1509 if(!RegisterClassA(&cls)) return FALSE;
1510
1511 return TRUE;
1512 }
1513
1514 static void test_mdi(void)
1515 {
1516 HWND mdi_hwndMain;
1517 /*MSG msg;*/
1518
1519 if (!mdi_RegisterWindowClasses()) assert(0);
1520
1521 mdi_hwndMain = CreateWindowExA(0, "MDI_parent_Class", "MDI parent window",
1522 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
1523 WS_MAXIMIZEBOX /*| WS_VISIBLE*/,
1524 100, 100, CW_USEDEFAULT, CW_USEDEFAULT,
1525 GetDesktopWindow(), 0,
1526 GetModuleHandle(0), NULL);
1527 assert(mdi_hwndMain);
1528 /*
1529 while(GetMessage(&msg, 0, 0, 0))
1530 {
1531 TranslateMessage(&msg);
1532 DispatchMessage(&msg);
1533 }
1534 */
1535 }
1536
1537 static void test_icons(void)
1538 {
1539 WNDCLASSEXA cls;
1540 HWND hwnd;
1541 HICON icon = LoadIconA(0, (LPSTR)IDI_APPLICATION);
1542 HICON icon2 = LoadIconA(0, (LPSTR)IDI_QUESTION);
1543 HICON small_icon = LoadImageA(0, (LPSTR)IDI_APPLICATION, IMAGE_ICON,
1544 GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_SHARED );
1545 HICON res;
1546
1547 cls.cbSize = sizeof(cls);
1548 cls.style = 0;
1549 cls.lpfnWndProc = DefWindowProcA;
1550 cls.cbClsExtra = 0;
1551 cls.cbWndExtra = 0;
1552 cls.hInstance = 0;
1553 cls.hIcon = LoadIconA(0, (LPSTR)IDI_HAND);
1554 cls.hIconSm = small_icon;
1555 cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
1556 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
1557 cls.lpszMenuName = NULL;
1558 cls.lpszClassName = "IconWindowClass";
1559
1560 RegisterClassExA(&cls);
1561
1562 hwnd = CreateWindowExA(0, "IconWindowClass", "icon test", 0,
1563 100, 100, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, NULL, NULL);
1564 assert( hwnd );
1565
1566 res = (HICON)SendMessageA( hwnd, WM_GETICON, ICON_BIG, 0 );
1567 ok( res == 0, "wrong big icon %p/0\n", res );
1568 res = (HICON)SendMessageA( hwnd, WM_SETICON, ICON_BIG, (LPARAM)icon );
1569 ok( res == 0, "wrong previous big icon %p/0\n", res );
1570 res = (HICON)SendMessageA( hwnd, WM_GETICON, ICON_BIG, 0 );
1571 ok( res == icon, "wrong big icon after set %p/%p\n", res, icon );
1572 res = (HICON)SendMessageA( hwnd, WM_SETICON, ICON_BIG, (LPARAM)icon2 );
1573 ok( res == icon, "wrong previous big icon %p/%p\n", res, icon );
1574 res = (HICON)SendMessageA( hwnd, WM_GETICON, ICON_BIG, 0 );
1575 ok( res == icon2, "wrong big icon after set %p/%p\n", res, icon2 );
1576
1577 res = (HICON)SendMessageA( hwnd, WM_GETICON, ICON_SMALL, 0 );
1578 ok( res == 0, "wrong small icon %p/0\n", res );
1579 /* this test is XP specific */
1580 /*res = (HICON)SendMessageA( hwnd, WM_GETICON, ICON_SMALL2, 0 );
1581 ok( res != 0, "wrong small icon %p\n", res );*/
1582 res = (HICON)SendMessageA( hwnd, WM_SETICON, ICON_SMALL, (LPARAM)icon );
1583 ok( res == 0, "wrong previous small icon %p/0\n", res );
1584 res = (HICON)SendMessageA( hwnd, WM_GETICON, ICON_SMALL, 0 );
1585 ok( res == icon, "wrong small icon after set %p/%p\n", res, icon );
1586 /* this test is XP specific */
1587 /*res = (HICON)SendMessageA( hwnd, WM_GETICON, ICON_SMALL2, 0 );
1588 ok( res == icon, "wrong small icon after set %p/%p\n", res, icon );*/
1589 res = (HICON)SendMessageA( hwnd, WM_SETICON, ICON_SMALL, (LPARAM)small_icon );
1590 ok( res == icon, "wrong previous small icon %p/%p\n", res, icon );
1591 res = (HICON)SendMessageA( hwnd, WM_GETICON, ICON_SMALL, 0 );
1592 ok( res == small_icon, "wrong small icon after set %p/%p\n", res, small_icon );
1593 /* this test is XP specific */
1594 /*res = (HICON)SendMessageA( hwnd, WM_GETICON, ICON_SMALL2, 0 );
1595 ok( res == small_icon, "wrong small icon after set %p/%p\n", res, small_icon );*/
1596
1597 /* make sure the big icon hasn't changed */
1598 res = (HICON)SendMessageA( hwnd, WM_GETICON, ICON_BIG, 0 );
1599 ok( res == icon2, "wrong big icon after set %p/%p\n", res, icon2 );
1600 }
1601
1602 static void test_SetWindowPos(HWND hwnd)
1603 {
1604 BOOL is_win9x = GetWindowLongW(hwnd, GWL_WNDPROC) == 0;
1605
1606 /* Win9x truncates coordinates to 16-bit irrespectively */
1607 if (is_win9x) return;
1608
1609 SetWindowPos(hwnd, 0, -32769, -40000, -32769, -90000, SWP_NOMOVE);
1610 SetWindowPos(hwnd, 0, 32768, 40000, 32768, 40000, SWP_NOMOVE);
1611
1612 SetWindowPos(hwnd, 0, -32769, -40000, -32769, -90000, SWP_NOSIZE);
1613 SetWindowPos(hwnd, 0, 32768, 40000, 32768, 40000, SWP_NOSIZE);
1614 }
1615
1616 static void test_SetMenu(HWND parent)
1617 {
1618 HWND child;
1619 HMENU hMenu, ret;
1620 BOOL is_win9x = GetWindowLongW(parent, GWL_WNDPROC) == 0;
1621
1622 hMenu = CreateMenu();
1623 assert(hMenu);
1624
1625 ok(SetMenu(parent, hMenu), "SetMenu on a top level window should not fail\n");
1626 test_nonclient_area(parent);
1627 ret = GetMenu(parent);
1628 ok(ret == hMenu, "unexpected menu id %p\n", ret);
1629 /* test whether we can destroy a menu assigned to a window */
1630 ok(DestroyMenu(hMenu), "DestroyMenu error %ld\n", GetLastError());
1631 ok(!IsMenu(hMenu), "menu handle should be not valid after DestroyMenu\n");
1632 ret = GetMenu(parent);
1633 /* This test fails on Win9x */
1634 if (!is_win9x)
1635 ok(ret == hMenu, "unexpected menu id %p\n", ret);
1636 ok(SetMenu(parent, 0), "SetMenu(0) on a top level window should not fail\n");
1637 test_nonclient_area(parent);
1638
1639 hMenu = CreateMenu();
1640 assert(hMenu);
1641
1642 /* parent */
1643 ret = GetMenu(parent);
1644 ok(ret == 0, "unexpected menu id %p\n", ret);
1645
1646 ok(!SetMenu(parent, (HMENU)20), "SetMenu with invalid menu handle should fail\n");
1647 test_nonclient_area(parent);
1648 ret = GetMenu(parent);
1649 ok(ret == 0, "unexpected menu id %p\n", ret);
1650
1651 ok(SetMenu(parent, hMenu), "SetMenu on a top level window should not fail\n");
1652 test_nonclient_area(parent);
1653 ret = GetMenu(parent);
1654 ok(ret == hMenu, "unexpected menu id %p\n", ret);
1655
1656 ok(SetMenu(parent, 0), "SetMenu(0) on a top level window should not fail\n");
1657 test_nonclient_area(parent);
1658 ret = GetMenu(parent);
1659 ok(ret == 0, "unexpected menu id %p\n", ret);
1660
1661 /* child */
1662 child = CreateWindowExA(0, "static", NULL, WS_CHILD, 0, 0, 0, 0, parent, (HMENU)10, 0, NULL);
1663 assert(child);
1664
1665 ret = GetMenu(child);
1666 ok(ret == (HMENU)10, "unexpected menu id %p\n", ret);
1667
1668 ok(!SetMenu(child, (HMENU)20), "SetMenu with invalid menu handle should fail\n");
1669 test_nonclient_area(child);
1670 ret = GetMenu(child);
1671 ok(ret == (HMENU)10, "unexpected menu id %p\n", ret);
1672
1673 ok(!SetMenu(child, hMenu), "SetMenu on a child window should fail\n");
1674 test_nonclient_area(child);
1675 ret = GetMenu(child);
1676 ok(ret == (HMENU)10, "unexpected menu id %p\n", ret);
1677
1678 ok(!SetMenu(child, 0), "SetMenu(0) on a child window should fail\n");
1679 test_nonclient_area(child);
1680 ret = GetMenu(child);
1681 ok(ret == (HMENU)10, "unexpected menu id %p\n", ret);
1682
1683 DestroyWindow(child);
1684 DestroyMenu(hMenu);
1685 }
1686
1687 static void test_window_tree(HWND parent, const DWORD *style, const int *order, int total)
1688 {
1689 HWND child[5], hwnd;
1690 int i;
1691
1692 assert(total <= 5);
1693
1694 hwnd = GetWindow(parent, GW_CHILD);
1695 ok(!hwnd, "have to start without children to perform the test\n");
1696
1697 for (i = 0; i < total; i++)
1698 {
1699 child[i] = CreateWindowExA(0, "static", "", style[i], 0,0,10,10,
1700 parent, 0, 0, NULL);
1701 trace("child[%d] = %p\n", i, child[i]);
1702 ok(child[i] != 0, "CreateWindowEx failed to create child window\n");
1703 }
1704
1705 hwnd = GetWindow(parent, GW_CHILD);
1706 ok(hwnd != 0, "GetWindow(GW_CHILD) failed\n");
1707 ok(hwnd == GetWindow(child[total - 1], GW_HWNDFIRST), "GW_HWNDFIRST is wrong\n");
1708 ok(child[order[total - 1]] == GetWindow(child[0], GW_HWNDLAST), "GW_HWNDLAST is wrong\n");
1709
1710 for (i = 0; i < total; i++)
1711 {
1712 trace("hwnd[%d] = %p\n", i, hwnd);
1713 ok(child[order[i]] == hwnd, "Z order of child #%d is wrong\n", i);
1714
1715 hwnd = GetWindow(hwnd, GW_HWNDNEXT);
1716 }
1717
1718 for (i = 0; i < total; i++)
1719 ok(DestroyWindow(child[i]), "DestroyWindow failed\n");
1720 }
1721
1722 static void test_children_zorder(HWND parent)
1723 {
1724 const DWORD simple_style[5] = { WS_CHILD, WS_CHILD, WS_CHILD, WS_CHILD,
1725 WS_CHILD };
1726 const int simple_order[5] = { 0, 1, 2, 3, 4 };
1727
1728 const DWORD complex_style[5] = { WS_CHILD, WS_CHILD | WS_MAXIMIZE,
1729 WS_CHILD | WS_VISIBLE, WS_CHILD,
1730 WS_CHILD | WS_MAXIMIZE | WS_VISIBLE };
1731 const int complex_order_1[1] = { 0 };
1732 const int complex_order_2[2] = { 1, 0 };
1733 const int complex_order_3[3] = { 1, 0, 2 };
1734 const int complex_order_4[4] = { 1, 0, 2, 3 };
1735 const int complex_order_5[5] = { 4, 1, 0, 2, 3 };
1736
1737 /* simple WS_CHILD */
1738 test_window_tree(parent, simple_style, simple_order, 5);
1739
1740 /* complex children styles */
1741 test_window_tree(parent, complex_style, complex_order_1, 1);
1742 test_window_tree(parent, complex_style, complex_order_2, 2);
1743 test_window_tree(parent, complex_style, complex_order_3, 3);
1744 test_window_tree(parent, complex_style, complex_order_4, 4);
1745 test_window_tree(parent, complex_style, complex_order_5, 5);
1746 }
1747
1748 static void test_SetFocus(HWND hwnd)
1749 {
1750 HWND child;
1751
1752 /* check if we can set focus to non-visible windows */
1753
1754 ShowWindow(hwnd, SW_SHOW);
1755 SetFocus(0);
1756 SetFocus(hwnd);
1757 ok( GetFocus() == hwnd, "Failed to set focus to visible window %p\n", hwnd );
1758 ok( GetWindowLong(hwnd,GWL_STYLE) & WS_VISIBLE, "Window %p not visible\n", hwnd );
1759 ShowWindow(hwnd, SW_HIDE);
1760 SetFocus(0);
1761 SetFocus(hwnd);
1762 ok( GetFocus() == hwnd, "Failed to set focus to invisible window %p\n", hwnd );
1763 ok( !(GetWindowLong(hwnd,GWL_STYLE) & WS_VISIBLE), "Window %p still visible\n", hwnd );
1764 child = CreateWindowExA(0, "static", NULL, WS_CHILD, 0, 0, 0, 0, hwnd, 0, 0, NULL);
1765 assert(child);
1766 SetFocus(child);
1767 ok( GetFocus() == child, "Failed to set focus to invisible child %p\n", child );
1768 ok( !(GetWindowLong(child,GWL_STYLE) & WS_VISIBLE), "Child %p is visible\n", child );
1769 ShowWindow(child, SW_SHOW);
1770 ok( GetWindowLong(child,GWL_STYLE) & WS_VISIBLE, "Child %p is not visible\n", child );
1771 ok( GetFocus() == child, "Focus no longer on child %p\n", child );
1772 ShowWindow(child, SW_HIDE);
1773 ok( !(GetWindowLong(child,GWL_STYLE) & WS_VISIBLE), "Child %p is visible\n", child );
1774 ok( GetFocus() == hwnd, "Focus should be on parent %p, not %p\n", hwnd, GetFocus() );
1775 ShowWindow(child, SW_SHOW);
1776 SetFocus(child);
1777 ok( GetFocus() == child, "Focus should be on child %p\n", child );
1778 SetWindowPos(child,0,0,0,0,0,SWP_NOZORDER|SWP_NOMOVE|SWP_NOSIZE|SWP_HIDEWINDOW);
1779 ok( GetFocus() == child, "Focus should still be on child %p\n", child );
1780
1781 ShowWindow(child, SW_HIDE);
1782 SetFocus(hwnd);
1783 ok( GetFocus() == hwnd, "Focus should be on parent %p, not %p\n", hwnd, GetFocus() );
1784 SetWindowPos(child,0,0,0,0,0,SWP_NOZORDER|SWP_NOMOVE|SWP_NOSIZE|SWP_SHOWWINDOW);
1785 ok( GetFocus() == hwnd, "Focus should still be on parent %p, not %p\n", hwnd, GetFocus() );
1786 ShowWindow(child, SW_HIDE);
1787 ok( GetFocus() == hwnd, "Focus should still be on parent %p, not %p\n", hwnd, GetFocus() );
1788
1789 ShowWindow(hwnd, SW_SHOW);
1790 ShowWindow(child, SW_SHOW);
1791 SetFocus(child);
1792 ok( GetFocus() == child, "Focus should be on child %p\n", child );
1793 EnableWindow(hwnd, FALSE);
1794 ok( GetFocus() == child, "Focus should still be on child %p\n", child );
1795 EnableWindow(hwnd, TRUE);
1796
1797 DestroyWindow( child );
1798 }
1799
1800 static void test_SetActiveWindow(HWND hwnd)
1801 {
1802 HWND hwnd2;
1803
1804 ShowWindow(hwnd, SW_SHOW);
1805 SetActiveWindow(0);
1806 SetActiveWindow(hwnd);
1807 ok( GetActiveWindow() == hwnd, "Failed to set focus to visible window %p\n", hwnd );
1808 SetWindowPos(hwnd,0,0,0,0,0,SWP_NOZORDER|SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE|SWP_HIDEWINDOW);
1809 ok( GetActiveWindow() == hwnd, "Window %p no longer active\n", hwnd );
1810 SetWindowPos(hwnd,0,0,0,0,0,SWP_NOZORDER|SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE|SWP_SHOWWINDOW);
1811 ShowWindow(hwnd, SW_HIDE);
1812 ok( GetActiveWindow() != hwnd, "Window %p is still active\n", hwnd );
1813 ShowWindow(hwnd, SW_SHOW);
1814
1815 hwnd2 = CreateWindowExA(0, "static", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 0, 0, hwnd, 0, 0, NULL);
1816 ok( GetActiveWindow() == hwnd2, "Window %p is not active\n", hwnd2 );
1817 DestroyWindow(hwnd2);
1818 ok( GetActiveWindow() != hwnd2, "Window %p is still active\n", hwnd2 );
1819
1820 hwnd2 = CreateWindowExA(0, "static", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 0, 0, hwnd, 0, 0, NULL);
1821 ok( GetActiveWindow() == hwnd2, "Window %p is not active\n", hwnd2 );
1822 SetWindowPos(hwnd2,0,0,0,0,0,SWP_NOZORDER|SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE|SWP_HIDEWINDOW);
1823 ok( GetActiveWindow() == hwnd2, "Window %p no longer active (%p)\n", hwnd2, GetActiveWindow() );
1824 DestroyWindow(hwnd2);
1825 ok( GetActiveWindow() != hwnd2, "Window %p is still active\n", hwnd2 );
1826 }
1827
1828 START_TEST(win)
1829 {
1830 pGetAncestor = (void *)GetProcAddress( GetModuleHandleA("user32.dll"), "GetAncestor" );
1831 pGetWindowInfo = (void *)GetProcAddress( GetModuleHandleA("user32.dll"), "GetWindowInfo" );
1832
1833 hwndMain = CreateWindowExA(0, "static", NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, 0, 0, NULL);
1834 if (hwndMain)
1835 {
1836 ok(!GetParent(hwndMain), "GetParent should return 0 for message only windows\n");
1837 if (pGetAncestor)
1838 {
1839 hwndMessage = pGetAncestor(hwndMain, GA_PARENT);
1840 ok(hwndMessage != 0, "GetAncestor(GA_PARENT) should not return 0 for message only windows\n");
1841 trace("hwndMessage %p\n", hwndMessage);
1842 }
1843 DestroyWindow(hwndMain);
1844 }
1845 else
1846 trace("CreateWindowExA with parent HWND_MESSAGE failed\n");
1847
1848 if (!RegisterWindowClasses()) assert(0);
1849
1850 hhook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, GetCurrentThreadId());
1851 assert(hhook);
1852
1853 hwndMain = CreateWindowExA(/*WS_EX_TOOLWINDOW*/ 0, "MainWindowClass", "Main window",
1854 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
1855 WS_MAXIMIZEBOX | WS_POPUP,
1856 100, 100, 200, 200,
1857 0, 0, 0, NULL);
1858 hwndMain2 = CreateWindowExA(/*WS_EX_TOOLWINDOW*/ 0, "MainWindowClass", "Main window 2",
1859 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
1860 WS_MAXIMIZEBOX | WS_POPUP,
1861 100, 100, 200, 200,
1862 0, 0, 0, NULL);
1863 assert( hwndMain );
1864 assert( hwndMain2 );
1865
1866 test_parent_owner();
1867 test_shell_window();
1868
1869 test_mdi();
1870 test_icons();
1871 test_SetWindowPos(hwndMain);
1872 test_SetMenu(hwndMain);
1873 test_SetFocus(hwndMain);
1874 test_SetActiveWindow(hwndMain);
1875
1876 test_children_zorder(hwndMain);
1877
1878 UnhookWindowsHookEx(hhook);
1879 }
Windows API implementation