modules/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 #ifndef __REACTOS__
  33 #define WINVER 0x0600 /* For NONCLIENTMETRICS with padding */
  34 #endif
  35
  36 #include <assert.h>
  37 #include <stdio.h>
  38 #include <stdarg.h>
  39
  40 #include "wine/test.h"
  41 #include "windef.h"
  42 #include "winbase.h"
  43 #include "wingdi.h"
  44 #include "winuser.h"
  45
  46 #define MAXHWNDS 1024
  47 static HWND hwnd [MAXHWNDS];
  48 static unsigned int numwnds=1; /* 0 is reserved for null */
  49
  50 /* Global handles */
  51 static HINSTANCE g_hinst;                          /* This application's HINSTANCE */
  52 static HWND g_hwndMain, g_hwndButton1, g_hwndButton2, g_hwndButtonCancel;
  53 static HWND g_hwndTestDlg, g_hwndTestDlgBut1, g_hwndTestDlgBut2, g_hwndTestDlgEdit;
  54 static HWND g_hwndInitialFocusT1, g_hwndInitialFocusT2, g_hwndInitialFocusGroupBox;
  55
  56 static LONG g_styleInitialFocusT1, g_styleInitialFocusT2;
  57 static BOOL g_bInitialFocusInitDlgResult, g_bReceivedCommand;
  58
  59 static BOOL g_terminated;
  60
  61 typedef struct {
  62     INT_PTR id;
  63     int parent;
  64     DWORD style;
  65     DWORD exstyle;
  66 } h_entry;
  67
  68 static const h_entry hierarchy [] = {
  69     /* 0 is reserved for the null window */
  70     {  1,  0, WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS, WS_EX_WINDOWEDGE},
  71     { 20,  1,  WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
  72     {  2,  1,  WS_CHILD | WS_VISIBLE, WS_EX_CONTROLPARENT},
  73     { 60,  2,  WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
  74     /* What happens with groups when the parent is disabled */
  75     {  8,  2,  WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_TABSTOP, WS_EX_CONTROLPARENT},
  76     { 85,  8,  WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_GROUP, 0},
  77     {  9,  8,  WS_CHILD, WS_EX_CONTROLPARENT},
  78     { 86,  9,  WS_CHILD | WS_VISIBLE, 0},
  79     { 87,  9,  WS_CHILD | WS_VISIBLE, 0},
  80     { 31,  8,  WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
  81     { 10,  2,  WS_CHILD | WS_VISIBLE, WS_EX_CONTROLPARENT},
  82     { 88, 10,  WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
  83     { 11, 10,  WS_CHILD, WS_EX_CONTROLPARENT},
  84     { 89, 11,  WS_CHILD | WS_VISIBLE, 0},
  85     { 32, 11,  WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
  86     { 90, 11,  WS_CHILD | WS_VISIBLE, 0},
  87     { 33, 10,  WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
  88     { 21,  2,  WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
  89     { 61,  2,  WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
  90     {  3,  1,  WS_CHILD | WS_VISIBLE | DS_CONTROL, 0},
  91     { 22,  3,  WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
  92     { 62,  3,  WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
  93     {  7,  3,  WS_CHILD | WS_VISIBLE, WS_EX_CONTROLPARENT},
  94     {  4,  7,  WS_CHILD | WS_VISIBLE | DS_CONTROL, 0},
  95     { 83,  4,  WS_CHILD | WS_VISIBLE, 0},
  96     {  5,  4,  WS_CHILD | WS_VISIBLE | DS_CONTROL, 0},
  97     /* A couple of controls around the main dialog */
  98     { 29,  5,  WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
  99     { 81,  5,  WS_CHILD | WS_VISIBLE, 0},
 100     /* The main dialog with lots of controls */
 101     {  6,  5,  WS_CHILD | WS_VISIBLE, WS_EX_CONTROLPARENT},
 102         /* At the start of a dialog */
 103         /* Disabled controls are skipped */
 104     { 63,  6,  WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_TABSTOP, 0},
 105         /* Invisible controls are skipped */
 106     { 64,  6,  WS_CHILD | WS_TABSTOP, 0},
 107         /* Invisible disabled controls are skipped */
 108     { 65,  6,  WS_CHILD | WS_DISABLED | WS_TABSTOP, 0},
 109         /* Non-tabstop controls are skipped for tabs but not for groups */
 110     { 66,  6,  WS_CHILD | WS_VISIBLE, 0},
 111         /* End of first group, with no tabstops in it */
 112     { 23,  6,  WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
 113         /* At last a tabstop */
 114     { 67,  6,  WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
 115     /* A group that is totally disabled or invisible */
 116     { 24,  6,  WS_CHILD | WS_DISABLED | WS_GROUP, 0},
 117     { 68,  6,  WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_TABSTOP, 0},
 118     { 69,  6,  WS_CHILD | WS_TABSTOP, 0},
 119     /* A valid group in the middle of the dialog (not the first nor last group*/
 120     { 25,  6,  WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
 121         /* A non-tabstop item will be skipped for tabs */
 122     { 70,  6,  WS_CHILD | WS_VISIBLE, 0},
 123         /* A disabled item will be skipped for tabs and groups */
 124     { 71,  6,  WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_TABSTOP, 0},
 125         /* A valid item will be found for tabs and groups */
 126     { 72,  6,  WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
 127         /* A disabled item to skip when looking for the next group item */
 128     { 73,  6,  WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_TABSTOP, 0},
 129     /* The next group begins with an enabled visible label */
 130     { 26,  6,  WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
 131     { 74,  6,  WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
 132     { 75,  6,  WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
 133     /* That group is terminated by a disabled label */
 134     { 27,  6,  WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_GROUP, 0},
 135     { 76,  6,  WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
 136     { 77,  6,  WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
 137     /* That group is terminated by an invisible label */
 138     { 28,  6,  WS_CHILD | WS_GROUP, 0},
 139     /* The end of the dialog with item for loop and recursion testing */
 140     { 78,  6,  WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
 141     /* No tabstop so skipped for prev tab, but found for prev group */
 142     { 79,  6,  WS_CHILD | WS_VISIBLE, 0},
 143     { 80,  6,  WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_TABSTOP, 0},
 144     /* A couple of controls after the main dialog */
 145     { 82,  5,  WS_CHILD | WS_VISIBLE, 0},
 146     { 30,  5,  WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
 147     /* And around them */
 148     { 84,  4,  WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
 149     {0, 0, 0, 0}
 150 };
 151
 152 static BOOL CreateWindows (HINSTANCE hinst)
 153 {
 154     const h_entry *p = hierarchy;
 155
 156     while (p->id != 0)
 157     {
 158         DWORD style, exstyle;
 159         char ctrlname[9];
 160
 161         /* Basically assert that the hierarchy is valid and track the
 162          * maximum control number
 163          */
 164         if (p->id >= numwnds)
 165         {
 166             if (p->id >=  sizeof(hwnd)/sizeof(hwnd[0]))
 167             {
 168                 trace ("Control %ld is out of range\n", p->id);
 169                 return FALSE;
 170             }
 171             else
 172                 numwnds = p->id+1;
 173         }
 174         if (p->id <= 0)
 175         {
 176             trace ("Control %ld is out of range\n", p->id);
 177             return FALSE;
 178         }
 179         if (hwnd[p->id] != 0)
 180         {
 181             trace ("Control %ld is used more than once\n", p->id);
 182             return FALSE;
 183         }
 184
 185         /* Create the control */
 186         sprintf (ctrlname, "ctrl%4.4ld", p->id);
 187         hwnd[p->id] = CreateWindowExA(p->exstyle, p->parent ? "static" : "GetNextDlgItemWindowClass", ctrlname, p->style, 10, 10, 10, 10, hwnd[p->parent], p->parent ? (HMENU) (2000 + p->id) : 0, hinst, 0);
 188         if (!hwnd[p->id])
 189         {
 190             trace ("Failed to create control %ld\n", p->id);
 191             return FALSE;
 192         }
 193
 194         /* Check that the styles are as we specified (except the main one
 195          * which is quite frequently messed up).  If this keeps breaking then
 196          * we could mask out the bits that don't concern us.
 197          */
 198         if (p->parent)
 199         {
 200             style = GetWindowLongA(hwnd[p->id], GWL_STYLE);
 201             exstyle = GetWindowLongA(hwnd[p->id], GWL_EXSTYLE);
 202             if (style != p->style || exstyle != p->exstyle)
 203             {
 204                 trace ("Style mismatch at %ld: %8.8x %8.8x cf %8.8x %8.8x\n", p->id, style, exstyle, p->style, p->exstyle);
 205             }
 206         }
 207         p++;
 208     }
 209
 210     return TRUE;
 211 }
 212
 213 /* Form the lParam of a WM_KEYDOWN message */
 214 static DWORD KeyDownData (int repeat, int scancode, int extended, int wasdown)
 215 {
 216     return ((repeat & 0x0000FFFF) | ((scancode & 0x00FF) << 16) |
 217             (extended ? 0x01000000 : 0) | (wasdown ? 0x40000000 : 0));
 218 }
 219
 220 /* Form a WM_KEYDOWN VK_TAB message to the specified window */
 221 static void FormTabMsg (MSG *pMsg, HWND hwnd)
 222 {
 223     pMsg->hwnd = hwnd;
 224     pMsg->message = WM_KEYDOWN;
 225     pMsg->wParam = VK_TAB;
 226     pMsg->lParam = KeyDownData (1, 0x0F, 0, 0);
 227     /* pMsg->time is not set.  It shouldn't be needed */
 228     /* pMsg->pt is ignored */
 229 }
 230
 231 /* Form a WM_KEYDOWN VK_RETURN message to the specified window */
 232 static void FormEnterMsg (MSG *pMsg, HWND hwnd)
 233 {
 234     pMsg->hwnd = hwnd;
 235     pMsg->message = WM_KEYDOWN;
 236     pMsg->wParam = VK_RETURN;
 237     pMsg->lParam = KeyDownData (1, 0x1C, 0, 0);
 238     /* pMsg->time is not set.  It shouldn't be needed */
 239     /* pMsg->pt is ignored */
 240 }
 241
 242 /***********************************************************************
 243  *
 244  * The actual tests
 245  */
 246
 247 typedef struct
 248 {
 249     int isok; /* or is it todo */
 250     int test;
 251     int dlg;
 252     int ctl;
 253     int tab;
 254     int prev;
 255     int res;
 256 } test_record;
 257
 258 static int id (HWND h)
 259 {
 260     unsigned int i;
 261     for (i = 0; i < numwnds; i++)
 262         if (hwnd[i] == h)
 263             return i;
 264     return -1;
 265 }
 266
 267 /* Tests
 268  *
 269  * Tests 1-8 test the hCtl argument of null or the dialog itself.
 270  *
 271  *   1. Prev Group of null is null
 272  *   2. Prev Tab of null is null
 273  *   3. Prev Group of hDlg in hDlg is null
 274  *   4. Prev Tab of hDlg in hDlg is null
 275  *   5. Next Group of null is first visible enabled child
 276  *      Check it skips invisible, disabled and both.
 277  *   6. Next Tab of null is first visible enabled tabstop
 278  *      Check it skips invisible, disabled, nontabstop, and in combination.
 279  *   7. Next Group of hDlg in hDlg is as of null
 280  *   8. Next Tab of hDlg in hDlg is as of null
 281  *
 282  * Tests 9-14 test descent
 283  *
 284  *   9. DS_CONTROL does not result in descending the hierarchy for Tab Next
 285  *  10. DS_CONTROL does not result in descending the hierarchy for Group Next
 286  *  11. WS_EX_CONTROLPARENT results in descending the hierarchy for Tab Next
 287  *  12. WS_EX_CONTROLPARENT results in descending the hierarchy for Group Next
 288  *  13. WS_EX_CONTROLPARENT results in descending the hierarchy for Tab Prev
 289  *  14. WS_EX_CONTROLPARENT results in descending the hierarchy for Group Prev
 290  *
 291  * Tests 15-24 are the basic Prev/Next Group tests
 292  *
 293  *  15. Next Group of a visible enabled non-group control is the next visible
 294  *      enabled non-group control, if there is one before the next group
 295  *  16. Next Group of a visible enabled non-group control wraps around to the
 296  *      beginning of the group on finding a control that starts another group.
 297  *      Note that the group is in the middle of the dialog.
 298  *  17. As 16 except note that the next group is started with a disabled
 299  *      visible control.
 300  *  18. As 16 except note that the next group is started with an invisible
 301  *      enabled control.
 302  *  19. Next Group wraps around the controls of the dialog
 303  *  20. Next Group is the same even if the initial control is disabled.
 304  *  21. Next Group is the same even if the initial control is invisible.
 305  *  22. Next Group is the same even if the initial control has the group style
 306  *  23. Next Group returns the initial control if there is no visible enabled
 307  *      control in the group. (Initial control disabled and not group style).
 308  *  24. Prev version of test 16.
 309  *      Prev Group of a visible enabled non-group control wraps around to the
 310  *      beginning of the group on finding a control that starts the group.
 311  *      Note that the group is in the middle of the dialog.
 312  *
 313  * In tests 25 to 28 the control is sitting under dialogs which do not have
 314  * the WS_EX_CONTROLPARENT style and so cannot be reached from the top of
 315  * the dialog.
 316  *
 317  *  25. Next Group of an inaccessible control is as if it were accessible
 318  *  26. Prev Group of an inaccessible control begins searching at the highest
 319  *      level ancestor that did not permit recursion down the hierarchy
 320  *  27. Next Tab of an inaccessible control is as if it were accessible
 321  *  28. Prev Tab of an inaccessible control begins searching at the highest
 322  *      level ancestor that did not permit recursion down the hierarchy.
 323  *
 324  * Tests 29- are the basic Tab tests
 325  *
 326  *  29. Next Tab of a control is the next visible enabled control with the
 327  *      Tabstop style (N.B. skips disabled, invisible and non-tabstop)
 328  *  30. Prev Tab of a control is the previous visible enabled control with the
 329  *      Tabstop style (N.B. skips disabled, invisible and non-tabstop)
 330  *  31. Next Tab test with at least two layers of descent and finding the
 331  *      result not at the first control.
 332  *  32. Next Tab test with at least two layers of descent with the descent and
 333  *      control at the start of each level.
 334  *  33. Prev Tab test with at least two layers of descent and finding the
 335  *      result not at the last control.
 336  *  34. Prev Tab test with at least two layers of descent with the descent and
 337  *      control at the end of each level.
 338  *
 339  *  35. Passing NULL may result in the first child being the one returned.
 340  *      (group test)
 341  *  36. Passing NULL may result in the first child being the one returned.
 342  *      (tab test)
 343  */
 344
 345 static void test_GetNextDlgItem(void)
 346 {
 347     static test_record test [] =
 348     {
 349         /* isok test dlg  ctl  tab  prev res  */
 350
 351         {   1,   1,    6,   0,   0,   1,   0},
 352         {   1,   2,    6,   0,   1,   1,   0},
 353         {   1,   3,    6,   6,   0,   1,   0},
 354         {   1,   4,    6,   6,   1,   1,   0},
 355         {   1,   5,    6,   0,   0,   0,  66},
 356         {   1,   6,    6,   0,   1,   0,  67},
 357         {   1,   7,    6,   6,   0,   0,  66},
 358         {   1,   8,    6,   6,   1,   0,  67},
 359
 360         {   1,   9,    4,  83,   1,   0,  84},
 361         {   1,  10,    4,  83,   0,   0,   5},
 362         {   1,  11,    5,  81,   1,   0,  67},
 363         {   1,  12,    5,  81,   0,   0,  66},
 364         {   1,  13,    5,  82,   1,   1,  78},
 365
 366         {   1,  14,    5,  82,   0,   1,  79},
 367         {   1,  15,    6,  70,   0,   0,  72},
 368         {   1,  16,    6,  72,   0,   0,  25},
 369         {   1,  17,    6,  75,   0,   0,  26},
 370         {   1,  18,    6,  77,   0,   0,  76},
 371         {   1,  19,    6,  79,   0,   0,  66},
 372         {   1,  20,    6,  71,   0,   0,  72},
 373         {   1,  21,    6,  64,   0,   0,  66},
 374
 375         {   1,  22,    6,  25,   0,   0,  70},
 376         {   1,  23,    6,  68,   0,   0,  68},
 377         {   1,  24,    6,  25,   0,   1,  72},
 378         {   1,  25,    1,  70,   0,   0,  72},
 379         /*{   0,  26,    1,  70,   0,   1,   3}, Crashes Win95*/
 380         {   1,  27,    1,  70,   1,   0,  72},
 381         /*{   0,  28,    1,  70,   1,   1,  61}, Crashes Win95*/
 382
 383         {   1,  29,    6,  67,   1,   0,  72},
 384         {   1,  30,    6,  72,   1,   1,  67},
 385
 386         {   1,  35,    2,   0,   0,   0,  60},
 387         {   1,  36,    2,   0,   1,   0,  60},
 388
 389         {   0,   0,    0,   0,   0,   0,   0}  /* End of test */
 390     };
 391     const test_record *p = test;
 392
 393     ok (CreateWindows (g_hinst), "Could not create test windows\n");
 394
 395     while (p->dlg)
 396     {
 397         HWND a;
 398         a = (p->tab ? GetNextDlgTabItem : GetNextDlgGroupItem) (hwnd[p->dlg], hwnd[p->ctl], p->prev);
 399         todo_wine_if (!p->isok)
 400             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);
 401         p++;
 402     }
 403 }
 404
 405 /*
 406  *  OnMainWindowCreate
 407  */
 408 static BOOL OnMainWindowCreate(HWND hwnd, LPCREATESTRUCTA lpcs)
 409 {
 410     g_hwndButton1 = CreateWindowA("button", "Button &1",
 411             WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_DEFPUSHBUTTON | BS_TEXT,
 412             10, 10, 80, 80, hwnd, (HMENU)100, g_hinst, 0);
 413     if (!g_hwndButton1) return FALSE;
 414
 415     g_hwndButton2 = CreateWindowA("button", "Button &2",
 416             WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_TEXT,
 417             110, 10, 80, 80, hwnd, (HMENU)200, g_hinst, 0);
 418     if (!g_hwndButton2) return FALSE;
 419
 420     g_hwndButtonCancel = CreateWindowA("button", "Cancel",
 421             WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON | BS_TEXT,
 422             210, 10, 80, 80, hwnd, (HMENU)IDCANCEL, g_hinst, 0);
 423     if (!g_hwndButtonCancel) return FALSE;
 424
 425     return TRUE;
 426 }
 427
 428
 429 /*
 430  *  OnTestDlgCreate
 431  */
 432
 433 static BOOL OnTestDlgCreate (HWND hwnd, LPCREATESTRUCTA lpcs)
 434 {
 435     g_hwndTestDlgEdit = CreateWindowExA( WS_EX_LEFT | WS_EX_LTRREADING |
 436             WS_EX_RIGHTSCROLLBAR | WS_EX_NOPARENTNOTIFY | WS_EX_CLIENTEDGE,
 437             "Edit", "Edit",
 438             WS_CHILDWINDOW | WS_VISIBLE | WS_TABSTOP | ES_LEFT | ES_AUTOHSCROLL,
 439             16,33,184,24, hwnd, (HMENU)101, g_hinst, 0);
 440     if (!g_hwndTestDlgEdit) return FALSE;
 441
 442     g_hwndTestDlgBut1 = CreateWindowExA( WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR
 443             | WS_EX_NOPARENTNOTIFY,
 444             "button", "Button &1",
 445             WS_CHILDWINDOW | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON | BS_TEXT,
 446             204,33,30,24, hwnd, (HMENU)201, g_hinst, 0);
 447     if (!g_hwndTestDlgBut1) return FALSE;
 448
 449     g_hwndTestDlgBut2 = CreateWindowExA( WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR
 450             | WS_EX_NOPARENTNOTIFY, "button",
 451             "Button &2",
 452             WS_CHILDWINDOW | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON | BS_TEXT,
 453             90,102,80,24, hwnd, (HMENU)IDCANCEL, g_hinst, 0);
 454     if (!g_hwndTestDlgBut2) return FALSE;
 455
 456     return TRUE;
 457 }
 458
 459 static LRESULT CALLBACK main_window_procA (HWND hwnd, UINT uiMsg, WPARAM wParam,
 460         LPARAM lParam)
 461 {
 462     switch (uiMsg)
 463     {
 464         /* Add blank case statements for these to ensure we don't use them
 465          * by mistake.
 466          */
 467         case DM_GETDEFID: break;
 468         case DM_SETDEFID: break;
 469
 470         case WM_CREATE:
 471             return (OnMainWindowCreate (hwnd,
 472                     (LPCREATESTRUCTA) lParam) ? 0 : (LRESULT) -1);
 473         case WM_COMMAND:
 474             if (wParam == IDCANCEL)
 475             {
 476                 g_terminated = TRUE;
 477                 return 0;
 478             }
 479             break;
 480     }
 481
 482     return DefWindowProcA (hwnd, uiMsg, wParam, lParam);
 483 }
 484
 485 static LRESULT CALLBACK disabled_test_proc (HWND hwnd, UINT uiMsg,
 486         WPARAM wParam, LPARAM lParam)
 487 {
 488     switch (uiMsg)
 489     {
 490         case WM_INITDIALOG:
 491         {
 492             DWORD dw;
 493             HWND hwndOk;
 494
 495             dw = SendMessageA(hwnd, DM_GETDEFID, 0, 0);
 496             assert(DC_HASDEFID == HIWORD(dw));
 497             hwndOk = GetDlgItem(hwnd, LOWORD(dw));
 498             assert(hwndOk);
 499             EnableWindow(hwndOk, FALSE);
 500
 501             PostMessageA(hwnd, WM_KEYDOWN, VK_RETURN, 0);
 502             PostMessageA(hwnd, WM_COMMAND, IDCANCEL, 0);
 503             break;
 504         }
 505         case WM_COMMAND:
 506             if (wParam == IDOK)
 507             {
 508                 g_terminated = TRUE;
 509                 EndDialog(hwnd, 0);
 510                 return 0;
 511             }
 512             else if (wParam == IDCANCEL)
 513             {
 514                 EndDialog(hwnd, 0);
 515                 return 0;
 516             }
 517             break;
 518     }
 519
 520     return DefWindowProcA (hwnd, uiMsg, wParam, lParam);
 521 }
 522
 523 static LRESULT CALLBACK testDlgWinProc (HWND hwnd, UINT uiMsg, WPARAM wParam,
 524         LPARAM lParam)
 525 {
 526     switch (uiMsg)
 527     {
 528         /* Add blank case statements for these to ensure we don't use them
 529          * by mistake.
 530          */
 531         case DM_GETDEFID: break;
 532         case DM_SETDEFID: break;
 533
 534         case WM_CREATE:
 535             return (OnTestDlgCreate (hwnd,
 536                     (LPCREATESTRUCTA) lParam) ? 0 : (LRESULT) -1);
 537         case WM_COMMAND:
 538             if(LOWORD(wParam) == 300) g_bReceivedCommand = TRUE;
 539     }
 540
 541     return DefDlgProcA (hwnd, uiMsg, wParam, lParam);
 542 }
 543
 544 static LRESULT CALLBACK test_control_procA(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
 545 {
 546     switch(msg)
 547     {
 548         case WM_CREATE:
 549         {
 550             static const short sample[] = { 10,1,2,3,4,5 };
 551             CREATESTRUCTA *cs = (CREATESTRUCTA *)lparam;
 552             short *data = cs->lpCreateParams;
 553             ok(!memcmp(data, sample, sizeof(sample)), "data mismatch: %d,%d,%d,%d,%d\n", data[0], data[1], data[2], data[3], data[4]);
 554         }
 555         return 0;
 556
 557     default:
 558         break;
 559     }
 560
 561     return DefWindowProcA(hwnd, msg, wparam, lparam);
 562 }
 563
 564 static BOOL RegisterWindowClasses (void)
 565 {
 566     WNDCLASSA cls;
 567
 568     cls.style = 0;
 569     cls.lpfnWndProc = DefWindowProcA;
 570     cls.cbClsExtra = 0;
 571     cls.cbWndExtra = 0;
 572     cls.hInstance = g_hinst;
 573     cls.hIcon = NULL;
 574     cls.hCursor = LoadCursorA (NULL, (LPCSTR)IDC_ARROW);
 575     cls.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
 576     cls.lpszMenuName = NULL;
 577     cls.lpszClassName = "GetNextDlgItemWindowClass";
 578
 579     if (!RegisterClassA (&cls)) return FALSE;
 580
 581     cls.lpfnWndProc = main_window_procA;
 582     cls.lpszClassName = "IsDialogMessageWindowClass";
 583     if (!RegisterClassA (&cls)) return FALSE;
 584
 585     cls.lpfnWndProc = test_control_procA;
 586     cls.lpszClassName = "TESTCONTROL";
 587     if (!RegisterClassA (&cls)) return FALSE;
 588
 589     GetClassInfoA(0, "#32770", &cls);
 590     cls.lpfnWndProc = testDlgWinProc;
 591     cls.lpszClassName = "WM_NEXTDLGCTLWndClass";
 592     if (!RegisterClassA (&cls)) return FALSE;
 593
 594     return TRUE;
 595 }
 596
 597 static void test_WM_NEXTDLGCTL(void)
 598 {
 599     HWND child1, child2, child3;
 600     MSG msg;
 601     DWORD dwVal;
 602
 603     g_hwndTestDlg = CreateWindowExA( WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR
 604               | WS_EX_DLGMODALFRAME | WS_EX_WINDOWEDGE | WS_EX_CONTROLPARENT | WS_EX_APPWINDOW,
 605               "WM_NEXTDLGCTLWndClass",
 606               "WM_NEXTDLGCTL Message test window",
 607               WS_POPUPWINDOW | WS_CLIPSIBLINGS | WS_DLGFRAME | WS_OVERLAPPED |
 608               WS_MINIMIZEBOX | WS_MAXIMIZEBOX | DS_3DLOOK | DS_SETFONT | DS_MODALFRAME,
 609               0, 0, 235, 135,
 610               NULL, NULL, g_hinst, 0);
 611
 612     assert (g_hwndTestDlg);
 613     assert (g_hwndTestDlgBut1);
 614     assert (g_hwndTestDlgBut2);
 615     assert (g_hwndTestDlgEdit);
 616
 617     /*
 618      * Test message DM_SETDEFID
 619      */
 620
 621     DefDlgProcA( g_hwndTestDlg, DM_SETDEFID, IDCANCEL, 0 );
 622     DefDlgProcA( g_hwndTestDlgBut1, BM_SETSTYLE, BS_DEFPUSHBUTTON, FALSE );
 623     dwVal = DefDlgProcA(g_hwndTestDlg, DM_GETDEFID, 0, 0);
 624
 625     ok ( IDCANCEL == (LOWORD(dwVal)), "Did not set default ID\n" );
 626
 627     /*
 628      * Check whether message WM_NEXTDLGCTL is changing the focus to next control and if
 629      * the destination control is a button, style of the button should be changed to
 630      * BS_DEFPUSHBUTTON with out making it default.
 631      */
 632
 633     /*
 634      * Keep the focus on Edit control.
 635      */
 636
 637     if ( SetFocus( g_hwndTestDlgEdit ) )
 638     {
 639          ok ((GetFocus() == g_hwndTestDlgEdit), "Focus didn't set on Edit control\n");
 640
 641         /*
 642          * Test message WM_NEXTDLGCTL
 643          */
 644         DefDlgProcA( g_hwndTestDlg, WM_NEXTDLGCTL, 0, 0 );
 645         ok ((GetFocus() == g_hwndTestDlgBut1), "Focus didn't move to first button\n");
 646
 647         /*
 648          * Check whether the default button ID got changed by sending message "WM_NEXTDLGCTL"
 649          */
 650         dwVal = DefDlgProcA(g_hwndTestDlg, DM_GETDEFID, 0, 0);
 651         ok ( IDCANCEL == (LOWORD(dwVal)), "WM_NEXTDLGCTL changed default button\n");
 652
 653         /*
 654          * Check whether the style of the button which got the focus, changed to BS_DEFPUSHBUTTON and
 655          * the style of default button changed to BS_PUSHBUTTON.
 656          */
 657         if ( IDCANCEL == (LOWORD(dwVal)) )
 658         {
 659                 ok ( ((GetWindowLongA( g_hwndTestDlgBut1, GWL_STYLE)) & BS_DEFPUSHBUTTON),
 660                         "Button1 style not set to BS_DEFPUSHBUTTON\n" );
 661
 662                 ok ( !((GetWindowLongA( g_hwndTestDlgBut2, GWL_STYLE)) & BS_DEFPUSHBUTTON),
 663                         "Button2's style not changed to BS_PUSHBUTTON\n" );
 664         }
 665
 666         /*
 667          * Move focus to Button2 using "WM_NEXTDLGCTL"
 668          */
 669         DefDlgProcA( g_hwndTestDlg, WM_NEXTDLGCTL, 0, 0 );
 670         ok ((GetFocus() == g_hwndTestDlgBut2), "Focus didn't move to second button\n");
 671
 672         /*
 673          * Check whether the default button ID got changed by sending message "WM_NEXTDLGCTL"
 674          */
 675         dwVal = DefDlgProcA(g_hwndTestDlg, DM_GETDEFID, 0, 0);
 676         ok ( IDCANCEL == (LOWORD(dwVal)), "WM_NEXTDLGCTL changed default button\n");
 677
 678         /*
 679          * Check whether the style of the button which got the focus, changed to BS_DEFPUSHBUTTON and
 680          * the style of button which lost the focus changed to BS_PUSHBUTTON.
 681          */
 682         if ( IDCANCEL == (LOWORD(dwVal)) )
 683         {
 684                 ok ( ((GetWindowLongA( g_hwndTestDlgBut2, GWL_STYLE)) & BS_DEFPUSHBUTTON),
 685                         "Button2 style not set to BS_DEFPUSHBUTTON\n" );
 686
 687                 ok ( !((GetWindowLongA( g_hwndTestDlgBut1, GWL_STYLE)) & BS_DEFPUSHBUTTON),
 688                         "Button1's style not changed to BS_PUSHBUTTON\n" );
 689         }
 690
 691         /*
 692          * Move focus to Edit control using "WM_NEXTDLGCTL"
 693          */
 694         DefDlgProcA( g_hwndTestDlg, WM_NEXTDLGCTL, 0, 0 );
 695         ok ((GetFocus() == g_hwndTestDlgEdit), "Focus didn't move to Edit control\n");
 696
 697         /*
 698          * Check whether the default button ID got changed by sending message "WM_NEXTDLGCTL"
 699          */
 700         dwVal = DefDlgProcA(g_hwndTestDlg, DM_GETDEFID, 0, 0);
 701         ok ( IDCANCEL == (LOWORD(dwVal)), "WM_NEXTDLGCTL changed default button\n");
 702     }
 703
 704     /* test nested default buttons */
 705
 706     child1 = CreateWindowA("button", "child1", WS_VISIBLE|WS_CHILD, 0, 0, 50, 50,
 707                            g_hwndTestDlg, (HMENU)100, g_hinst, NULL);
 708     ok(child1 != NULL, "failed to create first child\n");
 709     child2 = CreateWindowA("button", "child2", WS_VISIBLE|WS_CHILD, 60, 60, 30, 30,
 710                            g_hwndTestDlg, (HMENU)200, g_hinst, NULL);
 711     ok(child2 != NULL, "failed to create second child\n");
 712     /* create nested child */
 713     child3 = CreateWindowA("button", "child3", WS_VISIBLE|WS_CHILD, 10, 10, 10, 10,
 714                            child1, (HMENU)300, g_hinst, NULL);
 715     ok(child3 != NULL, "failed to create subchild\n");
 716
 717     DefDlgProcA( g_hwndTestDlg, DM_SETDEFID, 200, 0);
 718     dwVal = DefDlgProcA( g_hwndTestDlg, DM_GETDEFID, 0, 0);
 719     ok(LOWORD(dwVal) == 200, "expected 200, got %x\n", dwVal);
 720
 721     DefDlgProcA( g_hwndTestDlg, DM_SETDEFID, 300, 0);
 722     dwVal = DefDlgProcA( g_hwndTestDlg, DM_GETDEFID, 0, 0);
 723     ok(LOWORD(dwVal) == 300, "expected 300, got %x\n", dwVal);
 724     ok(SendMessageW( child3, WM_GETDLGCODE, 0, 0) != DLGC_DEFPUSHBUTTON,
 725        "expected child3 not to be marked as DLGC_DEFPUSHBUTTON\n");
 726
 727     g_bReceivedCommand = FALSE;
 728     FormEnterMsg (&msg, child3);
 729     ok(IsDialogMessageA(g_hwndTestDlg, &msg), "Did not handle the ENTER\n");
 730     ok(g_bReceivedCommand, "Did not trigger the default Button action\n");
 731
 732     DestroyWindow(child3);
 733     DestroyWindow(child2);
 734     DestroyWindow(child1);
 735     DestroyWindow(g_hwndTestDlg);
 736 }
 737
 738 static LRESULT CALLBACK hook_proc(INT code, WPARAM wParam, LPARAM lParam)
 739 {
 740     ok(0, "unexpected hook called, code %d\n", code);
 741     return CallNextHookEx(NULL, code, wParam, lParam);
 742 }
 743
 744 static BOOL g_MSGF_DIALOGBOX;
 745 static LRESULT CALLBACK hook_proc2(INT code, WPARAM wParam, LPARAM lParam)
 746 {
 747     ok(code == MSGF_DIALOGBOX, "unexpected hook called, code %d\n", code);
 748     g_MSGF_DIALOGBOX = code == MSGF_DIALOGBOX;
 749     return CallNextHookEx(NULL, code, wParam, lParam);
 750 }
 751
 752 static void test_IsDialogMessage(void)
 753 {
 754     HHOOK hook;
 755     MSG msg;
 756
 757     g_hwndMain = CreateWindowA("IsDialogMessageWindowClass", "IsDialogMessageWindowClass",
 758             WS_OVERLAPPEDWINDOW,
 759             CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
 760             NULL, NULL, g_hinst, 0);
 761
 762     assert (g_hwndMain);
 763     assert (g_hwndButton1);
 764     assert (g_hwndButtonCancel);
 765
 766     if (0)
 767     {
 768         /* crashes on Windows */
 769         IsDialogMessageA(NULL, NULL);
 770         IsDialogMessageA(g_hwndMain, NULL);
 771     }
 772
 773     /* The focus should initially be nowhere.  The first TAB should take it
 774      * to the first button.  The second TAB should take it to the Cancel
 775      * button.
 776      */
 777
 778     /* valid window, invalid message window */
 779     hook = SetWindowsHookExA(WH_MSGFILTER, hook_proc2, NULL, GetCurrentThreadId());
 780     FormTabMsg (&msg, (HWND)0xbeefbeef);
 781     ok (!IsDialogMessageA(g_hwndMain, &msg), "expected failure\n");
 782     ok(g_MSGF_DIALOGBOX, "hook wasn't called\n");
 783     g_MSGF_DIALOGBOX = FALSE;
 784     UnhookWindowsHookEx(hook);
 785
 786     hook = SetWindowsHookExA(WH_MSGFILTER, hook_proc, NULL, GetCurrentThreadId());
 787     FormTabMsg (&msg, g_hwndMain);
 788
 789     ok (!IsDialogMessageA(NULL, &msg), "expected failure\n");
 790     ok (!IsDialogMessageA((HWND)0xbeefbeef, &msg), "expected failure\n");
 791
 792     UnhookWindowsHookEx(hook);
 793
 794     ok (IsDialogMessageA(g_hwndMain, &msg), "Did not handle first TAB\n");
 795     ok ((GetFocus() == g_hwndButton1), "Focus did not move to first button\n");
 796     FormTabMsg (&msg, g_hwndButton1);
 797     ok (IsDialogMessageA(g_hwndMain, &msg), "Did not handle second TAB\n");
 798     ok ((GetFocus() == g_hwndButtonCancel),
 799             "Focus did not move to cancel button\n");
 800     FormEnterMsg (&msg, g_hwndButtonCancel);
 801     ok (IsDialogMessageA(g_hwndMain, &msg), "Did not handle the ENTER\n");
 802     ok (g_terminated, "ENTER did not terminate\n");
 803
 804     /* matching but invalid window handles, NULL */
 805     hook = SetWindowsHookExA(WH_MSGFILTER, hook_proc, NULL, GetCurrentThreadId());
 806
 807     FormTabMsg (&msg, NULL);
 808     ok (!IsDialogMessageA(msg.hwnd, &msg), "expected failure\n");
 809
 810     /* matching but invalid window handles, not NULL */
 811     FormTabMsg (&msg, (HWND)0xbeefbeef);
 812     ok (!IsDialogMessageA(msg.hwnd, &msg), "expected failure\n");
 813
 814     UnhookWindowsHookEx(hook);
 815 }
 816
 817
 818 static INT_PTR CALLBACK delayFocusDlgWinProc (HWND hDlg, UINT uiMsg, WPARAM wParam,
 819         LPARAM lParam)
 820 {
 821     switch (uiMsg)
 822     {
 823     case WM_INITDIALOG:
 824         g_hwndMain = hDlg;
 825        g_hwndInitialFocusGroupBox = GetDlgItem(hDlg,100);
 826        g_hwndButton1 = GetDlgItem(hDlg,200);
 827        g_hwndButton2 = GetDlgItem(hDlg,201);
 828        g_hwndButtonCancel = GetDlgItem(hDlg,IDCANCEL);
 829        g_styleInitialFocusT1 = GetWindowLongA(g_hwndInitialFocusGroupBox, GWL_STYLE);
 830
 831        /* Initially check the second radio button */
 832        SendMessageA(g_hwndButton1, BM_SETCHECK, BST_UNCHECKED, 0);
 833        SendMessageA(g_hwndButton2, BM_SETCHECK, BST_CHECKED  , 0);
 834        /* Continue testing after dialog initialization */
 835        PostMessageA(hDlg, WM_USER, 0, 0);
 836        return g_bInitialFocusInitDlgResult;
 837
 838     case WM_COMMAND:
 839         if (LOWORD(wParam) == IDCANCEL)
 840        {
 841            EndDialog(hDlg, LOWORD(wParam));
 842            return TRUE;
 843        }
 844        return FALSE;
 845
 846     case WM_USER:
 847        g_styleInitialFocusT2 = GetWindowLongA(hDlg, GWL_STYLE);
 848         g_hwndInitialFocusT1 = GetFocus();
 849        SetFocus(hDlg);
 850         g_hwndInitialFocusT2 = GetFocus();
 851        PostMessageA(hDlg, WM_COMMAND, IDCANCEL, 0);
 852        return TRUE;
 853     }
 854
 855     return FALSE;
 856 }
 857
 858 static INT_PTR CALLBACK focusDlgWinProc (HWND hDlg, UINT uiMsg, WPARAM wParam,
 859         LPARAM lParam)
 860 {
 861     switch (uiMsg)
 862     {
 863     case WM_INITDIALOG:
 864         SetWindowTextA(GetDlgItem(hDlg, 200), "new caption");
 865         return TRUE;
 866
 867     case WM_COMMAND:
 868        if (LOWORD(wParam) == 200)
 869        {
 870            if (HIWORD(wParam) == EN_SETFOCUS)
 871                g_hwndInitialFocusT1 = (HWND)lParam;
 872        }
 873        return FALSE;
 874     }
 875
 876     return FALSE;
 877 }
 878
 879 /* Helper for InitialFocusTest */
 880 static const char * GetHwndString(HWND hw)
 881 {
 882   if (hw == NULL)
 883     return "a null handle";
 884   if (hw == g_hwndMain)
 885     return "the dialog handle";
 886   if (hw == g_hwndInitialFocusGroupBox)
 887     return "the group box control";
 888   if (hw == g_hwndButton1)
 889     return "the first button";
 890   if (hw == g_hwndButton2)
 891     return "the second button";
 892   if (hw == g_hwndButtonCancel)
 893     return "the cancel button";
 894
 895   return "unknown handle";
 896 }
 897
 898 static void test_focus(void)
 899 {
 900     /* Test 1:
 901      * This test intentionally returns FALSE in response to WM_INITDIALOG
 902      * without setting focus to a control. This is what MFC's CFormView does.
 903      *
 904      * Since the WM_INITDIALOG handler returns FALSE without setting the focus,
 905      * the focus should initially be NULL. Later, when we manually set focus to
 906      * the dialog, the default handler should set focus to the first control that
 907      * is "visible, not disabled, and has the WS_TABSTOP style" (MSDN). Because the
 908      * second radio button has been checked, it should be the first control
 909      * that meets these criteria and should receive the focus.
 910      */
 911
 912     g_bInitialFocusInitDlgResult = FALSE;
 913     g_hwndInitialFocusT1 = (HWND) -1;
 914     g_hwndInitialFocusT2 = (HWND) -1;
 915     g_styleInitialFocusT1 = -1;
 916     g_styleInitialFocusT2 = -1;
 917
 918     DialogBoxA(g_hinst, "RADIO_TEST_DIALOG", NULL, delayFocusDlgWinProc);
 919
 920     ok (((g_styleInitialFocusT1 & WS_TABSTOP) == 0),
 921        "Error in wrc - Detected WS_TABSTOP as default style for GROUPBOX\n");
 922
 923     ok (((g_styleInitialFocusT2 & WS_VISIBLE) == 0),
 924        "Modal dialogs should not be shown until the message queue first goes empty\n");
 925
 926     ok ((g_hwndInitialFocusT1 == NULL),
 927         "Error in initial focus when WM_INITDIALOG returned FALSE: "
 928         "Expected NULL focus, got %s (%p).\n",
 929         GetHwndString(g_hwndInitialFocusT1), g_hwndInitialFocusT1);
 930
 931     ok ((g_hwndInitialFocusT2 == g_hwndButton2),
 932         "Error after first SetFocus() when WM_INITDIALOG returned FALSE: "
 933         "Expected the second button (%p), got %s (%p).\n",
 934         g_hwndButton2, GetHwndString(g_hwndInitialFocusT2),
 935         g_hwndInitialFocusT2);
 936
 937     /* Test 2:
 938      * This is the same as above, except WM_INITDIALOG is made to return TRUE.
 939      * This should cause the focus to go to the second radio button right away
 940      * and stay there (until the user indicates otherwise).
 941      */
 942
 943     g_bInitialFocusInitDlgResult = TRUE;
 944     g_hwndInitialFocusT1 = (HWND) -1;
 945     g_hwndInitialFocusT2 = (HWND) -1;
 946     g_styleInitialFocusT1 = -1;
 947     g_styleInitialFocusT2 = -1;
 948
 949     DialogBoxA(g_hinst, "RADIO_TEST_DIALOG", NULL, delayFocusDlgWinProc);
 950
 951     ok ((g_hwndInitialFocusT1 == g_hwndButton2),
 952        "Error in initial focus when WM_INITDIALOG returned TRUE: "
 953        "Expected the second button (%p), got %s (%p).\n",
 954        g_hwndButton2, GetHwndString(g_hwndInitialFocusT1),
 955        g_hwndInitialFocusT1);
 956
 957     ok ((g_hwndInitialFocusT2 == g_hwndButton2),
 958        "Error after first SetFocus() when WM_INITDIALOG returned TRUE: "
 959        "Expected the second button (%p), got %s (%p).\n",
 960        g_hwndButton2, GetHwndString(g_hwndInitialFocusT2),
 961        g_hwndInitialFocusT2);
 962
 963     /* Test 3:
 964      * If the dialog has DS_CONTROL and it's not visible then we shouldn't change focus */
 965     {
 966         HWND hDlg;
 967         HRSRC hResource;
 968         HANDLE hTemplate;
 969         DLGTEMPLATE* pTemplate;
 970         HWND hTextbox;
 971         DWORD selectionStart = 0xdead, selectionEnd = 0xbeef;
 972
 973         hResource = FindResourceA(g_hinst,"FOCUS_TEST_DIALOG", (LPCSTR)RT_DIALOG);
 974         hTemplate = LoadResource(g_hinst, hResource);
 975         pTemplate = LockResource(hTemplate);
 976
 977         g_hwndInitialFocusT1 = 0;
 978         hDlg = CreateDialogIndirectParamA(g_hinst, pTemplate, NULL, focusDlgWinProc, 0);
 979         ok (hDlg != 0, "Failed to create test dialog.\n");
 980
 981         ok ((g_hwndInitialFocusT1 == 0),
 982             "Focus should not be set for an invisible DS_CONTROL dialog %p.\n", g_hwndInitialFocusT1);
 983
 984         /* Also make sure that WM_SETFOCUS selects the textbox's text */
 985         hTextbox = GetDlgItem(hDlg, 200);
 986         SendMessageA(hTextbox, WM_SETTEXT, 0, (LPARAM)"Hello world");
 987
 988         SendMessageA(hDlg, WM_SETFOCUS, 0, 0);
 989         SendMessageA(hTextbox, EM_GETSEL, (WPARAM)&selectionStart, (LPARAM)&selectionEnd);
 990         ok(selectionStart == 0 && selectionEnd == 11, "Text selection after WM_SETFOCUS is [%i, %i) expected [0, 11)\n", selectionStart, selectionEnd);
 991
 992         /* but WM_ACTIVATE does not */
 993         SendMessageA(hTextbox, EM_SETSEL, 0, 0);
 994         SendMessageA(hDlg, WM_ACTIVATE, WA_ACTIVE, 0);
 995         SendMessageA(hTextbox, EM_GETSEL, (WPARAM)&selectionStart, (LPARAM)&selectionEnd);
 996         ok(selectionStart == 0 && selectionEnd == 0, "Text selection after WM_ACTIVATE is [%i, %i) expected [0, 0)\n", selectionStart, selectionEnd);
 997
 998         DestroyWindow(hDlg);
 999     }
1000
1001     /* Test 4:
1002      * If the dialog has no tab-accessible controls, set focus to first control */
1003     {
1004         HWND hDlg;
1005         HRSRC hResource;
1006         HANDLE hTemplate;
1007         DLGTEMPLATE* pTemplate;
1008         HWND hLabel;
1009
1010         hResource = FindResourceA(g_hinst,"FOCUS_TEST_DIALOG_2", (LPCSTR)RT_DIALOG);
1011         hTemplate = LoadResource(g_hinst, hResource);
1012         pTemplate = LockResource(hTemplate);
1013
1014         hDlg = CreateDialogIndirectParamA(g_hinst, pTemplate, NULL, focusDlgWinProc, 0);
1015         ok(hDlg != 0, "Failed to create test dialog.\n");
1016         hLabel = GetDlgItem(hDlg, 200);
1017
1018         ok(GetFocus() == hLabel, "Focus not set to label, focus=%p dialog=%p label=%p\n", GetFocus(), hDlg, hLabel);
1019
1020         DestroyWindow(hDlg);
1021
1022         /* Also check focus after WM_ACTIVATE and WM_SETFOCUS */
1023         hDlg = CreateDialogIndirectParamA(g_hinst, pTemplate, NULL, NULL, 0);
1024         ok(hDlg != 0, "Failed to create test dialog.\n");
1025         hLabel = GetDlgItem(hDlg, 200);
1026
1027         SetFocus(NULL);
1028         SendMessageA(hDlg, WM_ACTIVATE, WA_ACTIVE, 0);
1029         ok(GetFocus() == NULL, "Focus set on WM_ACTIVATE, focus=%p dialog=%p label=%p\n", GetFocus(), hDlg, hLabel);
1030
1031         SetFocus(NULL);
1032         SendMessageA(hDlg, WM_SETFOCUS, 0, 0);
1033         ok(GetFocus() == hLabel, "Focus not set to label on WM_SETFOCUS, focus=%p dialog=%p label=%p\n", GetFocus(), hDlg, hLabel);
1034
1035         DestroyWindow(hDlg);
1036     }
1037
1038     /* Test 5:
1039      * Select textbox's text on creation */
1040     {
1041         HWND hDlg;
1042         HRSRC hResource;
1043         HANDLE hTemplate;
1044         DLGTEMPLATE* pTemplate;
1045         HWND edit;
1046         DWORD selectionStart = 0xdead, selectionEnd = 0xbeef;
1047
1048         hResource = FindResourceA(g_hinst,"FOCUS_TEST_DIALOG_3", (LPCSTR)RT_DIALOG);
1049         hTemplate = LoadResource(g_hinst, hResource);
1050         pTemplate = LockResource(hTemplate);
1051
1052         hDlg = CreateDialogIndirectParamA(g_hinst, pTemplate, NULL, focusDlgWinProc, 0);
1053         ok(hDlg != 0, "Failed to create test dialog.\n");
1054         edit = GetDlgItem(hDlg, 200);
1055
1056         ok(GetFocus() == edit, "Focus not set to edit, focus=%p, dialog=%p, edit=%p\n",
1057                 GetFocus(), hDlg, edit);
1058         SendMessageA(edit, EM_GETSEL, (WPARAM)&selectionStart, (LPARAM)&selectionEnd);
1059         ok(selectionStart == 0 && selectionEnd == 11,
1060                 "Text selection after WM_SETFOCUS is [%i, %i) expected [0, 11)\n",
1061                 selectionStart, selectionEnd);
1062
1063         DestroyWindow(hDlg);
1064     }
1065 }
1066
1067 static void test_GetDlgItemText(void)
1068 {
1069     char string[64];
1070     BOOL ret;
1071
1072     strcpy(string, "Overwrite Me");
1073     ret = GetDlgItemTextA(NULL, 0, string, sizeof(string)/sizeof(string[0]));
1074     ok(!ret, "GetDlgItemText(NULL) shouldn't have succeeded\n");
1075
1076     ok(string[0] == '\0' || broken(!strcmp(string, "Overwrite Me")),
1077        "string retrieved using GetDlgItemText should have been NULL terminated\n");
1078 }
1079
1080 static void test_GetDlgItem(void)
1081 {
1082     HWND hwnd, child1, child2, hwnd2;
1083     BOOL ret;
1084
1085     hwnd = CreateWindowA("button", "parent", WS_VISIBLE, 0, 0, 100, 100, NULL, 0, g_hinst, NULL);
1086     ok(hwnd != NULL, "failed to created window\n");
1087
1088     /* created with the same ID */
1089     child1 = CreateWindowA("button", "child1", WS_VISIBLE|WS_CHILD, 0, 0, 10, 10, hwnd, 0, g_hinst, NULL);
1090     ok(child1 != NULL, "failed to create first child\n");
1091     child2 = CreateWindowA("button", "child2", WS_VISIBLE|WS_CHILD, 0, 0, 10, 10, hwnd, 0, g_hinst, NULL);
1092     ok(child2 != NULL, "failed to create second child\n");
1093
1094     hwnd2 = GetDlgItem(hwnd, 0);
1095     ok(hwnd2 == child1, "expected first child, got %p\n", hwnd2);
1096
1097     hwnd2 = GetTopWindow(hwnd);
1098     ok(hwnd2 == child1, "expected first child to be top, got %p\n", hwnd2);
1099
1100     ret = SetWindowPos(child1, child2, 0, 0, 0, 0, SWP_NOMOVE);
1101     ok(ret, "got %d\n", ret);
1102     hwnd2 = GetTopWindow(hwnd);
1103     ok(hwnd2 == child2, "expected second child to be top, got %p\n", hwnd2);
1104
1105     /* top window from child list is picked */
1106     hwnd2 = GetDlgItem(hwnd, 0);
1107     ok(hwnd2 == child2, "expected second child, got %p\n", hwnd2);
1108
1109     /* Now test how GetDlgItem searches */
1110     DestroyWindow(child2);
1111     child2 = CreateWindowA("button", "child2", WS_VISIBLE|WS_CHILD, 0, 0, 10, 10, child1, 0, g_hinst, NULL);
1112     ok(child2 != NULL, "failed to create second child\n");
1113
1114     /* give child2 an ID */
1115     SetWindowLongA(child2, GWLP_ID, 100);
1116
1117     hwnd2 = GetDlgItem(hwnd, 100);
1118     ok(!hwnd2, "expected child to not be found, got %p\n", hwnd2);
1119
1120     /* make the ID of child2 public with a WS_EX_CONTROLPARENT parent */
1121     SetWindowLongA(child1, GWL_EXSTYLE, WS_EX_CONTROLPARENT);
1122
1123     hwnd2 = GetDlgItem(hwnd, 100);
1124     ok(!hwnd2, "expected child to not be found, got %p\n", hwnd2);
1125
1126     DestroyWindow(child1);
1127     DestroyWindow(child2);
1128     DestroyWindow(hwnd);
1129 }
1130
1131 static INT_PTR CALLBACK DestroyDlgWinProc (HWND hDlg, UINT uiMsg,
1132         WPARAM wParam, LPARAM lParam)
1133 {
1134     if (uiMsg == WM_INITDIALOG)
1135     {
1136         DestroyWindow(hDlg);
1137         return TRUE;
1138     }
1139     return FALSE;
1140 }
1141
1142 static INT_PTR CALLBACK DestroyOnCloseDlgWinProc (HWND hDlg, UINT uiMsg,
1143         WPARAM wParam, LPARAM lParam)
1144 {
1145     switch (uiMsg)
1146     {
1147     case WM_INITDIALOG:
1148         PostMessageA(hDlg, WM_CLOSE, 0, 0);
1149         return TRUE;
1150     case WM_CLOSE:
1151         DestroyWindow(hDlg);
1152         return TRUE;
1153     case WM_DESTROY:
1154         PostQuitMessage(0);
1155         return TRUE;
1156     }
1157     return FALSE;
1158 }
1159
1160 static INT_PTR CALLBACK TestInitDialogHandleProc (HWND hDlg, UINT uiMsg,
1161         WPARAM wParam, LPARAM lParam)
1162 {
1163     if (uiMsg == WM_INITDIALOG)
1164     {
1165         HWND expected = GetNextDlgTabItem(hDlg, NULL, FALSE);
1166         ok(expected == (HWND)wParam,
1167            "Expected wParam to be the handle to the first tabstop control (%p), got %p\n",
1168            expected, (HWND)wParam);
1169
1170         EndDialog(hDlg, LOWORD(SendMessageA(hDlg, DM_GETDEFID, 0, 0)));
1171         return TRUE;
1172     }
1173     return FALSE;
1174 }
1175
1176 static INT_PTR CALLBACK TestDefButtonDlgProc (HWND hDlg, UINT uiMsg,
1177                                               WPARAM wParam, LPARAM lParam)
1178 {
1179     switch (uiMsg)
1180     {
1181     case WM_INITDIALOG:
1182         EndDialog(hDlg, LOWORD(SendMessageA(hDlg, DM_GETDEFID, 0, 0)));
1183         return TRUE;
1184     }
1185     return FALSE;
1186 }
1187
1188 static INT_PTR CALLBACK TestReturnKeyDlgProc (HWND hDlg, UINT uiMsg,
1189         WPARAM wParam, LPARAM lParam)
1190 {
1191     static int received_idok;
1192
1193     switch (uiMsg)
1194     {
1195     case WM_INITDIALOG:
1196     {
1197         MSG msg = {hDlg, WM_KEYDOWN, VK_RETURN, 0x011c0001};
1198
1199         received_idok = -1;
1200         IsDialogMessageA(hDlg, &msg);
1201         ok(received_idok == 0xdead, "WM_COMMAND/0xdead not received\n");
1202
1203         received_idok = -2;
1204         IsDialogMessageA(hDlg, &msg);
1205         ok(received_idok == IDOK, "WM_COMMAND/IDOK not received\n");
1206
1207         EndDialog(hDlg, 0);
1208         return TRUE;
1209     }
1210
1211     case DM_GETDEFID:
1212         if (received_idok == -1)
1213         {
1214             HWND hwnd = GetDlgItem(hDlg, 0xdead);
1215             ok(!hwnd, "dialog item with ID 0xdead should not exist\n");
1216             SetWindowLongA(hDlg, DWLP_MSGRESULT, MAKELRESULT(0xdead, DC_HASDEFID));
1217             return TRUE;
1218         }
1219         return FALSE;
1220
1221     case WM_COMMAND:
1222         received_idok = wParam;
1223         return TRUE;
1224     }
1225     return FALSE;
1226 }
1227
1228 static INT_PTR CALLBACK TestControlStyleDlgProc(HWND hdlg, UINT msg,
1229                                                 WPARAM wparam, LPARAM lparam)
1230 {
1231     HWND control;
1232     DWORD style, exstyle;
1233     char buf[256];
1234
1235     switch (msg)
1236     {
1237     case WM_INITDIALOG:
1238         control = GetDlgItem(hdlg, 7);
1239         ok(control != 0, "dialog control with id 7 not found\n");
1240         style = GetWindowLongA(control, GWL_STYLE);
1241         ok(style == (WS_CHILD|WS_VISIBLE), "expected WS_CHILD|WS_VISIBLE, got %#x\n", style);
1242         exstyle = GetWindowLongA(control, GWL_EXSTYLE);
1243         ok(exstyle == (WS_EX_NOPARENTNOTIFY|WS_EX_TRANSPARENT|WS_EX_CLIENTEDGE), "expected WS_EX_NOPARENTNOTIFY|WS_EX_TRANSPARENT|WS_EX_CLIENTEDGE, got %#x\n", exstyle);
1244         buf[0] = 0;
1245         GetWindowTextA(control, buf, sizeof(buf));
1246         ok(strcmp(buf, "bump7") == 0,  "expected bump7, got %s\n", buf);
1247
1248         control = GetDlgItem(hdlg, 8);
1249         ok(control != 0, "dialog control with id 8 not found\n");
1250         style = GetWindowLongA(control, GWL_STYLE);
1251         ok(style == (WS_CHILD|WS_VISIBLE), "expected WS_CHILD|WS_VISIBLE, got %#x\n", style);
1252         exstyle = GetWindowLongA(control, GWL_EXSTYLE);
1253         ok(exstyle == (WS_EX_NOPARENTNOTIFY|WS_EX_TRANSPARENT), "expected WS_EX_NOPARENTNOTIFY|WS_EX_TRANSPARENT, got %#x\n", exstyle);
1254         buf[0] = 0;
1255         GetWindowTextA(control, buf, sizeof(buf));
1256         ok(strcmp(buf, "bump8") == 0,  "expected bump8, got %s\n", buf);
1257
1258         EndDialog(hdlg, -7);
1259         return TRUE;
1260     }
1261     return FALSE;
1262 }
1263
1264 static const WCHAR testtextW[] = {'W','n','d','T','e','x','t',0};
1265 static const char *testtext = "WndText";
1266
1267 enum defdlgproc_text
1268 {
1269     DLGPROCTEXT_SNDMSGA = 0,
1270     DLGPROCTEXT_SNDMSGW,
1271     DLGPROCTEXT_DLGPROCA,
1272     DLGPROCTEXT_DLGPROCW,
1273     DLGPROCTEXT_SETTEXTA,
1274     DLGPROCTEXT_SETTEXTW,
1275 };
1276
1277 static const char *testmodes[] =
1278 {
1279     "SNDMSGA",
1280     "SNDMSGW",
1281     "DLGPROCA",
1282     "DLGPROCW",
1283     "SETTEXTA",
1284     "SETTEXTW",
1285 };
1286
1287 static INT_PTR CALLBACK test_aw_conversion_dlgprocA(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam)
1288 {
1289     int mode = HandleToULong(GetPropA(hdlg, "test_mode"));
1290     WCHAR *text = (WCHAR *)lparam;
1291     char *textA = (char *)lparam;
1292
1293     switch (msg)
1294     {
1295     case WM_SETTEXT:
1296     case WM_WININICHANGE:
1297     case WM_DEVMODECHANGE:
1298     case CB_DIR:
1299     case LB_DIR:
1300     case LB_ADDFILE:
1301     case EM_REPLACESEL:
1302         switch (mode)
1303         {
1304         case DLGPROCTEXT_DLGPROCA:
1305             ok(textA == testtext, "%s: %s, unexpected text %s.\n", IsWindowUnicode(hdlg) ? "U" : "A",
1306                 testmodes[mode], textA);
1307             break;
1308         case DLGPROCTEXT_DLGPROCW:
1309             ok(text == testtextW, "%s: %s, unexpected text %s.\n", IsWindowUnicode(hdlg) ? "U" : "A", testmodes[mode],
1310                 wine_dbgstr_w(text));
1311             break;
1312         case DLGPROCTEXT_SNDMSGA:
1313         case DLGPROCTEXT_SETTEXTA:
1314             if (IsWindowUnicode(hdlg))
1315             {
1316                 ok(text != testtextW && !lstrcmpW(text, testtextW),
1317                     "U: %s, unexpected text %s.\n", testmodes[mode], wine_dbgstr_w(text));
1318             }
1319             else
1320                 ok(textA == testtext, "A: %s, unexpected text %s.\n", testmodes[mode], textA);
1321             break;
1322         case DLGPROCTEXT_SNDMSGW:
1323         case DLGPROCTEXT_SETTEXTW:
1324             if (IsWindowUnicode(hdlg))
1325                 ok(text == testtextW, "U: %s, unexpected text %s.\n", testmodes[mode], wine_dbgstr_w(text));
1326             else
1327                 ok(textA != testtext && !strcmp(textA, testtext), "A: %s, unexpected text %s.\n",
1328                     testmodes[mode], textA);
1329             break;
1330         }
1331         break;
1332     };
1333
1334     return DefWindowProcW(hdlg, msg, wparam, lparam);
1335 }
1336
1337 static INT_PTR CALLBACK test_aw_conversion_dlgprocW(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam)
1338 {
1339     int mode = HandleToULong(GetPropA(hdlg, "test_mode"));
1340     WCHAR *text = (WCHAR *)lparam;
1341     char *textA = (char *)lparam;
1342
1343     switch (msg)
1344     {
1345     case WM_SETTEXT:
1346     case WM_WININICHANGE:
1347     case WM_DEVMODECHANGE:
1348     case CB_DIR:
1349     case LB_DIR:
1350     case LB_ADDFILE:
1351     case EM_REPLACESEL:
1352         switch (mode)
1353         {
1354         case DLGPROCTEXT_DLGPROCA:
1355             ok(textA == testtext, "%s: %s, unexpected text %s.\n", IsWindowUnicode(hdlg) ? "U" : "A",
1356                 testmodes[mode], textA);
1357             break;
1358         case DLGPROCTEXT_DLGPROCW:
1359             ok(text == testtextW, "%s: %s, unexpected text %s.\n", IsWindowUnicode(hdlg) ? "U" : "A", testmodes[mode],
1360                 wine_dbgstr_w(text));
1361             break;
1362         case DLGPROCTEXT_SNDMSGA:
1363         case DLGPROCTEXT_SETTEXTA:
1364             if (IsWindowUnicode(hdlg))
1365                 ok(text != testtextW && !lstrcmpW(text, testtextW),
1366                     "U: %s, unexpected text %s.\n", testmodes[mode], wine_dbgstr_w(text));
1367             else
1368                 ok(textA == testtext, "A: %s, unexpected text %s.\n", testmodes[mode], textA);
1369             break;
1370         case DLGPROCTEXT_SNDMSGW:
1371         case DLGPROCTEXT_SETTEXTW:
1372             if (IsWindowUnicode(hdlg))
1373                 ok(text == testtextW, "U: %s, unexpected text %s.\n", testmodes[mode], wine_dbgstr_w(text));
1374             else
1375                 ok(textA != testtext && !strcmp(textA, testtext), "A: %s, unexpected text %s.\n",
1376                     testmodes[mode], textA);
1377             break;
1378         }
1379         break;
1380     }
1381
1382     return DefWindowProcA(hdlg, msg, wparam, lparam);
1383 }
1384
1385 static void dlg_test_aw_message(HWND hdlg, UINT msg)
1386 {
1387     SetPropA(hdlg, "test_mode", ULongToHandle(DLGPROCTEXT_SNDMSGA));
1388     SendMessageA(hdlg, msg, 0, (LPARAM)testtext);
1389
1390     SetPropA(hdlg, "test_mode", ULongToHandle(DLGPROCTEXT_SNDMSGW));
1391     SendMessageW(hdlg, msg, 0, (LPARAM)testtextW);
1392
1393     SetPropA(hdlg, "test_mode", ULongToHandle(DLGPROCTEXT_DLGPROCA));
1394     DefDlgProcA(hdlg, msg, 0, (LPARAM)testtext);
1395
1396     SetPropA(hdlg, "test_mode", ULongToHandle(DLGPROCTEXT_DLGPROCW));
1397     DefDlgProcW(hdlg, msg, 0, (LPARAM)testtextW);
1398 }
1399
1400 static INT_PTR CALLBACK test_aw_conversion_dlgproc(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam)
1401 {
1402     ULONG_PTR dlgproc, originalproc;
1403     WCHAR buffW[64];
1404     char buff[64];
1405     BOOL ret;
1406     INT len;
1407
1408     switch (msg)
1409     {
1410     case WM_INITDIALOG:
1411         ok(IsWindowUnicode(hdlg), "Expected unicode window.\n");
1412
1413         dlg_test_aw_message(hdlg, WM_WININICHANGE);
1414         dlg_test_aw_message(hdlg, WM_DEVMODECHANGE);
1415         dlg_test_aw_message(hdlg, CB_DIR);
1416         dlg_test_aw_message(hdlg, LB_DIR);
1417         dlg_test_aw_message(hdlg, LB_ADDFILE);
1418         dlg_test_aw_message(hdlg, EM_REPLACESEL);
1419         dlg_test_aw_message(hdlg, WM_SETTEXT);
1420
1421         /* WM_SETTEXT/WM_GETTEXT */
1422         originalproc = GetWindowLongPtrW(hdlg, DWLP_DLGPROC);
1423         ok(originalproc == (ULONG_PTR)test_aw_conversion_dlgproc, "Unexpected dlg proc %#lx.\n", originalproc);
1424
1425         dlgproc = GetWindowLongPtrA(hdlg, DWLP_DLGPROC);
1426         ok(dlgproc != (ULONG_PTR)test_aw_conversion_dlgproc, "Unexpected dlg proc %#lx.\n", dlgproc);
1427
1428         dlgproc = SetWindowLongPtrA(hdlg, DWLP_DLGPROC, (UINT_PTR)test_aw_conversion_dlgprocA);
1429         ok(IsWindowUnicode(hdlg), "Expected unicode window.\n");
1430
1431         dlgproc = GetWindowLongPtrW(hdlg, DWLP_DLGPROC);
1432         ok(dlgproc != (ULONG_PTR)test_aw_conversion_dlgprocA, "Unexpected dlg proc %#lx.\n", dlgproc);
1433
1434         dlgproc = GetWindowLongPtrA(hdlg, DWLP_DLGPROC);
1435         ok(dlgproc == (ULONG_PTR)test_aw_conversion_dlgprocA, "Unexpected dlg proc %#lx.\n", dlgproc);
1436
1437         SetPropA(hdlg, "test_mode", ULongToHandle(DLGPROCTEXT_SETTEXTA));
1438         ret = SetWindowTextA(hdlg, testtext);
1439     todo_wine
1440         ok(ret, "Failed to set window text.\n");
1441
1442         SetPropA(hdlg, "test_mode", ULongToHandle(DLGPROCTEXT_SETTEXTW));
1443         ret = SetWindowTextW(hdlg, testtextW);
1444     todo_wine
1445         ok(ret, "Failed to set window text.\n");
1446
1447         memset(buff, 'A', sizeof(buff));
1448         len = GetWindowTextA(hdlg, buff, sizeof(buff));
1449         ok(buff[0] == 0 && buff[1] == 'A' && len == 0, "Unexpected window text %#x, %#x, len %d\n",
1450            (BYTE)buff[0], (BYTE)buff[1], len);
1451
1452         memset(buffW, 0xff, sizeof(buffW));
1453         len = GetWindowTextW(hdlg, buffW, 64);
1454         ok(!lstrcmpW(buffW, testtextW) && len == 0, "Unexpected window text %s, len %d\n", wine_dbgstr_w(buffW), len);
1455
1456         dlg_test_aw_message(hdlg, WM_WININICHANGE);
1457         dlg_test_aw_message(hdlg, WM_DEVMODECHANGE);
1458         dlg_test_aw_message(hdlg, CB_DIR);
1459         dlg_test_aw_message(hdlg, LB_DIR);
1460         dlg_test_aw_message(hdlg, LB_ADDFILE);
1461         dlg_test_aw_message(hdlg, EM_REPLACESEL);
1462         dlg_test_aw_message(hdlg, WM_SETTEXT);
1463
1464         dlgproc = SetWindowLongPtrW(hdlg, DWLP_DLGPROC, (UINT_PTR)test_aw_conversion_dlgprocW);
1465         ok(IsWindowUnicode(hdlg), "Expected unicode window.\n");
1466
1467         dlgproc = GetWindowLongPtrW(hdlg, DWLP_DLGPROC);
1468         ok(dlgproc == (ULONG_PTR)test_aw_conversion_dlgprocW, "Unexpected dlg proc %#lx.\n", dlgproc);
1469
1470         dlgproc = GetWindowLongPtrA(hdlg, DWLP_DLGPROC);
1471         ok(dlgproc != (ULONG_PTR)test_aw_conversion_dlgprocW, "Unexpected dlg proc %#lx.\n", dlgproc);
1472
1473         SetPropA(hdlg, "test_mode", ULongToHandle(DLGPROCTEXT_SETTEXTA));
1474         ret = SetWindowTextA(hdlg, testtext);
1475     todo_wine
1476         ok(ret, "Failed to set window text.\n");
1477
1478         SetPropA(hdlg, "test_mode", ULongToHandle(DLGPROCTEXT_SETTEXTW));
1479         ret = SetWindowTextW(hdlg, testtextW);
1480     todo_wine
1481         ok(ret, "Failed to set window text.\n");
1482
1483         memset(buff, 'A', sizeof(buff));
1484         len = GetWindowTextA(hdlg, buff, sizeof(buff));
1485         ok(buff[0] == 0 && buff[1] == 'A' && len == 0, "Unexpected window text %#x, %#x, len %d\n",
1486            (BYTE)buff[0], (BYTE)buff[1], len);
1487
1488         memset(buffW, 0xff, sizeof(buffW));
1489         len = GetWindowTextW(hdlg, buffW, sizeof(buffW)/sizeof(buffW[0]));
1490         ok(buffW[0] == 'W' && buffW[1] == 0xffff && len == 0, "Unexpected window text %#x, %#x, len %d\n",
1491             buffW[0], buffW[1], len);
1492
1493         dlg_test_aw_message(hdlg, WM_WININICHANGE);
1494         dlg_test_aw_message(hdlg, WM_DEVMODECHANGE);
1495         dlg_test_aw_message(hdlg, CB_DIR);
1496         dlg_test_aw_message(hdlg, LB_DIR);
1497         dlg_test_aw_message(hdlg, LB_ADDFILE);
1498         dlg_test_aw_message(hdlg, EM_REPLACESEL);
1499         dlg_test_aw_message(hdlg, WM_SETTEXT);
1500
1501         SetWindowLongPtrA(hdlg, DWLP_DLGPROC, originalproc);
1502         EndDialog(hdlg, -123);
1503         return TRUE;
1504     }
1505     return FALSE;
1506 }
1507
1508 static INT_PTR CALLBACK test_aw_conversion_dlgproc2(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam)
1509 {
1510     ULONG_PTR dlgproc, originalproc;
1511     WCHAR buffW[64];
1512     char buff[64];
1513     BOOL ret;
1514     INT len;
1515
1516     switch (msg)
1517     {
1518     case WM_INITDIALOG:
1519         ok(!IsWindowUnicode(hdlg), "Unexpected unicode window.\n");
1520
1521         dlg_test_aw_message(hdlg, WM_WININICHANGE);
1522         dlg_test_aw_message(hdlg, WM_DEVMODECHANGE);
1523         dlg_test_aw_message(hdlg, CB_DIR);
1524         dlg_test_aw_message(hdlg, LB_DIR);
1525         dlg_test_aw_message(hdlg, LB_ADDFILE);
1526         dlg_test_aw_message(hdlg, EM_REPLACESEL);
1527         dlg_test_aw_message(hdlg, WM_SETTEXT);
1528
1529         originalproc = GetWindowLongPtrW(hdlg, DWLP_DLGPROC);
1530         ok(originalproc != (ULONG_PTR)test_aw_conversion_dlgproc2, "Unexpected dlg proc %#lx.\n", originalproc);
1531
1532         dlgproc = GetWindowLongPtrA(hdlg, DWLP_DLGPROC);
1533         ok(dlgproc == (ULONG_PTR)test_aw_conversion_dlgproc2, "Unexpected dlg proc %#lx.\n", dlgproc);
1534
1535         dlgproc = SetWindowLongPtrA(hdlg, DWLP_DLGPROC, (UINT_PTR)test_aw_conversion_dlgprocW);
1536         ok(!IsWindowUnicode(hdlg), "Unexpected unicode window.\n");
1537
1538         dlgproc = GetWindowLongPtrW(hdlg, DWLP_DLGPROC);
1539         ok(dlgproc != (ULONG_PTR)test_aw_conversion_dlgprocW, "Unexpected dlg proc %#lx.\n", dlgproc);
1540
1541         dlgproc = GetWindowLongPtrA(hdlg, DWLP_DLGPROC);
1542         ok(dlgproc == (ULONG_PTR)test_aw_conversion_dlgprocW, "Unexpected dlg proc %#lx.\n", dlgproc);
1543
1544         SetPropA(hdlg, "test_mode", ULongToHandle(DLGPROCTEXT_SETTEXTA));
1545         ret = SetWindowTextA(hdlg, testtext);
1546     todo_wine
1547         ok(ret, "Failed to set window text.\n");
1548
1549         SetPropA(hdlg, "test_mode", ULongToHandle(DLGPROCTEXT_SETTEXTW));
1550         ret = SetWindowTextW(hdlg, testtextW);
1551     todo_wine
1552         ok(ret, "Failed to set window text.\n");
1553
1554         memset(buff, 'A', sizeof(buff));
1555         len = GetWindowTextA(hdlg, buff, sizeof(buff));
1556         ok(!strcmp(buff, testtext) && len == 0, "Unexpected window text %s, len %d\n", buff, len);
1557
1558         memset(buffW, 0xff, sizeof(buffW));
1559         len = GetWindowTextW(hdlg, buffW, 64);
1560         ok(buffW[0] == 0 && buffW[1] == 0xffff && len == 0, "Unexpected window text %s, len %d\n",
1561             wine_dbgstr_w(buffW), len);
1562
1563         dlg_test_aw_message(hdlg, WM_WININICHANGE);
1564         dlg_test_aw_message(hdlg, WM_DEVMODECHANGE);
1565         dlg_test_aw_message(hdlg, CB_DIR);
1566         dlg_test_aw_message(hdlg, LB_DIR);
1567         dlg_test_aw_message(hdlg, LB_ADDFILE);
1568         dlg_test_aw_message(hdlg, EM_REPLACESEL);
1569         dlg_test_aw_message(hdlg, WM_SETTEXT);
1570
1571         dlgproc = SetWindowLongPtrW(hdlg, DWLP_DLGPROC, (UINT_PTR)test_aw_conversion_dlgprocA);
1572         ok(!IsWindowUnicode(hdlg), "Unexpected unicode window.\n");
1573
1574         dlgproc = GetWindowLongPtrW(hdlg, DWLP_DLGPROC);
1575         ok(dlgproc == (ULONG_PTR)test_aw_conversion_dlgprocA, "Unexpected dlg proc %#lx.\n", dlgproc);
1576
1577         dlgproc = GetWindowLongPtrA(hdlg, DWLP_DLGPROC);
1578         ok(dlgproc != (ULONG_PTR)test_aw_conversion_dlgprocA, "Unexpected dlg proc %#lx.\n", dlgproc);
1579
1580         SetPropA(hdlg, "test_mode", ULongToHandle(DLGPROCTEXT_SETTEXTA));
1581         ret = SetWindowTextA(hdlg, testtext);
1582     todo_wine
1583         ok(ret, "Failed to set window text.\n");
1584
1585         SetPropA(hdlg, "test_mode", ULongToHandle(DLGPROCTEXT_SETTEXTW));
1586         ret = SetWindowTextW(hdlg, testtextW);
1587     todo_wine
1588         ok(ret, "Failed to set window text.\n");
1589
1590         memset(buff, 'A', sizeof(buff));
1591         len = GetWindowTextA(hdlg, buff, sizeof(buff));
1592         ok(!strcmp(buff, testtext) && len == 0, "Unexpected window text %s, len %d\n", buff, len);
1593
1594         memset(buffW, 0xff, sizeof(buffW));
1595         len = GetWindowTextW(hdlg, buffW, sizeof(buffW)/sizeof(buffW[0]));
1596         ok(buffW[0] == 0 && buffW[1] == 0xffff && len == 0, "Unexpected window text %#x, %#x, len %d\n",
1597             buffW[0], buffW[1], len);
1598
1599         dlg_test_aw_message(hdlg, WM_WININICHANGE);
1600         dlg_test_aw_message(hdlg, WM_DEVMODECHANGE);
1601         dlg_test_aw_message(hdlg, CB_DIR);
1602         dlg_test_aw_message(hdlg, LB_DIR);
1603         dlg_test_aw_message(hdlg, LB_ADDFILE);
1604         dlg_test_aw_message(hdlg, EM_REPLACESEL);
1605         dlg_test_aw_message(hdlg, WM_SETTEXT);
1606
1607         SetWindowLongPtrA(hdlg, DWLP_DLGPROC, originalproc);
1608         EndDialog(hdlg, -123);
1609         return TRUE;
1610     }
1611     return FALSE;
1612 }
1613
1614 static LRESULT CALLBACK test_aw_conversion_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
1615 {
1616     WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
1617     int mode = HandleToULong(GetPropA(hwnd, "test_mode"));
1618     WCHAR *text = (WCHAR *)lparam;
1619     char *textA = (char *)lparam;
1620
1621     switch (msg)
1622     {
1623     case WM_SETTEXT:
1624     case WM_WININICHANGE:
1625     case WM_DEVMODECHANGE:
1626     case CB_DIR:
1627     case LB_DIR:
1628     case LB_ADDFILE:
1629     case EM_REPLACESEL:
1630         switch (mode)
1631         {
1632         case DLGPROCTEXT_SNDMSGA:
1633             if (IsWindowUnicode(hwnd))
1634                 ok(text != testtextW && !lstrcmpW(text, testtextW),
1635                     "U: %s, unexpected text %s.\n", testmodes[mode], wine_dbgstr_w(text));
1636             else
1637                 ok(textA == testtext, "A: %s, unexpected text %s.\n", testmodes[mode], textA);
1638             break;
1639         case DLGPROCTEXT_SNDMSGW:
1640             if (IsWindowUnicode(hwnd))
1641                 ok(text == testtextW, "U: %s, unexpected text %s.\n", testmodes[mode], wine_dbgstr_w(text));
1642             else
1643                 ok(textA != testtext && !strcmp(textA, testtext), "A: %s, unexpected text %s.\n",
1644                     testmodes[mode], textA);
1645             break;
1646         default:
1647             ok(0, "Unexpected test mode %d.\n", mode);
1648         }
1649         break;
1650     }
1651
1652     return IsWindowUnicode(hwnd) ? CallWindowProcW(oldproc, hwnd, msg, wparam, lparam) :
1653         CallWindowProcA(oldproc, hwnd, msg, wparam, lparam);
1654 }
1655
1656 static INT_PTR CALLBACK test_aw_conversion_dlgproc3(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam)
1657 {
1658     BOOL is_unicode = !!lparam;
1659     LONG_PTR oldproc;
1660
1661     switch (msg)
1662     {
1663     case WM_INITDIALOG:
1664         ok(is_unicode == IsWindowUnicode(hdlg), "Unexpected unicode window property.\n");
1665
1666         oldproc = SetWindowLongPtrA(hdlg, GWLP_WNDPROC, (LONG_PTR)test_aw_conversion_wndproc);
1667         SetWindowLongPtrA(hdlg, GWLP_USERDATA, oldproc);
1668         ok(!IsWindowUnicode(hdlg), "Unexpected unicode window.\n");
1669
1670         dlg_test_aw_message(hdlg, WM_WININICHANGE);
1671         dlg_test_aw_message(hdlg, WM_DEVMODECHANGE);
1672         dlg_test_aw_message(hdlg, CB_DIR);
1673         dlg_test_aw_message(hdlg, LB_DIR);
1674         dlg_test_aw_message(hdlg, LB_ADDFILE);
1675         dlg_test_aw_message(hdlg, EM_REPLACESEL);
1676         dlg_test_aw_message(hdlg, WM_SETTEXT);
1677
1678         SetWindowLongPtrW(hdlg, GWLP_WNDPROC, (LONG_PTR)test_aw_conversion_wndproc);
1679         ok(IsWindowUnicode(hdlg), "Expected unicode window.\n");
1680
1681         dlg_test_aw_message(hdlg, WM_WININICHANGE);
1682         dlg_test_aw_message(hdlg, WM_DEVMODECHANGE);
1683         dlg_test_aw_message(hdlg, CB_DIR);
1684         dlg_test_aw_message(hdlg, LB_DIR);
1685         dlg_test_aw_message(hdlg, LB_ADDFILE);
1686         dlg_test_aw_message(hdlg, EM_REPLACESEL);
1687         dlg_test_aw_message(hdlg, WM_SETTEXT);
1688
1689         SetWindowLongPtrA(hdlg, GWLP_WNDPROC, oldproc);
1690         EndDialog(hdlg, -123);
1691         return TRUE;
1692     }
1693     return FALSE;
1694 }
1695
1696 static void test_DialogBoxParam(void)
1697 {
1698     static const WCHAR nameW[] = {'T','E','S','T','_','E','M','P','T','Y','_','D','I','A','L','O','G',0};
1699     INT_PTR ret;
1700     HWND hwnd_invalid = (HWND)0x4444;
1701
1702     ret = DialogBoxParamA(GetModuleHandleA(NULL), "TEST_DLG_CHILD_POPUP", 0, TestControlStyleDlgProc, 0);
1703     ok(ret == -7, "expected -7, got %ld\n", ret);
1704
1705     SetLastError(0xdeadbeef);
1706     ret = DialogBoxParamA(GetModuleHandleA(NULL), "IDD_DIALOG" , hwnd_invalid, 0 , 0);
1707     ok(0 == ret || broken(ret == -1), "DialogBoxParamA returned %ld, expected 0\n", ret);
1708     ok(ERROR_INVALID_WINDOW_HANDLE == GetLastError() ||
1709        broken(GetLastError() == 0xdeadbeef),
1710        "got %d, expected ERROR_INVALID_WINDOW_HANDLE\n",GetLastError());
1711
1712     /* Test a dialog which destroys itself on WM_INITDIALOG. */
1713     SetLastError(0xdeadbeef);
1714     ret = DialogBoxParamA(GetModuleHandleA(NULL), "IDD_DIALOG", 0, DestroyDlgWinProc, 0);
1715     ok(-1 == ret, "DialogBoxParamA returned %ld, expected -1\n", ret);
1716     ok(ERROR_INVALID_WINDOW_HANDLE == GetLastError() ||
1717        GetLastError() == ERROR_SUCCESS ||
1718        broken(GetLastError() == 0xdeadbeef),
1719        "got %d, expected ERROR_INVALID_WINDOW_HANDLE\n",GetLastError());
1720
1721     /* Test a dialog which destroys itself on WM_CLOSE. */
1722     ret = DialogBoxParamA(GetModuleHandleA(NULL), "IDD_DIALOG", 0, DestroyOnCloseDlgWinProc, 0);
1723     ok(0 == ret, "DialogBoxParamA returned %ld, expected 0\n", ret);
1724
1725     SetLastError(0xdeadbeef);
1726     ret = DialogBoxParamA(GetModuleHandleA(NULL), "RESOURCE_INVALID" , 0, 0, 0);
1727     ok(-1 == ret, "DialogBoxParamA returned %ld, expected -1\n", ret);
1728     ok(ERROR_RESOURCE_NAME_NOT_FOUND == GetLastError() ||
1729        broken(GetLastError() == 0xdeadbeef),
1730        "got %d, expected ERROR_RESOURCE_NAME_NOT_FOUND\n",GetLastError());
1731
1732     SetLastError(0xdeadbeef);
1733     ret = DialogBoxParamA(GetModuleHandleA(NULL), "TEST_DIALOG_INVALID_CLASS", 0, DestroyDlgWinProc, 0);
1734     ok(ret == -1, "DialogBoxParamA returned %ld, expected -1\n", ret);
1735     ok(GetLastError() == 0, "got %d\n", GetLastError());
1736
1737     SetLastError(0xdeadbeef);
1738     ret = DefDlgProcA(0, WM_ERASEBKGND, 0, 0);
1739     ok(ret == 0, "DefDlgProcA returned %ld, expected 0\n", ret);
1740     ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE ||
1741        broken(GetLastError() == 0xdeadbeef),
1742        "got %d, expected ERROR_INVALID_WINDOW_HANDLE\n", GetLastError());
1743
1744     ret = DialogBoxParamA(GetModuleHandleA(NULL), "TEST_EMPTY_DIALOG", 0, TestInitDialogHandleProc, 0);
1745     ok(ret == IDOK, "Expected IDOK\n");
1746
1747     ret = DialogBoxParamA(GetModuleHandleA(NULL), "TEST_EMPTY_DIALOG", 0, TestDefButtonDlgProc, 0);
1748     ok(ret == IDOK, "Expected IDOK\n");
1749
1750     ret = DialogBoxParamA(GetModuleHandleA(NULL), "TEST_EMPTY_DIALOG", 0, TestReturnKeyDlgProc, 0);
1751     ok(ret == 0, "Unexpected ret value %ld.\n", ret);
1752
1753     /* WM_SETTEXT handling in case of A/W dialog procedures vs A/W dialog window.  */
1754     ret = DialogBoxParamW(GetModuleHandleA(NULL), nameW, 0, test_aw_conversion_dlgproc, 0);
1755     ok(ret == -123, "Unexpected ret value %ld.\n", ret);
1756
1757     ret = DialogBoxParamA(GetModuleHandleA(NULL), "TEST_EMPTY_DIALOG", 0, test_aw_conversion_dlgproc2, 0);
1758     ok(ret == -123, "Unexpected ret value %ld.\n", ret);
1759
1760     ret = DialogBoxParamW(GetModuleHandleA(NULL), nameW, 0, test_aw_conversion_dlgproc3, 1);
1761     ok(ret == -123, "Unexpected ret value %ld.\n", ret);
1762
1763     ret = DialogBoxParamA(GetModuleHandleA(NULL), "TEST_EMPTY_DIALOG", 0, test_aw_conversion_dlgproc3, 0);
1764     ok(ret == -123, "Unexpected ret value %ld.\n", ret);
1765 }
1766
1767 static void test_DisabledDialogTest(void)
1768 {
1769     g_terminated = FALSE;
1770     DialogBoxParamA(g_hinst, "IDD_DIALOG", NULL, disabled_test_proc, 0);
1771     ok(FALSE == g_terminated, "dialog with disabled ok button has been terminated\n");
1772 }
1773
1774 static INT_PTR CALLBACK messageBoxFontDlgWinProc (HWND hDlg, UINT uiMsg, WPARAM wParam,
1775         LPARAM lParam)
1776 {
1777     if (uiMsg == WM_INITDIALOG) {
1778         SetFocus(hDlg);
1779         return 1;
1780     }
1781
1782     return 0;
1783 }
1784
1785 static void test_MessageBoxFontTest(void)
1786 {
1787     /* This dialog template defines a dialog template which got 0x7fff as its
1788      * font size and omits the other font members. On WinNT, passing such a
1789      * dialog template to CreateDialogIndirectParamW will result in a dialog
1790      * being created which uses the message box font. We test that here.
1791      */
1792
1793     static unsigned char dlgTemplate[] =
1794     {
1795         /* Dialog header */
1796         0x01,0x00,              /* Version */
1797         0xff,0xff,              /* Extended template marker */
1798         0x00,0x00,0x00,0x00,    /* Context Help ID */
1799         0x00,0x00,0x00,0x00,    /* Extended style */
1800         0xc0,0x00,0xc8,0x80,    /* Style (WS_SYSMENU|WS_CAPTION|WS_POPUP|DS_SETFONT|DS_MODALFRAME) */
1801         0x01,0x00,              /* Control count */
1802         0x00,0x00,              /* X */
1803         0x00,0x00,              /* Y */
1804         0x80,0x00,              /* Width */
1805         0x80,0x00,              /* Height */
1806         0x00,0x00,              /* Menu name */
1807         0x00,0x00,              /* Class name */
1808         'T',0x00,'e',0x00,      /* Caption (unicode) */
1809         's',0x00,'t',0x00,
1810         0x00,0x00,
1811         0xff,0x7f,              /* Font height (0x7fff = message box font) */
1812
1813         /* Control #1 */
1814         0x00,0x00,              /* Align to DWORD (header is 42 bytes) */
1815         0x00,0x00,0x00,0x00,    /* Context Help ID */
1816         0x00,0x00,0x00,0x00,    /* Extended style */
1817         0x00,0x00,0x00,0x50,    /* Style (WS_CHILD|WS_VISIBLE) */
1818         0x00,0x00,              /* X */
1819         0x00,0x00,              /* Y */
1820         0x80,0x00,              /* Width */
1821         0x80,0x00,              /* Height */
1822         0x00,0x01,0x00,0x00,    /* Control ID (256) */
1823         0xff,0xff,0x82,0x00,    /* Class (Static) */
1824         'W',0x00,'I',0x00,      /* Caption (unicode) */
1825         'N',0x00,'E',0x00,
1826         ' ',0x00,'d',0x00,
1827         'i',0x00,'a',0x00,
1828         'l',0x00,'o',0x00,
1829         'g',0x00,' ',0x00,
1830         't',0x00,'e',0x00,
1831         's',0x00,'t',0x00,
1832         '.',0x00,0x00,0x00,
1833         0x00,0x00,              /* Size of extended data */
1834
1835         0x00,0x00               /* Align to DWORD */
1836     };
1837
1838     HWND hDlg;
1839     HFONT hFont;
1840     LOGFONTW lfStaticFont;
1841     NONCLIENTMETRICSW ncMetrics;
1842
1843     /* Check if the dialog can be created from the template. On Win9x, this should fail
1844      * because we are calling the W function which is not implemented, but that's what
1845      * we want, because passing such a template to CreateDialogIndirectParamA would crash
1846      * anyway.
1847      */
1848     hDlg = CreateDialogIndirectParamW(g_hinst, (LPCDLGTEMPLATEW)dlgTemplate, NULL, messageBoxFontDlgWinProc, 0);
1849     if (!hDlg)
1850     {
1851         win_skip("dialog wasn't created\n");
1852         return;
1853     }
1854
1855     hFont = (HFONT) SendDlgItemMessageW(hDlg, 256, WM_GETFONT, 0, 0);
1856     if (!hFont)
1857     {
1858         skip("dialog uses system font\n");
1859         DestroyWindow(hDlg);
1860         return;
1861     }
1862     GetObjectW(hFont, sizeof(LOGFONTW), &lfStaticFont);
1863
1864     ncMetrics.cbSize = FIELD_OFFSET(NONCLIENTMETRICSW, iPaddedBorderWidth);
1865     SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, 0, &ncMetrics, 0);
1866     ok( !memcmp(&lfStaticFont, &ncMetrics.lfMessageFont, FIELD_OFFSET(LOGFONTW, lfFaceName)) &&
1867         !lstrcmpW(lfStaticFont.lfFaceName, ncMetrics.lfMessageFont.lfFaceName),
1868         "dialog doesn't use message box font\n");
1869     DestroyWindow(hDlg);
1870 }
1871
1872 static void test_SaveRestoreFocus(void)
1873 {
1874     HWND hDlg;
1875     HRSRC hResource;
1876     HANDLE hTemplate;
1877     DLGTEMPLATE* pTemplate;
1878     LONG_PTR foundId;
1879     HWND foundHwnd;
1880
1881     /* create the dialog */
1882     hResource = FindResourceA(g_hinst, "MULTI_EDIT_DIALOG", (LPCSTR)RT_DIALOG);
1883     hTemplate = LoadResource(g_hinst, hResource);
1884     pTemplate = LockResource(hTemplate);
1885
1886     hDlg = CreateDialogIndirectParamA(g_hinst, pTemplate, NULL, messageBoxFontDlgWinProc, 0);
1887     ok (hDlg != 0, "Failed to create test dialog.\n");
1888
1889     foundId = GetWindowLongPtrA(GetFocus(), GWLP_ID);
1890     ok (foundId == 1000, "First edit box should have gained focus on dialog creation. Expected: %d, Found: %ld\n", 1000, foundId);
1891
1892     SetFocus(GetNextDlgTabItem(hDlg, GetFocus(), FALSE));
1893     SendMessageA(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_ACTIVE, 0), 0);
1894     foundId = GetWindowLongPtrA(GetFocus(), GWLP_ID);
1895     ok (foundId == 1001, "First edit box should have regained focus after dialog reactivation. Expected: %d, Found: %ld\n", 1001, foundId);
1896     SetFocus(GetNextDlgTabItem(hDlg, NULL, FALSE));
1897
1898     /* de- then reactivate the dialog */
1899     SendMessageA(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_INACTIVE, 0), 0);
1900     SendMessageA(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_ACTIVE, 0), 0);
1901
1902     foundId = GetWindowLongPtrA(GetFocus(), GWLP_ID);
1903     ok (foundId == 1000, "First edit box should have regained focus after dialog reactivation. Expected: %d, Found: %ld\n", 1000, foundId);
1904
1905     /* select the next tabbable item */
1906     SetFocus(GetNextDlgTabItem(hDlg, GetFocus(), FALSE));
1907
1908     foundId = GetWindowLongPtrA(GetFocus(), GWLP_ID);
1909     ok (foundId == 1001, "Second edit box should have gained focus. Expected: %d, Found: %ld\n", 1001, foundId);
1910
1911     /* de- then reactivate the dialog */
1912     SendMessageA(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_INACTIVE, 0), 0);
1913     SendMessageA(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_ACTIVE, 0), 0);
1914
1915     foundId = GetWindowLongPtrA(GetFocus(), GWLP_ID);
1916     ok (foundId == 1001, "Second edit box should have gained focus after dialog reactivation. Expected: %d, Found: %ld\n", 1001, foundId);
1917
1918     /* set focus to the dialog */
1919     SetFocus(hDlg);
1920
1921     foundId = GetWindowLongPtrA(GetFocus(), GWLP_ID);
1922     ok (foundId == 1000, "First edit box should have gained focus on dialog focus. Expected: %d, Found: %ld\n", 1000, foundId);
1923
1924     /* select second tabbable item */
1925     SetFocus(GetNextDlgTabItem(hDlg, GetNextDlgTabItem(hDlg, NULL, FALSE), FALSE));
1926
1927     foundId = GetWindowLongPtrA(GetFocus(), GWLP_ID);
1928     ok (foundId == 1001, "Second edit box should have gained focus. Expected: %d, Found: %ld\n", 1001, foundId);
1929
1930     /* send WM_ACTIVATE message to already active dialog */
1931     SendMessageA(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_ACTIVE, 0), 0);
1932
1933     foundId = GetWindowLongPtrA(GetFocus(), GWLP_ID);
1934     ok (foundId == 1001, "Second edit box should have gained focus. Expected: %d, Found: %ld\n", 1001, foundId);
1935
1936     /* disable the 2nd box */
1937     EnableWindow(GetFocus(), FALSE);
1938
1939     foundHwnd = GetFocus();
1940     ok (foundHwnd == NULL, "Second edit box should have lost focus after being disabled. Expected: %p, Found: %p\n", NULL, foundHwnd);
1941
1942     /* de- then reactivate the dialog */
1943     SendMessageA(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_INACTIVE, 0), 0);
1944     SendMessageA(hDlg, WM_ACTIVATE, MAKEWPARAM(WA_ACTIVE, 0), 0);
1945
1946     foundHwnd = GetFocus();
1947     ok (foundHwnd == NULL, "No controls should have gained focus after dialog reactivation. Expected: %p, Found: %p\n", NULL, foundHwnd);
1948
1949     /* clean up */
1950     DestroyWindow(hDlg);
1951 }
1952
1953 static INT_PTR CALLBACK timer_message_dlg_proc(HWND wnd, UINT msg, WPARAM wparam, LPARAM lparam)
1954 {
1955     static int count;
1956     BOOL visible;
1957
1958     switch (msg)
1959     {
1960         case WM_INITDIALOG:
1961             visible = GetWindowLongA(wnd, GWL_STYLE) & WS_VISIBLE;
1962             ok(!visible, "Dialog should not be visible.\n");
1963             SetTimer(wnd, 1, 100, NULL);
1964             Sleep(200);
1965             return FALSE;
1966
1967         case WM_COMMAND:
1968             if (LOWORD(wparam) != IDCANCEL) return FALSE;
1969             EndDialog(wnd, LOWORD(wparam));
1970             return TRUE;
1971
1972         case WM_TIMER:
1973             if (wparam != 1) return FALSE;
1974             visible = GetWindowLongA(wnd, GWL_STYLE) & WS_VISIBLE;
1975             if (!count++)
1976             {
1977                 ok(!visible, "Dialog should not be visible.\n");
1978                 PostMessageA(wnd, WM_USER, 0, 0);
1979             }
1980             else
1981             {
1982                 ok(visible, "Dialog should be visible.\n");
1983                 PostMessageA(wnd, WM_COMMAND, IDCANCEL, 0);
1984             }
1985             return TRUE;
1986
1987         case WM_USER:
1988             visible = GetWindowLongA(wnd, GWL_STYLE) & WS_VISIBLE;
1989             ok(visible, "Dialog should be visible.\n");
1990             return TRUE;
1991
1992         default:
1993             return FALSE;
1994     }
1995 }
1996
1997 static void test_timer_message(void)
1998 {
1999     DialogBoxA(g_hinst, "RADIO_TEST_DIALOG", NULL, timer_message_dlg_proc);
2000 }
2001
2002 static LRESULT CALLBACK msgbox_hook_proc(INT code, WPARAM wParam, LPARAM lParam)
2003 {
2004     if (code == HCBT_ACTIVATE)
2005     {
2006         HWND msgbox = (HWND)wParam, msghwnd;
2007         char text[64];
2008
2009         if (msgbox)
2010         {
2011             text[0] = 0;
2012             GetWindowTextA(msgbox, text, sizeof(text));
2013             ok(!strcmp(text, "MSGBOX caption"), "Unexpected window text \"%s\"\n", text);
2014
2015             msghwnd = GetDlgItem(msgbox, 0xffff);
2016             ok(msghwnd != NULL, "Expected static control\n");
2017
2018             text[0] = 0;
2019             GetWindowTextA(msghwnd, text, sizeof(text));
2020             ok(!strcmp(text, "Text"), "Unexpected window text \"%s\"\n", text);
2021
2022             SendDlgItemMessageA(msgbox, IDCANCEL, WM_LBUTTONDOWN, 0, 0);
2023             SendDlgItemMessageA(msgbox, IDCANCEL, WM_LBUTTONUP, 0, 0);
2024         }
2025     }
2026
2027     return CallNextHookEx(NULL, code, wParam, lParam);
2028 }
2029
2030 struct create_window_params
2031 {
2032     BOOL owner;
2033     char caption[64];
2034     DWORD style;
2035 };
2036
2037 static DWORD WINAPI create_window_thread(void *param)
2038 {
2039     struct create_window_params *p = param;
2040     HWND owner = 0;
2041
2042     if (p->owner)
2043     {
2044         owner = CreateWindowExA(0, "Static", NULL, WS_POPUP, 10, 10, 10, 10, 0, 0, 0, NULL);
2045         ok(owner != 0, "failed to create owner window\n");
2046     }
2047
2048     MessageBoxA(owner, NULL, p->caption, p->style);
2049
2050     if (owner) DestroyWindow(owner);
2051
2052     return 0;
2053 }
2054
2055 static HWND wait_for_window(const char *caption)
2056 {
2057     HWND hwnd;
2058     DWORD timeout = 0;
2059
2060     for (;;)
2061     {
2062         hwnd = FindWindowA(NULL, caption);
2063         if (hwnd) break;
2064
2065         Sleep(50);
2066         timeout += 50;
2067         if (timeout > 3000)
2068         {
2069             ok(0, "failed to wait for a window %s\n", caption);
2070             break;
2071         }
2072     }
2073
2074     Sleep(50);
2075     return hwnd;
2076 }
2077
2078 static void test_MessageBox(void)
2079 {
2080     static const struct
2081     {
2082         DWORD mb_style;
2083         DWORD ex_style;
2084     } test[] =
2085     {
2086         { MB_OK, 0 },
2087         { MB_OK | MB_TASKMODAL, 0 },
2088         { MB_OK | MB_SYSTEMMODAL, WS_EX_TOPMOST },
2089     };
2090     struct create_window_params params;
2091     HANDLE thread;
2092     DWORD tid, i;
2093     HHOOK hook;
2094     int ret;
2095
2096     hook = SetWindowsHookExA(WH_CBT, msgbox_hook_proc, NULL, GetCurrentThreadId());
2097
2098     ret = MessageBoxA(NULL, "Text", "MSGBOX caption", MB_OKCANCEL);
2099     ok(ret == IDCANCEL, "got %d\n", ret);
2100
2101     UnhookWindowsHookEx(hook);
2102
2103     sprintf(params.caption, "pid %08x, tid %08x, time %08x",
2104             GetCurrentProcessId(), GetCurrentThreadId(), GetCurrentTime());
2105
2106     params.owner = FALSE;
2107
2108     for (i = 0; i < sizeof(test)/sizeof(test[0]); i++)
2109     {
2110         HWND hwnd;
2111         DWORD ex_style;
2112
2113         params.style = test[i].mb_style;
2114
2115         thread = CreateThread(NULL, 0, create_window_thread, &params, 0, &tid);
2116
2117         hwnd = wait_for_window(params.caption);
2118         ex_style = GetWindowLongA(hwnd, GWL_EXSTYLE);
2119         ok((ex_style & WS_EX_TOPMOST) == test[i].ex_style, "%d: got window ex_style %#x\n", i, ex_style);
2120
2121         PostMessageA(hwnd, WM_COMMAND, IDCANCEL, 0);
2122
2123         ok(WaitForSingleObject(thread, 5000) != WAIT_TIMEOUT, "thread failed to terminate\n");
2124         CloseHandle(thread);
2125     }
2126
2127     params.owner = TRUE;
2128
2129     for (i = 0; i < sizeof(test)/sizeof(test[0]); i++)
2130     {
2131         HWND hwnd;
2132         DWORD ex_style;
2133
2134         params.style = test[i].mb_style;
2135
2136         thread = CreateThread(NULL, 0, create_window_thread, &params, 0, &tid);
2137
2138         hwnd = wait_for_window(params.caption);
2139         ex_style = GetWindowLongA(hwnd, GWL_EXSTYLE);
2140         ok((ex_style & WS_EX_TOPMOST) == test[i].ex_style, "%d: got window ex_style %#x\n", i, ex_style);
2141
2142         PostMessageA(hwnd, WM_COMMAND, IDCANCEL, 0);
2143
2144         ok(WaitForSingleObject(thread, 5000) != WAIT_TIMEOUT, "thread failed to terminate\n");
2145         CloseHandle(thread);
2146     }
2147 }
2148
2149 static INT_PTR CALLBACK custom_test_dialog_proc(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam)
2150 {
2151     if (msg == WM_INITDIALOG)
2152         EndDialog(hdlg, 0);
2153
2154     return FALSE;
2155 }
2156
2157 static void test_dialog_custom_data(void)
2158 {
2159     DialogBoxA(g_hinst, "CUSTOM_TEST_DIALOG", NULL, custom_test_dialog_proc);
2160 }
2161
2162 START_TEST(dialog)
2163 {
2164     g_hinst = GetModuleHandleA (0);
2165
2166     if (!RegisterWindowClasses()) assert(0);
2167
2168     test_dialog_custom_data();
2169     test_GetNextDlgItem();
2170     test_IsDialogMessage();
2171     test_WM_NEXTDLGCTL();
2172     test_focus();
2173     test_GetDlgItem();
2174     test_GetDlgItemText();
2175     test_DialogBoxParam();
2176     test_DisabledDialogTest();
2177     test_MessageBoxFontTest();
2178     test_SaveRestoreFocus();
2179     test_timer_message();
2180     test_MessageBox();
2181 }