Merge QGuiShortcut and QShortcut again in QtGui

QShortcut has only one widget specific feature, which is whatsThis; that
is just a QString, so the setters and getters can just as well be in
QtGui.

The widgets specific implementation of shortcut matching and of showing
the whatsThis balloon stays in QtWidgets, in the private implementation.
Using virtual functions in the private we can override the empty default
in QtGui, and by adding a virtual factory function in QGuiApplication,
the correct private is instantiated depending on the kind of application
running.

Change-Id: I09ae4a5482f9fb70940c5e2bfe76d3d7fd710afc
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

7 files changed, 669 insertions, 463 deletions

diff --git a/src/gui/kernel/kernel.pri b/src/gui/kernel/kernel.pri
index 518220ad3e..548bc18698 100644
--- a/src/gui/kernel/kernel.pri
+++ b/src/gui/kernel/kernel.pri
@@ -167,13 +167,13 @@ qtConfig(opengl) {
 
 qtConfig(shortcut) {
     HEADERS += \
-            kernel/qguishortcut.h \
-            kernel/qguishortcut_p.h \
+            kernel/qshortcut.h \
+            kernel/qshortcut_p.h \
             kernel/qshortcutmap_p.h \
             kernel/qkeysequence.h \
             kernel/qkeysequence_p.h
     SOURCES += \
-            kernel/qguishortcut.cpp \
+            kernel/qshortcut.cpp \
             kernel/qshortcutmap.cpp \
             kernel/qkeysequence.cpp
 }
diff --git a/src/gui/kernel/qguiapplication_p.h b/src/gui/kernel/qguiapplication_p.h
index 80649d067b..ab1e6a46cd 100644
--- a/src/gui/kernel/qguiapplication_p.h
+++ b/src/gui/kernel/qguiapplication_p.h
@@ -81,6 +81,9 @@ class QInputDeviceManager;
 #ifndef QT_NO_ACTION
 class QActionPrivate;
 #endif
+#if QT_CONFIG(shortcut)
+class QShortcutPrivate;
+#endif
 
 class Q_GUI_EXPORT QGuiApplicationPrivate : public QCoreApplicationPrivate
 {
@@ -332,6 +335,9 @@ public:
 #ifndef QT_NO_ACTION
     virtual QActionPrivate *createActionPrivate() const;
 #endif
+#ifndef QT_NO_SHORTCUT
+    virtual QShortcutPrivate *createShortcutPrivate() const;
+#endif
 
 protected:
     virtual void notifyThemeChanged();
diff --git a/src/gui/kernel/qguishortcut.cpp b/src/gui/kernel/qguishortcut.cpp
deleted file mode 100644
index add1dce12e..0000000000
--- a/src/gui/kernel/qguishortcut.cpp
+++ /dev/null
@@ -1,354 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2019 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui module 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$
-**
-****************************************************************************/
-
-#include "qguishortcut.h"
-#include "qguishortcut_p.h"
-
-#include <qevent.h>
-#include <qguiapplication.h>
-#include <qwindow.h>
-#include <private/qguiapplication_p.h>
-#include <qpa/qplatformmenu.h>
-
-QT_BEGIN_NAMESPACE
-
-#define QAPP_CHECK(functionName) \
-    if (Q_UNLIKELY(!qApp)) {                                            \
-        qWarning("QGuiShortcut: Initialize QGuiApplication before calling '" functionName "'."); \
-        return; \
-    }
-
-/*!
-    \class QGuiShortcut
-    \brief The QGuiShortcut class is a base class for handling keyboard shortcuts.
-
-    \ingroup events
-    \inmodule QtGui
-    \since 6.0
-
-    The QGuiShortcut class is a base class for classes providing a way of
-    connecting keyboard shortcuts to Qt's \l{signals and slots} mechanism,
-    so that objects can be informed when a shortcut is executed. The shortcut
-    can be set up to contain all the key presses necessary to
-    describe a keyboard shortcut, including the states of modifier
-    keys such as \uicontrol Shift, \uicontrol Ctrl, and \uicontrol Alt.
-
-    \target mnemonic
-
-    \sa QShortcutEvent, QKeySequence, QAction
-*/
-
-/*!
-    \fn void QGuiShortcut::activated()
-
-    This signal is emitted when the user types the shortcut's key
-    sequence.
-
-    \sa activatedAmbiguously()
-*/
-
-/*!
-    \fn void QGuiShortcut::activatedAmbiguously()
-
-    When a key sequence is being typed at the keyboard, it is said to
-    be ambiguous as long as it matches the start of more than one
-    shortcut.
-
-    When a shortcut's key sequence is completed,
-    activatedAmbiguously() is emitted if the key sequence is still
-    ambiguous (i.e., it is the start of one or more other shortcuts).
-    The activated() signal is not emitted in this case.
-
-    \sa activated()
-*/
-
-static bool simpleContextMatcher(QObject *object, Qt::ShortcutContext context)
-{
-    auto guiShortcut = qobject_cast<QGuiShortcut *>(object);
-    if (QGuiApplication::applicationState() != Qt::ApplicationActive || guiShortcut == nullptr)
-        return false;
-    if (context == Qt::ApplicationShortcut)
-        return true;
-    auto focusWindow = QGuiApplication::focusWindow();
-    if (!focusWindow)
-        return false;
-    auto window = qobject_cast<const QWindow *>(guiShortcut->parent());
-    if (!window)
-        return false;
-    if (focusWindow == window && focusWindow->isTopLevel())
-        return context == Qt::WindowShortcut || context == Qt::WidgetWithChildrenShortcut;
-    return focusWindow->isAncestorOf(window, QWindow::ExcludeTransients);
-}
-
-QShortcutMap::ContextMatcher QGuiShortcutPrivate::contextMatcher() const
-{
-    return simpleContextMatcher;
-}
-
-void QGuiShortcutPrivate::redoGrab(QShortcutMap &map)
-{
-    Q_Q(QGuiShortcut);
-    if (Q_UNLIKELY(!parent)) {
-        qWarning("QGuiShortcut: No window parent defined");
-        return;
-    }
-
-    if (sc_id)
-        map.removeShortcut(sc_id, q);
-    if (sc_sequence.isEmpty())
-        return;
-    sc_id = map.addShortcut(q, sc_sequence, sc_context, contextMatcher());
-    if (!sc_enabled)
-        map.setShortcutEnabled(false, sc_id, q);
-    if (!sc_autorepeat)
-        map.setShortcutAutoRepeat(false, sc_id, q);
-}
-
-/*!
-    Constructs a QGuiShortcut object for the \a parent window. Since no
-    shortcut key sequence is specified, the shortcut will not emit any
-    signals.
-
-    \sa setKey()
-*/
-QGuiShortcut::QGuiShortcut(QWindow *parent)
-    : QGuiShortcut(*new QGuiShortcutPrivate, parent)
-{
-}
-
-/*!
-    Constructs a QGuiShortcut object for the \a parent window. The shortcut
-    operates on its parent, listening for \l{QShortcutEvent}s that
-    match the \a key sequence. Depending on the ambiguity of the
-    event, the shortcut will call the \a member function, or the \a
-    ambiguousMember function, if the key press was in the shortcut's
-    \a context.
-*/
-QGuiShortcut::QGuiShortcut(const QKeySequence &key, QWindow *parent,
-                           const char *member, const char *ambiguousMember,
-                           Qt::ShortcutContext context)
-    : QGuiShortcut(*new QGuiShortcutPrivate, key, parent, member, ambiguousMember, context)
-{
-}
-
-/*!
-    \internal
-*/
-QGuiShortcut::QGuiShortcut(QGuiShortcutPrivate &dd, QObject *parent)
-     : QObject(dd, parent)
-{
-    Q_ASSERT(parent != nullptr);
-}
-
-/*!
-    \internal
-*/
-QGuiShortcut::QGuiShortcut(QGuiShortcutPrivate &dd,
-                           const QKeySequence &key, QObject *parent,
-                           const char *member, const char *ambiguousMember,
-                           Qt::ShortcutContext context)
-    : QGuiShortcut(dd, parent)
-{
-    QAPP_CHECK("QGuiShortcut");
-
-    Q_D(QGuiShortcut);
-    d->sc_context = context;
-    d->sc_sequence = key;
-    d->redoGrab(QGuiApplicationPrivate::instance()->shortcutMap);
-    if (member)
-        connect(this, SIGNAL(activated()), parent, member);
-    if (ambiguousMember)
-        connect(this, SIGNAL(activatedAmbiguously()), parent, ambiguousMember);
-}
-
-/*!
-    Destroys the shortcut.
-*/
-QGuiShortcut::~QGuiShortcut()
-{
-    Q_D(QGuiShortcut);
-    if (qApp)
-        QGuiApplicationPrivate::instance()->shortcutMap.removeShortcut(d->sc_id, this);
-}
-
-/*!
-    \property QGuiShortcut::key
-    \brief the shortcut's key sequence
-
-    This is a key sequence with an optional combination of Shift, Ctrl,
-    and Alt. The key sequence may be supplied in a number of ways:
-
-    \snippet code/src_gui_kernel_qshortcut.cpp 1
-
-    By default, this property contains an empty key sequence.
-*/
-void QGuiShortcut::setKey(const QKeySequence &key)
-{
-    Q_D(QGuiShortcut);
-    if (d->sc_sequence == key)
-        return;
-    QAPP_CHECK("setKey");
-    d->sc_sequence = key;
-    d->redoGrab(QGuiApplicationPrivate::instance()->shortcutMap);
-}
-
-QKeySequence QGuiShortcut::key() const
-{
-    Q_D(const QGuiShortcut);
-    return d->sc_sequence;
-}
-
-/*!
-    \property QGuiShortcut::enabled
-    \brief whether the shortcut is enabled
-
-    An enabled shortcut emits the activated() or activatedAmbiguously()
-    signal when a QShortcutEvent occurs that matches the shortcut's
-    key() sequence.
-
-    If the application is in \c WhatsThis mode the shortcut will not emit
-    the signals, but will show the "What's This?" text instead.
-
-    By default, this property is \c true.
-
-    \sa whatsThis
-*/
-void QGuiShortcut::setEnabled(bool enable)
-{
-    Q_D(QGuiShortcut);
-    if (d->sc_enabled == enable)
-        return;
-    QAPP_CHECK("setEnabled");
-    d->sc_enabled = enable;
-    QGuiApplicationPrivate::instance()->shortcutMap.setShortcutEnabled(enable, d->sc_id, this);
-}
-
-bool QGuiShortcut::isEnabled() const
-{
-    Q_D(const QGuiShortcut);
-    return d->sc_enabled;
-}
-
-/*!
-    \property QGuiShortcut::context
-    \brief the context in which the shortcut is valid
-
-    A shortcut's context decides in which circumstances a shortcut is
-    allowed to be triggered. The normal context is Qt::WindowShortcut,
-    which allows the shortcut to trigger if the parent (the widget
-    containing the shortcut) is a subwidget of the active top-level
-    window.
-
-    By default, this property is set to Qt::WindowShortcut.
-*/
-void QGuiShortcut::setContext(Qt::ShortcutContext context)
-{
-    Q_D(QGuiShortcut);
-    if (d->sc_context == context)
-        return;
-    QAPP_CHECK("setContext");
-    d->sc_context = context;
-    d->redoGrab(QGuiApplicationPrivate::instance()->shortcutMap);
-}
-
-Qt::ShortcutContext QGuiShortcut::context() const
-{
-    Q_D(const QGuiShortcut);
-    return d->sc_context;
-}
-
-/*!
-    \property QGuiShortcut::autoRepeat
-    \brief whether the shortcut can auto repeat
-
-    If true, the shortcut will auto repeat when the keyboard shortcut
-    combination is held down, provided that keyboard auto repeat is
-    enabled on the system.
-    The default value is true.
-*/
-void QGuiShortcut::setAutoRepeat(bool on)
-{
-    Q_D(QGuiShortcut);
-    if (d->sc_autorepeat == on)
-        return;
-    QAPP_CHECK("setAutoRepeat");
-    d->sc_autorepeat = on;
-    QGuiApplicationPrivate::instance()->shortcutMap.setShortcutAutoRepeat(on, d->sc_id, this);
-}
-
-bool QGuiShortcut::autoRepeat() const
-{
-    Q_D(const QGuiShortcut);
-    return d->sc_autorepeat;
-}
-
-/*!
-    Returns the shortcut's ID.
-
-    \sa QShortcutEvent::shortcutId()
-*/
-int QGuiShortcut::id() const
-{
-    Q_D(const QGuiShortcut);
-    return d->sc_id;
-}
-
-/*!
-    \internal
-*/
-bool QGuiShortcut::event(QEvent *e)
-{
-    Q_D(QGuiShortcut);
-    if (d->sc_enabled && e->type() == QEvent::Shortcut) {
-        auto se = static_cast<QShortcutEvent *>(e);
-        if (se->shortcutId() == d->sc_id && se->key() == d->sc_sequence
-            && !d->handleWhatsThis()) {
-            if (se->isAmbiguous())
-                emit activatedAmbiguously();
-            else
-                emit activated();
-            return true;
-        }
-    }
-    return QObject::event(e);
-}
-
-QT_END_NAMESPACE
-
-#include "moc_qguishortcut.cpp"
diff --git a/src/gui/kernel/qguishortcut.h b/src/gui/kernel/qguishortcut.h
deleted file mode 100644
index fb64f10c84..0000000000
--- a/src/gui/kernel/qguishortcut.h
+++ /dev/null
@@ -1,98 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2019 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtGui module 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$
-**
-****************************************************************************/
-
-#ifndef QGUISHORTCUT_H
-#define QGUISHORTCUT_H
-
-#include <QtGui/qtguiglobal.h>
-#include <QtGui/qkeysequence.h>
-#include <QtCore/qobject.h>
-
-QT_REQUIRE_CONFIG(shortcut);
-
-QT_BEGIN_NAMESPACE
-
-class QGuiShortcutPrivate;
-class QWindow;
-
-class Q_GUI_EXPORT QGuiShortcut : public QObject
-{
-    Q_OBJECT
-    Q_DECLARE_PRIVATE(QGuiShortcut)
-    Q_PROPERTY(QKeySequence key READ key WRITE setKey)
-    Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled)
-    Q_PROPERTY(bool autoRepeat READ autoRepeat WRITE setAutoRepeat)
-    Q_PROPERTY(Qt::ShortcutContext context READ context WRITE setContext)
-public:
-    explicit QGuiShortcut(QWindow *parent);
-    explicit QGuiShortcut(const QKeySequence& key, QWindow *parent,
-                          const char *member = nullptr, const char *ambiguousMember = nullptr,
-                          Qt::ShortcutContext context = Qt::WindowShortcut);
-    ~QGuiShortcut();
-
-    void setKey(const QKeySequence& key);
-    QKeySequence key() const;
-
-    void setEnabled(bool enable);
-    bool isEnabled() const;
-
-    void setContext(Qt::ShortcutContext context);
-    Qt::ShortcutContext context() const;
-
-    void setAutoRepeat(bool on);
-    bool autoRepeat() const;
-
-    int id() const;
-
-Q_SIGNALS:
-    void activated();
-    void activatedAmbiguously();
-
-protected:
-    QGuiShortcut(QGuiShortcutPrivate &dd, QObject *parent);
-    QGuiShortcut(QGuiShortcutPrivate &dd, const QKeySequence& key, QObject *parent,
-                 const char *member, const char *ambiguousMember,
-                 Qt::ShortcutContext context);
-
-    bool event(QEvent *e) override;
-};
-
-QT_END_NAMESPACE
-
-#endif // QGUISHORTCUT_H
diff --git a/src/gui/kernel/qshortcut.cpp b/src/gui/kernel/qshortcut.cpp
new file mode 100644
index 0000000000..c4305d5a7f
--- /dev/null
+++ b/src/gui/kernel/qshortcut.cpp
@@ -0,0 +1,483 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtGui module 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$
+**
+****************************************************************************/
+
+#include "qshortcut.h"
+#include "qshortcut_p.h"
+
+#include <qevent.h>
+#include <qguiapplication.h>
+#include <qwindow.h>
+#include <private/qguiapplication_p.h>
+#include <qpa/qplatformmenu.h>
+
+QT_BEGIN_NAMESPACE
+
+#define QAPP_CHECK(functionName) \
+    if (Q_UNLIKELY(!qApp)) {                                            \
+        qWarning("QShortcut: Initialize QGuiApplication before calling '" functionName "'."); \
+        return; \
+    }
+
+/*!
+    \class QShortcut
+    \brief The QShortcut class is used to create keyboard shortcuts.
+
+    \ingroup events
+    \inmodule QtGui
+
+    The QShortcut class provides a way of connecting keyboard
+    shortcuts to Qt's \l{signals and slots} mechanism, so that
+    objects can be informed when a shortcut is executed. The shortcut
+    can be set up to contain all the key presses necessary to
+    describe a keyboard shortcut, including the states of modifier
+    keys such as \uicontrol Shift, \uicontrol Ctrl, and \uicontrol Alt.
+
+    \target mnemonic
+
+    In widget applications, certain widgets can use '&' in front of a character.
+    This will automatically create a mnemonic (a shortcut) for that character,
+    e.g. "E&xit" will create the shortcut \uicontrol Alt+X (use '&&'
+    to display an actual ampersand). The widget might consume and perform
+    an action on a given shortcut. On X11 the ampersand will not be
+    shown and the character will be underlined. On Windows, shortcuts
+    are normally not displayed until the user presses the \uicontrol Alt
+    key, but this is a setting the user can change. On Mac, shortcuts
+    are disabled by default. Call \l qt_set_sequence_auto_mnemonic() to
+    enable them. However, because mnemonic shortcuts do not fit in
+    with Aqua's guidelines, Qt will not show the shortcut character
+    underlined.
+
+    For applications that use menus, it may be more convenient to
+    use the convenience functions provided in the QMenu class to
+    assign keyboard shortcuts to menu items as they are created.
+    Alternatively, shortcuts may be associated with other types of
+    actions in the QAction class.
+
+    The simplest way to create a shortcut for a particular widget is
+    to construct the shortcut with a key sequence. For example:
+
+    \snippet code/src_gui_kernel_qshortcut.cpp 0
+
+    When the user types the \l{QKeySequence}{key sequence}
+    for a given shortcut, the shortcut's activated() signal is
+    emitted. (In the case of ambiguity, the activatedAmbiguously()
+    signal is emitted.) A shortcut is "listened for" by Qt's event
+    loop when the shortcut's parent widget is receiving events.
+
+    A shortcut's key sequence can be set with setKey() and retrieved
+    with key(). A shortcut can be enabled or disabled with
+    setEnabled(), and can have "What's This?" help text set with
+    setWhatsThis().
+
+    \sa QShortcutEvent, QKeySequence, QAction
+*/
+
+/*!
+    \fn void QShortcut::activated()
+
+    This signal is emitted when the user types the shortcut's key
+    sequence.
+
+    \sa activatedAmbiguously()
+*/
+
+/*!
+    \fn void QShortcut::activatedAmbiguously()
+
+    When a key sequence is being typed at the keyboard, it is said to
+    be ambiguous as long as it matches the start of more than one
+    shortcut.
+
+    When a shortcut's key sequence is completed,
+    activatedAmbiguously() is emitted if the key sequence is still
+    ambiguous (i.e., it is the start of one or more other shortcuts).
+    The activated() signal is not emitted in this case.
+
+    \sa activated()
+*/
+
+static bool simpleContextMatcher(QObject *object, Qt::ShortcutContext context)
+{
+    auto guiShortcut = qobject_cast<QShortcut *>(object);
+    if (QGuiApplication::applicationState() != Qt::ApplicationActive || guiShortcut == nullptr)
+        return false;
+    if (context == Qt::ApplicationShortcut)
+        return true;
+    auto focusWindow = QGuiApplication::focusWindow();
+    if (!focusWindow)
+        return false;
+    auto window = qobject_cast<const QWindow *>(guiShortcut->parent());
+    if (!window)
+        return false;
+    if (focusWindow == window && focusWindow->isTopLevel())
+        return context == Qt::WindowShortcut || context == Qt::WidgetWithChildrenShortcut;
+    return focusWindow->isAncestorOf(window, QWindow::ExcludeTransients);
+}
+
+QShortcutMap::ContextMatcher QShortcutPrivate::contextMatcher() const
+{
+    return simpleContextMatcher;
+}
+
+void QShortcutPrivate::redoGrab(QShortcutMap &map)
+{
+    Q_Q(QShortcut);
+    if (Q_UNLIKELY(!parent)) {
+        qWarning("QShortcut: No window parent defined");
+        return;
+    }
+
+    if (sc_id)
+        map.removeShortcut(sc_id, q);
+    if (sc_sequence.isEmpty())
+        return;
+    sc_id = map.addShortcut(q, sc_sequence, sc_context, contextMatcher());
+    if (!sc_enabled)
+        map.setShortcutEnabled(false, sc_id, q);
+    if (!sc_autorepeat)
+        map.setShortcutAutoRepeat(false, sc_id, q);
+}
+
+QShortcutPrivate *QGuiApplicationPrivate::createShortcutPrivate() const
+{
+    return new QShortcutPrivate;
+}
+
+/*!
+    Constructs a QShortcut object for the \a parent, which should be a
+    QWindow or a QWidget.
+
+    Since no shortcut key sequence is specified, the shortcut will not emit any
+    signals.
+
+    \sa setKey()
+*/
+QShortcut::QShortcut(QObject *parent)
+    : QObject(*QGuiApplicationPrivate::instance()->createShortcutPrivate(), parent)
+{
+    Q_ASSERT(parent != nullptr);
+}
+
+/*!
+    Constructs a QShortcut object for the \a parent, which should be a
+    QWindow or a QWidget.
+
+    The shortcut operates on its parent, listening for \l{QShortcutEvent}s that
+    match the \a key sequence. Depending on the ambiguity of the event, the
+    shortcut will call the \a member function, or the \a ambiguousMember function,
+    if the key press was in the shortcut's \a context.
+*/
+QShortcut::QShortcut(const QKeySequence &key, QObject *parent,
+                           const char *member, const char *ambiguousMember,
+                           Qt::ShortcutContext context)
+    : QShortcut(parent)
+{
+    Q_D(QShortcut);
+    d->sc_context = context;
+    d->sc_sequence = key;
+    d->redoGrab(QGuiApplicationPrivate::instance()->shortcutMap);
+    if (member)
+        connect(this, SIGNAL(activated()), parent, member);
+    if (ambiguousMember)
+        connect(this, SIGNAL(activatedAmbiguously()), parent, ambiguousMember);
+}
+
+
+/*!
+    \fn template<typename Functor>
+        QShortcut(const QKeySequence &key, QObject *parent,
+                  Functor functor,
+                  Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
+    \since 5.15
+    \overload
+
+    This is a QShortcut convenience constructor which connects the shortcut's
+    \l{QShortcut::activated()}{activated()} signal to the \a functor.
+*/
+/*!
+    \fn template<typename Functor>
+        QShortcut(const QKeySequence &key, QObject *parent,
+                  const QObject *context, Functor functor,
+                  Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
+    \since 5.15
+    \overload
+
+    This is a QShortcut convenience constructor which connects the shortcut's
+    \l{QShortcut::activated()}{activated()} signal to the \a functor.
+
+    The \a functor can be a pointer to a member function of the \a context object.
+
+    If the \a context object is destroyed, the \a functor will not be called.
+*/
+/*!
+    \fn template<typename Functor, typename FunctorAmbiguous>
+        QShortcut(const QKeySequence &key, QObject *parent,
+                  const QObject *context1, Functor functor,
+                  FunctorAmbiguous functorAmbiguous,
+                  Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
+    \since 5.15
+    \overload
+
+    This is a QShortcut convenience constructor which connects the shortcut's
+    \l{QShortcut::activated()}{activated()} signal to the \a functor and
+    \l{QShortcut::activatedAmbiguously()}{activatedAmbiguously()}
+    signal to the \a FunctorAmbiguous.
+
+    The \a functor and \a FunctorAmbiguous can be a pointer to a member
+    function of the \a context object.
+
+    If the \a context object is destroyed, the \a functor and
+    \a FunctorAmbiguous will not be called.
+*/
+/*!
+    \fn template<typename Functor, typename FunctorAmbiguous>
+        QShortcut(const QKeySequence &key, QObject *parent,
+                  const QObject *context1, Functor functor,
+                  const QObject *context2, FunctorAmbiguous functorAmbiguous,
+                  Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
+    \since 5.15
+    \overload
+
+    This is a QShortcut convenience constructor which connects the shortcut's
+    \l{QShortcut::activated()}{activated()} signal to the \a functor and
+    \l{QShortcut::activatedAmbiguously()}{activatedAmbiguously()}
+    signal to the \a FunctorAmbiguous.
+
+    The \a functor can be a pointer to a member function of the
+    \a context1 object.
+    The \a FunctorAmbiguous can be a pointer to a member function of the
+    \a context2 object.
+
+    If the \a context1 object is destroyed, the \a functor will not be called.
+    If the \a context2 object is destroyed, the \a FunctorAmbiguous
+    will not be called.
+*/
+
+/*!
+    Destroys the shortcut.
+*/
+QShortcut::~QShortcut()
+{
+    Q_D(QShortcut);
+    if (qApp)
+        QGuiApplicationPrivate::instance()->shortcutMap.removeShortcut(d->sc_id, this);
+}
+
+/*!
+    \property QShortcut::key
+    \brief the shortcut's key sequence
+
+    This is a key sequence with an optional combination of Shift, Ctrl,
+    and Alt. The key sequence may be supplied in a number of ways:
+
+    \snippet code/src_gui_kernel_qshortcut.cpp 1
+
+    By default, this property contains an empty key sequence.
+*/
+void QShortcut::setKey(const QKeySequence &key)
+{
+    Q_D(QShortcut);
+    if (d->sc_sequence == key)
+        return;
+    QAPP_CHECK("setKey");
+    d->sc_sequence = key;
+    d->redoGrab(QGuiApplicationPrivate::instance()->shortcutMap);
+}
+
+QKeySequence QShortcut::key() const
+{
+    Q_D(const QShortcut);
+    return d->sc_sequence;
+}
+
+/*!
+    \property QShortcut::enabled
+    \brief whether the shortcut is enabled
+
+    An enabled shortcut emits the activated() or activatedAmbiguously()
+    signal when a QShortcutEvent occurs that matches the shortcut's
+    key() sequence.
+
+    If the application is in \c WhatsThis mode the shortcut will not emit
+    the signals, but will show the "What's This?" text instead.
+
+    By default, this property is \c true.
+
+    \sa whatsThis
+*/
+void QShortcut::setEnabled(bool enable)
+{
+    Q_D(QShortcut);
+    if (d->sc_enabled == enable)
+        return;
+    QAPP_CHECK("setEnabled");
+    d->sc_enabled = enable;
+    QGuiApplicationPrivate::instance()->shortcutMap.setShortcutEnabled(enable, d->sc_id, this);
+}
+
+bool QShortcut::isEnabled() const
+{
+    Q_D(const QShortcut);
+    return d->sc_enabled;
+}
+
+/*!
+    \property QShortcut::context
+    \brief the context in which the shortcut is valid
+
+    A shortcut's context decides in which circumstances a shortcut is
+    allowed to be triggered. The normal context is Qt::WindowShortcut,
+    which allows the shortcut to trigger if the parent (the widget
+    containing the shortcut) is a subwidget of the active top-level
+    window.
+
+    By default, this property is set to Qt::WindowShortcut.
+*/
+void QShortcut::setContext(Qt::ShortcutContext context)
+{
+    Q_D(QShortcut);
+    if (d->sc_context == context)
+        return;
+    QAPP_CHECK("setContext");
+    d->sc_context = context;
+    d->redoGrab(QGuiApplicationPrivate::instance()->shortcutMap);
+}
+
+Qt::ShortcutContext QShortcut::context() const
+{
+    Q_D(const QShortcut);
+    return d->sc_context;
+}
+
+/*!
+    \property QShortcut::autoRepeat
+    \brief whether the shortcut can auto repeat
+
+    If true, the shortcut will auto repeat when the keyboard shortcut
+    combination is held down, provided that keyboard auto repeat is
+    enabled on the system.
+    The default value is true.
+*/
+void QShortcut::setAutoRepeat(bool on)
+{
+    Q_D(QShortcut);
+    if (d->sc_autorepeat == on)
+        return;
+    QAPP_CHECK("setAutoRepeat");
+    d->sc_autorepeat = on;
+    QGuiApplicationPrivate::instance()->shortcutMap.setShortcutAutoRepeat(on, d->sc_id, this);
+}
+
+bool QShortcut::autoRepeat() const
+{
+    Q_D(const QShortcut);
+    return d->sc_autorepeat;
+}
+
+
+/*!
+    \property QShortcut::whatsThis
+    \brief the shortcut's "What's This?" help text
+
+    The text will be shown when a widget application is in "What's
+    This?" mode and the user types the shortcut key() sequence.
+
+    To set "What's This?" help on a menu item (with or without a
+    shortcut key), set the help on the item's action.
+
+    By default, this property contains an empty string.
+
+    This property has no effect in applications that don't use
+    widgets.
+
+    \sa QWhatsThis::inWhatsThisMode(), QAction::setWhatsThis()
+*/
+void QShortcut::setWhatsThis(const QString &text)
+{
+    Q_D(QShortcut);
+    d->sc_whatsthis = text;
+}
+
+QString QShortcut::whatsThis() const
+{
+    Q_D(const QShortcut);
+    return d->sc_whatsthis;
+}
+
+
+/*!
+    Returns the shortcut's ID.
+
+    \sa QShortcutEvent::shortcutId()
+*/
+int QShortcut::id() const
+{
+    Q_D(const QShortcut);
+    return d->sc_id;
+}
+
+/*!
+    \fn QWidget *QShortcut::parentWidget() const
+
+    Returns the shortcut's parent widget.
+*/
+
+/*!
+    \internal
+*/
+bool QShortcut::event(QEvent *e)
+{
+    Q_D(QShortcut);
+    if (d->sc_enabled && e->type() == QEvent::Shortcut) {
+        auto se = static_cast<QShortcutEvent *>(e);
+        if (se->shortcutId() == d->sc_id && se->key() == d->sc_sequence
+            && !d->handleWhatsThis()) {
+            if (se->isAmbiguous())
+                emit activatedAmbiguously();
+            else
+                emit activated();
+            return true;
+        }
+    }
+    return QObject::event(e);
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qshortcut.cpp"
diff --git a/src/gui/kernel/qshortcut.h b/src/gui/kernel/qshortcut.h
new file mode 100644
index 0000000000..1b90a21925
--- /dev/null
+++ b/src/gui/kernel/qshortcut.h
@@ -0,0 +1,168 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtGui module 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$
+**
+****************************************************************************/
+
+#ifndef QSHORTCUT_H
+#define QSHORTCUT_H
+
+#include <QtGui/qtguiglobal.h>
+#include <QtGui/qkeysequence.h>
+#include <QtCore/qobject.h>
+
+QT_REQUIRE_CONFIG(shortcut);
+
+QT_BEGIN_NAMESPACE
+
+class QShortcutPrivate;
+class QWindow;
+
+class Q_GUI_EXPORT QShortcut : public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QShortcut)
+    Q_PROPERTY(QKeySequence key READ key WRITE setKey)
+    Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled)
+    Q_PROPERTY(bool autoRepeat READ autoRepeat WRITE setAutoRepeat)
+    Q_PROPERTY(Qt::ShortcutContext context READ context WRITE setContext)
+public:
+    explicit QShortcut(QObject *parent);
+    explicit QShortcut(const QKeySequence& key, QObject *parent,
+                       const char *member = nullptr, const char *ambiguousMember = nullptr,
+                       Qt::ShortcutContext context = Qt::WindowShortcut);
+
+#ifdef Q_CLANG_QDOC
+    template<typename Functor>
+    QShortcut(const QKeySequence &key, QObject *parent,
+              Functor functor,
+              Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
+    template<typename Functor>
+    QShortcut(const QKeySequence &key, QObject *parent,
+              const QObject *context, Functor functor,
+              Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
+    template<typename Functor, typename FunctorAmbiguous>
+    QShortcut(const QKeySequence &key, QObject *parent,
+              const QObject *context1, Functor functor,
+              FunctorAmbiguous functorAmbiguous,
+              Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
+    template<typename Functor, typename FunctorAmbiguous>
+    QShortcut(const QKeySequence &key, QObject *parent,
+              const QObject *context1, Functor functor,
+              const QObject *context2, FunctorAmbiguous functorAmbiguous,
+              Qt::ShortcutContext shortcutContext = Qt::WindowShortcut);
+#else
+    template<typename Func1>
+    QShortcut(const QKeySequence &key, QObject *parent,
+              Func1 slot1,
+              Qt::ShortcutContext context = Qt::WindowShortcut)
+        : QShortcut(key, parent, static_cast<const char*>(nullptr), static_cast<const char*>(nullptr), context)
+    {
+        connect(this, &QShortcut::activated, std::move(slot1));
+    }
+    template<class Obj1, typename Func1>
+    QShortcut(const QKeySequence &key, QObject *parent,
+              const Obj1 *object1, Func1 slot1,
+              Qt::ShortcutContext context = Qt::WindowShortcut,
+              typename std::enable_if<QtPrivate::IsPointerToTypeDerivedFromQObject<Obj1*>::Value>::type* = 0)
+        : QShortcut(key, parent, static_cast<const char*>(nullptr), static_cast<const char*>(nullptr), context)
+    {
+        connect(this, &QShortcut::activated, object1, std::move(slot1));
+    }
+    template<class Obj1, typename Func1, typename Func2>
+    QShortcut(const QKeySequence &key, QObject *parent,
+              const Obj1 *object1, Func1 slot1, Func2 slot2,
+              Qt::ShortcutContext context = Qt::WindowShortcut,
+              typename std::enable_if<QtPrivate::IsPointerToTypeDerivedFromQObject<Obj1*>::Value>::type* = 0)
+        : QShortcut(key, parent, static_cast<const char*>(nullptr), static_cast<const char*>(nullptr), context)
+    {
+        connect(this, &QShortcut::activated, object1, std::move(slot1));
+        connect(this, &QShortcut::activatedAmbiguously, object1, std::move(slot2));
+    }
+    template<class Obj1, typename Func1, class Obj2, typename Func2>
+    QShortcut(const QKeySequence &key, QObject *parent,
+              const Obj1 *object1, Func1 slot1,
+              const Obj2 *object2, Func2 slot2,
+              Qt::ShortcutContext context = Qt::WindowShortcut,
+              typename std::enable_if<QtPrivate::IsPointerToTypeDerivedFromQObject<Obj1*>::Value>::type* = 0,
+              typename std::enable_if<QtPrivate::IsPointerToTypeDerivedFromQObject<Obj2*>::Value>::type* = 0)
+        : QShortcut(key, parent, static_cast<const char*>(nullptr), static_cast<const char*>(nullptr), context)
+    {
+        connect(this, &QShortcut::activated, object1, std::move(slot1));
+        connect(this, &QShortcut::activatedAmbiguously, object2, std::move(slot2));
+    }
+#endif
+
+    ~QShortcut();
+
+    void setKey(const QKeySequence& key);
+    QKeySequence key() const;
+
+    void setEnabled(bool enable);
+    bool isEnabled() const;
+
+    void setContext(Qt::ShortcutContext context);
+    Qt::ShortcutContext context() const;
+
+    void setAutoRepeat(bool on);
+    bool autoRepeat() const;
+
+    int id() const;
+
+    void setWhatsThis(const QString &text);
+    QString whatsThis() const;
+
+#if QT_DEPRECATED_SINCE(6,0)
+#ifdef Q_CLANG_QDOC
+    QWidget *parentWidget() const;
+#else
+    template<typename T = QWidget*>
+    inline T parentWidget() const
+    { return static_cast<T>(QObject::parent()); }
+#endif
+#endif
+
+Q_SIGNALS:
+    void activated();
+    void activatedAmbiguously();
+
+protected:
+    bool event(QEvent *e) override;
+};
+
+QT_END_NAMESPACE
+
+#endif // QSHORTCUT_H
diff --git a/src/gui/kernel/qguishortcut_p.h b/src/gui/kernel/qshortcut_p.h
index 420b02ef1a..254745960f 100644
--- a/src/gui/kernel/qguishortcut_p.h
+++ b/src/gui/kernel/qshortcut_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2019 The Qt Company Ltd.
+** Copyright (C) 2020 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -37,8 +37,8 @@
 **
 ****************************************************************************/
 
-#ifndef QGUISHORTCUT_P_H
-#define QGUISHORTCUT_P_H
+#ifndef QSHORTCUT_P_H
+#define QSHORTCUT_P_H
 
 //
 //  W A R N I N G
@@ -52,7 +52,7 @@
 //
 
 #include <QtGui/private/qtguiglobal_p.h>
-#include "qguishortcut.h"
+#include "qshortcut.h"
 #include <QtGui/qkeysequence.h>
 
 #include <QtCore/qstring.h>
@@ -70,16 +70,17 @@ class QShortcutMap;
     \internal
     Private data accessed through d-pointer.
 */
-class Q_GUI_EXPORT QGuiShortcutPrivate : public QObjectPrivate
+class Q_GUI_EXPORT QShortcutPrivate : public QObjectPrivate
 {
-    Q_DECLARE_PUBLIC(QGuiShortcut)
+    Q_DECLARE_PUBLIC(QShortcut)
 public:
-    QGuiShortcutPrivate() = default;
+    QShortcutPrivate() = default;
 
     virtual QShortcutMap::ContextMatcher contextMatcher() const;
     virtual bool handleWhatsThis() { return false; }
 
     QKeySequence sc_sequence;
+    QString sc_whatsthis;
     Qt::ShortcutContext sc_context = Qt::WindowShortcut;
     bool sc_enabled = true;
     bool sc_autorepeat = true;
@@ -89,4 +90,4 @@ public:
 
 QT_END_NAMESPACE
 
-#endif // QGUISHORTCUT_P_H
+#endif // QSHORTCUT_P_H