You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1402 lines
45 KiB
1402 lines
45 KiB
/*++
|
|
*
|
|
* WOW v1.0
|
|
*
|
|
* Copyright (c) 1991, Microsoft Corporation
|
|
*
|
|
* WUDLG.C
|
|
* WOW32 16-bit User API support
|
|
*
|
|
* History:
|
|
* Created 07-Mar-1991 by Jeff Parsons (jeffpar)
|
|
--*/
|
|
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
MODNAME(wudlg.c);
|
|
|
|
// SendDlgItemMessage cache
|
|
extern HWND hdlgSDIMCached ;
|
|
|
|
/*++
|
|
void CheckDlgButton(<hDlg>, <nIDButton>, <wCheck>)
|
|
HWND <hDlg>;
|
|
int <nIDButton>;
|
|
WORD <wCheck>;
|
|
|
|
The %CheckDlgButton% function places a checkmark next to or removes a
|
|
checkmark from a button control, or changes the state of a three-state
|
|
button. The %CheckDlgButton% function sends a BM_SETCHECK message to the
|
|
button control that has the specified ID in the given dialog box.
|
|
|
|
<hDlg>
|
|
Identifies the dialog box that contains the button.
|
|
|
|
<nIDButton>
|
|
Specifies the button control to be modified.
|
|
|
|
<wCheck>
|
|
Specifies the action to take. If the <wCheck> parameter is
|
|
nonzero, the %CheckDlgButton% function places a checkmark next to the
|
|
button; if zero, the checkmark is removed. For three-state buttons, if
|
|
<wCheck> is 2, the button is grayed; if <wCheck> is 1, it is checked; if
|
|
<wCheck> is 0, the checkmark is removed.
|
|
|
|
This function does not return a value.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32CheckDlgButton(PVDMFRAME pFrame)
|
|
{
|
|
register PCHECKDLGBUTTON16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(CHECKDLGBUTTON16), parg16);
|
|
|
|
CheckDlgButton(
|
|
HWND32(parg16->f1),
|
|
WORD32(parg16->f2),
|
|
WORD32(parg16->f3)
|
|
);
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(0);
|
|
}
|
|
|
|
|
|
/*++
|
|
void CheckRadioButton(<hDlg>, <nIDFirstButton>, <nIDLastButton>,
|
|
<nIDCheckButton>)
|
|
HWND <hDlg>;
|
|
int <nIDFirstButton>;
|
|
int <nIDLastButton>;
|
|
int <nIDCheckButton>;
|
|
|
|
The %CheckRadioButton% function checks the radio button specified by the
|
|
<nIDCheckButton> parameter and removes the checkmark from all other radio
|
|
buttons in the group of buttons specified by the <nIDFirstButton> and
|
|
<nIDLastButton> parameters. The %CheckRadioButton% function sends a
|
|
BM_SETCHECK message to the radio-button control that has the specified ID in
|
|
the given dialog box.
|
|
|
|
<hDlg>
|
|
Identifies the dialog box.
|
|
|
|
<nIDFirstButton>
|
|
Specifies the integer identifier of the first radio button in the
|
|
group.
|
|
|
|
<nIDLastButton>
|
|
Specifies the integer identifier of the last radio button in the
|
|
group.
|
|
|
|
<nIDCheckButton>
|
|
Specifies the integer identifier of the radio button to be
|
|
checked.
|
|
|
|
This function does not return a value.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32CheckRadioButton(PVDMFRAME pFrame)
|
|
{
|
|
register PCHECKRADIOBUTTON16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(CHECKRADIOBUTTON16), parg16);
|
|
|
|
CheckRadioButton(
|
|
HWND32(parg16->f1),
|
|
WORD32(parg16->f2),
|
|
WORD32(parg16->f3),
|
|
WORD32(parg16->f4)
|
|
);
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(0);
|
|
}
|
|
|
|
//***************************************************************************
|
|
// HWND WINAPI CreateDialog(HINSTANCE, LPCSTR, HWND, DLGPROC);
|
|
// HWND WINAPI CreateDialogIndirect(HINSTANCE, const void FAR*, HWND, DLGPROC);
|
|
// HWND WINAPI CreateDialogParam(HINSTANCE, LPCSTR, HWND, DLGPROC, LPARAM);
|
|
// HWND WINAPI CreateDialogIndirectParam(HINSTANCE, const void FAR*, HWND, DLGPROC, LPARAM);
|
|
//
|
|
// int WINAPI DialogBox(HINSTANCE, LPCSTR, HWND, DLGPROC);
|
|
// int WINAPI DialogBoxIndirect(HINSTANCE, HGLOBAL, HWND, DLGPROC);
|
|
// int WINAPI DialogBoxParam(HINSTANCE, LPCSTR, HWND, DLGPROC, LPARAM);
|
|
// int WINAPI DialogBoxIndirectParam(HINSTANCE, HGLOBAL, HWND, DLGPROC, LPARAM);
|
|
//
|
|
// This is a common entry point for all the apis above. We distinguish
|
|
// between 'create' and 'dialogbox' apis by a bool flag (parg16->f7).
|
|
// TRUE implies 'dialogbox' apis else 'create' apis.
|
|
//
|
|
// - nanduri
|
|
//***************************************************************************
|
|
|
|
ULONG FASTCALL WU32DialogBoxParam(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul=(ULONG)-1;
|
|
PVOID pDlg;
|
|
DWORD cb, cb16;
|
|
register PDIALOGBOXPARAM16 parg16;
|
|
BYTE abT[1024];
|
|
WNDPROC vpDlgProc = NULL;
|
|
|
|
GETARGPTR(pFrame, sizeof(DIALOGBOXPARAM16), parg16);
|
|
|
|
if (DWORD32(parg16->f4)) {
|
|
// mark the proc as WOW proc and save the high bits in the RPL
|
|
MarkWOWProc (parg16->f4,vpDlgProc);
|
|
}
|
|
|
|
if (!(cb16 = parg16->f6)) {
|
|
cb = ConvertDialog16(NULL, DWORD32(parg16->f2), 0, cb16);
|
|
}
|
|
else {
|
|
// The idea is eliminate a call to ConverDialog16
|
|
//
|
|
// the maximum size that 32bit dlgtemplate would be is twice
|
|
// the 16bit dlgtemplate.
|
|
//
|
|
// this assumption is true cause - we convert most words to dwords
|
|
// and ansi strings to unicode strings - since we know that a
|
|
// DWORD is twice the sizeof a WORD a unicode character is 2bytes
|
|
// therefore maxsize of dlgtemplate cannot exceed cb * 2.
|
|
//
|
|
// - nanduri
|
|
|
|
cb = cb16 * max(sizeof(DWORD) / sizeof(WORD), sizeof(WCHAR)/sizeof(BYTE));
|
|
WOW32ASSERT(cb >= ConvertDialog16(NULL, DWORD32(parg16->f2), 0, cb16));
|
|
}
|
|
|
|
pDlg = (cb > sizeof(abT)) ? malloc_w(cb) : (PVOID)abT;
|
|
if (cb && pDlg) {
|
|
cb = ConvertDialog16(pDlg, DWORD32(parg16->f2), cb, cb16);
|
|
|
|
if (parg16->f7) {
|
|
ul = GETINT16(DialogBoxIndirectParamAorW(HMODINST32(parg16->f1),
|
|
pDlg, HWND32(parg16->f3),
|
|
vpDlgProc,
|
|
(LPARAM) DWORD32(parg16->f5), SCDLG_ANSI));
|
|
}
|
|
else {
|
|
ul = GETHWND16((pfnOut.pfnServerCreateDialog)(HMODINST32(parg16->f1), (LPDLGTEMPLATE)pDlg,
|
|
cb, HWND32(parg16->f3),
|
|
vpDlgProc,
|
|
(LPARAM) DWORD32(parg16->f5), SCDLG_CLIENT | SCDLG_ANSI | SCDLG_NOREVALIDATE));
|
|
}
|
|
|
|
if (pDlg != (PVOID)abT) {
|
|
free_w (pDlg);
|
|
}
|
|
|
|
}
|
|
|
|
// Invalidate SendDlgItemMessage cache
|
|
hdlgSDIMCached = NULL ;
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
int DlgDirList(<hDlg>, <lpPathSpec>, <nIDListBox>, <nIDStaticPath>,
|
|
<wFiletype>)
|
|
HWND <hDlg>;
|
|
LPSTR <lpPathSpec>;
|
|
int <nIDListBox>;
|
|
int <nIDStaticPath>;
|
|
WORD <wFiletype>;
|
|
|
|
The %DlgDirList% function fills a list-box control with a file or directory
|
|
listing. It fills the list box specified by the <nIDListBox> parameter with
|
|
the names of all files matching the pathname given by the <lpPathSpec>
|
|
parameter.
|
|
|
|
The %DlgDirList% function shows subdirectories enclosed in square brackets
|
|
([ ]), and shows drives in the form [-<x>-], where <x> is the drive letter.
|
|
|
|
The <lpPathSpec> parameter has the following form:
|
|
|
|
[drive:] [ [\u]directory[\idirectory]...\u] [filename]
|
|
|
|
In this example, <drive> is a drive letter, <directory> is a valid directory
|
|
name, and <filename> is a valid filename that must contain at least one
|
|
wildcard character. The wildcard characters are a question mark (?), meaning
|
|
match any character, and an asterisk (*), meaning match any number of
|
|
characters.
|
|
|
|
If the <lpPathSpec> parameter includes a drive and/or directory name, the
|
|
current drive and directory are changed to the designated drive and
|
|
directory before the list box is filled. The text control identified by the
|
|
<nIDStaticPath> parameter is also updated with the new drive and/or
|
|
directory name.
|
|
|
|
After the list box is filled, <lpPathSpec> is updated by removing the drive
|
|
and/or directory portion of the pathname.
|
|
|
|
%DlgDirList% sends LB_RESETCONTENT and LB_DIR messages to the list box.
|
|
|
|
<hDlg>
|
|
Identifies the dialog box that contains the list box.
|
|
|
|
<lpPathSpec>
|
|
Points to a pathname string. The string must be a
|
|
null-terminated character string.
|
|
|
|
<nIDListBox>
|
|
Specifies the identifier of a list-box control. If <nIDListBox> is
|
|
zero, %DlgDirList% assumes that no list box exists and does not attempt
|
|
to fill it.
|
|
|
|
<nIDStaticPath>
|
|
Specifies the identifier of the static-text control used for
|
|
displaying the current drive and directory. If <nIDStaticPath> is zero,
|
|
%DlgDirList% assumes that no such text control is present.
|
|
|
|
<wFiletype>
|
|
Specifies the attributes of the files to be displayed. It can be any
|
|
combination of the following values:
|
|
|
|
0x0000
|
|
Read/write data files with no additional attributes
|
|
|
|
0x0001
|
|
Read-only files
|
|
|
|
0x0002
|
|
Hidden files
|
|
|
|
0x0004
|
|
System files
|
|
|
|
0x0010
|
|
Subdirectories
|
|
|
|
0x0020
|
|
Archives
|
|
|
|
0x2000
|
|
LB_DIR flag. If the LB_DIR flag is set, Windows places the messages
|
|
generated by %DlgDirList% in the application's queue; otherwise they are
|
|
sent directly to the dialog function.
|
|
|
|
0x4000
|
|
Drives
|
|
|
|
0x8000
|
|
Exclusive bit. If the exclusive bit is set, only files of the specified
|
|
type are listed. Otherwise, files of the specified type are listed in
|
|
addition to normal files.
|
|
|
|
The return value specifies the outcome of the function. It is nonzero if a
|
|
listing was made, even an empty listing. A zero return value implies that
|
|
the input string did not contain a valid search path.
|
|
|
|
The <wFiletype> parameter specifies the DOS attributes of the files to be
|
|
listed. Table 4.6 describes these attributes.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32DlgDirList(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
PSZ psz2;
|
|
register PDLGDIRLIST16 parg16;
|
|
|
|
UpdateDosCurrentDirectory(DIR_DOS_TO_NT);
|
|
|
|
GETARGPTR(pFrame, sizeof(DLGDIRLIST16), parg16);
|
|
GETPSZPTR(parg16->f2, psz2);
|
|
|
|
//
|
|
// KidPix passes an invalid filetype flag (0x1000) that Win3.1 doesn't
|
|
// check for. Win32 does, and fails the API, so mask that flag off here.
|
|
// John Vert (jvert) 11-Jun-1993
|
|
//
|
|
|
|
ul = GETINT16(DlgDirList(
|
|
HWND32(parg16->f1),
|
|
psz2,
|
|
WORD32(parg16->f3),
|
|
WORD32(parg16->f4),
|
|
WORD32(parg16->f5) & DDL_VALID
|
|
));
|
|
|
|
UpdateDosCurrentDirectory(DIR_NT_TO_DOS);
|
|
|
|
FREEPSZPTR(psz2);
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
int DlgDirListComboBox(<hDlg>, <lpPathSpec>, <nIDComboBox>, <nIDStaticPath>,
|
|
<wFiletype>)
|
|
HWND <hDlg>;
|
|
LPSTR <lpPathSpec>;
|
|
int <nIDComboBox>;
|
|
int <nIDStaticPath>;
|
|
WORD <wFiletype>;
|
|
|
|
The %DlgDirListComboBox% function fills the list box of a combo-box control
|
|
with a file or directory listing. It fills the list box of the combo box
|
|
specified by the <nIDComboBox> parameter with the names of all files
|
|
matching the pathname given by the <lpPathSpec> parameter.
|
|
|
|
The %DlgDirListComboBox% function shows subdirectories enclosed in square
|
|
brackets ([ ]), and shows drives in the form [-<x>-], where <x> is the drive
|
|
letter.
|
|
|
|
The <lpPathSpec> parameter has the following form:
|
|
|
|
[drive:] [ [\u]directory[\idirectory]...\u] [filename]
|
|
|
|
In this example, <drive> is a drive letter, <directory> is a valid directory
|
|
name, and <filename> is a valid filename that must contain at least one
|
|
wildcard character. The wildcard characters are a question mark (?), meaning
|
|
match any character, and an asterisk (*), meaning match any number of
|
|
characters.
|
|
|
|
If the <lpPathSpec> parameter includes a drive and/or directory name, the
|
|
current drive and directory are changed to the designated drive and
|
|
directory before the list box is filled. The text control identified by the
|
|
<nIDStaticPath> parameter is also updated with the new drive and/or
|
|
directory name.
|
|
|
|
After the combo-box list box is filled, <lpPathSpec> is updated by removing
|
|
the drive and/or directory portion of the pathname.
|
|
|
|
%DlgDirListComboBox% sends CB_RESETCONTENT and CB_DIR messages to the combo
|
|
box.
|
|
|
|
<hDlg>
|
|
Identifies the dialog box that contains the combo box.
|
|
|
|
<lpPathSpec>
|
|
Points to a pathname string. The string must be a
|
|
null-terminated string.
|
|
|
|
<nIDComboBox>
|
|
Specifies the identifier of a combo-box control in a dialog box.
|
|
If <nIDComboBox> is zero, %DlgDirListComboBox% assumes that no combo box
|
|
exists and does not attempt to fill it.
|
|
|
|
<nIDStaticPath>
|
|
Specifies the identifier of the static-text control used for
|
|
displaying the current drive and directory. If <nIDStaticPath> is zero,
|
|
%DlgDirListComboBox% assumes that no such text control is present.
|
|
|
|
<wFiletype>
|
|
Specifies DOS file attributes of the files to be displayed. It
|
|
can be any combination of the following values:
|
|
|
|
The return value specifies the outcome of the function. It is nonzero if a
|
|
listing was made, even an empty listing. A zero return value implies that
|
|
the input string did not contain a valid search path.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32DlgDirListComboBox(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
PSZ psz2;
|
|
register PDLGDIRLISTCOMBOBOX16 parg16;
|
|
|
|
UpdateDosCurrentDirectory(DIR_DOS_TO_NT);
|
|
|
|
GETARGPTR(pFrame, sizeof(DLGDIRLISTCOMBOBOX16), parg16);
|
|
GETPSZPTR(parg16->f2, psz2);
|
|
|
|
ul = GETINT16(DlgDirListComboBox(
|
|
HWND32(parg16->f1),
|
|
psz2,
|
|
WORD32(parg16->f3),
|
|
WORD32(parg16->f4),
|
|
WORD32(parg16->f5)
|
|
));
|
|
|
|
UpdateDosCurrentDirectory(DIR_NT_TO_DOS);
|
|
|
|
|
|
FREEPSZPTR(psz2);
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
BOOL DlgDirSelectEx(<hDlg>, <lpString>, <nIDListBox>)
|
|
HWND <hDlg>;
|
|
LPSTR <lpString>;
|
|
int <nIDListBox>;
|
|
|
|
The %DlgDirSelectEx% function retrieves the current selection from a list
|
|
box. It assumes that the list box has been filled by the %DlgDirList%
|
|
function and that the selection is a drive letter, a file, or a directory
|
|
name.
|
|
|
|
The %DlgDirSelectEx% function copies the selection to the buffer given by the
|
|
<lpString> parameter. If the current selection is a directory name or drive
|
|
letter, %DlgDirSelectEx% removes the enclosing square brackets (and hyphens,
|
|
for drive letters) so that the name or letter is ready to be inserted into a
|
|
new pathname. If there is no selection, <lpString> does not change.
|
|
|
|
%DlgDirSelectEx% sends LB_GETCURSEL and LB_GETTEXT messages to the list box.
|
|
|
|
<hDlg>
|
|
Identifies the dialog box that contains the list box.
|
|
|
|
<lpString>
|
|
Points to a buffer that is to receive the selected pathname.
|
|
|
|
<nIDListBox>
|
|
Specifies the integer ID of a list-box control in the dialog box.
|
|
|
|
The return value specifies the status of the current list-box selection. It
|
|
is TRUE if the current selection is a directory name. Otherwise, it is
|
|
FALSE.
|
|
|
|
The %DlgDirSelectEx% function does not allow more than one filename to be
|
|
returned from a list box.
|
|
|
|
The list box must not be a multiple-selection list box. If it is, this
|
|
function will not return a zero value and <lpString> will remain unchanged.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32DlgDirSelect(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
PSZ psz2;
|
|
VPVOID vp;
|
|
register PDLGDIRSELECT16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(DLGDIRSELECT16), parg16);
|
|
ALLOCVDMPTR(parg16->f2, MAX_VDMFILENAME, psz2);
|
|
vp = parg16->f2;
|
|
|
|
ul = GETBOOL16(DlgDirSelectEx(
|
|
HWND32(parg16->f1),
|
|
psz2,
|
|
SIZE_BOGUS,
|
|
WORD32(parg16->f3)
|
|
));
|
|
|
|
// special case to keep common dialog structs in sync (see wcommdlg.c)
|
|
Check_ComDlg_pszptr(CURRENTPTD()->CommDlgTd, vp);
|
|
|
|
FLUSHVDMPTR(parg16->f2, strlen(psz2)+1, psz2);
|
|
FREEVDMPTR(psz2);
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
BOOL DlgDirSelectComboBoxEx(<hDlg>, <lpString>, <nIDComboBox>)
|
|
HWND <hDlg>;
|
|
LPSTR <lpString>;
|
|
int <nIDComboBox>;
|
|
|
|
The %DlgDirSelectComboBoxEx% function retrieves the current selection from the
|
|
list box of a combo box created with the CBS_SIMPLE style. It cannot be used
|
|
with combo boxes created with either the CBS_DROPDOWN or CBS_DROPDOWNLIST
|
|
style. It assumes that the list box has been filled by the
|
|
%DlgDirListComboBox% function and that the selection is a drive letter, a
|
|
file, or a directory name.
|
|
|
|
The %DlgDirSelectComboBoxEx% function copies the selection to the buffer given
|
|
by the <lpString> parameter. If the current selection is a directory name or
|
|
drive letter, %DlgDirSelectComboBoxEx% removes the enclosing square brackets
|
|
(and hyphens, for drive letters) so that the name or letter is ready to be
|
|
inserted into a new pathname. If there is no selection, <lpString> does not
|
|
change.
|
|
|
|
%DlgDirSelectComboBoxEx% sends CB_GETCURSEL and CB_GETLBTEXT messages to the
|
|
combo box.
|
|
|
|
<hDlg>
|
|
Identifies the dialog box that contains the combo box.
|
|
|
|
<lpString>
|
|
Points to a buffer that is to receive the selected pathname.
|
|
|
|
<nIDComboBox>
|
|
Specifies the integer ID of the combo-box control in the dialog
|
|
box.
|
|
|
|
The return value specifies the status of the current combo-box selection. It
|
|
is TRUE if the current selection is a directory name. Otherwise, it is
|
|
FALSE.
|
|
|
|
The %DlgDirSelectComboBoxEx% function does not allow more than one filename to
|
|
be returned from a combo box.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32DlgDirSelectComboBox(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
PSZ psz2;
|
|
VPVOID vp;
|
|
register PDLGDIRSELECTCOMBOBOX16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(DLGDIRSELECTCOMBOBOX16), parg16);
|
|
ALLOCVDMPTR(parg16->f2, MAX_VDMFILENAME, psz2);
|
|
vp = parg16->f2;
|
|
|
|
ul = GETBOOL16(DlgDirSelectComboBoxEx(
|
|
HWND32(parg16->f1),
|
|
psz2,
|
|
SIZE_BOGUS,
|
|
WORD32(parg16->f3)
|
|
));
|
|
|
|
// special case to keep common dialog structs in sync (see wcommdlg.c)
|
|
Check_ComDlg_pszptr(CURRENTPTD()->CommDlgTd, vp);
|
|
|
|
FLUSHVDMPTR(parg16->f2, strlen(psz2)+1, psz2);
|
|
FREEVDMPTR(psz2);
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
void EndDialog(<hDlg>, <nResult>)
|
|
HWND <hDlg>;
|
|
int <nResult>;
|
|
|
|
The %EndDialog% function terminates a modal dialog box and returns the given
|
|
result to the %DialogBox% function that created the dialog box. The
|
|
%EndDialog% function is required to complete processing whenever the
|
|
%DialogBox% function is used to create a modal dialog box. The function must
|
|
be used in the dialog function of the modal dialog box and should not be
|
|
used for any other purpose.
|
|
|
|
The dialog function can call %EndDialog% at any time, even during the
|
|
processing of the WM_INITDIALOG message. If called during the WM_INITDIALOG
|
|
message, the dialog box is terminated before it is shown or before the input
|
|
focus is set.
|
|
|
|
%EndDialog% does not terminate the dialog box immediately. Instead, it sets
|
|
a flag that directs the dialog box to terminate as soon as the dialog
|
|
function ends. The %EndDialog% function returns to the dialog function, so
|
|
the dialog function must return control to Windows.
|
|
|
|
<hDlg>
|
|
Identifies the dialog box to be destroyed.
|
|
|
|
<nResult>
|
|
Specifies the value to be returned from the dialog box to the
|
|
%DialogBox% function that created it.
|
|
|
|
This function does not return a value.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32EndDialog(PVDMFRAME pFrame)
|
|
{
|
|
HWND hwnd;
|
|
register PENDDIALOG16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(ENDDIALOG16), parg16);
|
|
|
|
hwnd = HWND32(parg16->f1);
|
|
|
|
if(!EndDialog(hwnd, INT32(parg16->f2)) && IsWindow(hwnd)){
|
|
CHAR szType[8];
|
|
if(GetLastError() == ERROR_WINDOW_NOT_DIALOG ||
|
|
(RealGetWindowClass(hwnd,szType,8) && WOW32_strnicmp(szType,"#32770",6))) {
|
|
// jarbats
|
|
// App is trying to close window created by CreateWindow
|
|
// via EndDialog! whistler bug #231059
|
|
|
|
DestroyWindow(hwnd);
|
|
}
|
|
}
|
|
FREEARGPTR(parg16);
|
|
RETURN(0);
|
|
}
|
|
|
|
|
|
/*++
|
|
LONG GetDialogBaseUnits(VOID)
|
|
|
|
The %GetDialogBaseUnits% function returns the dialog base units used by
|
|
Windows when creating dialog boxes. An application should use these values
|
|
to calculate the average width of characters in the system font.
|
|
|
|
This function has no parameters.
|
|
|
|
The return value specifies the dialog base units. The high-order word
|
|
contains the height in pixels of the current dialog base height unit derived
|
|
from the height of the system font, and the low-order word contains the
|
|
width in pixels of the current dialog base width unit derived from the width
|
|
of the system font.
|
|
|
|
The values returned represent dialog base units before being scaled to
|
|
actual dialog units. The actual dialog unit in the <x> direction is
|
|
1/4th of the width returned by %GetDialogBaseUnits%. The actual dialog
|
|
unit in the <y> direction is 1/8th of the height returned by the
|
|
function.
|
|
|
|
To determine the actual height and width in pixels of a control, given the
|
|
height (x) and width (y) in dialog units and the return value
|
|
(lDlgBaseUnits) from calling %GetDialogBaseUnits%, use the following
|
|
formula:
|
|
|
|
(x * LOWORD(lDlgBaseUnits))/4
|
|
(y * HIWORD(lDlgBaseUnits))/8
|
|
|
|
To avoid rounding problems, perform the multiplication before the division
|
|
in case the dialog base units are not evenly divisible by four.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32GetDialogBaseUnits(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
|
|
UNREFERENCED_PARAMETER(pFrame);
|
|
|
|
ul = GETLONG16(GetDialogBaseUnits());
|
|
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
int GetDlgCtrlID(<hwnd>)
|
|
HWND <hwnd>;
|
|
|
|
The %GetDlgCtrlID% function returns the ID value of the child window
|
|
identified by the <hwnd> parameter.
|
|
|
|
<hwnd>
|
|
Identifies the child window.
|
|
|
|
The return value is the numeric identifier of the child window if the
|
|
function is successful. If the function fails, or if <hwnd> is not a valid
|
|
window handle, the return value is NULL.
|
|
|
|
Since top-level windows do not have an ID value, the return value of this
|
|
function is invalid if the <hwnd> parameter identifies a top-level window.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32GetDlgCtrlID(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
register PGETDLGCTRLID16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(GETDLGCTRLID16), parg16);
|
|
|
|
ul = GETINT16(GetDlgCtrlID(
|
|
HWND32(parg16->f1)
|
|
));
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
WORD GetDlgItemInt(<hDlg>, <nIDDlgItem>, <lpTranslated>, <bSigned>)
|
|
HWND <hDlg>;
|
|
int <nIDDlgItem>;
|
|
BOOL FAR *<lpTranslated>;
|
|
BOOL <bSigned>;
|
|
|
|
The %GetDlgItemInt% function translates the text of a control in the given
|
|
dialog box into an integer value. The %GetDlgItemInt% function retrieves the
|
|
text of the control identified by the <nIDDlgItem> parameter. It translates
|
|
the text by stripping any extra spaces at the beginning of the text and
|
|
converting decimal digits, stopping the translation when it reaches the end
|
|
of the text or encounters any nonnumeric character. If the <bSigned>
|
|
parameter is TRUE, %GetDlgItemInt% checks for a minus sign (-) at the
|
|
beginning of the text and translates the text into a signed number.
|
|
Otherwise, it creates an unsigned value.
|
|
|
|
%GetDlgItemInt% returns zero if the translated number is greater than 32,767
|
|
(for signed numbers) or 65,535 (for unsigned). When errors occur, such as
|
|
encountering nonnumeric characters and exceeding the given maximum,
|
|
%GetDlgItemInt% copies zero to the location pointed to by the <lpTranslated>
|
|
parameter. If there are no errors, <lpTranslated> receives a nonzero value.
|
|
If <lpTranslated> is NULL, %GetDlgItemInt% does not warn about errors.
|
|
%GetDlgItemInt% sends a WM_GETTEXT message to the control.
|
|
|
|
<hDlg>
|
|
Identifies the dialog box.
|
|
|
|
<nIDDlgItem>
|
|
Specifies the integer identifier of the dialog-box item to be
|
|
translated.
|
|
|
|
<lpTranslated>
|
|
Points to the Boolean variable that is to receive the
|
|
translated flag.
|
|
|
|
<bSigned>
|
|
Specifies whether the value to be retrieved is signed.
|
|
|
|
The return value specifies the translated value of the dialog-box item text.
|
|
Since zero is a valid return value, the <lpTranslated> parameter must be
|
|
used to detect errors. If a signed return value is desired, it should be
|
|
cast as an %int% type.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32GetDlgItemInt(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
BOOL t3;
|
|
register PGETDLGITEMINT16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(GETDLGITEMINT16), parg16);
|
|
|
|
ul = GETWORD16(GetDlgItemInt(
|
|
HWND32(parg16->f1),
|
|
WORD32(parg16->f2), // see comment in wu32getdlgitem
|
|
&t3,
|
|
BOOL32(parg16->f4)
|
|
));
|
|
|
|
PUTBOOL16(parg16->f3, t3);
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
int GetDlgItemText(<hDlg>, <nIDDlgItem>, <lpString>, <nMaxCount>)
|
|
HWND <hDlg>;
|
|
int <nIDDlgItem>;
|
|
LPSTR <lpString>;
|
|
int <nMaxCount>;
|
|
|
|
The %GetDlgItemText% function retrieves the caption or text associated with
|
|
a control in a dialog box. The %GetDlgItemText% function copies the text to
|
|
the location pointed to by the <lpString> parameter and returns a count of
|
|
the number of characters it copies.
|
|
|
|
%GetDlgItemText% sends a WM_GETTEXT message to the control.
|
|
|
|
<hDlg>
|
|
Identifies the dialog box that contains the control.
|
|
|
|
<nIDDlgItem>
|
|
Specifies the integer identifier of the dialog-box item whose
|
|
caption or text is to be retrieved.
|
|
|
|
<lpString>
|
|
Points to the buffer to receive the text.
|
|
|
|
<nMaxCount>
|
|
Specifies the maximum length (in bytes) of the string to be copied
|
|
to <lpString>. If the string is longer than <nMaxCount>, it is
|
|
truncated.
|
|
|
|
The return value specifies the actual number of characters copied to the
|
|
buffer. It is zero if no text is copied.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32GetDlgItemText(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
PSZ psz3;
|
|
VPVOID vp;
|
|
register PGETDLGITEMTEXT16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(GETDLGITEMTEXT16), parg16);
|
|
ALLOCVDMPTR(parg16->f3, parg16->f4, psz3);
|
|
vp = parg16->f3;
|
|
|
|
ul = GETINT16(GetDlgItemText(
|
|
HWND32(parg16->f1),
|
|
WORD32(parg16->f2), // see comment in wu32getdlgitem
|
|
psz3,
|
|
WORD32(parg16->f4)
|
|
));
|
|
|
|
// special case to keep common dialog structs in sync (see wcommdlg.c)
|
|
Check_ComDlg_pszptr(CURRENTPTD()->CommDlgTd, vp);
|
|
|
|
FLUSHVDMPTR(parg16->f3, strlen(psz3)+1, psz3);
|
|
FREEVDMPTR(psz3);
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
HWND GetNextDlgGroupItem(<hDlg>, <hCtl>, <bPrevious>)
|
|
HWND <hDlg>;
|
|
HWND <hCtl>;
|
|
BOOL <bPrevious>;
|
|
|
|
The %GetNextDlgGroupItem% function searches for the next (or previous)
|
|
control within a group of controls in the dialog box identified by the
|
|
<hDlg> parameter. A group of controls consists of one or more controls with
|
|
WS_GROUP style.
|
|
|
|
<hDlg>
|
|
Identifies the dialog box being searched.
|
|
|
|
<hCtl>
|
|
Identifies the control in the dialog box where the search starts.
|
|
|
|
<bPrevious>
|
|
Specifies how the function is to search the group of controls in the
|
|
dialog box. If the <bPrevious> parameter is zero, the function searches
|
|
for the previous control in the group. If -<bPrevious> is TRUE, the
|
|
function searches for the next control in the group.
|
|
|
|
The return value identifies the next or previous control in the group.
|
|
|
|
If the current item is the last item in the group and <bPrevious> is FALSE,
|
|
the %GetNextDlgGroupItem% function returns the window handle of the first
|
|
item in the group. If the current item is the first item in the group and
|
|
<bPrevious> is TRUE, %GetNextDlgGroupItem% returns the window handle of the
|
|
last item in the group.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32GetNextDlgGroupItem(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
register PGETNEXTDLGGROUPITEM16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(GETNEXTDLGGROUPITEM16), parg16);
|
|
|
|
ul = GETHWND16(GetNextDlgGroupItem(HWND32(parg16->f1),
|
|
HWND32(parg16->f2),
|
|
BOOL32(parg16->f3)));
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
HWND GetNextDlgTabItem(<hDlg>, <hCtl>, <bPrevious>)
|
|
HWND <hDlg>;
|
|
HWND <hCtl>;
|
|
BOOL <bPrevious>;
|
|
|
|
The %GetNextDlgTabItem% function obtains the handle of the first control
|
|
that has the WS_TABSTOP style that precedes (or follows) the control
|
|
identified by the <hCtl> parameter.
|
|
|
|
<hDlg>
|
|
Identifies the dialog box being searched.
|
|
|
|
<hCtl>
|
|
Identifies the control to be used as a starting point for the
|
|
search.
|
|
|
|
<bPrevious>
|
|
Specifies how the function is to search the dialog box. If the
|
|
<bPrevious> parameter is FALSE, the function searches for the previous
|
|
control in the dialog box. If <bPrevious> is TRUE, the function searches
|
|
for the next control in the dialog box. Identifies the control to be
|
|
used as a starting point for the search.
|
|
|
|
The return value identifies the previous (or next) control that has the
|
|
WS_TABSTOP style set.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32GetNextDlgTabItem(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
register PGETNEXTDLGTABITEM16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(GETNEXTDLGTABITEM16), parg16);
|
|
|
|
ul = GETHWND16(GetNextDlgTabItem(HWND32(parg16->f1),
|
|
HWND32(parg16->f2),
|
|
BOOL32(parg16->f3)));
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
BOOL IsDialogMessage(<hDlg>, <lpMsg>)
|
|
HWND <hDlg>;
|
|
LPMSG <lpMsg>;
|
|
|
|
The %IsDialogMessage% function determines whether the given message is
|
|
intended for the modeless dialog box specified by the <hDlg> parameter, and
|
|
automatically processes the message if it is. When the %IsDialogMessage%
|
|
function processes a message, it checks for keyboard messages and converts
|
|
them into selection commands for the corresponding dialog box. For example,
|
|
the ^TAB^ key selects the next control or group of controls, and the ^DOWN^
|
|
key selects the next control in a group.
|
|
|
|
If a message is processed by %IsDialogMessage%, it must not be passed to the
|
|
%TranslateMessage% or %DispatchMessage% function. This is because
|
|
%IsDialogMessage% performs all necessary translating and dispatching of
|
|
messages.
|
|
|
|
%IsDialogMessage% sends WM_GETDLGCODE messages to the dialog function to
|
|
determine which keys should be processed.
|
|
|
|
<hDlg>
|
|
Identifies the dialog box.
|
|
|
|
<lpMsg>
|
|
Points to an %MSG% structure that contains the message to
|
|
be checked.
|
|
|
|
The return value specifies whether or not the given message has been
|
|
processed. It is TRUE if the message has been processed. Otherwise, it is
|
|
FALSE.
|
|
|
|
Although %IsDialogMessage% is intended for modeless dialog boxes, it can be
|
|
used with any window that contains controls to provide the same keyboard
|
|
selection as in a dialog box.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32IsDialogMessage(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
MSG t2;
|
|
register PISDIALOGMESSAGE16 parg16;
|
|
MSGPARAMEX mpex;
|
|
PMSG16 pMsg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(ISDIALOGMESSAGE16), parg16);
|
|
GETMISCPTR(parg16->f2, pMsg16);
|
|
|
|
mpex.Parm16.WndProc.hwnd = pMsg16->hwnd;
|
|
mpex.Parm16.WndProc.wMsg = pMsg16->message;
|
|
mpex.Parm16.WndProc.wParam = pMsg16->wParam;
|
|
mpex.Parm16.WndProc.lParam = pMsg16->lParam;
|
|
mpex.iMsgThunkClass = WOWCLASS_WIN16;
|
|
|
|
ThunkMsg16(&mpex);
|
|
|
|
GETFRAMEPTR(((PTD)CURRENTPTD())->vpStack, pFrame);
|
|
GETARGPTR(pFrame, sizeof(ISDIALOGMESSAGE16), parg16);
|
|
|
|
t2.message = mpex.uMsg;
|
|
t2.wParam = mpex.uParam;
|
|
t2.lParam = mpex.lParam;
|
|
t2.hwnd = HWND32(FETCHWORD(pMsg16->hwnd));
|
|
t2.time = FETCHLONG(pMsg16->time);
|
|
t2.pt.x = FETCHSHORT(pMsg16->pt.x);
|
|
t2.pt.y = FETCHSHORT(pMsg16->pt.y);
|
|
|
|
ul = GETBOOL16(IsDialogMessage(
|
|
HWND32(parg16->f1),
|
|
&t2
|
|
));
|
|
|
|
if (MSG16NEEDSTHUNKING(&mpex)) {
|
|
mpex.uMsg = t2.message;
|
|
mpex.uParam = t2.wParam;
|
|
mpex.lParam = t2.lParam;
|
|
(mpex.lpfnUnThunk16)(&mpex);
|
|
}
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
WORD IsDlgButtonChecked(<hDlg>, <nIDButton>)
|
|
HWND <hDlg>;
|
|
int <nIDButton>;
|
|
|
|
The %IsDlgButtonChecked% function determines whether a button control has a
|
|
checkmark next to it, and whether a three-state button control is grayed,
|
|
checked, or neither. The %IsDlgButtonChecked% function sends a BM_GETCHECK
|
|
message to the button control.
|
|
|
|
<hDlg>
|
|
Identifies the dialog box that contains the button control.
|
|
|
|
<nIDButton>
|
|
Specifies the integer identifier of the button control.
|
|
|
|
The return value specifies the outcome of the function. It is nonzero if the
|
|
given control has a checkmark next to it. Otherwise, it is zero. For
|
|
three-state buttons, the return value is 2 if the button is grayed, 1 if the
|
|
button has a checkmark next to it, and zero otherwise.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32IsDlgButtonChecked(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
register PISDLGBUTTONCHECKED16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(ISDLGBUTTONCHECKED16), parg16);
|
|
|
|
ul = GETWORD16(IsDlgButtonChecked(
|
|
HWND32(parg16->f1),
|
|
WORD32(parg16->f2)
|
|
));
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
void MapDialogRect(<hDlg>, <lpRect>)
|
|
HDLG <hDlg>;
|
|
LPRECT <lpRect>;
|
|
|
|
The %MapDialogRect% function converts the dialog-box units given in the
|
|
<lpRect> parameter to screen units. Dialog-box units are stated in terms of
|
|
the current dialog base unit derived from the average width and height of
|
|
characters in the system font. One horizontal unit is one-fourth of the
|
|
dialog base width unit, and one vertical unit is one-eighth of the dialog
|
|
base height unit. The %GetDialogBaseUnits% function returns the dialog base
|
|
units in pixels.
|
|
|
|
The %MapDialogRect% function replaces the dialog-box units in <lpRect> with
|
|
screen units (pixels), so that the rectangle can be used to create a dialog
|
|
box or position a control within a box.
|
|
|
|
<hDlg>
|
|
Identifies a dialog box.
|
|
|
|
<lpRect>
|
|
Points to a %RECT% structure that contains the dialog-box
|
|
coordinates to be converted.
|
|
|
|
This function does not return a value.
|
|
|
|
The <hDlg> parameter must be created by using the %CreateDialog% or
|
|
%DialogBox% function.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32MapDialogRect(PVDMFRAME pFrame)
|
|
{
|
|
RECT t2;
|
|
register PMAPDIALOGRECT16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(MAPDIALOGRECT16), parg16);
|
|
WOW32VERIFY(GETRECT16(parg16->f2, &t2));
|
|
|
|
MapDialogRect(
|
|
HWND32(parg16->f1),
|
|
&t2
|
|
);
|
|
|
|
PUTRECT16(parg16->f2, &t2);
|
|
FREEARGPTR(parg16);
|
|
RETURN(0);
|
|
}
|
|
|
|
|
|
/*++
|
|
int MessageBox(<hwndParent>, <lpText>, <lpCaption>, <wType>)
|
|
HWND <hwndParent>;
|
|
LPSTR <lpText>;
|
|
LPSTR <lpCaption>;
|
|
WORD <wType>;
|
|
|
|
The %MessageBox% function creates and displays a window that contains an
|
|
application-supplied message and caption, plus any combination of the
|
|
predefined icons and push buttons described in the following list.
|
|
|
|
<hwndParent>
|
|
Identifies the window that owns the message box.
|
|
|
|
<lpText>
|
|
Points to a null-terminated string containing the message to be
|
|
displayed.
|
|
|
|
<lpCaption>
|
|
Points to a null-terminated string to be used for the dialog-box
|
|
caption. If the <lpCaption> parameter is NULL, the default caption Error
|
|
is used.
|
|
|
|
<wType>
|
|
Specifies the contents of the dialog box. It can be any
|
|
combination of the following values:
|
|
|
|
MB_ABORTRETRYIGNORE
|
|
Message box contains three push buttons: Abort, Retry, and Ignore.
|
|
|
|
MB_APPLMODAL
|
|
The user must respond to the message box before continuing work in the
|
|
window identified by the <hwndParent> parameter. However, the user can
|
|
move to the windows of other applications and work in those windows.
|
|
MB_APPLMODAL is the default if neither MB_SYSTEMMODAL nor MB_TASKMODAL
|
|
are specified.
|
|
|
|
MB_DEFBUTTON1
|
|
First button is the default. Note that the first button is always the
|
|
default unless MB_DEFBUTTON2 or MB_DEFBUTTON3 is specified.
|
|
|
|
MB_DEFBUTTON2
|
|
Second button is the default.
|
|
|
|
MB_DEFBUTTON3
|
|
Third button is the default.
|
|
|
|
MB_ICONASTERISK
|
|
Same as MB_ICONINFORMATION.
|
|
|
|
MB_ICONEXCLAMATION
|
|
An exclamation-point icon appears in the message box.
|
|
|
|
MB_ICONHAND
|
|
Same as MB_ICONSTOP.
|
|
|
|
MB_ICONINFORMATION
|
|
An icon consisting of a lowercase i in a circle appears in the message
|
|
box.
|
|
|
|
MB_ICONQUESTION
|
|
A question-mark icon appears in the message box.
|
|
|
|
MB_ICONSTOP
|
|
A stop sign icon appears in the message box.
|
|
|
|
MB_OK
|
|
Message box contains one push button: OK.
|
|
|
|
MB_OKCANCEL
|
|
Message box contains two push buttons: OK and Cancel.
|
|
|
|
MB_RETRYCANCEL
|
|
Message box contains two push buttons: Retry and Cancel.
|
|
|
|
MB_SYSTEMMODAL
|
|
All applications are suspended until the user responds to the message
|
|
box. Unless the application specifies MB_ICONHAND, the message box does
|
|
not become modal until after it is created; consequently, the parent
|
|
window and other windows continue to receive messages resulting from its
|
|
activation. System-modal message boxes are used to notify the user of
|
|
serious, potentially damaging errors that require immediate attention
|
|
(for example, running out of memory).
|
|
|
|
MB_TASKMODAL
|
|
Same as MB_APPMODAL except that all the top-level windows belonging to
|
|
the current task are disabled if the <hwndOwner> parameter is NULL. This
|
|
flag should be used when the calling application or library does not
|
|
have a window handle available, but still needs to prevent input to
|
|
other windows in the current application without suspending other
|
|
applications.
|
|
|
|
MB_YESNO
|
|
Message box contains two push buttons: Yes and No.
|
|
|
|
MB_YESNOCANCEL
|
|
Message box contains three push buttons: Yes, No, and Cancel.
|
|
|
|
The return value specifies the outcome of the function. It is zero if there
|
|
is not enough memory to create the message box. Otherwise, it is one of the
|
|
following menu-item values returned by the dialog box:
|
|
|
|
IDABORT Abort button pressed.
|
|
IDCANCEL Cancel button pressed.
|
|
IDIGNORE Ignore button pressed.
|
|
IDNO No button pressed.
|
|
IDOK OK button pressed.
|
|
IDRETRY Retry button pressed.
|
|
IDYES Yes button pressed.
|
|
|
|
If a message box has a Cancel button, the IDCANCEL value will be returned if
|
|
either the ^ESCAPE^ key or Cancel button is pressed. If the message box has
|
|
no Cancel button, pressing the ^ESCAPE^ key has no effect.
|
|
|
|
When a system-modal message box is created to indicate that the system is
|
|
low on memory, the strings passed as the <lpText> and <lpCaption> parameters
|
|
should not be taken from a resource file, since an attempt to load the
|
|
resource may fail.
|
|
|
|
When an application calls the %MessageBox% function and specifies the
|
|
MB_ICONHAND and MB_SYSTEMMODAL flags for the <wType> parameter, Windows will
|
|
display the resulting message box regardless of available memory. When these
|
|
flags are specified, Windows limits the length of the message-box text to
|
|
one line.
|
|
|
|
If a message box is created while a dialog box is present, use the handle of
|
|
the dialog box as the <hwndParent> parameter. The <hwndParent> parameter
|
|
should not identify a child window, such as a dialog-box control.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32MessageBox(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
UINT uType;
|
|
PSZ psz2;
|
|
PSZ psz3;
|
|
register PMESSAGEBOX16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(MESSAGEBOX16), parg16);
|
|
GETPSZPTR(parg16->f2, psz2);
|
|
GETPSZPTR(parg16->f3, psz3);
|
|
|
|
// WHISTLER RAID BUG #348251
|
|
// A messagebox posted by artgalry.exe would remain behind autosketches window
|
|
// after it was invoked. In order to move the messagebox to the foreground we
|
|
// need to set its MB_SETFOREGROUND bit. Since this will be applied to all
|
|
// 16bit MessageBox's we will only set this bit if the MessageBox does not
|
|
// have the MB_NOFOCUS bit. This fix works in conjunction with the
|
|
// GACF2_GIVEUPFOREGROUND compat flag.
|
|
uType = (UINT)parg16->f4;
|
|
if(!(uType & MB_NOFOCUS))
|
|
{
|
|
uType |= MB_SETFOREGROUND;
|
|
}
|
|
|
|
ul = GETINT16(MessageBox(
|
|
HWND32(parg16->f1),
|
|
psz2,
|
|
psz3,
|
|
uType
|
|
));
|
|
|
|
FREEPSZPTR(psz2);
|
|
FREEPSZPTR(psz3);
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
|
|
/*++
|
|
void SetDlgItemInt(<hDlg>, <nIDDlgItem>, <wValue>, <bSigned>)
|
|
HWND <hDlg>;
|
|
int <nIDDlgItem>;
|
|
WORD <wValue>;
|
|
BOOL <bSigned>;
|
|
|
|
The %SetDlgItemInt% function sets the text of a control in the given dialog
|
|
box to the string that represents the integer value given by the <wValue>
|
|
parameter. The %SetDlgItemInt% function converts <wValue> to a string that
|
|
consists of decimal digits, and then copies the string to the control. If
|
|
the <bSigned> parameter is TRUE, <wValue> is assumed to be signed. If
|
|
<wValue> is signed and less than zero, the function places a minus sign
|
|
before the first digit in the string.
|
|
|
|
%SetDlgItemInt% sends a WM_SETTEXT message to the given control.
|
|
|
|
<hDlg>
|
|
Identifies the dialog box that contains the control.
|
|
|
|
<nIDDlgItem>
|
|
Specifies the control to be modified.
|
|
|
|
<wValue>
|
|
Specifies the value to be set.
|
|
|
|
<bSigned>
|
|
Specifies whether or not the integer value is signed.
|
|
|
|
This function does not return a value.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32SetDlgItemInt(PVDMFRAME pFrame)
|
|
{
|
|
HWND hwnd;
|
|
register PSETDLGITEMINT16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(SETDLGITEMINT16), parg16);
|
|
|
|
hwnd = HWND32(parg16->f1);
|
|
|
|
SetDlgItemInt(
|
|
hwnd,
|
|
WORD32(parg16->f2), // see comment in wu32getdlgitem
|
|
(parg16->f4) ? INT32(parg16->f3) : WORD32(parg16->f3),
|
|
BOOL32(parg16->f4)
|
|
);
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(0);
|
|
}
|
|
|
|
|
|
/*++
|
|
void SetDlgItemText(<hDlg>, <nIDDlgItem>, <lpString>)
|
|
HWND <hDlg>;
|
|
int <nIDDlgItem>;
|
|
LPSTR <lpString>;
|
|
|
|
The %SetDlgItemText% function sets the caption or text of a control in the
|
|
dialog box specified by the <hDlg> parameter. The %SetDlgItemText% function
|
|
sends a WM_SETTEXT message to the given control.
|
|
|
|
<hDlg>
|
|
Identifies the dialog box that contains the control.
|
|
|
|
<nIDDlgItem>
|
|
Specifies the control whose text is to be set.
|
|
|
|
<lpString>
|
|
Points to the null-terminated string that is to be copied to the
|
|
control.
|
|
|
|
This function does not return a value.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32SetDlgItemText(PVDMFRAME pFrame)
|
|
{
|
|
HWND hwnd;
|
|
PSZ psz3;
|
|
register PSETDLGITEMTEXT16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(SETDLGITEMTEXT16), parg16);
|
|
GETPSZPTR(parg16->f3, psz3);
|
|
|
|
hwnd = HWND32(parg16->f1);
|
|
|
|
if (NULL != psz3) {
|
|
AddParamMap((DWORD)psz3, FETCHDWORD(parg16->f3));
|
|
}
|
|
|
|
SetDlgItemText(
|
|
hwnd,
|
|
WORD32(parg16->f2), // see comment in wu32getdlgitem
|
|
psz3
|
|
);
|
|
|
|
if (NULL != psz3) {
|
|
DeleteParamMap((DWORD)psz3, PARAM_32, NULL);
|
|
}
|
|
|
|
|
|
FREEPSZPTR(psz3);
|
|
FREEARGPTR(parg16);
|
|
RETURN(0);
|
|
}
|
|
|
|
|
|
/*++
|
|
No REF header file
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32SysErrorBox(PVDMFRAME pFrame)
|
|
{
|
|
DWORD dwExitCode;
|
|
PSZ pszText;
|
|
PSZ pszCaption;
|
|
register PSYSERRORBOX16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(SYSERRORBOX16), parg16);
|
|
|
|
// WARNING - If things go wrong during boot, this routine can be called in
|
|
// real mode (v86 mode). So be very careful which GetPtr routines you
|
|
// use to convert from 16:16 to flat pointers
|
|
|
|
pszText = WOWGetVDMPointer(FETCHDWORD(parg16->vpszText),0,fWowMode);
|
|
pszCaption = WOWGetVDMPointer(FETCHDWORD(parg16->vpszCaption),0,fWowMode);
|
|
|
|
LOGDEBUG(5,(" SYSERRORBOX: %s\n", pszText));
|
|
|
|
dwExitCode = WOWSysErrorBox(
|
|
pszCaption,
|
|
pszText,
|
|
parg16->sBtn1,
|
|
parg16->sBtn2,
|
|
parg16->sBtn3
|
|
);
|
|
|
|
FREEPSZPTR(pszCaption);
|
|
FREEPSZPTR(pszText);
|
|
FREEARGPTR(parg16);
|
|
RETURN(dwExitCode);
|
|
}
|