1 files changed, 262 insertions, 0 deletions
diff --git a/src/plugins/platforms/cocoa/qnsview_keys.mm b/src/plugins/platforms/cocoa/qnsview_keys.mm
new file mode 100644
index 0000000000..57ce6a009f
--- /dev/null
+++ b/src/plugins/platforms/cocoa/qnsview_keys.mm
@@ -0,0 +1,262 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+// This file is included from qnsview.mm, and only used to organize the code
+
+@implementation QT_MANGLE_NAMESPACE(QNSView) (KeysAPI)
+
++ (Qt::KeyboardModifiers)convertKeyModifiers:(ulong)modifierFlags
+{
+    const bool dontSwapCtrlAndMeta = qApp->testAttribute(Qt::AA_MacDontSwapCtrlAndMeta);
+    Qt::KeyboardModifiers qtMods =Qt::NoModifier;
+    if (modifierFlags &  NSShiftKeyMask)
+        qtMods |= Qt::ShiftModifier;
+    if (modifierFlags & NSControlKeyMask)
+        qtMods |= dontSwapCtrlAndMeta ? Qt::ControlModifier : Qt::MetaModifier;
+    if (modifierFlags & NSAlternateKeyMask)
+        qtMods |= Qt::AltModifier;
+    if (modifierFlags & NSCommandKeyMask)
+        qtMods |= dontSwapCtrlAndMeta ? Qt::MetaModifier : Qt::ControlModifier;
+    if (modifierFlags & NSNumericPadKeyMask)
+        qtMods |= Qt::KeypadModifier;
+    return qtMods;
+}
+
+@end
+
+@implementation QT_MANGLE_NAMESPACE(QNSView) (Keys)
+
+- (int)convertKeyCode:(QChar)keyChar
+{
+    return qt_mac_cocoaKey2QtKey(keyChar);
+}
+
+- (bool)handleKeyEvent:(NSEvent *)nsevent eventType:(int)eventType
+{
+    ulong timestamp = [nsevent timestamp] * 1000;
+    ulong nativeModifiers = [nsevent modifierFlags];
+    Qt::KeyboardModifiers modifiers = [QNSView convertKeyModifiers: nativeModifiers];
+    NSString *charactersIgnoringModifiers = [nsevent charactersIgnoringModifiers];
+    NSString *characters = [nsevent characters];
+    if (m_inputSource != characters) {
+        [m_inputSource release];
+        m_inputSource = [characters retain];
+    }
+
+    // There is no way to get the scan code from carbon/cocoa. But we cannot
+    // use the value 0, since it indicates that the event originates from somewhere
+    // else than the keyboard.
+    quint32 nativeScanCode = 1;
+    quint32 nativeVirtualKey = [nsevent keyCode];
+
+    QChar ch = QChar::ReplacementCharacter;
+    int keyCode = Qt::Key_unknown;
+
+    // If a dead key occurs as a result of pressing a key combination then
+    // characters will have 0 length, but charactersIgnoringModifiers will
+    // have a valid character in it. This enables key combinations such as
+    // ALT+E to be used as a shortcut with an English keyboard even though
+    // pressing ALT+E will give a dead key while doing normal text input.
+    if ([characters length] != 0 || [charactersIgnoringModifiers length] != 0) {
+        auto ctrlOrMetaModifier = qApp->testAttribute(Qt::AA_MacDontSwapCtrlAndMeta) ? Qt::ControlModifier : Qt::MetaModifier;
+        if (((modifiers & ctrlOrMetaModifier) || (modifiers & Qt::AltModifier)) && ([charactersIgnoringModifiers length] != 0))
+            ch = QChar([charactersIgnoringModifiers characterAtIndex:0]);
+        else if ([characters length] != 0)
+            ch = QChar([characters characterAtIndex:0]);
+        keyCode = [self convertKeyCode:ch];
+    }
+
+    // we will send a key event unless the input method sets m_sendKeyEvent to false
+    m_sendKeyEvent = true;
+    QString text;
+    // ignore text for the U+F700-U+F8FF range. This is used by Cocoa when
+    // delivering function keys (e.g. arrow keys, backspace, F1-F35, etc.)
+    if (!(modifiers & (Qt::ControlModifier | Qt::MetaModifier)) && (ch.unicode() < 0xf700 || ch.unicode() > 0xf8ff))
+        text = QString::fromNSString(characters);
+
+    QWindow *window = [self topLevelWindow];
+
+    // Popups implicitly grab key events; forward to the active popup if there is one.
+    // This allows popups to e.g. intercept shortcuts and close the popup in response.
+    if (QCocoaWindow *popup = QCocoaIntegration::instance()->activePopupWindow()) {
+        if (!popup->window()->flags().testFlag(Qt::ToolTip))
+            window = popup->window();
+    }
+
+    if (eventType == QEvent::KeyPress) {
+
+        if (m_composingText.isEmpty()) {
+            m_sendKeyEvent = !QWindowSystemInterface::handleShortcutEvent(window, timestamp, keyCode,
+                modifiers, nativeScanCode, nativeVirtualKey, nativeModifiers, text, [nsevent isARepeat], 1);
+
+            // Handling a shortcut may result in closing the window
+            if (!m_platformWindow)
+                return true;
+        }
+
+        QObject *fo = m_platformWindow->window()->focusObject();
+        if (m_sendKeyEvent && fo) {
+            QInputMethodQueryEvent queryEvent(Qt::ImEnabled | Qt::ImHints);
+            if (QCoreApplication::sendEvent(fo, &queryEvent)) {
+                bool imEnabled = queryEvent.value(Qt::ImEnabled).toBool();
+                Qt::InputMethodHints hints = static_cast<Qt::InputMethodHints>(queryEvent.value(Qt::ImHints).toUInt());
+                if (imEnabled && !(hints & Qt::ImhDigitsOnly || hints & Qt::ImhFormattedNumbersOnly || hints & Qt::ImhHiddenText)) {
+                    // pass the key event to the input method. note that m_sendKeyEvent may be set to false during this call
+                    m_currentlyInterpretedKeyEvent = nsevent;
+                    [self interpretKeyEvents:@[nsevent]];
+                    m_currentlyInterpretedKeyEvent = 0;
+                }
+            }
+        }
+        if (m_resendKeyEvent)
+            m_sendKeyEvent = true;
+    }
+
+    bool accepted = true;
+    if (m_sendKeyEvent && m_composingText.isEmpty()) {
+        QWindowSystemInterface::handleExtendedKeyEvent(window, timestamp, QEvent::Type(eventType), keyCode, modifiers,
+                                                       nativeScanCode, nativeVirtualKey, nativeModifiers, text, [nsevent isARepeat], 1, false);
+        accepted = QWindowSystemInterface::flushWindowSystemEvents();
+    }
+    m_sendKeyEvent = false;
+    m_resendKeyEvent = false;
+    return accepted;
+}
+
+- (void)keyDown:(NSEvent *)nsevent
+{
+    if ([self isTransparentForUserInput])
+        return [super keyDown:nsevent];
+
+    const bool accepted = [self handleKeyEvent:nsevent eventType:int(QEvent::KeyPress)];
+
+    // When Qt is used to implement a plugin for a native application we
+    // want to propagate unhandled events to other native views. However,
+    // Qt does not always set the accepted state correctly (in particular
+    // for return key events), so do this for plugin applications only
+    // to prevent incorrect forwarding in the general case.
+    const bool shouldPropagate = QCoreApplication::testAttribute(Qt::AA_PluginApplication) && !accepted;
+
+    // Track keyDown acceptance/forward state for later acceptance of the keyUp.
+    if (!shouldPropagate)
+        m_acceptedKeyDowns.insert([nsevent keyCode]);
+
+    if (shouldPropagate)
+        [super keyDown:nsevent];
+}
+
+- (void)keyUp:(NSEvent *)nsevent
+{
+    if ([self isTransparentForUserInput])
+        return [super keyUp:nsevent];
+
+    const bool keyUpAccepted = [self handleKeyEvent:nsevent eventType:int(QEvent::KeyRelease)];
+
+    // Propagate the keyUp if neither Qt accepted it nor the corresponding KeyDown was
+    // accepted. Qt text controls wil often not use and ignore keyUp events, but we
+    // want to avoid propagating unmatched keyUps.
+    const bool keyDownAccepted = m_acceptedKeyDowns.remove([nsevent keyCode]);
+    if (!keyUpAccepted && !keyDownAccepted)
+        [super keyUp:nsevent];
+}
+
+- (void)cancelOperation:(id)sender
+{
+    Q_UNUSED(sender);
+
+    NSEvent *currentEvent = [NSApp currentEvent];
+    if (!currentEvent || currentEvent.type != NSKeyDown)
+        return;
+
+    // Handling the key event may recurse back here through interpretKeyEvents
+    // (when IM is enabled), so we need to guard against that.
+    if (currentEvent == m_currentlyInterpretedKeyEvent)
+        return;
+
+    // Send Command+Key_Period and Escape as normal keypresses so that
+    // the key sequence is delivered through Qt. That way clients can
+    // intercept the shortcut and override its effect.
+    [self handleKeyEvent:currentEvent eventType:int(QEvent::KeyPress)];
+}
+
+- (void)flagsChanged:(NSEvent *)nsevent
+{
+    ulong timestamp = [nsevent timestamp] * 1000;
+    ulong modifiers = [nsevent modifierFlags];
+    Qt::KeyboardModifiers qmodifiers = [QNSView convertKeyModifiers:modifiers];
+
+    // calculate the delta and remember the current modifiers for next time
+    static ulong m_lastKnownModifiers;
+    ulong lastKnownModifiers = m_lastKnownModifiers;
+    ulong delta = lastKnownModifiers ^ modifiers;
+    m_lastKnownModifiers = modifiers;
+
+    struct qt_mac_enum_mapper
+    {
+        ulong mac_mask;
+        Qt::Key qt_code;
+    };
+    static qt_mac_enum_mapper modifier_key_symbols[] = {
+        { NSShiftKeyMask, Qt::Key_Shift },
+        { NSControlKeyMask, Qt::Key_Meta },
+        { NSCommandKeyMask, Qt::Key_Control },
+        { NSAlternateKeyMask, Qt::Key_Alt },
+        { NSAlphaShiftKeyMask, Qt::Key_CapsLock },
+        { 0ul, Qt::Key_unknown } };
+    for (int i = 0; modifier_key_symbols[i].mac_mask != 0u; ++i) {
+        uint mac_mask = modifier_key_symbols[i].mac_mask;
+        if ((delta & mac_mask) == 0u)
+            continue;
+
+        Qt::Key qtCode = modifier_key_symbols[i].qt_code;
+        if (qApp->testAttribute(Qt::AA_MacDontSwapCtrlAndMeta)) {
+            if (qtCode == Qt::Key_Meta)
+                qtCode = Qt::Key_Control;
+            else if (qtCode == Qt::Key_Control)
+                qtCode = Qt::Key_Meta;
+        }
+        QWindowSystemInterface::handleKeyEvent(m_platformWindow->window(),
+                                               timestamp,
+                                               (lastKnownModifiers & mac_mask) ? QEvent::KeyRelease : QEvent::KeyPress,
+                                               qtCode,
+                                               qmodifiers ^ [QNSView convertKeyModifiers:mac_mask]);
+    }
+}
+
+@end