Ignore:
Timestamp:
Sep 28, 1999, 6:35:06 PM (26 years ago)
Author:
cbratschi
Message:

functions sorted and fixed

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/user32/user32.cpp

    r1078 r1084  
    1 /* $Id: user32.cpp,v 1.35 1999-09-28 12:44:33 dengert Exp $ */
     1/* $Id: user32.cpp,v 1.36 1999-09-28 16:35:06 cbratschi Exp $ */
    22
    33/*
    … …  
    475475  return(rc);
    476476}
    477 //******************************************************************************
    478477
    479478#if 0
    480 //******************************************************************************
    481479/* Caret Functions */
    482480
    … …  
    733731}
    734732
    735 /* Other Functions */
    736 
     733/* Mouse Input Functions */
     734
     735/*****************************************************************************
     736 * Name      : BOOL WIN32API DragDetect
     737 * Purpose   : The DragDetect function captures the mouse and tracks its movement
     738 * Parameters: HWND  hwnd
     739 *             POINT pt
     740 * Variables :
     741 * Result    : If the user moved the mouse outside of the drag rectangle while
     742 *               holding the left button down, the return value is TRUE.
     743 *             If the user did not move the mouse outside of the drag rectangle
     744 *               while holding the left button down, the return value is FALSE.
     745 * Remark    :
     746 * Status    : UNTESTED STUB
     747 *
     748 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     749 *****************************************************************************/
     750BOOL WIN32API DragDetect(HWND  hwnd,
     751                            POINT pt)
     752{
     753  dprintf(("USER32:DragDetect(%08xh,...) not implemented.\n",
     754         hwnd));
     755
     756  return (FALSE);
     757}
     758//******************************************************************************
     759//******************************************************************************
     760HWND WIN32API GetCapture(void)
     761{
     762#ifdef DEBUG
     763    WriteLog("USER32:  GetCapture\n");
     764#endif
     765    return Win32Window::OS2ToWin32Handle(O32_GetCapture());
     766}
     767//******************************************************************************
     768//******************************************************************************
     769UINT WIN32API GetDoubleClickTime(void)
     770{
     771#ifdef DEBUG
     772    WriteLog("USER32:  GetDoubleClickTime\n");
     773#endif
     774    return O32_GetDoubleClickTime();
     775}
     776/*****************************************************************************
     777 * Name      : VOID WIN32API mouse_event
     778 * Purpose   : The mouse_event function synthesizes mouse motion and button clicks.
     779 * Parameters: DWORD dwFlags     flags specifying various motion/click variants
     780 *             DWORD dx          horizontal mouse position or position change
     781 *             DWORD dy          vertical mouse position or position change
     782 *             DWORD cButtons    unused, reserved for future use, set to zero
     783 *             DWORD dwExtraInfo 32 bits of application-defined information
     784 * Variables :
     785 * Result    :
     786 * Remark    :
     787 * Status    : UNTESTED STUB
     788 *
     789 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     790 *****************************************************************************/
     791VOID WIN32API mouse_event(DWORD dwFlags,
     792                             DWORD dx,
     793                             DWORD dy,
     794                             DWORD cButtons,
     795                             DWORD dwExtraInfo)
     796{
     797  dprintf(("USER32:mouse_event (%08xh,%u,%u,%u,%08x) not implemented.\n",
     798          dwFlags,
     799          dx,
     800          dy,
     801          cButtons,
     802          dwExtraInfo));
     803}
     804//******************************************************************************
     805//******************************************************************************
     806BOOL WIN32API ReleaseCapture(void)
     807{
     808#ifdef DEBUG
     809    WriteLog("USER32:  ReleaseCapture\n");
     810#endif
     811    return O32_ReleaseCapture();
     812}
     813//******************************************************************************
     814//******************************************************************************
     815HWND WIN32API SetCapture( HWND hwnd)
     816{
     817#ifdef DEBUG
     818    WriteLog("USER32:  SetCapture\n");
     819#endif
     820    hwnd = Win32Window::Win32ToOS2Handle(hwnd);
     821    return Win32Window::OS2ToWin32Handle(O32_SetCapture(hwnd));
     822}
     823//******************************************************************************
     824//******************************************************************************
     825BOOL WIN32API SetDoubleClickTime( UINT uInterval)
     826{
     827#ifdef DEBUG
     828    WriteLog("USER32:  SetDoubleClickTime\n");
     829#endif
     830    return O32_SetDoubleClickTime(uInterval);
     831}
     832//******************************************************************************
     833//******************************************************************************
     834BOOL WIN32API SwapMouseButton( BOOL fSwap)
     835{
     836#ifdef DEBUG
     837    WriteLog("USER32:  SwapMouseButton\n");
     838#endif
     839    return O32_SwapMouseButton(fSwap);
     840}
     841
     842/* Error Functions */
     843
     844BOOL WIN32API ExitWindowsEx( UINT uFlags, DWORD  dwReserved)
     845{
     846#ifdef DEBUG
     847    WriteLog("USER32:  ExitWindowsEx\n");
     848#endif
     849    return O32_ExitWindowsEx(uFlags,dwReserved);
     850}
     851//******************************************************************************
     852//******************************************************************************
    737853BOOL WIN32API MessageBeep( UINT uType)
    738854{
    … …  
    766882}
    767883//******************************************************************************
    768 //******************************************************************************
     884//2nd parameter not used according to SDK (yet?)
     885//******************************************************************************
     886VOID WIN32API SetLastErrorEx(DWORD dwErrCode, DWORD dwType)
     887{
     888#ifdef DEBUG
     889  WriteLog("USER32:  SetLastErrorEx\n");
     890#endif
     891  SetLastError(dwErrCode);
     892}
     893
     894/* Accessibility Functions */
     895
    769896int WIN32API GetSystemMetrics(int nIndex)
    770897{
    … …  
    802929        rc = GetSystemMetrics(SM_CYMINIMIZED);
    803930        break;
     931    case SM_CXICON:
     932    case SM_CYICON:
     933        rc = 32;  //CB: Win32: only 32x32, OS/2 32x32/40x40
     934                  //    we must implement 32x32 for all screen resolutions
     935        break;
    804936    case SM_CXSMICON: //recommended size of small icons (TODO: adjust to screen res.)
    805937        rc = 16;
    … …  
    8781010#endif
    8791011    return(rc);
    880 }
    881 //******************************************************************************
    882 //******************************************************************************
    883 #if 0
    884 UINT WIN32API SetTimer( HWND hwnd, UINT idTimer, UINT uTimeout, TIMERPROC  tmprc)
    885 {
    886 #ifdef DEBUG
    887     WriteLog("USER32: SetTimer INCORRECT CALLING CONVENTION FOR HANDLER!!!!!\n");
    888 #endif
    889     hwnd = Win32Window::Win32ToOS2Handle(hwnd);
    890     //SvL: Write callback handler class for this one
    891     //CB: replace
    892     return O32_SetTimer(hwnd,idTimer,uTimeout,(TIMERPROC_O32)tmprc);
    893 }
    894 //******************************************************************************
    895 //******************************************************************************
    896 BOOL WIN32API KillTimer(HWND hWnd, UINT uIDEvent)
    897 {
    898 #ifdef DEBUG
    899     WriteLog("USER32:  KillTimer\n");
    900 #endif
    901     hWnd = Win32Window::Win32ToOS2Handle(hWnd);
    902     //WinStopTimer
    903     //CB: replace
    904     return O32_KillTimer(hWnd,uIDEvent);
    905 }
    906 #endif
    907 //******************************************************************************
    908 //******************************************************************************
    909 //******************************************************************************
    910 //TODO:How can we emulate this one in OS/2???
    911 //******************************************************************************
    912 DWORD WIN32API WaitForInputIdle(HANDLE hProcess, DWORD dwTimeOut)
    913 {
    914 #ifdef DEBUG
    915   WriteLog("USER32:  WaitForInputIdle (Not Implemented) %d\n", dwTimeOut);
    916 #endif
    917 
    918   if(dwTimeOut == INFINITE) return(0);
    919 
    920 //  DosSleep(dwTimeOut/16);
    921   return(0);
    922 }
    923 //******************************************************************************
    924 //******************************************************************************
    925 BOOL WIN32API WinHelpA( HWND hwnd, LPCSTR lpszHelp, UINT uCommand, DWORD  dwData)
    926 {
    927 #ifdef DEBUG
    928     WriteLog("USER32:  WinHelp not implemented %s\n", lpszHelp);
    929 #endif
    930 //    hwnd = Win32Window::Win32ToOS2Handle(hwnd);
    931 //    return O32_WinHelp(arg1, arg2, arg3, arg4);
    932 
    933     return(TRUE);
    934 }
    935 //******************************************************************************
    936 //SvL: 24-6-'97 - Added
    937 //TODO: Not implemented
    938 //******************************************************************************
    939 WORD WIN32API GetAsyncKeyState(INT nVirtKey)
    940 {
    941 #ifdef DEBUG
    942 ////    WriteLog("USER32:  GetAsyncKeyState Not implemented\n");
    943 #endif
    944     return 0;
    945 }
    946 //******************************************************************************
    947 //SvL: 24-6-'97 - Added
    948 //******************************************************************************
    949 WORD WIN32API VkKeyScanA( char ch)
    950 {
    951 #ifdef DEBUG
    952     WriteLog("USER32:  VkKeyScanA\n");
    953 #endif
    954     return O32_VkKeyScan(ch);
    955 }
    956 //******************************************************************************
    957 //SvL: 24-6-'97 - Added
    958 //******************************************************************************
    959 SHORT WIN32API GetKeyState( int nVirtKey)
    960 {
    961 #ifdef DEBUG
    962     WriteLog("USER32:  GetKeyState %d\n", nVirtKey);
    963 #endif
    964     return O32_GetKeyState(nVirtKey);
    965 }
    966 //******************************************************************************
    967 //******************************************************************************
    968 HWND WIN32API SetCapture( HWND arg1)
    969 {
    970 #ifdef DEBUG
    971     WriteLog("USER32:  SetCapture\n");
    972 #endif
    973     return O32_SetCapture(arg1);
    974 }
    975 //******************************************************************************
    976 //******************************************************************************
    977 BOOL WIN32API ReleaseCapture(void)
    978 {
    979 #ifdef DEBUG
    980     WriteLog("USER32:  ReleaseCapture\n");
    981 #endif
    982     return O32_ReleaseCapture();
    983 }
    984 //******************************************************************************
    985 //******************************************************************************
    986 DWORD WIN32API MsgWaitForMultipleObjects( DWORD arg1, LPHANDLE arg2, BOOL arg3, DWORD arg4, DWORD  arg5)
    987 {
    988 #ifdef DEBUG
    989     WriteLog("USER32:  MsgWaitForMultipleObjects\n");
    990 #endif
    991     return O32_MsgWaitForMultipleObjects(arg1, arg2, arg3, arg4, arg5);
    992 }
    993 //******************************************************************************
    994 //******************************************************************************
    995 BOOL WIN32API CheckRadioButton( HWND arg1, UINT arg2, UINT arg3, UINT  arg4)
    996 {
    997 #ifdef DEBUG
    998     WriteLog("USER32:  CheckRadioButton\n");
    999 #endif
    1000     //CB: check radio buttons in interval
    1001     if (arg2 > arg3) return (FALSE);
    1002     for (UINT x=arg2;x <= arg3;x++)
    1003     {
    1004      SendDlgItemMessageA(arg1,x,BM_SETCHECK,(x == arg4) ? BST_CHECKED : BST_UNCHECKED,0);
    1005     }
    1006     return (TRUE);
    1007 }
    1008 //******************************************************************************
    1009 //******************************************************************************
    1010 BOOL WIN32API EndDeferWindowPos( HDWP arg1)
    1011 {
    1012 #ifdef DEBUG
    1013     WriteLog("USER32:  EndDeferWindowPos\n");
    1014 #endif
    1015     return O32_EndDeferWindowPos(arg1);
    1016 }
    1017 //******************************************************************************
    1018 //******************************************************************************
    1019 INT WIN32API ExcludeUpdateRgn( HDC arg1, HWND  arg2)
    1020 {
    1021 #ifdef DEBUG
    1022     WriteLog("USER32:  ExcludeUpdateRgn\n");
    1023 #endif
    1024     return O32_ExcludeUpdateRgn(arg1, arg2);
    1025 }
    1026 //******************************************************************************
    1027 //******************************************************************************
    1028 BOOL WIN32API ExitWindowsEx( UINT arg1, DWORD  arg2)
    1029 {
    1030 #ifdef DEBUG
    1031     WriteLog("USER32:  ExitWindowsEx\n");
    1032 #endif
    1033     return O32_ExitWindowsEx(arg1, arg2);
    1034 }
    1035 //******************************************************************************
    1036 //******************************************************************************
    1037 int WIN32API FillRect(HDC arg1, const RECT * arg2, HBRUSH arg3)
    1038 {
    1039 #ifdef DEBUG
    1040     WriteLog("USER32:  FillRect (%d,%d)(%d,%d) brush %X\n", arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
    1041 #endif
    1042     return O32_FillRect(arg1, arg2, arg3);
    1043 }
    1044 //******************************************************************************
    1045 //******************************************************************************
    1046 HWND WIN32API FindWindowW( LPCWSTR arg1, LPCWSTR arg2)
    1047 {
    1048  char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
    1049  char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
    1050  HWND rc;
    1051 
    1052 #ifdef DEBUG
    1053     WriteLog("USER32:  FindWindowW\n");
    1054 #endif
    1055     rc = O32_FindWindow(astring1, astring2);
    1056     FreeAsciiString(astring1);
    1057     FreeAsciiString(astring2);
    1058     return rc;
    1059 }
    1060 //******************************************************************************
    1061 //******************************************************************************
    1062 int WIN32API FrameRect( HDC arg1, const RECT * arg2, HBRUSH  arg3)
    1063 {
    1064 #ifdef DEBUG
    1065     WriteLog("USER32:  FrameRect\n");
    1066 #endif
    1067     return O32_FrameRect(arg1, arg2, arg3);
    1068 }
    1069 //******************************************************************************
    1070 //******************************************************************************
    1071 HWND WIN32API GetCapture(void)
    1072 {
    1073 #ifdef DEBUG
    1074     WriteLog("USER32:  GetCapture\n");
    1075 #endif
    1076     return O32_GetCapture();
    1077 }
    1078 //******************************************************************************
    1079 //******************************************************************************
    1080 UINT WIN32API GetDoubleClickTime(void)
    1081 {
    1082 #ifdef DEBUG
    1083     WriteLog("USER32:  GetDoubleClickTime\n");
    1084 #endif
    1085     return O32_GetDoubleClickTime();
    1086 }
    1087 //******************************************************************************
    1088 //******************************************************************************
    1089 HWND WIN32API GetForegroundWindow(void)
    1090 {
    1091 #ifdef DEBUG
    1092     WriteLog("USER32:  GetForegroundWindow\n");
    1093 #endif
    1094     return O32_GetForegroundWindow();
    1095 }
    1096 //******************************************************************************
    1097 //******************************************************************************
    1098 int WIN32API GetKeyNameTextA( LPARAM arg1, LPSTR arg2, int  arg3)
    1099 {
    1100 #ifdef DEBUG
    1101     WriteLog("USER32:  GetKeyNameTextA\n");
    1102 #endif
    1103     return O32_GetKeyNameText(arg1, arg2, arg3);
    1104 }
    1105 //******************************************************************************
    1106 //******************************************************************************
    1107 int WIN32API GetKeyNameTextW( LPARAM arg1, LPWSTR arg2, int  arg3)
    1108 {
    1109 #ifdef DEBUG
    1110     WriteLog("USER32:  GetKeyNameTextW DOES NOT WORK\n");
    1111 #endif
    1112     // NOTE: This will not work as is (needs UNICODE support)
    1113     return 0;
    1114 //    return O32_GetKeyNameText(arg1, arg2, arg3);
    1115 }
    1116 //******************************************************************************
    1117 //******************************************************************************
    1118 int WIN32API GetKeyboardType( int arg1)
    1119 {
    1120 #ifdef DEBUG
    1121     WriteLog("USER32:  GetKeyboardType\n");
    1122 #endif
    1123     return O32_GetKeyboardType(arg1);
    1124 }
    1125 //******************************************************************************
    1126 //******************************************************************************
    1127 HWND WIN32API GetLastActivePopup( HWND arg1)
    1128 {
    1129 #ifdef DEBUG
    1130     WriteLog("USER32:  GetLastActivePopup\n");
    1131 #endif
    1132     return O32_GetLastActivePopup(arg1);
    1133 }
    1134 //******************************************************************************
    1135 //******************************************************************************
    1136 //******************************************************************************
    1137 //******************************************************************************
    1138 DWORD WIN32API GetQueueStatus( UINT arg1)
    1139 {
    1140 #ifdef DEBUG
    1141     WriteLog("USER32:  GetQueueStatus\n");
    1142 #endif
    1143     return O32_GetQueueStatus(arg1);
    1144 }
    1145 //******************************************************************************
    1146 //******************************************************************************
    1147 DWORD WIN32API GetTabbedTextExtentA( HDC arg1, LPCSTR arg2, int arg3, int arg4, int * arg5)
    1148 {
    1149 #ifdef DEBUG
    1150     WriteLog("USER32:  GetTabbedTextExtentA\n");
    1151 #endif
    1152     return O32_GetTabbedTextExtent(arg1, arg2, arg3, arg4, arg5);
    1153 }
    1154 //******************************************************************************
    1155 //******************************************************************************
    1156 DWORD WIN32API GetTabbedTextExtentW( HDC arg1, LPCWSTR arg2, int arg3, int arg4, int * arg5)
    1157 {
    1158  char *astring = UnicodeToAsciiString((LPWSTR)arg2);
    1159  DWORD rc;
    1160 
    1161 #ifdef DEBUG
    1162     WriteLog("USER32:  GetTabbedTextExtentW\n");
    1163 #endif
    1164     rc = O32_GetTabbedTextExtent(arg1, astring, arg3, arg4, arg5);
    1165     FreeAsciiString(astring);
    1166     return rc;
    1167 }
    1168 //******************************************************************************
    1169 //******************************************************************************
    1170 #if 0
    1171 int WIN32API GetUpdateRgn( HWND arg1, HRGN arg2, BOOL  arg3)
    1172 {
    1173 #ifdef DEBUG
    1174     WriteLog("USER32:  GetUpdateRgn\n");
    1175 #endif
    1176     return O32_GetUpdateRgn(arg1, arg2, arg3);
    1177 }
    1178 #endif
    1179 //******************************************************************************
    1180 
    1181 
    1182 //******************************************************************************
    1183 //******************************************************************************
    1184 //******************************************************************************
    1185 DWORD WIN32API GetWindowThreadProcessId(HWND arg1, PDWORD  arg2)
    1186 {
    1187 #ifdef DEBUG
    1188     WriteLog("USER32:  GetWindowThreadProcessId\n");
    1189 #endif
    1190     return O32_GetWindowThreadProcessId(arg1, arg2);
    1191 }
    1192 //******************************************************************************
    1193 //******************************************************************************
    1194 #if 0
    1195 BOOL WIN32API InvalidateRgn( HWND arg1, HRGN arg2, BOOL  arg3)
    1196 {
    1197 #ifdef DEBUG
    1198     WriteLog("USER32:  InvalidateRgn\n");
    1199 #endif
    1200     return O32_InvalidateRgn(arg1, arg2, arg3);
    1201 }
    1202 #endif
    1203 //******************************************************************************
    1204 //******************************************************************************
    1205 BOOL WIN32API InvertRect( HDC arg1, const RECT * arg2)
    1206 {
    1207 #ifdef DEBUG
    1208     WriteLog("USER32:  InvertRect\n");
    1209 #endif
    1210     return O32_InvertRect(arg1, arg2);
    1211 }
    1212 //******************************************************************************
    1213 //******************************************************************************
    1214 BOOL WIN32API MapDialogRect( HWND arg1, PRECT  arg2)
    1215 {
    1216 #ifdef DEBUG
    1217     WriteLog("USER32:  MapDialogRect\n");
    1218 #endif
    1219     return O32_MapDialogRect(arg1, arg2);
    1220 }
    1221 //******************************************************************************
    1222 //******************************************************************************
    1223 UINT WIN32API MapVirtualKeyA( UINT arg1, UINT  arg2)
    1224 {
    1225 #ifdef DEBUG
    1226     WriteLog("USER32:  MapVirtualKeyA\n");
    1227 #endif
    1228     return O32_MapVirtualKey(arg1, arg2);
    1229 }
    1230 //******************************************************************************
    1231 //******************************************************************************
    1232 UINT WIN32API MapVirtualKeyW( UINT arg1, UINT  arg2)
    1233 {
    1234 #ifdef DEBUG
    1235     WriteLog("USER32:  MapVirtualKeyW\n");
    1236 #endif
    1237     // NOTE: This will not work as is (needs UNICODE support)
    1238     return O32_MapVirtualKey(arg1, arg2);
    1239 }
    1240 //******************************************************************************
    1241 //******************************************************************************
    1242 int WIN32API MapWindowPoints( HWND arg1, HWND arg2, LPPOINT arg3, UINT arg4)
    1243 {
    1244 #ifdef DEBUG
    1245     WriteLog("USER32:  MapWindowPoints\n");
    1246 #endif
    1247     return O32_MapWindowPoints(arg1, arg2, arg3, arg4);
    1248 }
    1249 //******************************************************************************
    1250 //******************************************************************************
    1251 BOOL WIN32API ScreenToClient (HWND hwnd, LPPOINT pt)
    1252 {
    1253 #ifdef DEBUG
    1254     WriteLog("USER32:  ScreenToClient\n");
    1255 #endif
    1256     Win32BaseWindow *wnd;
    1257     PRECT rcl;
    1258 
    1259     if (!hwnd) return (TRUE);
    1260     wnd = Win32BaseWindow::GetWindowFromHandle (hwnd);
    1261     if (!wnd) return (TRUE);
    1262 
    1263     rcl   = wnd->getClientRect();
    1264     pt->y = ScreenHeight - pt->y;
    1265     OSLibWinMapWindowPoints (OSLIB_HWND_DESKTOP, wnd->getOS2WindowHandle(), (OSLIBPOINT *)pt, 1);
    1266     pt->y = (rcl->bottom - rcl->top) - pt->y;
    1267     return (TRUE);
    1268 }
    1269 //******************************************************************************
    1270 //******************************************************************************
    1271 #if 0
    1272 BOOL WIN32API ScrollDC( HDC arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT  arg7)
    1273 {
    1274 #ifdef DEBUG
    1275     WriteLog("USER32:  ScrollDC\n");
    1276 #endif
    1277     return O32_ScrollDC(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
    1278 }
    1279 #endif
    1280 //******************************************************************************
    1281 //******************************************************************************
    1282 BOOL WIN32API SetDoubleClickTime( UINT arg1)
    1283 {
    1284 #ifdef DEBUG
    1285     WriteLog("USER32:  SetDoubleClickTime\n");
    1286 #endif
    1287     return O32_SetDoubleClickTime(arg1);
    1288 }
    1289 //******************************************************************************
    1290 //******************************************************************************
    1291 BOOL WIN32API SwapMouseButton( BOOL arg1)
    1292 {
    1293 #ifdef DEBUG
    1294     WriteLog("USER32:  SwapMouseButton\n");
    1295 #endif
    1296     return O32_SwapMouseButton(arg1);
    12971012}
    12981013//******************************************************************************
    … …  
    13341049        memset(cmetric, 0, sizeof(NONCLIENTMETRICSA));
    13351050        cmetric->cbSize = sizeof(NONCLIENTMETRICSA);
    1336         //CB: font info not valid, needs improvements
    1337         O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfCaptionFont),0);
    1338         O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMenuFont),0);
    1339         //CB: experimental change for statusbar (and tooltips)
    1340 
    1341         //O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfStatusFont),0);
     1051
     1052        //CB: fonts not handled by Open32, set to WarpSans
     1053        lstrcpyA(cmetric->lfCaptionFont.lfFaceName,"WarpSans");
     1054        cmetric->lfCaptionFont.lfHeight = 9;
     1055
     1056        lstrcpyA(cmetric->lfMenuFont.lfFaceName,"WarpSans");
     1057        cmetric->lfMenuFont.lfHeight = 9;
     1058
    13421059        lstrcpyA(cmetric->lfStatusFont.lfFaceName,"WarpSans");
    13431060        cmetric->lfStatusFont.lfHeight = 9;
    13441061
    1345         O32_SystemParametersInfo(SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(cmetric->lfMessageFont),0);
     1062        lstrcpyA(cmetric->lfMessageFont.lfFaceName,"WarpSans");
     1063        cmetric->lfMessageFont.lfHeight = 9;
     1064
    13461065        cmetric->iBorderWidth     = GetSystemMetrics(SM_CXBORDER);
    13471066        cmetric->iScrollWidth     = GetSystemMetrics(SM_CXHSCROLL);
    … …  
    14811200    return(rc);
    14821201}
    1483 //******************************************************************************
    1484 //******************************************************************************
    1485 LONG WIN32API TabbedTextOutA( HDC arg1, int arg2, int arg3, LPCSTR arg4, int arg5, int arg6, int * arg7, int  arg8)
    1486 {
    1487 #ifdef DEBUG
    1488     WriteLog("USER32:  TabbedTextOutA\n");
    1489 #endif
    1490     return O32_TabbedTextOut(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
    1491 }
    1492 //******************************************************************************
    1493 //******************************************************************************
    1494 LONG WIN32API TabbedTextOutW( HDC arg1, int arg2, int arg3, LPCWSTR arg4, int arg5, int arg6, int * arg7, int  arg8)
    1495 {
    1496  char *astring = UnicodeToAsciiString((LPWSTR)arg4);
    1497  LONG rc;
    1498 
    1499 #ifdef DEBUG
    1500     WriteLog("USER32:  TabbedTextOutW\n");
    1501 #endif
    1502     rc = O32_TabbedTextOut(arg1, arg2, arg3, astring, arg5, arg6, arg7, arg8);
    1503     FreeAsciiString(astring);
    1504     return rc;
    1505 }
    1506 //******************************************************************************
    1507 //******************************************************************************
    1508 BOOL WIN32API ValidateRect( HWND arg1, const RECT * arg2)
    1509 {
    1510 #ifdef DEBUG
    1511     WriteLog("USER32:  ValidateRect\n");
    1512 #endif
    1513     return O32_ValidateRect(arg1, arg2);
    1514 }
    1515 //******************************************************************************
    1516 //******************************************************************************
    1517 BOOL WIN32API ValidateRgn( HWND arg1, HRGN  arg2)
    1518 {
    1519 #ifdef DEBUG
    1520     WriteLog("USER32:  ValidateRgn\n");
    1521 #endif
    1522     return O32_ValidateRgn(arg1, arg2);
    1523 }
    1524 //******************************************************************************
    1525 //******************************************************************************
    1526 WORD WIN32API VkKeyScanW( WCHAR arg1)
    1527 {
    1528 #ifdef DEBUG
    1529     WriteLog("USER32:  VkKeyScanW\n");
    1530 #endif
    1531     // NOTE: This will not work as is (needs UNICODE support)
    1532     return O32_VkKeyScan((char)arg1);
     1202
     1203/* Timer Functions */
     1204
     1205#if 0
     1206BOOL WIN32API KillTimer(HWND hWnd, UINT uIDEvent)
     1207{
     1208#ifdef DEBUG
     1209    WriteLog("USER32:  KillTimer\n");
     1210#endif
     1211    hWnd = Win32Window::Win32ToOS2Handle(hWnd);
     1212    //WinStopTimer
     1213    //CB: replace
     1214    return O32_KillTimer(hWnd,uIDEvent);
     1215}
     1216//******************************************************************************
     1217//******************************************************************************
     1218UINT WIN32API SetTimer( HWND hwnd, UINT idTimer, UINT uTimeout, TIMERPROC  tmprc)
     1219{
     1220#ifdef DEBUG
     1221    WriteLog("USER32: SetTimer INCORRECT CALLING CONVENTION FOR HANDLER!!!!!\n");
     1222#endif
     1223    hwnd = Win32Window::Win32ToOS2Handle(hwnd);
     1224    //SvL: Write callback handler class for this one
     1225    //CB: replace
     1226    return O32_SetTimer(hwnd,idTimer,uTimeout,(TIMERPROC_O32)tmprc);
     1227}
     1228#endif
     1229
     1230/* Process and Thread Functions */
     1231
     1232//******************************************************************************
     1233//DWORD idAttach;   /* thread to attach */
     1234//DWORD idAttachTo; /* thread to attach to  */
     1235//BOOL fAttach; /* attach or detach */
     1236//******************************************************************************
     1237BOOL WIN32API AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
     1238{
     1239#ifdef DEBUG
     1240  WriteLog("USER32:  AttachThreadInput, not implemented\n");
     1241#endif
     1242  return(TRUE);
     1243}
     1244//******************************************************************************
     1245//TODO:How can we emulate this one in OS/2???
     1246//******************************************************************************
     1247DWORD WIN32API WaitForInputIdle(HANDLE hProcess, DWORD dwTimeOut)
     1248{
     1249#ifdef DEBUG
     1250  WriteLog("USER32:  WaitForInputIdle (Not Implemented) %d\n", dwTimeOut);
     1251#endif
     1252
     1253  if(dwTimeOut == INFINITE) return(0);
     1254
     1255//  DosSleep(dwTimeOut/16);
     1256  return(0);
     1257}
     1258
     1259/* Help Functions */
     1260
     1261BOOL WIN32API WinHelpA( HWND hwnd, LPCSTR lpszHelp, UINT uCommand, DWORD  dwData)
     1262{
     1263#ifdef DEBUG
     1264    WriteLog("USER32:  WinHelp not implemented %s\n", lpszHelp);
     1265#endif
     1266//    hwnd = Win32Window::Win32ToOS2Handle(hwnd);
     1267//    return O32_WinHelp(arg1, arg2, arg3, arg4);
     1268
     1269    return(TRUE);
    15331270}
    15341271//******************************************************************************
    … …  
    15461283    return rc;
    15471284}
    1548 //******************************************************************************
    1549 //TODO: Not complete
    1550 //******************************************************************************
    1551 BOOL WIN32API GrayStringA(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
    1552                           LPARAM lpData, int nCount, int X, int Y, int nWidth,
    1553                           int nHeight)
    1554 {
    1555  BOOL     rc;
    1556  COLORREF curclr;
    1557 
    1558 #ifdef DEBUG
    1559   WriteLog("USER32:  GrayStringA, not completely implemented\n");
    1560 #endif
    1561   if(lpOutputFunc == NULL && lpData == NULL) {
    1562 #ifdef DEBUG
    1563     WriteLog("USER32:  lpOutputFunc == NULL && lpData == NULL\n");
    1564 #endif
    1565     return(FALSE);
    1566   }
    1567   if(lpOutputFunc) {
    1568         return(lpOutputFunc(hdc, lpData, nCount));
    1569   }
    1570   curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
    1571   rc = TextOutA(hdc, X, Y, (char *)lpData, nCount);
    1572   SetTextColor(hdc, curclr);
    1573 
    1574   return(rc);
    1575 }
    1576 //******************************************************************************
    1577 //******************************************************************************
    1578 BOOL WIN32API GrayStringW(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
    1579                           LPARAM lpData, int nCount, int X, int Y, int nWidth,
    1580                           int nHeight)
    1581 {
    1582  BOOL     rc;
    1583  char    *astring;
    1584  COLORREF curclr;
    1585 
    1586 #ifdef DEBUG
    1587   WriteLog("USER32:  GrayStringW, not completely implemented\n");
    1588 #endif
    1589 
    1590   if(lpOutputFunc == NULL && lpData == NULL) {
    1591 #ifdef DEBUG
    1592     WriteLog("USER32:  lpOutputFunc == NULL && lpData == NULL\n");
    1593 #endif
    1594     return(FALSE);
    1595   }
    1596   if(nCount == 0)
    1597     nCount = UniStrlen((UniChar*)lpData);
    1598 
    1599   if(lpOutputFunc) {
    1600     return(lpOutputFunc(hdc, lpData, nCount));
    1601   }
    1602   astring = UnicodeToAsciiString((LPWSTR)lpData);
    1603 
    1604   curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
    1605   rc = TextOutA(hdc, X, Y, astring, nCount);
    1606   SetTextColor(hdc, curclr);
    1607 
    1608   FreeAsciiString(astring);
    1609   return(rc);
    1610 }
    1611 //******************************************************************************
    1612 //TODO:
    1613 //******************************************************************************
    1614 HANDLE WIN32API CopyImage(HANDLE hImage, UINT uType, int cxDesired, int cyDesired, UINT fuFlags)
    1615 {
    1616 #ifdef DEBUG
    1617   WriteLog("USER32:  CopyImage, not implemented\n");
    1618 #endif
    1619   switch(uType) {
    1620     case IMAGE_BITMAP:
    1621     case IMAGE_CURSOR:
    1622     case IMAGE_ICON:
    1623     default:
    1624 #ifdef DEBUG
    1625         WriteLog("USER32:  CopyImage, unknown type\n");
    1626 #endif
    1627         return(NULL);
    1628   }
    1629   return(NULL);
    1630 }
    1631 //******************************************************************************
    1632 //******************************************************************************
    1633 BOOL WIN32API GetKeyboardState(PBYTE lpKeyState)
    1634 {
    1635 #ifdef DEBUG
    1636   WriteLog("USER32:  GetKeyboardState, not properly implemented\n");
    1637 #endif
    1638   memset(lpKeyState, 0, 256);
     1285
     1286/* Keyboard and Input Functions */
     1287
     1288BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
     1289{
     1290#ifdef DEBUG
     1291  WriteLog("USER32:  ActivateKeyboardLayout, not implemented\n");
     1292#endif
    16391293  return(TRUE);
    16401294}
    16411295//******************************************************************************
    1642 //******************************************************************************
    1643 BOOL WIN32API SetKeyboardState(PBYTE lpKeyState)
    1644 {
    1645 #ifdef DEBUG
    1646   WriteLog("USER32:  SetKeyboardState, not implemented\n");
    1647 #endif
    1648   return(TRUE);
    1649 }
    1650 //******************************************************************************
    1651 //2nd parameter not used according to SDK (yet?)
    1652 //******************************************************************************
    1653 VOID WIN32API SetLastErrorEx(DWORD dwErrCode, DWORD dwType)
    1654 {
    1655 #ifdef DEBUG
    1656   WriteLog("USER32:  SetLastErrorEx\n");
    1657 #endif
    1658   SetLastError(dwErrCode);
    1659 }
    1660 //******************************************************************************
    1661 //******************************************************************************
    1662 BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
    1663 {
    1664 #ifdef DEBUG
    1665   WriteLog("USER32:  ActivateKeyboardLayout, not implemented\n");
    1666 #endif
    1667   return(TRUE);
    1668 }
    1669 //******************************************************************************
    1670 //******************************************************************************
    1671 int WIN32API GetKeyboardLayoutList(int nBuff, HKL *lpList)
    1672 {
    1673 #ifdef DEBUG
    1674   WriteLog("USER32:  GetKeyboardLayoutList, not implemented\n");
    1675 #endif
    1676   return(0);
    1677 }
    1678 //******************************************************************************
    1679 //******************************************************************************
    1680 HKL WIN32API GetKeyboardLayout(DWORD dwLayout)
    1681 {
    1682 #ifdef DEBUG
    1683   WriteLog("USER32:  GetKeyboardLayout, not implemented\n");
    1684 #endif
    1685   return(0);
    1686 }
    1687 //******************************************************************************
    1688 //******************************************************************************
    1689 int WIN32API LookupIconIdFromDirectory(PBYTE presbits, BOOL fIcon)
    1690 {
    1691 #ifdef DEBUG
    1692   WriteLog("USER32:  LookupIconIdFromDirectory, not implemented\n");
    1693 #endif
    1694   return(0);
    1695 }
    1696 //******************************************************************************
    1697 //******************************************************************************
    1698 int WIN32API LookupIconIdFromDirectoryEx(PBYTE presbits, BOOL  fIcon,
    1699                         int cxDesired, int cyDesired,
    1700                         UINT Flags)
    1701 {
    1702 #ifdef DEBUG
    1703   WriteLog("USER32:  LookupIconIdFromDirectoryEx, not implemented\n");
    1704 #endif
    1705   return(0);
    1706 }
    1707 //******************************************************************************
    1708 //DWORD idAttach;   /* thread to attach */
    1709 //DWORD idAttachTo; /* thread to attach to  */
    1710 //BOOL fAttach; /* attach or detach */
    1711 //******************************************************************************
    1712 BOOL WIN32API AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
    1713 {
    1714 #ifdef DEBUG
    1715   WriteLog("USER32:  AttachThreadInput, not implemented\n");
    1716 #endif
    1717   return(TRUE);
    1718 }
    1719 //******************************************************************************
    1720 //******************************************************************************
    1721 BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
    1722 {
    1723 #ifdef DEBUG
    1724   WriteLog("USER32:  RegisterHotKey, not implemented\n");
    1725 #endif
    1726   return(TRUE);
    1727 }
    1728 //******************************************************************************
    1729 //******************************************************************************
    1730 BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
    1731 {
    1732 #ifdef DEBUG
    1733   WriteLog("USER32:  UnregisterHotKey, not implemented\n");
    1734 #endif
    1735   return(TRUE);
    1736 }
    1737 //******************************************************************************
    1738 //******************************************************************************
    1739 BOOL WIN32API SetWindowContextHelpId(HWND hwnd, DWORD dwContextHelpId)
    1740 {
    1741 #ifdef DEBUG
    1742   WriteLog("USER32:  SetWindowContextHelpId, not implemented\n");
    1743 #endif
    1744   return(TRUE);
    1745 }
    1746 //******************************************************************************
    1747 //******************************************************************************
    1748 DWORD WIN32API GetWindowContextHelpId(HWND hwnd)
    1749 {
    1750 #ifdef DEBUG
    1751   WriteLog("USER32:  GetWindowContextHelpId, not implemented\n");
    1752 #endif
    1753   return(0);
    1754 }
    1755 //******************************************************************************
    1756 //******************************************************************************
    1757 BOOL WIN32API GetMonitorInfoA(HMONITOR,LPMONITORINFO)
    1758 {
    1759 #ifdef DEBUG
    1760   WriteLog("USER32:  GetMonitorInfoA not supported!!\n");
    1761 #endif
    1762   return(FALSE);
    1763 }
    1764 //******************************************************************************
    1765 //******************************************************************************
    1766 BOOL WIN32API GetMonitorInfoW(HMONITOR,LPMONITORINFO)
    1767 {
    1768 #ifdef DEBUG
    1769   WriteLog("USER32:  GetMonitorInfoW not supported!!\n");
    1770 #endif
    1771   return(FALSE);
    1772 }
    1773 //******************************************************************************
    1774 //******************************************************************************
    1775 HMONITOR WIN32API MonitorFromWindow(HWND hwnd, DWORD dwFlags)
    1776 {
    1777 #ifdef DEBUG
    1778   WriteLog("USER32:  MonitorFromWindow not correctly supported??\n");
    1779 #endif
    1780   return(0);
    1781 }
    1782 //******************************************************************************
    1783 //******************************************************************************
    1784 HMONITOR WIN32API MonitorFromRect(LPRECT rect, DWORD dwFlags)
    1785 {
    1786 #ifdef DEBUG
    1787   WriteLog("USER32:  MonitorFromRect not correctly supported??\n");
    1788 #endif
    1789   return(0);
    1790 }
    1791 //******************************************************************************
    1792 //******************************************************************************
    1793 HMONITOR WIN32API MonitorFromPoint(POINT point, DWORD dwflags)
    1794 {
    1795 #ifdef DEBUG
    1796   WriteLog("USER32:  MonitorFromPoint not correctly supported??\n");
    1797 #endif
    1798   return(0);
    1799 }
    1800 //******************************************************************************
    1801 //******************************************************************************
    1802 BOOL WIN32API EnumDisplayMonitors(HDC,LPRECT,MONITORENUMPROC,LPARAM)
    1803 {
    1804 #ifdef DEBUG
    1805   WriteLog("USER32:  EnumDisplayMonitors not supported??\n");
    1806 #endif
    1807   return(FALSE);
    1808 }
    1809 //******************************************************************************
    1810 //******************************************************************************
    1811 BOOL WIN32API EnumDisplaySettingsA(LPCSTR lpszDeviceName, DWORD iModeNum,
    1812                       LPDEVMODEA lpDevMode)
    1813 {
    1814 #ifdef DEBUG
    1815     WriteLog("USER32:  EnumDisplaySettingsA FAKED\n");
    1816 #endif
    1817     switch(iModeNum) {
    1818     case 0:
    1819         lpDevMode->dmBitsPerPel       = 16;
    1820         lpDevMode->dmPelsWidth        = 768;
    1821         lpDevMode->dmPelsHeight       = 1024;
    1822         lpDevMode->dmDisplayFlags     = 0;
    1823         lpDevMode->dmDisplayFrequency = 70;
    1824         break;
    1825     case 1:
    1826         lpDevMode->dmBitsPerPel       = 16;
    1827         lpDevMode->dmPelsWidth        = 640;
    1828         lpDevMode->dmPelsHeight       = 480;
    1829         lpDevMode->dmDisplayFlags     = 0;
    1830         lpDevMode->dmDisplayFrequency = 70;
    1831         break;
    1832     default:
    1833         return(FALSE);
    1834     }
    1835     return(TRUE);
    1836 }
    1837 //******************************************************************************
    1838 //******************************************************************************
    1839 LONG WIN32API ChangeDisplaySettingsA(LPDEVMODEA  lpDevMode, DWORD dwFlags)
    1840 {
    1841 #ifdef DEBUG
    1842     if(lpDevMode) {
    1843         WriteLog("USER32:  ChangeDisplaySettingsA FAKED %X\n", dwFlags);
    1844         WriteLog("USER32:  ChangeDisplaySettingsA lpDevMode->dmBitsPerPel %d\n", lpDevMode->dmBitsPerPel);
    1845         WriteLog("USER32:  ChangeDisplaySettingsA lpDevMode->dmPelsWidth  %d\n", lpDevMode->dmPelsWidth);
    1846         WriteLog("USER32:  ChangeDisplaySettingsA lpDevMode->dmPelsHeight %d\n", lpDevMode->dmPelsHeight);
    1847     }
    1848 #endif
    1849     return(DISP_CHANGE_SUCCESSFUL);
    1850 }
    1851 //******************************************************************************
    1852 //******************************************************************************
    1853 
    1854 
    1855 /*****************************************************************************
    1856  * Name      : BOOL WIN32API AnyPopup
    1857  * Purpose   : The AnyPopup function indicates whether an owned, visible,
    1858  *             top-level pop-up, or overlapped window exists on the screen. The
    1859  *             function searches the entire Windows screen, not just the calling
    1860  *             application's client area.
    1861  * Parameters: VOID
    1862  * Variables :
    1863  * Result    : If a pop-up window exists, the return value is TRUE even if the
    1864  *             pop-up window is completely covered by other windows. Otherwise,
    1865  *             it is FALSE.
    1866  * Remark    : AnyPopup is a Windows version 1.x function and is retained for
    1867  *             compatibility purposes. It is generally not useful.
    1868  * Status    : UNTESTED STUB
    1869  *
    1870  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    1871  *****************************************************************************/
    1872 
    1873 BOOL WIN32API AnyPopup(VOID)
    1874 {
    1875   dprintf(("USER32:AnyPopup() not implemented.\n"));
    1876 
    1877   return (FALSE);
    1878 }
    1879 
    1880 
    1881 
    1882 /*****************************************************************************
    1883  * Name      : LONG WIN32API ChangeDisplaySettingsW
    1884  * Purpose   : The ChangeDisplaySettings function changes the display settings
    1885  *             to the specified graphics mode.
    1886  * Parameters: LPDEVMODEW lpDevModeW
    1887  *             DWORD      dwFlags
    1888  * Variables :
    1889  * Result    : DISP_CHANGE_SUCCESSFUL The settings change was successful.
    1890  *             DISP_CHANGE_RESTART    The computer must be restarted in order for the graphics mode to work.
    1891  *             DISP_CHANGE_BADFLAGS   An invalid set of flags was passed in.
    1892  *             DISP_CHANGE_FAILED     The display driver failed the specified graphics mode.
    1893  *             DISP_CHANGE_BADMODE    The graphics mode is not supported.
    1894  *             DISP_CHANGE_NOTUPDATED Unable to write settings to the registry.
    1895  * Remark    :
    1896  * Status    : UNTESTED STUB
    1897  *
    1898  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    1899  *****************************************************************************/
    1900 
    1901 LONG WIN32API ChangeDisplaySettingsW(LPDEVMODEW lpDevMode,
    1902                                         DWORD      dwFlags)
    1903 {
    1904   dprintf(("USER32:ChangeDisplaySettingsW(%08xh,%08x) not implemented.\n",
    1905          lpDevMode,
    1906          dwFlags));
    1907 
    1908   return (ChangeDisplaySettingsA((LPDEVMODEA)lpDevMode,
    1909                                   dwFlags));
    1910 }
    1911 
    1912 /*****************************************************************************
    1913  * Name      : BOOL WIN32API CloseDesktop
    1914  * Purpose   : The CloseDesktop function closes an open handle of a desktop
    1915  *             object. A desktop is a secure object contained within a window
    1916  *             station object. A desktop has a logical display surface and
    1917  *             contains windows, menus and hooks.
    1918  * Parameters: HDESK hDesktop
    1919  * Variables :
    1920  * Result    : If the function succeeds, the return value is TRUE.
    1921  *             If the functions fails, the return value is FALSE. To get
    1922  *             extended error information, call GetLastError.
    1923  * Remark    :
    1924  * Status    : UNTESTED STUB
    1925  *
    1926  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    1927  *****************************************************************************/
    1928 
    1929 BOOL WIN32API CloseDesktop(HDESK hDesktop)
    1930 {
    1931   dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
    1932          hDesktop));
    1933 
    1934   return (FALSE);
    1935 }
    1936 
    1937 
    1938 /*****************************************************************************
    1939  * Name      : BOOL WIN32API CloseWindowStation
    1940  * Purpose   : The CloseWindowStation function closes an open window station handle.
    1941  * Parameters: HWINSTA hWinSta
    1942  * Variables :
    1943  * Result    :
    1944  * Remark    : If the function succeeds, the return value is TRUE.
    1945  *             If the functions fails, the return value is FALSE. To get
    1946  *             extended error information, call GetLastError.
    1947  * Status    : UNTESTED STUB
    1948  *
    1949  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    1950  *****************************************************************************/
    1951 
    1952 BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
    1953 {
    1954   dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
    1955          hWinSta));
    1956 
    1957   return (FALSE);
    1958 }
    1959 
    1960 
    1961 /*****************************************************************************
    1962  * Name      : HDESK WIN32API CreateDesktopA
    1963  * Purpose   : The CreateDesktop function creates a new desktop on the window
    1964  *             station associated with the calling process.
    1965  * Parameters: LPCTSTR   lpszDesktop      name of the new desktop
    1966  *             LPCTSTR   lpszDevice       name of display device to assign to the desktop
    1967  *             LPDEVMODE pDevMode         reserved; must be NULL
    1968  *             DWORD     dwFlags          flags to control interaction with other applications
    1969  *             DWORD     dwDesiredAccess  specifies access of returned handle
    1970  *             LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
    1971  * Variables :
    1972  * Result    : If the function succeeds, the return value is a handle of the
    1973  *               newly created desktop.
    1974  *             If the function fails, the return value is NULL. To get extended
    1975  *               error information, call GetLastError.
    1976  * Remark    :
    1977  * Status    : UNTESTED STUB
    1978  *
    1979  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    1980  *****************************************************************************/
    1981 
    1982 HDESK WIN32API CreateDesktopA(LPCTSTR               lpszDesktop,
    1983                               LPCTSTR               lpszDevice,
    1984                               LPDEVMODEA            pDevMode,
    1985                               DWORD                 dwFlags,
    1986                               DWORD                 dwDesiredAccess,
    1987                               LPSECURITY_ATTRIBUTES lpsa)
    1988 {
    1989   dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
    1990          lpszDesktop,
    1991          lpszDevice,
    1992          pDevMode,
    1993          dwFlags,
    1994          dwDesiredAccess,
    1995          lpsa));
    1996 
    1997   return (NULL);
    1998 }
    1999 
    2000 
    2001 /*****************************************************************************
    2002  * Name      : HDESK WIN32API CreateDesktopW
    2003  * Purpose   : The CreateDesktop function creates a new desktop on the window
    2004  *             station associated with the calling process.
    2005  * Parameters: LPCTSTR   lpszDesktop      name of the new desktop
    2006  *             LPCTSTR   lpszDevice       name of display device to assign to the desktop
    2007  *             LPDEVMODE pDevMode         reserved; must be NULL
    2008  *             DWORD     dwFlags          flags to control interaction with other applications
    2009  *             DWORD     dwDesiredAccess  specifies access of returned handle
    2010  *             LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
    2011  * Variables :
    2012  * Result    : If the function succeeds, the return value is a handle of the
    2013  *               newly created desktop.
    2014  *             If the function fails, the return value is NULL. To get extended
    2015  *               error information, call GetLastError.
    2016  * Remark    :
    2017  * Status    : UNTESTED STUB
    2018  *
    2019  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2020  *****************************************************************************/
    2021 
    2022 HDESK WIN32API CreateDesktopW(LPCTSTR               lpszDesktop,
    2023                               LPCTSTR               lpszDevice,
    2024                               LPDEVMODEW            pDevMode,
    2025                               DWORD                 dwFlags,
    2026                               DWORD                 dwDesiredAccess,
    2027                               LPSECURITY_ATTRIBUTES lpsa)
    2028 {
    2029   dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
    2030          lpszDesktop,
    2031          lpszDevice,
    2032          pDevMode,
    2033          dwFlags,
    2034          dwDesiredAccess,
    2035          lpsa));
    2036 
    2037   return (NULL);
    2038 }
    2039 
    2040 
    2041 /*****************************************************************************
    2042  * Name      : HWINSTA WIN32API CreateWindowStationA
    2043  * Purpose   : The CreateWindowStation function creates a window station object.
    2044  *             It returns a handle that can be used to access the window station.
    2045  *             A window station is a secure object that contains a set of global
    2046  *             atoms, a clipboard, and a set of desktop objects.
    2047  * Parameters: LPTSTR lpwinsta            name of the new window station
    2048  *             DWORD dwReserved           reserved; must be NULL
    2049  *             DWORD dwDesiredAccess      specifies access of returned handle
    2050  *             LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
    2051  * Variables :
    2052  * Result    : If the function succeeds, the return value is the handle to the
    2053  *               newly created window station.
    2054  *             If the function fails, the return value is NULL. To get extended
    2055  *               error information, call GetLastError.
    2056  * Remark    :
    2057  * Status    : UNTESTED STUB
    2058  *
    2059  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2060  *****************************************************************************/
    2061 
    2062 HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
    2063                                          DWORD  dwReserved,
    2064                                          DWORD  dwDesiredAccess,
    2065                                          LPSECURITY_ATTRIBUTES lpsa)
    2066 {
    2067   dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
    2068          lpWinSta,
    2069          dwReserved,
    2070          dwDesiredAccess,
    2071          lpsa));
    2072 
    2073   return (NULL);
    2074 }
    2075 
    2076 
    2077 /*****************************************************************************
    2078  * Name      : HWINSTA WIN32API CreateWindowStationW
    2079  * Purpose   : The CreateWindowStation function creates a window station object.
    2080  *             It returns a handle that can be used to access the window station.
    2081  *             A window station is a secure object that contains a set of global
    2082  *             atoms, a clipboard, and a set of desktop objects.
    2083  * Parameters: LPTSTR lpwinsta            name of the new window station
    2084  *             DWORD dwReserved           reserved; must be NULL
    2085  *             DWORD dwDesiredAccess      specifies access of returned handle
    2086  *             LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
    2087  * Variables :
    2088  * Result    : If the function succeeds, the return value is the handle to the
    2089  *               newly created window station.
    2090  *             If the function fails, the return value is NULL. To get extended
    2091  *               error information, call GetLastError.
    2092  * Remark    :
    2093  * Status    : UNTESTED STUB
    2094  *
    2095  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2096  *****************************************************************************/
    2097 
    2098 HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
    2099                                          DWORD  dwReserved,
    2100                                          DWORD  dwDesiredAccess,
    2101                                          LPSECURITY_ATTRIBUTES lpsa)
    2102 {
    2103   dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
    2104          lpWinSta,
    2105          dwReserved,
    2106          dwDesiredAccess,
    2107          lpsa));
    2108 
    2109   return (NULL);
    2110 }
    2111 
    2112 /*****************************************************************************
    2113  * Name      : BOOL WIN32API DragDetect
    2114  * Purpose   : The DragDetect function captures the mouse and tracks its movement
    2115  * Parameters: HWND  hwnd
    2116  *             POINT pt
    2117  * Variables :
    2118  * Result    : If the user moved the mouse outside of the drag rectangle while
    2119  *               holding the left button down, the return value is TRUE.
    2120  *             If the user did not move the mouse outside of the drag rectangle
    2121  *               while holding the left button down, the return value is FALSE.
    2122  * Remark    :
    2123  * Status    : UNTESTED STUB
    2124  *
    2125  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2126  *****************************************************************************/
    2127 
    2128 BOOL WIN32API DragDetect(HWND  hwnd,
    2129                             POINT pt)
    2130 {
    2131   dprintf(("USER32:DragDetect(%08xh,...) not implemented.\n",
    2132          hwnd));
    2133 
    2134   return (FALSE);
    2135 }
    2136 
    2137 
    2138 
    2139 /*****************************************************************************
    2140  * Name      : BOOL WIN32API EnumDesktopWindows
    2141  * Purpose   : The EnumDesktopWindows function enumerates all windows in a
    2142  *             desktop by passing the handle of each window, in turn, to an
    2143  *             application-defined callback function.
    2144  * Parameters: HDESK       hDesktop handle of desktop to enumerate
    2145  *             WNDENUMPROC lpfn     points to application's callback function
    2146  *             LPARAM      lParam   32-bit value to pass to the callback function
    2147  * Variables :
    2148  * Result    : If the function succeeds, the return value is TRUE.
    2149  *             If the function fails, the return value is FALSE. To get
    2150  *             extended error information, call GetLastError.
    2151  * Remark    :
    2152  * Status    : UNTESTED STUB
    2153  *
    2154  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2155  *****************************************************************************/
    2156 
    2157 BOOL WIN32API EnumDesktopWindows(HDESK       hDesktop,
    2158                                     WNDENUMPROC lpfn,
    2159                                     LPARAM      lParam)
    2160 {
    2161   dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
    2162          hDesktop,
    2163          lpfn,
    2164          lParam));
    2165 
    2166   return (FALSE);
    2167 }
    2168 
    2169 
    2170 /*****************************************************************************
    2171  * Name      : BOOL WIN32API EnumDesktopsA
    2172  * Purpose   : The EnumDesktops function enumerates all desktops in the window
    2173  *             station assigned to the calling process. The function does so by
    2174  *             passing the name of each desktop, in turn, to an application-
    2175  *             defined callback function.
    2176  * Parameters: HWINSTA         hwinsta    handle of window station to enumerate
    2177  *             DESKTOPENUMPROC lpEnumFunc points to application's callback function
    2178  *             LPARAM          lParam     32-bit value to pass to the callback function
    2179  * Variables :
    2180  * Result    : If the function succeeds, the return value is TRUE.
    2181  *             If the function fails, the return value is FALSE. To get extended
    2182  *             error information, call GetLastError.
    2183  * Remark    :
    2184  * Status    : UNTESTED STUB
    2185  *
    2186  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2187  *****************************************************************************/
    2188 
    2189 BOOL WIN32API EnumDesktopsA(HWINSTA          hWinSta,
    2190                             DESKTOPENUMPROCA lpEnumFunc,
    2191                             LPARAM           lParam)
    2192 {
    2193   dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
    2194          hWinSta,
    2195          lpEnumFunc,
    2196          lParam));
    2197 
    2198   return (FALSE);
    2199 }
    2200 
    2201 
    2202 /*****************************************************************************
    2203  * Name      : BOOL WIN32API EnumDesktopsW
    2204  * Purpose   : The EnumDesktops function enumerates all desktops in the window
    2205  *             station assigned to the calling process. The function does so by
    2206  *             passing the name of each desktop, in turn, to an application-
    2207  *             defined callback function.
    2208  * Parameters: HWINSTA         hwinsta    handle of window station to enumerate
    2209  *             DESKTOPENUMPROC lpEnumFunc points to application's callback function
    2210  *             LPARAM          lParam     32-bit value to pass to the callback function
    2211  * Variables :
    2212  * Result    : If the function succeeds, the return value is TRUE.
    2213  *             If the function fails, the return value is FALSE. To get extended
    2214  *             error information, call GetLastError.
    2215  * Remark    :
    2216  * Status    : UNTESTED STUB
    2217  *
    2218  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2219  *****************************************************************************/
    2220 
    2221 BOOL WIN32API EnumDesktopsW(HWINSTA          hWinSta,
    2222                             DESKTOPENUMPROCW lpEnumFunc,
    2223                             LPARAM           lParam)
    2224 {
    2225   dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
    2226          hWinSta,
    2227          lpEnumFunc,
    2228          lParam));
    2229 
    2230   return (FALSE);
    2231 }
    2232 
    2233 
    2234 
    2235 /*****************************************************************************
    2236  * Name      : BOOL WIN32API EnumDisplaySettingsW
    2237  * Purpose   : The EnumDisplaySettings function obtains information about one
    2238  *             of a display device's graphics modes. You can obtain information
    2239  *             for all of a display device's graphics modes by making a series
    2240  *             of calls to this function.
    2241  * Parameters: LPCTSTR   lpszDeviceName specifies the display device
    2242  *             DWORD     iModeNum       specifies the graphics mode
    2243  *             LPDEVMODE lpDevMode      points to structure to receive settings
    2244  * Variables :
    2245  * Result    : If the function succeeds, the return value is TRUE.
    2246  *             If the function fails, the return value is FALSE.
    2247  * Remark    :
    2248  * Status    : UNTESTED STUB
    2249  *
    2250  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2251  *****************************************************************************/
    2252 
    2253 BOOL WIN32API EnumDisplaySettingsW(LPCSTR     lpszDeviceName,
    2254                                       DWORD      iModeNum,
    2255                                       LPDEVMODEW lpDevMode)
    2256 {
    2257   dprintf(("USER32:EnumDisplaySettingsW (%s,%08xh,%08x) not implemented.\n",
    2258          lpszDeviceName,
    2259          iModeNum,
    2260          lpDevMode));
    2261 
    2262   return (EnumDisplaySettingsA(lpszDeviceName,
    2263                                iModeNum,
    2264                                (LPDEVMODEA)lpDevMode));
    2265 }
    2266 
    2267 
    2268 /*****************************************************************************
    2269  * Name      : BOOL WIN32API EnumWindowStationsA
    2270  * Purpose   : The EnumWindowStations function enumerates all windowstations
    2271  *             in the system by passing the name of each window station, in
    2272  *             turn, to an application-defined callback function.
    2273  * Parameters:
    2274  * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
    2275  *             LPARAM         lParam     32-bit value to pass to the callback function
    2276  * Result    : If the function succeeds, the return value is TRUE.
    2277  *             If the function fails the return value is FALSE. To get extended
    2278  *             error information, call GetLastError.
    2279  * Remark    :
    2280  * Status    : UNTESTED STUB
    2281  *
    2282  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2283  *****************************************************************************/
    2284 
    2285 BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
    2286                                   LPARAM          lParam)
    2287 {
    2288   dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
    2289          lpEnumFunc,
    2290          lParam));
    2291 
    2292   return (FALSE);
    2293 }
    2294 
    2295 
    2296 /*****************************************************************************
    2297  * Name      : BOOL WIN32API EnumWindowStationsW
    2298  * Purpose   : The EnumWindowStations function enumerates all windowstations
    2299  *             in the system by passing the name of each window station, in
    2300  *             turn, to an application-defined callback function.
    2301  * Parameters:
    2302  * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
    2303  *             LPARAM         lParam     32-bit value to pass to the callback function
    2304  * Result    : If the function succeeds, the return value is TRUE.
    2305  *             If the function fails the return value is FALSE. To get extended
    2306  *             error information, call GetLastError.
    2307  * Remark    :
    2308  * Status    : UNTESTED STUB
    2309  *
    2310  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2311  *****************************************************************************/
    2312 
    2313 BOOL WIN32API EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
    2314                                   LPARAM          lParam)
    2315 {
    2316   dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
    2317          lpEnumFunc,
    2318          lParam));
    2319 
    2320   return (FALSE);
    2321 }
    2322 
    2323 
    2324 
    2325 /*****************************************************************************
    2326  * Name      : BOOL WIN32API GetInputState
    2327  * Purpose   : The GetInputState function determines whether there are
    2328  *             mouse-button or keyboard messages in the calling thread's message queue.
    2329  * Parameters:
    2330  * Variables :
    2331  * Result    : If the queue contains one or more new mouse-button or keyboard
    2332  *               messages, the return value is TRUE.
    2333  *             If the function fails, the return value is FALSE.
    2334  * Remark    :
    2335  * Status    : UNTESTED STUB
    2336  *
    2337  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2338  *****************************************************************************/
    2339 
    2340 BOOL WIN32API GetInputState(VOID)
    2341 {
    2342   dprintf(("USER32:GetInputState () not implemented.\n"));
    2343 
    2344   return (FALSE);
    2345 }
    2346 
    2347 
    2348 /*****************************************************************************
    2349  * Name      : UINT WIN32API GetKBCodePage
    2350  * Purpose   : The GetKBCodePage function is provided for compatibility with
    2351  *             earlier versions of Windows. In the Win32 application programming
    2352  *             interface (API) it just calls the GetOEMCP function.
    2353  * Parameters:
    2354  * Variables :
    2355  * Result    : If the function succeeds, the return value is an OEM code-page
    2356  *             identifier, or it is the default identifier if the registry
    2357  *             value is not readable. For a list of OEM code-page identifiers,
    2358  *             see GetOEMCP.
    2359  * Remark    :
    2360  * Status    : UNTESTED
    2361  *
    2362  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2363  *****************************************************************************/
    2364 
    2365 UINT WIN32API GetKBCodePage(VOID)
    2366 {
    2367   return (GetOEMCP());
    2368 }
    2369 
    2370 
     1296//SvL: 24-6-'97 - Added
     1297//TODO: Not implemented
     1298//******************************************************************************
     1299WORD WIN32API GetAsyncKeyState(INT nVirtKey)
     1300{
     1301#ifdef DEBUG
     1302////    WriteLog("USER32:  GetAsyncKeyState Not implemented\n");
     1303#endif
     1304    return 0;
     1305}
    23711306/*****************************************************************************
    23721307 * Name      : BOOL WIN32API GetKeyboardLayoutNameA
    … …  
    23831318 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    23841319 *****************************************************************************/
    2385 
    23861320// @@@PH Win32 BOOL's are casted to INTs
    23871321INT WIN32API GetKeyboardLayoutNameA(LPTSTR pwszKLID)
    … …  
    23921326  return(FALSE);
    23931327}
    2394 
    2395 
    23961328/*****************************************************************************
    23971329 * Name      : BOOL WIN32API GetKeyboardLayoutNameW
    … …  
    24081340 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    24091341 *****************************************************************************/
    2410 
    24111342// @@@PH Win32 BOOL's are casted to INTs
    24121343INT WIN32API GetKeyboardLayoutNameW(LPWSTR pwszKLID)
    … …  
    24171348  return(FALSE);
    24181349}
    2419 
    2420 
    2421 
    2422 
    2423 /*****************************************************************************
    2424  * Name      : HWINSTA WIN32API GetProcessWindowStation
    2425  * Purpose   : The GetProcessWindowStation function returns a handle of the
    2426  *             window station associated with the calling process.
    2427  * Parameters:
    2428  * Variables :
    2429  * Result    : If the function succeeds, the return value is a handle of the
    2430  *               window station associated with the calling process.
    2431  *             If the function fails, the return value is NULL. This can occur
    2432  *               if the calling process is not an application written for Windows
    2433  *               NT. To get extended error information, call GetLastError.
    2434  * Remark    :
    2435  * Status    : UNTESTED STUB
    2436  *
    2437  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2438  *****************************************************************************/
    2439 
    2440 HWINSTA WIN32API GetProcessWindowStation(VOID)
    2441 {
    2442   dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
    2443 
    2444   return (NULL);
    2445 }
    2446 
    2447 
    2448 
    2449 /*****************************************************************************
    2450  * Name      : HDESK WIN32API GetThreadDesktop
    2451  * Purpose   : The GetThreadDesktop function returns a handle to the desktop
    2452  *             associated with a specified thread.
    2453  * Parameters: DWORD dwThreadId thread identifier
    2454  * Variables :
    2455  * Result    : If the function succeeds, the return value is the handle of the
    2456  *               desktop associated with the specified thread.
    2457  * Remark    :
    2458  * Status    : UNTESTED STUB
    2459  *
    2460  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2461  *****************************************************************************/
    2462 
    2463 HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
    2464 {
    2465   dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
    2466          dwThreadId));
    2467 
    2468   return (NULL);
    2469 }
    2470 
    2471 
    2472 /*****************************************************************************
    2473  * Name      : BOOL WIN32API GetUserObjectInformationA
    2474  * Purpose   : The GetUserObjectInformation function returns information about
    2475  *               a window station or desktop object.
    2476  * Parameters: HANDLE  hObj            handle of object to get information for
    2477  *             int     nIndex          type of information to get
    2478  *             PVOID   pvInfo          points to buffer that receives the information
    2479  *             DWORD   nLength         size, in bytes, of pvInfo buffer
    2480  *             LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
    2481  * Variables :
    2482  * Result    : If the function succeeds, the return value is TRUE.
    2483  *             If the function fails, the return value is FALSE. To get extended
    2484  *             error information, call GetLastError.
    2485  * Remark    :
    2486  * Status    : UNTESTED STUB
    2487  *
    2488  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2489  *****************************************************************************/
    2490 
    2491 BOOL WIN32API GetUserObjectInformationA(HANDLE  hObj,
    2492                                            int     nIndex,
    2493                                            PVOID   pvInfo,
    2494                                            DWORD   nLength,
    2495                                            LPDWORD lpnLengthNeeded)
    2496 {
    2497   dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
    2498          hObj,
    2499          nIndex,
    2500          pvInfo,
    2501          nLength,
    2502          lpnLengthNeeded));
    2503 
    2504   return (FALSE);
    2505 }
    2506 
    2507 
    2508 /*****************************************************************************
    2509  * Name      : BOOL WIN32API GetUserObjectInformationW
    2510  * Purpose   : The GetUserObjectInformation function returns information about
    2511  *               a window station or desktop object.
    2512  * Parameters: HANDLE  hObj            handle of object to get information for
    2513  *             int     nIndex          type of information to get
    2514  *             PVOID   pvInfo          points to buffer that receives the information
    2515  *             DWORD   nLength         size, in bytes, of pvInfo buffer
    2516  *             LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
    2517  * Variables :
    2518  * Result    : If the function succeeds, the return value is TRUE.
    2519  *             If the function fails, the return value is FALSE. To get extended
    2520  *             error information, call GetLastError.
    2521  * Remark    :
    2522  * Status    : UNTESTED STUB
    2523  *
    2524  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2525  *****************************************************************************/
    2526 
    2527 BOOL WIN32API GetUserObjectInformationW(HANDLE  hObj,
    2528                                            int     nIndex,
    2529                                            PVOID   pvInfo,
    2530                                            DWORD   nLength,
    2531                                            LPDWORD lpnLengthNeeded)
    2532 {
    2533   dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
    2534          hObj,
    2535          nIndex,
    2536          pvInfo,
    2537          nLength,
    2538          lpnLengthNeeded));
    2539 
    2540   return (FALSE);
    2541 }
    2542 
    2543 
    2544 /*****************************************************************************
    2545  * Name      : BOOL WIN32API GetUserObjectSecurity
    2546  * Purpose   : The GetUserObjectSecurity function retrieves security information
    2547  *             for the specified user object.
    2548  * Parameters: HANDLE                hObj            handle of user object
    2549  *             SECURITY_INFORMATION * pSIRequested    address of requested security information
    2550  *             LPSECURITY_DESCRIPTOR  pSID            address of security descriptor
    2551  *             DWORD                 nLength         size of buffer for security descriptor
    2552  *             LPDWORD               lpnLengthNeeded address of required size of buffer
    2553  * Variables :
    2554  * Result    : If the function succeeds, the return value is TRUE.
    2555  *             If the function fails, the return value is FALSE. To get extended
    2556  *               error information, call GetLastError.
    2557  * Remark    :
    2558  * Status    : UNTESTED STUB
    2559  *
    2560  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2561  *****************************************************************************/
    2562 
    2563 BOOL WIN32API GetUserObjectSecurity(HANDLE                hObj,
    2564                                        SECURITY_INFORMATION * pSIRequested,
    2565                                        LPSECURITY_DESCRIPTOR  pSID,
    2566                                        DWORD                 nLength,
    2567                                        LPDWORD               lpnLengthNeeded)
    2568 {
    2569   dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
    2570          hObj,
    2571          pSIRequested,
    2572          pSID,
    2573          nLength,
    2574          lpnLengthNeeded));
    2575 
    2576   return (FALSE);
    2577 }
    2578 
    2579 
    2580 
    2581 /*****************************************************************************
    2582  * Name      : int WIN32API GetWindowRgn
    2583  * Purpose   : The GetWindowRgn function obtains a copy of the window region of a window.
    2584  * Parameters: HWND hWnd handle to window whose window region is to be obtained
    2585  *             HRGN hRgn handle to region that receives a copy of the window region
    2586  * Variables :
    2587  * Result    : NULLREGION, SIMPLEREGION, COMPLEXREGION, ERROR
    2588  * Remark    :
    2589  * Status    : UNTESTED STUB
    2590  *
    2591  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2592  *****************************************************************************/
    2593 
    2594 int WIN32API GetWindowRgn (HWND hWnd,
    2595                               HRGN hRgn)
    2596 {
    2597   dprintf(("USER32:GetWindowRgn (%08xh,%08x) not implemented.\n",
    2598          hWnd,
    2599          hRgn));
    2600 
    2601   return (NULLREGION);
    2602 }
    2603 
    2604 
    2605 
     1350//******************************************************************************
     1351//******************************************************************************
     1352BOOL WIN32API GetKeyboardState(PBYTE lpKeyState)
     1353{
     1354#ifdef DEBUG
     1355  WriteLog("USER32:  GetKeyboardState, not properly implemented\n");
     1356#endif
     1357  memset(lpKeyState, 0, 256);
     1358  return(TRUE);
     1359}
     1360//******************************************************************************
     1361//******************************************************************************
     1362int WIN32API GetKeyNameTextA( LPARAM lParam, LPSTR lpString, int  nSize)
     1363{
     1364#ifdef DEBUG
     1365    WriteLog("USER32:  GetKeyNameTextA\n");
     1366#endif
     1367    return O32_GetKeyNameText(lParam,lpString,nSize);
     1368}
     1369//******************************************************************************
     1370//******************************************************************************
     1371int WIN32API GetKeyNameTextW( LPARAM lParam, LPWSTR lpString, int  nSize)
     1372{
     1373#ifdef DEBUG
     1374    WriteLog("USER32:  GetKeyNameTextW DOES NOT WORK\n");
     1375#endif
     1376    // NOTE: This will not work as is (needs UNICODE support)
     1377    return 0;
     1378//    return O32_GetKeyNameText(arg1, arg2, arg3);
     1379}
     1380//******************************************************************************
     1381//SvL: 24-6-'97 - Added
     1382//******************************************************************************
     1383SHORT WIN32API GetKeyState( int nVirtKey)
     1384{
     1385#ifdef DEBUG
     1386    WriteLog("USER32:  GetKeyState %d\n", nVirtKey);
     1387#endif
     1388    return O32_GetKeyState(nVirtKey);
     1389}
     1390/*****************************************************************************
     1391 * Name      : VOID WIN32API keybd_event
     1392 * Purpose   : The keybd_event function synthesizes a keystroke. The system
     1393 *             can use such a synthesized keystroke to generate a WM_KEYUP or
     1394 *             WM_KEYDOWN message. The keyboard driver's interrupt handler calls
     1395 *             the keybd_event function.
     1396 * Parameters: BYTE  bVk         virtual-key code
     1397
     1398 *             BYTE  bScan       hardware scan code
     1399 *             DWORD dwFlags     flags specifying various function options
     1400 *             DWORD dwExtraInfo additional data associated with keystroke
     1401 * Variables :
     1402 * Result    :
     1403 * Remark    :
     1404 * Status    : UNTESTED STUB
     1405 *
     1406 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     1407 *****************************************************************************/
     1408VOID WIN32API keybd_event (BYTE bVk,
     1409                           BYTE bScan,
     1410                           DWORD dwFlags,
     1411                           DWORD dwExtraInfo)
     1412{
     1413  dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
     1414         bVk,
     1415         bScan,
     1416         dwFlags,
     1417         dwExtraInfo));
     1418}
    26061419/*****************************************************************************
    26071420 * Name      : HLK WIN32API LoadKeyboardLayoutA
    … …  
    26211434 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    26221435 *****************************************************************************/
    2623 
    26241436HKL WIN32API LoadKeyboardLayoutA(LPCTSTR pwszKLID,
    26251437                                 UINT    Flags)
    … …  
    26311443  return (NULL);
    26321444}
    2633 
    2634 
    26351445/*****************************************************************************
    26361446 * Name      : HLK WIN32API LoadKeyboardLayoutW
    … …  
    26501460 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    26511461 *****************************************************************************/
    2652 
    26531462HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID,
    26541463                                 UINT    Flags)
    … …  
    26601469  return (NULL);
    26611470}
    2662 
    2663 
     1471//******************************************************************************
     1472//******************************************************************************
     1473UINT WIN32API MapVirtualKeyA( UINT uCode, UINT  uMapType)
     1474{
     1475#ifdef DEBUG
     1476    WriteLog("USER32:  MapVirtualKeyA\n");
     1477#endif
     1478    return O32_MapVirtualKey(uCode,uMapType);
     1479}
     1480//******************************************************************************
     1481//******************************************************************************
     1482UINT WIN32API MapVirtualKeyW( UINT uCode, UINT  uMapType)
     1483{
     1484#ifdef DEBUG
     1485    WriteLog("USER32:  MapVirtualKeyW\n");
     1486#endif
     1487    // NOTE: This will not work as is (needs UNICODE support)
     1488    return O32_MapVirtualKey(uCode,uMapType);
     1489}
    26641490/*****************************************************************************
    26651491 * Name      : UINT WIN32API MapVirtualKeyExA
    … …  
    26791505 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    26801506 *****************************************************************************/
    2681 
    26821507UINT WIN32API MapVirtualKeyExA(UINT uCode,
    26831508                                  UINT uMapType,
    … …  
    26911516  return (0);
    26921517}
    2693 
    2694 
    26951518/*****************************************************************************
    26961519 * Name      : UINT WIN32API MapVirtualKeyExW
    … …  
    27111534 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    27121535 *****************************************************************************/
    2713 
    27141536UINT WIN32API MapVirtualKeyExW(UINT uCode,
    27151537                                  UINT uMapType,
    … …  
    27231545  return (0);
    27241546}
    2725 
    27261547/*****************************************************************************
    27271548 * Name      : DWORD WIN32API OemKeyScan
    … …  
    27381559 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    27391560 *****************************************************************************/
    2740 
    27411561DWORD WIN32API OemKeyScan(WORD wOemChar)
    27421562{
    … …  
    27461566  return (wOemChar);
    27471567}
    2748 
    2749 
    2750 /*****************************************************************************
    2751  * Name      : HDESK WIN32API OpenDesktopA
    2752  * Purpose   : The OpenDesktop function returns a handle to an existing desktop.
    2753  *             A desktop is a secure object contained within a window station
    2754  *             object. A desktop has a logical display surface and contains
    2755  *             windows, menus and hooks.
    2756  * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
    2757  *             DWORD dwFlags           flags to control interaction with other applications
    2758  *             BOOL fInherit           specifies whether returned handle is inheritable
    2759  *             DWORD dwDesiredAccess   specifies access of returned handle
    2760  * Variables :
    2761  * Result    : If the function succeeds, the return value is the handle to the
    2762  *               opened desktop.
    2763  *             If the function fails, the return value is NULL. To get extended
    2764  *               error information, call GetLastError.
    2765  * Remark    :
    2766  * Status    : UNTESTED STUB
    2767  *
    2768  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2769  *****************************************************************************/
    2770 
    2771 HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
    2772                                DWORD   dwFlags,
    2773                                BOOL    fInherit,
    2774                                DWORD   dwDesiredAccess)
    2775 {
    2776   dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
    2777          lpszDesktopName,
    2778          dwFlags,
    2779          fInherit,
    2780          dwDesiredAccess));
    2781 
    2782   return (NULL);
    2783 }
    2784 
    2785 
    2786 /*****************************************************************************
    2787  * Name      : HDESK WIN32API OpenDesktopW
    2788  * Purpose   : The OpenDesktop function returns a handle to an existing desktop.
    2789  *             A desktop is a secure object contained within a window station
    2790  *             object. A desktop has a logical display surface and contains
    2791  *             windows, menus and hooks.
    2792  * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
    2793  *             DWORD dwFlags           flags to control interaction with other applications
    2794  *             BOOL fInherit           specifies whether returned handle is inheritable
    2795  *             DWORD dwDesiredAccess   specifies access of returned handle
    2796  * Variables :
    2797  * Result    : If the function succeeds, the return value is the handle to the
    2798  *               opened desktop.
    2799  *             If the function fails, the return value is NULL. To get extended
    2800  *               error information, call GetLastError.
    2801  * Remark    :
    2802  * Status    : UNTESTED STUB
    2803  *
    2804  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2805  *****************************************************************************/
    2806 
    2807 HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
    2808                                DWORD   dwFlags,
    2809                                BOOL    fInherit,
    2810                                DWORD   dwDesiredAccess)
    2811 {
    2812   dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
    2813          lpszDesktopName,
    2814          dwFlags,
    2815          fInherit,
    2816          dwDesiredAccess));
    2817 
    2818   return (NULL);
    2819 }
    2820 
    2821 
    2822 /*****************************************************************************
    2823  * Name      : HDESK WIN32API OpenInputDesktop
    2824  * Purpose   : The OpenInputDesktop function returns a handle to the desktop
    2825  *             that receives user input. The input desktop is a desktop on the
    2826  *             window station associated with the logged-on user.
    2827  * Parameters: DWORD dwFlags         flags to control interaction with other applications
    2828  *             BOOL  fInherit        specifies whether returned handle is inheritable
    2829  *             DWORD dwDesiredAccess specifies access of returned handle
    2830  * Variables :
    2831  * Result    : If the function succeeds, the return value is a handle of the
    2832  *               desktop that receives user input.
    2833  *             If the function fails, the return value is NULL. To get extended
    2834  *               error information, call GetLastError.
    2835  * Remark    :
    2836  * Status    : UNTESTED STUB
    2837  *
    2838  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2839  *****************************************************************************/
    2840 
    2841 HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
    2842                                    BOOL  fInherit,
    2843                                    DWORD dwDesiredAccess)
    2844 {
    2845   dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
    2846          dwFlags,
    2847          fInherit,
    2848          dwDesiredAccess));
    2849 
    2850   return (NULL);
    2851 }
    2852 
    2853 
    2854 /*****************************************************************************
    2855  * Name      : HWINSTA WIN32API OpenWindowStationA
    2856  * Purpose   : The OpenWindowStation function returns a handle to an existing
    2857  *               window station.
    2858  * Parameters: LPCTSTR lpszWinStaName name of the window station to open
    2859  *             BOOL fInherit          specifies whether returned handle is inheritable
    2860  *             DWORD dwDesiredAccess  specifies access of returned handle
    2861  * Variables :
    2862  * Result    : If the function succeeds, the return value is the handle to the
    2863  *               specified window station.
    2864  *             If the function fails, the return value is NULL. To get extended
    2865  *               error information, call GetLastError.
    2866  * Remark    :
    2867  * Status    : UNTESTED STUB
    2868  *
    2869  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2870  *****************************************************************************/
    2871 
    2872 HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
    2873                                        BOOL    fInherit,
    2874                                        DWORD   dwDesiredAccess)
    2875 {
    2876   dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
    2877          lpszWinStaName,
    2878          fInherit,
    2879          dwDesiredAccess));
    2880 
    2881   return (NULL);
    2882 }
    2883 
    2884 
    2885 /*****************************************************************************
    2886  * Name      : HWINSTA WIN32API OpenWindowStationW
    2887  * Purpose   : The OpenWindowStation function returns a handle to an existing
    2888  *               window station.
    2889  * Parameters: LPCTSTR lpszWinStaName name of the window station to open
    2890  *             BOOL fInherit          specifies whether returned handle is inheritable
    2891  *             DWORD dwDesiredAccess  specifies access of returned handle
    2892  * Variables :
    2893  * Result    : If the function succeeds, the return value is the handle to the
    2894  *               specified window station.
    2895  *             If the function fails, the return value is NULL. To get extended
    2896  *               error information, call GetLastError.
    2897 
    2898 
    2899  * Remark    :
    2900  * Status    : UNTESTED STUB
    2901  *
    2902  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2903  *****************************************************************************/
    2904 
    2905 HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
    2906                                        BOOL    fInherit,
    2907                                        DWORD   dwDesiredAccess)
    2908 {
    2909   dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
    2910          lpszWinStaName,
    2911          fInherit,
    2912          dwDesiredAccess));
    2913 
    2914   return (NULL);
    2915 }
    2916 
    2917 
    2918 /*****************************************************************************
    2919  * Name      : BOOL WIN32API PaintDesktop
    2920  * Purpose   : The PaintDesktop function fills the clipping region in the
    2921  *             specified device context with the desktop pattern or wallpaper.
    2922  *             The function is provided primarily for shell desktops.
    2923  * Parameters:
    2924  * Variables :
    2925  * Result    : If the function succeeds, the return value is TRUE.
    2926  *             If the function fails, the return value is FALSE.
    2927  * Remark    :
    2928  * Status    : UNTESTED STUB
    2929  *
    2930  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2931  *****************************************************************************/
    2932 
    2933 BOOL WIN32API PaintDesktop(HDC hdc)
    2934 {
    2935   dprintf(("USER32:PaintDesktop (%08x) not implemented.\n",
    2936          hdc));
    2937 
    2938   return (FALSE);
    2939 }
    2940 
    2941 
    2942 
    2943 /*****************************************************************************
    2944  * Name      : VOID WIN32API SetDebugErrorLevel
    2945  * Purpose   : The SetDebugErrorLevel function sets the minimum error level at
    2946  *             which Windows will generate debugging events and pass them to a debugger.
    2947  * Parameters: DWORD dwLevel debugging error level
    2948  * Variables :
    2949  * Result    :
    2950  * Remark    :
    2951  * Status    : UNTESTED STUB
    2952  *
    2953  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2954  *****************************************************************************/
    2955 
    2956 VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
    2957 {
    2958   dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
    2959          dwLevel));
    2960 }
    2961 
    2962 
    2963 /*****************************************************************************
    2964  * Name      : BOOL WIN32API SetProcessWindowStation
    2965  * Purpose   : The SetProcessWindowStation function assigns a window station
    2966  *             to the calling process. This enables the process to access
    2967  *             objects in the window station such as desktops, the clipboard,
    2968  *             and global atoms. All subsequent operations on the window station
    2969  *             use the access rights granted to hWinSta.
    2970  * Parameters:
    2971  * Variables :
    2972  * Result    : If the function succeeds, the return value is TRUE.
    2973  *             If the function fails, the return value is FALSE. To get extended
    2974  *               error information, call GetLastError.
    2975  * Remark    :
    2976  * Status    : UNTESTED STUB
    2977  *
    2978  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    2979  *****************************************************************************/
    2980 
    2981 BOOL WIN32API SetProcessWindowStation(HWINSTA hWinSta)
    2982 {
    2983   dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
    2984          hWinSta));
    2985 
    2986   return (FALSE);
    2987 }
    2988 
    2989 
    2990 /*****************************************************************************
    2991  * Name      : BOOL WIN32API SetThreadDesktop
    2992  * Purpose   : The SetThreadDesktop function assigns a desktop to the calling
    2993  *             thread. All subsequent operations on the desktop use the access
    2994  *             rights granted to hDesk.
    2995  * Parameters: HDESK hDesk handle of the desktop to assign to this thread
    2996  * Variables :
    2997  * Result    : If the function succeeds, the return value is TRUE.
    2998  *             If the function fails, the return value is FALSE. To get extended
    2999  *             error information, call GetLastError.
    3000  * Remark    :
    3001  * Status    : UNTESTED STUB
    3002  *
    3003  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    3004  *****************************************************************************/
    3005 
    3006 BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
    3007 {
    3008   dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
    3009          hDesktop));
    3010 
    3011   return (FALSE);
    3012 }
    3013 
    3014 
    3015 /*****************************************************************************
    3016  * Name      : BOOL WIN32API SetUserObjectInformationA
    3017  * Purpose   : The SetUserObjectInformation function sets information about a
    3018  *             window station or desktop object.
    3019  * Parameters: HANDLE hObject handle of the object for which to set information
    3020  *             int    nIndex  type of information to set
    3021  *             PVOID  lpvInfo points to a buffer that contains the information
    3022  *             DWORD  cbInfo  size, in bytes, of lpvInfo buffer
    3023  * Variables :
    3024  * Result    : If the function succeeds, the return value is TRUE.
    3025  *             If the function fails the return value is FALSE. To get extended
    3026  *               error information, call GetLastError.
    3027  * Remark    :
    3028  * Status    : UNTESTED STUB
    3029  *
    3030  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    3031  *****************************************************************************/
    3032 
    3033 BOOL WIN32API SetUserObjectInformationA(HANDLE hObject,
    3034                                            int    nIndex,
    3035                                            PVOID  lpvInfo,
    3036                                            DWORD  cbInfo)
    3037 {
    3038   dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
    3039            hObject,
    3040            nIndex,
    3041            lpvInfo,
    3042            cbInfo));
    3043 
    3044   return (FALSE);
    3045 }
    3046 
    3047 
    3048 /*****************************************************************************
    3049  * Name      : BOOL WIN32API SetUserObjectInformationW
    3050  * Purpose   : The SetUserObjectInformation function sets information about a
    3051  *             window station or desktop object.
    3052  * Parameters: HANDLE hObject handle of the object for which to set information
    3053  *             int    nIndex  type of information to set
    3054  *             PVOID  lpvInfo points to a buffer that contains the information
    3055  *             DWORD  cbInfo  size, in bytes, of lpvInfo buffer
    3056  * Variables :
    3057  * Result    : If the function succeeds, the return value is TRUE.
    3058  *             If the function fails the return value is FALSE. To get extended
    3059  *               error information, call GetLastError.
    3060  * Remark    :
    3061  * Status    : UNTESTED STUB
    3062  *
    3063  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    3064  *****************************************************************************/
    3065 
    3066 BOOL WIN32API SetUserObjectInformationW(HANDLE hObject,
    3067                                            int    nIndex,
    3068                                            PVOID  lpvInfo,
    3069                                            DWORD  cbInfo)
    3070 {
    3071   dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
    3072            hObject,
    3073            nIndex,
    3074            lpvInfo,
    3075            cbInfo));
    3076 
    3077   return (FALSE);
    3078 }
    3079 
    3080 
    3081 /*****************************************************************************
    3082  * Name      : BOOL WIN32API SetUserObjectSecurity
    3083  * Purpose   : The SetUserObjectSecurity function sets the security of a user
    3084  *             object. This can be, for example, a window or a DDE conversation
    3085  * Parameters: HANDLE  hObject           handle of user object
    3086  *             SECURITY_INFORMATION * psi address of security information
    3087  *             LPSECURITY_DESCRIPTOR  psd address of security descriptor
    3088  * Variables :
    3089  * Result    : If the function succeeds, the return value is TRUE.
    3090  *             If the function fails, the return value is FALSE. To get extended
    3091  *             error information, call GetLastError.
    3092  * Remark    :
    3093  * Status    : UNTESTED STUB
    3094  *
    3095  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    3096  *****************************************************************************/
    3097 
    3098 BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
    3099                                        SECURITY_INFORMATION * psi,
    3100                                        LPSECURITY_DESCRIPTOR  psd)
    3101 {
    3102   dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
    3103            hObject,
    3104            psi,
    3105            psd));
    3106 
    3107   return (FALSE);
    3108 }
    3109 
    3110 
    3111 /*****************************************************************************
    3112  * Name      : int WIN32API SetWindowRgn
    3113  * Purpose   : The SetWindowRgn function sets the window region of a window. The
    3114  *             window region determines the area within the window where the
    3115  *             operating system permits drawing. The operating system does not
    3116  *             display any portion of a window that lies outside of the window region
    3117  * Parameters: HWND  hWnd    handle to window whose window region is to be set
    3118  *             HRGN  hRgn    handle to region
    3119  *             BOOL  bRedraw window redraw flag
    3120  * Variables :
    3121  * Result    : If the function succeeds, the return value is non-zero.
    3122  *             If the function fails, the return value is zero.
    3123  * Remark    :
    3124  * Status    : UNTESTED STUB
    3125  *
    3126  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    3127  *****************************************************************************/
    3128 
    3129 int WIN32API SetWindowRgn(HWND hWnd,
    3130                              HRGN hRgn,
    3131                              BOOL bRedraw)
    3132 {
    3133   dprintf(("USER32:SetWindowRgn (%08xh,%08xh,%u) not implemented.\n",
    3134          hWnd,
    3135          hRgn,
    3136          bRedraw));
    3137 
    3138   return (0);
    3139 }
    3140 
    3141 
    3142 /*****************************************************************************
    3143  * Name      : BOOL WIN32API SetWindowsHookW
    3144  * Purpose   : The SetWindowsHook function is not implemented in the Win32 API.
    3145  *             Win32-based applications should use the SetWindowsHookEx function.
    3146  * Parameters:
    3147  * Variables :
    3148  * Result    :
    3149  * Remark    : ARGH ! MICROSOFT !
    3150  * Status    : UNTESTED STUB
    3151  *
    3152  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    3153  *****************************************************************************/
    3154 
    3155 HHOOK WIN32API SetWindowsHookW(int nFilterType, HOOKPROC pfnFilterProc)
    3156 
    3157 {
    3158   return (FALSE);
    3159 }
    3160 
    3161 
    3162 /*****************************************************************************
    3163  * Name      : BOOL WIN32API ShowWindowAsync
    3164  * Purpose   : The ShowWindowAsync function sets the show state of a window
    3165  *             created by a different thread.
    3166  * Parameters: HWND hwnd     handle of window
    3167  *             int  nCmdShow show state of window
    3168  * Variables :
    3169  * Result    : If the window was previously visible, the return value is TRUE.
    3170  *             If the window was previously hidden, the return value is FALSE.
    3171  * Remark    :
    3172  * Status    : UNTESTED STUB
    3173  *
    3174  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    3175  *****************************************************************************/
    3176 
    3177 BOOL WIN32API ShowWindowAsync (HWND hWnd,
    3178                                int  nCmdShow)
    3179 {
    3180   dprintf(("USER32:ShowWindowAsync (%08xh,%08x) not implemented.\n",
    3181          hWnd,
    3182          nCmdShow));
    3183 
    3184   return (FALSE);
    3185 }
    3186 
    3187 
    3188 /*****************************************************************************
    3189  * Name      : BOOL WIN32API SwitchDesktop
    3190  * Purpose   : The SwitchDesktop function makes a desktop visible and activates
    3191  *             it. This enables the desktop to receive input from the user. The
    3192  *             calling process must have DESKTOP_SWITCHDESKTOP access to the
    3193  *             desktop for the SwitchDesktop function to succeed.
    3194  * Parameters:
    3195  * Variables :
    3196  * Result    : If the function succeeds, the return value is TRUE.
    3197  *             If the function fails, the return value is FALSE. To get extended
    3198  *               error information, call GetLastError.
    3199  * Remark    :
    3200  * Status    : UNTESTED STUB
    3201  *
    3202  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    3203  *****************************************************************************/
    3204 
    3205 BOOL WIN32API SwitchDesktop(HDESK hDesktop)
    3206 {
    3207   dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
    3208          hDesktop));
    3209 
    3210   return (FALSE);
    3211 }
    3212 
    3213 
    3214 /*****************************************************************************
    3215  * Name      : WORD WIN32API TileWindows
    3216  * Purpose   : The TileWindows function tiles the specified windows, or the child
    3217  *             windows of the specified parent window.
    3218  * Parameters: HWND       hwndParent     handle of parent window
    3219  *             WORD       wFlags         types of windows not to arrange
    3220  *             LPCRECT    lpRect         rectangle to arrange windows in
    3221  *             WORD       cChildrenb     number of windows to arrange
    3222  *             const HWND *ahwndChildren array of window handles
    3223  * Variables :
    3224  * Result    : If the function succeeds, the return value is the number of
    3225  *               windows arranged.
    3226  *             If the function fails, the return value is zero.
    3227  * Remark    :
    3228  * Status    : UNTESTED STUB
    3229  *
    3230  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    3231  *****************************************************************************/
    3232 
    3233 WORD WIN32API TileWindows(HWND       hwndParent,
    3234                           UINT       wFlags,
    3235                           const LPRECT lpRect,
    3236                           UINT       cChildrenb,
    3237                           const HWND *ahwndChildren)
    3238 {
    3239   dprintf(("USER32:TileWindows (%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
    3240            hwndParent,
    3241            wFlags,
    3242            lpRect,
    3243            cChildrenb,
    3244            ahwndChildren));
    3245 
    3246    return (0);
    3247 }
    3248 
    3249 
     1568//******************************************************************************
     1569//******************************************************************************
     1570BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
     1571{
     1572#ifdef DEBUG
     1573  WriteLog("USER32:  RegisterHotKey, not implemented\n");
     1574#endif
     1575  hwnd = Win32Window::Win32ToOS2Handle(hwnd);
     1576  return(TRUE);
     1577}
     1578//******************************************************************************
     1579//******************************************************************************
     1580BOOL WIN32API SetKeyboardState(PBYTE lpKeyState)
     1581{
     1582#ifdef DEBUG
     1583  WriteLog("USER32:  SetKeyboardState, not implemented\n");
     1584#endif
     1585  return(TRUE);
     1586}
    32501587/*****************************************************************************
    32511588 * Name      : int WIN32API ToAscii
    … …  
    32701607 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    32711608 *****************************************************************************/
    3272 
    32731609int WIN32API ToAscii(UINT   uVirtKey,
    32741610                        UINT   uScanCode,
    … …  
    32861622  return (0);
    32871623}
    3288 
    3289 
    32901624/*****************************************************************************
    32911625 * Name      : int WIN32API ToAsciiEx
    … …  
    33111645 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    33121646 *****************************************************************************/
    3313 
    33141647int WIN32API ToAsciiEx(UINT   uVirtKey,
    33151648                          UINT   uScanCode,
    … …  
    33291662  return (0);
    33301663}
    3331 
    3332 
    33331664/*****************************************************************************
    33341665 * Name      : int WIN32API ToUnicode
    … …  
    33641695 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    33651696 *****************************************************************************/
    3366 
    33671697int WIN32API ToUnicode(UINT   uVirtKey,
    33681698                          UINT   uScanCode,
    … …  
    33821712  return (0);
    33831713}
    3384 
    3385 
    33861714/*****************************************************************************
    33871715 * Name      : BOOL WIN32API UnloadKeyboardLayout
    … …  
    33971725 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    33981726 *****************************************************************************/
    3399 
    34001727BOOL WIN32API UnloadKeyboardLayout (HKL hkl)
    34011728{
    … …  
    34041731
    34051732  return (0);
     1733}
     1734//******************************************************************************
     1735//******************************************************************************
     1736BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
     1737{
     1738#ifdef DEBUG
     1739  WriteLog("USER32:  UnregisterHotKey, not implemented\n");
     1740#endif
     1741  hwnd = Win32Window::Win32ToOS2Handle(hwnd);
     1742
     1743  return(TRUE);
     1744}
     1745//******************************************************************************
     1746//SvL: 24-6-'97 - Added
     1747//******************************************************************************
     1748WORD WIN32API VkKeyScanA( char ch)
     1749{
     1750#ifdef DEBUG
     1751    WriteLog("USER32:  VkKeyScanA\n");
     1752#endif
     1753    return O32_VkKeyScan(ch);
     1754}
     1755
     1756
     1757//CB: stopped here void aa(){};
     1758
     1759//******************************************************************************
     1760//******************************************************************************
     1761DWORD WIN32API MsgWaitForMultipleObjects( DWORD arg1, LPHANDLE arg2, BOOL arg3, DWORD arg4, DWORD  arg5)
     1762{
     1763#ifdef DEBUG
     1764    WriteLog("USER32:  MsgWaitForMultipleObjects\n");
     1765#endif
     1766    return O32_MsgWaitForMultipleObjects(arg1, arg2, arg3, arg4, arg5);
     1767}
     1768//******************************************************************************
     1769//******************************************************************************
     1770BOOL WIN32API CheckRadioButton( HWND arg1, UINT arg2, UINT arg3, UINT  arg4)
     1771{
     1772#ifdef DEBUG
     1773    WriteLog("USER32:  CheckRadioButton\n");
     1774#endif
     1775    //CB: check radio buttons in interval
     1776    if (arg2 > arg3) return (FALSE);
     1777    for (UINT x=arg2;x <= arg3;x++)
     1778    {
     1779     SendDlgItemMessageA(arg1,x,BM_SETCHECK,(x == arg4) ? BST_CHECKED : BST_UNCHECKED,0);
     1780    }
     1781    return (TRUE);
     1782}
     1783//******************************************************************************
     1784//******************************************************************************
     1785BOOL WIN32API EndDeferWindowPos( HDWP arg1)
     1786{
     1787#ifdef DEBUG
     1788    WriteLog("USER32:  EndDeferWindowPos\n");
     1789#endif
     1790    return O32_EndDeferWindowPos(arg1);
     1791}
     1792//******************************************************************************
     1793//******************************************************************************
     1794INT WIN32API ExcludeUpdateRgn( HDC arg1, HWND  arg2)
     1795{
     1796#ifdef DEBUG
     1797    WriteLog("USER32:  ExcludeUpdateRgn\n");
     1798#endif
     1799    return O32_ExcludeUpdateRgn(arg1, arg2);
     1800}
     1801//******************************************************************************
     1802//******************************************************************************
     1803int WIN32API FillRect(HDC arg1, const RECT * arg2, HBRUSH arg3)
     1804{
     1805#ifdef DEBUG
     1806    WriteLog("USER32:  FillRect (%d,%d)(%d,%d) brush %X\n", arg2->left, arg2->top, arg2->right, arg2->bottom, arg3);
     1807#endif
     1808    return O32_FillRect(arg1, arg2, arg3);
     1809}
     1810//******************************************************************************
     1811//******************************************************************************
     1812HWND WIN32API FindWindowW( LPCWSTR arg1, LPCWSTR arg2)
     1813{
     1814 char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
     1815 char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
     1816 HWND rc;
     1817
     1818#ifdef DEBUG
     1819    WriteLog("USER32:  FindWindowW\n");
     1820#endif
     1821    rc = O32_FindWindow(astring1, astring2);
     1822    FreeAsciiString(astring1);
     1823    FreeAsciiString(astring2);
     1824    return rc;
     1825}
     1826//******************************************************************************
     1827//******************************************************************************
     1828int WIN32API FrameRect( HDC arg1, const RECT * arg2, HBRUSH  arg3)
     1829{
     1830#ifdef DEBUG
     1831    WriteLog("USER32:  FrameRect\n");
     1832#endif
     1833    return O32_FrameRect(arg1, arg2, arg3);
     1834}
     1835//******************************************************************************
     1836//******************************************************************************
     1837HWND WIN32API GetForegroundWindow(void)
     1838{
     1839#ifdef DEBUG
     1840    WriteLog("USER32:  GetForegroundWindow\n");
     1841#endif
     1842    return O32_GetForegroundWindow();
     1843}
     1844//******************************************************************************
     1845//******************************************************************************
     1846int WIN32API GetKeyboardType( int arg1)
     1847{
     1848#ifdef DEBUG
     1849    WriteLog("USER32:  GetKeyboardType\n");
     1850#endif
     1851    return O32_GetKeyboardType(arg1);
     1852}
     1853//******************************************************************************
     1854//******************************************************************************
     1855HWND WIN32API GetLastActivePopup( HWND arg1)
     1856{
     1857#ifdef DEBUG
     1858    WriteLog("USER32:  GetLastActivePopup\n");
     1859#endif
     1860    return O32_GetLastActivePopup(arg1);
     1861}
     1862//******************************************************************************
     1863//******************************************************************************
     1864//******************************************************************************
     1865//******************************************************************************
     1866DWORD WIN32API GetQueueStatus( UINT arg1)
     1867{
     1868#ifdef DEBUG
     1869    WriteLog("USER32:  GetQueueStatus\n");
     1870#endif
     1871    return O32_GetQueueStatus(arg1);
     1872}
     1873//******************************************************************************
     1874//******************************************************************************
     1875DWORD WIN32API GetTabbedTextExtentA( HDC arg1, LPCSTR arg2, int arg3, int arg4, int * arg5)
     1876{
     1877#ifdef DEBUG
     1878    WriteLog("USER32:  GetTabbedTextExtentA\n");
     1879#endif
     1880    return O32_GetTabbedTextExtent(arg1, arg2, arg3, arg4, arg5);
     1881}
     1882//******************************************************************************
     1883//******************************************************************************
     1884DWORD WIN32API GetTabbedTextExtentW( HDC arg1, LPCWSTR arg2, int arg3, int arg4, int * arg5)
     1885{
     1886 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
     1887 DWORD rc;
     1888
     1889#ifdef DEBUG
     1890    WriteLog("USER32:  GetTabbedTextExtentW\n");
     1891#endif
     1892    rc = O32_GetTabbedTextExtent(arg1, astring, arg3, arg4, arg5);
     1893    FreeAsciiString(astring);
     1894    return rc;
     1895}
     1896//******************************************************************************
     1897//******************************************************************************
     1898#if 0
     1899int WIN32API GetUpdateRgn( HWND arg1, HRGN arg2, BOOL  arg3)
     1900{
     1901#ifdef DEBUG
     1902    WriteLog("USER32:  GetUpdateRgn\n");
     1903#endif
     1904    return O32_GetUpdateRgn(arg1, arg2, arg3);
     1905}
     1906#endif
     1907//******************************************************************************
     1908
     1909
     1910//******************************************************************************
     1911//******************************************************************************
     1912//******************************************************************************
     1913DWORD WIN32API GetWindowThreadProcessId(HWND arg1, PDWORD  arg2)
     1914{
     1915#ifdef DEBUG
     1916    WriteLog("USER32:  GetWindowThreadProcessId\n");
     1917#endif
     1918    return O32_GetWindowThreadProcessId(arg1, arg2);
     1919}
     1920//******************************************************************************
     1921//******************************************************************************
     1922#if 0
     1923BOOL WIN32API InvalidateRgn( HWND arg1, HRGN arg2, BOOL  arg3)
     1924{
     1925#ifdef DEBUG
     1926    WriteLog("USER32:  InvalidateRgn\n");
     1927#endif
     1928    return O32_InvalidateRgn(arg1, arg2, arg3);
     1929}
     1930#endif
     1931//******************************************************************************
     1932//******************************************************************************
     1933BOOL WIN32API InvertRect( HDC arg1, const RECT * arg2)
     1934{
     1935#ifdef DEBUG
     1936    WriteLog("USER32:  InvertRect\n");
     1937#endif
     1938    return O32_InvertRect(arg1, arg2);
     1939}
     1940//******************************************************************************
     1941//******************************************************************************
     1942BOOL WIN32API MapDialogRect( HWND arg1, PRECT  arg2)
     1943{
     1944#ifdef DEBUG
     1945    WriteLog("USER32:  MapDialogRect\n");
     1946#endif
     1947    return O32_MapDialogRect(arg1, arg2);
     1948}
     1949//******************************************************************************
     1950//******************************************************************************
     1951int WIN32API MapWindowPoints( HWND arg1, HWND arg2, LPPOINT arg3, UINT arg4)
     1952{
     1953#ifdef DEBUG
     1954    WriteLog("USER32:  MapWindowPoints\n");
     1955#endif
     1956    return O32_MapWindowPoints(arg1, arg2, arg3, arg4);
     1957}
     1958//******************************************************************************
     1959//******************************************************************************
     1960BOOL WIN32API ScreenToClient (HWND hwnd, LPPOINT pt)
     1961{
     1962#ifdef DEBUG
     1963    WriteLog("USER32:  ScreenToClient\n");
     1964#endif
     1965    Win32BaseWindow *wnd;
     1966    PRECT rcl;
     1967
     1968    if (!hwnd) return (TRUE);
     1969    wnd = Win32BaseWindow::GetWindowFromHandle (hwnd);
     1970    if (!wnd) return (TRUE);
     1971
     1972    rcl   = wnd->getClientRect();
     1973    pt->y = ScreenHeight - pt->y;
     1974    OSLibWinMapWindowPoints (OSLIB_HWND_DESKTOP, wnd->getOS2WindowHandle(), (OSLIBPOINT *)pt, 1);
     1975    pt->y = (rcl->bottom - rcl->top) - pt->y;
     1976    return (TRUE);
     1977}
     1978//******************************************************************************
     1979//******************************************************************************
     1980#if 0
     1981BOOL WIN32API ScrollDC( HDC arg1, int arg2, int arg3, const RECT * arg4, const RECT * arg5, HRGN arg6, PRECT  arg7)
     1982{
     1983#ifdef DEBUG
     1984    WriteLog("USER32:  ScrollDC\n");
     1985#endif
     1986    return O32_ScrollDC(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
     1987}
     1988#endif
     1989//******************************************************************************
     1990//******************************************************************************
     1991LONG WIN32API TabbedTextOutA( HDC arg1, int arg2, int arg3, LPCSTR arg4, int arg5, int arg6, int * arg7, int  arg8)
     1992{
     1993#ifdef DEBUG
     1994    WriteLog("USER32:  TabbedTextOutA\n");
     1995#endif
     1996    return O32_TabbedTextOut(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
     1997}
     1998//******************************************************************************
     1999//******************************************************************************
     2000LONG WIN32API TabbedTextOutW( HDC arg1, int arg2, int arg3, LPCWSTR arg4, int arg5, int arg6, int * arg7, int  arg8)
     2001{
     2002 char *astring = UnicodeToAsciiString((LPWSTR)arg4);
     2003 LONG rc;
     2004
     2005#ifdef DEBUG
     2006    WriteLog("USER32:  TabbedTextOutW\n");
     2007#endif
     2008    rc = O32_TabbedTextOut(arg1, arg2, arg3, astring, arg5, arg6, arg7, arg8);
     2009    FreeAsciiString(astring);
     2010    return rc;
     2011}
     2012//******************************************************************************
     2013//******************************************************************************
     2014BOOL WIN32API ValidateRect( HWND arg1, const RECT * arg2)
     2015{
     2016#ifdef DEBUG
     2017    WriteLog("USER32:  ValidateRect\n");
     2018#endif
     2019    return O32_ValidateRect(arg1, arg2);
     2020}
     2021//******************************************************************************
     2022//******************************************************************************
     2023BOOL WIN32API ValidateRgn( HWND arg1, HRGN  arg2)
     2024{
     2025#ifdef DEBUG
     2026    WriteLog("USER32:  ValidateRgn\n");
     2027#endif
     2028    return O32_ValidateRgn(arg1, arg2);
     2029}
     2030//******************************************************************************
     2031//******************************************************************************
     2032WORD WIN32API VkKeyScanW( WCHAR arg1)
     2033{
     2034#ifdef DEBUG
     2035    WriteLog("USER32:  VkKeyScanW\n");
     2036#endif
     2037    // NOTE: This will not work as is (needs UNICODE support)
     2038    return O32_VkKeyScan((char)arg1);
     2039}
     2040//******************************************************************************
     2041//TODO: Not complete
     2042//******************************************************************************
     2043BOOL WIN32API GrayStringA(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
     2044                          LPARAM lpData, int nCount, int X, int Y, int nWidth,
     2045                          int nHeight)
     2046{
     2047 BOOL     rc;
     2048 COLORREF curclr;
     2049
     2050#ifdef DEBUG
     2051  WriteLog("USER32:  GrayStringA, not completely implemented\n");
     2052#endif
     2053  if(lpOutputFunc == NULL && lpData == NULL) {
     2054#ifdef DEBUG
     2055    WriteLog("USER32:  lpOutputFunc == NULL && lpData == NULL\n");
     2056#endif
     2057    return(FALSE);
     2058  }
     2059  if(lpOutputFunc) {
     2060        return(lpOutputFunc(hdc, lpData, nCount));
     2061  }
     2062  curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
     2063  rc = TextOutA(hdc, X, Y, (char *)lpData, nCount);
     2064  SetTextColor(hdc, curclr);
     2065
     2066  return(rc);
     2067}
     2068//******************************************************************************
     2069//******************************************************************************
     2070BOOL WIN32API GrayStringW(HDC hdc, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc,
     2071                          LPARAM lpData, int nCount, int X, int Y, int nWidth,
     2072                          int nHeight)
     2073{
     2074 BOOL     rc;
     2075 char    *astring;
     2076 COLORREF curclr;
     2077
     2078#ifdef DEBUG
     2079  WriteLog("USER32:  GrayStringW, not completely implemented\n");
     2080#endif
     2081
     2082  if(lpOutputFunc == NULL && lpData == NULL) {
     2083#ifdef DEBUG
     2084    WriteLog("USER32:  lpOutputFunc == NULL && lpData == NULL\n");
     2085#endif
     2086    return(FALSE);
     2087  }
     2088  if(nCount == 0)
     2089    nCount = UniStrlen((UniChar*)lpData);
     2090
     2091  if(lpOutputFunc) {
     2092    return(lpOutputFunc(hdc, lpData, nCount));
     2093  }
     2094  astring = UnicodeToAsciiString((LPWSTR)lpData);
     2095
     2096  curclr = SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
     2097  rc = TextOutA(hdc, X, Y, astring, nCount);
     2098  SetTextColor(hdc, curclr);
     2099
     2100  FreeAsciiString(astring);
     2101  return(rc);
     2102}
     2103//******************************************************************************
     2104//TODO:
     2105//******************************************************************************
     2106HANDLE WIN32API CopyImage(HANDLE hImage, UINT uType, int cxDesired, int cyDesired, UINT fuFlags)
     2107{
     2108#ifdef DEBUG
     2109  WriteLog("USER32:  CopyImage, not implemented\n");
     2110#endif
     2111  switch(uType) {
     2112    case IMAGE_BITMAP:
     2113    case IMAGE_CURSOR:
     2114    case IMAGE_ICON:
     2115    default:
     2116#ifdef DEBUG
     2117        WriteLog("USER32:  CopyImage, unknown type\n");
     2118#endif
     2119        return(NULL);
     2120  }
     2121  return(NULL);
     2122}
     2123//******************************************************************************
     2124//******************************************************************************
     2125int WIN32API GetKeyboardLayoutList(int nBuff, HKL *lpList)
     2126{
     2127#ifdef DEBUG
     2128  WriteLog("USER32:  GetKeyboardLayoutList, not implemented\n");
     2129#endif
     2130  return(0);
     2131}
     2132//******************************************************************************
     2133//******************************************************************************
     2134HKL WIN32API GetKeyboardLayout(DWORD dwLayout)
     2135{
     2136#ifdef DEBUG
     2137  WriteLog("USER32:  GetKeyboardLayout, not implemented\n");
     2138#endif
     2139  return(0);
     2140}
     2141//******************************************************************************
     2142//******************************************************************************
     2143int WIN32API LookupIconIdFromDirectory(PBYTE presbits, BOOL fIcon)
     2144{
     2145#ifdef DEBUG
     2146  WriteLog("USER32:  LookupIconIdFromDirectory, not implemented\n");
     2147#endif
     2148  return(0);
     2149}
     2150//******************************************************************************
     2151//******************************************************************************
     2152int WIN32API LookupIconIdFromDirectoryEx(PBYTE presbits, BOOL  fIcon,
     2153                        int cxDesired, int cyDesired,
     2154                        UINT Flags)
     2155{
     2156#ifdef DEBUG
     2157  WriteLog("USER32:  LookupIconIdFromDirectoryEx, not implemented\n");
     2158#endif
     2159  return(0);
     2160}
     2161//******************************************************************************
     2162//******************************************************************************
     2163BOOL WIN32API SetWindowContextHelpId(HWND hwnd, DWORD dwContextHelpId)
     2164{
     2165#ifdef DEBUG
     2166  WriteLog("USER32:  SetWindowContextHelpId, not implemented\n");
     2167#endif
     2168  return(TRUE);
     2169}
     2170//******************************************************************************
     2171//******************************************************************************
     2172DWORD WIN32API GetWindowContextHelpId(HWND hwnd)
     2173{
     2174#ifdef DEBUG
     2175  WriteLog("USER32:  GetWindowContextHelpId, not implemented\n");
     2176#endif
     2177  return(0);
     2178}
     2179//******************************************************************************
     2180//******************************************************************************
     2181BOOL WIN32API GetMonitorInfoA(HMONITOR,LPMONITORINFO)
     2182{
     2183#ifdef DEBUG
     2184  WriteLog("USER32:  GetMonitorInfoA not supported!!\n");
     2185#endif
     2186  return(FALSE);
     2187}
     2188//******************************************************************************
     2189//******************************************************************************
     2190BOOL WIN32API GetMonitorInfoW(HMONITOR,LPMONITORINFO)
     2191{
     2192#ifdef DEBUG
     2193  WriteLog("USER32:  GetMonitorInfoW not supported!!\n");
     2194#endif
     2195  return(FALSE);
     2196}
     2197//******************************************************************************
     2198//******************************************************************************
     2199HMONITOR WIN32API MonitorFromWindow(HWND hwnd, DWORD dwFlags)
     2200{
     2201#ifdef DEBUG
     2202  WriteLog("USER32:  MonitorFromWindow not correctly supported??\n");
     2203#endif
     2204  return(0);
     2205}
     2206//******************************************************************************
     2207//******************************************************************************
     2208HMONITOR WIN32API MonitorFromRect(LPRECT rect, DWORD dwFlags)
     2209{
     2210#ifdef DEBUG
     2211  WriteLog("USER32:  MonitorFromRect not correctly supported??\n");
     2212#endif
     2213  return(0);
     2214}
     2215//******************************************************************************
     2216//******************************************************************************
     2217HMONITOR WIN32API MonitorFromPoint(POINT point, DWORD dwflags)
     2218{
     2219#ifdef DEBUG
     2220  WriteLog("USER32:  MonitorFromPoint not correctly supported??\n");
     2221#endif
     2222  return(0);
     2223}
     2224//******************************************************************************
     2225//******************************************************************************
     2226BOOL WIN32API EnumDisplayMonitors(HDC,LPRECT,MONITORENUMPROC,LPARAM)
     2227{
     2228#ifdef DEBUG
     2229  WriteLog("USER32:  EnumDisplayMonitors not supported??\n");
     2230#endif
     2231  return(FALSE);
     2232}
     2233//******************************************************************************
     2234//******************************************************************************
     2235BOOL WIN32API EnumDisplaySettingsA(LPCSTR lpszDeviceName, DWORD iModeNum,
     2236                      LPDEVMODEA lpDevMode)
     2237{
     2238#ifdef DEBUG
     2239    WriteLog("USER32:  EnumDisplaySettingsA FAKED\n");
     2240#endif
     2241    switch(iModeNum) {
     2242    case 0:
     2243        lpDevMode->dmBitsPerPel       = 16;
     2244        lpDevMode->dmPelsWidth        = 768;
     2245        lpDevMode->dmPelsHeight       = 1024;
     2246        lpDevMode->dmDisplayFlags     = 0;
     2247        lpDevMode->dmDisplayFrequency = 70;
     2248        break;
     2249    case 1:
     2250        lpDevMode->dmBitsPerPel       = 16;
     2251        lpDevMode->dmPelsWidth        = 640;
     2252        lpDevMode->dmPelsHeight       = 480;
     2253        lpDevMode->dmDisplayFlags     = 0;
     2254        lpDevMode->dmDisplayFrequency = 70;
     2255        break;
     2256    default:
     2257        return(FALSE);
     2258    }
     2259    return(TRUE);
     2260}
     2261//******************************************************************************
     2262//******************************************************************************
     2263LONG WIN32API ChangeDisplaySettingsA(LPDEVMODEA  lpDevMode, DWORD dwFlags)
     2264{
     2265#ifdef DEBUG
     2266    if(lpDevMode) {
     2267        WriteLog("USER32:  ChangeDisplaySettingsA FAKED %X\n", dwFlags);
     2268        WriteLog("USER32:  ChangeDisplaySettingsA lpDevMode->dmBitsPerPel %d\n", lpDevMode->dmBitsPerPel);
     2269        WriteLog("USER32:  ChangeDisplaySettingsA lpDevMode->dmPelsWidth  %d\n", lpDevMode->dmPelsWidth);
     2270        WriteLog("USER32:  ChangeDisplaySettingsA lpDevMode->dmPelsHeight %d\n", lpDevMode->dmPelsHeight);
     2271    }
     2272#endif
     2273    return(DISP_CHANGE_SUCCESSFUL);
     2274}
     2275//******************************************************************************
     2276//******************************************************************************
     2277
     2278
     2279/*****************************************************************************
     2280 * Name      : BOOL WIN32API AnyPopup
     2281 * Purpose   : The AnyPopup function indicates whether an owned, visible,
     2282 *             top-level pop-up, or overlapped window exists on the screen. The
     2283 *             function searches the entire Windows screen, not just the calling
     2284 *             application's client area.
     2285 * Parameters: VOID
     2286 * Variables :
     2287 * Result    : If a pop-up window exists, the return value is TRUE even if the
     2288 *             pop-up window is completely covered by other windows. Otherwise,
     2289 *             it is FALSE.
     2290 * Remark    : AnyPopup is a Windows version 1.x function and is retained for
     2291 *             compatibility purposes. It is generally not useful.
     2292 * Status    : UNTESTED STUB
     2293 *
     2294 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2295 *****************************************************************************/
     2296
     2297BOOL WIN32API AnyPopup(VOID)
     2298{
     2299  dprintf(("USER32:AnyPopup() not implemented.\n"));
     2300
     2301  return (FALSE);
     2302}
     2303
     2304
     2305
     2306/*****************************************************************************
     2307 * Name      : LONG WIN32API ChangeDisplaySettingsW
     2308 * Purpose   : The ChangeDisplaySettings function changes the display settings
     2309 *             to the specified graphics mode.
     2310 * Parameters: LPDEVMODEW lpDevModeW
     2311 *             DWORD      dwFlags
     2312 * Variables :
     2313 * Result    : DISP_CHANGE_SUCCESSFUL The settings change was successful.
     2314 *             DISP_CHANGE_RESTART    The computer must be restarted in order for the graphics mode to work.
     2315 *             DISP_CHANGE_BADFLAGS   An invalid set of flags was passed in.
     2316 *             DISP_CHANGE_FAILED     The display driver failed the specified graphics mode.
     2317 *             DISP_CHANGE_BADMODE    The graphics mode is not supported.
     2318 *             DISP_CHANGE_NOTUPDATED Unable to write settings to the registry.
     2319 * Remark    :
     2320 * Status    : UNTESTED STUB
     2321 *
     2322 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2323 *****************************************************************************/
     2324
     2325LONG WIN32API ChangeDisplaySettingsW(LPDEVMODEW lpDevMode,
     2326                                        DWORD      dwFlags)
     2327{
     2328  dprintf(("USER32:ChangeDisplaySettingsW(%08xh,%08x) not implemented.\n",
     2329         lpDevMode,
     2330         dwFlags));
     2331
     2332  return (ChangeDisplaySettingsA((LPDEVMODEA)lpDevMode,
     2333                                  dwFlags));
     2334}
     2335
     2336/*****************************************************************************
     2337 * Name      : BOOL WIN32API CloseDesktop
     2338 * Purpose   : The CloseDesktop function closes an open handle of a desktop
     2339 *             object. A desktop is a secure object contained within a window
     2340 *             station object. A desktop has a logical display surface and
     2341 *             contains windows, menus and hooks.
     2342 * Parameters: HDESK hDesktop
     2343 * Variables :
     2344 * Result    : If the function succeeds, the return value is TRUE.
     2345 *             If the functions fails, the return value is FALSE. To get
     2346 *             extended error information, call GetLastError.
     2347 * Remark    :
     2348 * Status    : UNTESTED STUB
     2349 *
     2350 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2351 *****************************************************************************/
     2352
     2353BOOL WIN32API CloseDesktop(HDESK hDesktop)
     2354{
     2355  dprintf(("USER32:CloseDesktop(%08x) not implemented.\n",
     2356         hDesktop));
     2357
     2358  return (FALSE);
     2359}
     2360
     2361
     2362/*****************************************************************************
     2363 * Name      : BOOL WIN32API CloseWindowStation
     2364 * Purpose   : The CloseWindowStation function closes an open window station handle.
     2365 * Parameters: HWINSTA hWinSta
     2366 * Variables :
     2367 * Result    :
     2368 * Remark    : If the function succeeds, the return value is TRUE.
     2369 *             If the functions fails, the return value is FALSE. To get
     2370 *             extended error information, call GetLastError.
     2371 * Status    : UNTESTED STUB
     2372 *
     2373 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2374 *****************************************************************************/
     2375
     2376BOOL WIN32API CloseWindowStation(HWINSTA hWinSta)
     2377{
     2378  dprintf(("USER32:CloseWindowStation(%08x) not implemented.\n",
     2379         hWinSta));
     2380
     2381  return (FALSE);
     2382}
     2383
     2384
     2385/*****************************************************************************
     2386 * Name      : HDESK WIN32API CreateDesktopA
     2387 * Purpose   : The CreateDesktop function creates a new desktop on the window
     2388 *             station associated with the calling process.
     2389 * Parameters: LPCTSTR   lpszDesktop      name of the new desktop
     2390 *             LPCTSTR   lpszDevice       name of display device to assign to the desktop
     2391 *             LPDEVMODE pDevMode         reserved; must be NULL
     2392 *             DWORD     dwFlags          flags to control interaction with other applications
     2393 *             DWORD     dwDesiredAccess  specifies access of returned handle
     2394 *             LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
     2395 * Variables :
     2396 * Result    : If the function succeeds, the return value is a handle of the
     2397 *               newly created desktop.
     2398 *             If the function fails, the return value is NULL. To get extended
     2399 *               error information, call GetLastError.
     2400 * Remark    :
     2401 * Status    : UNTESTED STUB
     2402 *
     2403 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2404 *****************************************************************************/
     2405
     2406HDESK WIN32API CreateDesktopA(LPCTSTR               lpszDesktop,
     2407                              LPCTSTR               lpszDevice,
     2408                              LPDEVMODEA            pDevMode,
     2409                              DWORD                 dwFlags,
     2410                              DWORD                 dwDesiredAccess,
     2411                              LPSECURITY_ATTRIBUTES lpsa)
     2412{
     2413  dprintf(("USER32:CreateDesktopA(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
     2414         lpszDesktop,
     2415         lpszDevice,
     2416         pDevMode,
     2417         dwFlags,
     2418         dwDesiredAccess,
     2419         lpsa));
     2420
     2421  return (NULL);
     2422}
     2423
     2424
     2425/*****************************************************************************
     2426 * Name      : HDESK WIN32API CreateDesktopW
     2427 * Purpose   : The CreateDesktop function creates a new desktop on the window
     2428 *             station associated with the calling process.
     2429 * Parameters: LPCTSTR   lpszDesktop      name of the new desktop
     2430 *             LPCTSTR   lpszDevice       name of display device to assign to the desktop
     2431 *             LPDEVMODE pDevMode         reserved; must be NULL
     2432 *             DWORD     dwFlags          flags to control interaction with other applications
     2433 *             DWORD     dwDesiredAccess  specifies access of returned handle
     2434 *             LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the desktop
     2435 * Variables :
     2436 * Result    : If the function succeeds, the return value is a handle of the
     2437 *               newly created desktop.
     2438 *             If the function fails, the return value is NULL. To get extended
     2439 *               error information, call GetLastError.
     2440 * Remark    :
     2441 * Status    : UNTESTED STUB
     2442 *
     2443 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2444 *****************************************************************************/
     2445
     2446HDESK WIN32API CreateDesktopW(LPCTSTR               lpszDesktop,
     2447                              LPCTSTR               lpszDevice,
     2448                              LPDEVMODEW            pDevMode,
     2449                              DWORD                 dwFlags,
     2450                              DWORD                 dwDesiredAccess,
     2451                              LPSECURITY_ATTRIBUTES lpsa)
     2452{
     2453  dprintf(("USER32:CreateDesktopW(%s,%s,%08xh,%08xh,%08xh,%08x) not implemented.\n",
     2454         lpszDesktop,
     2455         lpszDevice,
     2456         pDevMode,
     2457         dwFlags,
     2458         dwDesiredAccess,
     2459         lpsa));
     2460
     2461  return (NULL);
     2462}
     2463
     2464
     2465/*****************************************************************************
     2466 * Name      : HWINSTA WIN32API CreateWindowStationA
     2467 * Purpose   : The CreateWindowStation function creates a window station object.
     2468 *             It returns a handle that can be used to access the window station.
     2469 *             A window station is a secure object that contains a set of global
     2470 *             atoms, a clipboard, and a set of desktop objects.
     2471 * Parameters: LPTSTR lpwinsta            name of the new window station
     2472 *             DWORD dwReserved           reserved; must be NULL
     2473 *             DWORD dwDesiredAccess      specifies access of returned handle
     2474 *             LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
     2475 * Variables :
     2476 * Result    : If the function succeeds, the return value is the handle to the
     2477 *               newly created window station.
     2478 *             If the function fails, the return value is NULL. To get extended
     2479 *               error information, call GetLastError.
     2480 * Remark    :
     2481 * Status    : UNTESTED STUB
     2482 *
     2483 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2484 *****************************************************************************/
     2485
     2486HWINSTA WIN32API CreateWindowStationA(LPTSTR lpWinSta,
     2487                                         DWORD  dwReserved,
     2488                                         DWORD  dwDesiredAccess,
     2489                                         LPSECURITY_ATTRIBUTES lpsa)
     2490{
     2491  dprintf(("USER32:CreateWindowStationA(%s,%08xh,%08xh,%08x) not implemented.\n",
     2492         lpWinSta,
     2493         dwReserved,
     2494         dwDesiredAccess,
     2495         lpsa));
     2496
     2497  return (NULL);
     2498}
     2499
     2500
     2501/*****************************************************************************
     2502 * Name      : HWINSTA WIN32API CreateWindowStationW
     2503 * Purpose   : The CreateWindowStation function creates a window station object.
     2504 *             It returns a handle that can be used to access the window station.
     2505 *             A window station is a secure object that contains a set of global
     2506 *             atoms, a clipboard, and a set of desktop objects.
     2507 * Parameters: LPTSTR lpwinsta            name of the new window station
     2508 *             DWORD dwReserved           reserved; must be NULL
     2509 *             DWORD dwDesiredAccess      specifies access of returned handle
     2510 *             LPSECURITY_ATTRIBUTES lpsa specifies security attributes of the window station
     2511 * Variables :
     2512 * Result    : If the function succeeds, the return value is the handle to the
     2513 *               newly created window station.
     2514 *             If the function fails, the return value is NULL. To get extended
     2515 *               error information, call GetLastError.
     2516 * Remark    :
     2517 * Status    : UNTESTED STUB
     2518 *
     2519 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2520 *****************************************************************************/
     2521
     2522HWINSTA WIN32API CreateWindowStationW(LPWSTR lpWinSta,
     2523                                         DWORD  dwReserved,
     2524                                         DWORD  dwDesiredAccess,
     2525                                         LPSECURITY_ATTRIBUTES lpsa)
     2526{
     2527  dprintf(("USER32:CreateWindowStationW(%s,%08xh,%08xh,%08x) not implemented.\n",
     2528         lpWinSta,
     2529         dwReserved,
     2530         dwDesiredAccess,
     2531         lpsa));
     2532
     2533  return (NULL);
     2534}
     2535
     2536/*****************************************************************************
     2537 * Name      : BOOL WIN32API EnumDesktopWindows
     2538 * Purpose   : The EnumDesktopWindows function enumerates all windows in a
     2539 *             desktop by passing the handle of each window, in turn, to an
     2540 *             application-defined callback function.
     2541 * Parameters: HDESK       hDesktop handle of desktop to enumerate
     2542 *             WNDENUMPROC lpfn     points to application's callback function
     2543 *             LPARAM      lParam   32-bit value to pass to the callback function
     2544 * Variables :
     2545 * Result    : If the function succeeds, the return value is TRUE.
     2546 *             If the function fails, the return value is FALSE. To get
     2547 *             extended error information, call GetLastError.
     2548 * Remark    :
     2549 * Status    : UNTESTED STUB
     2550 *
     2551 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2552 *****************************************************************************/
     2553
     2554BOOL WIN32API EnumDesktopWindows(HDESK       hDesktop,
     2555                                    WNDENUMPROC lpfn,
     2556                                    LPARAM      lParam)
     2557{
     2558  dprintf(("USER32:EnumDesktopWindows (%08xh,%08xh,%08x) not implemented.\n",
     2559         hDesktop,
     2560         lpfn,
     2561         lParam));
     2562
     2563  return (FALSE);
     2564}
     2565
     2566
     2567/*****************************************************************************
     2568 * Name      : BOOL WIN32API EnumDesktopsA
     2569 * Purpose   : The EnumDesktops function enumerates all desktops in the window
     2570 *             station assigned to the calling process. The function does so by
     2571 *             passing the name of each desktop, in turn, to an application-
     2572 *             defined callback function.
     2573 * Parameters: HWINSTA         hwinsta    handle of window station to enumerate
     2574 *             DESKTOPENUMPROC lpEnumFunc points to application's callback function
     2575 *             LPARAM          lParam     32-bit value to pass to the callback function
     2576 * Variables :
     2577 * Result    : If the function succeeds, the return value is TRUE.
     2578 *             If the function fails, the return value is FALSE. To get extended
     2579 *             error information, call GetLastError.
     2580 * Remark    :
     2581 * Status    : UNTESTED STUB
     2582 *
     2583 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2584 *****************************************************************************/
     2585
     2586BOOL WIN32API EnumDesktopsA(HWINSTA          hWinSta,
     2587                            DESKTOPENUMPROCA lpEnumFunc,
     2588                            LPARAM           lParam)
     2589{
     2590  dprintf(("USER32:EnumDesktopsA (%08xh,%08xh,%08x) not implemented.\n",
     2591         hWinSta,
     2592         lpEnumFunc,
     2593         lParam));
     2594
     2595  return (FALSE);
     2596}
     2597
     2598
     2599/*****************************************************************************
     2600 * Name      : BOOL WIN32API EnumDesktopsW
     2601 * Purpose   : The EnumDesktops function enumerates all desktops in the window
     2602 *             station assigned to the calling process. The function does so by
     2603 *             passing the name of each desktop, in turn, to an application-
     2604 *             defined callback function.
     2605 * Parameters: HWINSTA         hwinsta    handle of window station to enumerate
     2606 *             DESKTOPENUMPROC lpEnumFunc points to application's callback function
     2607 *             LPARAM          lParam     32-bit value to pass to the callback function
     2608 * Variables :
     2609 * Result    : If the function succeeds, the return value is TRUE.
     2610 *             If the function fails, the return value is FALSE. To get extended
     2611 *             error information, call GetLastError.
     2612 * Remark    :
     2613 * Status    : UNTESTED STUB
     2614 *
     2615 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2616 *****************************************************************************/
     2617
     2618BOOL WIN32API EnumDesktopsW(HWINSTA          hWinSta,
     2619                            DESKTOPENUMPROCW lpEnumFunc,
     2620                            LPARAM           lParam)
     2621{
     2622  dprintf(("USER32:EnumDesktopsW (%08xh,%08xh,%08x) not implemented.\n",
     2623         hWinSta,
     2624         lpEnumFunc,
     2625         lParam));
     2626
     2627  return (FALSE);
     2628}
     2629
     2630
     2631
     2632/*****************************************************************************
     2633 * Name      : BOOL WIN32API EnumDisplaySettingsW
     2634 * Purpose   : The EnumDisplaySettings function obtains information about one
     2635 *             of a display device's graphics modes. You can obtain information
     2636 *             for all of a display device's graphics modes by making a series
     2637 *             of calls to this function.
     2638 * Parameters: LPCTSTR   lpszDeviceName specifies the display device
     2639 *             DWORD     iModeNum       specifies the graphics mode
     2640 *             LPDEVMODE lpDevMode      points to structure to receive settings
     2641 * Variables :
     2642 * Result    : If the function succeeds, the return value is TRUE.
     2643 *             If the function fails, the return value is FALSE.
     2644 * Remark    :
     2645 * Status    : UNTESTED STUB
     2646 *
     2647 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2648 *****************************************************************************/
     2649
     2650BOOL WIN32API EnumDisplaySettingsW(LPCSTR     lpszDeviceName,
     2651                                      DWORD      iModeNum,
     2652                                      LPDEVMODEW lpDevMode)
     2653{
     2654  dprintf(("USER32:EnumDisplaySettingsW (%s,%08xh,%08x) not implemented.\n",
     2655         lpszDeviceName,
     2656         iModeNum,
     2657         lpDevMode));
     2658
     2659  return (EnumDisplaySettingsA(lpszDeviceName,
     2660                               iModeNum,
     2661                               (LPDEVMODEA)lpDevMode));
     2662}
     2663
     2664
     2665/*****************************************************************************
     2666 * Name      : BOOL WIN32API EnumWindowStationsA
     2667 * Purpose   : The EnumWindowStations function enumerates all windowstations
     2668 *             in the system by passing the name of each window station, in
     2669 *             turn, to an application-defined callback function.
     2670 * Parameters:
     2671 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
     2672 *             LPARAM         lParam     32-bit value to pass to the callback function
     2673 * Result    : If the function succeeds, the return value is TRUE.
     2674 *             If the function fails the return value is FALSE. To get extended
     2675 *             error information, call GetLastError.
     2676 * Remark    :
     2677 * Status    : UNTESTED STUB
     2678 *
     2679 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2680 *****************************************************************************/
     2681
     2682BOOL WIN32API EnumWindowStationsA(WINSTAENUMPROCA lpEnumFunc,
     2683                                  LPARAM          lParam)
     2684{
     2685  dprintf(("USER32:EnumWindowStationsA (%08xh,%08x) not implemented.\n",
     2686         lpEnumFunc,
     2687         lParam));
     2688
     2689  return (FALSE);
     2690}
     2691
     2692
     2693/*****************************************************************************
     2694 * Name      : BOOL WIN32API EnumWindowStationsW
     2695 * Purpose   : The EnumWindowStations function enumerates all windowstations
     2696 *             in the system by passing the name of each window station, in
     2697 *             turn, to an application-defined callback function.
     2698 * Parameters:
     2699 * Variables : WINSTAENUMPROC lpEnumFunc points to application's callback function
     2700 *             LPARAM         lParam     32-bit value to pass to the callback function
     2701 * Result    : If the function succeeds, the return value is TRUE.
     2702 *             If the function fails the return value is FALSE. To get extended
     2703 *             error information, call GetLastError.
     2704 * Remark    :
     2705 * Status    : UNTESTED STUB
     2706 *
     2707 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2708 *****************************************************************************/
     2709
     2710BOOL WIN32API EnumWindowStationsW(WINSTAENUMPROCW lpEnumFunc,
     2711                                  LPARAM          lParam)
     2712{
     2713  dprintf(("USER32:EnumWindowStationsW (%08xh,%08x) not implemented.\n",
     2714         lpEnumFunc,
     2715         lParam));
     2716
     2717  return (FALSE);
     2718}
     2719
     2720
     2721
     2722/*****************************************************************************
     2723 * Name      : BOOL WIN32API GetInputState
     2724 * Purpose   : The GetInputState function determines whether there are
     2725 *             mouse-button or keyboard messages in the calling thread's message queue.
     2726 * Parameters:
     2727 * Variables :
     2728 * Result    : If the queue contains one or more new mouse-button or keyboard
     2729 *               messages, the return value is TRUE.
     2730 *             If the function fails, the return value is FALSE.
     2731 * Remark    :
     2732 * Status    : UNTESTED STUB
     2733 *
     2734 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2735 *****************************************************************************/
     2736
     2737BOOL WIN32API GetInputState(VOID)
     2738{
     2739  dprintf(("USER32:GetInputState () not implemented.\n"));
     2740
     2741  return (FALSE);
     2742}
     2743
     2744
     2745/*****************************************************************************
     2746 * Name      : UINT WIN32API GetKBCodePage
     2747 * Purpose   : The GetKBCodePage function is provided for compatibility with
     2748 *             earlier versions of Windows. In the Win32 application programming
     2749 *             interface (API) it just calls the GetOEMCP function.
     2750 * Parameters:
     2751 * Variables :
     2752 * Result    : If the function succeeds, the return value is an OEM code-page
     2753 *             identifier, or it is the default identifier if the registry
     2754 *             value is not readable. For a list of OEM code-page identifiers,
     2755 *             see GetOEMCP.
     2756 * Remark    :
     2757 * Status    : UNTESTED
     2758 *
     2759 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2760 *****************************************************************************/
     2761
     2762UINT WIN32API GetKBCodePage(VOID)
     2763{
     2764  return (GetOEMCP());
     2765}
     2766
     2767
     2768/*****************************************************************************
     2769 * Name      : HWINSTA WIN32API GetProcessWindowStation
     2770 * Purpose   : The GetProcessWindowStation function returns a handle of the
     2771 *             window station associated with the calling process.
     2772 * Parameters:
     2773 * Variables :
     2774 * Result    : If the function succeeds, the return value is a handle of the
     2775 *               window station associated with the calling process.
     2776 *             If the function fails, the return value is NULL. This can occur
     2777 *               if the calling process is not an application written for Windows
     2778 *               NT. To get extended error information, call GetLastError.
     2779 * Remark    :
     2780 * Status    : UNTESTED STUB
     2781 *
     2782 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2783 *****************************************************************************/
     2784
     2785HWINSTA WIN32API GetProcessWindowStation(VOID)
     2786{
     2787  dprintf(("USER32:GetProcessWindowStation () not implemented.\n"));
     2788
     2789  return (NULL);
     2790}
     2791
     2792
     2793
     2794/*****************************************************************************
     2795 * Name      : HDESK WIN32API GetThreadDesktop
     2796 * Purpose   : The GetThreadDesktop function returns a handle to the desktop
     2797 *             associated with a specified thread.
     2798 * Parameters: DWORD dwThreadId thread identifier
     2799 * Variables :
     2800 * Result    : If the function succeeds, the return value is the handle of the
     2801 *               desktop associated with the specified thread.
     2802 * Remark    :
     2803 * Status    : UNTESTED STUB
     2804 *
     2805 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2806 *****************************************************************************/
     2807
     2808HDESK WIN32API GetThreadDesktop(DWORD dwThreadId)
     2809{
     2810  dprintf(("USER32:GetThreadDesktop (%u) not implemented.\n",
     2811         dwThreadId));
     2812
     2813  return (NULL);
     2814}
     2815
     2816
     2817/*****************************************************************************
     2818 * Name      : BOOL WIN32API GetUserObjectInformationA
     2819 * Purpose   : The GetUserObjectInformation function returns information about
     2820 *               a window station or desktop object.
     2821 * Parameters: HANDLE  hObj            handle of object to get information for
     2822 *             int     nIndex          type of information to get
     2823 *             PVOID   pvInfo          points to buffer that receives the information
     2824 *             DWORD   nLength         size, in bytes, of pvInfo buffer
     2825 *             LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
     2826 * Variables :
     2827 * Result    : If the function succeeds, the return value is TRUE.
     2828 *             If the function fails, the return value is FALSE. To get extended
     2829 *             error information, call GetLastError.
     2830 * Remark    :
     2831 * Status    : UNTESTED STUB
     2832 *
     2833 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2834 *****************************************************************************/
     2835
     2836BOOL WIN32API GetUserObjectInformationA(HANDLE  hObj,
     2837                                           int     nIndex,
     2838                                           PVOID   pvInfo,
     2839                                           DWORD   nLength,
     2840                                           LPDWORD lpnLengthNeeded)
     2841{
     2842  dprintf(("USER32:GetUserObjectInformationA (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
     2843         hObj,
     2844         nIndex,
     2845         pvInfo,
     2846         nLength,
     2847         lpnLengthNeeded));
     2848
     2849  return (FALSE);
     2850}
     2851
     2852
     2853/*****************************************************************************
     2854 * Name      : BOOL WIN32API GetUserObjectInformationW
     2855 * Purpose   : The GetUserObjectInformation function returns information about
     2856 *               a window station or desktop object.
     2857 * Parameters: HANDLE  hObj            handle of object to get information for
     2858 *             int     nIndex          type of information to get
     2859 *             PVOID   pvInfo          points to buffer that receives the information
     2860 *             DWORD   nLength         size, in bytes, of pvInfo buffer
     2861 *             LPDWORD lpnLengthNeeded receives required size, in bytes, of pvInfo buffer
     2862 * Variables :
     2863 * Result    : If the function succeeds, the return value is TRUE.
     2864 *             If the function fails, the return value is FALSE. To get extended
     2865 *             error information, call GetLastError.
     2866 * Remark    :
     2867 * Status    : UNTESTED STUB
     2868 *
     2869 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2870 *****************************************************************************/
     2871
     2872BOOL WIN32API GetUserObjectInformationW(HANDLE  hObj,
     2873                                           int     nIndex,
     2874                                           PVOID   pvInfo,
     2875                                           DWORD   nLength,
     2876                                           LPDWORD lpnLengthNeeded)
     2877{
     2878  dprintf(("USER32:GetUserObjectInformationW (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
     2879         hObj,
     2880         nIndex,
     2881         pvInfo,
     2882         nLength,
     2883         lpnLengthNeeded));
     2884
     2885  return (FALSE);
     2886}
     2887
     2888
     2889/*****************************************************************************
     2890 * Name      : BOOL WIN32API GetUserObjectSecurity
     2891 * Purpose   : The GetUserObjectSecurity function retrieves security information
     2892 *             for the specified user object.
     2893 * Parameters: HANDLE                hObj            handle of user object
     2894 *             SECURITY_INFORMATION * pSIRequested    address of requested security information
     2895 *             LPSECURITY_DESCRIPTOR  pSID            address of security descriptor
     2896 *             DWORD                 nLength         size of buffer for security descriptor
     2897 *             LPDWORD               lpnLengthNeeded address of required size of buffer
     2898 * Variables :
     2899 * Result    : If the function succeeds, the return value is TRUE.
     2900 *             If the function fails, the return value is FALSE. To get extended
     2901 *               error information, call GetLastError.
     2902 * Remark    :
     2903 * Status    : UNTESTED STUB
     2904 *
     2905 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2906 *****************************************************************************/
     2907
     2908BOOL WIN32API GetUserObjectSecurity(HANDLE                hObj,
     2909                                       SECURITY_INFORMATION * pSIRequested,
     2910                                       LPSECURITY_DESCRIPTOR  pSID,
     2911                                       DWORD                 nLength,
     2912                                       LPDWORD               lpnLengthNeeded)
     2913{
     2914  dprintf(("USER32:GetUserObjectSecurity (%08xh,%08xh,%08xh,%u,%08x) not implemented.\n",
     2915         hObj,
     2916         pSIRequested,
     2917         pSID,
     2918         nLength,
     2919         lpnLengthNeeded));
     2920
     2921  return (FALSE);
     2922}
     2923
     2924
     2925
     2926/*****************************************************************************
     2927 * Name      : int WIN32API GetWindowRgn
     2928 * Purpose   : The GetWindowRgn function obtains a copy of the window region of a window.
     2929 * Parameters: HWND hWnd handle to window whose window region is to be obtained
     2930 *             HRGN hRgn handle to region that receives a copy of the window region
     2931 * Variables :
     2932 * Result    : NULLREGION, SIMPLEREGION, COMPLEXREGION, ERROR
     2933 * Remark    :
     2934 * Status    : UNTESTED STUB
     2935 *
     2936 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2937 *****************************************************************************/
     2938
     2939int WIN32API GetWindowRgn (HWND hWnd,
     2940                              HRGN hRgn)
     2941{
     2942  dprintf(("USER32:GetWindowRgn (%08xh,%08x) not implemented.\n",
     2943         hWnd,
     2944         hRgn));
     2945
     2946  return (NULLREGION);
     2947}
     2948
     2949
     2950
     2951/*****************************************************************************
     2952 * Name      : HDESK WIN32API OpenDesktopA
     2953 * Purpose   : The OpenDesktop function returns a handle to an existing desktop.
     2954 *             A desktop is a secure object contained within a window station
     2955 *             object. A desktop has a logical display surface and contains
     2956 *             windows, menus and hooks.
     2957 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
     2958 *             DWORD dwFlags           flags to control interaction with other applications
     2959 *             BOOL fInherit           specifies whether returned handle is inheritable
     2960 *             DWORD dwDesiredAccess   specifies access of returned handle
     2961 * Variables :
     2962 * Result    : If the function succeeds, the return value is the handle to the
     2963 *               opened desktop.
     2964 *             If the function fails, the return value is NULL. To get extended
     2965 *               error information, call GetLastError.
     2966 * Remark    :
     2967 * Status    : UNTESTED STUB
     2968 *
     2969 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     2970 *****************************************************************************/
     2971
     2972HDESK WIN32API OpenDesktopA(LPCTSTR lpszDesktopName,
     2973                               DWORD   dwFlags,
     2974                               BOOL    fInherit,
     2975                               DWORD   dwDesiredAccess)
     2976{
     2977  dprintf(("USER32:OpenDesktopA (%s,%08xh,%08xh,%08x) not implemented.\n",
     2978         lpszDesktopName,
     2979         dwFlags,
     2980         fInherit,
     2981         dwDesiredAccess));
     2982
     2983  return (NULL);
     2984}
     2985
     2986
     2987/*****************************************************************************
     2988 * Name      : HDESK WIN32API OpenDesktopW
     2989 * Purpose   : The OpenDesktop function returns a handle to an existing desktop.
     2990 *             A desktop is a secure object contained within a window station
     2991 *             object. A desktop has a logical display surface and contains
     2992 *             windows, menus and hooks.
     2993 * Parameters: LPCTSTR lpszDesktopName name of the desktop to open
     2994 *             DWORD dwFlags           flags to control interaction with other applications
     2995 *             BOOL fInherit           specifies whether returned handle is inheritable
     2996 *             DWORD dwDesiredAccess   specifies access of returned handle
     2997 * Variables :
     2998 * Result    : If the function succeeds, the return value is the handle to the
     2999 *               opened desktop.
     3000 *             If the function fails, the return value is NULL. To get extended
     3001 *               error information, call GetLastError.
     3002 * Remark    :
     3003 * Status    : UNTESTED STUB
     3004 *
     3005 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     3006 *****************************************************************************/
     3007
     3008HDESK WIN32API OpenDesktopW(LPCTSTR lpszDesktopName,
     3009                               DWORD   dwFlags,
     3010                               BOOL    fInherit,
     3011                               DWORD   dwDesiredAccess)
     3012{
     3013  dprintf(("USER32:OpenDesktopW (%s,%08xh,%08xh,%08x) not implemented.\n",
     3014         lpszDesktopName,
     3015         dwFlags,
     3016         fInherit,
     3017         dwDesiredAccess));
     3018
     3019  return (NULL);
     3020}
     3021
     3022
     3023/*****************************************************************************
     3024 * Name      : HDESK WIN32API OpenInputDesktop
     3025 * Purpose   : The OpenInputDesktop function returns a handle to the desktop
     3026 *             that receives user input. The input desktop is a desktop on the
     3027 *             window station associated with the logged-on user.
     3028 * Parameters: DWORD dwFlags         flags to control interaction with other applications
     3029 *             BOOL  fInherit        specifies whether returned handle is inheritable
     3030 *             DWORD dwDesiredAccess specifies access of returned handle
     3031 * Variables :
     3032 * Result    : If the function succeeds, the return value is a handle of the
     3033 *               desktop that receives user input.
     3034 *             If the function fails, the return value is NULL. To get extended
     3035 *               error information, call GetLastError.
     3036 * Remark    :
     3037 * Status    : UNTESTED STUB
     3038 *
     3039 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     3040 *****************************************************************************/
     3041
     3042HDESK WIN32API OpenInputDesktop(DWORD dwFlags,
     3043                                   BOOL  fInherit,
     3044                                   DWORD dwDesiredAccess)
     3045{
     3046  dprintf(("USER32:OpenInputDesktop (%08xh,%08xh,%08x) not implemented.\n",
     3047         dwFlags,
     3048         fInherit,
     3049         dwDesiredAccess));
     3050
     3051  return (NULL);
     3052}
     3053
     3054
     3055/*****************************************************************************
     3056 * Name      : HWINSTA WIN32API OpenWindowStationA
     3057 * Purpose   : The OpenWindowStation function returns a handle to an existing
     3058 *               window station.
     3059 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
     3060 *             BOOL fInherit          specifies whether returned handle is inheritable
     3061 *             DWORD dwDesiredAccess  specifies access of returned handle
     3062 * Variables :
     3063 * Result    : If the function succeeds, the return value is the handle to the
     3064 *               specified window station.
     3065 *             If the function fails, the return value is NULL. To get extended
     3066 *               error information, call GetLastError.
     3067 * Remark    :
     3068 * Status    : UNTESTED STUB
     3069 *
     3070 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     3071 *****************************************************************************/
     3072
     3073HWINSTA WIN32API OpenWindowStationA(LPCTSTR lpszWinStaName,
     3074                                       BOOL    fInherit,
     3075                                       DWORD   dwDesiredAccess)
     3076{
     3077  dprintf(("USER32:OpenWindowStatieonA (%s,%08xh,%08x) not implemented.\n",
     3078         lpszWinStaName,
     3079         fInherit,
     3080         dwDesiredAccess));
     3081
     3082  return (NULL);
     3083}
     3084
     3085
     3086/*****************************************************************************
     3087 * Name      : HWINSTA WIN32API OpenWindowStationW
     3088 * Purpose   : The OpenWindowStation function returns a handle to an existing
     3089 *               window station.
     3090 * Parameters: LPCTSTR lpszWinStaName name of the window station to open
     3091 *             BOOL fInherit          specifies whether returned handle is inheritable
     3092 *             DWORD dwDesiredAccess  specifies access of returned handle
     3093 * Variables :
     3094 * Result    : If the function succeeds, the return value is the handle to the
     3095 *               specified window station.
     3096 *             If the function fails, the return value is NULL. To get extended
     3097 *               error information, call GetLastError.
     3098
     3099
     3100 * Remark    :
     3101 * Status    : UNTESTED STUB
     3102 *
     3103 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     3104 *****************************************************************************/
     3105
     3106HWINSTA WIN32API OpenWindowStationW(LPCTSTR lpszWinStaName,
     3107                                       BOOL    fInherit,
     3108                                       DWORD   dwDesiredAccess)
     3109{
     3110  dprintf(("USER32:OpenWindowStatieonW (%s,%08xh,%08x) not implemented.\n",
     3111         lpszWinStaName,
     3112         fInherit,
     3113         dwDesiredAccess));
     3114
     3115  return (NULL);
     3116}
     3117
     3118
     3119/*****************************************************************************
     3120 * Name      : BOOL WIN32API PaintDesktop
     3121 * Purpose   : The PaintDesktop function fills the clipping region in the
     3122 *             specified device context with the desktop pattern or wallpaper.
     3123 *             The function is provided primarily for shell desktops.
     3124 * Parameters:
     3125 * Variables :
     3126 * Result    : If the function succeeds, the return value is TRUE.
     3127 *             If the function fails, the return value is FALSE.
     3128 * Remark    :
     3129 * Status    : UNTESTED STUB
     3130 *
     3131 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     3132 *****************************************************************************/
     3133
     3134BOOL WIN32API PaintDesktop(HDC hdc)
     3135{
     3136  dprintf(("USER32:PaintDesktop (%08x) not implemented.\n",
     3137         hdc));
     3138
     3139  return (FALSE);
     3140}
     3141
     3142
     3143
     3144/*****************************************************************************
     3145 * Name      : VOID WIN32API SetDebugErrorLevel
     3146 * Purpose   : The SetDebugErrorLevel function sets the minimum error level at
     3147 *             which Windows will generate debugging events and pass them to a debugger.
     3148 * Parameters: DWORD dwLevel debugging error level
     3149 * Variables :
     3150 * Result    :
     3151 * Remark    :
     3152 * Status    : UNTESTED STUB
     3153 *
     3154 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     3155 *****************************************************************************/
     3156
     3157VOID WIN32API SetDebugErrorLevel(DWORD dwLevel)
     3158{
     3159  dprintf(("USER32:SetDebugErrorLevel (%08x) not implemented.\n",
     3160         dwLevel));
     3161}
     3162
     3163
     3164/*****************************************************************************
     3165 * Name      : BOOL WIN32API SetProcessWindowStation
     3166 * Purpose   : The SetProcessWindowStation function assigns a window station
     3167 *             to the calling process. This enables the process to access
     3168 *             objects in the window station such as desktops, the clipboard,
     3169 *             and global atoms. All subsequent operations on the window station
     3170 *             use the access rights granted to hWinSta.
     3171 * Parameters:
     3172 * Variables :
     3173 * Result    : If the function succeeds, the return value is TRUE.
     3174 *             If the function fails, the return value is FALSE. To get extended
     3175 *               error information, call GetLastError.
     3176 * Remark    :
     3177 * Status    : UNTESTED STUB
     3178 *
     3179 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     3180 *****************************************************************************/
     3181
     3182BOOL WIN32API SetProcessWindowStation(HWINSTA hWinSta)
     3183{
     3184  dprintf(("USER32:SetProcessWindowStation (%08x) not implemented.\n",
     3185         hWinSta));
     3186
     3187  return (FALSE);
     3188}
     3189
     3190
     3191/*****************************************************************************
     3192 * Name      : BOOL WIN32API SetThreadDesktop
     3193 * Purpose   : The SetThreadDesktop function assigns a desktop to the calling
     3194 *             thread. All subsequent operations on the desktop use the access
     3195 *             rights granted to hDesk.
     3196 * Parameters: HDESK hDesk handle of the desktop to assign to this thread
     3197 * Variables :
     3198 * Result    : If the function succeeds, the return value is TRUE.
     3199 *             If the function fails, the return value is FALSE. To get extended
     3200 *             error information, call GetLastError.
     3201 * Remark    :
     3202 * Status    : UNTESTED STUB
     3203 *
     3204 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     3205 *****************************************************************************/
     3206
     3207BOOL WIN32API SetThreadDesktop(HDESK hDesktop)
     3208{
     3209  dprintf(("USER32:SetThreadDesktop (%08x) not implemented.\n",
     3210         hDesktop));
     3211
     3212  return (FALSE);
     3213}
     3214
     3215
     3216/*****************************************************************************
     3217 * Name      : BOOL WIN32API SetUserObjectInformationA
     3218 * Purpose   : The SetUserObjectInformation function sets information about a
     3219 *             window station or desktop object.
     3220 * Parameters: HANDLE hObject handle of the object for which to set information
     3221 *             int    nIndex  type of information to set
     3222 *             PVOID  lpvInfo points to a buffer that contains the information
     3223 *             DWORD  cbInfo  size, in bytes, of lpvInfo buffer
     3224 * Variables :
     3225 * Result    : If the function succeeds, the return value is TRUE.
     3226 *             If the function fails the return value is FALSE. To get extended
     3227 *               error information, call GetLastError.
     3228 * Remark    :
     3229 * Status    : UNTESTED STUB
     3230 *
     3231 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     3232 *****************************************************************************/
     3233
     3234BOOL WIN32API SetUserObjectInformationA(HANDLE hObject,
     3235                                           int    nIndex,
     3236                                           PVOID  lpvInfo,
     3237                                           DWORD  cbInfo)
     3238{
     3239  dprintf(("USER32:SetUserObjectInformationA (%08xh,%u,%08xh,%08x) not implemented.\n",
     3240           hObject,
     3241           nIndex,
     3242           lpvInfo,
     3243           cbInfo));
     3244
     3245  return (FALSE);
     3246}
     3247
     3248
     3249/*****************************************************************************
     3250 * Name      : BOOL WIN32API SetUserObjectInformationW
     3251 * Purpose   : The SetUserObjectInformation function sets information about a
     3252 *             window station or desktop object.
     3253 * Parameters: HANDLE hObject handle of the object for which to set information
     3254 *             int    nIndex  type of information to set
     3255 *             PVOID  lpvInfo points to a buffer that contains the information
     3256 *             DWORD  cbInfo  size, in bytes, of lpvInfo buffer
     3257 * Variables :
     3258 * Result    : If the function succeeds, the return value is TRUE.
     3259 *             If the function fails the return value is FALSE. To get extended
     3260 *               error information, call GetLastError.
     3261 * Remark    :
     3262 * Status    : UNTESTED STUB
     3263 *
     3264 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     3265 *****************************************************************************/
     3266
     3267BOOL WIN32API SetUserObjectInformationW(HANDLE hObject,
     3268                                           int    nIndex,
     3269                                           PVOID  lpvInfo,
     3270                                           DWORD  cbInfo)
     3271{
     3272  dprintf(("USER32:SetUserObjectInformationW (%08xh,%u,%08xh,%08x) not implemented.\n",
     3273           hObject,
     3274           nIndex,
     3275           lpvInfo,
     3276           cbInfo));
     3277
     3278  return (FALSE);
     3279}
     3280
     3281
     3282/*****************************************************************************
     3283 * Name      : BOOL WIN32API SetUserObjectSecurity
     3284 * Purpose   : The SetUserObjectSecurity function sets the security of a user
     3285 *             object. This can be, for example, a window or a DDE conversation
     3286 * Parameters: HANDLE  hObject           handle of user object
     3287 *             SECURITY_INFORMATION * psi address of security information
     3288 *             LPSECURITY_DESCRIPTOR  psd address of security descriptor
     3289 * Variables :
     3290 * Result    : If the function succeeds, the return value is TRUE.
     3291 *             If the function fails, the return value is FALSE. To get extended
     3292 *             error information, call GetLastError.
     3293 * Remark    :
     3294 * Status    : UNTESTED STUB
     3295 *
     3296 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     3297 *****************************************************************************/
     3298
     3299BOOL WIN32API SetUserObjectSecurity(HANDLE hObject,
     3300                                       SECURITY_INFORMATION * psi,
     3301                                       LPSECURITY_DESCRIPTOR  psd)
     3302{
     3303  dprintf(("USER32:SetUserObjectSecuroty (%08xh,%08xh,%08x) not implemented.\n",
     3304           hObject,
     3305           psi,
     3306           psd));
     3307
     3308  return (FALSE);
     3309}
     3310
     3311
     3312/*****************************************************************************
     3313 * Name      : int WIN32API SetWindowRgn
     3314 * Purpose   : The SetWindowRgn function sets the window region of a window. The
     3315 *             window region determines the area within the window where the
     3316 *             operating system permits drawing. The operating system does not
     3317 *             display any portion of a window that lies outside of the window region
     3318 * Parameters: HWND  hWnd    handle to window whose window region is to be set
     3319 *             HRGN  hRgn    handle to region
     3320 *             BOOL  bRedraw window redraw flag
     3321 * Variables :
     3322 * Result    : If the function succeeds, the return value is non-zero.
     3323 *             If the function fails, the return value is zero.
     3324 * Remark    :
     3325 * Status    : UNTESTED STUB
     3326 *
     3327 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     3328 *****************************************************************************/
     3329
     3330int WIN32API SetWindowRgn(HWND hWnd,
     3331                             HRGN hRgn,
     3332                             BOOL bRedraw)
     3333{
     3334  dprintf(("USER32:SetWindowRgn (%08xh,%08xh,%u) not implemented.\n",
     3335         hWnd,
     3336         hRgn,
     3337         bRedraw));
     3338
     3339  return (0);
     3340}
     3341
     3342
     3343/*****************************************************************************
     3344 * Name      : BOOL WIN32API SetWindowsHookW
     3345 * Purpose   : The SetWindowsHook function is not implemented in the Win32 API.
     3346 *             Win32-based applications should use the SetWindowsHookEx function.
     3347 * Parameters:
     3348 * Variables :
     3349 * Result    :
     3350 * Remark    : ARGH ! MICROSOFT !
     3351 * Status    : UNTESTED STUB
     3352 *
     3353 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     3354 *****************************************************************************/
     3355
     3356HHOOK WIN32API SetWindowsHookW(int nFilterType, HOOKPROC pfnFilterProc)
     3357
     3358{
     3359  return (FALSE);
     3360}
     3361
     3362
     3363/*****************************************************************************
     3364 * Name      : BOOL WIN32API ShowWindowAsync
     3365 * Purpose   : The ShowWindowAsync function sets the show state of a window
     3366 *             created by a different thread.
     3367 * Parameters: HWND hwnd     handle of window
     3368 *             int  nCmdShow show state of window
     3369 * Variables :
     3370 * Result    : If the window was previously visible, the return value is TRUE.
     3371 *             If the window was previously hidden, the return value is FALSE.
     3372 * Remark    :
     3373 * Status    : UNTESTED STUB
     3374 *
     3375 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     3376 *****************************************************************************/
     3377
     3378BOOL WIN32API ShowWindowAsync (HWND hWnd,
     3379                               int  nCmdShow)
     3380{
     3381  dprintf(("USER32:ShowWindowAsync (%08xh,%08x) not implemented.\n",
     3382         hWnd,
     3383         nCmdShow));
     3384
     3385  return (FALSE);
     3386}
     3387
     3388
     3389/*****************************************************************************
     3390 * Name      : BOOL WIN32API SwitchDesktop
     3391 * Purpose   : The SwitchDesktop function makes a desktop visible and activates
     3392 *             it. This enables the desktop to receive input from the user. The
     3393 *             calling process must have DESKTOP_SWITCHDESKTOP access to the
     3394 *             desktop for the SwitchDesktop function to succeed.
     3395 * Parameters:
     3396 * Variables :
     3397 * Result    : If the function succeeds, the return value is TRUE.
     3398 *             If the function fails, the return value is FALSE. To get extended
     3399 *               error information, call GetLastError.
     3400 * Remark    :
     3401 * Status    : UNTESTED STUB
     3402 *
     3403 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     3404 *****************************************************************************/
     3405
     3406BOOL WIN32API SwitchDesktop(HDESK hDesktop)
     3407{
     3408  dprintf(("USER32:SwitchDesktop (%08x) not implemented.\n",
     3409         hDesktop));
     3410
     3411  return (FALSE);
     3412}
     3413
     3414
     3415/*****************************************************************************
     3416 * Name      : WORD WIN32API TileWindows
     3417 * Purpose   : The TileWindows function tiles the specified windows, or the child
     3418 *             windows of the specified parent window.
     3419 * Parameters: HWND       hwndParent     handle of parent window
     3420 *             WORD       wFlags         types of windows not to arrange
     3421 *             LPCRECT    lpRect         rectangle to arrange windows in
     3422 *             WORD       cChildrenb     number of windows to arrange
     3423 *             const HWND *ahwndChildren array of window handles
     3424 * Variables :
     3425 * Result    : If the function succeeds, the return value is the number of
     3426 *               windows arranged.
     3427 *             If the function fails, the return value is zero.
     3428 * Remark    :
     3429 * Status    : UNTESTED STUB
     3430 *
     3431 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     3432 *****************************************************************************/
     3433
     3434WORD WIN32API TileWindows(HWND       hwndParent,
     3435                          UINT       wFlags,
     3436                          const LPRECT lpRect,
     3437                          UINT       cChildrenb,
     3438                          const HWND *ahwndChildren)
     3439{
     3440  dprintf(("USER32:TileWindows (%08xh,%08xh,%08xh,%08xh,%08x) not implemented.\n",
     3441           hwndParent,
     3442           wFlags,
     3443           lpRect,
     3444           cChildrenb,
     3445           ahwndChildren));
     3446
     3447   return (0);
    34063448}
    34073449
    … …  
    34623504
    34633505/*****************************************************************************
    3464  * Name      : VOID WIN32API keybd_event
    3465  * Purpose   : The keybd_event function synthesizes a keystroke. The system
    3466  *             can use such a synthesized keystroke to generate a WM_KEYUP or
    3467  *             WM_KEYDOWN message. The keyboard driver's interrupt handler calls
    3468  *             the keybd_event function.
    3469  * Parameters: BYTE  bVk         virtual-key code
    3470 
    3471  *             BYTE  bScan       hardware scan code
    3472  *             DWORD dwFlags     flags specifying various function options
    3473  *             DWORD dwExtraInfo additional data associated with keystroke
    3474  * Variables :
    3475  * Result    :
    3476  * Remark    :
    3477  * Status    : UNTESTED STUB
    3478  *
    3479  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    3480  *****************************************************************************/
    3481 
    3482 VOID WIN32API keybd_event (BYTE bVk,
    3483                            BYTE bScan,
    3484                            DWORD dwFlags,
    3485                            DWORD dwExtraInfo)
    3486 {
    3487   dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
    3488          bVk,
    3489          bScan,
    3490          dwFlags,
    3491          dwExtraInfo));
    3492 }
    3493 
    3494 
    3495 /*****************************************************************************
    3496  * Name      : VOID WIN32API mouse_event
    3497  * Purpose   : The mouse_event function synthesizes mouse motion and button clicks.
    3498  * Parameters: DWORD dwFlags     flags specifying various motion/click variants
    3499  *             DWORD dx          horizontal mouse position or position change
    3500  *             DWORD dy          vertical mouse position or position change
    3501  *             DWORD cButtons    unused, reserved for future use, set to zero
    3502  *             DWORD dwExtraInfo 32 bits of application-defined information
    3503  * Variables :
    3504  * Result    :
    3505  * Remark    :
    3506  * Status    : UNTESTED STUB
    3507  *
    3508  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    3509  *****************************************************************************/
    3510 
    3511 VOID WIN32API mouse_event(DWORD dwFlags,
    3512                              DWORD dx,
    3513                              DWORD dy,
    3514                              DWORD cButtons,
    3515                              DWORD dwExtraInfo)
    3516 {
    3517   dprintf(("USER32:mouse_event (%08xh,%u,%u,%u,%08x) not implemented.\n",
    3518           dwFlags,
    3519           dx,
    3520           dy,
    3521           cButtons,
    3522           dwExtraInfo));
    3523 }
    3524 
    3525 
    3526 /*****************************************************************************
    35273506 * Name      : BOOL WIN32API SetShellWindow
    35283507 * Purpose   : Unknown
Note: See TracChangeset for help on using the changeset viewer.