Changeset 53221 in vbox for trunk/src/VBox/Frontends

Timestamp:

Nov 5, 2014 9:09:40 AM (10 years ago)

Author:

vboxsync

Message:

FE/Qt: win: improved AltGr handling.

Location:

trunk/src/VBox/Frontends/VirtualBox/src

Files:

• platform/win/WinKeyboard.cpp (modified) (1 diff)
• platform/win/WinKeyboard.h (modified) (1 diff)
• runtime/UIKeyboardHandler.cpp (modified) (8 diffs)
• runtime/UIKeyboardHandler.h (modified) (3 diffs)
• widgets/UIHostComboEditor.cpp (modified) (5 diffs)
• widgets/UIHostComboEditor.h (modified) (2 diffs)

trunk/src/VBox/Frontends/VirtualBox/src/platform/win/WinKeyboard.cpp

@@ -171 +171 @@
         LogRel2(("HID LEDs sync: broadcast failed\n"));
 }
+
+/** @brief doesCurrentLayoutHaveAltGr
+  *
+  * @return true if this keyboard layout has an AltGr key, false otherwise
+  * Check to see whether the current keyboard layout actually has an AltGr key
+  * by checking whether any of the keys which might do produce a symbol when
+  * AltGr (Control + Alt) is depressed. Generally this loop will exit pretty
+  * early (it exits on the first iteration for my German layout). If there is
+  * no AltGr key in the layout then it will run right through, but that should
+  * hopefully not happen very often.
+  * 
+  * In theory we could do this once and cache the result, but that involves
+  * tracking layout switches to invalidate the cache, and I don't think that the
+  * added complexity is worth the price. */
+static bool doesCurrentLayoutHaveAltGr()
+{
+    /** Keyboard state array with VK_CONTROL and VK_MENU depressed. */
+    const BYTE auKeyStates[256] =
+        { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x80, 0x80 };
+    WORD ach;
+    unsigned i;
+
+    for (i = '0'; i <= VK_OEM_102; ++i)
+    {
+        if (ToAscii(i, 0, auKeyStates, &ach, 0))
+            break;
+        /* Skip ranges of virtual keys which are undefined or not relevant. */
+        if (i == '9')
+            i = 'A' - 1;
+        if (i == 'Z')
+            i = VK_OEM_1 - 1;
+        if (i == VK_OEM_3)
+            i = VK_OEM_4 - 1;
+        if (i == VK_OEM_8)
+            i = VK_OEM_102 - 1;
+    }
+    if (i > VK_OEM_102)
+        return false;
+    return true;
+}
+
+void WinAltGrMonitor::updateStateFromKeyEvent(unsigned iDownScanCode,
+                                              bool fKeyDown, bool fExtendedKey)
+{
+    LONG messageTime = GetMessageTime();
+    /* We do not want the make/break: */
+    AssertRelease(~iDownScanCode & 0x80);
+    /* Depending on m_enmFakeControlDetectionState: */
+    switch (m_enmFakeControlDetectionState)
+    {
+        case NONE:
+        case FAKE_CONTROL_DOWN:
+            if (   iDownScanCode == 0x1D /* left control */
+                && fKeyDown
+                && !fExtendedKey)
+                m_enmFakeControlDetectionState = LAST_EVENT_WAS_LEFT_CONTROL_DOWN;
+            else
+                m_enmFakeControlDetectionState = NONE;
+            break;
+        case LAST_EVENT_WAS_LEFT_CONTROL_DOWN:
+            if (   iDownScanCode == 0x38 /* Alt */
+                && fKeyDown
+                && fExtendedKey
+                && m_timeOfLastKeyEvent == messageTime
+                && doesCurrentLayoutHaveAltGr())
+            {
+                m_enmFakeControlDetectionState = FAKE_CONTROL_DOWN;
+                break;
+            }
+            else
+                m_enmFakeControlDetectionState = LEFT_CONTROL_DOWN;
+            /* Fall through. */
+        case LEFT_CONTROL_DOWN:
+            if (   iDownScanCode == 0x1D /* left control */
+                && !fKeyDown
+                && !fExtendedKey)
+                m_enmFakeControlDetectionState = NONE;
+            break;
+        default:
+            AssertReleaseMsgFailed(("Unknown AltGr detection state.\n"));
+    }
+    m_timeOfLastKeyEvent = messageTime;
+}
+
+bool WinAltGrMonitor::isLeftControlReleaseNeeded() const
+{
+    return m_enmFakeControlDetectionState == FAKE_CONTROL_DOWN;
+}
+
+bool WinAltGrMonitor::isCurrentEventDefinitelyFake(unsigned iDownScanCode,
+                                                   bool fKeyDown,
+                                                   bool fExtendedKey) const
+{
+    MSG peekMsg;
+    LONG messageTime = GetMessageTime();
+
+    if (   iDownScanCode != 0x1d /* scan code: Control */ || fExtendedKey)
+        return false;
+    if (!PeekMessage(&peekMsg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_NOREMOVE))
+        return false;
+
+                if (   fKeyDown
+        && (peekMsg.message != WM_KEYDOWN && peekMsg.message != WM_SYSKEYDOWN))
+        return false;
+    if (   !fKeyDown
+        && (peekMsg.message != WM_KEYUP && peekMsg.message != WM_SYSKEYUP))
+        return false;
+    if (   ((RT_HIWORD(peekMsg.lParam) & 0xFF) != 0x38 /* scan code: Alt */)
+        || !(RT_HIWORD(peekMsg.lParam) & KF_EXTENDED))
+        return false;
+    if (!doesCurrentLayoutHaveAltGr())
+        return false;
+    return true;
+}

trunk/src/VBox/Frontends/VirtualBox/src/platform/win/WinKeyboard.h

@@ -28 +28 @@
 bool winHidLedsInSync(bool fNumLockOn, bool fCapsLockOn, bool fScrollLockOn);
 
+/** Helper class to deal with Windows AltGr handling.
+  *
+  * Background: Windows sends AltGr key down and up events as two events: a
+  * left control event and a right alt one.  Since the left control event does
+  * not correspond to actually pressing or releasing the left control key we
+  * would like to detect it and handle it.  This class monitors all key down and
+  * up events and if it detects that a left control down event has been sendt
+  * although left control should be up it tells us to insert a left control up
+  * event into the event stream.  While this does not let us filter out the
+  * unwanted event at source, it should still make guest system keyboard handling
+  * work correctly. */
+class WinAltGrMonitor
+{
+public:
+
+    /** Constructor. */
+    WinAltGrMonitor() : m_enmFakeControlDetectionState(NONE), m_timeOfLastKeyEvent(0) {}
+
+    /** All key events should be fed to this method.
+      * @param iDownScanCode the scan code stripped of the make/break bit
+      * @param fKeyDown      is this a key down event?
+      * @param fExtended     is this an extended scan code? */
+    void updateStateFromKeyEvent(unsigned iDownScanCode, bool fKeyDown, bool fExtended);
+
+    /** Do we need to insert a left control up into the stream? */
+    bool isLeftControlReleaseNeeded() const;
+
+    /** Can we tell for sure at this point that the current message is a fake
+     * control event?  This method might fail to recognise a fake event, but
+     * should never incorrectly flag a non-fake one.
+     * @note We deliberately do not call this from the host combination editor
+     *       in an attempt to ensure that the other code path also gets enough
+     *       test coverage.
+     */
+    bool isCurrentEventDefinitelyFake(unsigned iDownScanCode,
+                                      bool fKeyDown,
+                                      bool fExtendedKey) const;
+
+private:
+
+    /** State detection for fake control events which we may have missed. */
+    enum
+    {
+        /** No interesting state. */
+        NONE,
+        /** The last keypress might be a fake control. */
+        LAST_EVENT_WAS_LEFT_CONTROL_DOWN,
+        /** Left control is down, so we ignore fake control events. */
+        LEFT_CONTROL_DOWN,
+        /** A fake control down event and no up was passed to the guest. */
+        FAKE_CONTROL_DOWN
+    } m_enmFakeControlDetectionState;
+    DWORD m_timeOfLastKeyEvent;
+};
 #endif /* __WinKeyboard_h__ */
 

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIKeyboardHandler.cpp

@@ -72 +72 @@
 #endif /* Q_WS_MAC */
 
-
+#ifdef Q_WS_WIN
+# include "WinKeyboard.h"
+#endif /* Q_WS_WIN */
+ 
 /* Enums representing different keyboard-states: */
 enum { KeyExtended = 0x01, KeyPressed = 0x02, KeyPause = 0x04, KeyPrint = 0x08 };
@@ -413 +416 @@
 }
 
-/**
- * @brief isSyntheticLCtrl
- * @param   pMsg  Windows WM_[SYS]KEY* event message structure
- * @return  true if this is a synthetic LCtrl event, false otherwise
- * This function is a heuristic to tell whether a key event is the first in
- * a synthetic LCtrl+RAlt sequence which Windows uses to signal AltGr.  Our
- * heuristic is in two parts.  First of all, we check whether there is a pending
- * RAlt key event matching this LCtrl event (i.e. both key up or both key down)
- * and if there is, we check whether the current layout has an AltGr key.  We
- * check this by looking to see if any of the layout-dependent keys has a symbol
- * associated when AltGr is pressed.
- */
-static bool isSyntheticLCtrl(MSG *pMsg)
-{
-    MSG peekMsg;
-    /** Keyboard state array with VK_CONTROL and VK_MENU depressed. */
-    const BYTE auKeyStates[256] =
-    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x80, 0x80 };
-    WORD ach;
-    unsigned i;
-
-    Assert(   pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN
-           || pMsg->message == WM_KEYUP || pMsg->message == WM_SYSKEYUP);
-    if (   ((RT_HIWORD(pMsg->lParam) & 0xFF) != 0x1d /* scan code: Control */)
-        || RT_HIWORD(pMsg->lParam) & KF_EXTENDED)
-        return false;
-    if (!PeekMessage(&peekMsg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_NOREMOVE))
-        return false;
-    if (   (pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN)
-        && (peekMsg.message != WM_KEYDOWN && peekMsg.message != WM_SYSKEYDOWN))
-        return false;
-    if (   (pMsg->message == WM_KEYUP || pMsg->message == WM_SYSKEYUP)
-        && (peekMsg.message != WM_KEYUP && peekMsg.message != WM_SYSKEYUP))
-        return false;
-    if (   ((RT_HIWORD(peekMsg.lParam) & 0xFF) != 0x38 /* scan code: Alt */)
-        || !(RT_HIWORD(peekMsg.lParam) & KF_EXTENDED))
-        return false;
-    /* If we got this far then we have a key event which could potentially
-     * be a synthetic left control.  Now we check to see whether the current
-     * keyboard layout actually has an AltGr key by checking whether any of
-     * the keys which might do produce a symbol when AltGr (Control + Alt) is
-     * depressed.  Generally this loop will exit pretty early (it exits on the
-     * first iteration for my German layout).  If there is no AltGr key in the
-     * layout then it will run right through, but that should not happen very
-     * often as we should hardly ever reach the loop in that case.
-     *
-     * In theory we could do this once and cache the result, but that involves
-     * tracking layout switches to invalidate the cache, and I don't think
-     * that the added complexity is worth the price.
-     */
-    for (i = '0'; i <= VK_OEM_102; ++i)
-    {
-        if (ToAscii(i, 0, auKeyStates, &ach, 0))
-            break;
-        /* Skip ranges of virtual keys which are undefined or not relevant. */
-        if (i == '9')
-            i = 'A' - 1;
-        if (i == 'Z')
-            i = VK_OEM_1 - 1;
-        if (i == VK_OEM_3)
-            i = VK_OEM_4 - 1;
-        if (i == VK_OEM_8)
-            i = VK_OEM_102 - 1;
-    }
-    if (i > VK_OEM_102)
-        return false;
-    return true;
-}
-
 bool UIKeyboardHandler::winEventFilter(MSG *pMsg, ulong uScreenId)
 {
@@ -505 +439 @@
                 pMsg->lParam &= ~(0x1 << 25);
                 fResult = false;
-                break;
-            }
-
-            if (isSyntheticLCtrl(pMsg))
-            {
-                fResult = true;
                 break;
             }
@@ -529 +457 @@
             if (!(pMsg->lParam & 0x80000000))
                 flags |= KeyPressed;
+
+            /* If present - why not just assert this? */
+            if (m_pAltGrMonitor)
+            {
+                /* Bail out if we are sure that this is a fake left control. */
+                if (m_pAltGrMonitor->isCurrentEventDefinitelyFake(scan, flags & KeyPressed, flags & KeyExtended))
+                {
+                    fResult = true;
+                    break;
+                }
+                /* Update AltGR monitor state from key-event: */
+                m_pAltGrMonitor->updateStateFromKeyEvent(scan, flags & KeyPressed, flags & KeyExtended);
+                /* And release left Ctrl key early (if required): */
+                if (m_pAltGrMonitor->isLeftControlReleaseNeeded())
+                    keyboard().PutScancode(0x1D | 0x80);
+            }
 
             /* Check for special Korean keys. Based on the keyboard layout selected
@@ -819 +763 @@
     , m_iKeyboardHookViewIndex(-1)
     , m_fSkipKeyboardEvents(false)
+    , m_pAltGrMonitor(0)
 #elif defined(Q_WS_MAC)
     , m_darwinKeyModifiers(0)
     , m_fKeyboardGrabbed(false)
     , m_iKeyboardGrabViewIndex(-1)
-#endif
+#endif /* Q_WS_MAC */
     , m_cMonitors(1)
 {
@@ -845 +790 @@
 void UIKeyboardHandler::prepareCommon()
 {
+#ifdef Q_WS_WIN
+    /* Prepare AltGR monitor: */
+    m_pAltGrMonitor = new WinAltGrMonitor;
+#endif /* Q_WS_WIN */
+
     /* Machine state-change updater: */
     connect(uisession(), SIGNAL(sigMachineStateChange()), this, SLOT(sltMachineStateChanged()));
@@ -872 +822 @@
 {
 #if defined(Q_WS_WIN)
+    /* Cleanup AltGR monitor: */
+    delete m_pAltGrMonitor;
+    m_pAltGrMonitor = 0;
+
     /* Cleaning keyboard-hook: */
     if (m_keyboardHook)
@@ -883 +837 @@
     if (m_fKeyboardGrabbed)
         darwinGrabKeyboardEvents(false);
-#endif
+#endif /* Q_WS_MAC */
 }
 

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIKeyboardHandler.h

@@ -41 +41 @@
 class UIMachineView;
 class VBoxGlobalSettings;
-#ifdef Q_WS_X11
+#if defined(Q_WS_WIN)
+class WinAltGrMonitor;
+#elif defined(Q_WS_X11)
 typedef union  _XEvent XEvent;
 #endif /* Q_WS_X11 */
@@ -93 +95 @@
     bool winEventFilter(MSG *pMsg, ulong uScreenId);
     void winSkipKeyboardEvents(bool fSkip);
+    /** Holds the object monitoring key event stream for problematic AltGr events. */
+    WinAltGrMonitor *m_pAltGrMonitor;
 #elif defined(Q_WS_X11)
     bool x11EventFilter(XEvent *pEvent, ulong uScreenId);
@@ -198 +202 @@
     bool m_fKeyboardGrabbed;
     int m_iKeyboardGrabViewIndex;
-#endif
+#endif /* Q_WS_MAC */
 
     ULONG m_cMonitors;

trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIHostComboEditor.cpp

@@ -42 +42 @@
 # undef HIBYTE
 # include <windows.h>
+# include "WinKeyboard.h"
 #endif /* Q_WS_WIN */
 
@@ -391 +392 @@
     : m_pReleaseTimer(0)
     , m_fStartNewSequence(true)
+#ifdef Q_WS_WIN
+    , m_pAltGrMonitor(0)
+#endif /* Q_WS_WIN */
 {
     /* Configure widget: */
@@ -403 +407 @@
     connect(m_pReleaseTimer, SIGNAL(timeout()), this, SLOT(sltReleasePendingKeys()));
 
-#ifdef Q_WS_X11
-    /* Initialize the X keyboard subsystem: */
-    initMappedX11Keyboard(QX11Info::display(), vboxGlobal().settings().publicProperty("GUI/RemapScancodes"));
-#endif /* Q_WS_X11 */
-
-#ifdef Q_WS_MAC
-    m_uDarwinKeyModifiers = 0;
-    UICocoaApplication::instance()->registerForNativeEvents(RT_BIT_32(10) | RT_BIT_32(11) | RT_BIT_32(12) /* NSKeyDown  | NSKeyUp | | NSFlagsChanged */, UIHostComboEditorPrivate::darwinEventHandlerProc, this);
-    ::DarwinGrabKeyboard(false /* just modifiers */);
-#endif /* Q_WS_MAC */
+#if defined(Q_WS_X11)
+     /* Initialize the X keyboard subsystem: */
+     initMappedX11Keyboard(QX11Info::display(), vboxGlobal().settings().publicProperty("GUI/RemapScancodes"));
+#elif defined(Q_WS_MAC)
+     m_uDarwinKeyModifiers = 0;
+     UICocoaApplication::instance()->registerForNativeEvents(RT_BIT_32(10) | RT_BIT_32(11) | RT_BIT_32(12) /* NSKeyDown  | NSKeyUp | | NSFlagsChanged */, UIHostComboEditorPrivate::darwinEventHandlerProc, this);
+     ::DarwinGrabKeyboard(false /* just modifiers */);
+#elif defined(Q_WS_WIN)
+    /* Prepare AltGR monitor: */
+    m_pAltGrMonitor = new WinAltGrMonitor;
+#endif /* Q_WS_WIN */
 }
 
 UIHostComboEditorPrivate::~UIHostComboEditorPrivate()
 {
-#ifdef Q_WS_MAC
+#if defined(Q_WS_WIN)
+    /* Cleanup AltGR monitor: */
+    delete m_pAltGrMonitor;
+    m_pAltGrMonitor = 0;
+#elif defined(Q_WS_MAC)
     ::DarwinReleaseKeyboard();
     UICocoaApplication::instance()->unregisterForNativeEvents(RT_BIT_32(10) | RT_BIT_32(11) | RT_BIT_32(12) /* NSKeyDown  | NSKeyUp | | NSFlagsChanged */, UIHostComboEditorPrivate::darwinEventHandlerProc, this);
@@ -465 +474 @@
 
 #ifdef Q_WS_WIN
-/**
- * @brief isSyntheticLCtrl
- * @param   pMsg  Windows WM_[SYS]KEY* event message structure
- * @return  true if this is a synthetic LCtrl event, false otherwise
- * This function is a heuristic to tell whether a key event is the first in
- * a synthetic LCtrl+RAlt sequence which Windows uses to signal AltGr.  Our
- * heuristic is in two parts.  First of all, we check whether there is a pending
- * RAlt key event matching this LCtrl event (i.e. both key up or both key down)
- * and if there is, we check whether the current layout has an AltGr key.  We
- * check this by looking to see if any of the layout-dependent keys has a symbol
- * associated when AltGr is pressed.
- */
-static bool isSyntheticLCtrl(MSG *pMsg)
-{
-    MSG peekMsg;
-    /** Keyboard state array with VK_CONTROL and VK_MENU depressed. */
-    const BYTE auKeyStates[256] =
-    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x80, 0x80 };
-    WORD ach;
-    unsigned i;
-
-    Assert(   pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN
-           || pMsg->message == WM_KEYUP || pMsg->message == WM_SYSKEYUP);
-    if (   ((RT_HIWORD(pMsg->lParam) & 0xFF) != 0x1d /* scan code: Control */)
-        || RT_HIWORD(pMsg->lParam) & KF_EXTENDED)
-        return false;
-    if (!PeekMessage(&peekMsg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_NOREMOVE))
-        return false;
-    if (   (pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN)
-        && (peekMsg.message != WM_KEYDOWN && peekMsg.message != WM_SYSKEYDOWN))
-        return false;
-    if (   (pMsg->message == WM_KEYUP || pMsg->message == WM_SYSKEYUP)
-        && (peekMsg.message != WM_KEYUP && peekMsg.message != WM_SYSKEYUP))
-        return false;
-    if (   ((RT_HIWORD(peekMsg.lParam) & 0xFF) != 0x38 /* scan code: Alt */)
-        || !(RT_HIWORD(peekMsg.lParam) & KF_EXTENDED))
-        return false;
-    /* If we got this far then we have a key event which could potentially
-     * be a synthetic left control.  Now we check to see whether the current
-     * keyboard layout actually has an AltGr key by checking whether any of
-     * the keys which might do produce a symbol when AltGr (Control + Alt) is
-     * depressed.  Generally this loop will exit pretty early (it exits on the
-     * first iteration for my German layout).  If there is no AltGr key in the
-     * layout then it will run right through, but that should not happen very
-     * often as we should hardly ever reach the loop in that case.
-     *
-     * In theory we could do this once and cache the result, but that involves
-     * tracking layout switches to invalidate the cache, and I don't think
-     * that the added complexity is worth the price.
-     */
-    for (i = '0'; i <= VK_OEM_102; ++i)
-    {
-        if (ToAscii(i, 0, auKeyStates, &ach, 0))
-            break;
-        /* Skip ranges of virtual keys which are undefined or not relevant. */
-        if (i == '9')
-            i = 'A' - 1;
-        if (i == 'Z')
-            i = VK_OEM_1 - 1;
-        if (i == VK_OEM_3)
-            i = VK_OEM_4 - 1;
-        if (i == VK_OEM_8)
-            i = VK_OEM_102 - 1;
-    }
-    if (i > VK_OEM_102)
-        return false;
-    return true;
-}
-
 bool UIHostComboEditorPrivate::winEvent(MSG *pMsg, long* /* pResult */)
 {
@@ -545 +485 @@
             /* Get key-code: */
             int iKeyCode = UINativeHotKey::distinguishModifierVKey((int)pMsg->wParam, (int)pMsg->lParam);
-
-            /* If this is the first event in a synthetic AltGr = LCtrl+RAlt
-             * sequence then swallow it. */
-            if (isSyntheticLCtrl(pMsg))
-                return true;
+            unsigned iDownScanCode = (pMsg->lParam >> 16) & 0x7F;
+            bool fPressed = !(pMsg->lParam & 0x80000000);
+            bool fExtended = pMsg->lParam & 0x1000000;
+
+            /* If present - why not just assert this? */
+            if (m_pAltGrMonitor)
+            {
+                /* Update AltGR monitor state from key-event: */
+                m_pAltGrMonitor->updateStateFromKeyEvent(iDownScanCode, fPressed, fExtended);
+                /* And release left Ctrl key early (if required): */
+                if (m_pAltGrMonitor->isLeftControlReleaseNeeded())
+                {
+                    m_pressedKeys.remove(VK_LCONTROL);
+                    m_shownKeys.remove(VK_LCONTROL);
+                }
+                /* Fake LCtrl release events can also end up in the released
+                 * key set.  Detect them on the immediately following RAlt up. */
+                if (!m_pressedKeys.contains(VK_LCONTROL))
+                    m_releasedKeys.remove(VK_LCONTROL);
+            }
 
             /* Process the key event: */

trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIHostComboEditor.h

@@ -30 +30 @@
 class UIHostComboEditorPrivate;
 class QIToolButton;
+#ifdef Q_WS_WIN
+class WinAltGrMonitor;
+#endif /* Q_WS_WIN */
 
 /* Native hot-key namespace to unify
@@ -171 +174 @@
     bool m_fStartNewSequence;
 
-#ifdef Q_WS_MAC
-    /* The current modifier key mask. Used to figure out which modifier
-     * key was pressed when we get a kEventRawKeyModifiersChanged event. */
-    uint32_t m_uDarwinKeyModifiers;
-#endif /* Q_WS_MAC */
+#if defined(Q_WS_MAC)
+     /* The current modifier key mask. Used to figure out which modifier
+      * key was pressed when we get a kEventRawKeyModifiersChanged event. */
+     uint32_t m_uDarwinKeyModifiers;
+#elif defined(Q_WS_WIN)
+    /** Holds the object monitoring key event stream for problematic AltGr events. */
+    WinAltGrMonitor *m_pAltGrMonitor;
+#endif /* Q_WS_WIN */
 };