qshortcut.cpp

Go to the documentation of this file.

// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#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; \
    }
 
bool QShortcutPrivate::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;
    }
 
    for (int id : std::as_const(sc_ids))
        map.removeShortcut(id, q);
 
    sc_ids.clear();
    if (sc_sequences.isEmpty())
        return;
    sc_ids.reserve(sc_sequences.size());
    for (const auto &keySequence : std::as_const(sc_sequences)) {
        if (keySequence.isEmpty())
            continue;
        int id = map.addShortcut(q, keySequence, sc_context, contextMatcher());
        sc_ids.append(id);
        if (!sc_enabled)
            map.setShortcutEnabled(false, id, q);
        if (!sc_autorepeat)
            map.setShortcutAutoRepeat(false, id, q);
    }
}
 
QShortcutPrivate *QGuiApplicationPrivate::createShortcutPrivate() const
{
    return new QShortcutPrivate;
}
 
QShortcut::QShortcut(QObject *parent)
    : QObject(*QGuiApplicationPrivate::instance()->createShortcutPrivate(), parent)
{
    Q_ASSERT(parent != nullptr);
}
 
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;
    if (!key.isEmpty()) {
        d->sc_sequences = { key };
        d->redoGrab(QGuiApplicationPrivate::instance()->shortcutMap);
    }
    if (member)
        connect(this, SIGNAL(activated()), parent, member);
    if (ambiguousMember)
        connect(this, SIGNAL(activatedAmbiguously()), parent, ambiguousMember);
}
 
QShortcut::QShortcut(QKeySequence::StandardKey standardKey, QObject *parent,
                     const char *member, const char *ambiguousMember,
                     Qt::ShortcutContext context)
    : QShortcut(parent)
{
    Q_D(QShortcut);
    d->sc_context = context;
    d->sc_sequences = QKeySequence::keyBindings(standardKey);
    d->redoGrab(QGuiApplicationPrivate::instance()->shortcutMap);
    if (member)
        connect(this, SIGNAL(activated()), parent, member);
    if (ambiguousMember)
        connect(this, SIGNAL(activatedAmbiguously()), parent, ambiguousMember);
}
 
 
QShortcut::~QShortcut()
{
    Q_D(QShortcut);
    if (qApp) {
         for (int id : std::as_const(d->sc_ids))
             QGuiApplicationPrivate::instance()->shortcutMap.removeShortcut(id, this);
    }
}
 
void QShortcut::setKey(const QKeySequence &key)
{
    if (key.isEmpty())
        setKeys({});
    else
        setKeys({ key });
}
 
QKeySequence QShortcut::key() const
{
    Q_D(const QShortcut);
    if (d->sc_sequences.isEmpty())
        return QKeySequence();
    return d->sc_sequences.first();
}
 
void QShortcut::setKeys(const QList<QKeySequence> &keys)
{
    Q_D(QShortcut);
    if (d->sc_sequences == keys)
        return;
    QAPP_CHECK("setKeys");
    d->sc_sequences = keys;
    d->redoGrab(QGuiApplicationPrivate::instance()->shortcutMap);
}
 
void QShortcut::setKeys(QKeySequence::StandardKey key)
{
    setKeys(QKeySequence::keyBindings(key));
}
 
QList<QKeySequence> QShortcut::keys() const
{
    Q_D(const QShortcut);
    return d->sc_sequences;
}
 
void QShortcut::setEnabled(bool enable)
{
    Q_D(QShortcut);
    if (d->sc_enabled == enable)
        return;
    QAPP_CHECK("setEnabled");
    d->sc_enabled = enable;
    for (int id : d->sc_ids)
        QGuiApplicationPrivate::instance()->shortcutMap.setShortcutEnabled(enable, id, this);
}
 
bool QShortcut::isEnabled() const
{
    Q_D(const QShortcut);
    return d->sc_enabled;
}
 
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;
}
 
void QShortcut::setAutoRepeat(bool on)
{
    Q_D(QShortcut);
    if (d->sc_autorepeat == on)
        return;
    QAPP_CHECK("setAutoRepeat");
    d->sc_autorepeat = on;
    for (int id : d->sc_ids)
        QGuiApplicationPrivate::instance()->shortcutMap.setShortcutAutoRepeat(on, id, this);
}
 
bool QShortcut::autoRepeat() const
{
    Q_D(const QShortcut);
    return d->sc_autorepeat;
}
 
 
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;
}
 
#if QT_DEPRECATED_SINCE(6,0)
int QShortcut::id() const
{
    Q_D(const QShortcut);
    if (d->sc_ids.isEmpty())
        return 0;
    return d->sc_ids.first();
}
#endif
 
bool QShortcut::event(QEvent *e)
{
    Q_D(QShortcut);
    if (d->sc_enabled && e->type() == QEvent::Shortcut) {
        auto se = static_cast<QShortcutEvent *>(e);
        if (!d->handleWhatsThis()) {
            Q_ASSERT_X(d->sc_ids.contains(se->shortcutId()), "QShortcut::event", "Received shortcut event from wrong shortcut");
            if (se->isAmbiguous())
                emit activatedAmbiguously();
            else
                emit activated();
            return true;
        }
    }
    return QObject::event(e);
}
 
QT_END_NAMESPACE
 
#include "moc_qshortcut.cpp"