__foldwin32sstuff __foldwin32sstuff;
foldstyleinitialization = true;



/*
 * More USER flat-thunks. Created because usrfthk.thk was nearing
 * the 256 per-script limit.
 */


enablemapdirect3216 = true;

flatthunks = true;

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



INT ShowCursor(BOOL bShow) =
INT ShowCursor(BOOL bShow)
{
        faulterrorcode = 0;
}

BOOL SetDoubleClickTime(UINT uTime) =
BOOL SetDoubleClickTime(UINT uTime)
{
    faulterrorcode = 0;
}


/* 
 * BOGUS
 * Implement natively in User32 
 */
LONG MapWindowPoints(HWND hwndFrom, HWND hwndTo, LPPOINT lppt, UINT cpt) =
LONG MapWindowPoints(HWND hwndFrom, HWND hwndTo, LPPOINT lppt, UINT cpt)
{
    lppt = inout;
    cpt = countof lppt;
    faulterrorcode = 0;
}

DWORD GetPriorityClipboardFormat(INT *lpList, UINT count) =
DWORD GetPriorityClipboardFormat(INT *lpList, UINT count)
{
    count = countof lpList;
    faulterrorcode = 0;
}


LONG TabbedTextOut(HDC, INT, INT, LPSTR, INT, UINT cTabs, LPINT lpTabs, INT) =
LONG TabbedTextOutA(HDC, INT, INT, LPSTR, INT, UINT cTabs, LPINT lpTabs, INT)
{
    cTabs = countof lpTabs;
    faulterrorcode = 0;
        
}

DWORD GetTabbedTextExtent(HDC, LPSTR, INT, UINT cTabs, LPINT lpTabs) =
DWORD GetTabbedTextExtentA(HDC, LPSTR, INT, UINT cTabs, LPINT lpTabs)
{
    cTabs = countof lpTabs;
    faulterrorcode = 0;
}


HICON CreateIconFromResourceEx(LPVOID lpIconBits, DWORD cbIconBits, BOOL, DWORD, UINT, UINT, UINT) =
HICON CreateIconFromResourceEx(LPVOID lpIconBits, DWORD cbIconBits, BOOL, DWORD, UINT, UINT, UINT)
{
        faulterrorcode = 0;
}

HICON CopyImage(HINSTANCE hInstOwner, HICON, UINT, INT, INT, UINT) =
HICON RealCopyImage(HINSTANCE hInstOwner, HICON, UINT, INT, INT, UINT)
{
        faulterrorcode = 0;
}



BOOL SetSysColors(UINT nChanges, LPINT lpSysColor, LONG *) =
BOOL SetSysColors(UINT nChanges, LPINT lpSysColor, LONG *)
{
    nChanges = countof lpSysColor;
    faulterrorcode = 0;
}

HANDLE SetSysColorsTemp(LONG *, LPINT lpSysBrushes, UINT wCnt) =
HANDLE SetSysColorsTemp(LONG *, LPINT lpSysBrushes, UINT wCnt)
{
    wCnt = countof lpSysBrushes;
    faulterrorcode = 0;
}


WORD   CascadeWindows(HWND hwndParent, UINT wHow, LPRECT lpRect, UINT cKids, LPHWND lpKids) =
WORD   CascadeWindows(HWND hwndParent, UINT wHow, LPRECT lpRect, UINT cKids, LPHWND lpKids)
{
    cKids = countof lpKids;
    faulterrorcode = 0;
}


WORD  TileWindows(HWND hwndParent, UINT wHow, LPRECT lpRect, UINT cKids, LPHWND lpKids) = 
WORD  TileWindows(HWND hwndParent, UINT wHow, LPRECT lpRect, UINT cKids, LPHWND lpKids)
{
    cKids = countof lpKids;
    faulterrorcode = 0;
}



BOOL DragDetect(HWND, POINT) =
BOOL DragDetect(HWND, POINT)
{
        faulterrorcode = 0;
}


LONG DragObject(HWND, HWND, UINT, DWORD, HCURSOR) =
LONG DragObject(HWND, HWND, UINT, DWORD, HCURSOR)
{
        faulterrorcode = 0;
}


HWND GetNextQueueWindow(HWND hWnd, int nCmd)=
HWND GetNextQueueWindow(HWND hWnd, int nCmd)
{
        faulterrorcode = 0;
}


BOOL FakeSetWindowPlacement(HWND hwnd, LPWINDOWPLACEMENT lpwndpl) =
BOOL SetWindowPlacement(HWND hwnd, LPWINDOWPLACEMENT lpwndpl)
{
        faulterrorcode = 0;
}


BOOL FakeGetWindowPlacement(HWND hwnd, LPWINDOWPLACEMENT lpwndpl) =
BOOL GetWindowPlacement(HWND hwnd, LPWINDOWPLACEMENT lpwndpl)
{
    lpwndpl = inout;
    faulterrorcode = 0;
}


INT UnhookWindowsHookEx(DWORD hhk) =
INT UnhookWindowsHookEx(DWORD hhk)
{
        faulterrorcode = 0;
}



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

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


HCURSOR FakeSetCursor(HCURSOR) =
HCURSOR SetCursor(HCURSOR)
{
        faulterrorcode = 0;
}


DWORD GetMenuState(HMENU, UINT, UINT) =
DWORD GetMenuState(HMENU, UINT, UINT)
{
        faulterrorcode = -1;
}


DWORD GetMenuItemID(HMENU, INT) =
DWORD GetMenuItemID(HMENU, INT)
{
        faulterrorcode = -1;
}


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


DWORD CheckMenuItem( HMENU hMenu, WORD wIDCheckItem, WORD wCheck) =
DWORD CheckMenuItem( HMENU hMenu, UINT wIDCheckItem, UINT wCheck)
{
        faulterrorcode = -1;
}


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


INT MessageBoxEx_R(HWND, LPSTR, LPSTR, DWORD, WORD, WORD, DWORD) =
INT MessageBoxExA_R(HWND, LPSTR, LPSTR, DWORD, WORD, WORD, DWORD)
{
        faulterrorcode = 0;
}


INT LookupIconIdFromDirectoryEx(LPSTR, BOOL, INT, INT, UINT) =
INT LookupIconIdFromDirectoryEx(LPSTR, BOOL, INT, INT, UINT)
{
        faulterrorcode = 0;
}


/* 16-bit one is in keyboard.drv, not user.exe */
UINT GetKBCodePage() =
UINT GetKBCodePage()
{
        faulterrorcode = 0;
}

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

INT  FakeMessageBoxIndirect(LPMSGBOXPARAMS, WORD, DWORD) =
INT  FakeMessageBoxIndirectA(LPMSGBOXPARAMS, WORD, DWORD)
{
    /* Need to thunk callback on 16-bit side */
        faulterrorcode = 0;
}


WORD  FakeRegisterClassEx(LPWNDCLASSEX) =
DWORD RegisterClassExA(LPWNDCLASSEX)
{
    /* Need to thunk callback on 16-bit side */
        faulterrorcode = 0;
}


HWND FakeCreateDialogParam(HINSTANCE, LPSTR, HWND, DWORD pfn, LONG) =
HWND CreateDialogParamA(HINSTANCE, LPSTR, HWND, DWORD pfn, LONG)
{
    /* Need to thunk pfn on 16-bit side */
        faulterrorcode = 0;
}


DWORD FakeDialogBoxParam(HINSTANCE, LPSTR, HWND, DWORD pfn, DWORD) =
DWORD DialogBoxParamA(HINSTANCE, LPSTR, HWND, DWORD pfn, DWORD)
{
    /* Need to thunk pfn on 16-bit side */
    faulterrorcode = -1;
}

BOOL FakeGrayString(HDC, HBRUSH, DWORD lpDrawProc, LPSTR, INT, INT, INT, INT, 
    INT) =
BOOL GrayStringA(HDC, HBRUSH, DWORD lpDrawProc, LPSTR, INT, INT, INT, INT, 
    INT)
{
    /* Need to thunk lpDrawProc on 16-bit side */
        faulterrorcode = 0;
}
      

BOOL FakeDrawState(HDC, HBRUSH, DWORD lpDrawProc, LPSTR, UINT, INT, INT, 
    INT, INT, UINT) =
BOOL DrawStateA(HDC, HBRUSH, DWORD lpDrawProc, LPSTR, UINT, INT, INT, 
    INT, INT, UINT)
{
    /* Need to thunk lpDrawProc on 16-bit side. */
    /* NOTE THAT DOING A MAPLS ON lpData IS COOL: */
    /*      * If a string, then great */
    /*      * If other known things, then HIWORD is 0, and mapping is a nop */
    /*      * If complex, then in lpDrawProc MAPSL undoes mapping */
        faulterrorcode = 0;
}


DWORD FakeSetTimer(HWND, DWORD, DWORD, DWORD lpTimerFunc) =
DWORD SetTimer(HWND, DWORD, DWORD, DWORD lpTimerFunc)
{
    /* Need to thunk lpTimerFunc on 16-bit side */
        faulterrorcode = 0;
}


INT FakeEnumProps(HWND, DWORD lpEnumFunc) =
INT EnumPropsA(HWND, DWORD lpEnumFunc)
{
    /* Need to thunk lpEnumFunc on 16-bit side */
    /* Also passes 0L lParam & extra flags to EnumPropsEx() */
    faulterrorcode = -1;
}

INT FakeEnumPropsEx(HWND, DWORD lpEnumFunc, DWORD lParam) =
INT EnumPropsExA(HWND, DWORD lpEnumFunc, DWORD lParam)
{
    /* Need to thunk lpEnumFunc on 16-bit side */
    /* Also passes extra flags to EnumPropsEx() */
    faulterrorcode = -1;
}


/*
 * This takes care of
 *      EnumThreadWindows
 *      EnumTaskWindows (== EnumThreadWindows)
 *      EnumWindows
 *      EnumChildWindows
 */
BOOL FakeEnumWindowsEx(DWORD, HWND, DWORD lpEnumFunc, DWORD) =
BOOL EnumWindowsEx(DWORD, HWND, DWORD lpEnumFunc, DWORD)
{
    /* Need to thunk lpEnumFunc on 16-bit side */
        faulterrorcode = 0;
}


UINT FakeDdeInitialize(LPDWORD, DWORD pfnCallback, DWORD, DWORD) =
UINT DdeInitializeA(LPDWORD, DWORD pfnCallback, DWORD, DWORD)
{ 
    /* Need to thunk pfnCallback on 16-bit side */
    faulterrorcode = 16390; //DMLERR_INVALIDPARAMETER
}


BOOL IsHungThread(DWORD dwThreadID) =
BOOL IsHungThread(DWORD dwThreadID)
{
        faulterrorcode = 0;
}

DWORD EndTask(HWND, DWORD, LPSTR, DWORD) =
DWORD EndTask(HWND, DWORD, LPSTR, DWORD)
{
        faulterrorcode = 0;
}

VOID RegisterNetworkCapabilities(DWORD, DWORD) =
VOID RegisterNetworkCapabilities(DWORD, DWORD)
{
        faulterrorcode = 0;
}

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

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

BOOL DrawCaptionTemp(HWND, HDC, LPRECT, HFONT, HICON, LPSTR, UINT) =
BOOL DrawCaptionTempA(HWND, HDC, LPRECT, HFONT, HICON, LPSTR, UINT)
{
    faulterrorcode = 0;
}

int DrawMenuBarTemp(HWND, HDC, LPRECT, HMENU, HFONT) =
int DrawMenuBarTemp(HWND, HDC, LPRECT, HMENU, HFONT)
{
    faulterrorcode = 0;
}


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

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


BOOL SetSystemCursor(HCURSOR, DWORD) =
BOOL SetSystemCursor(HCURSOR, DWORD)
{
    faulterrorcode = 0;
}

DWORD ChangeDisplaySettings(LPVOID, DWORD) =
DWORD ChangeDisplaySettingsA(LPVOID, DWORD)
{
    faulterrorcode = 0;
}

DWORD ChangeDisplaySettingsEx(LPSTR,LPVOID,HWND,DWORD,LPVOID) =
DWORD ChangeDisplaySettingsExA(LPSTR,LPVOID,HWND,DWORD,LPVOID)
{
    faulterrorcode = 0;
}

BOOL EnumDisplaySettings(LPSTR, DWORD, LPVOID) =
BOOL EnumDisplaySettingsA(LPSTR, DWORD, LPVOID)
{
    faulterrorcode = 0;
}

BOOL EnumDisplaySettingsEx(LPSTR, DWORD, LPVOID, DWORD) =
BOOL EnumDisplaySettingsExA(LPSTR, DWORD, LPVOID, DWORD)
{
    faulterrorcode = 0;
}

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


//
// Multiple Monitor Support
//

HMONITOR MonitorFromPoint(POINT, UINT) =
HMONITOR MonitorFromPoint(POINT, UINT)
{
    faulterrorcode = 0;
}

HMONITOR MonitorFromWindow(HWND, UINT) =
HMONITOR MonitorFromWindow(HWND, UINT)
{
    faulterrorcode = 0;
}

HMONITOR MonitorFromRect(LPRECT, UINT) =
HMONITOR MonitorFromRect(LPRECT, UINT)
{
    faulterrorcode = 0;
}

BOOL GetMonitorInfo(HMONITOR hMonitor, LPVOID lpMonitorInfo) =
BOOL GetMonitorInfoA(HMONITOR hMonitor, LPVOID lpMonitorInfo)
{
    faulterrorcode = 0;
}

BOOL EnumDisplayDevices(LPVOID Unused, DWORD iDevNum, LPVOID lpDisplayDevice, DWORD dwFlags) =
BOOL EnumDisplayDevicesA(LPVOID Unused, DWORD iDevNum, LPVOID lpDisplayDevice, DWORD dwFlags)
{
    faulterrorcode = 0;
}

BOOL FakeEnumDisplayMonitors(HDC, LPRECT, DWORD, DWORD) =
BOOL EnumDisplayMonitors(HDC, LPRECT, DWORD, DWORD)
{
    faulterrorcode = 0;
}


//
// WINABLE
// For ACTIVE ACCESSIBILITY
//

//
// PUBLIC:  NotifyWinEvent()
//
VOID  SimpleNotifyWinEvent(DWORD, DWORD, DWORD, DWORD) =
VOID  FakeNotifyWinEvent(DWORD, DWORD, DWORD, DWORD)
{
}


//
// PUBLIC:  SetWinEventHook() is NOT in USRTHK.THK like other callback goop.
//
DWORD   SetWinEventHook(DWORD eventMin, DWORD eventMax, DWORD hModule, 
    DWORD lpfnHook, DWORD idProcess, DWORD idThread, DWORD dwFlags) =
DWORD   FakeSetWinEventHook(DWORD eventMin, DWORD eventMax, DWORD hModule,
    DWORD lpfnHook, DWORD idProcess, DWORD idThread, DWORD dwFlags)
{
    faulterrorcode = 0;
}


//
// PUBLIC:  UnhookWinEvent()
//
BOOL    UnhookWinEvent(DWORD hEvent) =
BOOL    UnhookWinEvent(DWORD hEvent)
{
    faulterrorcode = 0;
}


//
// PUBLIC:  GetWindowModuleFileName()
//
UINT    GetWindowModuleFileName(HWND, LPSTR, UINT) =
UINT    GetWindowModuleFileNameA(HWND, LPSTR, UINT)
{
    faulterrorcode = 0;
}


//
// PUBLIC:  GetGUIThreadInfo()
//
BOOL  GetGUIThreadInfo(DWORD, LPGUITHREADINFO lpGuiInfo) =
BOOL  GetGUIThreadInfo(DWORD, LPGUITHREADINFO lpGuiInfo)
{
    lpGuiInfo = inout;
    faulterrorcode = 0;
}


//
// PUBLIC:  GetCursorInfo()
//
BOOL  GetCursorInfo(LPCURSORINFO lpCursorInfo) =
BOOL  GetCursorInfo(LPCURSORINFO lpCursorInfo)
{
    lpCursorInfo = inout;
    faulterrorcode = 0;
}


//
// PUBLIC:  BlockInput()
//
BOOL    BlockInput(BOOL fBlockIt) =
BOOL    BlockInput(BOOL fBlockIt)
{
    faulterrorcode = 0;
}


//
// PUBLIC:  SendInput()  The structure is a union but 32-bit and 16-bit one
// are same size--so rather than complicated def use LPVOID
//
UINT    SendInput(UINT cInputs, LPVOID rgInputs, int cbSize) =
UINT    SendInput(UINT cInputs, LPVOID rgInputs, int cbSize)
{
    faulterrorcode = 0;
}


BOOL  GetWindowInfo(HWND, LPWINDOWINFO lpwi) =
BOOL  GetWindowInfo(HWND, LPWINDOWINFO lpwi)
{
    lpwi = inout;
    faulterrorcode = 0;
}

BOOL  GetTitleBarInfo(HWND, LPTITLEBARINFO lpti) =
BOOL  GetTitleBarInfo(HWND, LPTITLEBARINFO lpti)
{
    lpti = inout;
    faulterrorcode = 0;
}

BOOL  GetScrollBarInfo(HWND, DWORD, LPSCROLLBARINFO lpsbi) =
BOOL  GetScrollBarInfo(HWND, DWORD, LPSCROLLBARINFO lpsbi)
{
    lpsbi = inout;
    faulterrorcode = 0;
}

BOOL  GetComboBoxInfo(HWND, LPCOMBOBOXINFO lpcbi) =
BOOL  GetComboBoxInfo(HWND, LPCOMBOBOXINFO lpcbi)
{
    lpcbi = inout;
    faulterrorcode = 0;
}


HWND  GetAncestor(HWND, UINT) =
HWND  GetAncestor(HWND, UINT)
{
    faulterrorcode = 0;
}


HWND RealChildWindowFromPoint(HWND, POINT) =
HWND RealChildWindowFromPoint(HWND, POINT)
{
    faulterrorcode = 0;
}


UINT RealGetWindowClass(HWND, LPSTR, UINT) =
UINT RealGetWindowClass(HWND, LPSTR, UINT)
{
    faulterrorcode = 0;
}


BOOL GetAltTabInfo(HWND, int, LPALTTABINFO lpati, LPSTR, UINT) =
BOOL GetAltTabInfo(HWND, int, LPALTTABINFO lpati, LPSTR, UINT)
{
    lpati = inout;
    faulterrorcode = 0;
}


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


BOOL GetMenuBarInfo(HWND, long, long, LPMENUBARINFO lpmbi) =
BOOL GetMenuBarInfo(HWND, long, long, LPMENUBARINFO lpmbi)
{
    lpmbi = inout;
    faulterrorcode = 0;
}