Changeset 6162


Ignore:
Timestamp:
Jul 4, 2001, 8:39:01 AM (24 years ago)
Author:
sandervl
Message:

VkKeyScanExA/W, ToAsciiEx & MapVirtualKeyExA/W updates

Location:
trunk/src/user32
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified trunk/src/user32/user32.cpp

    r6156 r6162  
    1 /* $Id: user32.cpp,v 1.104 2001-07-03 18:33:27 sandervl Exp $ */
     1/* $Id: user32.cpp,v 1.105 2001-07-04 06:39:01 sandervl Exp $ */
    22
    33/*
    … …  
    10771077}
    10781078
    1079 /* Keyboard and Input Functions */
    1080 
    1081 BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
    1082 {
    1083   dprintf(("USER32:  ActivateKeyboardLayout, not implemented\n"));
    1084   return(TRUE);
    1085 }
    1086 /*****************************************************************************
    1087  * Name      : UINT WIN32API GetKBCodePage
    1088  * Purpose   : The GetKBCodePage function is provided for compatibility with
    1089  *             earlier versions of Windows. In the Win32 application programming
    1090  *             interface (API) it just calls the GetOEMCP function.
    1091  * Parameters:
    1092  * Variables :
    1093  * Result    : If the function succeeds, the return value is an OEM code-page
    1094  *             identifier, or it is the default identifier if the registry
    1095  *             value is not readable. For a list of OEM code-page identifiers,
    1096  *             see GetOEMCP.
    1097  * Remark    :
    1098  * Status    : COMPLETELY IMPLEMENTED UNTESTED
    1099  *
    1100  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    1101  *****************************************************************************/
    1102 
    1103 UINT WIN32API GetKBCodePage(VOID)
    1104 {
    1105   return (GetOEMCP());
    1106 }
    1107 //******************************************************************************
    1108 //******************************************************************************
    1109 int WIN32API GetKeyNameTextA( LPARAM lParam, LPSTR lpString, int  nSize)
    1110 {
    1111     dprintf(("USER32:  GetKeyNameTextA\n"));
    1112     return O32_GetKeyNameText(lParam,lpString,nSize);
    1113 }
    1114 //******************************************************************************
    1115 //******************************************************************************
    1116 int WIN32API GetKeyNameTextW( LPARAM lParam, LPWSTR lpString, int  nSize)
    1117 {
    1118     dprintf(("USER32:  GetKeyNameTextW DOES NOT WORK\n"));
    1119     // NOTE: This will not work as is (needs UNICODE support)
    1120     return 0;
    1121 //    return O32_GetKeyNameText(arg1, arg2, arg3);
    1122 }
    1123 //******************************************************************************
    1124 //******************************************************************************
    1125 SHORT WIN32API GetKeyState( int nVirtKey)
    1126 {
    1127     dprintf2(("USER32: GetKeyState %x", nVirtKey));
    1128     return O32_GetKeyState(nVirtKey);
    1129 }
    1130 //******************************************************************************
    1131 //******************************************************************************
    1132 WORD WIN32API GetAsyncKeyState(INT nVirtKey)
    1133 {
    1134     dprintf2(("USER32: GetAsyncKeyState %x", nVirtKey));
    1135     return O32_GetAsyncKeyState(nVirtKey);
    1136 }
    1137 
    1138 /*****************************************************************************
    1139  * Name      : VOID WIN32API keybd_event
    1140  * Purpose   : The keybd_event function synthesizes a keystroke. The system
    1141  *             can use such a synthesized keystroke to generate a WM_KEYUP or
    1142  *             WM_KEYDOWN message. The keyboard driver's interrupt handler calls
    1143  *             the keybd_event function.
    1144  * Parameters: BYTE  bVk         virtual-key code
    1145 
    1146  *             BYTE  bScan       hardware scan code
    1147  *             DWORD dwFlags     flags specifying various function options
    1148  *             DWORD dwExtraInfo additional data associated with keystroke
    1149  * Variables :
    1150  * Result    :
    1151  * Remark    :
    1152  * Status    : UNTESTED STUB
    1153  *
    1154  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    1155  *****************************************************************************/
    1156 VOID WIN32API keybd_event (BYTE bVk,
    1157                            BYTE bScan,
    1158                            DWORD dwFlags,
    1159                            DWORD dwExtraInfo)
    1160 {
    1161   dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
    1162          bVk,
    1163          bScan,
    1164          dwFlags,
    1165          dwExtraInfo));
    1166 }
    1167 /*****************************************************************************
    1168  * Name      : HLK WIN32API LoadKeyboardLayoutA
    1169  * Purpose   : The LoadKeyboardLayout function loads a new keyboard layout into
    1170  *             the system. Several keyboard layouts can be loaded at a time, but
    1171  *             only one per process is active at a time. Loading multiple keyboard
    1172  *             layouts makes it possible to rapidly switch between layouts.
    1173  * Parameters:
    1174  * Variables :
    1175  * Result    : If the function succeeds, the return value is the handle of the
    1176  *               keyboard layout.
    1177  *             If the function fails, the return value is NULL. To get extended
    1178  *               error information, call GetLastError.
    1179  * Remark    :
    1180  * Status    : UNTESTED STUB
    1181  *
    1182  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    1183  *****************************************************************************/
    1184 HKL WIN32API LoadKeyboardLayoutA(LPCTSTR pwszKLID,
    1185                                  UINT    Flags)
    1186 {
    1187   dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
    1188          pwszKLID,
    1189          Flags));
    1190 
    1191   return (NULL);
    1192 }
    1193 /*****************************************************************************
    1194  * Name      : HLK WIN32API LoadKeyboardLayoutW
    1195  * Purpose   : The LoadKeyboardLayout function loads a new keyboard layout into
    1196  *             the system. Several keyboard layouts can be loaded at a time, but
    1197  *             only one per process is active at a time. Loading multiple keyboard
    1198  *             layouts makes it possible to rapidly switch between layouts.
    1199  * Parameters:
    1200  * Variables :
    1201  * Result    : If the function succeeds, the return value is the handle of the
    1202  *               keyboard layout.
    1203  *             If the function fails, the return value is NULL. To get extended
    1204  *               error information, call GetLastError.
    1205  * Remark    :
    1206  * Status    : UNTESTED STUB
    1207  *
    1208  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    1209  *****************************************************************************/
    1210 HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID,
    1211                                  UINT    Flags)
    1212 {
    1213   dprintf(("USER32:LeadKeyboardLayoutW (%s,%u) not implemented.\n",
    1214          pwszKLID,
    1215          Flags));
    1216 
    1217   return (NULL);
    1218 }
    1219 //******************************************************************************
    1220 //******************************************************************************
    1221 UINT WIN32API MapVirtualKeyA( UINT uCode, UINT  uMapType)
    1222 {
    1223     dprintf(("USER32:  MapVirtualKeyA\n"));
    1224     /* A quick fix for Commandos, very incomplete */
    1225     switch (uMapType) {
    1226     case 2:
    1227       if (uCode >= VK_A && uCode <= VK_Z) {
    1228          return 'A' + uCode - VK_A;
    1229       }
    1230       break;
    1231     }
    1232     return O32_MapVirtualKey(uCode,uMapType);
    1233 }
    1234 //******************************************************************************
    1235 //******************************************************************************
    1236 UINT WIN32API MapVirtualKeyW( UINT uCode, UINT  uMapType)
    1237 {
    1238     dprintf(("USER32:  MapVirtualKeyW\n"));
    1239     // NOTE: This will not work as is (needs UNICODE support)
    1240     return O32_MapVirtualKey(uCode,uMapType);
    1241 }
    1242 /*****************************************************************************
    1243  * Name      : UINT WIN32API MapVirtualKeyExA
    1244  * Purpose   : The MapVirtualKeyEx function translates (maps) a virtual-key
    1245  *             code into a scan code or character value, or translates a scan
    1246  *             code into a virtual-key code. The function translates the codes
    1247  *             using the input language and physical keyboard layout identified
    1248  *             by the given keyboard layout handle.
    1249  * Parameters:
    1250  * Variables :
    1251  * Result    : The return value is either a scan code, a virtual-key code, or
    1252  *             a character value, depending on the value of uCode and uMapType.
    1253  *             If there is no translation, the return value is zero.
    1254  * Remark    :
    1255  * Status    : UNTESTED STUB
    1256  *
    1257  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    1258  *****************************************************************************/
    1259 UINT WIN32API MapVirtualKeyExA(UINT uCode,
    1260                                   UINT uMapType,
    1261                                   HKL  dwhkl)
    1262 {
    1263   dprintf(("USER32:MapVirtualKeyExA (%u,%u,%08x) not implemented.\n",
    1264          uCode,
    1265          uMapType,
    1266          dwhkl));
    1267 
    1268   return (0);
    1269 }
    1270 /*****************************************************************************
    1271  * Name      : UINT WIN32API MapVirtualKeyExW
    1272  * Purpose   : The MapVirtualKeyEx function translates (maps) a virtual-key
    1273  *             code into a scan code or character value, or translates a scan
    1274  *             code into a virtual-key code. The function translates the codes
    1275  *             using the input language and physical keyboard layout identified
    1276  *             by the given keyboard layout handle.
    1277  * Parameters:
    1278  * Variables :
    1279  * Result    : The return value is either a scan code, a virtual-key code, or
    1280  *             a character value, depending on the value of uCode and uMapType.
    1281  *             If there is no translation, the return value is zero.
    1282  * Remark    :
    1283  * Status    : UNTESTED STUB
    1284 
    1285  *
    1286  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    1287  *****************************************************************************/
    1288 UINT WIN32API MapVirtualKeyExW(UINT uCode,
    1289                                   UINT uMapType,
    1290                                   HKL  dwhkl)
    1291 {
    1292   dprintf(("USER32:MapVirtualKeyExW (%u,%u,%08x) not implemented.\n",
    1293          uCode,
    1294          uMapType,
    1295          dwhkl));
    1296 
    1297   return (0);
    1298 }
    1299 /*****************************************************************************
    1300  * Name      : DWORD WIN32API OemKeyScan
    1301  * Purpose   : The OemKeyScan function maps OEM ASCII codes 0 through 0x0FF
    1302  *             into the OEM scan codes and shift states. The function provides
    1303  *             information that allows a program to send OEM text to another
    1304  *             program by simulating keyboard input.
    1305  * Parameters:
    1306  * Variables :
    1307  * Result    :
    1308  * Remark    :
    1309  * Status    : UNTESTED STUB
    1310  *
    1311  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    1312  *****************************************************************************/
    1313 DWORD WIN32API OemKeyScan(WORD wOemChar)
    1314 {
    1315   dprintf(("USER32:OemKeyScan (%u) not implemented.\n",
    1316          wOemChar));
    1317 
    1318   return (wOemChar);
    1319 }
    1320 //******************************************************************************
    1321 //******************************************************************************
    1322 BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
    1323 {
    1324   dprintf(("USER32:  RegisterHotKey, not implemented\n"));
    1325   hwnd = Win32ToOS2Handle(hwnd);
    1326   return(TRUE);
    1327 }
    1328 /*****************************************************************************
    1329  * Name      : BOOL WIN32API UnloadKeyboardLayout
    1330  * Purpose   : The UnloadKeyboardLayout function removes a keyboard layout.
    1331  * Parameters: HKL hkl handle of keyboard layout
    1332  * Variables :
    1333  * Result    : If the function succeeds, the return value is the handle of the
    1334  *             keyboard layout; otherwise, it is NULL. To get extended error
    1335  *             information, use the GetLastError function.
    1336  * Remark    :
    1337  * Status    : UNTESTED STUB
    1338  *
    1339  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    1340  *****************************************************************************/
    1341 BOOL WIN32API UnloadKeyboardLayout (HKL hkl)
    1342 {
    1343   dprintf(("USER32:UnloadKeyboardLayout (%08x) not implemented.\n",
    1344          hkl));
    1345 
    1346   return (0);
    1347 }
    1348 //******************************************************************************
    1349 //******************************************************************************
    1350 BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
    1351 {
    1352   dprintf(("USER32:  UnregisterHotKey, not implemented\n"));
    1353   hwnd = Win32ToOS2Handle(hwnd);
    1354 
    1355   return(TRUE);
    1356 }
    1357 //******************************************************************************
    1358 //SvL: 24-6-'97 - Added
    1359 //******************************************************************************
    1360 WORD WIN32API VkKeyScanA( char ch)
    1361 {
    1362     dprintf(("USER32: VkKeyScanA %x", ch));
    1363     return O32_VkKeyScan(ch);
    1364 }
    1365 //******************************************************************************
    1366 //******************************************************************************
    1367 WORD WIN32API VkKeyScanW( WCHAR wch)
    1368 {
    1369     dprintf(("USER32:  VkKeyScanW %x", wch));
    1370     // NOTE: This will not work as is (needs UNICODE support)
    1371     return O32_VkKeyScan((char)wch);
    1372 }
    1373 /*****************************************************************************
    1374  * Name      : SHORT WIN32API VkKeyScanExW
    1375  * Purpose   : The VkKeyScanEx function translates a character to the
    1376  *             corresponding virtual-key code and shift state. The function
    1377  *             translates the character using the input language and physical
    1378  *             keyboard layout identified by the given keyboard layout handle.
    1379  * Parameters: UINT uChar character to translate
    1380  *             HKL  hkl   keyboard layout handle
    1381  * Variables :
    1382  * Result    : see docs
    1383  * Remark    :
    1384  * Status    : UNTESTED STUB
    1385  *
    1386  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    1387  *****************************************************************************/
    1388 WORD WIN32API VkKeyScanExW(WCHAR uChar,
    1389                            HKL   hkl)
    1390 {
    1391   dprintf(("USER32:VkKeyScanExW (%u,%08x) not implemented.\n",
    1392          uChar,
    1393          hkl));
    1394 
    1395   return (uChar);
    1396 }
    1397 /*****************************************************************************
    1398  * Name      : SHORT WIN32API VkKeyScanExA
    1399  * Purpose   : The VkKeyScanEx function translates a character to the
    1400  *             corresponding virtual-key code and shift state. The function
    1401  *             translates the character using the input language and physical
    1402  *             keyboard layout identified by the given keyboard layout handle.
    1403  * Parameters: UINT uChar character to translate
    1404  *             HKL  hkl   keyboard layout handle
    1405  * Variables :
    1406  * Result    : see docs
    1407  * Remark    :
    1408  * Status    : UNTESTED STUB
    1409  *
    1410  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    1411  *****************************************************************************/
    1412 WORD WIN32API VkKeyScanExA(CHAR uChar,
    1413                            HKL  hkl)
    1414 {
    1415   dprintf(("USER32:VkKeyScanExA (%u,%08x) not implemented.\n",
    1416          uChar,
    1417          hkl));
    1418 
    1419   return (uChar);
    1420 }
    14211079
    14221080/* Window Functions */

  • TabularUnified trunk/src/user32/winkeyboard.cpp

    r6157 r6162  
    1 /* $Id: winkeyboard.cpp,v 1.11 2001-07-03 20:36:54 sandervl Exp $ */
     1/* $Id: winkeyboard.cpp,v 1.12 2001-07-04 06:39:01 sandervl Exp $ */
    22/*
    33 * Win32 <-> PM key translation
    … …  
    1515#include <heapstring.h>
    1616#include <pmscan.h>
     17#include <winuser32.h>
    1718
    1819#define DBG_LOCALLOG    DBG_winkeyboard
    … …  
    777778           if(uVirtKey >= VK_A && uVirtKey <= VK_Z) {
    778779               //NT returns key-0x60 (or so it seems) for ctrl-(shift-)-a..z
    779                if(shiftstate & TCF_SHIFT) {
     780               if(shiftstate & (TCF_SHIFT|TCF_CAPSLOCK)) {
    780781                    *(char *)lpwTransKey -= 0x40;
    781782               }
    … …  
    833834                       HKL    hkl)
    834835{
    835   dprintf(("USER32:ToAsciiEx (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
     836  dprintf(("USER32:ToAsciiEx (%u,%u,%08xh,%08xh,%u,%08x) partially implemented",
    836837         uVirtKey,
    837838         uScanCode,
    … …  
    841842         hkl));
    842843
    843   return (0);
     844  return ToAscii(uVirtKey, uScanCode, lpbKeyState, lpwTransKey, fuState);
    844845}
    845846/*****************************************************************************
    … …  
    893894  return (0);
    894895}
    895 //******************************************************************************
    896 //******************************************************************************
     896/*****************************************************************************
     897 * Name      : UINT WIN32API GetKBCodePage
     898 * Purpose   : The GetKBCodePage function is provided for compatibility with
     899 *             earlier versions of Windows. In the Win32 application programming
     900 *             interface (API) it just calls the GetOEMCP function.
     901 * Parameters:
     902 * Variables :
     903 * Result    : If the function succeeds, the return value is an OEM code-page
     904 *             identifier, or it is the default identifier if the registry
     905 *             value is not readable. For a list of OEM code-page identifiers,
     906 *             see GetOEMCP.
     907 * Remark    :
     908 * Status    : COMPLETELY IMPLEMENTED UNTESTED
     909 *
     910 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     911 *****************************************************************************/
     912
     913UINT WIN32API GetKBCodePage(VOID)
     914{
     915  return (GetOEMCP());
     916}
     917//******************************************************************************
     918//******************************************************************************
     919int WIN32API GetKeyNameTextA( LPARAM lParam, LPSTR lpString, int  nSize)
     920{
     921    dprintf(("USER32:  GetKeyNameTextA\n"));
     922    return O32_GetKeyNameText(lParam,lpString,nSize);
     923}
     924//******************************************************************************
     925//******************************************************************************
     926int WIN32API GetKeyNameTextW( LPARAM lParam, LPWSTR lpString, int  nSize)
     927{
     928    dprintf(("USER32:  GetKeyNameTextW DOES NOT WORK\n"));
     929    // NOTE: This will not work as is (needs UNICODE support)
     930    return 0;
     931//    return O32_GetKeyNameText(arg1, arg2, arg3);
     932}
     933//******************************************************************************
     934//******************************************************************************
     935SHORT WIN32API GetKeyState( int nVirtKey)
     936{
     937    dprintf2(("USER32: GetKeyState %x", nVirtKey));
     938    return O32_GetKeyState(nVirtKey);
     939}
     940//******************************************************************************
     941//******************************************************************************
     942WORD WIN32API GetAsyncKeyState(INT nVirtKey)
     943{
     944    dprintf2(("USER32: GetAsyncKeyState %x", nVirtKey));
     945    return O32_GetAsyncKeyState(nVirtKey);
     946}
     947//******************************************************************************
     948//******************************************************************************
     949UINT WIN32API MapVirtualKeyA( UINT uCode, UINT  uMapType)
     950{
     951    dprintf(("USER32: MapVirtualKeyA %x %x", uCode, uMapType));
     952    /* A quick fix for Commandos, very incomplete */
     953    switch (uMapType) {
     954    case 2:
     955      if (uCode >= VK_A && uCode <= VK_Z) {
     956         return 'A' + uCode - VK_A;
     957      }
     958      break;
     959    }
     960    return O32_MapVirtualKey(uCode,uMapType);
     961}
     962//******************************************************************************
     963//******************************************************************************
     964UINT WIN32API MapVirtualKeyW( UINT uCode, UINT  uMapType)
     965{
     966    dprintf(("USER32:  MapVirtualKeyW\n"));
     967    // NOTE: This will not work as is (needs UNICODE support)
     968    return O32_MapVirtualKey(uCode,uMapType);
     969}
     970/*****************************************************************************
     971 * Name      : UINT WIN32API MapVirtualKeyExA
     972 * Purpose   : The MapVirtualKeyEx function translates (maps) a virtual-key
     973 *             code into a scan code or character value, or translates a scan
     974 *             code into a virtual-key code. The function translates the codes
     975 *             using the input language and physical keyboard layout identified
     976 *             by the given keyboard layout handle.
     977 * Parameters:
     978 * Variables :
     979 * Result    : The return value is either a scan code, a virtual-key code, or
     980 *             a character value, depending on the value of uCode and uMapType.
     981 *             If there is no translation, the return value is zero.
     982 * Remark    :
     983 * Status    : UNTESTED STUB
     984 *
     985 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     986 *****************************************************************************/
     987UINT WIN32API MapVirtualKeyExA(UINT uCode, UINT uMapType, HKL  dwhkl)
     988{
     989  dprintf(("USER32:MapVirtualKeyExA (%u,%u,%08x) partially implemented",
     990         uCode,
     991         uMapType,
     992         dwhkl));
     993
     994  return MapVirtualKeyA(uCode, uMapType);
     995}
     996/*****************************************************************************
     997 * Name      : UINT WIN32API MapVirtualKeyExW
     998 * Purpose   : The MapVirtualKeyEx function translates (maps) a virtual-key
     999 *             code into a scan code or character value, or translates a scan
     1000 *             code into a virtual-key code. The function translates the codes
     1001 *             using the input language and physical keyboard layout identified
     1002 *             by the given keyboard layout handle.
     1003 * Parameters:
     1004 * Variables :
     1005 * Result    : The return value is either a scan code, a virtual-key code, or
     1006 *             a character value, depending on the value of uCode and uMapType.
     1007 *             If there is no translation, the return value is zero.
     1008 * Remark    :
     1009 * Status    : UNTESTED STUB
     1010 *
     1011 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     1012 *****************************************************************************/
     1013UINT WIN32API MapVirtualKeyExW(UINT uCode, UINT uMapType, HKL  dwhkl)
     1014{
     1015  dprintf(("USER32:MapVirtualKeyExW (%u,%u,%08x) partially implemented",
     1016          uCode, uMapType, dwhkl));
     1017
     1018  return MapVirtualKeyW(uCode, uMapType);
     1019}
     1020/*****************************************************************************
     1021 * Name      : DWORD WIN32API OemKeyScan
     1022 * Purpose   : The OemKeyScan function maps OEM ASCII codes 0 through 0x0FF
     1023 *             into the OEM scan codes and shift states. The function provides
     1024 *             information that allows a program to send OEM text to another
     1025 *             program by simulating keyboard input.
     1026 * Parameters:
     1027 * Variables :
     1028 * Result    :
     1029 * Remark    :
     1030 * Status    : UNTESTED STUB
     1031 *
     1032 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     1033 *****************************************************************************/
     1034DWORD WIN32API OemKeyScan(WORD wOemChar)
     1035{
     1036  dprintf(("USER32:OemKeyScan (%u) not implemented.\n",
     1037         wOemChar));
     1038
     1039  return (wOemChar);
     1040}
     1041//******************************************************************************
     1042//******************************************************************************
     1043BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
     1044{
     1045  dprintf(("USER32:  RegisterHotKey %x %d %x %x not implemented", hwnd, idHotKey, fuModifiers, uVirtKey));
     1046  hwnd = Win32ToOS2Handle(hwnd);
     1047  return(TRUE);
     1048}
     1049//******************************************************************************
     1050//******************************************************************************
     1051BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
     1052{
     1053  dprintf(("USER32:  UnregisterHotKey %x %d not implemented", hwnd, idHotKey));
     1054  hwnd = Win32ToOS2Handle(hwnd);
     1055
     1056  return(TRUE);
     1057}
     1058//******************************************************************************
     1059//SvL: 24-6-'97 - Added
     1060//******************************************************************************
     1061WORD WIN32API VkKeyScanA( char ch)
     1062{
     1063    dprintf(("USER32: VkKeyScanA %x", ch));
     1064    return O32_VkKeyScan(ch);
     1065}
     1066//******************************************************************************
     1067//******************************************************************************
     1068WORD WIN32API VkKeyScanW( WCHAR wch)
     1069{
     1070    dprintf(("USER32:  VkKeyScanW %x", wch));
     1071    // NOTE: This will not work as is (needs UNICODE support)
     1072    return O32_VkKeyScan((char)wch);
     1073}
     1074/*****************************************************************************
     1075 * Name      : SHORT WIN32API VkKeyScanExW
     1076 * Purpose   : The VkKeyScanEx function translates a character to the
     1077 *             corresponding virtual-key code and shift state. The function
     1078 *             translates the character using the input language and physical
     1079 *             keyboard layout identified by the given keyboard layout handle.
     1080 * Parameters: UINT uChar character to translate
     1081 *             HKL  hkl   keyboard layout handle
     1082 * Variables :
     1083 * Result    : see docs
     1084 * Remark    :
     1085 * Status    : UNTESTED STUB
     1086 *
     1087 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     1088 *****************************************************************************/
     1089WORD WIN32API VkKeyScanExW(WCHAR uChar,
     1090                           HKL   hkl)
     1091{
     1092  dprintf(("USER32:VkKeyScanExW (%u,%08x) partially implemented",
     1093          uChar,hkl));
     1094
     1095  return VkKeyScanW(uChar);
     1096}
     1097/*****************************************************************************
     1098 * Name      : SHORT WIN32API VkKeyScanExA
     1099 * Purpose   : The VkKeyScanEx function translates a character to the
     1100 *             corresponding virtual-key code and shift state. The function
     1101 *             translates the character using the input language and physical
     1102 *             keyboard layout identified by the given keyboard layout handle.
     1103 * Parameters: UINT uChar character to translate
     1104 *             HKL  hkl   keyboard layout handle
     1105 * Variables :
     1106 * Result    : see docs
     1107 * Remark    :
     1108 * Status    : UNTESTED STUB
     1109 *
     1110 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     1111 *****************************************************************************/
     1112WORD WIN32API VkKeyScanExA(CHAR uChar,
     1113                           HKL  hkl)
     1114{
     1115  dprintf(("USER32:VkKeyScanExA (%u,%08x) partially implemented",
     1116         uChar, hkl));
     1117
     1118  return VkKeyScanA(uChar);
     1119}
     1120/*****************************************************************************
     1121 * Name      : VOID WIN32API keybd_event
     1122 * Purpose   : The keybd_event function synthesizes a keystroke. The system
     1123 *             can use such a synthesized keystroke to generate a WM_KEYUP or
     1124 *             WM_KEYDOWN message. The keyboard driver's interrupt handler calls
     1125 *             the keybd_event function.
     1126 * Parameters: BYTE  bVk         virtual-key code
     1127
     1128 *             BYTE  bScan       hardware scan code
     1129 *             DWORD dwFlags     flags specifying various function options
     1130 *             DWORD dwExtraInfo additional data associated with keystroke
     1131 * Variables :
     1132 * Result    :
     1133 * Remark    :
     1134 * Status    : UNTESTED STUB
     1135 *
     1136 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     1137 *****************************************************************************/
     1138VOID WIN32API keybd_event (BYTE bVk,
     1139                           BYTE bScan,
     1140                           DWORD dwFlags,
     1141                           DWORD dwExtraInfo)
     1142{
     1143  dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
     1144         bVk,
     1145         bScan,
     1146         dwFlags,
     1147         dwExtraInfo));
     1148}
     1149/*****************************************************************************
     1150 * Name      : HLK WIN32API LoadKeyboardLayoutA
     1151 * Purpose   : The LoadKeyboardLayout function loads a new keyboard layout into
     1152 *             the system. Several keyboard layouts can be loaded at a time, but
     1153 *             only one per process is active at a time. Loading multiple keyboard
     1154 *             layouts makes it possible to rapidly switch between layouts.
     1155 * Parameters:
     1156 * Variables :
     1157 * Result    : If the function succeeds, the return value is the handle of the
     1158 *               keyboard layout.
     1159 *             If the function fails, the return value is NULL. To get extended
     1160 *               error information, call GetLastError.
     1161 * Remark    :
     1162 * Status    : UNTESTED STUB
     1163 *
     1164 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     1165 *****************************************************************************/
     1166HKL WIN32API LoadKeyboardLayoutA(LPCTSTR pwszKLID,
     1167                                 UINT    Flags)
     1168{
     1169  dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
     1170         pwszKLID,
     1171         Flags));
     1172
     1173  return (NULL);
     1174}
     1175/*****************************************************************************
     1176 * Name      : HLK WIN32API LoadKeyboardLayoutW
     1177 * Purpose   : The LoadKeyboardLayout function loads a new keyboard layout into
     1178 *             the system. Several keyboard layouts can be loaded at a time, but
     1179 *             only one per process is active at a time. Loading multiple keyboard
     1180 *             layouts makes it possible to rapidly switch between layouts.
     1181 * Parameters:
     1182 * Variables :
     1183 * Result    : If the function succeeds, the return value is the handle of the
     1184 *               keyboard layout.
     1185 *             If the function fails, the return value is NULL. To get extended
     1186 *               error information, call GetLastError.
     1187 * Remark    :
     1188 * Status    : UNTESTED STUB
     1189 *
     1190 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     1191 *****************************************************************************/
     1192HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID,
     1193                                 UINT    Flags)
     1194{
     1195  dprintf(("USER32:LeadKeyboardLayoutW (%s,%u) not implemented.\n",
     1196         pwszKLID,
     1197         Flags));
     1198
     1199  return (NULL);
     1200}
     1201//******************************************************************************
     1202//******************************************************************************
     1203BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
     1204{
     1205  dprintf(("USER32:  ActivateKeyboardLayout, not implemented\n"));
     1206  return(TRUE);
     1207}
     1208/*****************************************************************************
     1209 * Name      : BOOL WIN32API UnloadKeyboardLayout
     1210 * Purpose   : The UnloadKeyboardLayout function removes a keyboard layout.
     1211 * Parameters: HKL hkl handle of keyboard layout
     1212 * Variables :
     1213 * Result    : If the function succeeds, the return value is the handle of the
     1214 *             keyboard layout; otherwise, it is NULL. To get extended error
     1215 *             information, use the GetLastError function.
     1216 * Remark    :
     1217 * Status    : UNTESTED STUB
     1218 *
     1219 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
     1220 *****************************************************************************/
     1221BOOL WIN32API UnloadKeyboardLayout (HKL hkl)
     1222{
     1223  dprintf(("USER32:UnloadKeyboardLayout (%08x) not implemented.\n",
     1224         hkl));
     1225
     1226  return (0);
     1227}
     1228//******************************************************************************
     1229//******************************************************************************
Note: See TracChangeset for help on using the changeset viewer.