qaction.cpp

Go to the documentation of this file.

// Copyright (C) 2020 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 "qaction.h"
#include "qactiongroup.h"
 
#include "qaction_p.h"
#include "qguiapplication.h"
#include "qevent.h"
#include "qlist.h"
#include "qstylehints.h"
#if QT_CONFIG(shortcut)
#  include <private/qshortcutmap_p.h>
#endif
#include <private/qguiapplication_p.h>
#include <private/qdebug_p.h>
 
#define QAPP_CHECK(functionName) \
    if (Q_UNLIKELY(!QCoreApplication::instance())) { \
        qWarning("QAction: Initialize Q(Gui)Application before calling '" functionName "'."); \
        return; \
    }
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
/*
  internal: guesses a descriptive text from a text suited for a menu entry
 */
static QString qt_strippedText(QString s)
{
    s.remove("..."_L1);
    for (int i = 0; i < s.size(); ++i) {
        if (s.at(i) == u'&')
            s.remove(i, 1);
    }
    return s.trimmed();
}
 
QActionPrivate *QGuiApplicationPrivate::createActionPrivate() const
{
    return new QActionPrivate;
}
 
QActionPrivate::QActionPrivate() :
#if QT_CONFIG(shortcut)
    autorepeat(1),
#endif
    enabled(1), explicitEnabled(0), explicitEnabledValue(1), visible(1), forceInvisible(0), checkable(0),
    checked(0), separator(0), fontSet(false),
    iconVisibleInMenu(-1), shortcutVisibleInContextMenu(-1)
{
}
 
#if QT_CONFIG(shortcut)
static bool dummy(QObject *, Qt::ShortcutContext) { return false; } // only for GUI testing.
 
QShortcutMap::ContextMatcher QActionPrivate::contextMatcher() const
{
    return dummy;
};
#endif // QT_CONFIG(shortcut)
 
QActionPrivate::~QActionPrivate() = default;
 
void QActionPrivate::destroy()
{
}
 
void QActionPrivate::sendDataChanged()
{
    Q_Q(QAction);
    QActionEvent e(QEvent::ActionChanged, q);
    QCoreApplication::sendEvent(q, &e);
 
    emit q->changed();
}
 
#if QT_CONFIG(shortcut)
void QActionPrivate::redoGrab(QShortcutMap &map)
{
    Q_Q(QAction);
    for (int id : std::as_const(shortcutIds)) {
        if (id)
            map.removeShortcut(id, q);
    }
 
    shortcutIds.clear();
    for (const QKeySequence &shortcut : std::as_const(shortcuts)) {
        if (!shortcut.isEmpty())
            shortcutIds.append(map.addShortcut(q, shortcut, shortcutContext, contextMatcher()));
        else
            shortcutIds.append(0);
    }
    if (!enabled) {
        for (int id : std::as_const(shortcutIds)) {
            if (id)
                map.setShortcutEnabled(false, id, q);
        }
    }
    if (!autorepeat) {
        for (int id : std::as_const(shortcutIds)) {
            if (id)
                map.setShortcutAutoRepeat(false, id, q);
        }
    }
}
 
void QActionPrivate::setShortcutEnabled(bool enable, QShortcutMap &map)
{
    Q_Q(QAction);
    for (int id : std::as_const(shortcutIds)) {
        if (id)
            map.setShortcutEnabled(enable, id, q);
    }
}
#endif // QT_NO_SHORTCUT
 
bool QActionPrivate::showStatusText(QObject *object, const QString &str)
{
    if (QObject *receiver = object ? object : parent) {
        QStatusTipEvent tip(str);
        QCoreApplication::sendEvent(receiver, &tip);
        return true;
    }
    return false;
}
 
void QActionPrivate::setMenu(QObject *)
{
}
 
QObject *QActionPrivate::menu() const
{
    return nullptr;
}
 
QAction::QAction(QObject *parent)
    : QAction(*QGuiApplicationPrivate::instance()->createActionPrivate(), parent)
{
}
 
QAction::QAction(const QString &text, QObject *parent)
    : QAction(parent)
{
    Q_D(QAction);
    d->text = text;
}
 
QAction::QAction(const QIcon &icon, const QString &text, QObject *parent)
    : QAction(text, parent)
{
    Q_D(QAction);
    d->icon = icon;
}
 
QAction::QAction(QActionPrivate &dd, QObject *parent)
    : QObject(dd, parent)
{
    Q_D(QAction);
    d->group = qobject_cast<QActionGroup *>(parent);
    if (d->group)
        d->group->addAction(this);
}
 
#if QT_CONFIG(shortcut)
void QAction::setShortcut(const QKeySequence &shortcut)
{
    if (shortcut.isEmpty())
        setShortcuts({});
    else
        setShortcuts({ shortcut });
}
 
void QAction::setShortcuts(const QList<QKeySequence> &shortcuts)
{
    QAPP_CHECK("setShortcuts");
    Q_D(QAction);
 
    if (d->shortcuts == shortcuts)
        return;
 
    d->shortcuts = shortcuts;
    d->redoGrab(QGuiApplicationPrivate::instance()->shortcutMap);
    d->sendDataChanged();
}
 
void QAction::setShortcuts(QKeySequence::StandardKey key)
{
    QList <QKeySequence> list = QKeySequence::keyBindings(key);
    setShortcuts(list);
}
 
QKeySequence QAction::shortcut() const
{
    Q_D(const QAction);
    if (d->shortcuts.isEmpty())
        return QKeySequence();
    return d->shortcuts.first();
}
 
QList<QKeySequence> QAction::shortcuts() const
{
    Q_D(const QAction);
    return d->shortcuts;
}
 
void QAction::setShortcutContext(Qt::ShortcutContext context)
{
    Q_D(QAction);
    if (d->shortcutContext == context)
        return;
    QAPP_CHECK("setShortcutContext");
    d->shortcutContext = context;
    d->redoGrab(QGuiApplicationPrivate::instance()->shortcutMap);
    d->sendDataChanged();
}
 
Qt::ShortcutContext QAction::shortcutContext() const
{
    Q_D(const QAction);
    return d->shortcutContext;
}
 
void QAction::setAutoRepeat(bool on)
{
    Q_D(QAction);
    if (d->autorepeat == on)
        return;
    QAPP_CHECK("setAutoRepeat");
    d->autorepeat = on;
    d->redoGrab(QGuiApplicationPrivate::instance()->shortcutMap);
    d->sendDataChanged();
}
 
bool QAction::autoRepeat() const
{
    Q_D(const QAction);
    return d->autorepeat;
}
#endif // QT_CONFIG(shortcut)
 
void QAction::setFont(const QFont &font)
{
    Q_D(QAction);
    if (d->font == font)
        return;
 
    d->fontSet = true;
    d->font = font;
    d->sendDataChanged();
}
 
QFont QAction::font() const
{
    Q_D(const QAction);
    return d->font;
}
 
 
QAction::~QAction()
{
    Q_D(QAction);
 
    d->destroy();
 
    if (d->group)
        d->group->removeAction(this);
#if QT_CONFIG(shortcut)
    if (qApp) {
        for (int id : std::as_const(d->shortcutIds)) {
            if (id)
                QGuiApplicationPrivate::instance()->shortcutMap.removeShortcut(id, this);
        }
    }
#endif
}
 
void QAction::setActionGroup(QActionGroup *group)
{
    Q_D(QAction);
    if (group == d->group)
        return;
 
    if (d->group)
        d->group->removeAction(this);
    d->group = group;
    if (group)
        group->addAction(this);
    d->sendDataChanged();
}
 
QActionGroup *QAction::actionGroup() const
{
    Q_D(const QAction);
    return d->group;
}
 
QList<QObject*> QAction::associatedObjects() const
{
    Q_D(const QAction);
    return d->associatedObjects;
}
 
void QAction::setIcon(const QIcon &icon)
{
    Q_D(QAction);
    d->icon = icon;
    d->sendDataChanged();
}
 
QIcon QAction::icon() const
{
    Q_D(const QAction);
    return d->icon;
}
 
void QAction::setSeparator(bool b)
{
    Q_D(QAction);
    if (d->separator == b)
        return;
 
    d->separator = b;
    d->sendDataChanged();
}
 
bool QAction::isSeparator() const
{
    Q_D(const QAction);
    return d->separator;
}
 
void QAction::setText(const QString &text)
{
    Q_D(QAction);
    if (d->text == text)
        return;
 
    d->text = text;
    d->sendDataChanged();
}
 
QString QAction::text() const
{
    Q_D(const QAction);
    QString s = d->text;
    if (s.isEmpty()) {
        s = d->iconText;
        s.replace(u'&', "&&"_L1);
    }
    return s;
}
 
void QAction::setIconText(const QString &text)
{
    Q_D(QAction);
    if (d->iconText == text)
        return;
 
    d->iconText = text;
    d->sendDataChanged();
}
 
QString QAction::iconText() const
{
    Q_D(const QAction);
    if (d->iconText.isEmpty())
        return qt_strippedText(d->text);
    return d->iconText;
}
 
void QAction::setToolTip(const QString &tooltip)
{
    Q_D(QAction);
    if (d->tooltip == tooltip)
        return;
 
    d->tooltip = tooltip;
    d->sendDataChanged();
}
 
QString QAction::toolTip() const
{
    Q_D(const QAction);
    if (d->tooltip.isEmpty()) {
        if (!d->text.isEmpty())
            return qt_strippedText(d->text);
        return qt_strippedText(d->iconText);
    }
    return d->tooltip;
}
 
void QAction::setStatusTip(const QString &statustip)
{
    Q_D(QAction);
    if (d->statustip == statustip)
        return;
 
    d->statustip = statustip;
    d->sendDataChanged();
}
 
QString QAction::statusTip() const
{
    Q_D(const QAction);
    return d->statustip;
}
 
bool QAction::showStatusText(QObject *object)
{
    Q_D(QAction);
    return d->showStatusText(object, statusTip());
}
 
void QAction::setWhatsThis(const QString &whatsthis)
{
    Q_D(QAction);
    if (d->whatsthis == whatsthis)
        return;
 
    d->whatsthis = whatsthis;
    d->sendDataChanged();
}
 
QString QAction::whatsThis() const
{
    Q_D(const QAction);
    return d->whatsthis;
}
 
void QAction::setPriority(Priority priority)
{
    Q_D(QAction);
    if (d->priority == priority)
        return;
 
    d->priority = priority;
    d->sendDataChanged();
}
 
QAction::Priority QAction::priority() const
{
    Q_D(const QAction);
    return d->priority;
}
 
void QAction::setCheckable(bool b)
{
    Q_D(QAction);
    if (d->checkable == b)
        return;
 
    d->checkable = b;
    QPointer<QAction> guard(this);
    d->sendDataChanged();
    if (guard)
        emit checkableChanged(b);
    if (guard && d->checked)
        emit toggled(b);
}
 
bool QAction::isCheckable() const
{
    Q_D(const QAction);
    return d->checkable;
}
 
void QAction::toggle()
{
    Q_D(QAction);
    setChecked(!d->checked);
}
 
void QAction::setChecked(bool b)
{
    Q_D(QAction);
    if (d->checked == b)
        return;
 
    d->checked = b;
    if (!d->checkable)
        return;
    QPointer<QAction> guard(this);
    d->sendDataChanged();
    if (guard)
        emit toggled(b);
}
 
bool QAction::isChecked() const
{
    Q_D(const QAction);
    return d->checked && d->checkable;
}
 
void QAction::setEnabled(bool b)
{
    Q_D(QAction);
    if (d->explicitEnabledValue == b && d->explicitEnabled)
        return;
    d->explicitEnabledValue = b;
    d->explicitEnabled = true;
    QAPP_CHECK("setEnabled");
    d->setEnabled(b, false);
}
 
bool QActionPrivate::setEnabled(bool b, bool byGroup)
{
    Q_Q(QAction);
    if (b && !visible)
        b = false;
    if (b && !byGroup && (group && !group->isEnabled()))
        b = false;
    if (b && byGroup && explicitEnabled)
        b = explicitEnabledValue;
 
    if (b == enabled)
        return false;
 
    enabled = b;
#if QT_CONFIG(shortcut)
    setShortcutEnabled(b, QGuiApplicationPrivate::instance()->shortcutMap);
#endif
    QPointer guard(q);
    sendDataChanged();
    if (guard)
        emit q->enabledChanged(b);
    return true;
}
 
void QAction::resetEnabled()
{
    Q_D(QAction);
    if (!d->explicitEnabled)
        return;
    d->explicitEnabled = false;
    d->setEnabled(true, false);
}
 
bool QAction::isEnabled() const
{
    Q_D(const QAction);
    return d->enabled;
}
 
void QAction::setVisible(bool b)
{
    Q_D(QAction);
    if (b != d->forceInvisible)
        return;
    d->forceInvisible = !b;
    if (b && d->group && !d->group->isVisible())
        return;
    d->setVisible(b);
}
 
void QActionPrivate::setVisible(bool b)
{
    Q_Q(QAction);
    if (b == visible)
        return;
    QAPP_CHECK("setVisible");
    visible = b;
    bool enable = visible;
    if (enable && explicitEnabled)
        enable = explicitEnabledValue;
    QPointer guard(q);
    if (!setEnabled(enable, false))
        sendDataChanged();
    if (guard)
        emit q->visibleChanged();
}
 
bool QAction::isVisible() const
{
    Q_D(const QAction);
    return d->visible;
}
 
bool QAction::event(QEvent *e)
{
    Q_D(QAction);
    if (e->type() == QEvent::ActionChanged) {
        for (auto object : std::as_const(d->associatedObjects))
            QCoreApplication::sendEvent(object, e);
    }
 
#if QT_CONFIG(shortcut)
    if (e->type() == QEvent::Shortcut) {
        QShortcutEvent *se = static_cast<QShortcutEvent *>(e);
        Q_ASSERT_X(d_func()->shortcutIds.contains(se->shortcutId()),
                   "QAction::event",
                   "Received shortcut event from incorrect shortcut");
        if (se->isAmbiguous())
            qWarning("QAction::event: Ambiguous shortcut overload: %s", se->key().toString(QKeySequence::NativeText).toLatin1().constData());
        else
            activate(Trigger);
        return true;
    }
#endif // QT_CONFIG(shortcut)
    return QObject::event(e);
}
 
QVariant QAction::data() const
{
    Q_D(const QAction);
    return d->userData;
}
 
void QAction::setData(const QVariant &data)
{
    Q_D(QAction);
    if (d->userData == data)
        return;
    d->userData = data;
    d->sendDataChanged();
}
 
void QAction::activate(ActionEvent event)
{
    Q_D(QAction);
    if (event == Trigger) {
        // Ignore even explicit triggers when explicitly disabled
        if ((d->explicitEnabled && !d->explicitEnabledValue) || (d->group && !d->group->isEnabled()))
            return;
        QPointer<QObject> guard = this;
        if (d->checkable) {
            // the checked action of an exclusive group may not be unchecked
            if (d->checked && (d->group
                               && d->group->exclusionPolicy() == QActionGroup::ExclusionPolicy::Exclusive
                               && d->group->checkedAction() == this)) {
                if (!guard.isNull())
                    emit triggered(true);
                return;
            }
            setChecked(!d->checked);
        }
        if (!guard.isNull())
            emit triggered(d->checked);
    } else if (event == Hover) {
        emit hovered();
    }
}
 
void QAction::setMenuRole(MenuRole menuRole)
{
    Q_D(QAction);
    if (d->menuRole == menuRole)
        return;
 
    d->menuRole = menuRole;
    d->sendDataChanged();
}
 
QAction::MenuRole QAction::menuRole() const
{
    Q_D(const QAction);
    return d->menuRole;
}
 
QObject* QAction::menuObject() const
{
    Q_D(const QAction);
    return d->menu();
}
 
void QAction::setMenuObject(QObject *object)
{
    Q_D(QAction);
    d->setMenu(object);
}
 
void QAction::setIconVisibleInMenu(bool visible)
{
    Q_D(QAction);
    if (d->iconVisibleInMenu == -1 || visible != bool(d->iconVisibleInMenu)) {
        int oldValue = d->iconVisibleInMenu;
        d->iconVisibleInMenu = visible;
        // Only send data changed if we really need to.
        if (oldValue != -1
            || visible == !QCoreApplication::testAttribute(Qt::AA_DontShowIconsInMenus)) {
            d->sendDataChanged();
        }
    }
}
 
bool QAction::isIconVisibleInMenu() const
{
    Q_D(const QAction);
    if (d->iconVisibleInMenu == -1) {
        return !QCoreApplication::testAttribute(Qt::AA_DontShowIconsInMenus);
    }
    return d->iconVisibleInMenu;
}
 
void QAction::setShortcutVisibleInContextMenu(bool visible)
{
    Q_D(QAction);
    if (d->shortcutVisibleInContextMenu == -1 || visible != bool(d->shortcutVisibleInContextMenu)) {
        int oldValue = d->shortcutVisibleInContextMenu;
        d->shortcutVisibleInContextMenu = visible;
        // Only send data changed if we really need to.
        if (oldValue != -1
            || visible == !QCoreApplication::testAttribute(Qt::AA_DontShowShortcutsInContextMenus)) {
            d->sendDataChanged();
        }
    }
}
 
bool QAction::isShortcutVisibleInContextMenu() const
{
    Q_D(const QAction);
    if (d->shortcutVisibleInContextMenu == -1)
        return !QCoreApplication::testAttribute(Qt::AA_DontShowShortcutsInContextMenus);
    return d->shortcutVisibleInContextMenu;
}
 
#ifndef QT_NO_DEBUG_STREAM
Q_GUI_EXPORT QDebug operator<<(QDebug d, const QAction *action)
{
    QDebugStateSaver saver(d);
    d.nospace();
    d << "QAction(" << static_cast<const void *>(action);
    if (action) {
        d << " text=" << action->text();
        if (!action->toolTip().isEmpty())
            d << " toolTip=" << action->toolTip();
        if (action->isCheckable())
            d << " checked=" << action->isChecked();
#if QT_CONFIG(shortcut)
        if (!action->shortcuts().isEmpty())
            d << " shortcuts=" << action->shortcuts();
#endif
        d << " menuRole=";
        QtDebugUtils::formatQEnum(d, action->menuRole());
        d << " enabled=" << action->isEnabled();
        d << " visible=" << action->isVisible();
    } else {
        d << '0';
    }
    d << ')';
    return d;
}
#endif // QT_NO_DEBUG_STREAM
 
QT_END_NAMESPACE
 
#include "moc_qaction.cpp"