519 lines
19 KiB
C
519 lines
19 KiB
C
![]() |
/* Unit test suite for the dialog functions.
|
||
|
*
|
||
|
* Copyright 2004 Bill Medland
|
||
|
*
|
||
|
* This library is free software; you can redistribute it and/or
|
||
|
* modify it under the terms of the GNU Lesser General Public
|
||
|
* License as published by the Free Software Foundation; either
|
||
|
* version 2.1 of the License, or (at your option) any later version.
|
||
|
*
|
||
|
* This library is distributed in the hope that it will be useful,
|
||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
|
* Lesser General Public License for more details.
|
||
|
*
|
||
|
* You should have received a copy of the GNU Lesser General Public
|
||
|
* License along with this library; if not, write to the Free Software
|
||
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* This test suite currently works by building a quite complex hierarchy of
|
||
|
* objects in a variety of styles and then performs a limited number of tests
|
||
|
* for the previous and next dialog group or tab items.
|
||
|
*
|
||
|
* The test specifically does not test all possibilities at this time since
|
||
|
* there are several cases where the Windows behaviour is rather strange and
|
||
|
* significant work would be required to get the Wine code to duplicate the
|
||
|
* strangeness, especially since most are in situations that would not
|
||
|
* normally be met.
|
||
|
*/
|
||
|
|
||
|
#include <assert.h>
|
||
|
#include <stdio.h>
|
||
|
#include <stdarg.h>
|
||
|
|
||
|
#include "wine/test.h"
|
||
|
#include "windef.h"
|
||
|
#include "winbase.h"
|
||
|
#include "winuser.h"
|
||
|
|
||
|
#define MAXHWNDS 1024
|
||
|
static HWND hwnd [MAXHWNDS];
|
||
|
static int numwnds=1; /* 0 is reserved for null */
|
||
|
|
||
|
/* Global handles */
|
||
|
static HINSTANCE g_hinst; /* This application's HINSTANCE */
|
||
|
static HWND g_hwndMain, g_hwndButton1, g_hwndButton2, g_hwndButtonCancel;
|
||
|
static int g_terminated;
|
||
|
|
||
|
typedef struct {
|
||
|
int id;
|
||
|
int parent;
|
||
|
DWORD style;
|
||
|
DWORD exstyle;
|
||
|
} h_entry;
|
||
|
|
||
|
static const h_entry hierarchy [] = {
|
||
|
/* 0 is reserved for the null window */
|
||
|
{ 1, 0, WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS, WS_EX_WINDOWEDGE},
|
||
|
{ 20, 1, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
|
||
|
{ 2, 1, WS_CHILD | WS_VISIBLE, WS_EX_CONTROLPARENT},
|
||
|
{ 60, 2, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
|
||
|
/* What happens with groups when the parent is disabled */
|
||
|
{ 8, 2, WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_TABSTOP, WS_EX_CONTROLPARENT},
|
||
|
{ 85, 8, WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_GROUP, 0},
|
||
|
{ 9, 8, WS_CHILD, WS_EX_CONTROLPARENT},
|
||
|
{ 86, 9, WS_CHILD | WS_VISIBLE, 0},
|
||
|
{ 87, 9, WS_CHILD | WS_VISIBLE, 0},
|
||
|
{ 31, 8, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
|
||
|
{ 10, 2, WS_CHILD | WS_VISIBLE, WS_EX_CONTROLPARENT},
|
||
|
{ 88, 10, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
|
||
|
{ 11, 10, WS_CHILD, WS_EX_CONTROLPARENT},
|
||
|
{ 89, 11, WS_CHILD | WS_VISIBLE, 0},
|
||
|
{ 32, 11, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
|
||
|
{ 90, 11, WS_CHILD | WS_VISIBLE, 0},
|
||
|
{ 33, 10, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
|
||
|
{ 21, 2, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
|
||
|
{ 61, 2, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
|
||
|
{ 3, 1, WS_CHILD | WS_VISIBLE | DS_CONTROL, 0},
|
||
|
{ 22, 3, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
|
||
|
{ 62, 3, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
|
||
|
{ 7, 3, WS_CHILD | WS_VISIBLE, WS_EX_CONTROLPARENT},
|
||
|
{ 4, 7, WS_CHILD | WS_VISIBLE | DS_CONTROL, 0},
|
||
|
{ 83, 4, WS_CHILD | WS_VISIBLE, 0},
|
||
|
{ 5, 4, WS_CHILD | WS_VISIBLE | DS_CONTROL, 0},
|
||
|
/* A couple of controls around the main dialog */
|
||
|
{ 29, 5, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
|
||
|
{ 81, 5, WS_CHILD | WS_VISIBLE, 0},
|
||
|
/* The main dialog with lots of controls */
|
||
|
{ 6, 5, WS_CHILD | WS_VISIBLE, WS_EX_CONTROLPARENT},
|
||
|
/* At the start of a dialog */
|
||
|
/* Disabled controls are skipped */
|
||
|
{ 63, 6, WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_TABSTOP, 0},
|
||
|
/* Invisible controls are skipped */
|
||
|
{ 64, 6, WS_CHILD | WS_TABSTOP, 0},
|
||
|
/* Invisible disabled controls are skipped */
|
||
|
{ 65, 6, WS_CHILD | WS_DISABLED | WS_TABSTOP, 0},
|
||
|
/* Non-tabstop controls are skipped for tabs but not for groups */
|
||
|
{ 66, 6, WS_CHILD | WS_VISIBLE, 0},
|
||
|
/* End of first group, with no tabstops in it */
|
||
|
{ 23, 6, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
|
||
|
/* At last a tabstop */
|
||
|
{ 67, 6, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
|
||
|
/* A group that is totally disabled or invisible */
|
||
|
{ 24, 6, WS_CHILD | WS_DISABLED | WS_GROUP, 0},
|
||
|
{ 68, 6, WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_TABSTOP, 0},
|
||
|
{ 69, 6, WS_CHILD | WS_TABSTOP, 0},
|
||
|
/* A valid group in the middle of the dialog (not the first nor last group*/
|
||
|
{ 25, 6, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
|
||
|
/* A non-tabstop item will be skipped for tabs */
|
||
|
{ 70, 6, WS_CHILD | WS_VISIBLE, 0},
|
||
|
/* A disabled item will be skipped for tabs and groups */
|
||
|
{ 71, 6, WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_TABSTOP, 0},
|
||
|
/* A valid item will be found for tabs and groups */
|
||
|
{ 72, 6, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
|
||
|
/* A disabled item to skip when looking for the next group item */
|
||
|
{ 73, 6, WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_TABSTOP, 0},
|
||
|
/* The next group begins with an enabled visible label */
|
||
|
{ 26, 6, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
|
||
|
{ 74, 6, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
|
||
|
{ 75, 6, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
|
||
|
/* That group is terminated by a disabled label */
|
||
|
{ 27, 6, WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_GROUP, 0},
|
||
|
{ 76, 6, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
|
||
|
{ 77, 6, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
|
||
|
/* That group is terminated by an invisible label */
|
||
|
{ 28, 6, WS_CHILD | WS_GROUP, 0},
|
||
|
/* The end of the dialog with item for loop and recursion testing */
|
||
|
{ 78, 6, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
|
||
|
/* No tabstop so skipped for prev tab, but found for prev group */
|
||
|
{ 79, 6, WS_CHILD | WS_VISIBLE, 0},
|
||
|
{ 80, 6, WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_TABSTOP, 0},
|
||
|
/* A couple of controls after the main dialog */
|
||
|
{ 82, 5, WS_CHILD | WS_VISIBLE, 0},
|
||
|
{ 30, 5, WS_CHILD | WS_VISIBLE | WS_GROUP, 0},
|
||
|
/* And around them */
|
||
|
{ 84, 4, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0},
|
||
|
{0, 0, 0, 0}
|
||
|
};
|
||
|
|
||
|
static BOOL CreateWindows (HINSTANCE hinst)
|
||
|
{
|
||
|
const h_entry *p = hierarchy;
|
||
|
|
||
|
while (p->id != 0)
|
||
|
{
|
||
|
DWORD style, exstyle;
|
||
|
char ctrlname[9];
|
||
|
|
||
|
/* Basically assert that the hierarchy is valid and track the
|
||
|
* maximum control number
|
||
|
*/
|
||
|
if (p->id >= numwnds)
|
||
|
{
|
||
|
if (p->id >= sizeof(hwnd)/sizeof(hwnd[0]))
|
||
|
{
|
||
|
trace ("Control %d is out of range\n", p->id);
|
||
|
return FALSE;
|
||
|
}
|
||
|
else
|
||
|
numwnds = p->id+1;
|
||
|
}
|
||
|
if (p->id <= 0)
|
||
|
{
|
||
|
trace ("Control %d is out of range\n", p->id);
|
||
|
return FALSE;
|
||
|
}
|
||
|
if (hwnd[p->id] != 0)
|
||
|
{
|
||
|
trace ("Control %d is used more than once\n", p->id);
|
||
|
return FALSE;
|
||
|
}
|
||
|
|
||
|
/* Create the control */
|
||
|
sprintf (ctrlname, "ctrl%4.4d", p->id);
|
||
|
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);
|
||
|
if (!hwnd[p->id])
|
||
|
{
|
||
|
trace ("Failed to create control %d\n", p->id);
|
||
|
return FALSE;
|
||
|
}
|
||
|
|
||
|
/* Check that the styles are as we specified (except the main one
|
||
|
* which is quite frequently messed up). If this keeps breaking then
|
||
|
* we could mask out the bits that don't concern us.
|
||
|
*/
|
||
|
if (p->parent)
|
||
|
{
|
||
|
style = GetWindowLong (hwnd[p->id], GWL_STYLE);
|
||
|
exstyle = GetWindowLong (hwnd[p->id], GWL_EXSTYLE);
|
||
|
if (style == p->style && exstyle == p->exstyle)
|
||
|
{
|
||
|
trace ("Style mismatch at %d: %8.8lx %8.8lx cf %8.8lx %8.8lx\n", p->id, style, exstyle, p->style, p->exstyle);
|
||
|
}
|
||
|
}
|
||
|
p++;
|
||
|
}
|
||
|
|
||
|
return TRUE;
|
||
|
}
|
||
|
|
||
|
/* Form the lParam of a WM_KEYDOWN message */
|
||
|
static DWORD KeyDownData (int repeat, int scancode, int extended, int wasdown)
|
||
|
{
|
||
|
return ((repeat & 0x0000FFFF) | ((scancode & 0x00FF) >> 16) |
|
||
|
(extended ? 0x01000000 : 0) | (wasdown ? 0x40000000 : 0));
|
||
|
}
|
||
|
|
||
|
/* Form a WM_KEYDOWN VK_TAB message to the specified window */
|
||
|
static void FormTabMsg (MSG *pMsg, HWND hwnd)
|
||
|
{
|
||
|
pMsg->hwnd = hwnd;
|
||
|
pMsg->message = WM_KEYDOWN;
|
||
|
pMsg->wParam = VK_TAB;
|
||
|
pMsg->lParam = KeyDownData (1, 0x0F, 0, 0);
|
||
|
/* pMsg->time is not set. It shouldn't be needed */
|
||
|
/* pMsg->pt is ignored */
|
||
|
}
|
||
|
|
||
|
/* Form a WM_KEYDOWN VK_RETURN message to the specified window */
|
||
|
static void FormEnterMsg (MSG *pMsg, HWND hwnd)
|
||
|
{
|
||
|
pMsg->hwnd = hwnd;
|
||
|
pMsg->message = WM_KEYDOWN;
|
||
|
pMsg->wParam = VK_RETURN;
|
||
|
pMsg->lParam = KeyDownData (1, 0x1C, 0, 0);
|
||
|
/* pMsg->time is not set. It shouldn't be needed */
|
||
|
/* pMsg->pt is ignored */
|
||
|
}
|
||
|
|
||
|
/***********************************************************************
|
||
|
*
|
||
|
* The actual tests
|
||
|
*/
|
||
|
|
||
|
typedef struct
|
||
|
{
|
||
|
int isok; /* or is it todo */
|
||
|
int test;
|
||
|
int dlg;
|
||
|
int ctl;
|
||
|
int tab;
|
||
|
int prev;
|
||
|
int res;
|
||
|
} test_record;
|
||
|
|
||
|
static int id (HWND h)
|
||
|
{
|
||
|
int i;
|
||
|
for (i = 0; i < numwnds; i++)
|
||
|
if (hwnd[i] == h)
|
||
|
return i;
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
/* Tests
|
||
|
*
|
||
|
* Tests 1-8 test the hCtl argument of null or the dialog itself.
|
||
|
*
|
||
|
* 1. Prev Group of null is null
|
||
|
* 2. Prev Tab of null is null
|
||
|
* 3. Prev Group of hDlg in hDlg is null
|
||
|
* 4. Prev Tab of hDlg in hDlg is null
|
||
|
* 5. Next Group of null is first visible enabled child
|
||
|
* Check it skips invisible, diabled and both.
|
||
|
* 6. Next Tab of null is first visible enabled tabstop
|
||
|
* Check it skips invisible, disabled, nontabstop, and in combination.
|
||
|
* 7. Next Group of hDlg in hDlg is as of null
|
||
|
* 8. Next Tab of hDlg in hDlg is as of null
|
||
|
*
|
||
|
* Tests 9-14 test descent
|
||
|
*
|
||
|
* 9. DS_CONTROL does not result in descending the hierarchy for Tab Next
|
||
|
* 10. DS_CONTROL does not result in descending the hierarchy for Group Next
|
||
|
* 11. WS_EX_CONTROLPARENT results in descending the hierarchy for Tab Next
|
||
|
* 12. WS_EX_CONTROLPARENT results in descending the hierarchy for Group Next
|
||
|
* 13. WS_EX_CONTROLPARENT results in descending the hierarchy for Tab Prev
|
||
|
* 14. WS_EX_CONTROLPARENT results in descending the hierarchy for Group Prev
|
||
|
*
|
||
|
* Tests 15-24 are the basic Prev/Next Group tests
|
||
|
*
|
||
|
* 15. Next Group of a visible enabled non-group control is the next visible
|
||
|
* enabled non-group control, if there is one before the next group
|
||
|
* 16. Next Group of a visible enabled non-group control wraps around to the
|
||
|
* beginning of the group on finding a control that starts another group.
|
||
|
* Note that the group is in the middle of the dialog.
|
||
|
* 17. As 16 except note that the next group is started with a disabled
|
||
|
* visible control.
|
||
|
* 18. As 16 except note that the next group is started with an invisible
|
||
|
* enabled control.
|
||
|
* 19. Next Group wraps around the controls of the dialog
|
||
|
* 20. Next Group is the same even if the initial control is disabled.
|
||
|
* 21. Next Group is the same even if the initial control is invisible.
|
||
|
* 22. Next Group is the same even if the initial control has the group style
|
||
|
* 23. Next Group returns the initial control if there is no visible enabled
|
||
|
* control in the group. (Initial control disabled and not group style).
|
||
|
* 24. Prev version of test 16.
|
||
|
* Prev Group of a visible enabled non-group control wraps around to the
|
||
|
* beginning of the group on finding a control that starts the group.
|
||
|
* Note that the group is in the middle of the dialog.
|
||
|
*
|
||
|
* In tests 25 to 28 the control is sitting under dialogs which do not have
|
||
|
* the WS_EX_CONTROLPARENT style and so cannot be reached from the top of
|
||
|
* the dialog.
|
||
|
*
|
||
|
* 25. Next Group of an inaccessible control is as if it were accessible
|
||
|
* 26. Prev Group of an inaccessible control begins searching at the highest
|
||
|
* level ancestor that did not permit recursion down the hierarchy
|
||
|
* 27. Next Tab of an inaccessible control is as if it were accessible
|
||
|
* 28. Prev Tab of an inaccessible control begins searching at the highest
|
||
|
* level ancestor that did not permit recursion down the hierarchy.
|
||
|
*
|
||
|
* Tests 29- are the basic Tab tests
|
||
|
*
|
||
|
* 29. Next Tab of a control is the next visible enabled control with the
|
||
|
* Tabstop style (N.B. skips disabled, invisible and non-tabstop)
|
||
|
* 30. Prev Tab of a control is the previous visible enabled control with the
|
||
|
* Tabstop style (N.B. skips disabled, invisible and non-tabstop)
|
||
|
* 31. Next Tab test with at least two layers of descent and finding the
|
||
|
* result not at the first control.
|
||
|
* 32. Next Tab test with at least two layers of descent with the descent and
|
||
|
* control at the start of each level.
|
||
|
* 33. Prev Tab test with at least two layers of descent and finding the
|
||
|
* result not at the last control.
|
||
|
* 34. Prev Tab test with at least two layers of descent with the descent and
|
||
|
* control at the end of each level.
|
||
|
*
|
||
|
* 35. Passing NULL may result in the first child being the one returned.
|
||
|
* (group test)
|
||
|
* 36. Passing NULL may result in the first child being the one returned.
|
||
|
* (tab test)
|
||
|
*/
|
||
|
|
||
|
static void GetNextDlgItemTest (void)
|
||
|
{
|
||
|
static test_record test [] =
|
||
|
{
|
||
|
/* isok test dlg ctl tab prev res */
|
||
|
|
||
|
{ 1, 1, 6, 0, 0, 1, 0},
|
||
|
{ 1, 2, 6, 0, 1, 1, 0},
|
||
|
{ 1, 3, 6, 6, 0, 1, 0},
|
||
|
{ 1, 4, 6, 6, 1, 1, 0},
|
||
|
{ 1, 5, 6, 0, 0, 0, 66},
|
||
|
{ 1, 6, 6, 0, 1, 0, 67},
|
||
|
{ 1, 7, 6, 6, 0, 0, 66},
|
||
|
{ 1, 8, 6, 6, 1, 0, 67},
|
||
|
|
||
|
{ 1, 9, 4, 83, 1, 0, 84},
|
||
|
{ 1, 10, 4, 83, 0, 0, 5},
|
||
|
{ 1, 11, 5, 81, 1, 0, 67},
|
||
|
{ 1, 12, 5, 81, 0, 0, 66},
|
||
|
{ 1, 13, 5, 82, 1, 1, 78},
|
||
|
|
||
|
{ 1, 14, 5, 82, 0, 1, 79},
|
||
|
{ 1, 15, 6, 70, 0, 0, 72},
|
||
|
{ 1, 16, 6, 72, 0, 0, 25},
|
||
|
{ 1, 17, 6, 75, 0, 0, 26},
|
||
|
{ 1, 18, 6, 77, 0, 0, 76},
|
||
|
{ 1, 19, 6, 79, 0, 0, 66},
|
||
|
{ 1, 20, 6, 71, 0, 0, 72},
|
||
|
{ 1, 21, 6, 64, 0, 0, 66},
|
||
|
|
||
|
{ 1, 22, 6, 25, 0, 0, 70},
|
||
|
{ 1, 23, 6, 68, 0, 0, 68},
|
||
|
{ 1, 24, 6, 25, 0, 1, 72},
|
||
|
{ 1, 25, 1, 70, 0, 0, 72},
|
||
|
{ 0, 26, 1, 70, 0, 1, 3},
|
||
|
{ 1, 27, 1, 70, 1, 0, 72},
|
||
|
{ 0, 28, 1, 70, 1, 1, 61},
|
||
|
|
||
|
{ 1, 29, 6, 67, 1, 0, 72},
|
||
|
{ 1, 30, 6, 72, 1, 1, 67},
|
||
|
|
||
|
{ 1, 35, 2, 0, 0, 0, 60},
|
||
|
{ 1, 36, 2, 0, 1, 0, 60},
|
||
|
|
||
|
{ 0, 0, 0, 0, 0, 0, 0} /* End of test */
|
||
|
};
|
||
|
const test_record *p = test;
|
||
|
|
||
|
ok (CreateWindows (g_hinst), "Could not create test windows\n");
|
||
|
|
||
|
while (p->dlg)
|
||
|
{
|
||
|
HWND a;
|
||
|
a = (p->tab ? GetNextDlgTabItem : GetNextDlgGroupItem) (hwnd[p->dlg], hwnd[p->ctl], p->prev);
|
||
|
if (p->isok)
|
||
|
{
|
||
|
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);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
todo_wine
|
||
|
{
|
||
|
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);
|
||
|
}
|
||
|
}
|
||
|
p++;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* OnMainWindowCreate
|
||
|
*/
|
||
|
static BOOL OnMainWindowCreate (HWND hwnd, LPCREATESTRUCT lpcs)
|
||
|
{
|
||
|
g_hwndButton1 = CreateWindow (TEXT("button"), TEXT("Button &1"),
|
||
|
WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_DEFPUSHBUTTON | BS_TEXT,
|
||
|
10, 10, 80, 80, hwnd, (HMENU)100, g_hinst, 0);
|
||
|
if (!g_hwndButton1) return FALSE;
|
||
|
|
||
|
g_hwndButton2 = CreateWindow (TEXT("button"), TEXT("Button &2"),
|
||
|
WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_TEXT,
|
||
|
110, 10, 80, 80, hwnd, (HMENU)200, g_hinst, 0);
|
||
|
if (!g_hwndButton2) return FALSE;
|
||
|
|
||
|
g_hwndButtonCancel = CreateWindow (TEXT("button"), TEXT("Cancel"),
|
||
|
WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON | BS_TEXT,
|
||
|
210, 10, 80, 80, hwnd, (HMENU)IDCANCEL, g_hinst, 0);
|
||
|
if (!g_hwndButtonCancel) return FALSE;
|
||
|
|
||
|
return TRUE;
|
||
|
}
|
||
|
|
||
|
|
||
|
static LRESULT CALLBACK main_window_procA (HWND hwnd, UINT uiMsg, WPARAM wParam,
|
||
|
LPARAM lParam)
|
||
|
{
|
||
|
LRESULT result;
|
||
|
switch (uiMsg)
|
||
|
{
|
||
|
/* Add blank case statements for these to ensure we don't use them
|
||
|
* by mistake.
|
||
|
*/
|
||
|
case DM_GETDEFID: break;
|
||
|
case DM_SETDEFID: break;
|
||
|
|
||
|
case WM_CREATE:
|
||
|
return (OnMainWindowCreate (hwnd,
|
||
|
(LPCREATESTRUCTA) lParam) ? 0 : (LRESULT) -1);
|
||
|
case WM_COMMAND:
|
||
|
if (wParam == IDCANCEL)
|
||
|
{
|
||
|
g_terminated = TRUE;
|
||
|
return 0;
|
||
|
}
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
result=DefWindowProcA (hwnd, uiMsg, wParam, lParam);
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
|
||
|
static BOOL RegisterWindowClasses (void)
|
||
|
{
|
||
|
WNDCLASSA cls;
|
||
|
|
||
|
cls.style = 0;
|
||
|
cls.lpfnWndProc = DefWindowProcA;
|
||
|
cls.cbClsExtra = 0;
|
||
|
cls.cbWndExtra = 0;
|
||
|
cls.hInstance = g_hinst;
|
||
|
cls.hIcon = NULL;
|
||
|
cls.hCursor = LoadCursorA (NULL, IDC_ARROW);
|
||
|
cls.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
|
||
|
cls.lpszMenuName = NULL;
|
||
|
cls.lpszClassName = "GetNextDlgItemWindowClass";
|
||
|
|
||
|
if (!RegisterClassA (&cls)) return FALSE;
|
||
|
|
||
|
cls.lpfnWndProc = main_window_procA;
|
||
|
cls.lpszClassName = "IsDialogMessageWindowClass";
|
||
|
|
||
|
if (!RegisterClassA (&cls)) return FALSE;
|
||
|
|
||
|
return TRUE;
|
||
|
}
|
||
|
|
||
|
static void IsDialogMessageWTest (void)
|
||
|
{
|
||
|
MSG msg;
|
||
|
|
||
|
g_hwndMain = CreateWindow ("IsDialogMessageWindowClass", "IsDialogMessageWindowClass",
|
||
|
WS_OVERLAPPEDWINDOW,
|
||
|
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
|
||
|
NULL, NULL, g_hinst, 0);
|
||
|
|
||
|
assert (g_hwndMain);
|
||
|
assert (g_hwndButton1);
|
||
|
assert (g_hwndButtonCancel);
|
||
|
|
||
|
/* The focus should initially be nowhere. The first TAB should take it
|
||
|
* to the first button. The second TAB should take it to the Cancel
|
||
|
* button.
|
||
|
*/
|
||
|
FormTabMsg (&msg, g_hwndMain);
|
||
|
ok (IsDialogMessage (g_hwndMain, &msg), "Did not handle first TAB\n");
|
||
|
ok ((GetFocus() == g_hwndButton1), "Focus did not move to first button\n");
|
||
|
FormTabMsg (&msg, g_hwndButton1);
|
||
|
ok (IsDialogMessage (g_hwndMain, &msg), "Did not handle second TAB\n");
|
||
|
ok ((GetFocus() == g_hwndButtonCancel),
|
||
|
"Focus did not move to cancel button\n");
|
||
|
FormEnterMsg (&msg, g_hwndButtonCancel);
|
||
|
ok (IsDialogMessage (g_hwndMain, &msg), "Did not handle the ENTER\n");
|
||
|
ok (g_terminated, "ENTER did not terminate\n");
|
||
|
}
|
||
|
|
||
|
START_TEST(dialog)
|
||
|
{
|
||
|
g_hinst = GetModuleHandleA (0);
|
||
|
|
||
|
if (!RegisterWindowClasses()) assert(0);
|
||
|
|
||
|
GetNextDlgItemTest();
|
||
|
IsDialogMessageWTest();
|
||
|
}
|