5879fbcb569630d78b65bc997cf90ab53fb37d26
[reactos.git] / rostests / winetests / user32 / dialog.c
1 /* Unit test suite for the dialog functions.
2 *
3 * Copyright 2004 Bill Medland
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 *
19 *
20 *
21 * This test suite currently works by building a quite complex hierarchy of
22 * objects in a variety of styles and then performs a limited number of tests
23 * for the previous and next dialog group or tab items.
24 *
25 * The test specifically does not test all possibilities at this time since
26 * there are several cases where the Windows behaviour is rather strange and
27 * significant work would be required to get the Wine code to duplicate the
28 * strangeness, especially since most are in situations that would not
29 * normally be met.
30 */
31
32 #include <assert.h>
33 #include <stdio.h>
34 #include <stdarg.h>
35
36 #include "wine/test.h"
37 #include "windef.h"
38 #include "winbase.h"
39 #include "wingdi.h"
40 #include "winuser.h"
41
42 #define MAXHWNDS 1024
43 static HWND hwnd [MAXHWNDS];
44 static unsigned int numwnds=1; /* 0 is reserved for null */
45
46 /* Global handles */
47 static HINSTANCE g_hinst; /* This application's HINSTANCE */
48 static HWND g_hwndMain, g_hwndButton1, g_hwndButton2, g_hwndButtonCancel;
49 static HWND g_hwndTestDlg, g_hwndTestDlgBut1, g_hwndTestDlgBut2, g_hwndTestDlgEdit;
50 static HWND g_hwndInitialFocusT1, g_hwndInitialFocusT2, g_hwndInitialFocusGroupBox;
51
52 static LONG g_styleInitialFocusT1, g_styleInitialFocusT2;
53 static BOOL g_bInitialFocusInitDlgResult;
54
55 static int g_terminated;
56
57 typedef struct {
58 INT_PTR id;
59 int parent;
60 DWORD style;
61 DWORD exstyle;
62 } h_entry;
63
64 static const h_entry hierarchy [] = {
65 /* 0 is reserved for the null window */
66 { 1, 0, WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS, WS_EX_WINDOWEDGE},
67 { 20, 1, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
68 { 2, 1, WS_CHILD | WS_VISIBLE, WS_EX_CONTROLPARENT},
69 { 60, 2, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
70 /* What happens with groups when the parent is disabled */
71 { 8, 2, WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_TABSTOP, WS_EX_CONTROLPARENT},
72 { 85, 8, WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_GROUP, 0},
73 { 9, 8, WS_CHILD, WS_EX_CONTROLPARENT},
74 { 86, 9, WS_CHILD | WS_VISIBLE, 0},
75 { 87, 9, WS_CHILD | WS_VISIBLE, 0},
76 { 31, 8, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
77 { 10, 2, WS_CHILD | WS_VISIBLE, WS_EX_CONTROLPARENT},
78 { 88, 10, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
79 { 11, 10, WS_CHILD, WS_EX_CONTROLPARENT},
80 { 89, 11, WS_CHILD | WS_VISIBLE, 0},
81 { 32, 11, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
82 { 90, 11, WS_CHILD | WS_VISIBLE, 0},
83 { 33, 10, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
84 { 21, 2, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
85 { 61, 2, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
86 { 3, 1, WS_CHILD | WS_VISIBLE | DS_CONTROL, 0},
87 { 22, 3, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
88 { 62, 3, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
89 { 7, 3, WS_CHILD | WS_VISIBLE, WS_EX_CONTROLPARENT},
90 { 4, 7, WS_CHILD | WS_VISIBLE | DS_CONTROL, 0},
91 { 83, 4, WS_CHILD | WS_VISIBLE, 0},
92 { 5, 4, WS_CHILD | WS_VISIBLE | DS_CONTROL, 0},
93 /* A couple of controls around the main dialog */
94 { 29, 5, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
95 { 81, 5, WS_CHILD | WS_VISIBLE, 0},
96 /* The main dialog with lots of controls */
97 { 6, 5, WS_CHILD | WS_VISIBLE, WS_EX_CONTROLPARENT},
98 /* At the start of a dialog */
99 /* Disabled controls are skipped */
100 { 63, 6, WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_TABSTOP, 0},
101 /* Invisible controls are skipped */
102 { 64, 6, WS_CHILD | WS_TABSTOP, 0},
103 /* Invisible disabled controls are skipped */
104 { 65, 6, WS_CHILD | WS_DISABLED | WS_TABSTOP, 0},
105 /* Non-tabstop controls are skipped for tabs but not for groups */
106 { 66, 6, WS_CHILD | WS_VISIBLE, 0},
107 /* End of first group, with no tabstops in it */
108 { 23, 6, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
109 /* At last a tabstop */
110 { 67, 6, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
111 /* A group that is totally disabled or invisible */
112 { 24, 6, WS_CHILD | WS_DISABLED | WS_GROUP, 0},
113 { 68, 6, WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_TABSTOP, 0},
114 { 69, 6, WS_CHILD | WS_TABSTOP, 0},
115 /* A valid group in the middle of the dialog (not the first nor last group*/
116 { 25, 6, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
117 /* A non-tabstop item will be skipped for tabs */
118 { 70, 6, WS_CHILD | WS_VISIBLE, 0},
119 /* A disabled item will be skipped for tabs and groups */
120 { 71, 6, WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_TABSTOP, 0},
121 /* A valid item will be found for tabs and groups */
122 { 72, 6, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
123 /* A disabled item to skip when looking for the next group item */
124 { 73, 6, WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_TABSTOP, 0},
125 /* The next group begins with an enabled visible label */
126 { 26, 6, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
127 { 74, 6, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
128 { 75, 6, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
129 /* That group is terminated by a disabled label */
130 { 27, 6, WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_GROUP, 0},
131 { 76, 6, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
132 { 77, 6, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
133 /* That group is terminated by an invisible label */
134 { 28, 6, WS_CHILD | WS_GROUP, 0},
135 /* The end of the dialog with item for loop and recursion testing */
136 { 78, 6, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
137 /* No tabstop so skipped for prev tab, but found for prev group */
138 { 79, 6, WS_CHILD | WS_VISIBLE, 0},
139 { 80, 6, WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_TABSTOP, 0},
140 /* A couple of controls after the main dialog */
141 { 82, 5, WS_CHILD | WS_VISIBLE, 0},
142 { 30, 5, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
143 /* And around them */
144 { 84, 4, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
145 {0, 0, 0, 0}
146 };
147
148 static BOOL CreateWindows (HINSTANCE hinst)
149 {
150 const h_entry *p = hierarchy;
151
152 while (p->id != 0)
153 {
154 DWORD style, exstyle;
155 char ctrlname[9];
156
157 /* Basically assert that the hierarchy is valid and track the
158 * maximum control number
159 */
160 if (p->id >= numwnds)
161 {
162 if (p->id >= sizeof(hwnd)/sizeof(hwnd[0]))
163 {
164 trace ("Control %ld is out of range\n", p->id);
165 return FALSE;
166 }
167 else
168 numwnds = p->id+1;
169 }
170 if (p->id <= 0)
171 {
172 trace ("Control %ld is out of range\n", p->id);
173 return FALSE;
174 }
175 if (hwnd[p->id] != 0)
176 {
177 trace ("Control %ld is used more than once\n", p->id);
178 return FALSE;
179 }
180
181 /* Create the control */
182 sprintf (ctrlname, "ctrl%4.4ld", p->id);
183 hwnd[p->id] = CreateWindowEx (p->exstyle, TEXT(p->parent ? "static" : "GetNextDlgItemWindowClass"), TEXT(ctrlname), p->style, 10, 10, 10, 10, hwnd[p->parent], p->parent ? (HMENU) (2000 + p->id) : 0, hinst, 0);
184 if (!hwnd[p->id])
185 {
186 trace ("Failed to create control %ld\n", p->id);
187 return FALSE;
188 }
189
190 /* Check that the styles are as we specified (except the main one
191 * which is quite frequently messed up). If this keeps breaking then
192 * we could mask out the bits that don't concern us.
193 */
194 if (p->parent)
195 {
196 style = GetWindowLong (hwnd[p->id], GWL_STYLE);
197 exstyle = GetWindowLong (hwnd[p->id], GWL_EXSTYLE);
198 if (style != p->style || exstyle != p->exstyle)
199 {
200 trace ("Style mismatch at %ld: %8.8x %8.8x cf %8.8x %8.8x\n", p->id, style, exstyle, p->style, p->exstyle);
201 }
202 }
203 p++;
204 }
205
206 return TRUE;
207 }
208
209 /* Form the lParam of a WM_KEYDOWN message */
210 static DWORD KeyDownData (int repeat, int scancode, int extended, int wasdown)
211 {
212 return ((repeat & 0x0000FFFF) | ((scancode & 0x00FF) >> 16) |
213 (extended ? 0x01000000 : 0) | (wasdown ? 0x40000000 : 0));
214 }
215
216 /* Form a WM_KEYDOWN VK_TAB message to the specified window */
217 static void FormTabMsg (MSG *pMsg, HWND hwnd)
218 {
219 pMsg->hwnd = hwnd;
220 pMsg->message = WM_KEYDOWN;
221 pMsg->wParam = VK_TAB;
222 pMsg->lParam = KeyDownData (1, 0x0F, 0, 0);
223 /* pMsg->time is not set. It shouldn't be needed */
224 /* pMsg->pt is ignored */
225 }
226
227 /* Form a WM_KEYDOWN VK_RETURN message to the specified window */
228 static void FormEnterMsg (MSG *pMsg, HWND hwnd)
229 {
230 pMsg->hwnd = hwnd;
231 pMsg->message = WM_KEYDOWN;
232 pMsg->wParam = VK_RETURN;
233 pMsg->lParam = KeyDownData (1, 0x1C, 0, 0);
234 /* pMsg->time is not set. It shouldn't be needed */
235 /* pMsg->pt is ignored */
236 }
237
238 /***********************************************************************
239 *
240 * The actual tests
241 */
242
243 typedef struct
244 {
245 int isok; /* or is it todo */
246 int test;
247 int dlg;
248 int ctl;
249 int tab;
250 int prev;
251 int res;
252 } test_record;
253
254 static int id (HWND h)
255 {
256 unsigned int i;
257 for (i = 0; i < numwnds; i++)
258 if (hwnd[i] == h)
259 return i;
260 return -1;
261 }
262
263 /* Tests
264 *
265 * Tests 1-8 test the hCtl argument of null or the dialog itself.
266 *
267 * 1. Prev Group of null is null
268 * 2. Prev Tab of null is null
269 * 3. Prev Group of hDlg in hDlg is null
270 * 4. Prev Tab of hDlg in hDlg is null
271 * 5. Next Group of null is first visible enabled child
272 * Check it skips invisible, disabled and both.
273 * 6. Next Tab of null is first visible enabled tabstop
274 * Check it skips invisible, disabled, nontabstop, and in combination.
275 * 7. Next Group of hDlg in hDlg is as of null
276 * 8. Next Tab of hDlg in hDlg is as of null
277 *
278 * Tests 9-14 test descent
279 *
280 * 9. DS_CONTROL does not result in descending the hierarchy for Tab Next
281 * 10. DS_CONTROL does not result in descending the hierarchy for Group Next
282 * 11. WS_EX_CONTROLPARENT results in descending the hierarchy for Tab Next
283 * 12. WS_EX_CONTROLPARENT results in descending the hierarchy for Group Next
284 * 13. WS_EX_CONTROLPARENT results in descending the hierarchy for Tab Prev
285 * 14. WS_EX_CONTROLPARENT results in descending the hierarchy for Group Prev
286 *
287 * Tests 15-24 are the basic Prev/Next Group tests
288 *
289 * 15. Next Group of a visible enabled non-group control is the next visible
290 * enabled non-group control, if there is one before the next group
291 * 16. Next Group of a visible enabled non-group control wraps around to the
292 * beginning of the group on finding a control that starts another group.
293 * Note that the group is in the middle of the dialog.
294 * 17. As 16 except note that the next group is started with a disabled
295 * visible control.
296 * 18. As 16 except note that the next group is started with an invisible
297 * enabled control.
298 * 19. Next Group wraps around the controls of the dialog
299 * 20. Next Group is the same even if the initial control is disabled.
300 * 21. Next Group is the same even if the initial control is invisible.
301 * 22. Next Group is the same even if the initial control has the group style
302 * 23. Next Group returns the initial control if there is no visible enabled
303 * control in the group. (Initial control disabled and not group style).
304 * 24. Prev version of test 16.
305 * Prev Group of a visible enabled non-group control wraps around to the
306 * beginning of the group on finding a control that starts the group.
307 * Note that the group is in the middle of the dialog.
308 *
309 * In tests 25 to 28 the control is sitting under dialogs which do not have
310 * the WS_EX_CONTROLPARENT style and so cannot be reached from the top of
311 * the dialog.
312 *
313 * 25. Next Group of an inaccessible control is as if it were accessible
314 * 26. Prev Group of an inaccessible control begins searching at the highest
315 * level ancestor that did not permit recursion down the hierarchy
316 * 27. Next Tab of an inaccessible control is as if it were accessible
317 * 28. Prev Tab of an inaccessible control begins searching at the highest
318 * level ancestor that did not permit recursion down the hierarchy.
319 *
320 * Tests 29- are the basic Tab tests
321 *
322 * 29. Next Tab of a control is the next visible enabled control with the
323 * Tabstop style (N.B. skips disabled, invisible and non-tabstop)
324 * 30. Prev Tab of a control is the previous visible enabled control with the
325 * Tabstop style (N.B. skips disabled, invisible and non-tabstop)
326 * 31. Next Tab test with at least two layers of descent and finding the
327 * result not at the first control.
328 * 32. Next Tab test with at least two layers of descent with the descent and
329 * control at the start of each level.
330 * 33. Prev Tab test with at least two layers of descent and finding the
331 * result not at the last control.
332 * 34. Prev Tab test with at least two layers of descent with the descent and
333 * control at the end of each level.
334 *
335 * 35. Passing NULL may result in the first child being the one returned.
336 * (group test)
337 * 36. Passing NULL may result in the first child being the one returned.
338 * (tab test)
339 */
340
341 static void GetNextDlgItemTest (void)
342 {
343 static test_record test [] =
344 {
345 /* isok test dlg ctl tab prev res */
346
347 { 1, 1, 6, 0, 0, 1, 0},
348 { 1, 2, 6, 0, 1, 1, 0},
349 { 1, 3, 6, 6, 0, 1, 0},
350 { 1, 4, 6, 6, 1, 1, 0},
351 { 1, 5, 6, 0, 0, 0, 66},
352 { 1, 6, 6, 0, 1, 0, 67},
353 { 1, 7, 6, 6, 0, 0, 66},
354 { 1, 8, 6, 6, 1, 0, 67},
355
356 { 1, 9, 4, 83, 1, 0, 84},
357 { 1, 10, 4, 83, 0, 0, 5},
358 { 1, 11, 5, 81, 1, 0, 67},
359 { 1, 12, 5, 81, 0, 0, 66},
360 { 1, 13, 5, 82, 1, 1, 78},
361
362 { 1, 14, 5, 82, 0, 1, 79},
363 { 1, 15, 6, 70, 0, 0, 72},
364 { 1, 16, 6, 72, 0, 0, 25},
365 { 1, 17, 6, 75, 0, 0, 26},
366 { 1, 18, 6, 77, 0, 0, 76},
367 { 1, 19, 6, 79, 0, 0, 66},
368 { 1, 20, 6, 71, 0, 0, 72},
369 { 1, 21, 6, 64, 0, 0, 66},
370
371 { 1, 22, 6, 25, 0, 0, 70},
372 { 1, 23, 6, 68, 0, 0, 68},
373 { 1, 24, 6, 25, 0, 1, 72},
374 { 1, 25, 1, 70, 0, 0, 72},
375 /*{ 0, 26, 1, 70, 0, 1, 3}, Crashes Win95*/
376 { 1, 27, 1, 70, 1, 0, 72},
377 /*{ 0, 28, 1, 70, 1, 1, 61}, Crashes Win95*/
378
379 { 1, 29, 6, 67, 1, 0, 72},
380 { 1, 30, 6, 72, 1, 1, 67},
381
382 { 1, 35, 2, 0, 0, 0, 60},
383 { 1, 36, 2, 0, 1, 0, 60},
384
385 { 0, 0, 0, 0, 0, 0, 0} /* End of test */
386 };
387 const test_record *p = test;
388
389 ok (CreateWindows (g_hinst), "Could not create test windows\n");
390
391 while (p->dlg)
392 {
393 HWND a;
394 a = (p->tab ? GetNextDlgTabItem : GetNextDlgGroupItem) (hwnd[p->dlg], hwnd[p->ctl], p->prev);
395 if (p->isok)
396 {
397 ok (a == hwnd[p->res], "Test %d: %s %s item of %d in %d was %d instead of %d\n", p->test, p->prev ? "Prev" : "Next", p->tab ? "Tab" : "Group", p->ctl, p->dlg, id(a), p->res);
398 }
399 else
400 {
401 todo_wine
402 {
403 ok (a == hwnd[p->res], "Test %d: %s %s item of %d in %d was actually %d matching expected %d\n", p->test, p->prev ? "Prev" : "Next", p->tab ? "Tab" : "Group", p->ctl, p->dlg, id(a), p->res);
404 }
405 }
406 p++;
407 }
408 }
409
410 /*
411 * OnMainWindowCreate
412 */
413 static BOOL OnMainWindowCreate (HWND hwnd, LPCREATESTRUCT lpcs)
414 {
415 g_hwndButton1 = CreateWindow (TEXT("button"), TEXT("Button &1"),
416 WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_DEFPUSHBUTTON | BS_TEXT,
417 10, 10, 80, 80, hwnd, (HMENU)100, g_hinst, 0);
418 if (!g_hwndButton1) return FALSE;
419
420 g_hwndButton2 = CreateWindow (TEXT("button"), TEXT("Button &2"),
421 WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_TEXT,
422 110, 10, 80, 80, hwnd, (HMENU)200, g_hinst, 0);
423 if (!g_hwndButton2) return FALSE;
424
425 g_hwndButtonCancel = CreateWindow (TEXT("button"), TEXT("Cancel"),
426 WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON | BS_TEXT,
427 210, 10, 80, 80, hwnd, (HMENU)IDCANCEL, g_hinst, 0);
428 if (!g_hwndButtonCancel) return FALSE;
429
430 return TRUE;
431 }
432
433
434 /*
435 * OnTestDlgCreate
436 */
437
438 static BOOL OnTestDlgCreate (HWND hwnd, LPCREATESTRUCT lpcs)
439 {
440 g_hwndTestDlgEdit = CreateWindowEx ( WS_EX_LEFT | WS_EX_LTRREADING |
441 WS_EX_RIGHTSCROLLBAR | WS_EX_NOPARENTNOTIFY | WS_EX_CLIENTEDGE,
442 TEXT("Edit"), TEXT("Edit"),
443 WS_CHILDWINDOW | WS_VISIBLE | WS_TABSTOP | ES_LEFT | ES_AUTOHSCROLL,
444 16,33,184,24, hwnd, (HMENU)101, g_hinst, 0);
445 if (!g_hwndTestDlgEdit) return FALSE;
446
447 g_hwndTestDlgBut1 = CreateWindowEx ( WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR
448 | WS_EX_NOPARENTNOTIFY,
449 TEXT("button"), TEXT("Button &1"),
450 WS_CHILDWINDOW | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON | BS_TEXT,
451 204,33,30,24, hwnd, (HMENU)201, g_hinst, 0);
452 if (!g_hwndTestDlgBut1) return FALSE;
453
454 g_hwndTestDlgBut2 = CreateWindowEx ( WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR
455 | WS_EX_NOPARENTNOTIFY, TEXT("button"),
456 TEXT("Button &2"),
457 WS_CHILDWINDOW | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON | BS_TEXT,
458 90,102,80,24, hwnd, (HMENU)IDCANCEL, g_hinst, 0);
459 if (!g_hwndTestDlgBut2) return FALSE;
460
461 return TRUE;
462 }
463
464 static LRESULT CALLBACK main_window_procA (HWND hwnd, UINT uiMsg, WPARAM wParam,
465 LPARAM lParam)
466 {
467 LRESULT result;
468 switch (uiMsg)
469 {
470 /* Add blank case statements for these to ensure we don't use them
471 * by mistake.
472 */
473 case DM_GETDEFID: break;
474 case DM_SETDEFID: break;
475
476 case WM_CREATE:
477 return (OnMainWindowCreate (hwnd,
478 (LPCREATESTRUCTA) lParam) ? 0 : (LRESULT) -1);
479 case WM_COMMAND:
480 if (wParam == IDCANCEL)
481 {
482 g_terminated = TRUE;
483 return 0;
484 }
485 break;
486 }
487
488 result=DefWindowProcA (hwnd, uiMsg, wParam, lParam);
489 return result;
490 }
491
492 static LRESULT CALLBACK disabled_test_proc (HWND hwnd, UINT uiMsg,
493 WPARAM wParam, LPARAM lParam)
494 {
495 LRESULT result;
496 DWORD dw;
497 HWND hwndOk;
498
499 switch (uiMsg)
500 {
501 case WM_INITDIALOG:
502 dw = SendMessage(hwnd, DM_GETDEFID, 0, 0);
503 assert(DC_HASDEFID == HIWORD(dw));
504 hwndOk = GetDlgItem(hwnd, LOWORD(dw));
505 assert(hwndOk);
506 EnableWindow(hwndOk, FALSE);
507
508 PostMessage(hwnd, WM_KEYDOWN, VK_RETURN, 0);
509 PostMessage(hwnd, WM_COMMAND, IDCANCEL, 0);
510 break;
511 case WM_COMMAND:
512 if (wParam == IDOK)
513 {
514 g_terminated = TRUE;
515 EndDialog(hwnd, 0);
516 return 0;
517 }
518 else if (wParam == IDCANCEL)
519 {
520 EndDialog(hwnd, 0);
521 return 0;
522 }
523 break;
524 }
525
526 result=DefWindowProcA (hwnd, uiMsg, wParam, lParam);
527 return result;
528 }
529
530 static LRESULT CALLBACK testDlgWinProc (HWND hwnd, UINT uiMsg, WPARAM wParam,
531 LPARAM lParam)
532 {
533 LRESULT result;
534 switch (uiMsg)
535 {
536 /* Add blank case statements for these to ensure we don't use them
537 * by mistake.
538 */
539 case DM_GETDEFID: break;
540 case DM_SETDEFID: break;
541
542 case WM_CREATE:
543 return (OnTestDlgCreate (hwnd,
544 (LPCREATESTRUCTA) lParam) ? 0 : (LRESULT) -1);
545 }
546
547 result=DefWindowProcA (hwnd, uiMsg, wParam, lParam);
548 return result;
549 }
550
551 static BOOL RegisterWindowClasses (void)
552 {
553 WNDCLASSA cls;
554
555 cls.style = 0;
556 cls.lpfnWndProc = DefWindowProcA;
557 cls.cbClsExtra = 0;
558 cls.cbWndExtra = 0;
559 cls.hInstance = g_hinst;
560 cls.hIcon = NULL;
561 cls.hCursor = LoadCursorA (NULL, IDC_ARROW);
562 cls.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
563 cls.lpszMenuName = NULL;
564 cls.lpszClassName = "GetNextDlgItemWindowClass";
565
566 if (!RegisterClassA (&cls)) return FALSE;
567
568 cls.lpfnWndProc = main_window_procA;
569 cls.lpszClassName = "IsDialogMessageWindowClass";
570
571 if (!RegisterClassA (&cls)) return FALSE;
572
573 GetClassInfoA(0, "#32770", &cls);
574 cls.lpfnWndProc = testDlgWinProc;
575 cls.lpszClassName = "WM_NEXTDLGCTLWndClass";
576 if (!RegisterClassA (&cls)) return FALSE;
577
578 return TRUE;
579 }
580
581 static void WM_NEXTDLGCTLTest(void)
582 {
583 DWORD dwVal;
584
585 g_hwndTestDlg = CreateWindowEx( WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR
586 | WS_EX_DLGMODALFRAME | WS_EX_WINDOWEDGE | WS_EX_CONTROLPARENT | WS_EX_APPWINDOW,
587 "WM_NEXTDLGCTLWndClass",
588 "WM_NEXTDLGCTL Message test window",
589 WS_POPUPWINDOW | WS_CLIPSIBLINGS | WS_DLGFRAME | WS_OVERLAPPED |
590 WS_MINIMIZEBOX | WS_MAXIMIZEBOX | DS_3DLOOK | DS_SETFONT | DS_MODALFRAME,
591 0, 0, 235, 135,
592 NULL, NULL, g_hinst, 0);
593
594 assert (g_hwndTestDlg);
595 assert (g_hwndTestDlgBut1);
596 assert (g_hwndTestDlgBut2);
597 assert (g_hwndTestDlgEdit);
598
599 /*
600 * Test message DM_SETDEFID
601 */
602
603 DefDlgProcA( g_hwndTestDlg, DM_SETDEFID, IDCANCEL, 0 );
604 DefDlgProcA( g_hwndTestDlgBut1, BM_SETSTYLE, BS_DEFPUSHBUTTON, FALSE );
605 dwVal = DefDlgProcA(g_hwndTestDlg, DM_GETDEFID, 0, 0);
606
607 ok ( IDCANCEL == (LOWORD(dwVal)), "Did not set default ID\n" );
608
609 /*
610 * Check whether message WM_NEXTDLGCTL is changing the focus to next control and if
611 * the destination control is a button, style of the button should be changed to
612 * BS_DEFPUSHBUTTON with out making it default.
613 */
614
615 /*
616 * Keep the focus on Edit control.
617 */
618
619 if ( SetFocus( g_hwndTestDlgEdit ) )
620 {
621 ok ((GetFocus() == g_hwndTestDlgEdit), "Focus didn't set on Edit control\n");
622
623 /*
624 * Test message WM_NEXTDLGCTL
625 */
626 DefDlgProcA( g_hwndTestDlg, WM_NEXTDLGCTL, 0, 0 );
627 ok ((GetFocus() == g_hwndTestDlgBut1), "Focus didn't move to first button\n");
628
629 /*
630 * Check whether the default button ID got changed by sending message "WM_NEXTDLGCTL"
631 */
632 dwVal = DefDlgProcA(g_hwndTestDlg, DM_GETDEFID, 0, 0);
633 ok ( IDCANCEL == (LOWORD(dwVal)), "WM_NEXTDLGCTL changed default button\n");
634
635 /*
636 * Check whether the style of the button which got the focus, changed to BS_DEFPUSHBUTTON and
637 * the style of default button changed to BS_PUSHBUTTON.
638 */
639 if ( IDCANCEL == (LOWORD(dwVal)) )
640 {
641 ok ( ((GetWindowLong( g_hwndTestDlgBut1, GWL_STYLE)) & BS_DEFPUSHBUTTON),
642 "Button1 style not set to BS_DEFPUSHBUTTON\n" );
643
644 ok ( !((GetWindowLong( g_hwndTestDlgBut2, GWL_STYLE)) & BS_DEFPUSHBUTTON),
645 "Button2's style not chaged to BS_PUSHBUTTON\n" );
646 }
647
648 /*
649 * Move focus to Button2 using "WM_NEXTDLGCTL"
650 */
651 DefDlgProcA( g_hwndTestDlg, WM_NEXTDLGCTL, 0, 0 );
652 ok ((GetFocus() == g_hwndTestDlgBut2), "Focus didn't move to second button\n");
653
654 /*
655 * Check whether the default button ID got changed by sending message "WM_NEXTDLGCTL"
656 */
657 dwVal = DefDlgProcA(g_hwndTestDlg, DM_GETDEFID, 0, 0);
658 ok ( IDCANCEL == (LOWORD(dwVal)), "WM_NEXTDLGCTL changed default button\n");
659
660 /*
661 * Check whether the style of the button which got the focus, changed to BS_DEFPUSHBUTTON and
662 * the style of button which lost the focus changed to BS_PUSHBUTTON.
663 */
664 if ( IDCANCEL == (LOWORD(dwVal)) )
665 {
666 ok ( ((GetWindowLong( g_hwndTestDlgBut2, GWL_STYLE)) & BS_DEFPUSHBUTTON),
667 "Button2 style not set to BS_DEFPUSHBUTTON\n" );
668
669 ok ( !((GetWindowLong( g_hwndTestDlgBut1, GWL_STYLE)) & BS_DEFPUSHBUTTON),
670 "Button1's style not chaged to BS_PUSHBUTTON\n" );
671 }
672
673 /*
674 * Move focus to Edit control using "WM_NEXTDLGCTL"
675 */
676 DefDlgProcA( g_hwndTestDlg, WM_NEXTDLGCTL, 0, 0 );
677 ok ((GetFocus() == g_hwndTestDlgEdit), "Focus didn't move to Edit control\n");
678
679 /*
680 * Check whether the default button ID got changed by sending message "WM_NEXTDLGCTL"
681 */
682 dwVal = DefDlgProcA(g_hwndTestDlg, DM_GETDEFID, 0, 0);
683 ok ( IDCANCEL == (LOWORD(dwVal)), "WM_NEXTDLGCTL changed default button\n");
684 }
685 DestroyWindow(g_hwndTestDlg);
686 }
687
688 static void IsDialogMessageWTest (void)
689 {
690 MSG msg;
691
692 g_hwndMain = CreateWindow ("IsDialogMessageWindowClass", "IsDialogMessageWindowClass",
693 WS_OVERLAPPEDWINDOW,
694 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
695 NULL, NULL, g_hinst, 0);
696
697 assert (g_hwndMain);
698 assert (g_hwndButton1);
699 assert (g_hwndButtonCancel);
700
701 /* The focus should initially be nowhere. The first TAB should take it
702 * to the first button. The second TAB should take it to the Cancel
703 * button.
704 */
705 FormTabMsg (&msg, g_hwndMain);
706 ok (IsDialogMessage (g_hwndMain, &msg), "Did not handle first TAB\n");
707 ok ((GetFocus() == g_hwndButton1), "Focus did not move to first button\n");
708 FormTabMsg (&msg, g_hwndButton1);
709 ok (IsDialogMessage (g_hwndMain, &msg), "Did not handle second TAB\n");
710 ok ((GetFocus() == g_hwndButtonCancel),
711 "Focus did not move to cancel button\n");
712 FormEnterMsg (&msg, g_hwndButtonCancel);
713 ok (IsDialogMessage (g_hwndMain, &msg), "Did not handle the ENTER\n");
714 ok (g_terminated, "ENTER did not terminate\n");
715 }
716
717
718 static INT_PTR CALLBACK delayFocusDlgWinProc (HWND hDlg, UINT uiMsg, WPARAM wParam,
719 LPARAM lParam)
720 {
721 switch (uiMsg)
722 {
723 case WM_INITDIALOG:
724 g_hwndMain = hDlg;
725 g_hwndInitialFocusGroupBox = GetDlgItem(hDlg,100);
726 g_hwndButton1 = GetDlgItem(hDlg,200);
727 g_hwndButton2 = GetDlgItem(hDlg,201);
728 g_hwndButtonCancel = GetDlgItem(hDlg,IDCANCEL);
729 g_styleInitialFocusT1 = GetWindowLong(g_hwndInitialFocusGroupBox, GWL_STYLE);
730
731 /* Initially check the second radio button */
732 SendMessage(g_hwndButton1, BM_SETCHECK, BST_UNCHECKED, 0);
733 SendMessage(g_hwndButton2, BM_SETCHECK, BST_CHECKED , 0);
734 /* Continue testing after dialog initialization */
735 PostMessage(hDlg, WM_USER, 0, 0);
736 return g_bInitialFocusInitDlgResult;
737
738 case WM_COMMAND:
739 if (LOWORD(wParam) == IDCANCEL)
740 {
741 EndDialog(hDlg, LOWORD(wParam));
742 return TRUE;
743 }
744 return FALSE;
745
746 case WM_USER:
747 g_styleInitialFocusT2 = GetWindowLong(hDlg, GWL_STYLE);
748 g_hwndInitialFocusT1 = GetFocus();
749 SetFocus(hDlg);
750 g_hwndInitialFocusT2 = GetFocus();
751 PostMessage(hDlg, WM_COMMAND, IDCANCEL, 0);
752 return TRUE;
753 }
754
755 return FALSE;
756 }
757
758 static INT_PTR CALLBACK focusDlgWinProc (HWND hDlg, UINT uiMsg, WPARAM wParam,
759 LPARAM lParam)
760 {
761 switch (uiMsg)
762 {
763 case WM_INITDIALOG:
764 return TRUE;
765
766 case WM_COMMAND:
767 if (LOWORD(wParam) == IDCANCEL)
768 {
769 EndDialog(hDlg, LOWORD(wParam));
770 return TRUE;
771 }
772 else if (LOWORD(wParam) == 200)
773 {
774 if (HIWORD(wParam) == EN_SETFOCUS)
775 g_hwndInitialFocusT1 = (HWND)lParam;
776 }
777 return FALSE;
778 }
779
780 return FALSE;
781 }
782
783 /* Helper for InitialFocusTest */
784 static const char * GetHwndString(HWND hw)
785 {
786 if (hw == NULL)
787 return "a null handle";
788 if (hw == g_hwndMain)
789 return "the dialog handle";
790 if (hw == g_hwndInitialFocusGroupBox)
791 return "the group box control";
792 if (hw == g_hwndButton1)
793 return "the first button";
794 if (hw == g_hwndButton2)
795 return "the second button";
796 if (hw == g_hwndButtonCancel)
797 return "the cancel button";
798
799 return "unknown handle";
800 }
801
802 static void InitialFocusTest (void)
803 {
804 /* Test 1:
805 * This test intentionally returns FALSE in response to WM_INITDIALOG
806 * without setting focus to a control. This is not allowed according to
807 * MSDN, but it is exactly what MFC's CFormView does.
808 *
809 * Since the WM_INITDIALOG handler returns FALSE without setting the focus,
810 * the focus should initially be NULL. Later, when we manually set focus to
811 * the dialog, the default handler should set focus to the first control that
812 * is "visible, not disabled, and has the WS_TABSTOP style" (MSDN). Because the
813 * second radio button has been checked, it should be the first control
814 * that meets these criteria and should receive the focus.
815 */
816
817 g_bInitialFocusInitDlgResult = FALSE;
818 g_hwndInitialFocusT1 = (HWND) -1;
819 g_hwndInitialFocusT2 = (HWND) -1;
820 g_styleInitialFocusT1 = -1;
821 g_styleInitialFocusT2 = -1;
822
823 DialogBoxA(g_hinst, "RADIO_TEST_DIALOG", NULL, delayFocusDlgWinProc);
824
825 ok (((g_styleInitialFocusT1 & WS_TABSTOP) == 0),
826 "Error in wrc - Detected WS_TABSTOP as default style for GROUPBOX\n");
827
828 ok (((g_styleInitialFocusT2 & WS_VISIBLE) == 0),
829 "Modal dialogs should not be shown until the message queue first goes empty\n");
830
831 ok ((g_hwndInitialFocusT1 == NULL),
832 "Error in initial focus when WM_INITDIALOG returned FALSE: "
833 "Expected NULL focus, got %s (%p).\n",
834 GetHwndString(g_hwndInitialFocusT1), g_hwndInitialFocusT1);
835
836 ok ((g_hwndInitialFocusT2 == g_hwndButton2),
837 "Error after first SetFocus() when WM_INITDIALOG returned FALSE: "
838 "Expected the second button (%p), got %s (%p).\n",
839 g_hwndButton2, GetHwndString(g_hwndInitialFocusT2),
840 g_hwndInitialFocusT2);
841
842 /* Test 2:
843 * This is the same as above, except WM_INITDIALOG is made to return TRUE.
844 * This should cause the focus to go to the second radio button right away
845 * and stay there (until the user indicates otherwise).
846 */
847
848 g_bInitialFocusInitDlgResult = TRUE;
849 g_hwndInitialFocusT1 = (HWND) -1;
850 g_hwndInitialFocusT2 = (HWND) -1;
851 g_styleInitialFocusT1 = -1;
852 g_styleInitialFocusT2 = -1;
853
854 DialogBoxA(g_hinst, "RADIO_TEST_DIALOG", NULL, delayFocusDlgWinProc);
855
856 ok ((g_hwndInitialFocusT1 == g_hwndButton2),
857 "Error in initial focus when WM_INITDIALOG returned TRUE: "
858 "Expected the second button (%p), got %s (%p).\n",
859 g_hwndButton2, GetHwndString(g_hwndInitialFocusT2),
860 g_hwndInitialFocusT2);
861
862 ok ((g_hwndInitialFocusT2 == g_hwndButton2),
863 "Error after first SetFocus() when WM_INITDIALOG returned TRUE: "
864 "Expected the second button (%p), got %s (%p).\n",
865 g_hwndButton2, GetHwndString(g_hwndInitialFocusT2),
866 g_hwndInitialFocusT2);
867
868 /* Test 3:
869 * If the dialog has DS_CONTROL and it's not visible then we shouldn't change focus */
870 {
871 HWND hDlg;
872 HRSRC hResource;
873 HANDLE hTemplate;
874 DLGTEMPLATE* pTemplate;
875
876 hResource = FindResourceA(g_hinst,"FOCUS_TEST_DIALOG", RT_DIALOG);
877 hTemplate = LoadResource(g_hinst, hResource);
878 pTemplate = LockResource(hTemplate);
879
880 g_hwndInitialFocusT1 = 0;
881 hDlg = CreateDialogIndirectParamA(g_hinst, pTemplate, NULL, focusDlgWinProc, 0);
882 ok (hDlg != 0, "Failed to create test dialog.\n");
883
884 ok ((g_hwndInitialFocusT1 == 0),
885 "Focus should not be set for an invisible DS_CONTROL dialog %p.\n", g_hwndInitialFocusT1);
886
887 DestroyWindow(hDlg);
888 }
889 }
890
891 static void test_GetDlgItemText(void)
892 {
893 char string[64];
894 BOOL ret;
895
896 strcpy(string, "Overwrite Me");
897 ret = GetDlgItemTextA(NULL, 0, string, sizeof(string)/sizeof(string[0]));
898 ok(!ret, "GetDlgItemText(NULL) shouldn't have succeeded\n");
899
900 ok(string[0] == '\0' || broken(!strcmp(string, "Overwrite Me")),
901 "string retrieved using GetDlgItemText should have been NULL terminated\n");
902 }
903
904 static INT_PTR CALLBACK DestroyDlgWinProc (HWND hDlg, UINT uiMsg,
905 WPARAM wParam, LPARAM lParam)
906 {
907 if (uiMsg == WM_INITDIALOG)
908 {
909 DestroyWindow(hDlg);
910 return TRUE;
911 }
912 return FALSE;
913 }
914
915 static INT_PTR CALLBACK DestroyOnCloseDlgWinProc (HWND hDlg, UINT uiMsg,
916 WPARAM wParam, LPARAM lParam)
917 {
918 switch (uiMsg)
919 {
920 case WM_INITDIALOG:
921 PostMessage(hDlg, WM_CLOSE, 0, 0);
922 return TRUE;
923 case WM_CLOSE:
924 DestroyWindow(hDlg);
925 return TRUE;
926 case WM_DESTROY:
927 PostQuitMessage(0);
928 return TRUE;
929 }
930 return FALSE;
931 }
932
933
934 static INT_PTR CALLBACK TestDefButtonDlgProc (HWND hDlg, UINT uiMsg,
935 WPARAM wParam, LPARAM lParam)
936 {
937 switch (uiMsg)
938 {
939 case WM_INITDIALOG:
940 EndDialog(hDlg, LOWORD(SendMessage(hDlg, DM_GETDEFID, 0, 0)));
941 return TRUE;
942 }
943 return FALSE;
944 }
945
946 static void test_DialogBoxParamA(void)
947 {
948 INT_PTR ret;
949 HWND hwnd_invalid = (HWND)0x4444;
950
951 SetLastError(0xdeadbeef);
952 ret = DialogBoxParamA(GetModuleHandle(NULL), "IDD_DIALOG" , hwnd_invalid, 0 , 0);
953 ok(0 == ret || broken(ret == -1), "DialogBoxParamA returned %ld, expected 0\n", ret);
954 ok(ERROR_INVALID_WINDOW_HANDLE == GetLastError() ||
955 broken(GetLastError() == 0xdeadbeef),
956 "got %d, expected ERROR_INVALID_WINDOW_HANDLE\n",GetLastError());
957
958 /* Test a dialog which destroys itself on WM_INITDIALOG. */
959 SetLastError(0xdeadbeef);
960 ret = DialogBoxParamA(GetModuleHandle(NULL), "IDD_DIALOG", 0, DestroyDlgWinProc, 0);
961 ok(-1 == ret, "DialogBoxParamA returned %ld, expected -1\n", ret);
962 ok(ERROR_INVALID_WINDOW_HANDLE == GetLastError() ||
963 GetLastError() == ERROR_SUCCESS ||
964 broken(GetLastError() == 0xdeadbeef),
965 "got %d, expected ERROR_INVALID_WINDOW_HANDLE\n",GetLastError());
966
967 /* Test a dialog which destroys itself on WM_CLOSE. */
968 ret = DialogBoxParamA(GetModuleHandle(NULL), "IDD_DIALOG", 0, DestroyOnCloseDlgWinProc, 0);
969 ok(0 == ret, "DialogBoxParamA returned %ld, expected 0\n", ret);
970
971 SetLastError(0xdeadbeef);
972 ret = DialogBoxParamA(GetModuleHandle(NULL), "RESOURCE_INVALID" , 0, 0, 0);
973 ok(-1 == ret, "DialogBoxParamA returned %ld, expected -1\n", ret);
974 ok(ERROR_RESOURCE_NAME_NOT_FOUND == GetLastError() ||
975 broken(GetLastError() == 0xdeadbeef),
976 "got %d, expected ERROR_RESOURCE_NAME_NOT_FOUND\n",GetLastError());
977
978 SetLastError(0xdeadbeef);
979 ret = DefDlgProcA(0, WM_ERASEBKGND, 0, 0);
980 ok(ret == 0, "DefDlgProcA returned %ld, expected 0\n", ret);
981 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE ||
982 broken(GetLastError() == 0xdeadbeef),
983 "got %d, expected ERROR_INVALID_WINDOW_HANDLE\n", GetLastError());
984
985 ret = DialogBoxParamA(GetModuleHandle(NULL), "TEST_EMPTY_DIALOG", 0, TestDefButtonDlgProc, 0);
986 ok(ret == IDOK, "Expected IDOK\n");
987 }
988
989 static void test_DisabledDialogTest(void)
990 {
991 g_terminated = FALSE;
992 DialogBoxParam(g_hinst, "IDD_DIALOG", NULL, (DLGPROC)disabled_test_proc, 0);
993 ok(FALSE == g_terminated, "dialog with disabled ok button has been terminated\n");
994 }
995
996 static INT_PTR CALLBACK messageBoxFontDlgWinProc (HWND hDlg, UINT uiMsg, WPARAM wParam,
997 LPARAM lParam)
998 {
999 return (uiMsg == WM_INITDIALOG);
1000 }
1001
1002 static void test_MessageBoxFontTest(void)
1003 {
1004 /* This dialog template defines a dialog template which got 0x7fff as its
1005 * font size and omits the other font members. On WinNT, passing such a
1006 * dialog template to CreateDialogIndirectParamW will result in a dialog
1007 * being created which uses the message box font. We test that here.
1008 */
1009
1010 static unsigned char dlgTemplate[] =
1011 {
1012 /* Dialog header */
1013 0x01,0x00, /* Version */
1014 0xff,0xff, /* Extended template marker */
1015 0x00,0x00,0x00,0x00, /* Context Help ID */
1016 0x00,0x00,0x00,0x00, /* Extended style */
1017 0xc0,0x00,0xc8,0x80, /* Style (WS_SYSMENU|WS_CAPTION|WS_POPUP|DS_SETFONT|DS_MODALFRAME) */
1018 0x01,0x00, /* Control count */
1019 0x00,0x00, /* X */
1020 0x00,0x00, /* Y */
1021 0x80,0x00, /* Width */
1022 0x80,0x00, /* Height */
1023 0x00,0x00, /* Menu name */
1024 0x00,0x00, /* Class name */
1025 'T',0x00,'e',0x00, /* Caption (unicode) */
1026 's',0x00,'t',0x00,
1027 0x00,0x00,
1028 0xff,0x7f, /* Font height (0x7fff = message box font) */
1029
1030 /* Control #1 */
1031 0x00,0x00, /* Align to DWORD (header is 42 bytes) */
1032 0x00,0x00,0x00,0x00, /* Context Help ID */
1033 0x00,0x00,0x00,0x00, /* Extended style */
1034 0x00,0x00,0x00,0x50, /* Style (WS_CHILD|WS_VISIBLE) */
1035 0x00,0x00, /* X */
1036 0x00,0x00, /* Y */
1037 0x80,0x00, /* Width */
1038 0x80,0x00, /* Height */
1039 0x00,0x01,0x00,0x00, /* Control ID (256) */
1040 0xff,0xff,0x82,0x00, /* Class (Static) */
1041 'W',0x00,'I',0x00, /* Caption (unicode) */
1042 'N',0x00,'E',0x00,
1043 ' ',0x00,'d',0x00,
1044 'i',0x00,'a',0x00,
1045 'l',0x00,'o',0x00,
1046 'g',0x00,' ',0x00,
1047 't',0x00,'e',0x00,
1048 's',0x00,'t',0x00,
1049 '.',0x00,0x00,0x00,
1050 0x00,0x00, /* Size of extended data */
1051
1052 0x00,0x00 /* Align to DWORD */
1053 };
1054
1055 HWND hDlg;
1056 HFONT hFont;
1057 LOGFONTW lfStaticFont;
1058 NONCLIENTMETRICSW ncMetrics;
1059
1060 /* Check if the dialog can be created from the template. On Win9x, this should fail
1061 * because we are calling the W function which is not implemented, but that's what
1062 * we want, because passing such a template to CreateDialogIndirectParamA would crash
1063 * anyway.
1064 */
1065 hDlg = CreateDialogIndirectParamW(g_hinst, (LPCDLGTEMPLATE)dlgTemplate, NULL, messageBoxFontDlgWinProc, 0);
1066 if (!hDlg)
1067 {
1068 win_skip("dialog wasn't created\n");
1069 return;
1070 }
1071
1072 hFont = (HFONT) SendDlgItemMessageW(hDlg, 256, WM_GETFONT, 0, 0);
1073 if (!hFont)
1074 {
1075 skip("dialog uses system font\n");
1076 DestroyWindow(hDlg);
1077 return;
1078 }
1079 GetObjectW(hFont, sizeof(LOGFONTW), &lfStaticFont);
1080
1081 ncMetrics.cbSize = sizeof(NONCLIENTMETRICSW);
1082 SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, 0, &ncMetrics, 0);
1083 ok( !memcmp(&lfStaticFont, &ncMetrics.lfMessageFont, FIELD_OFFSET(LOGFONTW, lfFaceName)) &&
1084 !lstrcmpW(lfStaticFont.lfFaceName, ncMetrics.lfMessageFont.lfFaceName),
1085 "dialog doesn't use message box font\n");
1086 DestroyWindow(hDlg);
1087 }
1088
1089 static void test_SaveRestoreFocus(void)
1090 {
1091 HWND hDlg;
1092 HRSRC hResource;
1093 HANDLE hTemplate;
1094 DLGTEMPLATE* pTemplate;
1095 LONG_PTR foundId;
1096 HWND foundHwnd;
1097
1098 /* create the dialog */
1099 hResource = FindResourceA(g_hinst, "MULTI_EDIT_DIALOG", RT_DIALOG);
1100 hTemplate = LoadResource(g_hinst, hResource);
1101 pTemplate = LockResource(hTemplate);
1102
1103 hDlg = CreateDialogIndirectParamA(g_hinst, pTemplate, NULL, messageBoxFontDlgWinProc, 0);
1104 ok (hDlg != 0, "Failed to create test dialog.\n");
1105
1106 foundId = GetWindowLongPtr(GetFocus(), GWLP_ID);
1107 ok (foundId == 1000, "First edit box should have gained focus on dialog creation. Expected: %d, Found: %ld\n", 1000, foundId);
1108
1109 /* de- then reactivate the dialog */
1110 SendMessage(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_INACTIVE, 0), 0);
1111 SendMessage(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_ACTIVE, 0), 0);
1112
1113 foundId = GetWindowLongPtr(GetFocus(), GWLP_ID);
1114 ok (foundId == 1000, "First edit box should have regained focus after dialog reactivation. Expected: %d, Found: %ld\n", 1000, foundId);
1115
1116 /* select the next tabbable item */
1117 SetFocus(GetNextDlgTabItem(hDlg, GetFocus(), FALSE));
1118
1119 foundId = GetWindowLongPtr(GetFocus(), GWLP_ID);
1120 ok (foundId == 1001, "Second edit box should have gained focus. Expected: %d, Found: %ld\n", 1001, foundId);
1121
1122 /* de- then reactivate the dialog */
1123 SendMessage(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_INACTIVE, 0), 0);
1124 SendMessage(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_ACTIVE, 0), 0);
1125
1126 foundId = GetWindowLongPtr(GetFocus(), GWLP_ID);
1127 ok (foundId == 1001, "Second edit box should have gained focus after dialog reactivation. Expected: %d, Found: %ld\n", 1001, foundId);
1128
1129 /* disable the 2nd box */
1130 EnableWindow(GetFocus(), FALSE);
1131
1132 foundHwnd = GetFocus();
1133 ok (foundHwnd == NULL, "Second edit box should have lost focus after being disabled. Expected: %p, Found: %p\n", NULL, foundHwnd);
1134
1135 /* de- then reactivate the dialog */
1136 SendMessage(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_INACTIVE, 0), 0);
1137 SendMessage(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_ACTIVE, 0), 0);
1138
1139 foundHwnd = GetFocus();
1140 ok (foundHwnd == NULL, "No controls should have gained focus after dialog reactivation. Expected: %p, Found: %p\n", NULL, foundHwnd);
1141
1142 /* clean up */
1143 DestroyWindow(hDlg);
1144 }
1145
1146 START_TEST(dialog)
1147 {
1148 g_hinst = GetModuleHandleA (0);
1149
1150 if (!RegisterWindowClasses()) assert(0);
1151
1152 GetNextDlgItemTest();
1153 IsDialogMessageWTest();
1154 WM_NEXTDLGCTLTest();
1155 InitialFocusTest();
1156 test_GetDlgItemText();
1157 test_DialogBoxParamA();
1158 test_DisabledDialogTest();
1159 test_MessageBoxFontTest();
1160 test_SaveRestoreFocus();
1161 }