701 lines
16 KiB
C
701 lines
16 KiB
C
/*++
|
|
*
|
|
* Windows NT v5.0 WOW
|
|
*
|
|
* Copyright (c) 1997, Microsoft Corporation
|
|
*
|
|
* WIN95.C
|
|
*
|
|
* WOW32 Hand-coded (as opposed to interpreted) thunks for new-for-Win95
|
|
* exports.
|
|
*
|
|
* History:
|
|
* 16 Feb 97 Created davehart
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
MODNAME(win95.c);
|
|
|
|
|
|
ULONG FASTCALL WU32TileWindows(PVDMFRAME pFrame)
|
|
{
|
|
return W32TileOrCascadeWindows(pFrame, TileWindows);
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WU32CascadeWindows(PVDMFRAME pFrame)
|
|
{
|
|
return W32TileOrCascadeWindows(pFrame, CascadeWindows);
|
|
}
|
|
|
|
|
|
ULONG FASTCALL W32TileOrCascadeWindows(PVDMFRAME pFrame, PFNTILECASCADEWINDOWS pfnWin32)
|
|
{
|
|
register PCASCADEWINDOWS16 parg16;
|
|
ULONG ul;
|
|
RECT rc;
|
|
PRECT prc;
|
|
HWND ahwnd[8];
|
|
DWORD chwnd;
|
|
HWND16 UNALIGNED *phwnd16;
|
|
HWND *phwnd;
|
|
|
|
GETARGPTR(pFrame, sizeof(*parg16), parg16);
|
|
chwnd = parg16->chwnd;
|
|
|
|
if (parg16->lpRect) {
|
|
GETRECT16(parg16->lpRect, &rc);
|
|
prc = &rc;
|
|
} else {
|
|
prc = NULL;
|
|
}
|
|
|
|
if (parg16->ahwnd) {
|
|
phwnd = STACKORHEAPALLOC( chwnd * sizeof(HWND), sizeof(ahwnd), ahwnd);
|
|
phwnd16 = VDMPTR(parg16->ahwnd, chwnd * sizeof(HWND16));
|
|
|
|
for (ul = 0; ul < chwnd; ul++) {
|
|
phwnd[ul] = HWND32(phwnd16[ul]);
|
|
}
|
|
|
|
FREEVDMPTR(phwnd16);
|
|
} else {
|
|
phwnd = NULL;
|
|
}
|
|
|
|
ul = (*pfnWin32)(
|
|
HWND32(parg16->hwndParent),
|
|
parg16->wFlags,
|
|
prc,
|
|
chwnd,
|
|
phwnd
|
|
);
|
|
|
|
//
|
|
// Memory movement may have occurred due to message activity,
|
|
// so throw away flat pointers to 16-bit memory.
|
|
//
|
|
|
|
FREEARGPTR(parg16);
|
|
|
|
if (phwnd) {
|
|
STACKORHEAPFREE(phwnd, ahwnd);
|
|
}
|
|
|
|
return ul;
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WU32DrawAnimatedRects(PVDMFRAME pFrame)
|
|
{
|
|
register PDRAWANIMATEDRECTS16 parg16;
|
|
ULONG ul;
|
|
RECT rcFrom, rcTo;
|
|
|
|
GETARGPTR(pFrame, sizeof(*parg16), parg16);
|
|
GETRECT16(parg16->lprcStart, &rcFrom);
|
|
GETRECT16(parg16->lprcEnd, &rcTo);
|
|
|
|
ul = DrawAnimatedRects(
|
|
HWND32(parg16->hwndClip),
|
|
parg16->idAnimation,
|
|
&rcFrom,
|
|
&rcTo
|
|
);
|
|
|
|
FREEARGPTR(parg16);
|
|
|
|
return ul;
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WU32DrawCaption(PVDMFRAME pFrame)
|
|
{
|
|
register PDRAWCAPTION16 parg16;
|
|
ULONG ul;
|
|
RECT rc;
|
|
|
|
GETARGPTR(pFrame, sizeof(*parg16), parg16);
|
|
GETRECT16(parg16->lprc, &rc);
|
|
|
|
ul = DrawCaption(
|
|
HWND32(parg16->hwnd),
|
|
HDC32(parg16->hdc),
|
|
&rc,
|
|
parg16->wFlags
|
|
);
|
|
|
|
FREEARGPTR(parg16);
|
|
|
|
return ul;
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WU32DrawEdge(PVDMFRAME pFrame)
|
|
{
|
|
return W32DrawEdgeOrFrameControl(pFrame, DrawEdge);
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WU32DrawFrameControl(PVDMFRAME pFrame)
|
|
{
|
|
return W32DrawEdgeOrFrameControl(pFrame, DrawFrameControl);
|
|
}
|
|
|
|
|
|
ULONG FASTCALL W32DrawEdgeOrFrameControl(PVDMFRAME pFrame, PFNDRAWEDGEFRAMECONTROL pfnWin32)
|
|
{
|
|
register PDRAWEDGE16 parg16;
|
|
ULONG ul;
|
|
RECT rc;
|
|
|
|
GETARGPTR(pFrame, sizeof(*parg16), parg16);
|
|
GETRECT16(parg16->lprc, &rc);
|
|
|
|
ul = (*pfnWin32)(
|
|
HDC32(parg16->hdc),
|
|
&rc,
|
|
parg16->wEdge,
|
|
parg16->wFlags
|
|
);
|
|
|
|
PUTRECT16(parg16->lprc, &rc);
|
|
|
|
FREEARGPTR(parg16);
|
|
|
|
return ul;
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WU32DrawTextEx(PVDMFRAME pFrame)
|
|
{
|
|
register PDRAWTEXTEX16 parg16;
|
|
ULONG ul;
|
|
PSZ psz;
|
|
RECT rc;
|
|
DRAWTEXTPARAMS dtp, *pdtp;
|
|
PDRAWTEXTPARAMS16 pdtp16;
|
|
|
|
GETARGPTR(pFrame, sizeof(*parg16), parg16);
|
|
GETVARSTRPTR(parg16->lpchText, parg16->cchText, psz);
|
|
GETRECT16(parg16->lprc, &rc);
|
|
|
|
if ( (parg16->lpDTparams) &&
|
|
(pdtp16 = VDMPTR(parg16->lpDTparams, sizeof(DRAWTEXTPARAMS16))) ) {
|
|
|
|
pdtp = &dtp;
|
|
dtp.cbSize = sizeof(dtp);
|
|
dtp.iTabLength = pdtp16->iTabLength;
|
|
dtp.iLeftMargin = pdtp16->iLeftMargin;
|
|
dtp.iRightMargin = pdtp16->iRightMargin;
|
|
dtp.uiLengthDrawn = 0;
|
|
} else {
|
|
pdtp = NULL;
|
|
}
|
|
|
|
ul = DrawTextEx(
|
|
HDC32(parg16->hdc),
|
|
psz,
|
|
parg16->cchText,
|
|
&rc,
|
|
parg16->dwDTformat,
|
|
pdtp
|
|
);
|
|
|
|
if (pdtp) {
|
|
pdtp16->uiLengthDrawn = (WORD)dtp.uiLengthDrawn;
|
|
}
|
|
|
|
FREEVDMPTR(pdtp16);
|
|
FREEVDMPTR(psz);
|
|
FREEARGPTR(parg16);
|
|
|
|
return ul;
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WU32GetIconInfo(PVDMFRAME pFrame)
|
|
{
|
|
register PGETICONINFO16 parg16;
|
|
ULONG ul;
|
|
ICONINFO ii;
|
|
PICONINFO16 pii16;
|
|
|
|
GETARGPTR(pFrame, sizeof(*parg16), parg16);
|
|
|
|
ul = GetIconInfo(
|
|
HICON32(parg16->hicon),
|
|
&ii
|
|
);
|
|
|
|
pii16 = VDMPTR(parg16->lpiconinfo, sizeof(*pii16));
|
|
pii16->fIcon = (BOOL16)ii.fIcon;
|
|
pii16->xHotspot = (INT16)ii.xHotspot;
|
|
pii16->yHotspot = (INT16)ii.yHotspot;
|
|
pii16->hbmMask = GETHBITMAP16(ii.hbmMask);
|
|
pii16->hbmColor = GETHBITMAP16(ii.hbmColor);
|
|
FREEVDMPTR(pii16);
|
|
|
|
FREEARGPTR(pFrame);
|
|
|
|
return ul;
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WU32GetMenuItemInfo(PVDMFRAME pFrame)
|
|
{
|
|
register PGETMENUITEMINFO16 parg16;
|
|
ULONG ul;
|
|
MENUITEMINFO mii;
|
|
PMENUITEMINFO16 pmii16;
|
|
|
|
GETARGPTR(pFrame, sizeof(*parg16), parg16);
|
|
GETVDMPTR(parg16->lpmii, sizeof(*pmii16), pmii16);
|
|
|
|
mii.cbSize = sizeof(mii);
|
|
mii.fMask = pmii16->fMask;
|
|
|
|
FREEVDMPTR(pmii16);
|
|
|
|
ul = GetMenuItemInfo(
|
|
HMENU32(parg16->hmenu),
|
|
parg16->wIndex,
|
|
parg16->fByPosition,
|
|
&mii
|
|
);
|
|
|
|
putmenuiteminfo16(parg16->lpmii, &mii);
|
|
|
|
FREEARGPTR(pFrame);
|
|
|
|
return ul;
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WU32InsertMenuItem(PVDMFRAME pFrame)
|
|
{
|
|
register PINSERTMENUITEM16 parg16;
|
|
ULONG ul;
|
|
MENUITEMINFO mii;
|
|
|
|
GETARGPTR(pFrame, sizeof(*parg16), parg16);
|
|
|
|
getmenuiteminfo16(parg16->lpmii, &mii);
|
|
|
|
ul = InsertMenuItem(
|
|
HMENU32(parg16->hmenu),
|
|
parg16->wIndex,
|
|
parg16->fByPosition,
|
|
&mii
|
|
);
|
|
|
|
|
|
FREEARGPTR(pFrame);
|
|
|
|
return ul;
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WU32SetMenuItemInfo(PVDMFRAME pFrame)
|
|
{
|
|
register PSETMENUITEMINFO16 parg16;
|
|
ULONG ul;
|
|
MENUITEMINFO mii;
|
|
|
|
GETARGPTR(pFrame, sizeof(*parg16), parg16);
|
|
|
|
getmenuiteminfo16(parg16->lpmii, &mii);
|
|
|
|
ul = SetMenuItemInfo(
|
|
HMENU32(parg16->hmenu),
|
|
parg16->wIndex,
|
|
parg16->fByPosition,
|
|
&mii
|
|
);
|
|
|
|
FREEARGPTR(pFrame);
|
|
|
|
return ul;
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WU32GetMenuItemRect(PVDMFRAME pFrame)
|
|
{
|
|
register PGETMENUITEMRECT16 parg16;
|
|
ULONG ul;
|
|
RECT rc;
|
|
|
|
GETARGPTR(pFrame, sizeof(*parg16), parg16);
|
|
|
|
ul = GetMenuItemRect(
|
|
HWND32(parg16->hwnd),
|
|
HMENU32(parg16->hmenu),
|
|
parg16->wIndex,
|
|
&rc
|
|
);
|
|
|
|
PUTRECT16(parg16->lprcScreen, &rc);
|
|
|
|
FREEARGPTR(pFrame);
|
|
|
|
return ul;
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WU32TrackPopupMenuEx(PVDMFRAME pFrame)
|
|
{
|
|
register PTRACKPOPUPMENUEX16 parg16;
|
|
ULONG ul;
|
|
TPMPARAMS tpmp;
|
|
LPTPMPARAMS lptpmp;
|
|
VPRECT16 vprcExclude;
|
|
|
|
GETARGPTR(pFrame, sizeof(*parg16), parg16);
|
|
|
|
if (parg16->lpTpm) {
|
|
lptpmp = &tpmp;
|
|
tpmp.cbSize = sizeof(tpmp);
|
|
vprcExclude = parg16->lpTpm + offsetof(TPMPARAMS16, rcExclude);
|
|
GETRECT16(vprcExclude, &tpmp.rcExclude);
|
|
} else {
|
|
lptpmp = NULL;
|
|
}
|
|
|
|
ul = TrackPopupMenuEx(
|
|
HMENU32(parg16->hmenu),
|
|
parg16->wFlags,
|
|
parg16->x,
|
|
parg16->y,
|
|
HWND32(parg16->hwndOwner),
|
|
lptpmp
|
|
);
|
|
|
|
FREEARGPTR(pFrame);
|
|
|
|
return ul;
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WG32GetCharacterPlacement(PVDMFRAME pFrame)
|
|
{
|
|
register PGETCHARACTERPLACEMENT16 parg16;
|
|
ULONG ul;
|
|
PSZ pszText;
|
|
PGCP_RESULTS16 pgcp16;
|
|
GCP_RESULTS gcp;
|
|
|
|
//
|
|
// Thankfully on Win95 the 16-bit GCP_RESULTS structure
|
|
// points to 32-bit ints, so the structure thunking
|
|
// is trivial.
|
|
//
|
|
|
|
GETARGPTR(pFrame, sizeof(*parg16), parg16);
|
|
GETPSZPTR(parg16->lpszText, pszText);
|
|
GETVDMPTR(parg16->lpResults, sizeof(*pgcp16), pgcp16);
|
|
|
|
gcp.lStructSize = sizeof gcp;
|
|
gcp.nGlyphs = pgcp16->nGlyphs;
|
|
gcp.nMaxFit = pgcp16->nMaxFit;
|
|
GETOPTPTR(pgcp16->lpOutString, 1, gcp.lpOutString);
|
|
GETOPTPTR(pgcp16->lpOrder, 4, gcp.lpOrder);
|
|
GETOPTPTR(pgcp16->lpDx, 4, gcp.lpDx);
|
|
GETOPTPTR(pgcp16->lpCaretPos, 4, gcp.lpCaretPos);
|
|
GETOPTPTR(pgcp16->lpClass, 1, gcp.lpClass);
|
|
GETOPTPTR(pgcp16->lpGlyphs, 4, gcp.lpGlyphs);
|
|
|
|
ul = GetCharacterPlacement(
|
|
HDC32(parg16->hdc),
|
|
pszText,
|
|
parg16->wCount,
|
|
parg16->wMaxExtent,
|
|
&gcp,
|
|
parg16->dwFlags
|
|
);
|
|
|
|
pgcp16->nGlyphs = (SHORT)gcp.nGlyphs;
|
|
pgcp16->nMaxFit = (SHORT)gcp.nMaxFit;
|
|
|
|
FREEARGPTR(pFrame);
|
|
|
|
return ul;
|
|
}
|
|
|
|
//
|
|
// On Win95, GetProductName returns "Windows 95".
|
|
// We'll return "Windows NT" unless something forces us
|
|
// to be identical.
|
|
//
|
|
// Two flavors: call with cbBuffer == 0 and it returns
|
|
// the length required minus 1 (a bug I think). Call with
|
|
// cbBuffer > 0 and it copies as much as possible and returns
|
|
// lpBuffer.
|
|
//
|
|
|
|
ULONG FASTCALL WK32GetProductName(PVDMFRAME pFrame)
|
|
{
|
|
register PGETPRODUCTNAME16 parg16;
|
|
ULONG ul;
|
|
PSZ pszBuffer;
|
|
static char szProductName[] = "Windows NT";
|
|
|
|
GETARGPTR(pFrame, sizeof(*parg16), parg16);
|
|
|
|
if (0 == parg16->cbBuffer) {
|
|
ul = (sizeof szProductName) - 1;
|
|
} else {
|
|
GETVDMPTR(parg16->lpBuffer, parg16->cbBuffer, pszBuffer);
|
|
WOW32VERIFY(pszBuffer == lstrcpyn(pszBuffer, szProductName, parg16->cbBuffer));
|
|
FREEVDMPTR(pszBuffer);
|
|
ul = parg16->lpBuffer;
|
|
}
|
|
|
|
FREEARGPTR(pFrame);
|
|
|
|
return ul;
|
|
}
|
|
|
|
|
|
typedef struct _tagWOWDRAWSTATECALLBACK {
|
|
VPVOID vpfnCallback;
|
|
LPARAM lparamUser;
|
|
} WOWDRAWSTATECALLBACK, *PWOWDRAWSTATECALLBACK;
|
|
|
|
|
|
BOOL CALLBACK WOWDrawStateCallback(HDC hdc, LPARAM lData, WPARAM wData, int cx, int cy)
|
|
{
|
|
PWOWDRAWSTATECALLBACK pwds = (PWOWDRAWSTATECALLBACK) lData;
|
|
ULONG ul;
|
|
WORD awCallbackArgs[6];
|
|
|
|
awCallbackArgs[0] = (WORD)(SHORT)cy;
|
|
awCallbackArgs[1] = (WORD)(SHORT)cx;
|
|
awCallbackArgs[2] = (WORD)wData;
|
|
awCallbackArgs[3] = LOWORD(pwds->lparamUser);
|
|
awCallbackArgs[4] = HIWORD(pwds->lparamUser);
|
|
awCallbackArgs[5] = GETHDC16(hdc);
|
|
|
|
WOWCallback16Ex(
|
|
pwds->vpfnCallback,
|
|
WCB16_PASCAL,
|
|
sizeof awCallbackArgs,
|
|
awCallbackArgs,
|
|
&ul // retcode filled into ul
|
|
);
|
|
|
|
return LOWORD(ul);
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WU32DrawState(PVDMFRAME pFrame)
|
|
{
|
|
register PDRAWSTATE16 parg16;
|
|
ULONG ul;
|
|
WOWDRAWSTATECALLBACK wds;
|
|
DRAWSTATEPROC pDrawStateCallback = NULL;
|
|
LPARAM lData;
|
|
HBRUSH hbr;
|
|
|
|
GETARGPTR(pFrame, sizeof(*parg16), parg16);
|
|
|
|
switch (parg16->uFlags & DST_TYPEMASK) {
|
|
|
|
case DST_COMPLEX:
|
|
if (parg16->pfnCallBack) {
|
|
wds.vpfnCallback = parg16->pfnCallBack;
|
|
wds.lparamUser = parg16->lData;
|
|
lData = (LPARAM) &wds;
|
|
pDrawStateCallback = (DRAWSTATEPROC) WOWDrawStateCallback;
|
|
}
|
|
break;
|
|
|
|
case DST_TEXT:
|
|
case DST_PREFIXTEXT:
|
|
lData = (LPARAM) VDMPTR(parg16->lData, parg16->wData);
|
|
break;
|
|
|
|
case DST_ICON:
|
|
lData = (LPARAM) HICON32( (WORD) parg16->lData );
|
|
break;
|
|
|
|
case DST_BITMAP:
|
|
lData = (LPARAM) HBITMAP32(parg16->lData);
|
|
break;
|
|
|
|
default:
|
|
WOW32WARNMSGF(FALSE, ("WOW32: Unknown DST_ code to DrawState %x.\n",
|
|
parg16->uFlags & DST_TYPEMASK));
|
|
}
|
|
|
|
hbr = (parg16->uFlags & DSS_MONO)
|
|
? HBRUSH32(parg16->hbrFore)
|
|
: NULL;
|
|
|
|
ul = GETBOOL16(DrawState(
|
|
HDC32(parg16->hdcDraw),
|
|
hbr,
|
|
pDrawStateCallback,
|
|
lData,
|
|
parg16->wData,
|
|
parg16->x,
|
|
parg16->y,
|
|
parg16->cx,
|
|
parg16->cy,
|
|
parg16->uFlags
|
|
));
|
|
|
|
FREEARGPTR(pFrame);
|
|
|
|
return ul;
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WU32GetAppVer(PVDMFRAME pFrame)
|
|
{
|
|
return ((PTDB)SEGPTR(pFrame->wTDB,0))->TDB_ExpWinVer;
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WU32CopyImage(PVDMFRAME pFrame)
|
|
{
|
|
register PCOPYIMAGE16 parg16;
|
|
ULONG ul;
|
|
BOOL fIconCursor; // as opposed to bitmap
|
|
|
|
GETARGPTR(pFrame, sizeof(*parg16), parg16);
|
|
|
|
//
|
|
// NOTE first parameter to Win16 CopyImage is hinstOwner,
|
|
// which isn't a parameter to Win32 CopyImage. It may
|
|
// be that we'll need to special-case LR_COPYFROMRESOURCE
|
|
// to work correctly.
|
|
//
|
|
|
|
fIconCursor = (parg16->wType != IMAGE_BITMAP);
|
|
|
|
ul = (ULONG) CopyImage(
|
|
(fIconCursor)
|
|
? HICON32(parg16->hImage)
|
|
: HBITMAP32(parg16->hImage),
|
|
parg16->wType,
|
|
parg16->cxNew,
|
|
parg16->cyNew,
|
|
parg16->wFlags
|
|
);
|
|
|
|
ul = (fIconCursor)
|
|
? GETHICON16(ul)
|
|
: GETHBITMAP16(ul);
|
|
|
|
return ul;
|
|
}
|
|
|
|
|
|
//
|
|
// WowMsgBoxIndirectCallback is called by User32 when a 16-bit app
|
|
// calls MessageBoxIndirect and specifies a help callback proc.
|
|
// User32 passes the 16:16 callback address to us along with a
|
|
// flat pointer to the HELPINFO structure to pass to the callback.
|
|
//
|
|
|
|
VOID FASTCALL WowMsgBoxIndirectCallback(DWORD vpfnCallback, LPHELPINFO lpHelpInfo)
|
|
{
|
|
VPVOID vpHelpInfo16;
|
|
LPHELPINFO lpHelpInfo16;
|
|
|
|
//
|
|
// As best as I can tell Win95 passes the WIN32 HELPINFO struct back to the
|
|
// 16-bit callback proc (i.e. there is no HELPINFO16).
|
|
//
|
|
|
|
// be sure allocation size matches stackfree16() size below
|
|
vpHelpInfo16 = stackalloc16( sizeof(*lpHelpInfo16) );
|
|
|
|
GETVDMPTR(vpHelpInfo16, sizeof(*lpHelpInfo16), lpHelpInfo16);
|
|
RtlCopyMemory(lpHelpInfo16, lpHelpInfo, sizeof(*lpHelpInfo16));
|
|
FREEVDMPTR(lpHelpInfo16);
|
|
|
|
WOWCallback16(
|
|
vpfnCallback,
|
|
vpHelpInfo16
|
|
);
|
|
|
|
if(vpHelpInfo16) {
|
|
stackfree16(vpHelpInfo16, sizeof(*lpHelpInfo16));
|
|
}
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WU32MessageBoxIndirect(PVDMFRAME pFrame)
|
|
{
|
|
register PMESSAGEBOXINDIRECT16 parg16;
|
|
ULONG ul;
|
|
PMSGBOXPARAMS16 pmbp16;
|
|
MSGBOXPARAMS mbp;
|
|
|
|
GETARGPTR(pFrame, sizeof(*parg16), parg16);
|
|
GETVDMPTR(parg16->lpmbp, sizeof *pmbp16, pmbp16);
|
|
|
|
mbp.cbSize = sizeof mbp;
|
|
mbp.hwndOwner = HWND32(pmbp16->hwndOwner);
|
|
mbp.hInstance = HINSTRES32(pmbp16->hInstance);
|
|
GETPSZIDPTR(pmbp16->lpszText, mbp.lpszText);
|
|
GETPSZIDPTR(pmbp16->lpszCaption, mbp.lpszCaption);
|
|
mbp.dwStyle = pmbp16->dwStyle;
|
|
GETPSZIDPTR(pmbp16->lpszIcon, mbp.lpszIcon);
|
|
mbp.dwContextHelpId = pmbp16->dwContextHelpId;
|
|
if (pmbp16->vpfnMsgBoxCallback) {
|
|
MarkWOWProc(pmbp16->vpfnMsgBoxCallback, mbp.lpfnMsgBoxCallback)
|
|
} else {
|
|
mbp.lpfnMsgBoxCallback = 0;
|
|
}
|
|
mbp.dwLanguageId = pmbp16->dwLanguageId;
|
|
|
|
ul = GETINT16( MessageBoxIndirect(&mbp) );
|
|
|
|
FREEARGPTR(pFrame);
|
|
|
|
return ul;
|
|
}
|
|
|
|
|
|
//
|
|
// was in wow.it: HGDI CreateEnhMetaFile(HGDI, PTR, PTR, PTR);
|
|
// Using real thunk to ensure Win32 curdir matches Win16.
|
|
//
|
|
ULONG FASTCALL WG32CreateEnhMetaFile(PVDMFRAME pFrame)
|
|
{
|
|
register PCREATEENHMETAFILE16 parg16;
|
|
ULONG ul;
|
|
LPCSTR lpszFile, lpszDescription;
|
|
CONST RECT *prclFrame;
|
|
|
|
GETARGPTR(pFrame, sizeof(*parg16), parg16);
|
|
GETVDMPTR(parg16->lpszFile, 1, lpszFile);
|
|
// note lpszDescription is really two SZs with extra terminator
|
|
GETVDMPTR(parg16->lpszDescription, 3, lpszDescription);
|
|
// note lprclFrame is a LPRECTL, a Win32 RECT
|
|
GETVDMPTR(parg16->lprclFrame, sizeof(*prclFrame), prclFrame);
|
|
|
|
//
|
|
// Make sure the Win32 current directory matches this task's.
|
|
//
|
|
|
|
UpdateDosCurrentDirectory(DIR_DOS_TO_NT);
|
|
|
|
ul = GETHDC16(CreateEnhMetaFile(
|
|
HDC32(parg16->hdcRef),
|
|
lpszFile,
|
|
prclFrame,
|
|
lpszDescription
|
|
));
|
|
|
|
FREEVDMPTR(prclFrame);
|
|
FREEVDMPTR(lpszDescription);
|
|
FREEVDMPTR(lpszFile);
|
|
|
|
return ul;
|
|
}
|