windows-xp/Source/XPSP1/NT/base/mvdm/thunk/usrthk.thk

__foldwin32sstuff __foldwin32sstuff;
foldstyleinitialization = true;


/*
 * USER Win32 thunks
 */

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

enablemapdirect3216 = true;
flatthunks = false;         /* BUGBUG [KevinR] 01-Sep-1993 */


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




WORD GetClassInfoEx(HANDLE hInst, LPSTR lpszClassName, LPSTR lpWndClassEx) =
DWORD GetClassInfoExA(HANDLE hInst, LPSTR lpszClassName, LPSTR lpWndClassEx)
{
    body = special;
    faulterrorcode = 4096 + 0;
}


DWORD GetSetClassData(HWND, INT, DWORD, UINT) =
DWORD GetSetClassData(HWND, INT, DWORD, UINT)
{
/*
 *  LATER: GCL_MENUNAME -- how to map?
 *         for now, pass it through.  ok for atoms (MAKEINTRESOURCE).
 */
    body = special;
    faulterrorcode = 4096 + 0;
}


DWORD GetSetWindowData(HWND, INT, DWORD, UINT) =
DWORD GetSetWindowData(HWND, INT, DWORD, UINT)
{
    body=special;
    faulterrorcode = 4096 + 0;
}



// This is now handled as a hand-coded flatthunk.
//
///*
// * createw.c "CreateWindow and related APIs and support routines."
// */
//
//HWND CreateWindowEx32(DWORD, LPSTR, LPSTR, DWORD, UINT, UINT, UINT, 
//    UINT, HWND, HMENU, HANDLE, DWORD, WORD wIDHi) =
//
//localheap HWND CreateWindowExA(DWORD, LPSTR, LPSTR, DWORD, UINT, UINT, UINT,
//    UINT, HWND, HMENU, HANDLE, DWORD, WORD wIDHi deleted)
//{
//    body = special;
//}




/*
 * Switch table based on uAction.
 */
BOOL SystemParametersInfo32(UINT uAction, UINT, DWORD, UINT) =
BOOL SystemParametersInfoA(UINT uAction, UINT, DWORD, UINT)
{
        body=special;
        faulterrorcode = 4096+0;
}



HWND CreateDialogIndirectParam( HANDLE hInstance, LPSTR lpDialogTemplate,
        HWND hWndParent, FARPROC lpDialogFunc, DWORD dwInitParam) =

localheap HWND CreateDialogIndirectParamA( HANDLE hInstance, LPSTR lpDialogTemplate,
        HWND hWndParent, FARPROC lpDialogFunc, DWORD dwInitParam)
{
    /*
     * !!! resource conversion
     */
    body=special;
}




/* Like DialogBoxIndirectParam but takes a linear address of the dialog
 * template rather than a handle. The real entry point is in user.c
 */
INT DialogBoxIndirectParam( HANDLE hInstance, LPSTR hDialogTemplate,
        HWND hWndParent, FARPROC lpDialogFunc, DWORD dwInitParam) =

localheap INT DialogBoxIndirectParamA( HANDLE hInstance, LPSTR hDialogTemplate,
        HWND hWndParent, FARPROC lpDialogFunc, DWORD dwInitParam)
{
    /*
     * !!! resource conversion
     */

    body=special;
}


HANDLE SetClipboardData32(UINT, HANDLE) =
HANDLE SetClipboardData(UINT, HANDLE)
{ 
        body=special; 
    faulterrorcode = 4096+0;


}

HANDLE GetClipboardData32(UINT) =
HANDLE GetClipboardData(UINT)
{ 
        body=special; 
    faulterrorcode = 4096+0;
}



HMENU LoadMenuIndirect(LPSTR) =
HMENU LoadMenuIndirectA(LPSTR)
{
        body=special;
    faulterrorcode = 4096+0;
}


/*
 * mnchange.c
 *
 * BOOL FAR PASCAL ChangeMenu( hMenu, cmdInsert, lpNewItem, cmd, flags)
 *
 * HMENU       hMenu;
 * WORD        cmdInsert;
 * LPSTR       lpNewItem;
 * WORD        cmd;
 * WORD        flags;
 * /* effects: Stub routine for compatability with the old menu code.
 *  */
 * {
 *   if ( !hMenu)
 *       return( FALSE);
 *
 *   /* These next two statements take care of sleazyness needed for
 *    * compatability with old changemenu.
 *    */
 *   if ( ( flags & MF_SEPARATOR) && cmdInsert==0 && !( flags & MF_CHANGE))
 *     {
 *       flags |= MF_APPEND;
 *     }
 *
 *   if ( !lpNewItem)
 *       flags |= MF_SEPARATOR;
 *
 *   if ( flags & MF_REMOVE)
 *       /* MUST be MF_BYPOSITION for Win2.x compatability.
 *        */
 *       return( RemoveMenu( hMenu, cmdInsert,
 *                         ( flags & ~MF_REMOVE) | MF_BYPOSITION));
 *
 *   if ( flags & MF_DELETE)
 *       return( DeleteMenu( hMenu, cmdInsert, flags & ~MF_DELETE));
 *
 *   if ( flags & MF_CHANGE)
 *       return( ModifyMenu( hMenu, cmdInsert,
 *              ( flags & ~MF_CHANGE) &
 *              ( 0x07F | MF_HELP | MF_BYPOSITION | MF_BYCOMMAND | MF_SEPARATOR),
 *              cmd, lpNewItem));
 *
 *   if ( flags & MF_APPEND)
 *       return( AppendMenu( hMenu, flags & ~MF_APPEND, cmd, lpNewItem));
 *
 *   /* Default is insert */
 *   return( InsertMenu( hMenu, cmdInsert, flags & ~MF_INSERT, cmd, lpNewItem));
 * }
 *
 */

BOOL ChangeMenu( HMENU hMenu, UINT cmdInsert, LPSTR lpNewItem,
                 UINT  cmd,  UINT flags) =
BOOL ChangeMenuA( HMENU hMenu, UINT cmdInsert, LPSTR lpNewItem,
                 UINT cmd, UINT flags)
{
        lpNewItem = raw pack unpack;
        lpNewItemSeg = local 4; 
        
        faulterrorcode = 4096+0;
}




BOOL GetMenuItemInfo32(HMENU, UINT, BOOL, LPMENUITEMINFO lpMenuItemInfo) =
BOOL GetMenuItemInfoA(HMENU, UINT, BOOL, LPMENUITEMINFO lpMenuItemInfo) 
{
    body = special;
    faulterrorcode = 4096+0;
}

BOOL SetMenuItemInfo32(HMENU, UINT, BOOL, LPMENUITEMINFO lpMenuItemInfo) =
BOOL SetMenuItemInfoA(HMENU, UINT, BOOL, LPMENUITEMINFO lpMenuItemInfo) 
{
    body = special;
    faulterrorcode = 4096+0;
}


BOOL InsertMenuItem32(HMENU, UINT, BOOL, LPMENUITEMINFO lpMenuItemInfo) =
BOOL InsertMenuItemA(HMENU, UINT, BOOL, LPMENUITEMINFO lpMenuItemInfo)
{
    body = special;
    faulterrorcode = 4096+0;
}


BOOL InsertMenu( HMENU hMenu, WORD nPosition, WORD wFlags, WORD wIDNewItem,
        LPSTR lpNewItem) =
BOOL InsertMenuA( HMENU hMenu, UINT nPosition, UINT wFlags, UINT wIDNewItem,
        LPSTR lpNewItem)
{
        lpNewItem = raw pack unpack;
        lpNewItemSeg = local 4;
        faulterrorcode = 4096+0;
}


BOOL ModifyMenu( HMENU hMenu, WORD nPosition, WORD wFlags, WORD wIDNewItem,
        LPSTR lpNewItem) =
BOOL ModifyMenuA( HMENU hMenu, UINT nPosition, UINT wFlags, UINT wIDNewItem,
        LPSTR lpNewItem)
{
        lpNewItem = raw pack unpack;
        lpNewItemSeg = local 4;
        faulterrorcode = 4096+0;
}





HHOOK SetWindowsHookEx32(int nType, DWORD pfn, DWORD hmod, DWORD hThread) =
HHOOK SetWindowsHookExA(int nType, DWORD pfn, DWORD hmod, DWORD hThread)
{
    body=special;
    faulterrorcode = 4096+0;
}


BOOL UnhookWindowsHook(int nType, DWORD pfn) =
BOOL UnhookWindowsHook(int nType, DWORD pfn)
{
     body=special;
    faulterrorcode = 4096+0;
}



BOOL WinHelp( HWND hWnd, LPSTR lpHelpFile,  WORD wCommand, DWORD dwData) =
BOOL WinHelpA( HWND hWnd, LPSTR lpHelpFile, DWORD wCommand, DWORD dwData)
{
    /*
     * if wCommand == HELP_KEY or HELP_MULTIKEY
     *     dwData is a pointer, so convert
     *
     * !!! MULTIKEYHELP structure not thunked yet
     */
     body = special;
    faulterrorcode = 4096+0;
}




HCONVLIST DdeConnectList(DWORD idInst, HSZ hszService, HSZ hszTopic,
        HCONVLIST hConvList, PCONVCONTEXT16 pCC) =
HCONVLIST DdeConnectList(DWORD idInst, HSZ hszService, HSZ hszTopic,
        HCONVLIST hConvList, PCONVCONTEXT32 pCC)
{
    pCC = push;
    faulterrorcode = 4096+0;
}


HCONV DdeConnect(DWORD idInst, HSZ hszService, HSZ hszTopic,
        PCONVCONTEXT16 pCC) =
HCONV DdeConnect(DWORD idInst, HSZ hszService, HSZ hszTopic,
        PCONVCONTEXT32 pCC)
{
    pCC = push;
    faulterrorcode = 4096+0;
}


UINT DdeQueryConvInfo(HCONV hConv, DWORD idTransaction, PCONVINFO16 pConvInfo) =
UINT DdeQueryConvInfo(HCONV hConv, DWORD idTransaction, PCONVINFO32 pConvInfo)
{
    body = special;
    faulterrorcode = 4096+0;
}


HDDEDATA DdeClientTransaction(LPBYTE pData, DWORD cbData, HCONV hConv,
        HSZ hszItem, UINT wFmt, UINT wType, DWORD dwTimeout,
        LPDWORD pdwResult) =
HDDEDATA DdeClientTransaction(LPBYTE pData, DWORD cbData, HCONV hConv,
        HSZ hszItem, UINT wFmt, UINT wType, DWORD dwTimeout,
        LPDWORD pdwResult)
{
    body = special;
    faulterrorcode = 4096+0;
}


//LPBYTE DdeAccessData(HDDEDATA hData, LPDWORD pcbDataSize) =
//LPBYTE DdeAccessData(HDDEDATA hData, LPDWORD pcbDataSize)
//{     
//    hData = push;
//}

//BOOL DdeUnaccessData(HDDEDATA hData) =
//BOOL DdeUnaccessData(HDDEDATA hData)
//{     
//    hData = push;
//}



DWORD PackDDElParam( WORD msg,  WORD lParamLo,  WORD lParamHi) =
DWORD PackDDElParam(DWORD msg, DWORD lParamLo, DWORD lParamHi)
{
    body=special;
    faulterrorcode = 4096+0;
}


DWORD UnpackDDElParam( WORD msg, DWORD lParam, DWORD pHi, DWORD pLo) =
DWORD UnpackDDElParam(DWORD msg, DWORD lParam, DWORD pHi, DWORD pLo)
{
    body=special;
    faulterrorcode = 4096+0;
}


BOOL FreeDDElParam( WORD msg, DWORD lParam) =
BOOL FreeDDElParam(DWORD msg, DWORD lParam)
{   
    body=special;
    faulterrorcode = 4096+0;
}

HACCEL CreateAcceleratorTable(LPACCEL16 lpAccel, INT cEntries) = 
HACCEL CreateAcceleratorTable(LPACCEL32 lpAccel, INT cEntries)
{
    cEntries = countof lpAccel;
    faulterrorcode = 4096+0;
}


INT CopyAcceleratorTable(HACCEL hacclOriginal, LPACCEL16 lpaccelCopy, INT cAccel) =
INT CopyAcceleratorTable(HACCEL hacclOriginal, LPACCEL32 lpaccelCopy, INT cAccel) 
{
    lpaccelCopy = output;
    cAccel = countof lpaccelCopy;
    faulterrorcode = 4096+0;
}

BOOL mouse_event(DWORD dwFlags, DWORD dx, DWORD dy, DWORD cButtons, DWORD dwExtraInfo) =
BOOL mouse_event(DWORD dwFlags, DWORD dx, DWORD dy, DWORD cButtons, DWORD dwExtraInfo)
{
    body=special;
}

BOOL keybd_event(BYTE bVirtualKey, BYTE bScanCode, DWORD dwFlags, DWORD dwExtraInfo) =
BOOL keybd_event(BYTE bVirtualKey, BYTE bScanCode, DWORD dwFlags, DWORD dwExtraInfo)
{
    body=special;
}
    

BOOL CleanUpDesktopRectangles(LPVOID arc, 
                              UINT count, 
                              UINT iPrimary, 
                              UINT flags)= 
BOOL AlignRects(LPVOID arc, 
                DWORD count, 
                DWORD iPrimary, 
                DWORD flags)
{
    body=special;
    faulterrorcode = 4096 + 0;
}

BOOL FlashWindowEx( LPFLASHWINFO) =
BOOL FlashWindowEx( LPFLASHWINFO)
{
    body=special;
    faulterrorcode = 0;
}