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

Timestamp:

Dec 7, 2015 7:08:56 PM (9 years ago)

Author:

vboxsync

Message:

FE/Qt: Qt5 migration (part 34): Windows nativeEvent handler implementation for UIHostComboEditor.

Location:

trunk/src/VBox/Frontends/VirtualBox/src/widgets

Files:

• UIHostComboEditor.cpp (modified) (8 diffs)
• UIHostComboEditor.h (modified) (2 diffs)

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

@@ -42 +42 @@
 
 #endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
+
+/* Qt includes: */
+#ifdef Q_WS_WIN
+# if QT_VERSION >= 0x050000
+#  include <QAbstractNativeEventFilter>
+# endif /* QT_VERSION >= 0x050000 */
+#endif /* Q_WS_WIN */
 
 /* GUI includes: */
@@ -75 +82 @@
 
 
+#ifdef Q_WS_WIN
+# if QT_VERSION >= 0x050000
+/** QAbstractNativeEventFilter extension
+  * allowing to handle native Windows (MSG) events.
+  * Why do we need it? It's because Qt5 have unhandled
+  * well .. let's call it 'a bug' about native keyboard events
+  * which come to top-level widget (window) instead of focused sub-widget
+  * which actually supposed to get them. The funny thing is that target of
+  * those events (MSG::hwnd) is indeed top-level widget, not the sub-widget
+  * we expect, so that's probably the reason Qt devs haven't fixed that bug. */
+class WinEventFilter : public QAbstractNativeEventFilter
+{
+public:
+
+    /** Constructor which takes the passed @a pParent to redirect events to. */
+    WinEventFilter(UIHostComboEditorPrivate *pParent)
+        : m_pParent(pParent)
+    {}
+
+    /** Handles all native events. */
+    bool nativeEventFilter(const QByteArray &eventType, void *pMessage, long *pResult)
+    {
+        /* Redirect event to parent: */
+        return m_pParent->nativeEvent(eventType, pMessage, pResult);
+    }
+
+private:
+
+    /** Holds the passed parent reference. */
+    UIHostComboEditorPrivate *m_pParent;
+};
+# endif /* QT_VERSION >= 0x050000 */
+#endif /* Q_WS_WIN */
+
+
 /*********************************************************************************************************************************
 *   Namespace UINativeHotKey implementation.                                                                                     *
@@ -428 +470 @@
     , m_fStartNewSequence(true)
 #ifdef Q_WS_WIN
+# if QT_VERSION >= 0x050000
+    , m_pWinEventFilter(0)
+# endif /* QT_VERSION >= 0x050000 */
     , m_pAltGrMonitor(0)
 #endif /* Q_WS_WIN */
@@ -443 +488 @@
 
 #if 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 */);
+    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)
+# if QT_VERSION >= 0x050000
+    /* Prepare Windows event filter: */
+    m_pWinEventFilter = new WinEventFilter(this);
+    qApp->installNativeEventFilter(m_pWinEventFilter);
+# endif /* QT_VERSION >= 0x050000 */
     /* Prepare AltGR monitor: */
     m_pAltGrMonitor = new WinAltGrMonitor;
 #elif defined(Q_WS_X11)
-     /* Initialize the X keyboard subsystem: */
-     initMappedX11Keyboard(QX11Info::display(), vboxGlobal().settings().publicProperty("GUI/RemapScancodes"));
+    /* Initialize the X keyboard subsystem: */
+    initMappedX11Keyboard(QX11Info::display(), vboxGlobal().settings().publicProperty("GUI/RemapScancodes"));
 #endif /* Q_WS_X11 */
 }
@@ -464 +514 @@
     delete m_pAltGrMonitor;
     m_pAltGrMonitor = 0;
+# if QT_VERSION >= 0x050000
+    /* Cleanup Windows event filter: */
+    qApp->removeNativeEventFilter(m_pWinEventFilter);
+    delete m_pWinEventFilter;
+    m_pWinEventFilter = 0;
+# endif /* QT_VERSION >= 0x050000 */
 #endif /* Q_WS_WIN */
 }
@@ -512 +568 @@
 bool UIHostComboEditorPrivate::nativeEvent(const QByteArray &eventType, void *pMessage, long *pResult)
 {
-# if defined(Q_WS_X11)
-#  pragma GCC diagnostic push
-#  pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-
-    /* Make sure it's generic XCB event: */
-    if (eventType != "xcb_generic_event_t")
+# if defined(Q_WS_WIN)
+
+    /* Make sure it's generic MSG event: */
+    if (eventType != "windows_generic_MSG")
         return QLineEdit::nativeEvent(eventType, pMessage, pResult);
-    xcb_generic_event_t *pEvent = static_cast<xcb_generic_event_t*>(pMessage);
-
-    /* Check if some XCB event should be filtered out.
+    MSG *pEvent = static_cast<MSG*>(pMessage);
+
+    /* Check if some MSG event should be filtered out.
      * Returning @c true means filtering-out,
      * Returning @c false means passing event to Qt. */
-    switch (pEvent->response_type & ~0x80)
+    switch (pEvent->message)
     {
         /* Watch for key-events: */
-        case XCB_KEY_PRESS:
-        case XCB_KEY_RELEASE:
-        {
-            /* Parse key-event: */
-            xcb_key_press_event_t *pKeyEvent = static_cast<xcb_key_press_event_t*>(pMessage);
-            const KeySym ks = ::XKeycodeToKeysym(QX11Info::display(), pKeyEvent->detail, 0);
-            const int iKeySym = static_cast<const int>(ks);
-
-            /* Handle key-event: */
-            return processKeyEvent(iKeySym, (pEvent->response_type & ~0x80) == XCB_KEY_PRESS);
-        }
-        default:
-            break;
-    }
-
-#  pragma GCC diagnostic pop
-# endif /* Q_WS_X11 */
-
-    /* Call to base-class: */
-    return QLineEdit::nativeEvent(eventType, pMessage, pResult);
-}
-
-#else /* QT_VERSION < 0x050000 */
-
-# if defined(Q_WS_MAC)
-
-/* static */
-bool UIHostComboEditorPrivate::darwinEventHandlerProc(const void *pvCocoaEvent, const void *pvCarbonEvent, void *pvUser)
-{
-    UIHostComboEditorPrivate *pEditor = static_cast<UIHostComboEditorPrivate*>(pvUser);
-    EventRef inEvent = (EventRef)pvCarbonEvent;
-    UInt32 EventClass = ::GetEventClass(inEvent);
-    if (EventClass == kEventClassKeyboard)
-        return pEditor->darwinKeyboardEvent(pvCocoaEvent, inEvent);
-    return false;
-}
-
-bool UIHostComboEditorPrivate::darwinKeyboardEvent(const void *pvCocoaEvent, EventRef inEvent)
-{
-    /* Ignore key changes unless we're the focus widget: */
-    if (!hasFocus())
-        return false;
-
-    UInt32 eventKind = ::GetEventKind(inEvent);
-    switch (eventKind)
-    {
-        //case kEventRawKeyDown:
-        //case kEventRawKeyUp:
-        //case kEventRawKeyRepeat:
-        case kEventRawKeyModifiersChanged:
-        {
-            /* Get modifier mask: */
-            UInt32 modifierMask = 0;
-            ::GetEventParameter(inEvent, kEventParamKeyModifiers, typeUInt32, NULL,
-                                sizeof(modifierMask), NULL, &modifierMask);
-            modifierMask = ::DarwinAdjustModifierMask(modifierMask, pvCocoaEvent);
-            UInt32 changed = m_uDarwinKeyModifiers ^ modifierMask;
-
-            if (!changed)
-                break;
-
-            /* Convert to keycode: */
-            unsigned uKeyCode = ::DarwinModifierMaskToDarwinKeycode(changed);
-
-            if (!uKeyCode || uKeyCode == ~0U)
-                return false;
-
-            /* Process the key event: */
-            if (processKeyEvent(uKeyCode, changed & modifierMask))
-            {
-                /* Save the new modifier mask state. */
-                m_uDarwinKeyModifiers = modifierMask;
-                return true;
-            }
-            break;
-        }
-        default:
-            break;
-    }
-    return false;
-}
-
-# elif defined(Q_WS_WIN)
-
-bool UIHostComboEditorPrivate::winEvent(MSG *pMsg, long* /* pResult */)
-{
-    switch (pMsg->message)
-    {
         case WM_KEYDOWN:
         case WM_SYSKEYDOWN:
@@ -620 +586 @@
         case WM_SYSKEYUP:
         {
-            /* Get key-code: */
-            int iKeyCode = UINativeHotKey::distinguishModifierVKey((int)pMsg->wParam, (int)pMsg->lParam);
-            unsigned iDownScanCode = (pMsg->lParam >> 16) & 0x7F;
-            bool fPressed = !(pMsg->lParam & 0x80000000);
-            bool fExtended = pMsg->lParam & 0x1000000;
+            /* Parse key-event: */
+            int iKeyCode = UINativeHotKey::distinguishModifierVKey((int)pEvent->wParam, (int)pEvent->lParam);
+            unsigned iDownScanCode = (pEvent->lParam >> 16) & 0x7F;
+            const bool fPressed = !(pEvent->lParam & 0x80000000);
+            const bool fExtended = pEvent->lParam & 0x1000000;
 
             /* If present - why not just assert this? */
@@ -643 +609 @@
             }
 
+            /* Handle key-event: */
+            return processKeyEvent(iKeyCode, (pEvent->message == WM_KEYDOWN || pEvent->message == WM_SYSKEYDOWN));
+        }
+        default:
+            break;
+    }
+
+# elif defined(Q_WS_X11)
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+    /* Make sure it's generic XCB event: */
+    if (eventType != "xcb_generic_event_t")
+        return QLineEdit::nativeEvent(eventType, pMessage, pResult);
+    xcb_generic_event_t *pEvent = static_cast<xcb_generic_event_t*>(pMessage);
+
+    /* Check if some XCB event should be filtered out.
+     * Returning @c true means filtering-out,
+     * Returning @c false means passing event to Qt. */
+    switch (pEvent->response_type & ~0x80)
+    {
+        /* Watch for key-events: */
+        case XCB_KEY_PRESS:
+        case XCB_KEY_RELEASE:
+        {
+            /* Parse key-event: */
+            xcb_key_press_event_t *pKeyEvent = static_cast<xcb_key_press_event_t*>(pMessage);
+            const KeySym ks = ::XKeycodeToKeysym(QX11Info::display(), pKeyEvent->detail, 0);
+            const int iKeySym = static_cast<const int>(ks);
+
+            /* Handle key-event: */
+            return processKeyEvent(iKeySym, (pEvent->response_type & ~0x80) == XCB_KEY_PRESS);
+        }
+        default:
+            break;
+    }
+
+#  pragma GCC diagnostic pop
+# else
+
+#  warning "port me!"
+
+# endif
+
+    /* Call to base-class: */
+    return QLineEdit::nativeEvent(eventType, pMessage, pResult);
+}
+
+#else /* QT_VERSION < 0x050000 */
+
+# if defined(Q_WS_MAC)
+
+/* static */
+bool UIHostComboEditorPrivate::darwinEventHandlerProc(const void *pvCocoaEvent, const void *pvCarbonEvent, void *pvUser)
+{
+    UIHostComboEditorPrivate *pEditor = static_cast<UIHostComboEditorPrivate*>(pvUser);
+    EventRef inEvent = (EventRef)pvCarbonEvent;
+    UInt32 EventClass = ::GetEventClass(inEvent);
+    if (EventClass == kEventClassKeyboard)
+        return pEditor->darwinKeyboardEvent(pvCocoaEvent, inEvent);
+    return false;
+}
+
+bool UIHostComboEditorPrivate::darwinKeyboardEvent(const void *pvCocoaEvent, EventRef inEvent)
+{
+    /* Ignore key changes unless we're the focus widget: */
+    if (!hasFocus())
+        return false;
+
+    UInt32 eventKind = ::GetEventKind(inEvent);
+    switch (eventKind)
+    {
+        //case kEventRawKeyDown:
+        //case kEventRawKeyUp:
+        //case kEventRawKeyRepeat:
+        case kEventRawKeyModifiersChanged:
+        {
+            /* Get modifier mask: */
+            UInt32 modifierMask = 0;
+            ::GetEventParameter(inEvent, kEventParamKeyModifiers, typeUInt32, NULL,
+                                sizeof(modifierMask), NULL, &modifierMask);
+            modifierMask = ::DarwinAdjustModifierMask(modifierMask, pvCocoaEvent);
+            UInt32 changed = m_uDarwinKeyModifiers ^ modifierMask;
+
+            if (!changed)
+                break;
+
+            /* Convert to keycode: */
+            unsigned uKeyCode = ::DarwinModifierMaskToDarwinKeycode(changed);
+
+            if (!uKeyCode || uKeyCode == ~0U)
+                return false;
+
+            /* Process the key event: */
+            if (processKeyEvent(uKeyCode, changed & modifierMask))
+            {
+                /* Save the new modifier mask state. */
+                m_uDarwinKeyModifiers = modifierMask;
+                return true;
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    return false;
+}
+
+# elif defined(Q_WS_WIN)
+
+bool UIHostComboEditorPrivate::winEvent(MSG *pMsg, long* /* pResult */)
+{
+    switch (pMsg->message)
+    {
+        case WM_KEYDOWN:
+        case WM_SYSKEYDOWN:
+        case WM_KEYUP:
+        case WM_SYSKEYUP:
+        {
+            /* Get key-code: */
+            int iKeyCode = UINativeHotKey::distinguishModifierVKey((int)pMsg->wParam, (int)pMsg->lParam);
+            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: */
             return processKeyEvent(iKeyCode, pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN);

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

@@ -32 +32 @@
 class UIHostComboEditorPrivate;
 #ifdef Q_WS_WIN
+# if QT_VERSION >= 0x050000
+class WinEventFilter;
+# endif /* QT_VERSION >= 0x050000 */
 class WinAltGrMonitor;
 #endif /* Q_WS_WIN */
@@ -187 +190 @@
      uint32_t m_uDarwinKeyModifiers;
 #elif defined(Q_WS_WIN)
+# if QT_VERSION >= 0x050000
+    /** Win: Holds the native event filter instance. */
+    WinEventFilter *m_pWinEventFilter;
+    /** Win: Allows the native event filter to
+      * redirect events directly to nativeEvent handler. */
+    friend class WinEventFilter;
+# endif /* QT_VERSION >= 0x050000 */
     /** Win: Holds the object monitoring key event
       * stream for problematic AltGr events. */