__foldwin32sstuff __foldwin32sstuff;
foldstyleinitialization = true;



/*
 * USER thunks for Win32s
 */

/*
 * Open issues:
 *
 *      cleanup of long-term callbacks
 *      ANSI/Unicode translation
 *      resource template conversion
 *      htask definition?
 *      COLOR_SHADOW
 *      input model ramifications?
 *      VOID->BOOL return code conversion (always returns TRUE)
 */

enablemapdirect3216 = true;

flatthunks = true;

#include "types.thk"
#include "usrtypes.thk"
#include "usrftype.thk"






HUSER LoadAccelerators(HINSTANCE hInstance, LPSTR) =
HUSER LoadAcceleratorsA(HINSTANCE hInstance, LPSTR)
{
        faulterrorcode = 0;
}


HANDLE LoadImage(HINSTANCE hInstLoad, LPSTR, UINT, INT, INT, UINT) =
HANDLE LoadImageA(HINSTANCE hInstLoad, LPSTR, UINT, INT, INT, UINT)
{
    hInstLoad = passifnull;
    faulterrorcode = 0;
}


HMENU LoadMenu(HINSTANCE hInstance, LPSTR) =
HMENU LoadMenuA(HINSTANCE hInstance, LPSTR)
{
        faulterrorcode = 0;
}


HKL LoadKeyboardLayout(LPSTR lpszLayoutName, UINT uiFlags) =
HKL LoadKeyboardLayoutA(LPSTR lpszLayoutName, UINT uiFlags)
{
        faulterrorcode = 0;
}

BOOL UnloadKeyboardLayout(DWORD hkl) =
BOOL UnloadKeyboardLayout(DWORD hkl)
{
        faulterrorcode = 0;
}

HKL ActivateKeyboardLayout(HKL hkl, UINT uiFlags) =
HKL ActivateKeyboardLayout(HKL hkl, UINT uiFlags)
{
        faulterrorcode = 0;
}

HKL GetKeyboardLayout( DWORD ht16 ) =
HKL GetKeyboardLayout( DWORD ht16 )
{
        faulterrorcode = 0;
}

INT GetKeyboardLayoutList( UINT, LPDWORD) =
INT GetKeyboardLayoutList( UINT, LPDWORD)
{
        faulterrorcode = 0;
}

HCURSOR CreateCursor(HINSTANCE, INT, INT, INT, INT, LPSTR, LPSTR) =
HCURSOR CreateCursor(HINSTANCE, INT, INT, INT, INT, LPSTR, LPSTR)
{
        faulterrorcode = 0;
}


HICON CreateIcon(HINSTANCE, INT, INT, BYTE, BYTE, LPSTR, LPSTR) =
HICON CreateIcon(HINSTANCE, INT, INT, BYTE, BYTE, LPSTR, LPSTR)
{
        faulterrorcode = 0;
}



/*
 * BOGUS
 * Implement natively in User32
 */
BOOL GetKeyboardLayoutName(LPSTR lpszLayoutName) =
BOOL GetKeyboardLayoutNameA(LPSTR lpszLayoutName)
{
        faulterrorcode = 0;
}



INT GetClassName( HWND, LPSTR, INT) =
INT GetClassNameA( HWND, LPSTR, INT)
{
        faulterrorcode = 0;
}


BOOL UnregisterClass(LPSTR, HINSTANCE) =
BOOL UnregisterClassA(LPSTR, HINSTANCE)
{
        faulterrorcode = 0;
}


BOOL GetIconInfo(HICON hIcon, LPICONINFO pIconInfo) =
BOOL GetIconInfo(HICON hIcon, LPICONINFO pIconInfo)
{
    pIconInfo = output;
    faulterrorcode = 0;
}


HICON CreateIconIndirect(LPICONINFO lpIconInfo) =
HICON CreateIconIndirect(LPICONINFO lpIconInfo)
{
        faulterrorcode = 0;
}


BOOL WaitMessage( ) =
BOOL WaitMessage( )
{
        faulterrorcode = 0;
}


BOOL ReplyMessage( LONG) =
BOOL ReplyMessage( LONG)
{
        faulterrorcode = 0;
}

BOOL PostQuitMessage( INT nExitCode) =
BOOL PostQuitMessage( INT nExitCode)
{
        faulterrorcode = 0;
}

/*
 * BOGUS
 * Implement natively in User32--it's easy
 */
BOOL InSendMessage( ) =
BOOL InSendMessage( )
{
        faulterrorcode = 0;
}

/*
 * BOGUS
 * Implement natively in User32--it's easy
 */
DWORD InSendMessageEx( LPVOID lpReserverd ) =
DWORD InSendMessageEx( LPVOID lpReserverd )
{
        faulterrorcode = 0;
}

 WORD RegisterWindowMessage(LPSTR) =
DWORD RegisterWindowMessageA(LPSTR)
{
        faulterrorcode = 0;
}


BOOL SwapMouseButton( BOOL) =
BOOL SwapMouseButton( BOOL)
{
        faulterrorcode = 0;
}


BOOL DrawAnimatedRects(HWND hwndClip, INT idAni, LPRECT lprcFrom, LPRECT lprcTo) =
BOOL DrawAnimatedRects(HWND hwndClip, INT idAni, LPRECT lprcFrom, LPRECT lprcTo)
{
        faulterrorcode = 0;
}

                           
BOOL ShowOwnedPopups( HWND, BOOL) =
BOOL ShowOwnedPopups( HWND, BOOL)
{
        faulterrorcode = 0;
}

BOOL OpenIcon( HWND) =
BOOL OpenIcon( HWND)
{
        faulterrorcode = 0;
}

BOOL CloseWindow(HWND) =
BOOL CloseWindow(HWND)
{
        faulterrorcode = 0;
}



BOOL DestroyWindow( HWND hWnd) =
BOOL DestroyWindow( HWND hWnd)
{
        faulterrorcode = 0;
}



BOOL SetWindowPos( HWND, HWND, INT, INT, INT, INT,  WORD) =
BOOL SetWindowPos( HWND, HWND, INT, INT, INT, INT, DWORD)
{
        faulterrorcode = 0;

}

HANDLE BeginDeferWindowPos( INT nNumWindows) =
HANDLE BeginDeferWindowPos( INT nNumWindows)
{
        faulterrorcode = 0;
}

HANDLE DeferWindowPos( HANDLE hWinPosInfo, HWND hWnd, HWND hWndInsertAfter, INT x, INT y, INT cx, INT cy,  WORD wFlags) =
HANDLE DeferWindowPos( HANDLE hWinPosInfo, HWND hWnd, HWND hWndInsertAfter, INT x, INT y, INT cx, INT cy, DWORD wFlags)
{
        faulterrorcode = 0;
}

BOOL EndDeferWindowPos( HANDLE hWinPosInfo) =
BOOL EndDeferWindowPos( HANDLE hWinPosInfo)
{
        faulterrorcode = 0;
}

BOOL MoveWindow( HWND, INT, INT, INT, INT, BOOL) =
BOOL MoveWindow( HWND, INT, INT, INT, INT, BOOL)
{
        faulterrorcode = 0;
}


BOOL BringWindowToTop( HWND) =
BOOL BringWindowToTop( HWND)
{
        faulterrorcode = 0;
}


BOOL ShowWindow( HWND hWnd, INT nCmdShow) =
BOOL ShowWindow( HWND hWnd, INT nCmdShow)
{
        faulterrorcode = 0;
}


BOOL ShowWindowAsync( HWND hWnd, INT nCmdShow) =
BOOL ShowWindowAsync( HWND hWnd, INT nCmdShow)
{
        faulterrorcode = 0;
}


BOOL LockWindowUpdate(HWND hwnd)=
BOOL LockWindowUpdate(HWND hwnd)
{
        faulterrorcode = 0;
}

BOOL AnimateWindow(HWND hwnd, DWORD dwTime, DWORD dwFlags)=
BOOL AnimateWindow(HWND hwnd, DWORD dwTime, DWORD dwFlags)
{
        faulterrorcode = 0;
}

BOOL FlashWindow( HWND, BOOL) =
BOOL FlashWindow( HWND, BOOL)
{
        faulterrorcode = 0;
}


/*
 * !!! return value?
 */
BOOL EnableWindow(HWND, BOOL) =
BOOL EnableWindow(HWND, BOOL)
{
        faulterrorcode = 0;
}


BOOL SetWindowText( HWND hWnd, LPSTR lpString) =
BOOL SetWindowTextA( HWND hWnd, LPSTR lpString)
{
        faulterrorcode = 0;
}

INT GetWindowText( HWND, LPSTR, INT) =
INT GetWindowTextA( HWND, LPSTR, INT)
{
        faulterrorcode = 0;
}


DWORD GetWindowTextLength(HWND) =
DWORD GetWindowTextLengthA(HWND)
{
        faulterrorcode = 0;
}


/*
 * BOGUS
 * Implement natively in User32
 */
BOOL AdjustWindowRectEx( LPRECT lpRect, LONG, BOOL, DWORD) =
BOOL AdjustWindowRectEx( LPRECT lpRect, LONG, BOOL, DWORD)
{
    lpRect = inout;
    faulterrorcode = 0;
}

/*
 * BOGUS
 * Implement natively in User32
 */
HWND GetParent( HWND) =
HWND GetParent( HWND)
{
        faulterrorcode = 0;
}

HWND SetParent( HWND, HWND) =
HWND SetParent( HWND, HWND)
{
        faulterrorcode = 0;
}


HWND FindWindowEx(HWND, HWND, LPSTR, LPSTR) =
HWND FindWindowExA(HWND, HWND, LPSTR, LPSTR)
{
        faulterrorcode = 0;
}


BOOL SetShellWindow(HWND) =
BOOL SetShellWindow(HWND)
{
        faulterrorcode = 0;
}


/*
 * BOGUS
 * Implement natively in User32
 */
HWND GetLastActivePopup( HWND) =
HWND GetLastActivePopup( HWND)
{
        faulterrorcode = 0;
}


/*
 * BOGUS
 * Implement natively in User32
 */
HWND GetWindow( HWND,  WORD) =
HWND GetWindow( HWND, DWORD)
{
        faulterrorcode = 0;
}

HWND GetTopWindow(HWND) =
HWND GetTopWindow(HWND)
{
        faulterrorcode = 0;
}


BOOL IsMenu( HWND) =
BOOL IsMenu( HWND)
{
        faulterrorcode = 0;
}


/*
 * BOGUS
 * Implement in User32 directly
 */
BOOL IsChild( HWND, HWND) =
BOOL IsChild( HWND, HWND)
{
        faulterrorcode = 0;
}


/*
 * BOGUS
 * Implement in User32 directly
 */
BOOL AnyPopup( ) =
BOOL AnyPopup( )
{
        faulterrorcode = 0;
}


BOOL EndDialog32( HWND hDlg, LONG lResult) =
BOOL EndDialog( HWND hDlg, LONG lResult)
{
        faulterrorcode = 0;
}


LONG GetDlgItemInt32( HWND, LONG, LPINT lpTranslated, BOOL, BOOL) =
LONG GetDlgItemInt32( HWND, LONG, LPINT lpTranslated, BOOL, BOOL)
{ 
    lpTranslated = output;
    faulterrorcode = 0;
}


BOOL SetDlgItemInt32( HWND, LONG, LONG, BOOL) =
BOOL SetDlgItemInt( HWND, INT, LONG, BOOL)
{
        faulterrorcode = 0;
}


BOOL SetDlgItemText32( HWND, LONG, LPSTR) =
BOOL SetDlgItemTextA( HWND, INT, LPSTR)
{
        faulterrorcode = 0;
}

INT GetDlgItemText32( HWND, LONG, LPSTR, INT) =
INT GetDlgItemTextA( HWND, INT, LPSTR, INT)
{
    faulterrorcode = 0;
}

BOOL CheckDlgButton32( HWND, LONG,  WORD) =
BOOL CheckDlgButton( HWND, INT, DWORD)
{
        faulterrorcode = 0;
}

BOOL CheckRadioButton32( HWND, LONG, LONG, LONG) =
BOOL CheckRadioButton( HWND, INT, INT, INT)
{
        faulterrorcode = 0;
}

 WORD IsDlgButtonChecked32( HWND, LONG) =
DWORD IsDlgButtonChecked( HWND, INT)
{
    /*
     * !!! How is error returned?
     */
        faulterrorcode = 0;
}

/*  !!! bPrevious reversed ??? */
HWND GetNextDlgGroupItem( HWND hDlg, HWND hCtl, BOOL bPrevious) =
HWND GetNextDlgGroupItem( HWND hDlg, HWND hCtl, BOOL bPrevious)
{
        faulterrorcode = 0;
}

/*  !!! bPrevious reversed ??? */
HWND GetNextDlgTabItem( HWND hDlg, HWND hCtl, BOOL bPrevious) =
HWND GetNextDlgTabItem( HWND hDlg, HWND hCtl, BOOL bPrevious)
{
        faulterrorcode = 0;
}

/*
 * BOGUS
 * Implement natively in User32
 */
BOOL MapDialogRect( HWND, LPRECT lpRect) =
BOOL MapDialogRect( HWND, LPRECT lpRect)
{
    lpRect = inout;
    faulterrorcode = 0;
}


/*
 * clipbrd.c "Clipboard Manager APIs and support routines."
 */



UINT EnumClipboardFormats(UINT) =
UINT EnumClipboardFormats(UINT)
{
        faulterrorcode = 0;
}

BOOL EmptyClipboard( ) =
BOOL EmptyClipboard( )
{
        faulterrorcode = 0;
}


INT GetClipboardFormatName( WORD, LPSTR, INT) =
INT GetClipboardFormatNameA( DWORD, LPSTR, INT)
{
        faulterrorcode = 0;
}


HWND SetClipboardViewer( HWND) =
HWND SetClipboardViewer( HWND)
{
        faulterrorcode = 0;
}

BOOL ChangeClipboardChain( HWND, HWND) =
BOOL ChangeClipboardChain( HWND, HWND)
{
        faulterrorcode = 0;
}


HDC BeginPaint( HWND hWnd, PAINTSTRUCT *lpPaint) =
HDC BeginPaint( HWND hWnd, PAINTSTRUCT *lpPaint)
{
    lpPaint = output;
    faulterrorcode = 0;
}

BOOL EndPaint( HWND hWnd, PAINTSTRUCT *lpPaint) =
BOOL EndPaint( HWND hWnd, PAINTSTRUCT *lpPaint)
{
        faulterrorcode = 0;
}


BOOL UpdateWindow( HWND hWnd) =
BOOL UpdateWindow( HWND hWnd)
{
        faulterrorcode = 0;
}

BOOL GetUpdateRect( HWND, LPRECT lpRect, BOOL) =
BOOL GetUpdateRect( HWND, LPRECT lpRect, BOOL)
{
    lpRect = output;
    faulterrorcode = 0;
}

INT GetUpdateRgn( HWND, HRGN, BOOL) =
INT GetUpdateRgn( HWND, HRGN, BOOL)
{
    faulterrorcode = 0;
}

INT ExcludeUpdateRgn( HDC, HWND) =
INT ExcludeUpdateRgn( HDC, HWND)
{
    faulterrorcode = 0;
}

BOOL InvalidateRect( HWND, LPRECT, BOOL) =
BOOL InvalidateRect( HWND, LPRECT, BOOL)
{
    faulterrorcode = 0;
}

BOOL ValidateRect( HWND, LPRECT) =
BOOL ValidateRect( HWND, LPRECT)
{
    faulterrorcode = 0;
}

BOOL SetWindowRgn( HWND, HRGN, BOOL) =
BOOL SetWindowRgn( HWND, HRGN, BOOL)
{
    faulterrorcode = 0;
}

int GetWindowRgn( HWND, HRGN) =
int GetWindowRgn( HWND, HRGN)
{
    faulterrorcode = 0;
}

BOOL InvalidateRgn( HWND, HRGN, BOOL) =
BOOL InvalidateRgn( HWND, HRGN, BOOL)
{
    faulterrorcode = 0;
}

BOOL ValidateRgn( HWND, HRGN) =
BOOL ValidateRgn( HWND, HRGN)
{
    faulterrorcode = 0;
}



HWND SetFocus( HWND hWnd) =
HWND SetFocus( HWND hWnd)
{
    faulterrorcode = 0;
}


HWND SetActiveWindow( HWND) =
HWND SetActiveWindow( HWND)
{
    faulterrorcode = 0;
}



HWND SetCapture( HWND hWnd) =
HWND SetCapture( HWND hWnd)
{
    faulterrorcode = 0;
}


BOOL ReleaseCapture( ) =
BOOL ReleaseCapture( )
{
    faulterrorcode = 0;
}



INT GetKeyState( INT nVirtKey) =
INT GetKeyState( INT nVirtKey)
{
    faulterrorcode = 0;
}

INT GetAsyncKeyState( INT) =
INT GetAsyncKeyState( INT)
{
    faulterrorcode = 0;
}


BOOL GetKeyboardState( BYTE *) =
BOOL GetKeyboardState( BYTE *)
{
    faulterrorcode = 0;
}



BOOL SetKeyboardState( BYTE *) =
BOOL SetKeyboardState( BYTE *)
{
    faulterrorcode = 0;
}

INT GetKeyNameText( LONG, LPSTR, INT) =
INT GetKeyNameTextA( LONG, LPSTR, INT)
{
    faulterrorcode = 0;
}


/*
 * toascii.c
 */

INT ToAsciiExInternal( WORD, WORD, LPSTR pKeys, DWORD *, WORD, DWORD) =
INT ToAsciiEx( UINT, UINT, LPSTR pKeys, DWORD *, WORD, DWORD)
{
    /*
     * pKeys is 256-byte array
     */
    faulterrorcode = 0;
}

WORD VkKeyScanExInternal( WORD, DWORD) =
UINT VkKeyScanExA( UINT, DWORD)
{
    faulterrorcode = 0;
}


INT ToAscii( WORD, WORD, LPSTR pKeys, DWORD *, WORD) =
INT ToAscii( UINT, UINT, LPSTR pKeys, DWORD *, WORD)
{
    /*
     * pKeys is 256-byte array
     */
    faulterrorcode = 0;
}

WORD VkKeyScan( WORD) =
UINT VkKeyScanA( UINT)
{
    /*
     * Win32 returns WORD, but high word should be zeroed in that case,
     * so UINT is used instead.
     *
     * Win32 takes TCHAR.  UINT is used instead since thunk.exe doesn't
     * understand TCHAR.
     */
    faulterrorcode = 0;
}


/*
 * xlate.c "Scancode, Virtual Key, and Character translations"
 */
WORD MapVirtualKey(WORD, WORD) =
UINT MapVirtualKey(UINT, UINT)
{
    faulterrorcode = 0;
}

WORD MapVirtualKeyExInternal(WORD, WORD, DWORD) =
UINT MapVirtualKeyExA(UINT, UINT, DWORD)
{
    faulterrorcode = 0;
}


BOOL GetInputState( ) =
BOOL GetInputState( )
{
    faulterrorcode = 0;
}


DWORD  MsgWaitForMultipleObjectsEx(DWORD dwCount, LPDWORD lpdwObjects, DWORD, DWORD, DWORD) =
DWORD  MsgWaitForMultipleObjectsEx(DWORD dwCount, LPDWORD lpdwObjects, DWORD, DWORD, DWORD)
{
        faulterrorcode = -1;
}

DWORD GetQueueStatus(UINT uiFlags)=
DWORD GetQueueStatus(UINT uiFlags)
{
    faulterrorcode = 0;
}


BOOL KillTimer32( HWND hWnd, DWORD nIDEvent) =
BOOL KillTimer( HWND hWnd, DWORD nIDEvent)
{
    faulterrorcode = 0;
}


BOOL DrawMenuBar( HWND) =
BOOL DrawMenuBar( HWND)
{
    faulterrorcode = 0;
}


DWORD GetMenu(HWND) =
DWORD GetMenu(HWND)
{
    faulterrorcode = 0;
}

DWORD GetMenuDefaultItem(HMENU, UINT, UINT) =
UINT  GetMenuDefaultItem(HMENU, UINT, UINT)
{
    faulterrorcode = 0;
}

BOOL  SetMenuDefaultItem(HMENU, UINT, UINT) =
BOOL  SetMenuDefaultItem(HMENU, UINT, UINT)
{
    faulterrorcode = 0;
}

BOOL SetMenu( HWND, HMENU) =
BOOL SetMenu( HWND, HMENU)
{
    faulterrorcode = 0;
}



BOOL HiliteMenuItem( HWND, HMENU, WORD, WORD) =
BOOL HiliteMenuItem( HWND, HMENU, UINT, UINT)
{
    faulterrorcode = 0;
}

INT GetMenuString( HMENU,  WORD, LPSTR, INT,  WORD) =
INT GetMenuStringA( HMENU, UINT, LPSTR, INT, DWORD)
{
    /*
     * Return code includes null-terminator.
     */
    faulterrorcode = 0;
}

BOOL GetMenuItemRect(HWND, HMENU, UINT, LPRECT qrc) =
BOOL GetMenuItemRect(HWND, HMENU, UINT, LPRECT qrc)
{
    qrc = output;
    faulterrorcode = 0;
}


INT MenuItemFromPoint(HWND, HMENU, POINT) =
INT MenuItemFromPoint(HWND, HMENU, POINT)
{
    faulterrorcode = 0;
}


BOOL  DrawEdge(HDC hdc, LPRECT qrc, UINT edgeType, UINT grfFlags)=
BOOL  DrawEdge(HDC hdc, LPRECT qrc, UINT edgeType, UINT grfFlags)
{
    qrc = inout;
    faulterrorcode = 0;
}

BOOL  DrawFrameControl(HDC, LPRECT qrc, UINT, UINT) =
BOOL  DrawFrameControl(HDC, LPRECT qrc, UINT, UINT)
{
    qrc = inout;
    faulterrorcode = 0;
}

HMENU GetSystemMenu( HWND, BOOL) =
HMENU GetSystemMenu( HWND, BOOL)
{
    faulterrorcode = 0;
}

HMENU CreateMenu( ) =
HMENU CreateMenu( )
{
    faulterrorcode = 0;
}

HMENU CreatePopupMenu( ) =
HMENU CreatePopupMenu( )
{
    faulterrorcode = 0;
}


BOOL DestroyMenu( HMENU hMenu) =
BOOL DestroyMenu( HMENU hMenu)
{
    /*
     * Win32 only
     * LATER:  BUGBUG: hMenu==NULL s/ret FALSE, not fault!
     * body = special;
     */
    faulterrorcode = 0;
}



HMENU GetSubMenu(HMENU, INT) =
HMENU GetSubMenu(HMENU, INT)
{
    faulterrorcode = 0;
}


INT GetMenuItemCount(HMENU) =
INT GetMenuItemCount(HMENU)
{
        faulterrorcode = -1;
}


BOOL RemoveMenu(HMENU, WORD, WORD) =
BOOL RemoveMenu(HMENU, UINT, UINT)
{
    faulterrorcode = 0;
}

BOOL DeleteMenu(HMENU, WORD, WORD) =
BOOL DeleteMenu(HMENU, UINT, UINT)
{
    faulterrorcode = 0;
}

BOOL SetMenuItemBitmaps( HMENU, WORD,  WORD, HBITMAP, HBITMAP) =
BOOL SetMenuItemBitmaps( HMENU, UINT, DWORD, HBITMAP, HBITMAP)
{
    faulterrorcode = 0;
}


LONG GetMenuCheckMarkDimensions( ) =
LONG GetMenuCheckMarkDimensions( )
{
    faulterrorcode = 0;
}

DWORD GetMenuContextHelpId(HMENU) =
DWORD GetMenuContextHelpId(HMENU)
{
    faulterrorcode = 0;
}

BOOL SetMenuContextHelpId(HMENU, DWORD) =
BOOL SetMenuContextHelpId(HMENU, DWORD)
{
    faulterrorcode = 0;
}

DWORD GetWindowContextHelpId(HWND) =
DWORD GetWindowContextHelpId(HWND)
{
    faulterrorcode = 0;
}

BOOL SetWindowContextHelpId(HWND, DWORD) =
BOOL SetWindowContextHelpId(HWND, DWORD)
{
    faulterrorcode = 0;
}

BOOL SetMenuInfo(HMENU, LPVOID lpMenuInfo) =
BOOL SetMenuInfo(HMENU, LPVOID lpMenuInfo)
{
    faulterrorcode = 0;
}

BOOL GetMenuInfo(HMENU, LPVOID lpMenuInfo) =
BOOL GetMenuInfo(HMENU, LPVOID lpMenuInfo)
{
    lpMenuInfo = inout;
    faulterrorcode = 0;
}

LONG SetScrollInfo(HWND, INT, LPSCROLLINFO lpScrollInfo, BOOL) =
LONG SetScrollInfo(HWND, INT, LPSCROLLINFO lpScrollInfo, BOOL)
{
    faulterrorcode = 0;
}


BOOL GetScrollInfo(HWND, INT, LPSCROLLINFO lpScrollInfo) =
BOOL GetScrollInfo(HWND, INT, LPSCROLLINFO lpScrollInfo)
{
    lpScrollInfo = inout;
    faulterrorcode = 0;
}


BOOL TrackMouseEvent(LPTRACKMOUSEEVENT lpEventTrack) =
BOOL TrackMouseEvent(LPTRACKMOUSEEVENT lpEventTrack)
{
    lpEventTrack = inout;
    faulterrorcode = 0;
}

UINT TrackPopupMenuEx(HMENU, UINT, INT, INT, HWND, LPTPMPARAMS lptpm) =
UINT TrackPopupMenuEx(HMENU, UINT, INT, INT, HWND, LPTPMPARAMS lptpm)
{
    faulterrorcode = 0;
}

BOOL EndMenu() =
BOOL EndMenu()
{
    faulterrorcode = 0;
}



INT ScrollWindowEx32(HWND, INT, INT, LPRECT, LPRECT, HRGN, LPRECT lprcUpdate, DWORD) =
INT ScrollWindowEx(HWND, INT, INT, LPRECT, LPRECT, HRGN, LPRECT lprcUpdate, DWORD)
{
    lprcUpdate = output;
    faulterrorcode = 0;
}


BOOL ScrollDC( HDC, INT, INT, LPRECT, LPRECT, HRGN, LPRECT lprcUpdate) =
BOOL ScrollDC( HDC, INT, INT, LPRECT, LPRECT, HRGN, LPRECT lprcUpdate)
{
    lprcUpdate = output;
    faulterrorcode = 0;
}


/*
 * sbapi.c "Scrollbar control"
 */

LONG GetScrollPos( HWND, INT) =
LONG GetScrollPos( HWND, INT)
{
    faulterrorcode = 0;
}


BOOL ShowScrollBar( HWND, WORD, BOOL) =
BOOL ShowScrollBar( HWND, UINT, BOOL)
{
    faulterrorcode = 0;
}



BOOL SetPropReal( HWND, LPSTR, DWORD, UINT) =
BOOL SetPropRealA(HWND, LPSTR, DWORD, UINT)
{
    faulterrorcode = 0;
}

DWORD GetPropEx(  HWND, LPSTR lpString) =
DWORD GetPropA( HWND, LPSTR lpString)
{
    faulterrorcode = 0;
}

DWORD RemovePropEx(HWND, LPSTR lpString) =
DWORD RemovePropA( HWND, LPSTR lpString)
{
    faulterrorcode = 0;
}


BOOL MessageBeep( WORD) =
BOOL MessageBeep( UINT)
{
    faulterrorcode = 0;
}



BOOL DestroyIcon32(HICON, UINT) =
BOOL DestroyIcoCur(HICON, UINT)
{
    faulterrorcode = 0;
}


BOOL DestroyAcceleratorTable(HACCEL  hAccel) =
BOOL DestroyAcceleratorTable(HACCEL  hAccel)
{
    faulterrorcode = 0;
}



BOOL SetCursorPos( INT X, INT Y) =
BOOL SetCursorPos( INT X, INT Y)
{
    faulterrorcode = 0;
}


BOOL GetCursorPos( LPPOINT lpPoint) =
BOOL GetCursorPos( LPPOINT lpPoint)
{
    lpPoint = output;
    faulterrorcode = 0;
}

BOOL ClipCursor( LPRECT) =
BOOL ClipCursor( LPRECT)
{
    faulterrorcode = 0;
}


BOOL DrawIconEx(HDC, INT, INT, HICON, INT, INT, UINT, HBRUSH, UINT) =
BOOL DrawIconEx(HDC, INT, INT, HICON, INT, INT, UINT, HBRUSH, UINT)
{
    faulterrorcode = 0;
}


BOOL CreateCaret( HWND, HBITMAP, INT, INT) =
BOOL CreateCaret( HWND, HBITMAP, INT, INT)
{
    faulterrorcode = 0;
}


BOOL SetCaretBlinkTime( WORD) =
BOOL SetCaretBlinkTime( UINT)
{
    faulterrorcode = 0;
}

BOOL DestroyCaret( ) =
BOOL DestroyCaret( )
{
    faulterrorcode = 0;
}


BOOL HideCaret( HWND) =
BOOL HideCaret( HWND)
{
    faulterrorcode = 0;
}


BOOL ShowCaret( HWND) =
BOOL ShowCaret( HWND)
{
    faulterrorcode = 0;
}


BOOL SetCaretPos( INT, INT) =
BOOL SetCaretPos( INT, INT)
{
    faulterrorcode = 0;
}


/*
 * BOGUS
 * Implement natively in User32
 */
BOOL GetCaretPos( LPPOINT lpPoint) =
BOOL GetCaretPos( LPPOINT lpPoint)
{
    lpPoint = output;
    faulterrorcode = 0;
}


HWND WindowFromPoint( POINT) =
HWND WindowFromPoint( POINT)
{
    faulterrorcode = 0;
}


HWND ChildWindowFromPointEx(HWND, POINT, UINT) =
HWND ChildWindowFromPointEx(HWND, POINT, UINT)
{
    faulterrorcode = 0;
}



BOOL PaintDesktop(HDC hdc) =
BOOL PaintDesktop(HDC hdc)
{
    faulterrorcode = 0;
}

INT DlgDirList( HWND, LPSTR, INT, INT,  WORD) =
INT DlgDirListA( HWND, LPSTR, INT, INT, DWORD)
{
    faulterrorcode = 0;
}


BOOL DlgDirSelectEx( HWND hDlg, LPSTR lpString, INT nLength, INT nIDListBox) =
BOOL DlgDirSelectExA( HWND hDlg, LPSTR lpString, INT nLength, INT nIDListBox)
{
    faulterrorcode = 0;
}


INT DlgDirListComboBox( HWND, LPSTR, INT, INT,  WORD) =
INT DlgDirListComboBoxA( HWND, LPSTR, INT, INT, DWORD)
{
    faulterrorcode = 0;
}


BOOL DlgDirSelectComboBoxEx( HWND hDlg, LPSTR lpString, INT nLength, int nIDComboBox) =
BOOL DlgDirSelectComboBoxExA( HWND hDlg, LPSTR lpString, INT nLength, int nIDComboBox)
{
    faulterrorcode = 0;
}



UINT ArrangeIconicWindows( HWND) =
UINT ArrangeIconicWindows( HWND)
{
    faulterrorcode = 0;
}


INT  DrawTextEx(HDC, LPSTR, INT, LPRECT lprc, DWORD, LPDRAWTEXTPARAMS lpdtp) =
INT  DrawTextExA(HDC, LPSTR, INT, LPRECT lprc, DWORD, LPDRAWTEXTPARAMS lpdtp)
{
    lprc = inout;
    lpdtp = inout;
    faulterrorcode = 0;
}


BOOL DrawFocusRect( HDC, LPRECT) =
BOOL DrawFocusRect( HDC, LPRECT)
{
    faulterrorcode = 0;
}


HDC GetWindowDC( HWND hWnd) =
HDC GetWindowDC( HWND hWnd)
{
    faulterrorcode = 0;
}

HDC GetDC( HWND hWnd) =
HDC GetDC( HWND hWnd)
{
    faulterrorcode = 0;
}

BOOL ReleaseDC( HWND hWnd, HDC hDC) =
BOOL ReleaseDC( HWND hWnd, HDC hDC)
{
    faulterrorcode = 0;
}


HWND  WindowFromDC(HDC) =
HWND  WindowFromDC(HDC)
{
    faulterrorcode = 0;
}

HDC GetDCEx(HWND hwnd, HRGN hrgnClip, DWORD flags)=
HDC GetDCEx(HWND hwnd, HRGN hrgnClip, DWORD flags)
{
    faulterrorcode = 0;
}


VOID SwitchToThisWindow(HWND hwnd, BOOL fAltTab) =
VOID SwitchToThisWindow(HWND hwnd, BOOL fAltTab)
{
    faulterrorcode = 0;
}

BOOL ExitWindowsEx(DWORD dwRetCode, DWORD dwUnused)=
BOOL ExitWindowsEx(DWORD dwRetCode, DWORD dwUnused)
{
    faulterrorcode = 0;
}



BOOL FillRect( HDC, LPRECT, HBRUSH) =
BOOL FillRect( HDC, LPRECT, HBRUSH)
{
    faulterrorcode = 0;
}

BOOL InvertRect( HDC, LPRECT) =
BOOL InvertRect( HDC, LPRECT)
{
    faulterrorcode = 0;
}

BOOL FrameRect( HDC, LPRECT, HBRUSH) =
BOOL FrameRect( HDC, LPRECT, HBRUSH)
{
    faulterrorcode = 0;
}


/*
 * BOGUS
 * Implement natively in User32
 */
HANDLE GetCursor( )=
HANDLE GetCursor( )
{
    faulterrorcode = 0;
}


BOOL DdeUninitialize(DWORD idInst) =
BOOL DdeUninitialize(DWORD idInst)
{
    faulterrorcode = 0;
}


HCONV DdeQueryNextServer(HCONVLIST hConvList, HCONV hConvPrev) =
HCONV DdeQueryNextServer(HCONVLIST hConvList, HCONV hConvPrev)
{
    faulterrorcode = 0;
}

BOOL  DdeDisconnectList(HCONVLIST hConvList) =
BOOL  DdeDisconnectList(HCONVLIST hConvList)
{
    faulterrorcode = 0;
}


BOOL DdeDisconnect(HCONV hConv) =
BOOL DdeDisconnect(HCONV hConv)
{
    faulterrorcode = 0;
}

HCONV DdeReconnect(HCONV hConv) =
HCONV DdeReconnect(HCONV hConv)
{
    faulterrorcode = 0;
}


BOOL DdeSetUserHandle(HCONV hConv, DWORD id, DWORD hUser) =
BOOL DdeSetUserHandle(HCONV hConv, DWORD id, DWORD hUser)
{
    faulterrorcode = 0;
}

BOOL DdeAbandonTransaction(DWORD idInst, HCONV hConv, DWORD idTransaction) =
BOOL DdeAbandonTransaction(DWORD idInst, HCONV hConv, DWORD idTransaction)
{
    faulterrorcode = 0;
}

BOOL DdePostAdvise(DWORD idInst, HSZ hszTopic, HSZ hszItem) =
BOOL DdePostAdvise(DWORD idInst, HSZ hszTopic, HSZ hszItem)
{
    faulterrorcode = 0;
}

BOOL DdeEnableCallback(DWORD idInst, HCONV hConv, UINT wCmd) =
BOOL DdeEnableCallback(DWORD idInst, HCONV hConv, UINT wCmd)
{
    faulterrorcode = 0;
}

HDDEDATA DdeNameService(DWORD idInst, HSZ hsz1, HSZ hsz2, UINT afCmd) =
HDDEDATA DdeNameService(DWORD idInst, HSZ hsz1, HSZ hsz2, UINT afCmd)
{
    faulterrorcode = 0;
}


HDDEDATA DdeCreateDataHandle(DWORD idInst, LPBYTE pSrc, DWORD cb, DWORD cbOff,
        HSZ hszItem, UINT wFmt, UINT afCmd)
{
    target = FakeDdeCreateDataHandle;
    faulterrorcode = 0;
}

HDDEDATA FakeDdeAddData(HDDEDATA hData, LPBYTE pSrc, DWORD cb, DWORD cbOff) =
HDDEDATA DdeAddData(HDDEDATA hData, LPBYTE pSrc, DWORD cb, DWORD cbOff)
{
    faulterrorcode = 0;
}

DWORD DdeGetData(HDDEDATA hData, LPBYTE pDst, DWORD cbMax, DWORD cbOff)
{
        target = FakeDdeGetData;
        faulterrorcode = 0;
}

LPBYTE DdeAccessData(HDDEDATA hData, LPDWORD pcbDataSize)
{
        target = FakeDdeAccessData;
        faulterrorcode = 0;
}

BOOL DdeUnaccessData(HDDEDATA hData)
{
        target = FakeDdeUnaccessData;
        faulterrorcode = 0;
}


BOOL DdeFreeDataHandle(HDDEDATA hData)
{
        target = FakeDdeFreeDataHandle;
        faulterrorcode = 0;
}

UINT DdeGetLastError(DWORD idInst) =
UINT DdeGetLastError(DWORD idInst)
{
        faulterrorcode = 0;
}

HSZ DdeCreateStringHandle(DWORD idInst, LPSTR psz, int iCodePage) =
HSZ DdeCreateStringHandleA(DWORD idInst, LPSTR psz, int iCodePage)
{
        faulterrorcode = 0;
}

DWORD DdeQueryString(DWORD idInst, HSZ hsz, LPSTR psz, DWORD cchMax,
        int iCodePage) =
DWORD DdeQueryStringA(DWORD idInst, HSZ hsz, LPSTR psz, DWORD cchMax,
        int iCodePage)
{
        faulterrorcode = 0;
}

BOOL DdeFreeStringHandle(DWORD idInst, HSZ hsz) =
BOOL DdeFreeStringHandle(DWORD idInst, HSZ hsz)
{
        faulterrorcode = 0;
}

BOOL DdeKeepStringHandle(DWORD idInst, HSZ hsz) =
BOOL DdeKeepStringHandle(DWORD idInst, HSZ hsz)
{
        faulterrorcode = 0;
}

/* !!! is this in ddemlrtl.dll? */
int DdeCmpStringHandles(HSZ hsz1, HSZ hsz2) =
int DdeCmpStringHandles(HSZ hsz1, HSZ hsz2)
{
        faulterrorcode = 0;
}



BOOL EnableScrollBar(HWND, INT, UINT) =
BOOL EnableScrollBar(HWND, INT, UINT)
{
        faulterrorcode = 0;
}

BOOL GetClipCursor(LPRECT lprc) =
BOOL GetClipCursor(LPRECT lprc)
{
        lprc = output;
        faulterrorcode = 0;
}



BOOL RedrawWindow(HWND, LPRECT, HRGN, UINT) =
BOOL RedrawWindow(HWND, LPRECT, HRGN, UINT)
{
        faulterrorcode = 0;
}



DWORD OemKeyScan (WORD) =
DWORD OemKeyScan (UINT)
{
        faulterrorcode = 0;

}


HANDLE SelectPalette(HDC, HANDLE, BOOL) =
HANDLE ThkSelectPalette(HDC, HANDLE, BOOL)
{
        faulterrorcode = 0;
}


UINT RealizePalette(HDC) =
UINT ThkRealizePalette(HDC)
{
        faulterrorcode = -1;
}



BOOL SetForegroundWindow(HWND hWnd) =
BOOL SetForegroundWindow(HWND hWnd)
{
        faulterrorcode = 0;
}

BOOL LockSetForegroundWindow(UINT) =
BOOL LockSetForegroundWindow(UINT)
{
        faulterrorcode = 0;
}

BOOL AllowSetForegroundWindow(DWORD) =
BOOL AllowSetForegroundWindow(DWORD)
{
        faulterrorcode = 0;
}


DWORD GetWindowThreadProcessId(HWND, LPDWORD lpdw) =
DWORD GetWindowThreadProcessId(HWND, LPDWORD lpdw)
{
    lpdw = output;
        faulterrorcode = 0;
}



DWORD WaitForInputIdle(DWORD, DWORD) =
DWORD WaitForInputIdle(DWORD, DWORD)
{
        faulterrorcode = 0;
}

/* Private API: USER32 must run this thunk before any other.
 *
 */
VOID UsrThunkInit(DWORD   pCB32Tab,
                  DWORD   pfnCALLBACK_BODY_32,
                  LPDWORD ppfnWNDPROC_CALLBACK_16) =
VOID UsrThunkInit(DWORD   pCB32Tab,
                  DWORD   pfnCALLBACK_BODY_32,
                  LPDWORD ppfnWNDPROC_CALLBACK_16)
{
        faulterrorcode = 0;
}

/* Signal proc called from Kernel32.  See coresig.inc for detailed
 *    information about the various signals.
 */
BOOL   SignalProc32(DWORD dwSignal,
                    DWORD dwID,
                    DWORD dwFlags,
                    WORD hTask16) =
BOOL UserSignalProc(DWORD dwSignal,
                    DWORD dwID,
                    DWORD dwFlags,
                    DWORD hTask16)
{
        faulterrorcode = 0;
}

BOOL AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach) =
BOOL AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
{
        faulterrorcode = 0;
}


BOOL PlaySoundEvent(DWORD) =
BOOL PlaySoundEvent(DWORD)
{
        faulterrorcode = 0;
}

/*
 * Private api called by the gp fault thread and some shell threads.
 */
VOID RegisterSystemThread(DWORD, DWORD) =
VOID RegisterSystemThread(DWORD, DWORD)
{
        faulterrorcode = 0;
}

INT SysErrorBox(LPSTR text, LPSTR caption, WORD b1, WORD b2, WORD b3) =
INT SysErrorBox(LPSTR text, LPSTR caption, DWORD b1, DWORD b2, DWORD b3)
{
        faulterrorcode = 0;
}

LONG WinOldAppHackoMatic(LONG) =
LONG WinOldAppHackoMatic(LONG)
{
        faulterrorcode = 0;
}


//
// DRAG And Drop Menu
// Call back to 16 bit USER.EXE
//

BOOL MNDragOver(LPPOINT lppt, LPMNDRAGOVERINFO lpmndoi) =
BOOL MNDragOver(LPPOINT lppt, LPMNDRAGOVERINFO lpmndoi)
{
        lpmndoi = output;
        faulterrorcode = 0;
}

BOOL MNDragLeave () =
BOOL MNDragLeave ()
{
        faulterrorcode = 0;
}

BOOL HasSystemSleepStarted(void) =
BOOL HasSystemSleepStarted(void)
{
    faulterrorcode = 0;
}

BOOL UserIsSystemResumeAutomatic(void) =
BOOL UserIsSystemResumeAutomatic(void)
{
    faulterrorcode = 0;
}

void UserTickleTimer(EXECUTION_STATE esFlags) =
void UserTickleTimer(EXECUTION_STATE esFlags)
{
    faulterrorcode = 0;
}

void UserSetDeviceHoldState(EXECUTION_STATE esFlags, BOOL bState) =
void UserSetDeviceHoldState(EXECUTION_STATE esFlags, BOOL bState)
{
    faulterrorcode = 0;
}

INT UserGetMouseMovePoints(LPVOID, LPVOID, UINT, DWORD) =
INT UserGetMouseMovePoints(LPVOID, LPVOID, UINT, DWORD)
{
    faulterrorcode = 0;
}

/*
 *#ifdef USE_MIRRORING
 */

BOOL SetProcessDefaultLayout(DWORD ) =
BOOL SetProcessDefaultLayout(DWORD )
{
        faulterrorcode = 0;
}

BOOL GetProcessDefaultLayout(DWORD *) =
BOOL GetProcessDefaultLayout(DWORD *)
{
        faulterrorcode = 0;
}

BOOL _SetProcessDefaultLayout(DWORD, DWORD ) =
BOOL _SetProcessDefaultLayout(DWORD, DWORD )
{
        faulterrorcode = 0;
}
/* 
 *#endif 
 */