Changeset 21885 for branches/gcc-kmk/src/user32/winkeyboard.cpp

Timestamp:

Dec 15, 2011, 11:24:47 AM (14 years ago)

Author:

dmik

Message:

Fix crashes in GUI apps when pressing modifier keys.

This was due the fact that BYTE is signed in the toolkit and converting it
to an unsigned int causes the sign bit to be extended in the result while
the code assumes that the extension is made with zeroes (this is how
VAC converts signed integers of smaller precisions to unsigned ones).

File:

• branches/gcc-kmk/src/user32/winkeyboard.cpp (modified) (24 diffs)

branches/gcc-kmk/src/user32/winkeyboard.cpp

@@ -55 +55 @@
 
 
-BYTE abPMScanToWinVKey[256][2] =
+static UCHAR auchPMScanToWinVKey[256][2] =
 /****************************************************************************/
 /* PM Scancode              *    Win32 vkey                 Extended Key     */
@@ -320 +320 @@
 {
   /* index is the VKey value */
-  BYTE  bPMScanCode;
+  UCHAR  uchPMScanCode;
   LPCSTR lpstrName;
 } WINVKEYTOPMSCAN, *PWINVKEYTOPMSCAN;
 
-static WINVKEYTOPMSCAN abWinVKeyToPMScan[256] =
+static WINVKEYTOPMSCAN auchWinVKeyToPMScan[256] =
 /**********************************************************************/
 /* Vkey                   *    Scancode               * Name          */
@@ -592 +592 @@
 // Note: windows uses different scancodes if numlock is pressed
 // This is not (yet) reflected here!
-static BYTE abPMScanToWinScan[256][2] =
+static BYTE auchPMScanToWinScan[256][2] =
 /****************************************************************************/
 /* PM Scancode              *    Win32 Scancode             Extended Key     */
@@ -858 +858 @@
 //******************************************************************************
 
-VOID WIN32API KeyTranslatePMToWinBuf(BYTE *pmkey, BYTE *winkey,
+VOID WIN32API KeyTranslatePMToWinBuf(PUCHAR pmkey, PUCHAR winkey,
                                      int nrkeys)
 {
@@ -871 +871 @@
 
    for(int i=1;i<nrkeys;i++) {
-       if(abWinVKeyToPMScan[i].bPMScanCode) {
-            pmvkey = OSLibWinTranslateChar(abWinVKeyToPMScan[i].bPMScanCode, TC_SCANCODETOVIRTUALKEY, 0);
+       if(auchWinVKeyToPMScan[i].uchPMScanCode) {
+            pmvkey = OSLibWinTranslateChar(auchWinVKeyToPMScan[i].uchPMScanCode, TC_SCANCODETOVIRTUALKEY, 0);
             if(pmvkey == 0) {
-                dprintf2(("WinTranslateChar %x (%x) FAILED!!", i, abWinVKeyToPMScan[i].bPMScanCode));
+                dprintf2(("WinTranslateChar %x (%x) FAILED!!", i, auchWinVKeyToPMScan[i].uchPMScanCode));
             }
             winkey[i] = pmkey[pmvkey];
@@ -886 +886 @@
 //******************************************************************************
 //******************************************************************************
-BYTE KeyTranslateWinVKeyToPMScan(BYTE bWinVKey, BOOL fExtended)
+UCHAR KeyTranslateWinVKeyToPMScan(UCHAR uchWinVKey, BOOL fExtended)
 {
   // if the extended bit didn't match, this is
   // the closest hit
-  BYTE bAlmost = 0;
+  UCHAR uchAlmost = 0;
   
   // experiment
 
 #if 0
-  bAlmost = abWinVKeyToPMScan[bWinVKey].bPMScanCode;
+  bAlmost = auchWinVKeyToPMScan[bWinVKey].uchPMScanCode;
 #else
   for(int i = 0;
-      i < 256; // sizeof(row of abPMScanToWinVKey)
+      i < 256; // sizeof(row of auchPMScanToWinVKey)
       i++)
   {
-    if (abPMScanToWinVKey[i][0] == bWinVKey)
+    if (auchPMScanToWinVKey[i][0] == uchWinVKey)
     {
       // this represents the PMScan code which is used as index      
-      bAlmost = i;
+      uchAlmost = i;
       
       // exact match!
-      if (abPMScanToWinVKey[i][1] == fExtended)
+      if (auchPMScanToWinVKey[i][1] == fExtended)
         break;
     }
@@ -914 +914 @@
   
   dprintf(("KeyTranslateWinVKeyToPMScan(%02xh,%d) = %02xh",
-           bWinVKey,
+           uchWinVKey,
            fExtended,
-           bAlmost));
+           uchAlmost));
   
   // almost a match or no match at all.
-  return bAlmost; 
-}
-//******************************************************************************
-//******************************************************************************
-void KeyTranslatePMScanToWinVKey(BYTE bPMScan, 
+  return uchAlmost;
+}
+//******************************************************************************
+//******************************************************************************
+void KeyTranslatePMScanToWinVKey(UCHAR uchPMScan,
                                  BOOL bNumLock,
-                                 PBYTE pbWinVKey,
-                                 WORD* pwWinScan,
+                                 PUCHAR puchWinVKey,
+                                 WORD *pwWinScan,
                                  PBOOL pfExtended)
 {
   // @@@PH numlock is currently ignored
-  if (pbWinVKey)
-    *pbWinVKey = abPMScanToWinVKey[bPMScan][0];
+  if (puchWinVKey)
+    *puchWinVKey = auchPMScanToWinVKey[uchPMScan][0];
   
   if (pfExtended)
-    *pfExtended = abPMScanToWinVKey[bPMScan][1];
+    *pfExtended = auchPMScanToWinVKey[uchPMScan][1];
   
   if (pwWinScan)
-    *pwWinScan = abPMScanToWinScan[bPMScan][0];
-}
-//******************************************************************************
-//******************************************************************************
-BYTE KeyTranslateWinScanToPMScan(BYTE bWinScan, BOOL fExtended)
+    *pwWinScan = auchPMScanToWinScan[uchPMScan][0];
+}
+//******************************************************************************
+//******************************************************************************
+UCHAR KeyTranslateWinScanToPMScan(UCHAR uchWinScan, BOOL fExtended)
 {
   // Note:
@@ -949 +949 @@
   // if the extended bit didn't match, this is
   // the closest hit
-  BYTE bAlmost = 0;
+  UCHAR uchAlmost = 0;
   
   for(int i = 0;
-      i < 256; // sizeof(row of abPMScanToWinVKey)
+      i < 256; // sizeof(row of auchPMScanToWinVKey)
       i++)
   {
-    if (abPMScanToWinScan[i][0] == bWinScan)
+    if (auchPMScanToWinScan[i][0] == uchWinScan)
     {
       // this represents the PMScan code which is used as index      
-      bAlmost = i;
+      uchAlmost = i;
       
       // exact match!
-      if (abPMScanToWinVKey[i][1] == fExtended)
+      if (auchPMScanToWinVKey[i][1] == fExtended)
         break;
     }
@@ -967 +967 @@
   
   dprintf(("KeyTranslateWinScanToPMScan(%02xh,%d) = %02xh",
-           bWinScan,
+           uchWinScan,
            fExtended,
-           bAlmost));
+           uchAlmost));
   
   // almost a match or no match at all.
-  return bAlmost; 
-  
-}
-//******************************************************************************
-//******************************************************************************
-BYTE KeyTranslatePMScanToWinScan(BYTE bPMScan)
+  return uchAlmost;
+  
+}
+//******************************************************************************
+//******************************************************************************
+UCHAR KeyTranslatePMScanToWinScan(UCHAR bPMScan)
 {
   // Note:
@@ -983 +983 @@
   // O32_MapVirtualKeyA uses PM Scancodes only!
   
-  return abPMScanToWinScan[bPMScan][0];
+  return auchPMScanToWinScan[bPMScan][0];
 }
 //******************************************************************************
@@ -1026 +1026 @@
    }
    for(int i=0;i<256;i++) {
-       if(abWinVKeyToPMScan[i].bPMScanCode) {
-           lpKeyState[i] = PMScanState[abWinVKeyToPMScan[i].bPMScanCode];
+       if(auchWinVKeyToPMScan[i].uchPMScanCode) {
+           lpKeyState[i] = PMScanState[auchWinVKeyToPMScan[i].uchPMScanCode];
        }
        if(lpKeyState[i] & 0x80) {
@@ -1372 +1372 @@
   BOOL  fDontCare = (lParam & WIN_KEY_DONTCARE) != 0;
   BOOL  fExtended = (lParam & WIN_KEY_EXTENDED) != 0,PMExtended;
-  UCHAR ucWinScan = (lParam & 0x00ff0000) >> 16;
-  UCHAR ucWinVKey;
-  UCHAR ucPMScan;
+  UCHAR uchWinScan = (lParam & 0x00ff0000) >> 16;
+  UCHAR uchWinVKey;
+  UCHAR uchPMScan;
   int   result;
   
@@ -1389 +1389 @@
   // Note: Open32 expects PM Scancodes, NOT Winscancodes.
   // Note: this is the only way of loss-less conversion!
-  ucPMScan = KeyTranslateWinScanToPMScan(ucWinScan, fExtended);
+  uchPMScan = KeyTranslateWinScanToPMScan(uchWinScan, fExtended);
   dprintf(("ucWinScan=%02xh, fExtended=%d translated to PMscan=%02xh\n",
-           ucWinScan,
+           uchWinScan,
            fExtended,
-           ucPMScan));
-  ucWinVKey = abPMScanToWinVKey[ucPMScan][0];
-  PMExtended = abPMScanToWinVKey[ucPMScan][1];
+           uchPMScan));
+  uchWinVKey = auchPMScanToWinVKey[uchPMScan][0];
+  PMExtended = auchPMScanToWinVKey[uchPMScan][1];
 
   dprintf(("ucPMScan=%02xh translated to ucWinVKey=%02xh PMExtended=%d\n",
-           ucPMScan,
-           ucWinVKey,PMExtended));
+           uchPMScan,
+           uchWinVKey,PMExtended));
 
   // Bug in Open32:
@@ -1410 +1410 @@
   
   LPCSTR lpstrKey;
-  lpstrKey = abWinVKeyToPMScan[ucWinVKey].lpstrName;
+  lpstrKey = auchWinVKeyToPMScan[uchWinVKey].lpstrName;
 
   // handle Enter on Numeric Keypad here
   if (PMExtended) 
   {
-   if (ucWinVKey==VK_RETURN) lpstrKey = lpstrNumEnter;
+   if (uchWinVKey==VK_RETURN) lpstrKey = lpstrNumEnter;
   }
 
@@ -1421 +1421 @@
   {
     dprintf(("ERROR: keyname for winscan=%02xh winvkey=%02xh, fExtended=%d not found.\n",
-             ucWinScan, ucWinVKey, fExtended & !fDontCare));
+             uchWinScan, uchWinVKey, fExtended & !fDontCare));
     
     // build artificial name
@@ -1428 +1428 @@
     sprintf(szName, 
             "VKey%02x%c",
-            ucWinScan,
+            uchWinScan,
             fExtended ? '+' : 0);
     memcpy(lpString, szName, nSize);
@@ -1505 +1505 @@
   //O32_GetKeyState converts windows virtual keys to PM virtual keys and there
   //are far fewer PM vkeys. (e.g. 0-9, A-Z will fail)
-  if(nVirtKey < 256 && abWinVKeyToPMScan[nVirtKey].bPMScanCode) 
+  if(nVirtKey < 256 && auchWinVKeyToPMScan[nVirtKey].uchPMScanCode)
   {
       INT  nVirtKey2 = 0;
@@ -1512 +1512 @@
       if (nVirtKey == VK_CONTROL || nVirtKey == VK_LCONTROL) 
       {//if AltGr is down, then pretend VK_LCONTROL is down too
-          result = OSLibWinGetScanState(abWinVKeyToPMScan[VK_RMENU].bPMScanCode);
+          result = OSLibWinGetScanState(auchWinVKeyToPMScan[VK_RMENU].uchPMScanCode);
           if(result & 0x8000) {
               return result;
@@ -1521 +1521 @@
       if ((nVirtKey >= VK_PRIOR) && (nVirtKey <= VK_DELETE))
       {
-         WORD numState = OSLibWinGetScanState(abWinVKeyToPMScan[VK_NUMLOCK].bPMScanCode) & 1;
+         WORD numState = OSLibWinGetScanState(auchWinVKeyToPMScan[VK_NUMLOCK].uchPMScanCode) & 1;
 
          if(!numState) {
@@ -1545 +1545 @@
           nVirtKey2 = VK_RSHIFT;
       }
-      result = OSLibWinGetScanState(abWinVKeyToPMScan[nVirtKey].bPMScanCode);
+      result = OSLibWinGetScanState(auchWinVKeyToPMScan[nVirtKey].uchPMScanCode);
       if(nVirtKey2) {
-          result |= OSLibWinGetScanState(abWinVKeyToPMScan[nVirtKey2].bPMScanCode);
+          result |= OSLibWinGetScanState(auchWinVKeyToPMScan[nVirtKey2].uchPMScanCode);
       }
       return result;
@@ -1577 +1577 @@
   //O32_GetAsyncKeyState converts windows virtual keys to PM virtual keys and there
   //are far fewer PM vkeys. (e.g. 0-9, A-Z will fail)
-  if(nVirtKey < 256 && abWinVKeyToPMScan[nVirtKey].bPMScanCode) 
+  if(nVirtKey < 256 && auchWinVKeyToPMScan[nVirtKey].uchPMScanCode)
   {
       INT  nVirtKey2 = 0;
@@ -1584 +1584 @@
       if (nVirtKey == VK_CONTROL || nVirtKey == VK_LCONTROL) 
       {//if AltGr is down, then pretend VK_LCONTROL is down too
-          result = OSLibWinGetPhysKeyState(abWinVKeyToPMScan[VK_RMENU].bPMScanCode);
+          result = OSLibWinGetPhysKeyState(auchWinVKeyToPMScan[VK_RMENU].uchPMScanCode);
           if(result & 0x8000) {
               return result;
@@ -1593 +1593 @@
       if ((nVirtKey >= VK_PRIOR) && (nVirtKey <= VK_DELETE))
       {
-         WORD numState = OSLibWinGetScanState(abWinVKeyToPMScan[VK_NUMLOCK].bPMScanCode) & 1;
+         WORD numState = OSLibWinGetScanState(auchWinVKeyToPMScan[VK_NUMLOCK].uchPMScanCode) & 1;
 
          if(!numState) {
@@ -1618 +1618 @@
       }
 
-      result = OSLibWinGetPhysKeyState(abWinVKeyToPMScan[nVirtKey].bPMScanCode);
+      result = OSLibWinGetPhysKeyState(auchWinVKeyToPMScan[nVirtKey].uchPMScanCode);
       if(nVirtKey2) {
-          result |= OSLibWinGetPhysKeyState(abWinVKeyToPMScan[nVirtKey2].bPMScanCode);
+          result |= OSLibWinGetPhysKeyState(auchWinVKeyToPMScan[nVirtKey2].uchPMScanCode);
       }
       return result;