qquickaction.cpp

Go to the documentation of this file.

// Copyright (C) 2017 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 "qquickaction_p.h"
#include "qquickaction_p_p.h"
#include "qquickactiongroup_p.h"
#include "qquickshortcutcontext_p_p.h"
 
#include <QtGui/qevent.h>
#if QT_CONFIG(shortcut)
#  include <QtGui/private/qshortcutmap_p.h>
#endif
#include <QtGui/private/qguiapplication_p.h>
#include <QtQuick/private/qquickitem_p.h>
 
QT_BEGIN_NAMESPACE
 
 
#if QT_CONFIG(shortcut)
static QKeySequence variantToKeySequence(const QVariant &var)
{
    if (var.metaType().id() == QMetaType::Int)
        return QKeySequence(static_cast<QKeySequence::StandardKey>(var.toInt()));
    return QKeySequence::fromString(var.toString());
}
 
QQuickActionPrivate::ShortcutEntry::ShortcutEntry(QObject *target)
    : m_target(target)
{
}
 
QQuickActionPrivate::ShortcutEntry::~ShortcutEntry()
{
    ungrab();
}
 
QObject *QQuickActionPrivate::ShortcutEntry::target() const
{
    return m_target;
}
 
int QQuickActionPrivate::ShortcutEntry::shortcutId() const
{
    return m_shortcutId;
}
 
void QQuickActionPrivate::ShortcutEntry::grab(const QKeySequence &shortcut, bool enabled)
{
    if (shortcut.isEmpty() || m_shortcutId)
        return;
 
    Qt::ShortcutContext context = Qt::WindowShortcut; // TODO
    m_shortcutId = QGuiApplicationPrivate::instance()->shortcutMap.addShortcut(m_target, shortcut, context, QQuickShortcutContext::matcher);
 
    if (!enabled)
        QGuiApplicationPrivate::instance()->shortcutMap.setShortcutEnabled(false, m_shortcutId, m_target);
}
 
void QQuickActionPrivate::ShortcutEntry::ungrab()
{
    if (!m_shortcutId)
        return;
 
    QGuiApplicationPrivate::instance()->shortcutMap.removeShortcut(m_shortcutId, m_target);
    m_shortcutId = 0;
}
 
void QQuickActionPrivate::ShortcutEntry::setEnabled(bool enabled)
{
    if (!m_shortcutId)
        return;
 
    QGuiApplicationPrivate::instance()->shortcutMap.setShortcutEnabled(enabled, m_shortcutId, m_target);
}
 
QVariant QQuickActionPrivate::shortcut() const
{
    return vshortcut;
}
 
void QQuickActionPrivate::setShortcut(const QVariant &var)
{
    Q_Q(QQuickAction);
    if (vshortcut == var)
        return;
 
    defaultShortcutEntry->ungrab();
    for (QQuickActionPrivate::ShortcutEntry *entry : std::as_const(shortcutEntries))
        entry->ungrab();
 
    vshortcut = var;
    keySequence = variantToKeySequence(var);
 
    defaultShortcutEntry->grab(keySequence, enabled);
    for (QQuickActionPrivate::ShortcutEntry *entry : std::as_const(shortcutEntries))
        entry->grab(keySequence, enabled);
 
    emit q->shortcutChanged(keySequence);
}
#endif // QT_CONFIG(shortcut)
 
void QQuickActionPrivate::setEnabled(bool enable)
{
    Q_Q(QQuickAction);
    if (enabled == enable)
        return;
 
    enabled = enable;
 
#if QT_CONFIG(shortcut)
    defaultShortcutEntry->setEnabled(enable);
    for (QQuickActionPrivate::ShortcutEntry *entry : std::as_const(shortcutEntries))
        entry->setEnabled(enable);
#endif
 
    emit q->enabledChanged(enable);
}
 
bool QQuickActionPrivate::watchItem(QQuickItem *item)
{
    Q_Q(QQuickAction);
    if (!item)
        return false;
 
    item->installEventFilter(q);
    QQuickItemPrivate::get(item)->addItemChangeListener(this, QQuickItemPrivate::Visibility | QQuickItemPrivate::Destroyed);
    return true;
}
 
bool QQuickActionPrivate::unwatchItem(QQuickItem *item)
{
    Q_Q(QQuickAction);
    if (!item)
        return false;
 
    item->removeEventFilter(q);
    QQuickItemPrivate::get(item)->removeItemChangeListener(this, QQuickItemPrivate::Visibility | QQuickItemPrivate::Destroyed);
    return true;
}
 
void QQuickActionPrivate::registerItem(QQuickItem *item)
{
    if (!watchItem(item))
        return;
 
#if QT_CONFIG(shortcut)
    QQuickActionPrivate::ShortcutEntry *entry = new QQuickActionPrivate::ShortcutEntry(item);
    if (item->isVisible())
        entry->grab(keySequence, enabled);
    shortcutEntries += entry;
 
    updateDefaultShortcutEntry();
#endif
}
 
void QQuickActionPrivate::unregisterItem(QQuickItem *item)
{
#if QT_CONFIG(shortcut)
    QQuickActionPrivate::ShortcutEntry *entry = findShortcutEntry(item);
    if (!entry || !unwatchItem(item))
        return;
 
    shortcutEntries.removeOne(entry);
    delete entry;
 
    updateDefaultShortcutEntry();
#else
    Q_UNUSED(item);
#endif
}
 
void QQuickActionPrivate::itemVisibilityChanged(QQuickItem *item)
{
#if QT_CONFIG(shortcut)
    QQuickActionPrivate::ShortcutEntry *entry = findShortcutEntry(item);
    if (!entry)
        return;
 
    if (item->isVisible())
        entry->grab(keySequence, enabled);
    else
        entry->ungrab();
 
    updateDefaultShortcutEntry();
#else
    Q_UNUSED(item);
#endif
}
 
void QQuickActionPrivate::itemDestroyed(QQuickItem *item)
{
    unregisterItem(item);
}
 
#if QT_CONFIG(shortcut)
bool QQuickActionPrivate::handleShortcutEvent(QObject *object, QShortcutEvent *event)
{
    Q_Q(QQuickAction);
    if (event->key() != keySequence)
        return false;
 
    QQuickActionPrivate::ShortcutEntry *entry = findShortcutEntry(object);
    if (!entry || event->shortcutId() != entry->shortcutId())
        return false;
 
    q->trigger(entry->target());
    return true;
}
 
QQuickActionPrivate::ShortcutEntry *QQuickActionPrivate::findShortcutEntry(QObject *target) const
{
    Q_Q(const QQuickAction);
    if (target == q)
        return defaultShortcutEntry;
    for (QQuickActionPrivate::ShortcutEntry *entry : shortcutEntries) {
        if (entry->target() == target)
            return entry;
    }
    return nullptr;
}
 
void QQuickActionPrivate::updateDefaultShortcutEntry()
{
    bool hasActiveShortcutEntries = false;
    for (QQuickActionPrivate::ShortcutEntry *entry : std::as_const(shortcutEntries)) {
        if (entry->shortcutId()) {
            hasActiveShortcutEntries = true;
            break;
        }
    }
 
    if (hasActiveShortcutEntries)
        defaultShortcutEntry->ungrab();
    else if (!defaultShortcutEntry->shortcutId())
        defaultShortcutEntry->grab(keySequence, enabled);
}
#endif // QT_CONFIG(shortcut)
 
QQuickAction::QQuickAction(QObject *parent)
    : QObject(*(new QQuickActionPrivate), parent)
{
#if QT_CONFIG(shortcut)
    Q_D(QQuickAction);
    d->defaultShortcutEntry = new QQuickActionPrivate::ShortcutEntry(this);
#endif
}
 
QQuickAction::~QQuickAction()
{
    Q_D(QQuickAction);
    if (d->group)
        d->group->removeAction(this);
 
#if QT_CONFIG(shortcut)
    for (QQuickActionPrivate::ShortcutEntry *entry : std::as_const(d->shortcutEntries))
        d->unwatchItem(qobject_cast<QQuickItem *>(entry->target()));
 
    qDeleteAll(d->shortcutEntries);
    delete d->defaultShortcutEntry;
#endif
}
 
QString QQuickAction::text() const
{
    Q_D(const QQuickAction);
    return d->text;
}
 
void QQuickAction::setText(const QString &text)
{
    Q_D(QQuickAction);
    if (d->text == text)
        return;
 
    d->text = text;
    emit textChanged(text);
}
 
QQuickIcon QQuickAction::icon() const
{
    Q_D(const QQuickAction);
    return d->icon;
}
 
void QQuickAction::setIcon(const QQuickIcon &icon)
{
    Q_D(QQuickAction);
    if (d->icon == icon)
        return;
 
    d->icon = icon;
    d->icon.ensureRelativeSourceResolved(this);
    emit iconChanged(icon);
}
 
bool QQuickAction::isEnabled() const
{
    Q_D(const QQuickAction);
    return d->enabled && (!d->group || d->group->isEnabled());
}
 
void QQuickAction::setEnabled(bool enabled)
{
    Q_D(QQuickAction);
    d->explicitEnabled = true;
    d->setEnabled(enabled);
}
 
void QQuickAction::resetEnabled()
{
    Q_D(QQuickAction);
    if (!d->explicitEnabled)
        return;
 
    d->explicitEnabled = false;
    d->setEnabled(true);
}
 
bool QQuickAction::isChecked() const
{
    Q_D(const QQuickAction);
    return d->checked;
}
 
void QQuickAction::setChecked(bool checked)
{
    Q_D(QQuickAction);
    if (d->checked == checked)
        return;
 
    d->checked = checked;
    emit checkedChanged(checked);
}
 
bool QQuickAction::isCheckable() const
{
    Q_D(const QQuickAction);
    return d->checkable;
}
 
void QQuickAction::setCheckable(bool checkable)
{
    Q_D(QQuickAction);
    if (d->checkable == checkable)
        return;
 
    d->checkable = checkable;
    emit checkableChanged(checkable);
}
 
#if QT_CONFIG(shortcut)
QKeySequence QQuickAction::shortcut() const
{
    Q_D(const QQuickAction);
    return d->keySequence;
}
 
void QQuickAction::setShortcut(const QKeySequence &shortcut)
{
    Q_D(QQuickAction);
    d->setShortcut(shortcut.toString());
}
#endif // QT_CONFIG(shortcut)
 
void QQuickAction::toggle(QObject *source)
{
    Q_D(QQuickAction);
    if (!d->enabled)
        return;
 
    if (d->checkable)
        setChecked(!d->checked);
 
    emit toggled(source);
}
 
void QQuickAction::trigger(QObject *source)
{
    Q_D(QQuickAction);
    d->trigger(source, true);
}
 
void QQuickActionPrivate::trigger(QObject* source, bool doToggle)
{
    Q_Q(QQuickAction);
    if (!enabled)
        return;
 
    QPointer<QObject> guard = q;
    // the checked action of an exclusive group cannot be unchecked
    if (checkable && (!checked || !group || !group->isExclusive() || group->checkedAction() != q)) {
        if (doToggle)
            q->toggle(source);
        else
            emit q->toggled(source);
    }
 
    if (!guard.isNull())
        emit q->triggered(source);
}
 
bool QQuickAction::event(QEvent *event)
{
#if QT_CONFIG(shortcut)
    Q_D(QQuickAction);
    if (event->type() == QEvent::Shortcut)
        return d->handleShortcutEvent(this, static_cast<QShortcutEvent *>(event));
#endif
    return QObject::event(event);
}
 
bool QQuickAction::eventFilter(QObject *object, QEvent *event)
{
#if QT_CONFIG(shortcut)
    Q_D(QQuickAction);
    if (event->type() == QEvent::Shortcut)
        return d->handleShortcutEvent(object, static_cast<QShortcutEvent *>(event));
#else
    Q_UNUSED(object);
    Q_UNUSED(event);
#endif
    return false;
}
 
QT_END_NAMESPACE
 
#include "moc_qquickaction_p.cpp"