Ignore:
Timestamp:
Sep 24, 2001, 6:24:59 PM (24 years ago)
Author:
phaller
Message:

Added debug tracing support

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/user32/winkeyboard.cpp

    r6339 r6801  
    1 /* $Id: winkeyboard.cpp,v 1.14 2001-07-15 14:58:12 sandervl Exp $ */
     1/* $Id: winkeyboard.cpp,v 1.15 2001-09-24 16:24:59 phaller Exp $ */
    22/*
    33 * Win32 <-> PM key translation
    … …  
    77 *
    88 */
     9
     10#include <odin.h>
     11#include <odinwrap.h>
     12#include <os2sel.h>
     13
    914#include <os2win.h>
    10 #include <odin.h>
     15
    1116#include <string.h>
    1217#include <stdio.h>
    … …  
    2025#define DBG_LOCALLOG    DBG_winkeyboard
    2126#include "dbglocal.h"
     27
     28
     29
     30
     31ODINDEBUGCHANNEL(USER32-WINKBD)
     32
    2233
    2334BOOL OPEN32API _O32_GetKeyboardState( PBYTE lpKeyState );
    … …  
    561572//******************************************************************************
    562573//******************************************************************************
    563 void WIN32API KeyTranslatePMToWinBuf(BYTE *pmkey, BYTE *winkey, int nrkeys)
     574
     575ODINPROCEDURE3(KeyTranslatePMToWinBuf,
     576               BYTE *, pmkey,
     577               BYTE *, winkey,
     578               int,    nrkeys)
    564579{
    565580   for(int i=1;i<nrkeys;i++) {
    … …  
    574589//******************************************************************************
    575590//******************************************************************************
    576 int WIN32API GetKeyboardType( int nTypeFlag)
     591ODINFUNCTION1(int, GetKeyboardType,
     592              int, nTypeFlag)
    577593{
    578594    dprintf(("USER32: GetKeyboardType %x", nTypeFlag));
    … …  
    581597//******************************************************************************
    582598//******************************************************************************
    583 BOOL WIN32API GetKeyboardState(PBYTE lpKeyState)
     599ODINFUNCTION1(BOOL,  GetKeyboardState,
     600              PBYTE, lpKeyState)
    584601{
    585602 BYTE   PMKeyState[256];
    … …  
    612629//******************************************************************************
    613630//******************************************************************************
    614 BOOL WIN32API SetKeyboardState(PBYTE lpKeyState)
     631ODINFUNCTION1(BOOL,  SetKeyboardState,
     632              PBYTE, lpKeyState)
    615633{
    616634  dprintf(("USER32: SetKeyboardState %x not implemented", lpKeyState));
    … …  
    625643 */
    626644// * Remark    : Based on Wine version (991031)
    627 HKL WIN32API GetKeyboardLayout(DWORD dwLayout)
     645ODINFUNCTION1(HKL,   GetKeyboardLayout,
     646              DWORD, dwLayout)
    628647{
    629648        HKL layout;
    … …  
    647666 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    648667 *****************************************************************************/
    649 INT WIN32API GetKeyboardLayoutNameA(LPTSTR pwszKLID)
    650 {
    651    dprintf(("USER32:GetKeyboardLayoutNameA"));
     668ODINFUNCTION1(INT,   GetKeyboardLayoutNameA,
     669              LPSTR, pwszKLID)
     670{
     671   dprintf(("not correctly implemented"));
    652672
    653673   sprintf(pwszKLID, "%08x",GetKeyboardLayout(0));
    654674   return 1;
    655675}
     676
     677
    656678/*****************************************************************************
    657679 * Name      : BOOL WIN32API GetKeyboardLayoutNameW
    … …  
    668690 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    669691 *****************************************************************************/
    670 INT WIN32API GetKeyboardLayoutNameW(LPWSTR pwszKLID)
     692ODINFUNCTION1(INT,    GetKeyboardLayoutNameW,
     693              LPWSTR, pwszKLID)
    671694{
    672695   LPSTR buf = (LPSTR)HEAP_xalloc( GetProcessHeap(), 0, strlen("00000409")+1);
    673696
    674    dprintf(("USER32:GetKeyboardLayoutNameA"));
    675697   int res = GetKeyboardLayoutNameA(buf);
    676698   lstrcpyAtoW(pwszKLID,buf);
    … …  
    689711 * Remark    : Based on Wine version (991031)
    690712 */
    691 INT WINAPI GetKeyboardLayoutList(INT nBuff,HKL *layouts)
    692 {
    693         dprintf(("GetKeyboardLayoutList(%d,%p)\n",nBuff,layouts));
    694         if (!nBuff || !layouts)
    695             return 1;
    696     if (layouts)
    697         layouts[0] = GetKeyboardLayout(0);
     713ODINFUNCTION2(INT,   GetKeyboardLayoutList,
     714              INT,   nBuff,
     715              HKL *, layouts)
     716{
     717  dprintf(("not correctly implemented"));
     718 
     719  if (!nBuff || !layouts)
    698720    return 1;
     721 
     722  if (layouts)
     723    layouts[0] = GetKeyboardLayout(0);
     724 
     725  return 1;
    699726}
    700727/*****************************************************************************
    … …  
    720747 * Author    : SvL
    721748 *****************************************************************************/
    722 int WIN32API ToAscii(UINT   uVirtKey,
    723                      UINT   uScanCode,
    724                      PBYTE  lpbKeyState,
    725                      LPWORD lpwTransKey,
    726                      UINT   fuState)
    727 {
    728   dprintf(("USER32:ToAscii (%x,%x,%08xh,%08xh,%x) partially implemented",
    729            uVirtKey, uScanCode, lpbKeyState, lpwTransKey,  fuState));
    730 
     749
     750ODINFUNCTION5(int,    ToAscii,
     751              UINT,   uVirtKey,
     752              UINT,   uScanCode,
     753              PBYTE,  lpbKeyState,
     754              LPWORD, lpwTransKey,
     755              UINT,   fuState)
     756{
    731757  INT ret;
    732758
    … …  
    828854 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    829855 *****************************************************************************/
    830 int WIN32API ToAsciiEx(UINT   uVirtKey,
    831                        UINT   uScanCode,
    832                        PBYTE  lpbKeyState,
    833                        LPWORD lpwTransKey,
    834                        UINT   fuState,
    835                        HKL    hkl)
    836 {
    837   dprintf(("USER32:ToAsciiEx (%u,%u,%08xh,%08xh,%u,%08x) partially implemented",
    838          uVirtKey,
    839          uScanCode,
    840          lpbKeyState,
    841          lpwTransKey,
    842          fuState,
    843          hkl));
     856
     857ODINFUNCTION6(int,    ToAsciiEx,
     858              UINT,   uVirtKey,
     859              UINT,   uScanCode,
     860              PBYTE,  lpbKeyState,
     861              LPWORD, lpwTransKey,
     862              UINT,   fuState,
     863              HKL,    hkl)
     864{
     865  dprintf(("imcompletely implemented"));
    844866
    845867  return ToAscii(uVirtKey, uScanCode, lpbKeyState, lpwTransKey, fuState);
    … …  
    878900 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    879901 *****************************************************************************/
    880 int WIN32API ToUnicode(UINT   uVirtKey,
    881                           UINT   uScanCode,
    882                           PBYTE  lpKeyState,
    883                           LPWSTR pwszBuff,
    884                           int    cchBuff,
    885                           UINT   wFlags)
    886 {
    887   dprintf(("USER32:ToUnicode (%u,%u,%08xh,%08xh,%u,%08x) not implemented.\n",
    888          uVirtKey,
    889          uScanCode,
    890          lpKeyState,
    891          pwszBuff,
    892          cchBuff,
    893          wFlags));
     902
     903ODINFUNCTION6(int,    ToUnicode,
     904              UINT,   uVirtKey,
     905              UINT,   uScanCode,
     906              PBYTE,  lpKeyState,
     907              LPWSTR, pwszBuff,
     908              int,    cchBuff,
     909              UINT,   wFlags)
     910{
     911  dprintf(("not implemented.\n"));
    894912
    895913  return (0);
    … …  
    912930 *****************************************************************************/
    913931
    914 UINT WIN32API GetKBCodePage(VOID)
     932ODINFUNCTION0(UINT, GetKBCodePage)
    915933{
    916934  return (GetOEMCP());
    … …  
    918936//******************************************************************************
    919937//******************************************************************************
    920 int WIN32API GetKeyNameTextA( LPARAM lParam, LPSTR lpString, int  nSize)
    921 {
    922     dprintf(("USER32:  GetKeyNameTextA\n"));
    923     return O32_GetKeyNameText(lParam,lpString,nSize);
    924 }
    925 //******************************************************************************
    926 //******************************************************************************
    927 int WIN32API GetKeyNameTextW( LPARAM lParam, LPWSTR lpString, int  nSize)
    928 {
    929     dprintf(("USER32:  GetKeyNameTextW DOES NOT WORK\n"));
     938ODINFUNCTION3(int,    GetKeyNameTextA,
     939              LPARAM, lParam,
     940              LPSTR,  lpString,
     941              int,    nSize)
     942{
     943  return O32_GetKeyNameText(lParam,lpString,nSize);
     944}
     945//******************************************************************************
     946//******************************************************************************
     947ODINFUNCTION3(int,    GetKeyNameTextW,
     948              LPARAM, lParam,
     949              LPWSTR, lpString,
     950              int,    nSize)
     951{
     952    dprintf(("USER32:  GetKeyNameTextW DOES NOT WORK (not implemented)\n"));
    930953    // NOTE: This will not work as is (needs UNICODE support)
    931954    return 0;
    … …  
    934957//******************************************************************************
    935958//******************************************************************************
    936 SHORT WIN32API GetKeyState( int nVirtKey)
    937 {
    938     dprintf2(("USER32: GetKeyState %x", nVirtKey));
     959ODINFUNCTION1(SHORT, GetKeyState,
     960              int,   nVirtKey)
     961{
     962  return O32_GetKeyState(nVirtKey);
     963}
     964//******************************************************************************
     965//******************************************************************************
     966ODINFUNCTION1(WORD,  GetAsyncKeyState,
     967              INT,   nVirtKey)
     968{
     969  if(fVersionWarp3)
     970  {
     971    dprintf(("WARNING: not correctly implemented for Warp 3"));
     972    //Not present in Warp 3's PMWINX
    939973    return O32_GetKeyState(nVirtKey);
    940 }
    941 //******************************************************************************
    942 //******************************************************************************
    943 WORD WIN32API GetAsyncKeyState(INT nVirtKey)
    944 {
    945     dprintf2(("USER32: GetAsyncKeyState %x", nVirtKey));
    946     if(fVersionWarp3) {//Not present in Warp 3's PMWINX
    947           return O32_GetKeyState(nVirtKey);
    948     }
    949     else  return O32_GetAsyncKeyState(nVirtKey);
    950 }
    951 //******************************************************************************
    952 //******************************************************************************
    953 UINT WIN32API MapVirtualKeyA( UINT uCode, UINT  uMapType)
    954 {
    955     dprintf(("USER32: MapVirtualKeyA %x %x", uCode, uMapType));
    956     /* A quick fix for Commandos, very incomplete */
    957     switch (uMapType) {
     974  }
     975  else 
     976    return O32_GetAsyncKeyState(nVirtKey);
     977}
     978//******************************************************************************
     979//******************************************************************************
     980ODINFUNCTION2(UINT,  MapVirtualKeyA,
     981              UINT,  uCode,
     982              UINT,  uMapType)
     983{
     984  dprintf(("imcompletely implemented"));
     985  /* A quick fix for Commandos, very incomplete */
     986  switch (uMapType)
     987  {
    958988    case 2:
    959       if (uCode >= VK_A && uCode <= VK_Z) {
    960          return 'A' + uCode - VK_A;
     989      if (uCode >= VK_A && uCode <= VK_Z)
     990      {
     991        return 'A' + uCode - VK_A;
    961992      }
    962993      break;
    963     }
    964     return O32_MapVirtualKey(uCode,uMapType);
    965 }
    966 //******************************************************************************
    967 //******************************************************************************
    968 UINT WIN32API MapVirtualKeyW( UINT uCode, UINT  uMapType)
    969 {
    970     dprintf(("USER32:  MapVirtualKeyW\n"));
    971     // NOTE: This will not work as is (needs UNICODE support)
    972     return O32_MapVirtualKey(uCode,uMapType);
     994  }
     995  return O32_MapVirtualKey(uCode, uMapType);
     996}
     997//******************************************************************************
     998//******************************************************************************
     999ODINFUNCTION2(UINT,  MapVirtualKeyW,
     1000              UINT,  uCode,
     1001              UINT,  uMapType)
     1002{
     1003  dprintf(("incorrectly implemented\n"));
     1004 
     1005  // NOTE: This will not work as is (needs UNICODE support)
     1006  return O32_MapVirtualKey(uCode,uMapType);
    9731007}
    9741008/*****************************************************************************
    … …  
    9891023 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    9901024 *****************************************************************************/
    991 UINT WIN32API MapVirtualKeyExA(UINT uCode, UINT uMapType, HKL  dwhkl)
    992 {
    993   dprintf(("USER32:MapVirtualKeyExA (%u,%u,%08x) partially implemented",
    994          uCode,
    995          uMapType,
    996          dwhkl));
     1025ODINFUNCTION3(UINT,  MapVirtualKeyExA,
     1026              UINT,  uCode,
     1027              UINT,  uMapType,
     1028              HKL,   dwhkl)
     1029{
     1030  dprintf(("incompletely implemented"));
    9971031
    9981032  return MapVirtualKeyA(uCode, uMapType);
    … …  
    10151049 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    10161050 *****************************************************************************/
    1017 UINT WIN32API MapVirtualKeyExW(UINT uCode, UINT uMapType, HKL  dwhkl)
    1018 {
    1019   dprintf(("USER32:MapVirtualKeyExW (%u,%u,%08x) partially implemented",
    1020           uCode, uMapType, dwhkl));
     1051ODINFUNCTION3(UINT, MapVirtualKeyExW,
     1052              UINT, uCode,
     1053              UINT, uMapType,
     1054              HKL,  dwhkl)
     1055{
     1056  dprintf(("incompletely implemented"));
    10211057
    10221058  return MapVirtualKeyW(uCode, uMapType);
    … …  
    10361072 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    10371073 *****************************************************************************/
    1038 DWORD WIN32API OemKeyScan(WORD wOemChar)
    1039 {
    1040   dprintf(("USER32:OemKeyScan (%u) not implemented.\n",
    1041          wOemChar));
     1074ODINFUNCTION1(DWORD, OemKeyScan,
     1075              WORD,  wOemChar)
     1076{
     1077  dprintf(("not implemented.\n"));
    10421078
    10431079  return (wOemChar);
    … …  
    10451081//******************************************************************************
    10461082//******************************************************************************
    1047 BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers, UINT uVirtKey)
    1048 {
    1049   dprintf(("USER32:  RegisterHotKey %x %d %x %x not implemented", hwnd, idHotKey, fuModifiers, uVirtKey));
     1083ODINFUNCTION4(BOOL,  RegisterHotKey,
     1084              HWND,  hwnd,
     1085              int,   idHotKey,
     1086              UINT,  fuModifiers,
     1087              UINT,  uVirtKey)
     1088{
     1089  dprintf(("not implemented"));
     1090 
    10501091  hwnd = Win32ToOS2Handle(hwnd);
    10511092  return(TRUE);
    … …  
    10531094//******************************************************************************
    10541095//******************************************************************************
    1055 BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
    1056 {
    1057   dprintf(("USER32:  UnregisterHotKey %x %d not implemented", hwnd, idHotKey));
     1096ODINFUNCTION2(BOOL, UnregisterHotKey,
     1097              HWND, hwnd,
     1098              int,  idHotKey)
     1099{
     1100  dprintf(("not implemented"));
     1101 
    10581102  hwnd = Win32ToOS2Handle(hwnd);
    10591103
    10601104  return(TRUE);
    10611105}
     1106
    10621107//******************************************************************************
    10631108//SvL: 24-6-'97 - Added
    10641109//******************************************************************************
    1065 WORD WIN32API VkKeyScanA( char ch)
    1066 {
    1067     dprintf(("USER32: VkKeyScanA %x", ch));
    1068     return O32_VkKeyScan(ch);
    1069 }
    1070 //******************************************************************************
    1071 //******************************************************************************
    1072 WORD WIN32API VkKeyScanW( WCHAR wch)
    1073 {
    1074     dprintf(("USER32:  VkKeyScanW %x", wch));
    1075     // NOTE: This will not work as is (needs UNICODE support)
    1076     return O32_VkKeyScan((char)wch);
     1110ODINFUNCTION1(WORD, VkKeyScanA,
     1111              char, ch)
     1112{
     1113  return O32_VkKeyScan(ch);
     1114}
     1115//******************************************************************************
     1116//******************************************************************************
     1117ODINFUNCTION1(WORD,  VkKeyScanW,
     1118              WCHAR, wch)
     1119{
     1120  dprintf(("incorrectly implemented"));
     1121  // NOTE: This will not work as is (needs UNICODE support)
     1122  return O32_VkKeyScan((char)wch);
    10771123}
    10781124/*****************************************************************************
    … …  
    10911137 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    10921138 *****************************************************************************/
    1093 WORD WIN32API VkKeyScanExW(WCHAR uChar,
    1094                            HKL   hkl)
    1095 {
    1096   dprintf(("USER32:VkKeyScanExW (%u,%08x) partially implemented",
    1097           uChar,hkl));
     1139ODINFUNCTION2(WORD,  VkKeyScanExW,
     1140              WCHAR, uChar,
     1141              HKL,   hkl)
     1142{
     1143  dprintf(("partially implemented"));
    10981144
    10991145  return VkKeyScanW(uChar);
    … …  
    11141160 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    11151161 *****************************************************************************/
    1116 WORD WIN32API VkKeyScanExA(CHAR uChar,
    1117                            HKL  hkl)
    1118 {
    1119   dprintf(("USER32:VkKeyScanExA (%u,%08x) partially implemented",
    1120          uChar, hkl));
     1162ODINFUNCTION2(WORD, VkKeyScanExA,
     1163              CHAR, uChar,
     1164              HKL,  hkl)
     1165{
     1166  dprintf(("partially implemented"));
    11211167
    11221168  return VkKeyScanA(uChar);
    … …  
    11401186 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    11411187 *****************************************************************************/
    1142 VOID WIN32API keybd_event (BYTE bVk,
    1143                            BYTE bScan,
    1144                            DWORD dwFlags,
    1145                            DWORD dwExtraInfo)
    1146 {
    1147   dprintf(("USER32:keybd_event (%u,%u,%08xh,%08x) not implemented.\n",
    1148          bVk,
    1149          bScan,
    1150          dwFlags,
    1151          dwExtraInfo));
     1188ODINPROCEDURE4(keybd_event,
     1189               BYTE,  bVk,
     1190               BYTE,  bScan,
     1191               DWORD, dwFlags,
     1192               DWORD, dwExtraInfo)
     1193{
     1194  dprintf(("not implemented.\n"));
    11521195}
    11531196/*****************************************************************************
    … …  
    11681211 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    11691212 *****************************************************************************/
    1170 HKL WIN32API LoadKeyboardLayoutA(LPCTSTR pwszKLID,
    1171                                  UINT    Flags)
     1213ODINFUNCTION2(HKL,     LoadKeyboardLayoutA,
     1214              LPCSTR,  pwszKLID,
     1215              UINT,    Flags)
    11721216{
    11731217  dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
    … …  
    11941238 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    11951239 *****************************************************************************/
    1196 HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID,
    1197                                  UINT    Flags)
    1198 {
    1199   dprintf(("USER32:LeadKeyboardLayoutW (%s,%u) not implemented.\n",
     1240ODINFUNCTION2(HKL,     LoadKeyboardLayoutW,
     1241              LPCWSTR, pwszKLID,
     1242              UINT,    Flags)
     1243{
     1244  dprintf(("USER32:LoadKeyboardLayoutW (%ls,%u) not implemented.\n",
    12001245         pwszKLID,
    12011246         Flags));
    … …  
    12051250//******************************************************************************
    12061251//******************************************************************************
    1207 BOOL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
    1208 {
    1209   dprintf(("USER32:  ActivateKeyboardLayout, not implemented\n"));
     1252ODINFUNCTION2(BOOL,  ActivateKeyboardLayout,
     1253              HKL,   hkl,
     1254              UINT,  fuFlags)
     1255{
     1256  dprintf(("not implemented\n"));
    12101257  return(TRUE);
    12111258}
    … …  
    12231270 * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    12241271 *****************************************************************************/
    1225 BOOL WIN32API UnloadKeyboardLayout (HKL hkl)
    1226 {
    1227   dprintf(("USER32:UnloadKeyboardLayout (%08x) not implemented.\n",
    1228          hkl));
    1229 
    1230   return (0);
    1231 }
    1232 //******************************************************************************
    1233 //******************************************************************************
     1272ODINFUNCTION1(BOOL, UnloadKeyboardLayout,
     1273              HKL,  hkl)
     1274{
     1275  dprintf(("not implemented.\n"));
     1276
     1277  return (TRUE);
     1278}
     1279//******************************************************************************
     1280//******************************************************************************
Note: See TracChangeset for help on using the changeset viewer.