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

Timestamp:

Jan 20, 2016 10:27:56 AM (9 years ago)

Author:

vboxsync

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

105133

Message:

FE/Qt: Qt5 migration (part 68): Implementing keyboard handling for Qt5 under Mac OS X.

Location:

trunk/src/VBox/Frontends/VirtualBox/src

Files:

• runtime/UIKeyboardHandler.cpp (modified) (3 diffs)
• runtime/UIMachineView.cpp (modified) (1 diff)
• widgets/UIHostComboEditor.cpp (modified) (1 diff)

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

@@ -49 +49 @@
 /* COM includes: */
 # include "CKeyboard.h"
+
+/* Other VBox includes: */
+# ifdef Q_WS_MAC
+#  if QT_VERSION >= 0x050000
+#   include "iprt/cpp/utils.h"
+#  endif /* QT_VERSION >= 0x050000 */
+# endif /* Q_WS_MAC */ 
 
 #endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
@@ -946 +953 @@
 # if defined(Q_WS_MAC)
 
-#  warning "implement me!"
+    /* Acquire carbon event reference from the cocoa one: */
+    EventRef event = static_cast<EventRef>(darwinCocoaToCarbonEvent(pMessage));
+
+    /* Depending on event kind: */
+    const UInt32 uEventKind = ::GetEventKind(event);
+    switch(uEventKind)
+    {
+        /* Watch for simple key-events: */
+        case kEventRawKeyDown:
+        case kEventRawKeyRepeat:
+        case kEventRawKeyUp:
+        {
+            /* Acquire keycode: */
+            UInt32 uKeyCode = ~0U;
+            ::GetEventParameter(event, kEventParamKeyCode, typeUInt32,
+                                NULL, sizeof(uKeyCode), NULL, &uKeyCode);
+
+            /* The usb keyboard driver translates these codes to different virtual
+             * keycodes depending of the keyboard type. There are ANSI, ISO, JIS
+             * and unknown. For European keyboards (ISO) the key 0xa and 0x32 have
+             * to be switched. Here we are doing this at runtime, cause the user
+             * can have more than one keyboard (of different type), where he may
+             * switch at will all the time. Default is the ANSI standard as defined
+             * in g_aDarwinToSet1. Please note that the "~" on some English ISO
+             * keyboards will be wrongly swapped. This can maybe fixed by
+             * using a Apple keyboard layout in the guest. */
+            if (   (uKeyCode == 0xa || uKeyCode == 0x32)
+                && KBGetLayoutType(LMGetKbdType()) == kKeyboardISO)
+                uKeyCode = 0x3c - uKeyCode;
+
+            /* Translate keycode to set 1 scan code: */
+            unsigned uScanCode = ::DarwinKeycodeToSet1Scancode(uKeyCode);
+
+            /* If scan code is valid: */
+            if (uScanCode)
+            {
+                /* Calculate flags: */
+                int iFlags = 0;
+                if (uEventKind != kEventRawKeyUp)
+                    iFlags |= KeyPressed;
+                if (uScanCode & VBOXKEY_EXTENDED)
+                    iFlags |= KeyExtended;
+                /** @todo KeyPause, KeyPrint. */
+                uScanCode &= VBOXKEY_SCANCODE_MASK;
+
+                /* Get the unicode string (if present): */
+                AssertCompileSize(wchar_t, 2);
+                AssertCompileSize(UniChar, 2);
+                ByteCount cbWritten = 0;
+                wchar_t ucs[8];
+                if (::GetEventParameter(event, kEventParamKeyUnicodes, typeUnicodeText,
+                                        NULL, sizeof(ucs), &cbWritten, &ucs[0]) != 0)
+                    cbWritten = 0;
+                ucs[cbWritten / sizeof(wchar_t)] = 0; /* The api doesn't terminate it. */
+
+                /* Finally, handle parsed key-event: */
+                fResult = keyEvent(uKeyCode, uScanCode, iFlags, uScreenId, ucs[0] ? ucs : NULL);
+            }
+
+            break;
+        }
+        /* Watch for modifier key-events: */
+        case kEventRawKeyModifiersChanged:
+        {
+            /* Acquire new modifier mask, it may contain
+             * multiple modifier changes, kind of annoying: */
+            UInt32 uNewMask = 0;
+            ::GetEventParameter(event, kEventParamKeyModifiers, typeUInt32,
+                                NULL, sizeof(uNewMask), NULL, &uNewMask);
+
+            /* Adjust new modifier mask to distinguish left/right modifiers: */
+            uNewMask = ::DarwinAdjustModifierMask(uNewMask, pMessage);
+
+            /* Determine what is really changed: */
+            const UInt32 changed = uNewMask ^ m_uDarwinKeyModifiers;
+            if (changed)
+            {
+                for (UInt32 bit = 0; bit < 32; ++bit)
+                {
+                    /* Skip unchanged bits: */
+                    if (!(changed & (1 << bit)))
+                        continue;
+                    /* Acquire set 1 scan code from new mask: */
+                    unsigned uScanCode = ::DarwinModifierMaskToSet1Scancode(1 << bit);
+                    /* Skip invalid scan codes: */
+                    if (!uScanCode)
+                        continue;
+                    /* Acquire darwin keycode from new mask: */
+                    unsigned uKeyCode = ::DarwinModifierMaskToDarwinKeycode(1 << bit);
+                    /* Assert invalid keycodes: */
+                    Assert(uKeyCode);
+
+                    /* For non-lockable modifier: */
+                    if (!(uScanCode & VBOXKEY_LOCK))
+                    {
+                        /* Calculate flags: */
+                        unsigned uFlags = (uNewMask & (1 << bit)) ? KeyPressed : 0;
+                        if (uScanCode & VBOXKEY_EXTENDED)
+                            uFlags |= KeyExtended;
+                        uScanCode &= VBOXKEY_SCANCODE_MASK;
+
+                        /* Finally, handle parsed key-event: */
+                        keyEvent(uKeyCode, uScanCode & 0xff, uFlags, uScreenId);
+                    }
+                    /* For lockable modifier: */
+                    else
+                    {
+                        /* Calculate flags: */
+                        unsigned uFlags = 0;
+                        if (uScanCode & VBOXKEY_EXTENDED)
+                            uFlags |= KeyExtended;
+                        uScanCode &= VBOXKEY_SCANCODE_MASK;
+
+                        /* Finally, handle parsed press/release pair: */
+                        keyEvent(uKeyCode, uScanCode, uFlags | KeyPressed, uScreenId);
+                        keyEvent(uKeyCode, uScanCode, uFlags, uScreenId);
+                    }
+                }
+            }
+
+            /* Remember new modifier mask: */
+            m_uDarwinKeyModifiers = uNewMask;
+
+            /* Always return true here because we'll otherwise getting a Qt event
+             * we don't want and that will only cause the Pause warning to pop up: */
+            fResult = true;
+
+            break;
+        }
+        default:
+            break;
+    }
 
 # elif defined(Q_WS_WIN)
@@ -1587 +1725 @@
 #if QT_VERSION < 0x050000
     return m_views[m_iKeyboardHookViewIndex]->macEvent(pvCocoaEvent, event);
-#endif /* QT_VERSION < 0x050000 */
+#else /* QT_VERSION >= 0x050000 */
+    Q_UNUSED(event);
+    QByteArray eventType("mac_generic_NSEvent");
+    return m_views[m_iKeyboardHookViewIndex]->nativeEvent(eventType, unconst(pvCocoaEvent));
+#endif /* QT_VERSION >= 0x050000 */
 }
 

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

@@ -1889 +1889 @@
 # if defined(Q_WS_MAC)
 
-#  warning "implement me!"
+    /* Make sure it's generic NSEvent: */
+    if (eventType != "mac_generic_NSEvent")
+        return false;
+    EventRef event = static_cast<EventRef>(darwinCocoaToCarbonEvent(pMessage));
+
+    /* Check if some NSEvent should be filtered out.
+     * Returning @c true means filtering-out,
+     * Returning @c false means passing event to Qt. */
+    switch(::GetEventClass(event))
+    {
+        /* Watch for keyboard-events: */
+        case kEventClassKeyboard:
+        {
+            switch(::GetEventKind(event))
+            {
+                /* Watch for key-events: */
+                case kEventRawKeyDown:
+                case kEventRawKeyRepeat:
+                case kEventRawKeyUp:
+                case kEventRawKeyModifiersChanged:
+                {
+                    /* Delegate key-event handling to the keyboard-handler: */
+                    return machineLogic()->keyboardHandler()->nativeEventFilter(pMessage, screenId());
+                }
+                default:
+                    break;
+            }
+            break;
+        }
+        default:
+            break;
+    }
 
 # elif defined(Q_WS_WIN)

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

@@ -586 +586 @@
     if (eventType != "mac_generic_NSEvent")
         return QLineEdit::nativeEvent(eventType, pMessage, pResult);
-    EventRef event = (EventRef)darwinCocoaToCarbonEvent(pMessage);
+    EventRef event = static_cast<EventRef>(darwinCocoaToCarbonEvent(pMessage));
 
     /* Check if some NSEvent should be filtered out.