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 }