Merge pull request #1714 from maisvendoo/master-RRS-winkeys

Fixed incorrect keyboard events process in win32 subsystem

Author: robertosfield

.gitignore

@@ -84,4 +84,5 @@ DerivedData/
 include/glslang
 src/vsg/CHANGES.md
 src/vsg/vsgTargets.cmake
-
+*.txt.user
+*.txt.user.*

include/vsg/platform/win32/Win32_Window.h

@@ -40,93 +40,91 @@ namespace vsgWin32
         {
             uint16_t modifierMask = 0;
 
-            // see https://learn.microsoft.com/en-us/windows/win32/inputdev/about-keyboard-input#keystroke-message-flags
-            WORD keyFlags = HIWORD(lParam);
-            WORD scanCode = LOBYTE(keyFlags);                             // scan code
-            BOOL isExtendedKey = (keyFlags & KF_EXTENDED) == KF_EXTENDED; // extended-key flag, 1 if scancode has 0xE0 prefix
+            // Get scancode
+            uint16_t keyFlags = HIWORD(lParam);
+            uint16_t scanCode = LOBYTE(lParam);
+            bool isExtendedKey = (keyFlags & KF_EXTENDED) == KF_EXTENDED;
 
             if (isExtendedKey)
+            {
                 scanCode = MAKEWORD(scanCode, 0xE0);
+            }
+
+            // Get virtual key code
+            uint32_t virtualKey = static_cast<uint32_t>(wParam);
+
+            // Left and right modifier detection
+            if (virtualKey == VK_SHIFT)
+            {
+                virtualKey = (scanCode == 0x2A) ? VK_RSHIFT : VK_LSHIFT;
+            }
+            else if (virtualKey == VK_CONTROL)
+            {
+                virtualKey = isExtendedKey ? VK_RCONTROL : VK_LCONTROL;
+            }
+            else if (virtualKey == VK_MENU)
+            {
+                virtualKey = isExtendedKey ? VK_RMENU : VK_LMENU;
+            }
 
-            uint32_t virtualKey = ::MapVirtualKeyEx(scanCode, MAPVK_VSC_TO_VK_EX, ::GetKeyboardLayout(0));
             auto itr = _vk2vsg.find(virtualKey);
 
             if (itr == _vk2vsg.end())
             {
-                // What ever the code was in lParam should translate to a Virtual Key that we know of in _vk2vsg
-                // If we cannot find it, we simply return.
                 return false;
             }
 
-            // This is the base-key that was pressed. (i.e., the VSG enum of the physical key pressed).
             keySymbol = itr->second;
 
-            // Look for any modifiers that may be active.
+            // Get keys state
             BYTE keyState[256];
-            if (virtualKey == 0 || !::GetKeyboardState(keyState))
-            {
-                // if virtualKey was undefined or we could not get the keyboard state, simply return.
-                return false;
-            }
 
-            // If any of the specific left/right modifier keys are active
-            // add the side-independent vsg modifier to the modifier Mask
-            switch (virtualKey)
+            if (!::GetKeyboardState(keyState))
             {
-            case VK_LSHIFT:
-            case VK_RSHIFT:
-                modifierMask |= vsg::KeyModifier::MODKEY_Shift;
-                break;
-
-            case VK_LCONTROL:
-            case VK_RCONTROL:
-                modifierMask |= vsg::KeyModifier::MODKEY_Control;
-                break;
-
-            case VK_LMENU:
-            case VK_RMENU:
-                modifierMask |= vsg::KeyModifier::MODKEY_Alt;
-                break;
-
-            default:
-                virtualKey = static_cast<uint32_t>(wParam);
-                break;
+                return false;
             }
 
-            // Check if caps lock or numlock is toggled.
+            // Modifier's flags setting
+            if (keyState[VK_SHIFT] & 0x80) modifierMask |= vsg::KeyModifier::MODKEY_Shift;
+            if (keyState[VK_CONTROL] & 0x80) modifierMask |= vsg::KeyModifier::MODKEY_Control;
+            if (keyState[VK_MENU] & 0x80) modifierMask |= vsg::KeyModifier::MODKEY_Alt;
             if (keyState[VK_CAPITAL] & 0x01) modifierMask |= vsg::KeyModifier::MODKEY_CapsLock;
             if (keyState[VK_NUMLOCK] & 0x01) modifierMask |= vsg::KeyModifier::MODKEY_NumLock;
 
-            // Check if the modifier keys are down (these are non-toggle keys, so the high-order bit is relevant!)
-            // again, vsg only has a side-independent modifier
-            if (keyState[VK_LSHIFT] & 0x80) modifierMask |= vsg::KeyModifier::MODKEY_Shift;
-            if (keyState[VK_RSHIFT] & 0x80) modifierMask |= vsg::KeyModifier::MODKEY_Shift;
-            if (keyState[VK_LCONTROL] & 0x80) modifierMask |= vsg::KeyModifier::MODKEY_Control;
-            if (keyState[VK_RCONTROL] & 0x80) modifierMask |= vsg::KeyModifier::MODKEY_Control;
-            if (keyState[VK_LMENU] & 0x80) modifierMask |= vsg::KeyModifier::MODKEY_Alt;
-            if (keyState[VK_RMENU] & 0x80) modifierMask |= vsg::KeyModifier::MODKEY_Alt;
-
-            // This is the final keyModifier
             keyModifier = static_cast<vsg::KeyModifier>(modifierMask);
 
-            // The actual keystroke is what we get after the ::ToAscii call
-            char asciiKey[2];
-            int32_t numChars = ::ToAsciiEx(static_cast<UINT>(wParam), scanCode, keyState, reinterpret_cast<WORD*>(asciiKey), 0, ::GetKeyboardLayout(0));
+            // Get Unicode symbol
+            wchar_t unicodeChar[2] = {0};
+            int numChars = ::ToUnicodeEx(virtualKey, scanCode, keyState, unicodeChar, 2, 0, ::GetKeyboardLayout(0));
+
             if (numChars == 1)
             {
-                // it is indeed an ascii character. 0-127
-                modifiedKeySymbol = static_cast<vsg::KeySymbol>(asciiKey[0]);
+                wchar_t ch = unicodeChar[0];
+
+                modifiedKeySymbol = mapCharToKeySymbol(ch);
             }
             else
             {
-                // otherwise treat the modifiedKeySymbol as the same as the keySymbol.
                 modifiedKeySymbol = keySymbol;
             }
 
             return true;
         }
 
     protected:
+
+        vsg::KeySymbol mapCharToKeySymbol(wchar_t ch)
+        {
+            // Special characters (with and without Shift)
+            switch (ch)
+            {
+            case L'\t': return vsg::KEY_Tab;
+            case L'\r': return vsg::KEY_Return;
+            }
+
+            return static_cast<vsg::KeySymbol>(ch);
+        }
+
         VirtualKeyToKeySymbolMap _vk2vsg;
     };