1538 lines
30 KiB
Plaintext
1538 lines
30 KiB
Plaintext
__foldwin32sstuff __foldwin32sstuff;
|
|
foldstyleinitialization = true;
|
|
|
|
|
|
|
|
enablemapdirect3216 = true;
|
|
|
|
flatthunks = true;
|
|
|
|
#include "types.thk"
|
|
#include "gditypes.thk"
|
|
|
|
|
|
/* _GetCharWidthA@16 converts wLastChar to nCnt for the thunk compiler's
|
|
* benefit. We use the "push" macro to convert it back.
|
|
*/
|
|
BOOL GetCharWidth( HDC hDC, UINT wFirstChar, UINT nCnt, LPINT lpBuffer) =
|
|
BOOL GetCharWidthAWrapper( HDC hDC, UINT wFirstChar, UINT nCnt, LPINT lpBuffer)
|
|
{
|
|
nCnt = push;
|
|
nCnt = countof lpBuffer;
|
|
lpBuffer = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL GetCharWidthW( HDC hDC, UINT wFirstChar, UINT nCnt, LPINT lpBuffer) =
|
|
BOOL GetCharWidthWWrapper( HDC hDC, UINT wFirstChar, UINT nCnt, LPINT lpBuffer)
|
|
{
|
|
nCnt = push;
|
|
nCnt = countof lpBuffer;
|
|
lpBuffer = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
/* _GetCharABCWidthsA@16 converts wLastChar to nCnt for the thunk compiler's
|
|
* benefit. We use the "push" macro to convert it back.
|
|
*/
|
|
BOOL GetCharABCWidths(HDC, UINT, UINT nCnt, LPABC lpabc) =
|
|
BOOL GetCharABCWidthsAWrapper(HDC, UINT, UINT nCnt, LPABC lpabc)
|
|
{
|
|
nCnt = push;
|
|
nCnt = countof lpabc;
|
|
lpabc = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* CreateDIBSection needs an extra parameter in the thunk so the 16-bit
|
|
* can distinguish whether it was called from Win32 or Win16. It returns
|
|
* pointer as a linear address or sel:off accordingly.
|
|
*/
|
|
|
|
HANDLE CDSInternal(HDC, LPSTR, UINT, LPSTR, DWORD, DWORD, BOOL) =
|
|
HANDLE ThkCreateDIBSection(HDC, LPSTR, UINT, LPSTR, DWORD, DWORD, BOOL)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
/* DrawEscape may need a buffer that is greater than 64K for lpszInData.
|
|
* The 16-bit entry point will handle this by calling SetSelectorBase()
|
|
* on the selector before calling the driver. It does not restore the
|
|
* selector base on return, however.
|
|
*/
|
|
LONG DrawEscape( HDC hdc, LONG nEscape, LONG cbInput, LPSTR lpszInData) =
|
|
LONG DrawEscape( HDC hdc, LONG nEscape, LONG cbInput, LPSTR lpszInData)
|
|
{
|
|
faulterrorcode = -1;
|
|
}
|
|
|
|
BOOL Polyline( HDC, LPPOINT lpPoints, UINT nCount) =
|
|
BOOL Polyline( HDC, LPPOINT lpPoints, UINT nCount)
|
|
{
|
|
nCount = countof lpPoints;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL PolylineTo( HDC, LPPOINT lpPoints, UINT nCount) =
|
|
BOOL PolylineTo( HDC, LPPOINT lpPoints, UINT nCount)
|
|
{
|
|
nCount = countof lpPoints;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL Polygon( HDC, LPPOINT lpPoints, UINT nCount) =
|
|
BOOL Polygon( HDC, LPPOINT lpPoints, UINT nCount)
|
|
{
|
|
nCount = countof lpPoints;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
HRGN CreatePolygonRgn( LPPOINT lpPoints, UINT nCount, INT) =
|
|
HRGN CreatePolygonRgn( LPPOINT lpPoints, UINT nCount, INT)
|
|
{
|
|
nCount = countof lpPoints;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL PolyBezier(HDC, LPPOINT lpPoints, UINT nCount) =
|
|
BOOL PolyBezier(HDC, LPPOINT lpPoints, UINT nCount)
|
|
{
|
|
nCount = countof lpPoints;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL PolyBezierTo(HDC, LPPOINT lpPoints, UINT nCount) =
|
|
BOOL PolyBezierTo(HDC, LPPOINT lpPoints, UINT nCount)
|
|
{
|
|
nCount = countof lpPoints;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* Notes:
|
|
* - ppt and pcnt have already been packed to shorts
|
|
*/
|
|
BOOL PolyPolygon(HDC, DWORD *ppt, DWORD *pcnt, UINT nCount) =
|
|
BOOL ThkPolyPolygon(HDC, DWORD *ppt, DWORD *pcnt, UINT nCount)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* Notes:
|
|
* - ppt and pcnt have already been packed to shorts
|
|
*/
|
|
HRGN CreatePolyPolygonRgn(DWORD *ppt, DWORD *pcnt, UINT nPolys, UINT fillMode) =
|
|
HRGN ThkCreatePolyPolygonRgn(DWORD *ppt, DWORD *pcnt, UINT nPolys, UINT fillMode)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* Notes:
|
|
* - _PolyPolyline@16 computes the sum of lpct and passes it in as nPt.
|
|
* - nPt remains a DWORD because 16-bit wrapper uses it for scratch space.x
|
|
*/
|
|
UINT PolyPolylineWrapper(DWORD nPt, HDC hdc, LPPOINT lppt, LPINT lpct, UINT nCt) =
|
|
UINT PolyPolylineWrapper(DWORD nPt, HDC hdc, LPPOINT lppt, LPINT lpct, UINT nCt)
|
|
{
|
|
nCt = countof lpct;
|
|
nPt = countof lppt;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL DPtoLP( HDC, LPPOINT lpPoints, UINT nCount) =
|
|
BOOL DPtoLP( HDC, LPPOINT lpPoints, UINT nCount)
|
|
{
|
|
nCount = countof lpPoints;
|
|
lpPoints = inout;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL LPtoDP( HDC, LPPOINT lpPoints, UINT nCount) =
|
|
BOOL LPtoDP( HDC, LPPOINT lpPoints, UINT nCount)
|
|
{
|
|
nCount = countof lpPoints;
|
|
lpPoints = inout;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
BOOL ExtTextOut( HDC hDC, INT X, INT Y, UINT fOptions,
|
|
LPRECT lpRect, LPSTR lpString, UINT nCount, LPINT lpDx) =
|
|
BOOL ExtTextOutA( HDC hDC, INT X, INT Y, UINT fOptions,
|
|
LPRECT lpRect, LPSTR lpString, UINT nCount, LPINT lpDx)
|
|
{
|
|
nCount = countof lpDx;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL ExtTextOutW( HDC hDC, INT X, INT Y, UINT fOptions,
|
|
LPRECT lpRect, LPSTR lpString, UINT nCount, LPINT lpDx) =
|
|
BOOL ExtTextOutW( HDC hDC, INT X, INT Y, UINT fOptions,
|
|
LPRECT lpRect, LPSTR lpString, UINT nCount, LPINT lpDx)
|
|
{
|
|
nCount = countof lpDx;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HMF GetMetaFileEx( LPSTR, BOOL) =
|
|
HMF GetMetaFileEx( LPSTR, BOOL)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
HMF CopyMetaFile( HMF, LPSTR) =
|
|
HMF CopyMetaFileA( HMF, LPSTR)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
HMF CreateMetaFile( LPSTR) =
|
|
HMF CreateMetaFileA( LPSTR)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
HBRUSH CreateBrushIndirect( PLOGBRUSH) =
|
|
HBRUSH ThkCreateBrushIndirect( PLOGBRUSH)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
HRGN CreateRectRgnIndirect( LPRECT) =
|
|
HRGN ThkCreateRectRgnIndirect( LPRECT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
HRGN CreateEllipticRgnIndirect( LPRECT) =
|
|
HRGN ThkCreateEllipticRgnIndirect( LPRECT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
INT GetClipBox( HDC, LPRECT lpRect) =
|
|
INT GetClipBox( HDC, LPRECT lpRect)
|
|
{
|
|
lpRect = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
HPALETTE CreateHalftonePalette(HDC) =
|
|
HPALETTE CreateHalftonePalette(HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
HPALETTE CreatePalette( LPLOGPALETTE) =
|
|
HPALETTE CreatePalette( LPLOGPALETTE)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/*
|
|
* LPPALETTEENTRY does not need to be repacked.
|
|
*/
|
|
void AnimatePalette( HPALETTE, WORD, WORD cEntries, LPPALETTEENTRY lppe) =
|
|
voidtotrue void AnimatePalette( HPALETTE, DWORD, DWORD cEntries, LPPALETTEENTRY lppe)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* LPPALETTEENTRY does not need to be repacked.
|
|
*/
|
|
WORD SetPaletteEntries( HPALETTE, WORD, WORD cEntries, LPPALETTEENTRY lppe) =
|
|
DWORD SetPaletteEntries( HPALETTE, DWORD, DWORD cEntries, LPPALETTEENTRY lppe)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* LPPALETTEENTRY does not need to be repacked.
|
|
*/
|
|
WORD GetPaletteEntries( HPALETTE, WORD, WORD cEntries, LPPALETTEENTRY lppe) =
|
|
DWORD GetPaletteEntries( HPALETTE, DWORD, DWORD cEntries, LPPALETTEENTRY lppe)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* LPPALETTEENTRY does not need to be repacked.
|
|
*/
|
|
WORD GetSystemPaletteEntries( HDC, WORD, WORD cEntries, LPPALETTEENTRY lppe) =
|
|
DWORD GetSystemPaletteEntries( HDC, DWORD, DWORD cEntries, LPPALETTEENTRY lppe)
|
|
{
|
|
faulterrorcode = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* lpPoint actually is LPSIZE */
|
|
BOOL GetBitmapDimensionEx( HBITMAP, LPPOINT lpPoint) =
|
|
BOOL GetBitmapDimensionEx( HBITMAP, LPPOINT lpPoint)
|
|
{ lpPoint = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* lpPoint actually is LPSIZE */
|
|
BOOL GetTextExtentPoint( HDC, LPSTR, INT, LPPOINT lpPoint) =
|
|
BOOL GetTextExtentPointA( HDC, LPSTR, INT, LPPOINT lpPoint)
|
|
{
|
|
lpPoint = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* lpPoint actually is LPSIZE */
|
|
BOOL GetTextExtentPoint( HDC, LPSTR, INT, LPPOINT lpPoint) =
|
|
BOOL GetTextExtentPoint32A( HDC, LPSTR, INT, LPPOINT lpPoint)
|
|
{
|
|
lpPoint = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* lpPoint actually is LPSIZE */
|
|
BOOL GetTextExtentPointW( HDC, LPSTR, INT, LPPOINT lpPoint) =
|
|
BOOL GetTextExtentPointW( HDC, LPSTR, INT, LPPOINT lpPoint)
|
|
{
|
|
lpPoint = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* lpPoint actually is LPSIZE */
|
|
BOOL GetTextExtentPointW( HDC, LPSTR, INT, LPPOINT lpPoint) =
|
|
BOOL GetTextExtentPoint32W( HDC, LPSTR, INT, LPPOINT lpPoint)
|
|
{
|
|
lpPoint = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL OffsetViewportOrgEx( HDC, INT, INT, LPPOINT lpPoint) =
|
|
BOOL OffsetViewportOrgEx( HDC, INT, INT, LPPOINT lpPoint)
|
|
{ lpPoint = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL OffsetWindowOrgEx( HDC, INT, INT, LPPOINT lpPoint) =
|
|
BOOL OffsetWindowOrgEx( HDC, INT, INT, LPPOINT lpPoint)
|
|
{ lpPoint = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL ScaleViewportExtEx( HDC, INT, INT, INT, INT, LPPOINT lpPoint) =
|
|
BOOL ScaleViewportExtEx( HDC, INT, INT, INT, INT, LPPOINT lpPoint)
|
|
{ lpPoint = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL ScaleWindowExtEx( HDC, INT, INT, INT, INT, LPPOINT lpPoint) =
|
|
BOOL ScaleWindowExtEx( HDC, INT, INT, INT, INT, LPPOINT lpPoint)
|
|
{ lpPoint = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* lpPoint actually is LPSIZE */
|
|
BOOL SetBitmapDimensionEx( HBITMAP, INT, INT, LPPOINT lpPoint) =
|
|
BOOL SetBitmapDimensionEx( HBITMAP, INT, INT, LPPOINT lpPoint)
|
|
{ lpPoint = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* lpPoint actually is LPSIZE */
|
|
BOOL SetViewportExtEx( HDC, INT, INT, LPPOINT lpPoint) =
|
|
BOOL SetViewportExtEx( HDC, INT, INT, LPPOINT lpPoint)
|
|
{ lpPoint = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* lpPoint actually is LPSIZE */
|
|
BOOL SetViewportOrgEx( HDC, INT, INT, LPPOINT lpPoint) =
|
|
BOOL SetViewportOrgEx( HDC, INT, INT, LPPOINT lpPoint)
|
|
{ lpPoint = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* lpPoint actually is LPSIZE */
|
|
BOOL SetWindowExtEx( HDC, INT, INT, LPPOINT lpPoint) =
|
|
BOOL SetWindowExtEx( HDC, INT, INT, LPPOINT lpPoint)
|
|
{ lpPoint = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL SetWindowOrgEx( HDC, INT, INT, LPPOINT lpPoint) =
|
|
BOOL SetWindowOrgEx( HDC, INT, INT, LPPOINT lpPoint)
|
|
{ lpPoint = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL MoveToEx( HDC, INT, INT, LPPOINT lpPoint) =
|
|
BOOL MoveToEx( HDC, INT, INT, LPPOINT lpPoint)
|
|
{ lpPoint = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL AbortPath(HDC) =
|
|
BOOL AbortPath(HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL BeginPath(HDC) =
|
|
BOOL BeginPath(HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL CloseFigure(HDC) =
|
|
BOOL CloseFigure(HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL EndPath(HDC) =
|
|
BOOL EndPath(HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL FillPath(HDC) =
|
|
BOOL FillPath(HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL FlattenPath(HDC) =
|
|
BOOL FlattenPath(HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOL PathToRegion(HDC) =
|
|
BOOL PathToRegion(HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL SelectClipPath(HDC, INT) =
|
|
BOOL SelectClipPath(HDC, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL StrokeAndFillPath(HDC) =
|
|
BOOL StrokeAndFillPath(HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL StrokePath(HDC) =
|
|
BOOL StrokePath(HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL WidenPath(HDC) =
|
|
BOOL WidenPath(HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
INT GetArcDirection(HDC) =
|
|
INT GetArcDirection(HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
INT SetArcDirection(HDC, INT) =
|
|
INT SetArcDirection(HDC, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL GetMiterLimit(HDC, LPDWORD) =
|
|
BOOL GetMiterLimit(HDC, LPDWORD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL SetMiterLimit(HDC, DWORD, LPDWORD) =
|
|
BOOL SetMiterLimit(HDC, DWORD, LPDWORD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL ExtCreatePen(DWORD, DWORD, LPNTLOGBRUSH, DWORD, DWORD) =
|
|
BOOL ExtCreatePen(DWORD, DWORD, LPNTLOGBRUSH, DWORD, DWORD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
INT ExtSelectClipRgn(HDC, HRGN, INT) =
|
|
INT ExtSelectClipRgn32(HDC, HRGN, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
INT SetMetaRgn(HDC) =
|
|
INT SetMetaRgn(HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
HEMF CloseEnhMetaFile(HDC) =
|
|
HEMF CloseEnhMetaFile(HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL MF_GdiCommentWindowsMetaFile(HDC, DWORD, LPSTR) =
|
|
BOOL MF_GdiCommentWindowsMetaFile(HDC, DWORD, LPSTR)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
HEMF CopyEnhMetaFile(HEMF, LPFILENAME) =
|
|
HEMF CopyEnhMetaFileA(HEMF, LPFILENAME)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* LPSTR is a description string which may exceed 64k. We'll truncate
|
|
* it on the 16-bit side so as not to fault. !!!
|
|
*/
|
|
HDC CreateEnhMetaFile(HDC, LPFILENAME, LPRECTL, LPSTR) =
|
|
HDC CreateEnhMetaFileA(HDC, LPFILENAME, LPRECTL, LPSTR)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL DeleteEnhMetaFile(HEMF) =
|
|
BOOL DeleteEnhMetaFile(HEMF)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
HEMF GetEnhMetaFile(LPFILENAME) =
|
|
HEMF GetEnhMetaFileA(LPFILENAME)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
ULONG GetEnhMetaFileHeader(HEMF, ULONG, LPENHMETAHEADER) =
|
|
ULONG GetEnhMetaFileHeader(HEMF, ULONG, LPENHMETAHEADER)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
UINT GetDIBColorTable(HDC, UINT, UINT, LPRGBQUAD) =
|
|
UINT GetDIBColorTable(HDC, UINT, UINT, LPRGBQUAD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
UINT SetDIBColorTable(HDC, UINT, UINT, LPRGBQUAD) =
|
|
UINT SetDIBColorTable(HDC, UINT, UINT, LPRGBQUAD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
HANDLE SetObjectOwner(HANDLE, hinstance) =
|
|
HANDLE ThkSetObjectOwner(HANDLE, hinstance)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
void WalkGDIHeaps(WORD, WORD) =
|
|
void ThkWalkGDIHeaps(WORD, WORD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
INT SetICMMode(HDC, INT) =
|
|
INT SetICMMode(HDC, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL CheckColorsInGamut(HDC,LPSTR,LPSTR,DWORD) =
|
|
BOOL CheckColorsInGamut(HDC,LPSTR,LPSTR,DWORD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
HANDLE GetColorSpace(HDC) =
|
|
HANDLE GetColorSpace(HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL GetLogColorSpace(HCOLORSPACE,LPVOID,WORD) =
|
|
BOOL GetLogColorSpaceA(HCOLORSPACE,LPVOID,DWORD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
HCOLORSPACE CreateColorSpace(LPLOGCOLORSPACE) =
|
|
HCOLORSPACE CreateColorSpaceA(LPLOGCOLORSPACE)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL SetColorSpace(HDC,HCOLORSPACE) =
|
|
BOOL SetColorSpace(HDC,HCOLORSPACE)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL DeleteColorSpace(HCOLORSPACE) =
|
|
BOOL DeleteColorSpace(HCOLORSPACE)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL ColorMatchToTarget(HDC,HDC,WORD) =
|
|
BOOL ColorMatchToTarget(HDC,HDC,DWORD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL GetICMProfile(HDC,LPINT,LPSTR) =
|
|
BOOL GetICMProfileA(HDC,LPINT,LPSTR)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL SetICMProfile(HDC,LPSTR) =
|
|
BOOL SetICMProfileA(HDC,LPSTR)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL GetDeviceGammaRamp(HDC,LPVOID) =
|
|
BOOL GetDeviceGammaRamp(HDC,LPVOID)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL SetDeviceGammaRamp(HDC,LPVOID) =
|
|
BOOL SetDeviceGammaRamp(HDC,LPVOID)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
INT ColorCorrectPalette(HDC, HPALETTE, WORD, WORD) =
|
|
INT ColorCorrectPalette(HDC, HPALETTE, DWORD, DWORD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
BOOL UnrealizeObject( HBRUSH) =
|
|
BOOL UnrealizeObject( HBRUSH)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
HDC CreateCompatibleDC( HDC) =
|
|
HDC CreateCompatibleDC( HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL DeleteDC( HDC hDC) =
|
|
BOOL DeleteDC( HDC hDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
INT SaveDC( HDC) =
|
|
INT SaveDC( HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL RestoreDC( HDC, INT) =
|
|
BOOL RestoreDC( HDC, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL LineTo( HDC, INT, INT) =
|
|
BOOL LineTo( HDC, INT, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL Rectangle( HDC, INT, INT, INT, INT) =
|
|
BOOL Rectangle( HDC, INT, INT, INT, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL RoundRect( HDC, INT, INT, INT, INT, INT, INT) =
|
|
BOOL RoundRect( HDC, INT, INT, INT, INT, INT, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL Ellipse( HDC, INT, INT, INT, INT) =
|
|
BOOL Ellipse( HDC, INT, INT, INT, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL Arc( HDC, INT, INT, INT, INT, INT, INT, INT, INT) =
|
|
BOOL Arc( HDC, INT, INT, INT, INT, INT, INT, INT, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL Chord( HDC, INT, INT, INT, INT, INT, INT, INT, INT) =
|
|
BOOL Chord( HDC, INT, INT, INT, INT, INT, INT, INT, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL Pie( HDC, INT, INT, INT, INT, INT, INT, INT, INT) =
|
|
BOOL Pie( HDC, INT, INT, INT, INT, INT, INT, INT, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL PatBlt( HDC, INT, INT, INT, INT, DWORD) =
|
|
BOOL PatBlt( HDC, INT, INT, INT, INT, DWORD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL BitBlt( HDC, INT, INT, INT, INT, HDC, INT, INT, DWORD) =
|
|
BOOL BitBlt( HDC, INT, INT, INT, INT, HDC, INT, INT, DWORD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL StretchBlt( HDC, INT, INT, INT, INT, HDC, INT, INT, INT, INT, DWORD) =
|
|
BOOL StretchBlt( HDC, INT, INT, INT, INT, HDC, INT, INT, INT, INT, DWORD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
DWORD SetPixel( HDC, INT, INT, DWORD) =
|
|
DWORD SetPixel( HDC, INT, INT, DWORD)
|
|
{
|
|
faulterrorcode = -1;
|
|
}
|
|
|
|
|
|
DWORD GetPixel( HDC, INT, INT) =
|
|
DWORD GetPixel( HDC, INT, INT)
|
|
{
|
|
faulterrorcode = -1;
|
|
}
|
|
|
|
|
|
BOOL ExtFloodFill( HDC, INT, INT, DWORD, WORD) =
|
|
BOOL ExtFloodFill( HDC, INT, INT, DWORD, DWORD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL FloodFill( HDC, INT, INT, DWORD) =
|
|
BOOL FloodFill( HDC, INT, INT, DWORD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
HPEN CreatePen( INT, INT, DWORD) =
|
|
HPEN CreatePen( INT, INT, DWORD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
HBRUSH CreateSolidBrush( DWORD) =
|
|
HBRUSH CreateSolidBrush( DWORD)
|
|
{ faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
HBRUSH CreatePatternBrush( HBITMAP) =
|
|
HBRUSH CreatePatternBrush( HBITMAP)
|
|
{ faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
HBITMAP CreateCompatibleBitmap( HDC, INT, INT) =
|
|
HBITMAP CreateCompatibleBitmap( HDC, INT, INT)
|
|
{ faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
INT SelectClipRgn( HDC, HRGN) =
|
|
INT SelectClipRgn32( HDC, HRGN)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
HRGN CreateRectRgn( INT, INT, INT, INT) =
|
|
HRGN ThkCreateRectRgn( INT, INT, INT, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
void SetRectRgn( HRGN, INT, INT, INT, INT) =
|
|
void ThkSetRectRgn( HRGN, INT, INT, INT, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
HRGN CreateEllipticRgn( INT, INT, INT, INT) =
|
|
HRGN ThkCreateEllipticRgn( INT, INT, INT, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
HRGN CreateRoundRectRgn( INT, INT, INT, INT, INT, INT) =
|
|
HRGN ThkCreateRoundRectRgn( INT, INT, INT, INT, INT, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL DeleteObject( HGDI hObj) =
|
|
BOOL DeleteObject( HGDI hObj)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
HGDI SelectObject( HDC, HGDI) =
|
|
HGDI SelectObject( HDC, HGDI)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
DWORD SetBkColor( HDC, DWORD) =
|
|
DWORD ThkSetBkColor( HDC, DWORD)
|
|
{
|
|
faulterrorcode = -1;
|
|
}
|
|
|
|
|
|
INT SetBkMode( HDC, INT) =
|
|
INT SetBkMode( HDC, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
DWORD SetTextColor( HDC, DWORD) =
|
|
DWORD ThkSetTextColor( HDC, DWORD)
|
|
{
|
|
faulterrorcode = -1;
|
|
}
|
|
|
|
|
|
WORD SetTextAlign( HDC, WORD) =
|
|
DWORD SetTextAlign( HDC, DWORD)
|
|
{ faulterrorcode = -1;
|
|
}
|
|
|
|
INT GetDeviceCaps( HDC, INT) =
|
|
INT ThkGetDeviceCaps( HDC, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
DWORD SetMapperFlags( HDC, DWORD) =
|
|
DWORD SetMapperFlags( HDC, DWORD)
|
|
{ faulterrorcode = -1;
|
|
}
|
|
|
|
|
|
DWORD GetNearestColor( HDC, DWORD) =
|
|
DWORD GetNearestColor( HDC, DWORD)
|
|
{ faulterrorcode = -1;
|
|
}
|
|
|
|
|
|
INT SetROP2( HDC, INT) =
|
|
INT SetROP2( HDC, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
INT SetStretchBltMode( HDC, INT) =
|
|
INT SetStretchBltMode( HDC, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
INT SetPolyFillMode( HDC, INT) =
|
|
INT SetPolyFillMode( HDC, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
INT SetMapMode( HDC, INT) =
|
|
INT SetMapMode( HDC, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
INT IntersectClipRect32( HDC, INT, INT, INT, INT) =
|
|
INT IntersectClipRect( HDC, INT, INT, INT, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
INT OffsetClipRgn( HDC, INT, INT) =
|
|
INT OffsetClipRgn( HDC, INT, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
INT ExcludeClipRect32( HDC, INT, INT, INT, INT) =
|
|
INT ExcludeClipRect( HDC, INT, INT, INT, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL PtVisible( HDC, INT, INT) =
|
|
BOOL PtVisible( HDC, INT, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
INT CombineRgn( HRGN, HRGN, HRGN, INT) =
|
|
INT ThkCombineRgn( HRGN, HRGN, HRGN, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL EqualRgn( HRGN, HRGN) =
|
|
BOOL EqualRgn( HRGN, HRGN)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
INT OffsetRgn( HRGN, INT, INT) =
|
|
INT OffsetRgn( HRGN, INT, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
INT SetTextJustification( HDC, INT, INT) =
|
|
INT SetTextJustification( HDC, INT, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
INT SetTextCharacterExtra( HDC, INT) =
|
|
INT SetTextCharacterExtra( HDC, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
INT GetTextCharacterExtra( HDC) =
|
|
INT GetTextCharacterExtra( HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOL PlayMetaFile( HDC, HMF) =
|
|
BOOL PlayMetaFile( HDC, HMF)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
HMF CloseMetaFile( HDC) =
|
|
HMF CloseMetaFile( HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
INT UpdateColors( HDC hdc) =
|
|
voidtotrue INT UpdateColors( HDC hdc)
|
|
{
|
|
faulterrorcode = 0;
|
|
|
|
}
|
|
|
|
|
|
WORD GetNearestPaletteIndex( HPALETTE, DWORD) =
|
|
DWORD GetNearestPaletteIndex( HPALETTE, DWORD)
|
|
{
|
|
faulterrorcode = -1;
|
|
}
|
|
|
|
|
|
BOOL ResizePalette( HPALETTE, WORD) =
|
|
BOOL ResizePalette( HPALETTE, DWORD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
WORD GetSystemPaletteUse( HDC) =
|
|
DWORD GetSystemPaletteUse( HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
WORD SetSystemPaletteUse( HDC, WORD) =
|
|
DWORD SetSystemPaletteUse( HDC, DWORD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
HBRUSH ThkCreateDIBPatternBrushPt( LPSTR, WORD, DWORD) =
|
|
HBRUSH ThkCreateDIBPatternBrushPt( LPSTR, DWORD, DWORD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
BOOL TextOut( HDC, INT, INT, LPSTR, INT) =
|
|
BOOL TextOutA( HDC, INT, INT, LPSTR, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL TextOutW( HDC, INT, INT, LPSTR, INT) =
|
|
BOOL TextOutW( HDC, INT, INT, LPSTR, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
INT GetTextFace( HDC, INT, LPSTR) =
|
|
INT GetTextFaceA( HDC, INT, LPSTR)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
INT GetTextCharset(HDC)=
|
|
INT GetTextCharset(HDC)
|
|
{
|
|
faulterrorcode = -1;
|
|
}
|
|
|
|
INT GetTextCharsetAndHff(HDC, DWORD *) =
|
|
INT GetTextCharsetAndHff(HDC, DWORD *)
|
|
{
|
|
faulterrorcode = -1;
|
|
}
|
|
|
|
HDC CreateDC( LPSTR lpDriverName, LPSTR lpDeviceName,
|
|
LPSTR lpOutput, LPSTR lpInitData) =
|
|
HDC ThkCreateDC(LPSTR lpDriverName, LPSTR lpDeviceName,
|
|
LPSTR lpOutput, LPSTR lpInitData)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
HDC CreateIC( LPSTR lpDriverName, LPSTR lpDeviceName,
|
|
LPSTR lpOutput, LPSTR lpInitData) =
|
|
HDC ThkCreateIC(LPSTR lpDriverName, LPSTR lpDeviceName,
|
|
LPSTR lpOutput, LPSTR lpInitData)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
HDC ResetDC( HDC, LPSTR lpDevMode) =
|
|
HDC ResetDCA(HDC, LPSTR lpDevMode)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
HFONT CreateFont( int nHeight, int nWidth, int nEscapement,
|
|
int nOrientation, int nWeight,
|
|
BYTE cItalic, BYTE cUnderline, BYTE cStrikeOut, BYTE cCharSet,
|
|
BYTE cOutputPrecision, BYTE cClipPrecision,
|
|
BYTE cQuality, BYTE cPitchAndFamily, LPSTR lpFacename) =
|
|
HFONT CreateFontA( int nHeight, int nWidth, int nEscapement,
|
|
int nOrientation, int nWeight,
|
|
DWORD cItalic, DWORD cUnderline, DWORD cStrikeOut, DWORD cCharSet,
|
|
DWORD cOutputPrecision, DWORD cClipPrecision,
|
|
DWORD cQuality, DWORD cPitchAndFamily, LPSTR lpFacename)
|
|
{
|
|
faulterrorcode = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Win32/DOS:
|
|
* If hi word null, module handle, so GetModuleFileName.
|
|
* Would be nice if GMFN would tell us how big the name is.
|
|
*
|
|
* Win32s:
|
|
* AddFontModule just calls here, so passifhinull is still necessary.
|
|
*/
|
|
int AddFontResource( LPSTR lpFilename) =
|
|
int AddFontResourceA( LPSTR lpFilename)
|
|
{
|
|
lpFilename = passifhinull;
|
|
faulterrorcode = -1;
|
|
}
|
|
|
|
|
|
|
|
|
|
HFONT CreateFontIndirect( LPLOGFONT lpLogFont) =
|
|
HFONT CreateFontIndirectA( LPLOGFONT lpLogFont)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
HBRUSH CreateHatchBrush( UINT nIndex, DWORD crColor) =
|
|
HBRUSH CreateHatchBrush( UINT nIndex, DWORD crColor)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HPEN CreatePenIndirect( LPLOGPEN lpLogPen) =
|
|
HPEN CreatePenIndirect( LPLOGPEN lpLogPen)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOL InvertRgn( HDC hDC, HRGN hRgn) =
|
|
BOOL ThkInvertRgn( HDC hDC, HRGN hRgn)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL PaintRgn( HDC hDC, HRGN hRgn) =
|
|
BOOL ThkPaintRgn( HDC hDC, HRGN hRgn)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
BOOL PtInRegion( HRGN, INT x, INT y) =
|
|
BOOL PtInRegion( HRGN, INT x, INT y)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL RectVisible( HDC, LPRECT) =
|
|
BOOL ThkRectVisible( HDC, LPRECT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOL FillRgn( HDC hDC, HRGN hRgn, HBRUSH hBrush) =
|
|
BOOL ThkFillRgn( HDC hDC, HRGN hRgn, HBRUSH hBrush)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL FrameRgn( HDC hDC, HRGN hRgn, HBRUSH hBrush, int nWidth, int nHeight) =
|
|
BOOL ThkFrameRgn( HDC hDC, HRGN hRgn, HBRUSH hBrush, int nWidth, int nHeight)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL RectInRegion( HRGN hRegion, LPRECT lpRect) =
|
|
BOOL RectInRegion( HRGN hRegion, LPRECT lpRect)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
HRGN ExtCreateRegion(LPXFORM lpxfm, DWORD cby, LPBYTE lpby) =
|
|
HRGN ExtCreateRegion(LPXFORM lpxfm, DWORD cby, LPBYTE lpby)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Win32/DOS:
|
|
* If hi word null, module handle, so RemoveFontModule (Krn handle
|
|
* mapping).
|
|
*
|
|
* Win32s:
|
|
* RemoveFontModule just calls here, so passifhinull is still necessary.
|
|
*/
|
|
int RemoveFontResource( LPSTR lpFilename) =
|
|
int RemoveFontResourceA( LPSTR lpFilename)
|
|
{
|
|
lpFilename = passifhinull;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
int AbortDoc(HDC hdc) =
|
|
int AbortDoc(HDC hdc)
|
|
{
|
|
faulterrorcode = -1;
|
|
}
|
|
|
|
int EndDoc(HDC hDC) =
|
|
int EndDoc(HDC hDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
int EndPage(HDC hDC) =
|
|
int EndPage(HDC hDC)
|
|
{
|
|
faulterrorcode = -1;
|
|
}
|
|
|
|
int StartPage(HDC hDC) =
|
|
int StartPage(HDC hDC)
|
|
{
|
|
faulterrorcode = -1;
|
|
}
|
|
|
|
BOOL QueryAbort(HDC hdc, int Reserved) =
|
|
BOOL QueryAbort(HDC hdc, int Reserved)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
|
|
BOOL CreateScalableFontResource(UINT, LPSTR, LPSTR, LPSTR) =
|
|
BOOL CreateScalableFontResourceA(UINT, LPSTR, LPSTR, LPSTR)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
BOOL GetRasterizerCaps(LPSTR, int) =
|
|
BOOL GetRasterizerCaps(LPSTR, int)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
UINT GetBoundsRect(HDC, LPRECT lprc, UINT) =
|
|
UINT GetBoundsRect(HDC, LPRECT lprc, UINT)
|
|
{ lprc = output;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
UINT SetBoundsRect(HDC, LPRECT, UINT) =
|
|
UINT SetBoundsRect(HDC, LPRECT, UINT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
DWORD GetCharacterPlacement( HDC hdc, LPSTR lpString, INT nCount, INT nMaxExt,
|
|
LPGCP_RESULTS lpGCP, DWORD dwFlags) =
|
|
DWORD ThkGetCharacterPlacement( HDC hdc, LPSTR lpString, INT nCount, INT nMaxExt,
|
|
LPGCP_RESULTS lpGCP, DWORD dwFlags)
|
|
{
|
|
lpGCP = inout;
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
DWORD GetFontLanguageInfo(HDC hdc) =
|
|
DWORD GetFontLanguageInfo(HDC hdc)
|
|
{
|
|
faulterrorcode = -1 ;
|
|
}
|
|
|
|
|
|
/*ifdef_FE_APIS
|
|
BOOL EnableEUDC(BOOL) =
|
|
BOOL EnableEUDC(BOOL)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
endif_FE_APIS*/
|
|
|
|
/*****************************************************************************
|
|
* PRIVATE APIs. This section provides thunks for GDI16 helper routines. *
|
|
*****************************************************************************/
|
|
|
|
short PlayBack(HDC hDC, HANDLE hemf, BOOL bDeSpool) =
|
|
short PlayBack(HDC hDC, HANDLE hemf, BOOL bDeSpool)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL SetPrinterInfo(HDC hDC, short wID, DWORD id) =
|
|
BOOL SetPrinterInfo(HDC hDC, short wID, DWORD id)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* EnumFonts32Helper is used by EnumFontsA to do font enumeration
|
|
* without requiring the Win16Lock to be taken during callback.
|
|
*/
|
|
int EnumFonts32Helper(HDC, LPSTR, UINT, LPSTR, UINT) =
|
|
int EnumFonts32Helper(HDC, LPSTR, UINT, LPSTR, UINT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* GDI32GlobalFree performs a GlobalUnfix/GlobalFree on a memory handle
|
|
* provided by a helper routine. This basically saves one thunk roundtrip.
|
|
*/
|
|
void GDI32GlobalFree(HANDLE) =
|
|
void GDI32GlobalFree(HANDLE)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* CallDevInstall16 call 16 bit printer driver DevInstall function
|
|
* Private thunk for 32 bit spooler
|
|
*/
|
|
int GDI_CallDevInstall16(DWORD, HWND, LPSTR, LPSTR, LPSTR) =
|
|
int GDI_CallDevInstall16(DWORD, HWND, LPSTR, LPSTR, LPSTR)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* CallExtDeviceModePropSheet16 call 16 bit printer driver ExtDeviceModePropSheet function
|
|
* Private thunk for 32 bit spooler
|
|
*/
|
|
int GDI_CallExtDeviceModePropSheet16(HWND, LPSTR, LPSTR, LPSTR) =
|
|
int GDI_CallExtDeviceModePropSheet16(HWND, LPSTR, LPSTR, LPSTR)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* CallExtDeviceMode16 call 16 bit printer driver ExtDeviceMode function
|
|
* Private thunk for 32 bit spooler
|
|
*/
|
|
int GDI_CallExtDeviceMode16(HWND, LPSTR, LPSTR, LPSTR, LPSTR, LPSTR, WORD) =
|
|
int GDI_CallExtDeviceMode16(HWND, LPSTR, LPSTR, LPSTR, LPSTR, LPSTR, WORD)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* CallAdvancedSetupDialog16 call 16 bit printer driver ExtDeviceMode function
|
|
* Private thunk for 32 bit spooler
|
|
*/
|
|
int GDI_CallAdvancedSetupDialog16(HWND, LPSTR, LPSTR, LPSTR) =
|
|
int GDI_CallAdvancedSetupDialog16(HWND, LPSTR, LPSTR, LPSTR)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* For NT compatability, we need to export DeviceCapabilities
|
|
* from winspool.lib.
|
|
*/
|
|
DWORD
|
|
DeviceCapabilities(
|
|
LPSTR pDevice,
|
|
LPSTR pPort,
|
|
WORD fwCapability,
|
|
LPSTR pOutput,
|
|
LPSTR pDevMode
|
|
) =
|
|
DWORD
|
|
GDI_CallDeviceCapabilities16(
|
|
LPSTR pDevice,
|
|
LPSTR pPort,
|
|
WORD fwCapability,
|
|
LPSTR pOutput,
|
|
LPSTR pDevMode
|
|
)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|
|
/* The following two thunks are private thunks used by the Win32 API
|
|
* GetWinMetaFileBits() to synchronize the entry and the exit of the
|
|
* potentially long EMF conversion process. They pass a structure
|
|
* which does not have to be repacked.
|
|
*/
|
|
BOOL bThkGetWMFBitsEntry(LPSTR) =
|
|
BOOL bThkGetWMFBitsEntry(LPSTR)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
void vThkGetWMFBitsExit(LPSTR) =
|
|
void vThkGetWMFBitsExit(LPSTR)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
/* The following two thunks are private thunks used by EnumMetaFile. */
|
|
BOOL InitEnumMF32(HDC, HANDLE, LPSTR) =
|
|
BOOL InitEnumMF32(HDC, HANDLE, LPSTR)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL TermEnumMF32(HDC, HANDLE, LPSTR, LPSTR) =
|
|
BOOL TermEnumMF32(HDC, HANDLE, LPSTR, LPSTR)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
/* The following two thunks are private thunks used by EnumEnhMetaFile. */
|
|
BOOL bInternalInitPlayEMF(HDC, HANDLE, LPSTR, LPSTR) =
|
|
BOOL bInternalInitPlayEMF(HDC, HANDLE, LPSTR, LPSTR)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
void vInternalTermPlayEMF(HDC, HANDLE, LPSTR) =
|
|
void vInternalTermPlayEMF(HDC, HANDLE, LPSTR)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
HRGN GetRandomRgn(HDC, HRGN, INT) =
|
|
HRGN ThkGetRandomRgn(HDC, HRGN, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL FarGetDeviceInfoFromHDC(HDC, DWORD, LPVOID, DWORD) =
|
|
BOOL FarGetDeviceInfoFromHDC(HDC, DWORD, LPVOID, DWORD)
|
|
{
|
|
}
|
|
|
|
BOOL SetMagicColors(HDC, DWORD, WORD) =
|
|
BOOL SetMagicColors(HDC, DWORD, DWORD)
|
|
{
|
|
}
|
|
|
|
|
|
INT SetLayout( HDC, INT) =
|
|
INT SetLayout( HDC, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
INT GetLayout( HDC) =
|
|
INT GetLayout( HDC)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
INT InternalSetLayout( HDC, INT, INT) =
|
|
INT InternalSetLayout( HDC, INT, INT)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
BOOL GdiMirrorRegion( HDC, HRGN) =
|
|
BOOL GdiMirrorRegion( HDC, HRGN)
|
|
{
|
|
faulterrorcode = 0;
|
|
}
|
|
|
|
|