Leaked source code of windows server 2003
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.
 
 
 
 
 
 

2187 lines
68 KiB

/*++
*
* WOW v1.0
*
* Copyright (c) 1991, Microsoft Corporation
*
* WUMSG.C
* WOW32 16-bit User Message API support
*
* History:
* Created 07-Mar-1991 by Jeff Parsons (jeffpar)
--*/
#include "precomp.h"
#pragma hdrstop
MODNAME(wumsg.c);
extern HANDLE hmodWOW32;
// SendDlgItemMessage cache
HWND hdlgSDIMCached = NULL ;
BOOL fWhoCalled = FALSE;
// DDE bit used in GetMessage and PeekMessage
#define fAckReq 0x8000
#define fRelease 0x2000
/*++
BOOL CallMsgFilter(<lpMsg>, <nCode>)
LPMSG <lpMsg>;
int <nCode>;
The %CallMsgFilter% function passes the given message and code to the
current message filter function. The message filter function is an
application-specified function that examines and modifies all messages. An
application specifies the function by using the %SetWindowsHook% function.
<lpMsg>
Points to an %MSG% structure that contains the message to be
filtered.
<nCode>
Specifies a code used by the filter function to determine how to
process the message.
The return value specifies the state of message processing. It is FALSE if
the message should be processed. It is TRUE if the message should not be
processed further.
The %CallMsgFilter% function is usually called by Windows to let
applications examine and control the flow of messages during internal
processing in menus and scroll bars or when moving or sizing a window.
Values given for the <nCode> parameter must not conflict with any of the
MSGF_ and HC_ values passed by Windows to the message filter function.
--*/
ULONG FASTCALL WU32CallMsgFilter(PVDMFRAME pFrame)
{
INT f2;
ULONG ul;
MSG t1;
VPMSG16 vpf1;
register PCALLMSGFILTER16 parg16;
MSGPARAMEX mpex;
GETARGPTR(pFrame, sizeof(CALLMSGFILTER16), parg16);
vpf1 = (VPMSG16)(parg16->f1);
f2 = INT32(parg16->f2);
getmsg16(vpf1, &t1, &mpex);
// Note: getmsg16 may have caused 16-bit memory movement
FREEARGPTR(pFrame);
FREEARGPTR(parg16);
BlockWOWIdle(TRUE);
ul = GETBOOL16(CallMsgFilter(&t1, f2));
// Note: Call to CallMsgFilter may have caused 16-bit memory to move
BlockWOWIdle(FALSE);
// we need to free the struct ret'd by PackDDElParam in the getmsg16 call
// (actually the call is made in ThunkWMMsg16() which is called by getmsg16)
if((t1.message >= WM_DDE_FIRST) && (t1.message <= WM_DDE_LAST)) {
if(t1.message == WM_DDE_ACK ||
t1.message == WM_DDE_DATA ||
t1.message == WM_DDE_POKE ||
t1.message == WM_DDE_ADVISE ) {
// make sure this isn't in response to an initiate message
if(!WI32DDEInitiate((HWND16) mpex.Parm16.WndProc.hwnd)) {
FreeDDElParam(t1.message, t1.lParam);
}
}
}
FREEMSG16(vpf1, &t1);
FREEARGPTR(parg16);
RETURN(ul);
}
/*++
LONG CallWindowProc(<lpPrevWndFunc>, <hwnd>, <wMsg>, <wParam>, <lParam>)
FARPROC <lpPrevWndFunc>;
HWND <hwnd>;
WORD <wMsg>;
WORD <wParam>;
DWORD <lParam>;
The %CallWindowProc% function passes message information to the function
specified by the <lpPrevWndFunc> parameter. The %CallWindowProc% function is
used for window subclassing. Normally, all windows with the same class share
the same window function. A subclass is a window or set of windows belonging
to the same window class whose messages are intercepted and processed by
another function (or functions) before being passed to the window function
of that class.
The %SetWindowLong% function creates the subclass by changing the window
function associated with a particular window, causing Windows to call the
new window function instead of the previous one. Any messages not processed
by the new window function must be passed to the previous window function by
calling %CallWindowProc%. This allows a chain of window functions to be
created.
<lpPrevWndFunc>
Is the procedure-instance address of the previous window function.
<hwnd>
Identifies the window that receives the message.
<wMsg>
Specifies the message number.
<wParam>
Specifies additional message-dependent information.
<lParam>
Specifies additional message-dependent information.
The return value specifies the result of the message processing. The
possible return values depend on the message sent.
--*/
ULONG FASTCALL WU32CallWindowProc(PVDMFRAME pFrame)
{
ULONG ul;
PARM16 Parm16;
register PCALLWINDOWPROC16 parg16;
WORD f2, f3, f4;
LONG f5;
DWORD Proc16;
DWORD Proc32;
INT iMsgThunkClass = 0;
ul = FALSE;
GETARGPTR(pFrame, sizeof(CALLWINDOWPROC16), parg16);
Proc16 = DWORD32(parg16->f1);
f2 = parg16->f2;
f3 = WORD32(parg16->f3);
f4 = WORD32(parg16->f4);
f5 = LONG32(parg16->f5);
Proc32 = IsThunkWindowProc(Proc16, &iMsgThunkClass);
// Note: IsThunkWindowProc may have caused 16-bit memory movement
FREEARGPTR(pFrame);
FREEARGPTR(parg16);
if (Proc32) {
HWND hwnd;
UINT uMsgNew;
UINT uParamNew;
LONG lParamNew;
MSGPARAMEX mpex;
mpex.Parm16.WndProc.hwnd = f2;
mpex.Parm16.WndProc.wMsg = f3;
mpex.Parm16.WndProc.wParam = f4;
mpex.Parm16.WndProc.lParam = f5;
mpex.iMsgThunkClass = iMsgThunkClass;
if (hwnd = ThunkMsg16(&mpex)) {
// Note: ThunkMsg16 may have caused 16-bit memory movement
// But: we haven't refreshed them since freeing after IsThunkWindowProc above.
// FREEARGPTR(pFrame);
// FREEARGPTR(parg16);
uMsgNew = mpex.uMsg;
uParamNew = mpex.uParam;
lParamNew = mpex.lParam;
//
// see comment in IsMDIChild()
//
if ((uMsgNew == WM_CREATE || uMsgNew == WM_NCCREATE) && iMsgThunkClass == WOWCLASS_MDICLIENT) {
FinishThunkingWMCreateMDI16(lParamNew,
(LPCLIENTCREATESTRUCT)((LPCREATESTRUCT)lParamNew + 1));
}
BlockWOWIdle(TRUE);
ul = CallWindowProc((WNDPROC)Proc32, hwnd, uMsgNew,
uParamNew, lParamNew);
BlockWOWIdle(FALSE);
if ((uMsgNew == WM_CREATE || uMsgNew == WM_NCCREATE) && iMsgThunkClass == WOWCLASS_MDICLIENT) {
StartUnThunkingWMCreateMDI16(lParamNew); // does nothing
}
if (MSG16NEEDSTHUNKING(&mpex)) {
mpex.lReturn = ul;
(mpex.lpfnUnThunk16)(&mpex);
ul = mpex.lReturn;
}
}
}
else {
Parm16.WndProc.hwnd = f2;
Parm16.WndProc.wMsg = f3;
Parm16.WndProc.wParam = f4;
Parm16.WndProc.lParam = f5;
Parm16.WndProc.hInst = (WORD)GetWindowLong(HWND32(f2), GWL_HINSTANCE);
CallBack16(RET_WNDPROC, &Parm16, VPFN32(Proc16), (PVPVOID)&ul);
}
FREEARGPTR(parg16);
RETURN(ul);
}
/*++
LONG DefDlgProc(<hDlg>, <wMsg>, <wParam>, <lParam>)
HWND <hDlg>;
WORD <wMsg>;
WORD <wParam>;
DWORD <lParam>;
The %DefDlgProc% function provides default processing for any Windows
messages that a dialog box with a private window class does not process.
All window messages that are not explicitly processed by the window function
must be passed to the %DefDlgProc% function, not the %DefWindowProc%
function. This ensures that all messages not handled by their private window
procedure will be handled properly.
<hDlg>
Identifies the dialog box.
<wMsg>
Specifies the message number.
<wParam>
Specifies 16 bits of additional message-dependent information.
<lParam>
Specifies 32 bits of additional message-dependent information.
The return value specifies the result of the message processing and depends
on the actual message sent.
The source code for the %DefDlgProc% function is provided on the SDK disks.
An application creates a dialog box by calling one of the following
functions:
%CreateDialog%
Creates a modeless dialog box.
%CreateDialogIndirect%
Creates a modeless dialog box.
%CreateDialogIndirectParam%
Creates a modeless dialog box and passes data to it when it is created.
%CreateDialogParam%
Creates a modeless dialog box and passes data to it when it is created.
%DialogBox%
Creates a modal dialog box.
%DialogBoxIndirect%
Creates a modal dialog box.
%DialogBoxIndirectParam%
Creates a modal dialog box and passes data to it when it is created.
%DialogBoxParam%
Creates a modal dialog box and passes data to it when it is created.
--*/
ULONG FASTCALL WU32DefDlgProc(PVDMFRAME pFrame)
{
HWND hdlg;
MSGPARAMEX mpex;
register PDEFDLGPROC16 parg16;
GETARGPTR(pFrame, sizeof(DEFDLGPROC16), parg16);
mpex.lReturn = 0;
mpex.Parm16.WndProc.hwnd = parg16->f1;
mpex.Parm16.WndProc.wMsg = WORD32(parg16->f2);
mpex.Parm16.WndProc.wParam = WORD32(parg16->f3);
mpex.Parm16.WndProc.lParam = LONG32(parg16->f4);
mpex.iMsgThunkClass = 0;
if (hdlg = ThunkMsg16(&mpex)) {
// Note: ThunkMsg16 may have caused 16-bit memory movement
FREEARGPTR(pFrame);
FREEARGPTR(parg16);
BlockWOWIdle(TRUE);
mpex.lReturn = DefDlgProc(hdlg, mpex.uMsg, mpex.uParam, mpex.lParam);
BlockWOWIdle(FALSE);
if (MSG16NEEDSTHUNKING(&mpex)) {
(mpex.lpfnUnThunk16)(&mpex);
}
}
FREEARGPTR(parg16);
RETURN((ULONG)mpex.lReturn);
}
/*++
LONG DefFrameProc(<hwnd>, <hwndMDIClient>, <wMsg>, <wParam>, <lParam>)
HWND <hwnd>;
HWND <hwndMDIClient>;
WORD <wMsg>;
WORD <wParam>;
DWORD <lParam>;
The %DefFrameProc% function provides default processing for any Windows
messages that the window function of a multiple document interface (MDI)
frame window does not process. All window messages that are not explicitly
processed by the window function must be passed to the %DefFrameProc%
function, not the %DefWindowProc% function.
<hwnd>
Identifies the MDI frame window.
<hwndMDIClient>
Identifies the MDI client window.
<wMsg>
Specifies the message number.
<wParam>
Specifies 16 bits of additional message-dependent information.
<lParam>
Specifies 32 bits of additional message-dependent information.
The return value specifies the result of the message processing and depends
on the actual message sent. If the <hwndMDIClient> parameter is NULL, the
return value is the same as for the %DefWindowProc% function.
Normally, when an application's window procedure does not handle a message,
it passes the message to the %DefWindowProc% function, which processes the
message. MDI applications use the %fDefFrameProc% and %DefMDIChildProc%
functions instead of %DefWindowProc% to provide default message processing.
All messages that an application would normally pass to %DefWindowProc%
(such as nonclient messages and WM_SETTEXT) should be passed to
%DefFrameProc% instead. In addition to these, %DefFrameProc% also handles
the following messages:
WM_COMMAND
The frame window of an MDI application receives the WM_COMMAND message
to activate a particular MDI child window. The window ID accompanying
this message will be the ID of the MDI child window assigned by Windows,
starting with the first ID specified by the application when it created
the MDI client window. This value of the first ID must not conflict with
menu-item IDs.
WM_MENUCHAR
When the ^ALTHYPHEN^ key is pressed, the control menu of the active MDI
child window will be selected.
WM_SETFOCUS
%DefFrameProc% passes focus on to the MDI client, which in turn passes
the focus on to the active MDI child window.
WM_SIZE
If the frame window procedure passes this message to %DefFrameProc%, the
MDI client window will be resized to fit in the new client area. If the
frame window procedure sizes the MDI client to a different size, it
should not pass the message to %DefWindowProc%.
--*/
ULONG FASTCALL WU32DefFrameProc(PVDMFRAME pFrame)
{
HWND hwnd, hwnd2;
MSGPARAMEX mpex;
register PDEFFRAMEPROC16 parg16;
GETARGPTR(pFrame, sizeof(DEFFRAMEPROC16), parg16);
mpex.lReturn = 0;
mpex.Parm16.WndProc.hwnd = parg16->f1;
mpex.Parm16.WndProc.wMsg = WORD32(parg16->f3);
mpex.Parm16.WndProc.wParam = WORD32(parg16->f4);
mpex.Parm16.WndProc.lParam = LONG32(parg16->f5);
mpex.iMsgThunkClass = 0;
hwnd2 = HWND32(parg16->f2);
if (hwnd = ThunkMsg16(&mpex)) {
// Note: ThunkMsg16 may have caused 16-bit memory movement
FREEARGPTR(pFrame);
FREEARGPTR(parg16);
if (mpex.uMsg == WM_CLIENTSHUTDOWN &&
CURRENTPTD()->dwWOWCompatFlagsEx & WOWCFEX_IGNORECLIENTSHUTDOWN) {
//
// TurboCAD picks up an uninitialized stack variable as the
// message number to pass to DefFrameProc. In NT 3.51 it
// got 0x907 so the call was a NOP. In NT 4.0, because we
// now save FS and GS in wow16call, they pick up the x86
// flat FS, 0x3b, which also happens to be WM_CLIENTSHUTDOWN
// on NT and Win95, an undocumented message. DefFrameProc
// passes the message to DefWindowProc, which does some
// shutdown related processing which causes TurboCAD to fault
// soon thereafter.
//
// We considered renumbering WM_CLIENTSHUTDOWN, but Win95 uses
// it as well and some apps may have reverse-engineered the
// value 3b and depend on seeing the message.
//
// So instead we eat the call to DefFrameProc here under
// a compatibility bit.
// -- DaveHart 31-May-96
//
mpex.lReturn = 0;
} else {
BlockWOWIdle(TRUE);
mpex.lReturn = DefFrameProc(hwnd, hwnd2,
mpex.uMsg, mpex.uParam, mpex.lParam);
BlockWOWIdle(FALSE);
}
if (MSG16NEEDSTHUNKING(&mpex)) {
(mpex.lpfnUnThunk16)(&mpex);
}
}
FREEARGPTR(parg16);
RETURN((ULONG)mpex.lReturn);
}
/*++
LONG DefMDIChildProc(<hwnd>, <wMsg>, <wParam>, <lParam>)
HWND <hwnd>;
WORD <wMsg>;
WORD <wParam>;
DWORD <lParam>;
The %DefMDIChildProc% function provides default processing for any Windows
messages that the window function of a multiple document interface (MDI)
child window does not process. All window messages that are not explicitly
processed by the window function must be passed to the %DefMDIChildProc%
function, not the %DefWindowProc% function.
<hwnd>
Identifies the MDI child window.
<wMsg>
Specifies the message number.
<wParam>
Specifies 16 bits of additional message-dependent information.
<lParam>
Specifies 32 bits of additional message-dependent information.
The return value specifies the result of the message processing and depends
on the actual message sent.
This function assumes that the parent of the window identified by the <hwnd>
parameter was created with the MDICLIENT class.
Normally, when an application's window procedure does not handle a message,
it passes the message to the %DefWindowProc% function, which processes the
message. MDI applications use the %DefFrameProc% and %DefMDIChildProc%
functions instead of %DefWindowProc% to provide default message processing.
All messages that an application would normally pass to %DefWindowProc%
(such as nonclient messages and WM_SETTEXT) should be passed to
%DefMDIChildProc% instead. In addition to these, %DefMDIChildProc% also
handles the following messages:
WM_CHILDACTIVATE
Performs activation processing when child windows are sized, moved, or
shown. This message must be passed.
WM_GETMINMAXINFO
Calculates the size of a maximized MDI child window based on the current
size of the MDI client window.
WM_MENUCHAR
Sends the key to the frame window.
WM_MOVE
Recalculates MDI client scroll bars, if they are present.
WM_SETFOCUS
Activates the child window if it is not the active MDI child.
WM_SIZE
Performs necessary operations when changing the size of a window,
especially when maximizing or restoring an MDI child window. Failing to
pass this message to %DefMDIChildProc% will produce highly undesirable
results.
WM_SYSCOMMAND
Also handles the next window command.
--*/
ULONG FASTCALL WU32DefMDIChildProc(PVDMFRAME pFrame)
{
HWND hwnd;
register PDEFMDICHILDPROC16 parg16;
MSGPARAMEX mpex;
GETARGPTR(pFrame, sizeof(DEFMDICHILDPROC16), parg16);
mpex.lReturn = 0;
mpex.Parm16.WndProc.hwnd = parg16->f1;
mpex.Parm16.WndProc.wMsg = WORD32(parg16->f2);
mpex.Parm16.WndProc.wParam = WORD32(parg16->f3);
mpex.Parm16.WndProc.lParam = LONG32(parg16->f4);
mpex.iMsgThunkClass = 0;
if (hwnd = ThunkMsg16(&mpex)) {
// Note: ThunkMsg16 may have caused 16-bit memory movement
FREEARGPTR(pFrame);
FREEARGPTR(parg16);
BlockWOWIdle(TRUE);
mpex.lReturn = DefMDIChildProc(hwnd, mpex.uMsg, mpex.uParam,
mpex.lParam);
BlockWOWIdle(FALSE);
if (MSG16NEEDSTHUNKING(&mpex)) {
(mpex.lpfnUnThunk16)(&mpex);
}
}
FREEARGPTR(parg16);
RETURN((ULONG)mpex.lReturn);
}
/*++
LONG DefWindowProc(<hwnd>, <wMsg>, <wParam>, <lParam>)
HWND <hwnd>;
WORD <wMsg>;
WORD <wParam>;
DWORD <lParam>;
The %DefWindowProc% function calls the default window procedure. The
default window procedure provides default processing for any window messages
that an application does not process. This function is used to ensure that
every message is processed. It should be called with the same parameters as
those received by the window procedure.
<hwnd>
Identifies the window that received the message.
<wMsg>
Specifies the message.
<wParam>
Specifies 16 bits of additional message-dependent information.
<lParam>
Specifies 32 bits of additional message-dependent information.
The return value is dependent on the message that was passed to this
function.
--*/
ULONG FASTCALL WU32DefWindowProc(PVDMFRAME pFrame)
{
HWND hwnd;
register PDEFWINDOWPROC16 parg16;
MSGPARAMEX mpex;
GETARGPTR(pFrame, sizeof(DEFWINDOWPROC16), parg16);
mpex.lReturn = 0;
mpex.Parm16.WndProc.hwnd = parg16->hwnd;
mpex.Parm16.WndProc.wMsg = WORD32(parg16->wMsg);
mpex.Parm16.WndProc.wParam = WORD32(parg16->wParam);
mpex.Parm16.WndProc.lParam = LONG32(parg16->lParam);
mpex.iMsgThunkClass = 0;
if (hwnd = ThunkMsg16(&mpex)) {
// Note: ThunkMsg16 may have caused 16-bit memory movement
FREEARGPTR(pFrame);
FREEARGPTR(parg16);
BlockWOWIdle(TRUE);
mpex.lReturn = DefWindowProc(hwnd, mpex.uMsg, mpex.uParam, mpex.lParam);
BlockWOWIdle(FALSE);
if (MSG16NEEDSTHUNKING(&mpex)) {
(mpex.lpfnUnThunk16)(&mpex);
}
}
FREEARGPTR(parg16);
RETURN((ULONG)mpex.lReturn);
}
/*++
LONG DispatchMessage(<lpMsg>)
LPMSG <lpMsg>;
The %DispatchMessage% function passes the message in the %MSG% structure
pointed to by the <lpMsg> parameter to the window function of the specified
window.
<lpMsg>
Points to an %MSG% structure that contains message information from
the Windows application queue.
The structure must contain valid message values. If <lpMsg> points to a
WM_TIMER message and the <lParam> parameter of the WM_TIMER message is
not NULL, then the <lParam> parameter is the address of a function that
is called instead of the window function.
The return value specifies the value returned by the window function. Its
meaning depends on the message being dispatched, but generally the return
value is ignored.
--*/
ULONG FASTCALL WU32DispatchMessage(PVDMFRAME pFrame)
{
ULONG ul;
WORD wTDB;
MSG t1;
register PDISPATCHMESSAGE16 parg16;
MSGPARAMEX mpex;
GETARGPTR(pFrame, sizeof(DISPATCHMESSAGE16), parg16);
wTDB = pFrame->wTDB;
getmsg16(parg16->f1, &t1, &mpex);
// Note: getmsg16 may have caused 16-bit memory movement
FREEARGPTR(pFrame);
FREEARGPTR(parg16);
if (CACHENOTEMPTY() && !(CURRENTPTD()->dwWOWCompatFlags & WOWCF_DONTRELEASECACHEDDC)) {
ReleaseCachedDCs(wTDB, 0, 0, 0, SRCHDC_TASK16);
}
BlockWOWIdle(TRUE);
ul = GETLONG16(DispatchMessage(&t1));
BlockWOWIdle(FALSE);
// WARNING Don't rely on any 32 bit flat pointers to 16 bit memory
// After the dispatchmessage call.
FREEARGPTR(parg16);
RETURN(ul);
}
/*++
BOOL GetMessage(<lpMsg>, <hwnd>, <wMsgFilterMin>, <wMsgFilterMax>)
LPMSG <lpMsg>;
HWND <hwnd>;
WORD <wMsgFilterMin>;
WORD <wMsgFilterMax>;
The %GetMessage% function retrieves a message from the application queue and
places the message in the structure pointed to by the <lpMsg> parameter. If
no message is available, the %GetMessage% function yields control to other
applications until a message becomes available.
%GetMessage% retrieves only messages associated with the window specified by
the <hwnd> parameter and within the range of message values given by the
<wMsgFilterMin> and <wMsgFilterMax> parameters. If <hwnd> is NULL,
%GetMessage% retrieves messages for any window that belongs to the
application making the call. (The %GetMessage% function does not retrieve
messages for windows that belong to other applications.) If <wMsgFilterMin>
and <wMsgFilterMax> are both zero, %GetMessage% returns all available
messages (no filtering is performed).
The constants WM_KEYFIRST and WM_KEYLAST can be used as filter values to
retrieve all messages related to keyboard input; the constants WM_MOUSEFIRST
and WM_MOUSELAST can be used to retrieve all mouse-related messages.
<lpMsg>
Points to an %MSG% structure that contains message information from
the Windows application queue.
<hwnd>
Identifies the window whose messages are to be examined. If
<hwnd> is NULL, %GetMessage% retrieves messages for any window that
belongs to the application making the call.
<wMsgFilterMin>
Specifies the integer value of the lowest message value to be
retrieved.
<wMsgFilterMax>
Specifies the integer value of the highest message value to be
retrieved.
The return value is TRUE if a message other than WM_QUIT is retrieved. It is
FALSE if the WM_QUIT message is retrieved.
The return value is usually used to decide whether to terminate the
application's main loop and exit the program.
In addition to yielding control to other applications when no messages are
available, the %GetMessage% and %PeekMessage% functions also yield control
when WM_PAINT or WM_TIMER messages for other tasks are available.
The %GetMessage%, %PeekMessage%, and %WaitMessage% functions are the only
ways to let other applications run. If your application does not call any of
these functions for long periods of time, other applications cannot run.
When %GetMessage%, %PeekMessage%, and %WaitMessage% yield control to other
applications, the stack and data segments of the application calling the
function may move in memory to accommodate the changing memory requirements
of other applications. If the application has stored long pointers to
objects in the data or stack segment (that is, global or local variables),
these pointers can become invalid after a call to %GetMessage%,
%PeekMessage%, or %WaitMessage%. The <lpMsg> parameter of the called
function remains valid in any case.
--*/
ULONG FASTCALL WU32GetMessage(PVDMFRAME pFrame)
{
ULONG ul;
MSG t1;
VPMSG16 vpMsg;
register PGETMESSAGE16 parg16;
ULONG ulReturn;
BlockWOWIdle(TRUE);
// NOTE: pFrame needs to be restored on all GOTO's to get_next_dde_message
get_next_dde_message:
GETARGPTR(pFrame, sizeof(GETMESSAGE16), parg16);
vpMsg = parg16->vpMsg;
ul = GETBOOL16(GetMessage(&t1,
HWND32(parg16->hwnd),
WORD32(parg16->wMin),
WORD32(parg16->wMax)));
// There Could have been a Task Switch Before GetMessage Returned so
// Don't Trust any 32 bit flat pointers we have, memory could've been
// compacted or moved.
FREEARGPTR(parg16);
FREEVDMPTR(pFrame);
#ifdef DEBUG
if (t1.message == WM_TIMER) {
WOW32ASSERT(HIWORD(t1.wParam) == 0);
}
#endif
ulReturn = putmsg16(vpMsg, &t1);
// NOTE: Call to putmsg16 could've caused 16-bit memory movement
if (((t1.message == WM_DDE_DATA) || (t1.message == WM_DDE_POKE)) && (!ulReturn)) {
register PMSG16 pmsg16;
DDEDATA *lpMem32;
WORD Status;
UINT dd;
WORD ww;
char szMsgBoxText[1024];
char szCaption[256];
GETVDMPTR(vpMsg, sizeof(MSG16), pmsg16);
dd = FETCHDWORD(pmsg16->lParam);
ww = FETCHWORD(pmsg16->wParam);
lpMem32 = GlobalLock((HGLOBAL)dd);
Status = (*((PWORD) lpMem32));
GlobalUnlock((HGLOBAL)dd);
(pfnOut.pfnFreeDDEData)((HANDLE)dd, TRUE, TRUE);
GlobalDeleteAtom (ww);
if ((Status & fAckReq) || (t1.message == WM_DDE_POKE)) {
LoadString(hmodWOW32, iszOLEMemAllocFailedFatal, szMsgBoxText, sizeof szMsgBoxText);
LoadString(hmodWOW32, iszSystemError, szCaption, sizeof szCaption);
MessageBox(t1.hwnd, (LPCTSTR) szMsgBoxText, szCaption, MB_OK | MB_SETFOREGROUND | MB_TOPMOST);
PostMessage((HWND) t1.wParam, WM_DDE_TERMINATE, (WPARAM)FULLHWND32((WORD)t1.hwnd), (LPARAM)0l);
}
else {
LoadString(hmodWOW32, iszOLEMemAllocFailed, szMsgBoxText, sizeof szMsgBoxText);
LoadString(hmodWOW32, iszSystemError, szCaption, sizeof szCaption);
MessageBox(t1.hwnd, (LPCTSTR) szMsgBoxText, szCaption, MB_OK | MB_SETFOREGROUND | MB_TOPMOST);
}
FREEVDMPTR(pmsg16);
// restore the frame ptr due to possible 16-bit memory movement
GETFRAMEPTR(((PTD)CURRENTPTD())->vpStack, pFrame);
goto get_next_dde_message;
}
BlockWOWIdle(FALSE);
FREEARGPTR(parg16);
FREEVDMPTR(pFrame);
RETURN(ul);
}
/*++
DWORD GetMessagePos(VOID)
The %GetMessagePos% function returns a long value that represents the cursor
position (in screen coordinates) when the last message obtained by the
%GetMessage% function occurred.
This function has no parameters.
The return value specifies the <x>- and <y>-coordinates of the cursor
position. The <x>-coordinate is in the low-order word, and the
<y>-coordinate is in the high-order word. If the return value is assigned to
a variable, the %MAKEPOINT% macro can be used to obtain a %POINT% structure
from the return value; the %LOWORD% or %HIWORD% macro can be used to extract
the <x>- or the <y>-coordinate.
To obtain the current position of the cursor instead of the position when
the last message occurred, use the %GetCursorPos% function.
--*/
ULONG FASTCALL WU32GetMessagePos(PVDMFRAME pFrame)
{
ULONG ul;
UNREFERENCED_PARAMETER(pFrame);
ul = GETDWORD16(GetMessagePos());
RETURN(ul);
}
/*++
DWORD GetMessageTime(VOID)
The %GetMessageTime% function returns the message time for the last message
retrieved by the %GetMessage% function. The time is a long integer that
specifies the elapsed time (in milliseconds) from the time the system was
booted to the time the message was created (placed in the application
queue).
This function has no parameters.
The return value specifies the message time.
Do not assume that the return value is always increasing. The return value
will wrap around to zero if the timer count exceeds the maximum value for
long integers.
To calculate time delays between messages, subtract the time of the second
message from the time of the first message.
--*/
ULONG FASTCALL WU32GetMessageTime(PVDMFRAME pFrame)
{
ULONG ul;
UNREFERENCED_PARAMETER(pFrame);
ul = GETLONG16(GetMessageTime());
RETURN(ul);
}
/*++
BOOL InSendMessage(VOID)
The %InSendMessage% function specifies whether the current window function
is processing a message that is passed to it through a call to the
%SendMessage% function.
This function has no parameters.
The return value specifies the outcome of the function. It is TRUE if the
window function is processing a message sent to it with %SendMessage%.
Otherwise, it is FALSE.
Applications use the %InSendMessage% function to determine how to handle
errors that occur when an inactive window processes messages. For example,
if the active window uses %SendMessage% to send a request for information to
another window, the other window cannot become active until it returns
control from the %SendMessage% call. The only method an inactive window has
to inform the user of an error is to create a message box.
--*/
ULONG FASTCALL WU32InSendMessage(PVDMFRAME pFrame)
{
ULONG ul;
UNREFERENCED_PARAMETER(pFrame);
ul = GETBOOL16(InSendMessage());
RETURN(ul);
}
/*++
BOOL PeekMessage(<lpMsg>, <hwnd>, <wMsgFilterMin>, <wMsgFilterMax>,
<wRemoveMsg>)
LPMSG <lpMsg>;
HWND <hwnd>;
WORD <wMsgFilterMin>;
WORD <wMsgFilterMax>;
WORD <wRemoveMsg>;
The %PeekMessage% function checks the application queue for a message and
places the message (if any) in the structure pointed to by the <lpMsg>
parameter. Unlike the %GetMessage% function, the %PeekMessage% function does
not wait for a message to be placed in the queue before returning. It does,
however, yield control (if the PM_NOYIELD flag isn't set) and does not
return control after the yield until Windows returns control to the
application.
%PeekMessage% retrieves only messages associated with the window specified
by the <hwnd> parameter, or any of its children as specified by the
%IsChild% function, and within the range of message values given by the
<wMsgFilterMin> and <wMsgFilterMax> parameters. If <hwnd> is NULL,
%PeekMessage% retrieves messages for any window that belongs to the
application making the call. (The %PeekMessage% function does not retrieve
messages for windows that belong to other applications.) If <hwnd> is -1,
%PeekMessage% returns only messages with a <hwnd> of NULL as posted by the
%PostAppMessage% function. If <wMsgFilterMin> and <wMsgFilterMax> are both
zero, %PeekMessage% returns all available messages (no range filtering is
performed).
The WM_KEYFIRST and WM_KEYLAST flags can be used as filter values to
retrieve all key messages; the WM_MOUSEFIRST and WM_MOUSELAST flags can be
used to retrieve all mouse messages.
<lpMsg>
Points to an %MSG% structure that contains message information from
the Windows application queue.
<hwnd>
Identifies the window whose messages are to be examined.
<wMsgFilterMin>
Specifies the value of the lowest message position to be
examined.
<wMsgFilterMax>
Specifies the value of the highest message position to be
examined.
<wRemoveMsg>
Specifies a combination of the flags described in the following
list. PM_NOYIELD can be combined with either PM_NOREMOVE or PM_REMOVE:
PM_NOREMOVE
Messages are not removed from the queue after processing by
PeekMessage.
PM_NOYIELD
Prevents the current task from halting and yielding system resources to
another task.
PM_REMOVE
Messages are removed from the queue after processing by %PeekMessage%.
The return value specifies whether or not a message is found. It is TRUE if
a message is available. Otherwise, it is FALSE.
%PeekMessage% does not remove WM_PAINT messages from the queue. The messages
remain in the queue until processed. The %GetMessage%, %PeekMessage%, and
%WaitMessage% functions yield control to other applications. These calls are
the only way to let other applications run. If your application does not
call any of these functions for long periods of time, other applications
cannot run.
When %GetMessage%, %PeekMessage%, and %WaitMessage% yield control to other
applications, the stack and data segments of the application calling the
function may move in memory to accommodate the changing memory requirements
of other applications.
If the application has stored long pointers to objects in the data or stack
segment (global or local variables), and if they are unlocked, these
pointers can become invalid after a call to %GetMessage%, %PeekMessage%, or
%WaitMessage%. The <lpMsg> parameter of the called function remains valid in
any case.
--*/
ULONG FASTCALL WU32PeekMessage(PVDMFRAME pFrame)
{
ULONG ul;
VPMSG16 vpf1;
HANDLE f2;
WORD f3, f4, f5;
MSG t1;
register PPEEKMESSAGE16 parg16;
BOOL fNoYield;
BlockWOWIdle(TRUE);
// NOTE: pFrame needs to be restored on all GOTO's to get_next_dde_message
get_next_dde_message:
GETARGPTR(pFrame, sizeof(PEEKMESSAGE16), parg16);
vpf1 = parg16->f1;
f2 = HWND32(parg16->f2);
f3 = WORD32(parg16->f3);
f4 = WORD32(parg16->f4);
f5 = parg16->f5;
fNoYield = f5 & PM_NOYIELD;
ul = GETBOOL16(PeekMessage(&t1, f2, f3, f4, f5));
// There could've been a task switch before peekmessage returned
// so Don't trust any 32 bit flat pointers we have, memory could
// have been compacted or moved.
FREEARGPTR(parg16);
FREEVDMPTR(pFrame);
#ifdef DEBUG
if (ul && t1.message == WM_TIMER) {
WOW32ASSERT(HIWORD(t1.wParam) == 0);
}
#endif
// If PeekMessage returned NULL don't bother to copy anything back
if (ul) {
ULONG ulReturn;
//
// We need to set/reset fThunkDDEmsg (based on PM_REMOVE flag)
// so that we know whether to call FreeDDElParam or not while
// thunking 32 bit message to 16 bit message.
//
fThunkDDEmsg = (BOOL) (f5 & PM_REMOVE);
ulReturn = putmsg16(vpf1, &t1);
// There Could've been a Task Switch Before putmsg16 Returned so Don't
// Trust any 32 bit flat pointers we have, memory could have been
// compacted or moved.
FREEARGPTR(parg16);
FREEVDMPTR(pFrame);
fThunkDDEmsg = TRUE;
if (((t1.message == WM_DDE_DATA) || (t1.message == WM_DDE_POKE)) && (!ulReturn)) {
register PMSG16 pmsg16;
DDEDATA *lpMem32;
WORD Status;
UINT dd;
WORD ww;
char szMsgBoxText[1024];
char szCaption[256];
GETVDMPTR(vpf1, sizeof(MSG16), pmsg16);
dd = FETCHDWORD(pmsg16->lParam);
ww = FETCHWORD(pmsg16->wParam);
lpMem32 = GlobalLock((HGLOBAL)dd);
Status = (*((PWORD) lpMem32));
GlobalUnlock((HGLOBAL)dd);
(pfnOut.pfnFreeDDEData)((HANDLE)dd, TRUE, TRUE);
GlobalDeleteAtom (ww);
if (!(f5 & PM_REMOVE)) {
ul = GETBOOL16(PeekMessage(&t1, f2, f3, f4, f5 | PM_REMOVE));
// There could've been a task switch before peekmessage returned
// so Don't trust any 32 bit flat pointers we have, memory could
// have been compacted or moved.
FREEARGPTR(parg16);
FREEVDMPTR(pFrame);
FREEVDMPTR(pmsg16);
// uncomment if parg16 is ref'd before goto get_next_dde_message
//GETFRAMEPTR(((PTD)CURRENTPTD())->vpStack, pFrame);
//GETARGPTR(pFrame, sizeof(PEEKMESSAGE16), parg16);
// uncomment if pmsg16 is ref'd before goto get_next_dde_message
//GETVDMPTR(vpf1, sizeof(MSG16), pmsg16);
}
if ((Status & fAckReq) || (t1.message == WM_DDE_POKE)) {
LoadString(hmodWOW32, iszOLEMemAllocFailedFatal, szMsgBoxText, sizeof szMsgBoxText);
LoadString(hmodWOW32, iszSystemError, szCaption, sizeof szCaption);
MessageBox(t1.hwnd, (LPCTSTR) szMsgBoxText, szCaption, MB_OK);
PostMessage ((HWND) t1.wParam, WM_DDE_TERMINATE, (WPARAM)FULLHWND32((WORD)t1.hwnd), (LPARAM)0l);
}
else {
LoadString(hmodWOW32, iszOLEMemAllocFailed, szMsgBoxText, sizeof szMsgBoxText);
LoadString(hmodWOW32, iszSystemError, szCaption, sizeof szCaption);
MessageBox(t1.hwnd, (LPCTSTR) szMsgBoxText, szCaption, MB_OK);
}
FREEVDMPTR(pmsg16);
// restore the frame ptr due to possible 16-bit memory movement
GETFRAMEPTR(((PTD)CURRENTPTD())->vpStack, pFrame);
goto get_next_dde_message;
}
}
else if (fNoYield && (CURRENTPTD()->dwWOWCompatFlags & WOWCF_SETNULLMESSAGE)) {
// winproj (help.tutorial) calls peekmessage with PM_REMOVE and
// PM_NOYIELD and an lpmsg whose contents are uninitialized. However
// even if peekmessage returns false, it checks if lpmsg->message is
// WM_QUIT and if true exits. In WOW by pure coincidence the
// unintialized lpmsg->message happens to be value 0x12, which is
// WM_QUIT and thus the tutorial always exits after initialization.
//
// So we reset lpmsg->message to zero, if it was called with PM_NOYIELD
// and if it happens to be WM_QUIT and if peekmessage returns zero.
//
// - nanduri
// we don't need to reinitialize pFrame etc. 'cause peekmessage was
// called with PM_NOYIELD and thus the 16bit memory couldn't have moved
register PMSG16 pmsg16;
GETVDMPTR(vpf1, sizeof(MSG16), pmsg16);
if (pmsg16 && (pmsg16->message == WM_QUIT)) {
pmsg16->message = 0;
}
FREEVDMPTR(pmsg16);
}
BlockWOWIdle(FALSE);
FREEARGPTR(parg16);
FREEVDMPTR(pFrame);
RETURN(ul);
}
/*++
BOOL PostAppMessage(<hTask>, <wMsg>, <wParam>, <lParam>)
HANDLE <hTask>;
WORD <wMsg>;
WORD <wParam>;
DWORD <lParam>;
The %PostAppMessage% function posts a message to an application identified
by a task handle, and then returns without waiting for the application to
process the message. The application receiving the message obtains the
message by calling the %GetMessage% or %PeekMessage% function. The <hwnd>
parameter of the returned %MSG% structure is NULL.
<hTask>
Identifies the task that is to receive the message. The
%GetCurrentTask% function returns this handle.
<wMsg>
Specifies the type of message posted.
<wParam>
Specifies additional message information.
<lParam>
Specifies additional message information.
The return value specifies whether or not the message is posted. It is
TRUE if the message is posted. Otherwise, it is FALSE.
--*/
ULONG FASTCALL WU32PostAppMessage(PVDMFRAME pFrame)
{
register PPOSTAPPMESSAGE16 parg16;
DWORD f1;
MSGPARAMEX mpex;
GETARGPTR(pFrame, sizeof(POSTAPPMESSAGE16), parg16);
mpex.lReturn = 0;
mpex.Parm16.WndProc.hwnd = 0;
mpex.Parm16.WndProc.wMsg = WORD32(parg16->f2);
mpex.Parm16.WndProc.wParam = WORD32(parg16->f3);
mpex.Parm16.WndProc.lParam = LONG32(parg16->f4);
mpex.iMsgThunkClass = 0;
f1 = THREADID32(parg16->f1);
ThunkMsg16(&mpex);
// Note: ThunkMsg16 may have caused 16-bit memory movement
FREEARGPTR(pFrame);
FREEARGPTR(parg16);
mpex.lReturn = PostThreadMessage(f1, mpex.uMsg, mpex.uParam, mpex.lParam);
if (MSG16NEEDSTHUNKING(&mpex)) {
(mpex.lpfnUnThunk16)(&mpex);
}
FREEARGPTR(parg16);
RETURN((ULONG)mpex.lReturn);
}
/*++
BOOL PostMessage(<hwnd>, <msg>, <wParam>, <lParam>)
HWND <hwnd>;
WORD <msg>;
WORD <wParam>;
LONG <lParam>;
The %PostMessage% function places a message in a window's application queue,
and then returns without waiting for the corresponding window to process the
message. Messages in a message queue are retrieved by calls to the
%GetMessage% or %PeekMessage% function.
.*
.* DA's: the following parameters section should be identical to the
.* parameters section in the sdmsg.ref file. If there is a change
.* to this section, the identical change should be made in the other
.* file.
.*
<hwnd>
Identifies the window that is to receive the message. If this parameter
is 0xFFFF (-1), the message is sent to all top-level windows.
<msg>
Specifies the message to be sent.
<wParam>
Specifies additional message information. The contents of this
parameter depends on the message being sent.
<lParam>
Specifies additional message information. The contents of this
parameter depends on the message being sent.
The return value is TRUE if the message is posted, or FALSE if it is not.
An application should never use the %PostMessage% function to send a message
to a control.
.cmt
27-Oct-1990 [ralphw]
The following is a rewording of the previous documentation. However, it
needs confirmation from development as to its technical accuracy before it
can be released for public consumption.
If the message is being sent to another application, and the <wParam> or
<lParam> parameters are used to pass a handle or pointer to global memory,
the memory should be allocated by the %GlobalAlloc% function using the
GMEM_NOT_BANKED flag. In a system using expanded memory (EMS), this ensures
that the memory is not in in a different bank of memory from the application
using the memory.
.endcmt
--*/
ULONG FASTCALL WU32PostMessage(PVDMFRAME pFrame)
{
LONG l;
UINT f2;
WPARAM f3;
LPARAM f4;
HWND hwnd;
register PPOSTMESSAGE16 parg16;
MSGPARAMEX mpex;
DWORD err = NO_ERROR;
GETARGPTR(pFrame, sizeof(POSTMESSAGE16), parg16);
// Apps should never use PostMessage to post messages that have
// pointers to structures, because those messages will show up in
// GetMessage, and if GetMessage tries to thunk them (ie, tries to
// call back to the 16-bit kernel to allocate some 16-bit memory to
// copy the converted 32-bit structure into), we have no way of
// knowing when to free that 16-bit memory.
//
// BUGBUG 22-Aug-91 JeffPar: a flag should be added to ThunkMsg16
// indicating whether or not such allocations are permissible; this
// flag should be passed on to all the ThunkXXMsg16 subfunctions,
// and each of those subfunctions should assert the flag is false
// whenever allocating 16-bit memory.
//
// Used by 16->32 DDE thunkers.
//
WOW32ASSERT(fWhoCalled == FALSE);
fWhoCalled = WOWDDE_POSTMESSAGE;
f2 = (UINT)WORD32(parg16->f2);
f3 = (WPARAM)(WORD32(parg16->f3));
f4 = (LPARAM)(LONG32(parg16->f4));
mpex.lReturn = 0;
mpex.Parm16.WndProc.hwnd = parg16->f1;
mpex.Parm16.WndProc.wMsg = (WORD)f2;
mpex.Parm16.WndProc.wParam = (WORD)f3;
mpex.Parm16.WndProc.lParam = f4;
mpex.iMsgThunkClass = 0;
// The Reader.exe shipped with Lotus 123MM version has a message
// synchronization problem. Force proper synchronization by
// converting this PostMessage call to a SendMessage().
if ((f2 == WM_VSCROLL) &&
((f3 == SB_THUMBTRACK) || (f3 == SB_THUMBPOSITION)) &&
(CURRENTPTD()->dwWOWCompatFlagsEx & WOWCFEX_SENDPOSTEDMSG) ) {
l = (LONG)WU32SendMessage(pFrame);
FREEARGPTR(parg16);
RETURN((ULONG) l);
}
hwnd = ThunkMsg16(&mpex);
// Note: ThunkMsg16 may have caused 16-bit memory movement
FREEARGPTR(pFrame);
FREEARGPTR(parg16);
WOW32ASSERT(fWhoCalled == WOWDDE_POSTMESSAGE);
fWhoCalled = FALSE;
if (hwnd) {
l = PostMessage(hwnd, mpex.uMsg, mpex.uParam, mpex.lParam);
if (!l)
err = GetLastError();
mpex.lReturn = l;
if (MSG16NEEDSTHUNKING(&mpex)) {
(mpex.lpfnUnThunk16)(&mpex);
}
// If the post message failed, then the message was probably one
// that has pointers and therefore can not be posted. (MetaDesign
// tries to post these kind of messages.) If the destination was a
// WOW app, then make it into a private message, and try the post
// again. We don't have to worry about thunking since both the source
// and destination are in the WOW address space.
if (err == ERROR_INVALID_PARAMETER) {
PWW pww;
DWORD dwpid;
pww = FindPWW(hwnd);
// was added for WM_DRAWITEM messages which are probably intended
// for owner drawn std-type classes. see bug #2047 NTBUG4
if (pww != NULL && GETICLASS(pww, hwnd) != WOWCLASS_WIN16) {
// make sure we're in the same vdm process
if (!(GetWindowThreadProcessId(hwnd, &dwpid) &&
(dwpid == GetCurrentProcessId()))) {
return 0;
}
mpex.lReturn = PostMessage(hwnd, f2 | WOWPRIVATEMSG, f3, f4);
}
}
}
FREEARGPTR(parg16);
RETURN((ULONG)mpex.lReturn);
}
/*++
void PostQuitMessage(<nExitCode>)
int <nExitCode>;
The %PostQuitMessage% function informs Windows that the application wishes
to terminate execution. It is typically used in response to a WM_DESTROY
message.
The %PostQuitMessage% function posts a WM_QUIT message to the application
and returns immediately; the function merely informs the system that the
application wants to quit sometime in the future.
When the application receives the WM_QUIT message, it should exit the
message loop in the main function and return control to Windows. The exit
code returned to Windows must be the <wParam> parameter of the WM_QUIT
message.
<nExitCode>
Specifies an application exit code. It is used as the wParam parameter
of the WM_QUIT message.
This function does not return a value.
--*/
ULONG FASTCALL WU32PostQuitMessage(PVDMFRAME pFrame)
{
register PPOSTQUITMESSAGE16 parg16;
GETARGPTR(pFrame, sizeof(POSTQUITMESSAGE16), parg16);
PostQuitMessage(INT32(parg16->wExitCode));
FREEARGPTR(parg16);
RETURN(0);
}
/*++
WORD RegisterWindowMessage(<lpString>)
LPSTR <lpString>;
This function defines a new window message that is guaranteed to be unique
throughout the system. The returned message value can be used when calling
the %SendMessage% or %PostMessage% function.
%RegisterWindowMessage% is typically used for communication between two
cooperating applications.
If the same message string is registered by two different applications, the
same message value is returned. The message remains registered until the
user ends the Windows session.
<lpString>
Points to the message string to be registered.
The return value specifies the outcome of the function. It is an unsigned
short integer within the range 0xC000 to 0xFFFF if the message is
successfully registered. Otherwise, it is zero.
Use the %RegisterWindowMessage% function only when the same message must be
understood by more than one application. For sending private messages within
an application, an application can use any integer within the range WM_USER
to 0xBFFF.
--*/
ULONG FASTCALL WU32RegisterWindowMessage(PVDMFRAME pFrame)
{
ULONG ul;
PSZ psz1;
register PREGISTERWINDOWMESSAGE16 parg16;
GETARGPTR(pFrame, sizeof(REGISTERWINDOWMESSAGE16), parg16);
GETPSZPTR(parg16->f1, psz1);
ul = GETWORD16(RegisterWindowMessage(psz1));
FREEPSZPTR(psz1);
FREEARGPTR(parg16);
RETURN(ul);
}
/*++
void ReplyMessage(<lReply>)
LONG <lReply>;
The %ReplyMessage% function is used to reply to a message sent through the
%SendMessage% function without returning control to the function that called
%SendMessage.%
By calling this function, the window function that receives the message
allows the task that called %SendMessage% to continue to execute as though
the task that received the message had returned control. The task that calls
%ReplyMessage% also continues to execute.
Normally a task that calls %SendMessage% to send a message to another task
will not continue executing until the window procedure that Windows calls to
receive the message returns. However, if a task that is called to receive a
message needs to perform some type of operation that might yield control
(such as calling the %MessageBox% or %DialogBox% functions), Windows could
be placed in a deadlock situation where the sending task needs to execute
and process messages but cannot because it is waiting for %SendMessage% to
return. An application can avoid this problem if the task receiving the
message calls %ReplyMessage% before performing any operation that could
cause the task to yield.
The %ReplyMessage% function has no effect if the message was not sent
through the %SendMessage% function or if the message was sent by the same
task.
<lReply>
Specifies the result of the message processing. The possible values
depend on the actual message sent.
This function does not return a value.
--*/
ULONG FASTCALL WU32ReplyMessage(PVDMFRAME pFrame)
{
register PREPLYMESSAGE16 parg16;
GETARGPTR(pFrame, sizeof(REPLYMESSAGE16), parg16);
ReplyMessage(LONG32(parg16->f1));
// WARNING - Don't use any 32 bit flat pointers after call to ReplyMessage,
// other tasks might have run and made the pointers invalid.
FREEARGPTR(parg16);
RETURN(0);
}
/*++
DWORD SendDlgItemMessage(<hDlg>, <nIDDlgItem>, <wMsg>, <wParam>, <lParam>)
HWND <hDlg>;
int <nIDDlgItem>;
WORD <wMsg>;
WORD <wParam>;
DWORD <lParam>;
The %SendDlgItemMessage% function sends a message to the control specified
by the <nIDDlgItem> parameter within the dialog box specified by the <hDlg>
parameter. The %SendDlgItemMessage% function does not return until the
message has been processed.
<hDlg>
Identifies the dialog box that contains the control.
<nIDDlgItem>
Specifies the integer identifier of the dialog item that is to
receive the message.
<wMsg>
Specifies the message value.
<wParam>
Specifies additional message information.
<lParam>
Specifies additional message information.
The return value specifies the outcome of the function. It is the value
returned by the control's window function, or zero if the control identifier
is not valid.
Using %SendDlgItemMessage% is identical to obtaining a handle to the given
control and calling the %SendMessage% function.
--*/
#define W31EM_GETRECT (WM_USER+2) // w31 EM_GETRECT != NT EM_GETRECT
ULONG FASTCALL WU32SendDlgItemMessage(PVDMFRAME pFrame)
{
HWND hdlg, hwndItem, hwnd;
register PSENDDLGITEMMESSAGE16 parg16;
MSGPARAMEX mpex;
static HWND hwndCached = NULL ;
static DWORD dwCachedItem = 0L ;
GETARGPTR(pFrame, sizeof(SENDDLGITEMMESSAGE16), parg16);
// QuarkExpress v3.31 passes a hard coded 7fff:0000 as the pointer to the
// RECT struct for EM_GETRECT message - W3.1 rejects it in validation layer
if( (DWORD32(parg16->f5) == 0x7FFF0000) &&
(WORD32(parg16->f3) == W31EM_GETRECT) &&
(CURRENTPTD()->dwWOWCompatFlagsEx & WOWCFEX_BOGUSPOINTER) ) {
FREEARGPTR(parg16);
RETURN((ULONG)0);
}
// Need unique handle
hdlg = (HWND)FULLHWND32(parg16->f1);
//
// Caching the hwnd for the dialog item because EForm will
// call SendDlgItemMessage in a tight loop.
//
if ( hdlg == hdlgSDIMCached && WORD32(parg16->f2) == dwCachedItem ) {
// Set from cached
hwndItem = hwndCached ;
}
else {
if ( hwndItem = GetDlgItem(hdlg, WORD32(parg16->f2)) ) {
// and cache needed information
hdlgSDIMCached = hdlg ;
hwndCached = hwndItem ;
dwCachedItem = WORD32(parg16->f2) ;
}
else {
FREEARGPTR(parg16);
RETURN((ULONG)0);
}
}
mpex.lReturn = 0;
if (hwndItem) {
mpex.Parm16.WndProc.hwnd = GETHWND16(hwndItem);
mpex.Parm16.WndProc.wMsg = WORD32(parg16->f3);
mpex.Parm16.WndProc.wParam = WORD32(parg16->f4);
mpex.Parm16.WndProc.lParam = LONG32(parg16->f5);
mpex.iMsgThunkClass = 0;
if (hwnd = ThunkMsg16(&mpex)) {
// Note: ThunkMsg16 may have caused memory movement
FREEARGPTR(pFrame);
FREEARGPTR(parg16);
/*
** Since we already know which window the message is going to
** don't make USER32 look it up again. - MarkRi
*/
mpex.lReturn = SendMessage(hwndItem, mpex.uMsg, mpex.uParam,
mpex.lParam);
// to keep common dialog structs in sync (see wcommdlg.c)
Check_ComDlg_pszptr(CURRENTPTD()->CommDlgTd,
(VPVOID)mpex.Parm16.WndProc.lParam);
if (MSG16NEEDSTHUNKING(&mpex)) {
(mpex.lpfnUnThunk16)(&mpex);
}
}
}
FREEARGPTR(parg16);
RETURN((ULONG)mpex.lReturn);
}
/*++
DWORD SendMessage(<hwnd>, <msg>, <wParam>, <lParam>)
HWND <hwnd>;
WORD <msg>;
WORD <wParam>;
LONG <lParam>;
The %SendMessage% function sends a message to a window or windows. The
%SendMessage% function calls the window procedure for the specified window,
and does not return until that window procedure has processed the message.
This is in contrast to the %PostMessage% function which places the message
into the specified window's message queue and returns immediately.
<hwnd>
Identifies the window that is to receive the message. If this parameter
is 0xFFFF (-1), the message is sent to all top-level windows.
<msg>
Specifies the message to be sent.
<wParam>
Specifies additional message information. The contents of this
parameter depends on the message being sent.
<lParam>
Specifies additional message information. The contents of this
parameter depends on the message being sent.
The return value is the result returned by the invoked window procedure; its
value depends on the message being sent.
--*/
ULONG FASTCALL WU32SendMessage(PVDMFRAME pFrame)
{
// NOTE: This can be called directly by WU32PostMessage!!!
HWND hwnd;
register PSENDMESSAGE16 parg16;
MSGPARAMEX mpex;
HWND16 hwndOld;
UINT uMsgOld;
UINT uParamOld;
LONG lParamOld;
#ifdef DBCS
HMEM16 hMem16;
LPSZ lpBuf16,lpBuf32;
#endif // DBCS
GETARGPTR(pFrame, sizeof(SENDMESSAGE16), parg16);
hwndOld = parg16->f1;
uMsgOld = WORD32(parg16->f2);
uParamOld = WORD32(parg16->f3);
lParamOld = LONG32(parg16->f4);
//
// Check for funky apps sending WM_SYSCOMMAND - SC_CLOSE to progman
//
if ( uMsgOld == WM_SYSCOMMAND && uParamOld == SC_CLOSE ) {
if ( hwndOld == GETHWND16(hwndProgman) && hwndProgman != (HWND)0 ) {
//
// Now if shift key is down, they must be trying to save
// settings in progman.
//
if ( GetKeyState( VK_SHIFT ) < 0 ) {
uMsgOld = RegisterWindowMessage("SaveSettings");
}
}
}
//
// This is for the apps that use DDE protocol wrongly, like AmiPro.
//
WOW32ASSERT(fWhoCalled == FALSE);
fWhoCalled = WOWDDE_POSTMESSAGE;
mpex.lReturn = 0;
mpex.Parm16.WndProc.hwnd = hwndOld;
mpex.Parm16.WndProc.wMsg = (WORD)uMsgOld;
#ifdef DBCS
//
// For WIN3.1J's BUG ?
// SendMessage( hwnd, WM_GETTEXT, 2, lpBuffer )
// if string is DBCS, return is DBCS-leadbyte.
// KKSUZUKA:#1731
// 1994.8.8 add by V-HIDEKK
//
if( uMsgOld == WM_GETTEXT && uParamOld == 2 ){
mpex.Parm16.WndProc.wParam = (WORD)(uParamOld + 1);
mpex.Parm16.WndProc.lParam = GlobalAllocLock16( GMEM_SHARE | GMEM_MOVEABLE, uParamOld +1, &hMem16 );
}
else {
mpex.Parm16.WndProc.wParam = (WORD)uParamOld;
mpex.Parm16.WndProc.lParam = lParamOld;
}
#else // !DBCS
mpex.Parm16.WndProc.wParam = (WORD)uParamOld;
mpex.Parm16.WndProc.lParam = lParamOld;
#endif // !DBCS
mpex.iMsgThunkClass = 0;
hwnd = ThunkMsg16(&mpex);
// Note: ThunkMsg16 may have caused memory movement
FREEARGPTR(pFrame);
FREEARGPTR(parg16);
WOW32ASSERT(fWhoCalled == WOWDDE_POSTMESSAGE);
fWhoCalled = FALSE;
if (hwnd) {
BlockWOWIdle(TRUE);
#ifdef DEBUG
if ( WM_DDE_EXECUTE == mpex.uMsg ) {
// comes handy when debugging shell shortcut problems
LOGDEBUG(1,("dest %x, src%x, msg %s\n",hwnd,mpex.uParam,mpex.lParam));
}
#endif
mpex.lReturn = SendMessage(hwnd, mpex.uMsg, mpex.uParam, mpex.lParam);
BlockWOWIdle(FALSE);
#ifdef DBCS
//
// For WIN3.1J's BUG ?
// SendMessage( hwnd, WM_GETTEXT, 2, lpBuffer )
// if string is DBCS, return is DBCSLeadbyte.
// KKSUZUKA:#1731
// 1994.8.8 add by V-HIDEKK
//
if( uMsgOld == WM_GETTEXT && uParamOld == 2 ){
GETVDMPTR(mpex.Parm16.WndProc.lParam,mpex.Parm16.WndProc.wParam,lpBuf32);
GETVDMPTR(lParamOld,uParamOld,lpBuf16);
lpBuf16[0] = lpBuf32[0];
if( mpex.lReturn == 2 ){
lpBuf16[1] = 0;
mpex.lReturn = 1;
}
else {
lpBuf16[1] = lpBuf32[1];
}
FREEVDMPTR(lpBuf16);
FREEVDMPTR(lpBuf32);
GlobalUnlockFree16( mpex.Parm16.WndProc.lParam );
mpex.Parm16.WndProc.wParam = (WORD)uParamOld;
mpex.Parm16.WndProc.lParam = lParamOld;
}
#endif // DBCS
WOW32ASSERT(fWhoCalled == FALSE);
fWhoCalled = WOWDDE_POSTMESSAGE;
if (MSG16NEEDSTHUNKING(&mpex)) {
(mpex.lpfnUnThunk16)(&mpex);
}
WOW32ASSERT(fWhoCalled == WOWDDE_POSTMESSAGE);
fWhoCalled = FALSE;
}
FREEARGPTR(parg16);
RETURN((ULONG)mpex.lReturn);
}
/*++
int TranslateAccelerator(<hwnd>, <hAccTable>, <lpMsg>)
The %TranslateAccelerator% function processes keyboard accelerators for menu
commands. The %TranslateAccelerator% function translates WM_KEYUP and
WM_KEYDOWN messages to WM_COMMAND or WM_SYSCOMMAND messages, if there is an
entry for the key in the application's accelerator table. The high-order
word of the <lParam> parameter of the WM_COMMAND or WM_SYSCOMMAND message
contains the value 1 to differentiate the message from messages sent by
menus or controls.
WM_COMMAND or WM_SYSCOMMAND messages are sent directly to the window, rather
than being posted to the application queue. The %TranslateAccelerator%
function does not return until the message is processed.
Accelerator key strokes that are defined to select items from the system
menu are translated into WM_SYSCOMMAND messages; all other accelerators are
translated into WM_COMMAND messages.
<hwnd>
Identifies the window whose messages are to be translated.
<hAccTable>
%HANDLE% Identifies an accelerator table (loaded by using the
%LoadAccelerators% function).
<lpMsg>
Points to a message retrieved by using the %GetMessage% or
%PeekMessage% function. The message must be an %MSG% structure and
contain message information from the Windows application queue.
.cmt
19-Sep-1990 [johnca]
Doesn't this function really return a BOOL?
.endcmt
The return value specifies the outcome of the function. It is nonzero if
translation occurs. Otherwise, it is zero.
When %TranslateAccelerator% returns nonzero (meaning that the message is
translated), the application should <not> process the message again by using
the %TranslateMessage% function.
Commands in accelerator tables do not have to correspond to menu items.
If the accelerator command does correspond to a menu item, the application
is sent WM_INITMENU and WM_INITMENUPOPUP messages, just as if the user were
trying to display the menu. However, these messages are not sent if any of
the following conditions are present:
o The window is disabled.
o The menu item is disabled.
o The command is not in the System menu and the window is minimized.
o A mouse capture is in effect (for more information, see the %SetCapture%
function, earlier in this chapter).
If the window is the active window and there is no keyboard focus (generally
true if the window is minimized), then WM_SYSKEYUP and WM_SYSKEYDOWN
messages are translated instead of WM_KEYUP and WM_KEYDOWN messages.
If an accelerator key stroke that corresponds to a menu item occurs when the
window that owns the menu is iconic, no WM_COMMAND message is sent. However,
if an accelerator key stroke that does not match any of the items on the
window's menu or the System menu occurs, a WM_COMMAND message is sent, even
if the window is iconic.
--*/
ULONG FASTCALL WU32TranslateAccelerator(PVDMFRAME pFrame)
{
ULONG ul;
MSG t3;
register PTRANSLATEACCELERATOR16 parg16;
GETARGPTR(pFrame, sizeof(TRANSLATEACCELERATOR16), parg16);
W32CopyMsgStruct(parg16->f3, &t3, TRUE);
ul = GETINT16(TranslateAccelerator(HWND32(parg16->f1),
HACCEL32(parg16->f2), &t3 ));
FREEARGPTR(parg16);
RETURN(ul);
}
/*++
BOOL TranslateMDISysAccel(<hwndClient>, <lpMsg>)
The %TranslateMDISysAccel% function processes keyboard accelerators for
multiple document interface (MDI) child window System-menu commands. The
%TranslateMDISysAccel% function translates WM_KEYUP and WM_KEYDOWN messages
to WM_SYSCOMMAND messages. The high-order word of the <lParam> parameter of
the WM_SYSCOMMAND message contains the value 1 to differentiate the message
from messages sent by menus or controls.
<hwndClient>
Identifies the parent MDI client window.
<lpMsg>
Points to a message retrieved by using the %GetMessage% or
%PeekMessage% function. The message must be an %MSG% structure and
contain message information from the Windows application queue.
The return value is TRUE if the function translated a message into a system
command. Otherwise, it is FALSE.
--*/
ULONG FASTCALL WU32TranslateMDISysAccel(PVDMFRAME pFrame)
{
ULONG ul;
MSG t2;
register PTRANSLATEMDISYSACCEL16 parg16;
GETARGPTR(pFrame, sizeof(TRANSLATEMDISYSACCEL16), parg16);
W32CopyMsgStruct(parg16->f2, &t2, TRUE);
ul = GETBOOL16(TranslateMDISysAccel(HWND32(parg16->f1), &t2));
FREEARGPTR(parg16);
RETURN(ul);
}
/*++
BOOL TranslateMessage(<lpMsg>)
The %TranslateMessage% function translates virtual-key messages into
character messages, as follows:
o WM_KEYDOWN/WM_KEYUP combinations produce a WM_CHAR or a WM_DEADCHAR
message.
o WM_SYSKEYDOWN/WM_SYSKEYUP combinations produce a WM_SYSCHAR or a
WM_SYSDEADCHAR message.
The character messages are posted to the application queue, to be read the
next time the application calls the %GetMessage% or %PeekMessage% function.
<lpMsg>
Points to a %MSG% structure retrieved through the GetMessage or
PeekMessage function. The structure contains message information from
the Windows application queue.
The return value specifies the outcome of the function. It is TRUE if the
message is translated (that is, character messages are posted to the
application queue). Otherwise, it is FALSE.
The %TranslateMessage% function does not modify the message given by the
<lpMsg> parameter.
%TranslateMessage% produces WM_CHAR messages only for keys which are mapped
to ASCII characters by the keyboard driver.
An application should not call %TranslateMessage% if the application
processes virtual-key messages for some other purpose. For instance, an
application should not call the %TranslateMessage% function if the
%TranslateAccelerator% function returns TRUE.
--*/
ULONG FASTCALL WU32TranslateMessage(PVDMFRAME pFrame)
{
ULONG ul;
MSG t1;
register PTRANSLATEMESSAGE16 parg16;
GETARGPTR(pFrame, sizeof(TRANSLATEMESSAGE16), parg16);
W32CopyMsgStruct(parg16->f1, &t1, TRUE);
ul = GETBOOL16(TranslateMessage( &t1 ));
FREEARGPTR(parg16);
RETURN(ul);
}
/*++
void WaitMessage(VOID)
The %WaitMessage% function yields control to other applications when an
application has no other tasks to perform. The %WaitMessage% function
suspends the application and does not return until a new message is placed
in the application's queue.
This function has no parameters.
This function does not return a value.
The %GetMessage%, %PeekMessage%, and %WaitMessage% functions yield control
to other applications. These calls are the only way to let other
applications run. If your application does not call any of these functions
for long periods of time, other applications cannot run.
When %GetMessage%, %PeekMessage%, and %WaitMessage% yield control to other
applications, the stack and data segments of the application calling the
function may move in memory to accommodate the changing memory requirements
of other applications. If the application has stored long pointers to
objects in the data or stack segment (that is, global or local variables),
these pointers can become invalid after a call to %GetMessage%,
%PeekMessage%, or %WaitMessage%.
--*/
ULONG FASTCALL WU32WaitMessage(PVDMFRAME pFrame)
{
UNREFERENCED_PARAMETER(pFrame);
BlockWOWIdle(TRUE);
WaitMessage();
BlockWOWIdle(FALSE);
RETURN(0);
}