windows-nt/Source/XPSP1/NT/base/mvdm/thunk/gdifthk.thk

__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 ExtSelectClipRgn(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      SelectClipRgn( 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)
{
}