user32/tests: Fix test failure on Win7.
[wine] / dlls / user32 / tests / 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 static void test_DialogBoxParamA(void)
934 {
935     INT_PTR ret;
936     HWND hwnd_invalid = (HWND)0x4444;
937
938     SetLastError(0xdeadbeef);
939     ret = DialogBoxParamA(GetModuleHandle(NULL), "IDD_DIALOG" , hwnd_invalid, 0 , 0);
940     ok(0 == ret || broken(ret == -1), "DialogBoxParamA returned %ld, expected 0\n", ret);
941     ok(ERROR_INVALID_WINDOW_HANDLE == GetLastError() ||
942        broken(GetLastError() == 0xdeadbeef),
943        "got %d, expected ERROR_INVALID_WINDOW_HANDLE\n",GetLastError());
944
945     /* Test a dialog which destroys itself on WM_INITDIALOG. */
946     SetLastError(0xdeadbeef);
947     ret = DialogBoxParamA(GetModuleHandle(NULL), "IDD_DIALOG", 0, DestroyDlgWinProc, 0);
948     ok(-1 == ret, "DialogBoxParamA returned %ld, expected -1\n", ret);
949     ok(ERROR_INVALID_WINDOW_HANDLE == GetLastError() ||
950        GetLastError() == ERROR_SUCCESS ||
951        broken(GetLastError() == 0xdeadbeef),
952        "got %d, expected ERROR_INVALID_WINDOW_HANDLE\n",GetLastError());
953
954     /* Test a dialog which destroys itself on WM_CLOSE. */
955     ret = DialogBoxParamA(GetModuleHandle(NULL), "IDD_DIALOG", 0, DestroyOnCloseDlgWinProc, 0);
956     ok(0 == ret, "DialogBoxParamA returned %ld, expected 0\n", ret);
957
958     SetLastError(0xdeadbeef);
959     ret = DialogBoxParamA(GetModuleHandle(NULL), "RESOURCE_INVALID" , 0, 0, 0);
960     ok(-1 == ret, "DialogBoxParamA returned %ld, expected -1\n", ret);
961     ok(ERROR_RESOURCE_NAME_NOT_FOUND == GetLastError() ||
962        broken(GetLastError() == 0xdeadbeef),
963        "got %d, expected ERROR_RESOURCE_NAME_NOT_FOUND\n",GetLastError());
964
965     SetLastError(0xdeadbeef);
966     ret = DefDlgProcA(0, WM_ERASEBKGND, 0, 0);
967     ok(ret == 0, "DefDlgProcA returned %ld, expected 0\n", ret);
968     ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE ||
969        broken(GetLastError() == 0xdeadbeef),
970        "got %d, expected ERROR_INVALID_WINDOW_HANDLE\n", GetLastError());
971 }
972
973 static void test_DisabledDialogTest(void)
974 {
975     g_terminated = FALSE;
976     DialogBoxParam(g_hinst, "IDD_DIALOG", NULL, (DLGPROC)disabled_test_proc, 0);
977     ok(FALSE == g_terminated, "dialog with disabled ok button has been terminated\n");
978 }
979
980 static INT_PTR CALLBACK messageBoxFontDlgWinProc (HWND hDlg, UINT uiMsg, WPARAM wParam,
981         LPARAM lParam)
982 {
983     return (uiMsg == WM_INITDIALOG);
984 }
985
986 static void test_MessageBoxFontTest(void)
987 {
988     /* This dialog template defines a dialog template which got 0x7fff as its
989      * font size and omits the other font members. On WinNT, passing such a
990      * dialog template to CreateDialogIndirectParamW will result in a dialog
991      * being created which uses the message box font. We test that here.
992      */
993
994     static unsigned char dlgTemplate[] =
995     {
996         /* Dialog header */
997         0x01,0x00,              /* Version */
998         0xff,0xff,              /* Extended template marker */
999         0x00,0x00,0x00,0x00,    /* Context Help ID */
1000         0x00,0x00,0x00,0x00,    /* Extended style */
1001         0xc0,0x00,0xc8,0x80,    /* Style (WS_SYSMENU|WS_CAPTION|WS_POPUP|DS_SETFONT|DS_MODALFRAME) */
1002         0x01,0x00,              /* Control count */
1003         0x00,0x00,              /* X */
1004         0x00,0x00,              /* Y */
1005         0x80,0x00,              /* Width */
1006         0x80,0x00,              /* Height */
1007         0x00,0x00,              /* Menu name */
1008         0x00,0x00,              /* Class name */
1009         'T',0x00,'e',0x00,      /* Caption (unicode) */
1010         's',0x00,'t',0x00,
1011         0x00,0x00,
1012         0xff,0x7f,              /* Font height (0x7fff = message box font) */
1013
1014         /* Control #1 */
1015         0x00,0x00,              /* Align to DWORD (header is 42 bytes) */
1016         0x00,0x00,0x00,0x00,    /* Context Help ID */
1017         0x00,0x00,0x00,0x00,    /* Extended style */
1018         0x00,0x00,0x00,0x50,    /* Style (WS_CHILD|WS_VISIBLE) */
1019         0x00,0x00,              /* X */
1020         0x00,0x00,              /* Y */
1021         0x80,0x00,              /* Width */
1022         0x80,0x00,              /* Height */
1023         0x00,0x01,0x00,0x00,    /* Control ID (256) */
1024         0xff,0xff,0x82,0x00,    /* Class (Static) */
1025         'W',0x00,'I',0x00,      /* Caption (unicode) */
1026         'N',0x00,'E',0x00,
1027         ' ',0x00,'d',0x00,
1028         'i',0x00,'a',0x00,
1029         'l',0x00,'o',0x00,
1030         'g',0x00,' ',0x00,
1031         't',0x00,'e',0x00,
1032         's',0x00,'t',0x00,
1033         '.',0x00,0x00,0x00,
1034         0x00,0x00,              /* Size of extended data */
1035
1036         0x00,0x00               /* Align to DWORD */
1037     };
1038
1039     HWND hDlg;
1040     HFONT hFont;
1041     LOGFONTW lfStaticFont;
1042     NONCLIENTMETRICSW ncMetrics;
1043
1044     /* Check if the dialog can be created from the template. On Win9x, this should fail
1045      * because we are calling the W function which is not implemented, but that's what
1046      * we want, because passing such a template to CreateDialogIndirectParamA would crash
1047      * anyway.
1048      */
1049     hDlg = CreateDialogIndirectParamW(g_hinst, (LPCDLGTEMPLATE)dlgTemplate, NULL, messageBoxFontDlgWinProc, 0);
1050     if (!hDlg)
1051     {
1052         win_skip("dialog wasn't created\n");
1053         return;
1054     }
1055
1056     hFont = (HFONT) SendDlgItemMessageW(hDlg, 256, WM_GETFONT, 0, 0);
1057     if (!hFont)
1058     {
1059         skip("dialog uses system font\n");
1060         DestroyWindow(hDlg);
1061         return;
1062     }
1063     GetObjectW(hFont, sizeof(LOGFONTW), &lfStaticFont);
1064
1065     ncMetrics.cbSize = sizeof(NONCLIENTMETRICSW);
1066     SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, 0, &ncMetrics, 0);
1067     ok( !memcmp(&lfStaticFont, &ncMetrics.lfMessageFont, FIELD_OFFSET(LOGFONTW, lfFaceName)) &&
1068         !lstrcmpW(lfStaticFont.lfFaceName, ncMetrics.lfMessageFont.lfFaceName),
1069         "dialog doesn't use message box font\n");
1070     DestroyWindow(hDlg);
1071 }
1072
1073 static void test_SaveRestoreFocus(void)
1074 {
1075     HWND hDlg;
1076     HRSRC hResource;
1077     HANDLE hTemplate;
1078     DLGTEMPLATE* pTemplate;
1079     LONG_PTR foundId;
1080     HWND foundHwnd;
1081
1082     /* create the dialog */
1083     hResource = FindResourceA(g_hinst, "MULTI_EDIT_DIALOG", RT_DIALOG);
1084     hTemplate = LoadResource(g_hinst, hResource);
1085     pTemplate = LockResource(hTemplate);
1086
1087     hDlg = CreateDialogIndirectParamA(g_hinst, pTemplate, NULL, messageBoxFontDlgWinProc, 0);
1088     ok (hDlg != 0, "Failed to create test dialog.\n");
1089
1090     foundId = GetWindowLongPtr(GetFocus(), GWLP_ID);
1091     ok (foundId == 1000, "First edit box should have gained focus on dialog creation. Expected: %d, Found: %ld\n", 1000, foundId);
1092
1093     /* de- then reactivate the dialog */
1094     SendMessage(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_INACTIVE, 0), 0);
1095     SendMessage(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_ACTIVE, 0), 0);
1096
1097     foundId = GetWindowLongPtr(GetFocus(), GWLP_ID);
1098     ok (foundId == 1000, "First edit box should have regained focus after dialog reactivation. Expected: %d, Found: %ld\n", 1000, foundId);
1099
1100     /* select the next tabbable item */
1101     SetFocus(GetNextDlgTabItem(hDlg, GetFocus(), FALSE));
1102
1103     foundId = GetWindowLongPtr(GetFocus(), GWLP_ID);
1104     ok (foundId == 1001, "Second edit box should have gained focus. Expected: %d, Found: %ld\n", 1001, foundId);
1105
1106     /* de- then reactivate the dialog */
1107     SendMessage(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_INACTIVE, 0), 0);
1108     SendMessage(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_ACTIVE, 0), 0);
1109
1110     foundId = GetWindowLongPtr(GetFocus(), GWLP_ID);
1111     ok (foundId == 1001, "Second edit box should have gained focus after dialog reactivation. Expected: %d, Found: %ld\n", 1001, foundId);
1112
1113     /* disable the 2nd box */
1114     EnableWindow(GetFocus(), FALSE);
1115
1116     foundHwnd = GetFocus();
1117     ok (foundHwnd == NULL, "Second edit box should have lost focus after being disabled. Expected: %p, Found: %p\n", NULL, foundHwnd);
1118
1119     /* de- then reactivate the dialog */
1120     SendMessage(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_INACTIVE, 0), 0);
1121     SendMessage(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_ACTIVE, 0), 0);
1122
1123     foundHwnd = GetFocus();
1124     ok (foundHwnd == NULL, "No controls should have gained focus after dialog reactivation. Expected: %p, Found: %p\n", NULL, foundHwnd);
1125
1126     /* clean up */
1127     DestroyWindow(hDlg);
1128 }
1129
1130 START_TEST(dialog)
1131 {
1132     g_hinst = GetModuleHandleA (0);
1133
1134     if (!RegisterWindowClasses()) assert(0);
1135
1136     GetNextDlgItemTest();
1137     IsDialogMessageWTest();
1138     WM_NEXTDLGCTLTest();
1139     InitialFocusTest();
1140     test_GetDlgItemText();
1141     test_DialogBoxParamA();
1142     test_DisabledDialogTest();
1143     test_MessageBoxFontTest();
1144     test_SaveRestoreFocus();
1145 }