Changeset 59347 in vbox for trunk/src/VBox/Frontends/VirtualBox

Timestamp:

Jan 14, 2016 1:56:30 PM (9 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

105028

Message:

FE/Qt: Qt5 migration (part 54): Reworking keyboard-handler: Refactoring.

Location:

trunk/src/VBox/Frontends/VirtualBox/src/runtime

Files:

• UIKeyboardHandler.cpp (modified) (21 diffs)
• UIKeyboardHandler.h (modified) (4 diffs)

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

@@ -138 +138 @@
 
 /* Prepare listened objects: */
-void UIKeyboardHandler::prepareListener(ulong uIndex, UIMachineWindow *pMachineWindow)
+void UIKeyboardHandler::prepareListener(ulong uScreenId, UIMachineWindow *pMachineWindow)
 {
     /* If that window is NOT registered yet: */
-    if (!m_windows.contains(uIndex))
+    if (!m_windows.contains(uScreenId))
     {
         /* Add window: */
-        m_windows.insert(uIndex, pMachineWindow);
+        m_windows.insert(uScreenId, pMachineWindow);
         /* Install event-filter for window: */
-        m_windows[uIndex]->installEventFilter(this);
+        m_windows[uScreenId]->installEventFilter(this);
     }
 
     /* If that view is NOT registered yet: */
-    if (!m_views.contains(uIndex))
+    if (!m_views.contains(uScreenId))
     {
         /* Add view: */
-        m_views.insert(uIndex, pMachineWindow->machineView());
+        m_views.insert(uScreenId, pMachineWindow->machineView());
         /* Install event-filter for view: */
-        m_views[uIndex]->installEventFilter(this);
+        m_views[uScreenId]->installEventFilter(this);
     }
 }
 
 /* Cleanup listened objects: */
-void UIKeyboardHandler::cleanupListener(ulong uIndex)
+void UIKeyboardHandler::cleanupListener(ulong uScreenId)
 {
     /* Check if we should release keyboard first: */
-    if ((int)uIndex == m_iKeyboardCaptureViewIndex)
+    if ((int)uScreenId == m_iKeyboardCaptureViewIndex)
         releaseKeyboard();
 
     /* If window still registered: */
-    if (m_windows.contains(uIndex))
+    if (m_windows.contains(uScreenId))
     {
         /* Remove window: */
-        m_windows.remove(uIndex);
+        m_windows.remove(uScreenId);
     }
 
     /* If view still registered: */
-    if (m_views.contains(uIndex))
+    if (m_views.contains(uScreenId))
     {
         /* Remove view: */
-        m_views.remove(uIndex);
+        m_views.remove(uScreenId);
     }
 }
@@ -406 +406 @@
         hostComboModifierMask |= ::DarwinKeyCodeToDarwinModifierMask(hostCombo.at(i));
     /* Clear most of the modifiers: */
-    m_darwinKeyModifiers &=
+    m_uDarwinKeyModifiers &=
         alphaLock | kEventKeyModifierNumLockMask |
         (aReleaseHostKey ? 0 : hostComboModifierMask);
@@ -889 +889 @@
     , m_fDebuggerActive(false)
 #if defined(Q_WS_MAC)
-    , m_darwinKeyModifiers(0)
-    , m_fKeyboardGrabbed(false)
-    , m_iKeyboardGrabViewIndex(-1)
+    , m_iKeyboardHookViewIndex(-1)
+    , m_uDarwinKeyModifiers(0)
 #elif defined(Q_WS_WIN)
-    , m_bIsHostkeyInCapture(false)
     , m_iKeyboardHookViewIndex(-1)
+    , m_fIsHostkeyInCapture(false)
     , m_fSkipKeyboardEvents(false)
+    , m_keyboardHook(NULL)
     , m_pAltGrMonitor(0)
 #endif /* Q_WS_WIN */
@@ -964 +964 @@
     /* We have to make sure the callback for the keyboard events
      * is released when closing this view. */
-    if (m_fKeyboardGrabbed)
+    if (m_iKeyboardHookViewIndex != -1)
         darwinGrabKeyboardEvents(false);
 #endif /* Q_WS_MAC */
@@ -1022 +1022 @@
                     }
                     /* Register new keyboard-hook: */
-                    m_keyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, lowLevelKeyboardProc, GetModuleHandle(NULL), 0);
+                    m_keyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, UIKeyboardHandler::winKeyboardProc, GetModuleHandle(NULL), 0);
                     AssertMsg(m_keyboardHook, ("SetWindowsHookEx(): err=%d", GetLastError()));
                     /* Remember which view had captured keyboard: */
@@ -1064 +1064 @@
                 /* If keyboard-event handler is NOT currently installed;
                  * Or installed but NOT for that view: */
-                if (m_iKeyboardGrabViewIndex != (int)uScreenId)
+                if (m_iKeyboardHookViewIndex != (int)uScreenId)
                 {
                     /* If keyboard-event handler is NOT currently installed: */
-                    if (m_iKeyboardGrabViewIndex == -1)
+                    if (m_iKeyboardHookViewIndex == -1)
                     {
                         /* Install the keyboard-event handler: */
@@ -1073 +1073 @@
                     }
                     /* Update the id: */
-                    m_iKeyboardGrabViewIndex = uScreenId;
+                    m_iKeyboardHookViewIndex = uScreenId;
                 }
 #endif /* Q_WS_MAC */
@@ -1097 +1097 @@
 #ifdef Q_WS_MAC
                 /* If keyboard-event handler is installed for that view: */
-                if (m_iKeyboardGrabViewIndex == (int)uScreenId)
+                if (m_iKeyboardHookViewIndex == (int)uScreenId)
                 {
                     /* Remove the keyboard-event handler: */
                     darwinGrabKeyboardEvents(false);
                     /* Update the id: */
-                    m_iKeyboardGrabViewIndex = -1;
+                    m_iKeyboardHookViewIndex = -1;
                 }
 #endif /* Q_WS_MAC */
@@ -1165 +1165 @@
 void UIKeyboardHandler::darwinGrabKeyboardEvents(bool fGrab)
 {
-    m_fKeyboardGrabbed = fGrab;
     if (fGrab)
     {
@@ -1174 +1173 @@
         /* Bring the caps lock state up to date, otherwise e.g. a later Shift
          * key press will accidentally inject a CapsLock key press and release,
-         * see UIKeyboardHandler::darwinKeyboardEvent for the code handling
+         * see UIKeyboardHandler::macKeyboardEvent for the code handling
          * modifier key state changes */
-        m_darwinKeyModifiers ^= (m_darwinKeyModifiers ^ ::GetCurrentEventKeyModifiers()) & alphaLock;
+        m_uDarwinKeyModifiers ^= (m_uDarwinKeyModifiers ^ ::GetCurrentEventKeyModifiers()) & alphaLock;
 
         /* Register the event callback/hook and grab the keyboard. */
         UICocoaApplication::instance()->registerForNativeEvents(RT_BIT_32(10) | RT_BIT_32(11) | RT_BIT_32(12) /* NSKeyDown  | NSKeyUp | | NSFlagsChanged */,
-                                                                UIKeyboardHandler::darwinEventHandlerProc, this);
+                                                                UIKeyboardHandler::macKeyboardProc, this);
 
         ::DarwinGrabKeyboard (false);
@@ -1188 +1187 @@
         ::DarwinReleaseKeyboard();
         UICocoaApplication::instance()->unregisterForNativeEvents(RT_BIT_32(10) | RT_BIT_32(11) | RT_BIT_32(12) /* NSKeyDown  | NSKeyUp | | NSFlagsChanged */,
-                                                                  UIKeyboardHandler::darwinEventHandlerProc, this);
-    }
-}
-
-bool UIKeyboardHandler::darwinEventHandlerProc(const void *pvCocoaEvent, const void *pvCarbonEvent, void *pvUser)
+                                                                  UIKeyboardHandler::macKeyboardProc, this);
+    }
+}
+
+bool UIKeyboardHandler::macKeyboardProc(const void *pvCocoaEvent, const void *pvCarbonEvent, void *pvUser)
 {
     UIKeyboardHandler *pKeyboardHandler = (UIKeyboardHandler*)pvUser;
@@ -1206 +1205 @@
     if (eventClass == kEventClassKeyboard)
     {
-        if (pKeyboardHandler->darwinKeyboardEvent (pvCocoaEvent, inEvent))
+        if (pKeyboardHandler->macKeyboardEvent(pvCocoaEvent, inEvent))
             return true;
     }
@@ -1213 +1212 @@
 }
 
-bool UIKeyboardHandler::darwinKeyboardEvent(const void *pvCocoaEvent, EventRef inEvent)
+bool UIKeyboardHandler::macKeyboardEvent(const void *pvCocoaEvent, EventRef inEvent)
 {
     bool ret = false;
@@ -1256 +1255 @@
             ucs[cbWritten / sizeof(wchar_t)] = 0; /* The api doesn't terminate it. */
 
-            ret = keyEvent(keyCode, scanCode, flags, m_iKeyboardGrabViewIndex, ucs[0] ? ucs : NULL);
+            ret = keyEvent(keyCode, scanCode, flags, m_iKeyboardHookViewIndex, ucs[0] ? ucs : NULL);
         }
     }
@@ -1266 +1265 @@
                             sizeof(newMask), NULL, &newMask);
         newMask = ::DarwinAdjustModifierMask(newMask, pvCocoaEvent);
-        UInt32 changed = newMask ^ m_darwinKeyModifiers;
+        UInt32 changed = newMask ^ m_uDarwinKeyModifiers;
         if (changed)
         {
@@ -1285 +1284 @@
                         flags |= KeyExtended;
                     scanCode &= VBOXKEY_SCANCODE_MASK;
-                    ret |= keyEvent(keyCode, scanCode & 0xff, flags, m_iKeyboardGrabViewIndex);
+                    ret |= keyEvent(keyCode, scanCode & 0xff, flags, m_iKeyboardHookViewIndex);
                 }
                 else
@@ -1293 +1292 @@
                         flags |= KeyExtended;
                     scanCode &= VBOXKEY_SCANCODE_MASK;
-                    keyEvent(keyCode, scanCode, flags | KeyPressed, m_iKeyboardGrabViewIndex);
-                    keyEvent(keyCode, scanCode, flags, m_iKeyboardGrabViewIndex);
+                    keyEvent(keyCode, scanCode, flags | KeyPressed, m_iKeyboardHookViewIndex);
+                    keyEvent(keyCode, scanCode, flags, m_iKeyboardHookViewIndex);
                 }
             }
         }
 
-        m_darwinKeyModifiers = newMask;
+        m_uDarwinKeyModifiers = newMask;
 
         /* Always return true here because we'll otherwise getting a Qt event
@@ -1311 +1310 @@
 #elif defined(Q_WS_WIN)
 
-LRESULT CALLBACK UIKeyboardHandler::lowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
-{
-    if (nCode == HC_ACTION && m_spKeyboardHandler && m_spKeyboardHandler->winLowKeyboardEvent(wParam, *(KBDLLHOOKSTRUCT*)lParam))
+LRESULT CALLBACK UIKeyboardHandler::winKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
+{
+    if (nCode == HC_ACTION && m_spKeyboardHandler && m_spKeyboardHandler->winKeyboardEvent(wParam, *(KBDLLHOOKSTRUCT*)lParam))
         return 1;
 
@@ -1319 +1318 @@
 }
 
-bool UIKeyboardHandler::winLowKeyboardEvent(UINT msg, const KBDLLHOOKSTRUCT &event)
+bool UIKeyboardHandler::winKeyboardEvent(UINT msg, const KBDLLHOOKSTRUCT &event)
 {
     /* Check what related machine-view was NOT unregistered yet: */
@@ -1333 +1332 @@
     if (   (event.flags & 0x80) /* released */
         && (   (   UIHostCombo::toKeyCodeList(m_globalSettings.hostCombo()).contains(event.vkCode)
-                && !m_bIsHostkeyInCapture)
+                && !m_fIsHostkeyInCapture)
             ||    (  m_pressedKeys[event.scanCode & 0x7F]
                    & (IsKbdCaptured | what_pressed))
@@ -1601 +1600 @@
     if (m_bIsHostComboPressed || isHostComboStateChanged)
     {
-        /* Currently this is used in winLowKeyboardEvent() only: */
-        m_bIsHostkeyInCapture = m_fIsKeyboardCaptured;
+        /* Currently this is used in winKeyboardEvent() only: */
+        m_fIsHostkeyInCapture = m_fIsKeyboardCaptured;
     }
 #endif /* Q_WS_WIN */

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

@@ -71 +71 @@
 
     /* Prepare/cleanup listeners: */
-    void prepareListener(ulong uIndex, UIMachineWindow *pMachineWindow);
-    void cleanupListener(ulong uIndex);
+    void prepareListener(ulong uScreenId, UIMachineWindow *pMachineWindow);
+    void cleanupListener(ulong uScreenId);
 
     /* Commands to capture/release keyboard: */
@@ -91 +91 @@
 #ifdef Q_WS_MAC
     bool isHostKeyAlone() const { return m_bIsHostComboAlone; }
-    bool isKeyboardGrabbed() const { return m_fKeyboardGrabbed; }
+    bool isKeyboardGrabbed() const { return m_iKeyboardHookViewIndex != -1; }
 #endif /* Q_WS_MAC */
 
@@ -153 +153 @@
     void darwinGrabKeyboardEvents(bool fGrab);
     /** Mac: Performs initial pre-processing of all the native keyboard events. */
-    static bool darwinEventHandlerProc(const void *pvCocoaEvent, const void *pvCarbonEvent, void *pvUser);
+    static bool macKeyboardProc(const void *pvCocoaEvent, const void *pvCarbonEvent, void *pvUser);
     /** Mac: Performs initial pre-processing of all the native keyboard events. */
-    bool darwinKeyboardEvent(const void *pvCocoaEvent, EventRef inEvent);
+    bool macKeyboardEvent(const void *pvCocoaEvent, EventRef inEvent);
 #elif defined(Q_WS_WIN)
     /** Win: Performs initial pre-processing of all the native keyboard events. */
-    static LRESULT CALLBACK lowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam);
+    static LRESULT CALLBACK winKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam);
     /** Win: Performs initial pre-processing of all the native keyboard events. */
-    bool winLowKeyboardEvent(UINT msg, const KBDLLHOOKSTRUCT &event);
+    bool winKeyboardEvent(UINT msg, const KBDLLHOOKSTRUCT &event);
 #endif /* Q_WS_WIN */
 
@@ -212 +212 @@
 
 #if defined(Q_WS_MAC)
+    /** Holds the keyboard hook view index. */
+    int m_iKeyboardHookViewIndex;
     /** Holds the current modifiers key mask. */
-    UInt32 m_darwinKeyModifiers;
-    /** Holds whether the keyboard is grabbed. */
-    bool m_fKeyboardGrabbed;
+    UInt32 m_uDarwinKeyModifiers;
+#elif defined(Q_WS_WIN)
     /** Holds the keyboard hook view index. */
-    int m_iKeyboardGrabViewIndex;
-#elif defined(Q_WS_WIN)
-    /* Currently this is used in winLowKeyboardEvent() only: */
-    bool m_bIsHostkeyInCapture;
+    int m_iKeyboardHookViewIndex;
+    /* Currently this is used in winKeyboardEvent() only: */
+    bool m_fIsHostkeyInCapture;
+    /** Holds whether the keyboard event filter should ignore keyboard events. */
+    bool m_fSkipKeyboardEvents;
+    /** Holds the keyboard hook instance. */
+    HHOOK m_keyboardHook;
+    /** Holds the object monitoring key event stream for problematic AltGr events. */
+    WinAltGrMonitor *m_pAltGrMonitor;
     /** Holds the keyboard handler reference to be accessible from the keyboard hook. */
     static UIKeyboardHandler *m_spKeyboardHandler;
-    /** Holds the keyboard hook instance. */
-    HHOOK m_keyboardHook;
-    /** Holds the keyboard hook view index. */
-    int m_iKeyboardHookViewIndex;
-    /** Holds whether the keyboard event filter should ignore keyboard events. */
-    bool m_fSkipKeyboardEvents;
-    /** Holds the object monitoring key event stream for problematic AltGr events. */
-    WinAltGrMonitor *m_pAltGrMonitor;
 #endif /* Q_WS_WIN */