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.
610 lines
16 KiB
610 lines
16 KiB
/*++
|
|
*
|
|
* WOW v1.0
|
|
*
|
|
* Copyright (c) 1991, Microsoft Corporation
|
|
*
|
|
* WGMETA.C
|
|
* WOW32 16-bit GDI API support
|
|
*
|
|
* History:
|
|
* Created 07-Mar-1991 by Jeff Parsons (jeffpar)
|
|
--*/
|
|
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
MODNAME(wgmeta.c);
|
|
|
|
typedef METAHEADER UNALIGNED *PMETAHEADER16;
|
|
|
|
|
|
// WARNING: This function may cause 16-bit memory to move
|
|
VOID CopyMetaFile16FromHMF32(HAND16 hMF16, HMETAFILE hMF32)
|
|
{
|
|
UINT cbMF32, cbMF16;
|
|
VPVOID vp;
|
|
PBYTE pMF16;
|
|
|
|
|
|
if((vp = GlobalLock16(hMF16, &cbMF16)) && hMF32) {
|
|
|
|
GETMISCPTR(vp, pMF16);
|
|
|
|
cbMF32 = GetMetaFileBitsEx(hMF32, 0, NULL);
|
|
|
|
// Verify these are the same size within the 16-bit kernel memory
|
|
// allocation granularity
|
|
WOW32WARNMSGF((abs(cbMF16 - cbMF32) < 32),
|
|
("WOW32: Size MF16 = %lu MF32 = %lu\n", cbMF16, cbMF32));
|
|
|
|
// copy the bits from the 32-bit metafile to the 16-bit metafile memory
|
|
cbMF32 = GetMetaFileBitsEx(hMF32, min(cbMF16, cbMF32), pMF16);
|
|
|
|
GlobalUnlock16(hMF16);
|
|
FLUSHVDMPTR(vp, cbMF32, pMF16);
|
|
FREEMISCPTR(pMF16);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
// WARNING: This function may cause 16-bit memory to move
|
|
HAND16 WinMetaFileFromHMF(HMETAFILE hmf, BOOL fFreeOriginal)
|
|
{
|
|
UINT cbMetaData;
|
|
VPVOID vpMetaData;
|
|
PBYTE pMetaData;
|
|
HAND16 h16;
|
|
|
|
/*
|
|
* Under Windows Metafiles were merely Global Handle to memory
|
|
* so we have to mimick that behavior because some apps "operate"
|
|
* on metafile handles directly. (WinWord and PowerPoint to
|
|
* GlobalSize and GlobalAlloc to size and create metafiles)
|
|
*/
|
|
|
|
cbMetaData = GetMetaFileBitsEx(hmf, 0, NULL);
|
|
|
|
if (!cbMetaData)
|
|
return((HAND16)NULL);
|
|
|
|
/*
|
|
* Win 3.1 allocates extra space in MetaFile and OLE2 checks for this.
|
|
* METAHEADER is defined to be the same size as the 16-bit structure.
|
|
*/
|
|
|
|
cbMetaData += sizeof(METAHEADER);
|
|
|
|
vpMetaData = GlobalAllocLock16(GMEM_MOVEABLE | GMEM_DDESHARE, cbMetaData, &h16);
|
|
|
|
if (!vpMetaData)
|
|
return((HAND16)NULL);
|
|
|
|
|
|
GETOPTPTR(vpMetaData, 0, pMetaData);
|
|
|
|
if (GetMetaFileBitsEx(hmf, cbMetaData, pMetaData)) {
|
|
GlobalUnlock16(h16);
|
|
} else {
|
|
GlobalUnlockFree16(vpMetaData);
|
|
return((HAND16)NULL);
|
|
}
|
|
|
|
if (fFreeOriginal)
|
|
DeleteMetaFile(hmf);
|
|
|
|
return(h16);
|
|
}
|
|
|
|
HMETAFILE HMFFromWinMetaFile(HAND16 h16, BOOL fFreeOriginal)
|
|
{
|
|
INT cb;
|
|
VPVOID vp;
|
|
HMETAFILE hmf = (HMETAFILE)0;
|
|
PMETAHEADER16 pMFH16;
|
|
|
|
vp = GlobalLock16(h16, &cb);
|
|
|
|
if (vp) {
|
|
GETMISCPTR(vp, pMFH16);
|
|
|
|
hmf = SetMetaFileBitsEx(cb, (LPBYTE)pMFH16);
|
|
|
|
if (fFreeOriginal)
|
|
GlobalUnlockFree16(vp);
|
|
else
|
|
GlobalUnlock16(h16);
|
|
|
|
FREEMISCPTR(pMFH16);
|
|
}
|
|
|
|
return(hmf);
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WG32CloseMetaFile(PVDMFRAME pFrame)
|
|
{
|
|
HMETAFILE hmf;
|
|
ULONG ulRet = 0;
|
|
HAND16 hdc16;
|
|
HANDLE hdc32;
|
|
register PCLOSEMETAFILE16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(CLOSEMETAFILE16), parg16);
|
|
|
|
hdc16 = (HAND16)parg16->f1;
|
|
hdc32 = HDC32(hdc16);
|
|
hmf = CloseMetaFile(hdc32);
|
|
|
|
// update our GDI handle mapping table
|
|
DeleteWOWGdiHandle(hdc32, hdc16);
|
|
|
|
if (hmf)
|
|
ulRet = (ULONG)WinMetaFileFromHMF(hmf, TRUE);
|
|
// WARNING: 16-bit memory may have moved - invalidate flat pointers now
|
|
FREEVDMPTR(pFrame);
|
|
FREEARGPTR(parg16);
|
|
RETURN(ulRet);
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WG32CopyMetaFile(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
PSZ psz2;
|
|
HMETAFILE hmfNew;
|
|
HMETAFILE hmf;
|
|
register PCOPYMETAFILE16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(COPYMETAFILE16), parg16);
|
|
GETPSZPTR(parg16->f2, psz2);
|
|
|
|
if (psz2) {
|
|
hmf = HMFFromWinMetaFile(parg16->f1, FALSE);
|
|
hmfNew = CopyMetaFile(hmf, psz2);
|
|
DeleteMetaFile(hmf);
|
|
ul = (ULONG)WinMetaFileFromHMF(hmfNew, TRUE);
|
|
// WARNING: 16-bit memory may have moved - invalidate flat pointers now
|
|
FREEVDMPTR(pFrame);
|
|
FREEARGPTR(parg16);
|
|
FREEPSZPTR(psz2);
|
|
} else {
|
|
UINT cb;
|
|
VPVOID vp, vpNew;
|
|
PBYTE pMF, pMFNew;
|
|
HAND16 h16New, h16;
|
|
|
|
h16 = (HAND16)parg16->f1;
|
|
|
|
ul = (ULONG) NULL;
|
|
|
|
vp = GlobalLock16(h16, &cb);
|
|
if (vp) {
|
|
|
|
/*
|
|
* Windows app such as WinWord uses GlobalSize to determine
|
|
* the size of the metafile. However, this size can be larger
|
|
* than the true size of a metafile. We have to make sure that
|
|
* both source and destination sizes are identical so that
|
|
* WinWord doesn't crash.
|
|
*/
|
|
|
|
vpNew = GlobalAllocLock16(GMEM_MOVEABLE | GMEM_DDESHARE, cb, &h16New);
|
|
|
|
// 16-bit memory may have moved - invalidate flat pointers now
|
|
FREEVDMPTR(pFrame);
|
|
FREEARGPTR(parg16);
|
|
FREEPSZPTR(psz2);
|
|
|
|
if (vpNew) {
|
|
GETMISCPTR(vp, pMF);
|
|
GETOPTPTR(vpNew, 0, pMFNew);
|
|
|
|
RtlCopyMemory(pMFNew, pMF, cb);
|
|
|
|
GlobalUnlock16(h16New);
|
|
FLUSHVDMPTR(vpNew, cb, pMFNew);
|
|
FREEOPTPTR(pMFNew);
|
|
ul = h16New;
|
|
}
|
|
|
|
GlobalUnlock16(h16);
|
|
FREEMISCPTR(pMF);
|
|
}
|
|
}
|
|
|
|
FREEPSZPTR(psz2);
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WG32CreateMetaFile(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
PSZ psz1;
|
|
register PCREATEMETAFILE16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(CREATEMETAFILE16), parg16);
|
|
GETPSZPTR(parg16->f1, psz1);
|
|
|
|
ul = GETHDC16(CreateMetaFile(psz1));
|
|
|
|
FREEPSZPTR(psz1);
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
//
|
|
// This routine does what the 16-bit parameter validation layer would
|
|
// normally do for metafile handles, but since it is currently disabled,
|
|
// we'll do it here to fix WordPerfect that relies on it. Once true
|
|
// win31-style parameter validation has been re-enabled for metafile
|
|
// handles, all code within the ifndefs here and in WG32DeleteMetaFile
|
|
// can be removed.
|
|
//
|
|
#ifndef PARAMETER_VALIDATION_16_RE_ENABLED
|
|
#define MEMORYMETAFILE 1
|
|
#define DISKMETAFILE 2
|
|
#define HEADERSIZE (sizeof(METAHEADER)/sizeof(WORD))
|
|
#define METAVERSION 0x0300
|
|
#define METAVERSION100 0x0100
|
|
|
|
BOOL IsValidMetaFile16(PMETAHEADER16 lpMetaData)
|
|
{
|
|
BOOL sts = FALSE;
|
|
|
|
sts = (lpMetaData->mtType == MEMORYMETAFILE ||
|
|
lpMetaData->mtType == DISKMETAFILE) &&
|
|
(lpMetaData->mtHeaderSize == HEADERSIZE) &&
|
|
((lpMetaData->mtVersion ==METAVERSION) ||
|
|
(lpMetaData->mtVersion ==METAVERSION100)) ;
|
|
return sts;
|
|
}
|
|
#endif
|
|
|
|
ULONG FASTCALL WG32DeleteMetaFile(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul = FALSE;
|
|
VPVOID vp;
|
|
#ifndef PARAMETER_VALIDATION_16_RE_ENABLED
|
|
PMETAHEADER16 lpMetaData;
|
|
#endif
|
|
|
|
register PDELETEMETAFILE16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(DELETEMETAFILE16), parg16);
|
|
|
|
if (vp = GlobalLock16(parg16->f1,NULL)) {
|
|
#ifdef PARAMETER_VALIDATION_16_RE_ENABLED
|
|
GlobalUnlockFree16(vp);
|
|
ul = TRUE;
|
|
#else
|
|
GETVDMPTR(vp, 1, lpMetaData);
|
|
|
|
if (IsValidMetaFile16(lpMetaData)) {
|
|
GlobalUnlockFree16(vp);
|
|
ul = TRUE;
|
|
}
|
|
|
|
FREEVDMPTR(lpMetaData);
|
|
#endif
|
|
}
|
|
|
|
|
|
// If this metafile was in DDE conversation, then DDE cleanup code
|
|
// needs to free its 32 bit counter part. So give DDE clean up
|
|
// code a chance.
|
|
// ChandanC
|
|
|
|
W32DdeFreeHandle16 (parg16->f1);
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
INT WG32EnumMetaFileCallBack(HDC hdc, LPHANDLETABLE lpht, LPMETARECORD lpMR, LONG nObj, PMETADATA pMetaData )
|
|
{
|
|
INT iReturn;
|
|
DWORD nWords;
|
|
|
|
// update object table if we have one
|
|
if (pMetaData->parmemp.vpHandleTable)
|
|
PUTHANDLETABLE16(pMetaData->parmemp.vpHandleTable, nObj, lpht);
|
|
|
|
// update MetaRecord
|
|
|
|
// don't trash the heap with a bogus record, halt the enumeration
|
|
nWords = lpMR->rdSize;
|
|
if (nWords > pMetaData->mtMaxRecordSize) {
|
|
LOGDEBUG(0,("WOW:bad metafile record during enumeration\n"));
|
|
WOW32ASSERT(FALSE); // contact barryb
|
|
return 0; // all done
|
|
}
|
|
putstr16(pMetaData->parmemp.vpMetaRecord, (LPSZ)lpMR, nWords*sizeof(WORD));
|
|
|
|
CallBack16(RET_ENUMMETAFILEPROC, (PPARM16)&pMetaData->parmemp, pMetaData->vpfnEnumMetaFileProc, (PVPVOID)&iReturn);
|
|
|
|
// update the metarec in case the app altered it (Approach does)
|
|
getstr16(pMetaData->parmemp.vpMetaRecord, (LPSZ)lpMR, nWords*sizeof(WORD));
|
|
|
|
// update object table if we have one
|
|
if (pMetaData->parmemp.vpHandleTable)
|
|
GETHANDLETABLE16(pMetaData->parmemp.vpHandleTable,nObj,lpht);
|
|
|
|
return (SHORT)iReturn;
|
|
|
|
hdc; // quiet the compilier; we already know the DC
|
|
}
|
|
|
|
ULONG FASTCALL WG32EnumMetaFile(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul = 0;
|
|
register PENUMMETAFILE16 parg16;
|
|
METADATA metadata;
|
|
VPVOID vpMetaFile = (VPVOID) NULL;
|
|
PBYTE pMetaFile;
|
|
HMETAFILE hmf = (HMETAFILE) 0;
|
|
HAND16 hMetaFile16;
|
|
HDC hDC = 0;
|
|
HDC hDC2 = 0;
|
|
|
|
GETARGPTR(pFrame, sizeof(ENUMMETAFILE16), parg16);
|
|
|
|
hMetaFile16 = parg16->f2;
|
|
|
|
metadata.vpfnEnumMetaFileProc = DWORD32(parg16->f3);
|
|
metadata.parmemp.vpData = (VPVOID)DWORD32(parg16->f4);
|
|
metadata.parmemp.vpMetaRecord = (VPVOID) NULL;
|
|
metadata.parmemp.vpHandleTable = (VPVOID) NULL;
|
|
metadata.parmemp.hdc = parg16->f1;
|
|
|
|
// WinWord never calls SetMetaFileBits; they peeked and know that
|
|
// a metafile is really a GlobalHandle in Windows so we have
|
|
// to look for that case.
|
|
|
|
hmf = HMFFromWinMetaFile(hMetaFile16, FALSE);
|
|
if (!hmf)
|
|
goto EMF_Exit;
|
|
|
|
// Get the metafile bits so we can get max record size and number of objects
|
|
|
|
vpMetaFile = GlobalLock16(hMetaFile16, NULL);
|
|
FREEARGPTR(parg16); // memory may have moved
|
|
FREEVDMPTR(pFrame);
|
|
if (!vpMetaFile)
|
|
goto EMF_Exit;
|
|
|
|
GETOPTPTR(vpMetaFile, 0, pMetaFile);
|
|
if (!pMetaFile)
|
|
goto EMF_Exit;
|
|
|
|
metadata.parmemp.nObjects = ((PMETAHEADER16)pMetaFile)->mtNoObjects;
|
|
metadata.mtMaxRecordSize = ((PMETAHEADER16)pMetaFile)->mtMaxRecord;
|
|
|
|
if (metadata.parmemp.nObjects)
|
|
{
|
|
PBYTE pHT;
|
|
|
|
DWORD cb = ((PMETAHEADER16)pMetaFile)->mtNoObjects*sizeof(HAND16);
|
|
|
|
metadata.parmemp.vpHandleTable =
|
|
GlobalAllocLock16(GMEM_MOVEABLE, cb, NULL);
|
|
|
|
FREEOPTPTR(pMetaFile); // memory may have moved
|
|
FREEARGPTR(parg16);
|
|
FREEVDMPTR(pFrame);
|
|
|
|
if (!metadata.parmemp.vpHandleTable)
|
|
goto EMF_Exit;
|
|
|
|
GETOPTPTR(metadata.parmemp.vpHandleTable, 0, pHT);
|
|
RtlZeroMemory(pHT, cb);
|
|
}
|
|
|
|
metadata.parmemp.vpMetaRecord = GlobalAllocLock16(GMEM_MOVEABLE, metadata.mtMaxRecordSize*sizeof(WORD), NULL);
|
|
FREEOPTPTR(pMetaFile); // memory may have moved
|
|
FREEARGPTR(parg16);
|
|
FREEVDMPTR(pFrame);
|
|
if (!metadata.parmemp.vpMetaRecord)
|
|
goto EMF_Exit;
|
|
|
|
hDC = HDC32(metadata.parmemp.hdc);
|
|
|
|
// Corel Draw passes a NULL hDC, we'll create a dummy to keep GDI32 happy.
|
|
if (CURRENTPTD()->dwWOWCompatFlags & WOWCF_GETDUMMYDC) {
|
|
if (hDC == 0) {
|
|
hDC = CreateMetaFile(NULL);
|
|
hDC2 = hDC;
|
|
}
|
|
}
|
|
|
|
// When processing metafile, access2.0 faults while receiving
|
|
// WM_DEVMODECHANGE so we block that particular message when
|
|
// in EnumMetaFile
|
|
|
|
if ( CURRENTPTD()->dwWOWCompatFlagsEx & WOWCFEX_EATDEVMODEMSG) {
|
|
CURRENTPTD()->dwFlags |= TDF_EATDEVMODEMSG;
|
|
}
|
|
ul = GETBOOL16(EnumMetaFile(hDC,
|
|
hmf,
|
|
(MFENUMPROC)WG32EnumMetaFileCallBack,
|
|
((LPARAM)(LPVOID)&metadata)));
|
|
|
|
|
|
CURRENTPTD()->dwFlags &= ~TDF_EATDEVMODEMSG;
|
|
|
|
|
|
// 16-bit memory may have moved - nothing to do as no flat ptrs exist now
|
|
|
|
// copy the 32-bit metafile back to 16-bit land (the app may have altered
|
|
// some of the metarecs in its MetaRecCallBackFunc -- Approach does)
|
|
CopyMetaFile16FromHMF32(hMetaFile16, hmf);
|
|
|
|
// Cleanup the dummy hDC created for Corel Draw 5.0.
|
|
if (CURRENTPTD()->dwWOWCompatFlags & WOWCF_GETDUMMYDC) {
|
|
if (hDC2 != 0) {
|
|
DeleteMetaFile(CloseMetaFile(hDC2));
|
|
}
|
|
}
|
|
|
|
EMF_Exit:
|
|
if (vpMetaFile)
|
|
GlobalUnlock16(hMetaFile16);
|
|
|
|
if (hmf)
|
|
DeleteMetaFile(hmf);
|
|
|
|
if (metadata.parmemp.vpHandleTable)
|
|
GlobalUnlockFree16(metadata.parmemp.vpHandleTable);
|
|
|
|
if (metadata.parmemp.vpMetaRecord)
|
|
GlobalUnlockFree16(metadata.parmemp.vpMetaRecord);
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
|
|
|
|
ULONG FASTCALL WG32GetMetaFile(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
PSZ psz1;
|
|
HMETAFILE hmf;
|
|
register PGETMETAFILE16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(GETMETAFILE16), parg16);
|
|
GETPSZPTR(parg16->f1, psz1);
|
|
|
|
hmf = GetMetaFile(psz1);
|
|
|
|
if (hmf)
|
|
ul = WinMetaFileFromHMF(hmf, TRUE);
|
|
else
|
|
ul = 0;
|
|
|
|
FREEPSZPTR(psz1);
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WG32PlayMetaFile(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
HMETAFILE hmf;
|
|
register PPLAYMETAFILE16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(PLAYMETAFILE16), parg16);
|
|
|
|
hmf = HMFFromWinMetaFile(parg16->f2, FALSE);
|
|
|
|
ul = GETBOOL16(PlayMetaFile(HDC32(parg16->f1), hmf));
|
|
|
|
if (hmf)
|
|
DeleteMetaFile(hmf);
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
ULONG FASTCALL WG32PlayMetaFileRecord(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul = FALSE;
|
|
LPHANDLETABLE pHT = NULL;
|
|
PBYTE pMetaData;
|
|
PMETARECORD pMetaRec;
|
|
HANDLE hDeleteObject32 = NULL;
|
|
HAND16 hDeleteObject16 = 0;
|
|
WORD wHandles;
|
|
VPHANDLETABLE16 vpHT;
|
|
register PPLAYMETAFILERECORD16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(PLAYMETAFILERECORD16), parg16);
|
|
|
|
wHandles = parg16->f4;
|
|
vpHT = parg16->f2;
|
|
if (wHandles && vpHT) {
|
|
ALLOCHANDLETABLE16(wHandles, pHT);
|
|
if (!pHT)
|
|
goto PMFR_Exit;
|
|
|
|
GETHANDLETABLE16(vpHT, wHandles, pHT);
|
|
}
|
|
GETOPTPTR(parg16->f3, 0, pMetaData);
|
|
|
|
// If the record is a DeleteObject record, save the index into the metafile
|
|
// handle table.
|
|
pMetaRec = (PMETARECORD)pMetaData;
|
|
if(pMetaRec) {
|
|
if(pMetaRec->rdFunction == META_DELETEOBJECT) {
|
|
hDeleteObject32 = pHT->objectHandle[pMetaRec->rdParm[0]];
|
|
hDeleteObject16 = GDI16(hDeleteObject32);
|
|
}
|
|
}
|
|
|
|
ul = (ULONG) PlayMetaFileRecord(HDC32(parg16->f1),
|
|
pHT,
|
|
(LPMETARECORD)pMetaData,
|
|
(UINT)wHandles);
|
|
|
|
if (wHandles && vpHT) {
|
|
|
|
// This will cause any handles that were created implicitly by the call
|
|
// PlayMetaFileRecord() & added to the metafile handle table (pHT) to be
|
|
// added to our GDI handle mapping table.
|
|
PUTHANDLETABLE16(vpHT, wHandles, pHT);
|
|
|
|
FREEHANDLETABLE16(pHT);
|
|
}
|
|
|
|
// Remove the handle associated with this DeleteObject record from the GDI
|
|
// handle mapping table.
|
|
if(hDeleteObject16) {
|
|
DeleteWOWGdiHandle((HANDLE)hDeleteObject32, hDeleteObject16);
|
|
}
|
|
|
|
PMFR_Exit:
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
#if 0 // implemented in gdi.exe
|
|
|
|
ULONG FASTCALL WG32GetMetaFileBits(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul = 0;
|
|
register PGETMETAFILEBITS16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(GETMETAFILEBITS16), parg16);
|
|
|
|
if (GlobalLock16(parg16->f1,NULL))
|
|
{
|
|
GlobalUnlock16(parg16->f1);
|
|
ul = parg16->f1;
|
|
}
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
ULONG FASTCALL WG32SetMetaFileBits(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
register PSETMETAFILEBITS16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(SETMETAFILEBITS16), parg16);
|
|
|
|
ul = parg16->f1;
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
#endif
|