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.
321 lines
10 KiB
321 lines
10 KiB
/*++
|
|
*
|
|
* WOW v1.0
|
|
*
|
|
* Copyright (c) 1991, Microsoft Corporation
|
|
*
|
|
* WUMAN.C
|
|
* WOW32 16-bit User API support (manually-coded thunks)
|
|
*
|
|
* History:
|
|
* Created 27-Jan-1991 by Jeff Parsons (jeffpar)
|
|
--*/
|
|
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
MODNAME(wuman.c);
|
|
|
|
WBP W32WordBreakProc = NULL;
|
|
|
|
extern DWORD fThunkStrRtns;
|
|
|
|
extern WORD gwKrnl386CodeSeg1;
|
|
extern WORD gwKrnl386CodeSeg2;
|
|
extern WORD gwKrnl386CodeSeg3;
|
|
extern WORD gwKrnl386DataSeg1;
|
|
|
|
ULONG FASTCALL WU32ExitWindows(PVDMFRAME pFrame)
|
|
// BUGBUG mattfe 4-mar-92, this routine should not return if we close down
|
|
// all the apps successfully.
|
|
{
|
|
ULONG ul;
|
|
register PEXITWINDOWS16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(EXITWINDOWS16), parg16);
|
|
|
|
ul = GETBOOL16(ExitWindows(
|
|
DWORD32(parg16->dwReserved),
|
|
WORD32(parg16->wReturnCode)
|
|
));
|
|
|
|
FREEARGPTR(parg16);
|
|
|
|
RETURN(ul);
|
|
}
|
|
|
|
WORD gUser16CS = 0;
|
|
|
|
ULONG FASTCALL WU32NotifyWow(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul = 0;
|
|
register PNOTIFYWOW16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(NOTIFYWOW16), parg16);
|
|
|
|
switch (FETCHWORD(parg16->Id)) {
|
|
case NW_LOADACCELERATORS:
|
|
ul = WU32LoadAccelerators(FETCHDWORD(parg16->pData));
|
|
break;
|
|
|
|
case NW_LOADICON:
|
|
case NW_LOADCURSOR:
|
|
ul = (ULONG) W32CheckIfAlreadyLoaded(parg16->pData, FETCHWORD(parg16->Id));
|
|
break;
|
|
|
|
case NW_WINHELP:
|
|
{
|
|
// this call is made from IWinHelp in USER.exe to find the
|
|
// '16bit' help window if it exists.
|
|
//
|
|
|
|
LPSZ lpszClass;
|
|
GETMISCPTR(parg16->pData, lpszClass);
|
|
ul = (ULONG)(pfnOut.pfnWOWFindWindow)((LPCSTR)lpszClass, (LPCSTR)NULL);
|
|
if (ul) {
|
|
// check if hwndWinHelp belongs to this process or not.
|
|
DWORD pid, pidT;
|
|
pid = pidT = GetCurrentProcessId();
|
|
GetWindowThreadProcessId((HWND)ul, &pid);
|
|
ul = (ULONG)MAKELONG((WORD)GETHWND16(ul),(WORD)(pid == pidT));
|
|
}
|
|
FREEMISCPTR(lpszClass);
|
|
}
|
|
break;
|
|
|
|
case NW_KRNL386SEGS:
|
|
{
|
|
PKRNL386SEGS pKrnl386Segs;
|
|
|
|
GETVDMPTR(parg16->pData, sizeof(KRNL386SEGS), pKrnl386Segs);
|
|
|
|
gwKrnl386CodeSeg1 = pKrnl386Segs->CodeSeg1;
|
|
gwKrnl386CodeSeg2 = pKrnl386Segs->CodeSeg2;
|
|
gwKrnl386CodeSeg3 = pKrnl386Segs->CodeSeg3;
|
|
gwKrnl386DataSeg1 = pKrnl386Segs->DataSeg1;
|
|
}
|
|
break;
|
|
|
|
case NW_FINALUSERINIT:
|
|
{
|
|
static BYTE CallCsrFlag = 0;
|
|
extern DWORD gpsi;
|
|
PUSERCLIENTGLOBALS pfinit16;
|
|
WORD UNALIGNED *pwMaxDWPMsg;
|
|
PBYTE pDWPBits;
|
|
#ifdef DEBUG
|
|
WORD wMsg;
|
|
int i;
|
|
PSZ pszFormat;
|
|
#endif
|
|
|
|
GETVDMPTR(parg16->pData, sizeof(USERCLIENTGLOBALS), pfinit16);
|
|
GETVDMPTR(pfinit16->lpwMaxDWPMsg, sizeof(WORD), pwMaxDWPMsg);
|
|
GETVDMPTR(pfinit16->lpDWPBits, pfinit16->cbDWPBits, pDWPBits);
|
|
|
|
// store the 16bit hmod of user.exe
|
|
gUser16hInstance = (WORD)pfinit16->hInstance;
|
|
WOW32ASSERTMSGF((gUser16hInstance),
|
|
("WOW Error gUser16hInstance == NULL!\n"));
|
|
|
|
// store the 16bit CS of user.exe
|
|
gUser16CS = HIWORD(pFrame->vpCSIP);
|
|
|
|
// initialize user16client globals
|
|
|
|
if (pfinit16->lpgpsi) {
|
|
BYTE **lpT;
|
|
GETVDMPTR(pfinit16->lpgpsi, sizeof(DWORD), lpT);
|
|
*lpT = (BYTE *)gpsi;
|
|
FLUSHVDMCODEPTR((ULONG)pfinit16->lpgpsi, sizeof(DWORD), lpT);
|
|
FREEVDMPTR(lpT);
|
|
}
|
|
|
|
|
|
if (pfinit16->lpCsrFlag) {
|
|
BYTE **lpT;
|
|
GETVDMPTR(pfinit16->lpCsrFlag, sizeof(DWORD), lpT);
|
|
*lpT = (LPSTR)&CallCsrFlag;
|
|
FLUSHVDMCODEPTR((ULONG)pfinit16->lpCsrFlag, sizeof(DWORD), lpT);
|
|
FREEVDMPTR(lpT);
|
|
}
|
|
|
|
if (pfinit16->lpHighestAddress) {
|
|
DWORD *lpT;
|
|
SYSTEM_BASIC_INFORMATION sbi;
|
|
NTSTATUS Status;
|
|
|
|
GETVDMPTR(pfinit16->lpHighestAddress, sizeof(DWORD), lpT);
|
|
Status = NtQuerySystemInformation(SystemBasicInformation,
|
|
&sbi,
|
|
sizeof(sbi),
|
|
NULL);
|
|
|
|
WOW32ASSERTMSGF((NT_SUCCESS(Status)),
|
|
("WOW Error NtQuerySystemInformation failed!\n"));
|
|
|
|
*lpT = sbi.MaximumUserModeAddress;
|
|
FLUSHVDMCODEPTR((ULONG)pfinit16->lpHighestAddress, sizeof(DWORD), lpT);
|
|
FREEVDMPTR(lpT);
|
|
}
|
|
|
|
|
|
/* No longer required now that user32 & user.exe are separate
|
|
DEAD CODE if (HIWORD(pfinit16->dwBldInfo) != HIWORD(pfnOut.dwBldInfo)) {
|
|
DEAD CODE MessageBeep(0);
|
|
DEAD CODE MessageBoxA(NULL, "user.exe and user32.dll are mismatched.",
|
|
DEAD CODE "WOW Error", MB_OK | MB_ICONEXCLAMATION);
|
|
DEAD CODE }
|
|
*/
|
|
|
|
*pwMaxDWPMsg = (pfnOut.pfnWowGetDefWindowProcBits)(pDWPBits, pfinit16->cbDWPBits);
|
|
|
|
FLUSHVDMCODEPTR(pfinit16->lpwMaxDWPMsg, sizeof(WORD), pwMaxDWPMsg);
|
|
FLUSHVDMCODEPTR(pfinit16->lpDWPBits, pfinit16->cbDWPBits, pDWPBits);
|
|
|
|
#ifdef DEBUG
|
|
LOGDEBUG(LOG_TRACE, ("WU32NotifyWow: got DefWindowProc bits, wMaxDWPMsg = 0x%x.\n", *pwMaxDWPMsg));
|
|
LOGDEBUG(LOG_TRACE, ("The following messages will be passed on to 32-bit DefWindowProc:\n"));
|
|
|
|
#define FPASSTODWP32(msg) \
|
|
(pDWPBits[msg >> 3] & (1 << (msg & 7)))
|
|
|
|
wMsg = 0;
|
|
i = 0;
|
|
|
|
while (wMsg <= *pwMaxDWPMsg) {
|
|
if (FPASSTODWP32(wMsg)) {
|
|
if ( i & 3 ) {
|
|
pszFormat = ", %s";
|
|
} else {
|
|
pszFormat = "\n%s";
|
|
}
|
|
LOGDEBUG(LOG_TRACE, (pszFormat, aw32Msg[wMsg].lpszW32));
|
|
i++;
|
|
}
|
|
wMsg++;
|
|
}
|
|
|
|
LOGDEBUG(LOG_TRACE, ("\n\n"));
|
|
#endif
|
|
|
|
gpfn16GetProcModule = pfinit16->pfnGetProcModule;
|
|
|
|
//
|
|
// Return value tells User16 whether to thunk
|
|
// string routines to Win32 or use the fast
|
|
// US-only versions. TRUE means thunk.
|
|
//
|
|
// If the locale is U.S. English, we default to
|
|
// not thunking, outside the U.S. we default to
|
|
// thunking. See wow32.c's use of fThunkStrRtns.
|
|
//
|
|
// We engage in this nastiness because the Winstone 94
|
|
// Access 1.1 test takes *twice* as long to run in
|
|
// the US if we thunk lstrcmp and lstrcmpi to Win32.
|
|
//
|
|
// By adding a value "ThunkNLS" to the WOW registry
|
|
// key of type REG_DWORD, the user can force thunking
|
|
// to Win32 (value 1) or use the fast US-only ones (value 0).
|
|
//
|
|
|
|
ul = fThunkStrRtns;
|
|
|
|
FREEVDMPTR(pDWPBits);
|
|
FREEVDMPTR(pwMaxDWPMsg);
|
|
FREEVDMPTR(pfinit16);
|
|
|
|
}
|
|
break;
|
|
|
|
default:
|
|
ul = 0;
|
|
break;
|
|
}
|
|
|
|
FREEARGPTR(parg16);
|
|
return ul;
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WU32WOWWordBreakProc(PVDMFRAME pFrame)
|
|
{
|
|
PSZ psz1;
|
|
ULONG ul;
|
|
register PWOWWORDBREAKPROC16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(*parg16), parg16);
|
|
GETPSZPTR(parg16->lpszEditText, psz1);
|
|
|
|
ul = (*W32WordBreakProc)(psz1, parg16->ichCurrentWord, parg16->cbEditText,
|
|
parg16->action);
|
|
|
|
FREEPSZPTR(psz1);
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
//
|
|
// WU32MouseEvent: Thunk for 16-bit register-based API mouse_event,
|
|
// with the help of user16 function mouse_event (in
|
|
// winmisc2.asm).
|
|
//
|
|
|
|
ULONG FASTCALL WU32MouseEvent(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
register PMOUSEEVENT16 parg16;
|
|
typedef ULONG (WINAPI *PFMOUSE_EVENT)(DWORD, DWORD, DWORD, DWORD, DWORD);
|
|
|
|
GETARGPTR(pFrame, sizeof(PMOUSEEVENT16), parg16);
|
|
|
|
//
|
|
// mouse_event is declared void, but we'll return the same value as
|
|
// user32.
|
|
//
|
|
|
|
ul = ((PFMOUSE_EVENT)(PVOID)mouse_event)(
|
|
parg16->wFlags,
|
|
parg16->dx,
|
|
parg16->dy,
|
|
parg16->cButtons,
|
|
parg16->dwExtraInfo
|
|
);
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WU32KeybdEvent: Thunk for 16-bit register-based API keybd_event,
|
|
// with the help of user16 function keybd_event (in
|
|
// winmisc2.asm).
|
|
//
|
|
|
|
ULONG FASTCALL WU32KeybdEvent(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
register PKEYBDEVENT16 parg16;
|
|
typedef ULONG (WINAPI *PFKEYBD_EVENT)(BYTE, BYTE, DWORD, DWORD);
|
|
|
|
GETARGPTR(pFrame, sizeof(PKEYBDEVENT16), parg16);
|
|
|
|
//
|
|
// keybd_event is declared void, but we'll return the same value as
|
|
// user32.
|
|
//
|
|
|
|
ul = ((PFKEYBD_EVENT)(PVOID)keybd_event)(
|
|
LOBYTE(parg16->bVirtualKey),
|
|
LOBYTE(parg16->bScanCode),
|
|
((HIBYTE(parg16->bVirtualKey) == 0x80) ? KEYEVENTF_KEYUP : 0) |
|
|
((HIBYTE(parg16->bScanCode) == 0x1) ? KEYEVENTF_EXTENDEDKEY : 0),
|
|
parg16->dwExtraInfo
|
|
);
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|