Revision control
Copy as Markdown
// 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
// Qt-Security score:significant reason:default
#include "qquickaction_p.h"
#include "qquickaction_p_p.h"
#include "qquickactiongroup_p.h"
#include "qquickshortcutcontext_p_p.h"
#include <QtCore/qpointer.h>
#include <QtCore/qloggingcategory.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>
#include <QtQuickTemplates2/private/qquickicon_p_p.h>
QT_BEGIN_NAMESPACE
Q_STATIC_LOGGING_CATEGORY(lcAction, "qt.quick.controls.action")
Q_STATIC_LOGGING_CATEGORY(lcShortcutEntry, "qt.quick.controls.action.shortcutEntry")
/*!
\qmltype Action
\inherits QtObject
//! \nativetype QQuickAction
\inqmlmodule QtQuick.Controls
\since 5.10
\ingroup utilities
\brief Abstract user interface action.
Action represents an abstract user interface action that can have shortcuts
and can be assigned to menu items and toolbar buttons.
Actions may contain \l text, an \l icon, and a \l shortcut. Actions are normally
\l triggered by the user via menu items, toolbar buttons, or keyboard shortcuts.
A \l checkable Action toggles its \l checked state when triggered.
\snippet qtquickcontrols-action.qml action
Action is commonly used to implement application commands that can be invoked
via menu items, toolbar buttons, and keyboard shortcuts. Since the user expects
the commands to be performed in the same way, regardless of the user interface
used, it is useful to represent the commands as shareable actions.
Action can be also used to separate the logic and the visual presentation. For
example, when declaring buttons and menu items in \c .ui.qml files, actions can
be declared elsewhere and assigned from the outside.
\snippet qtquickcontrols-action.qml toolbutton
When an action is paired with buttons and menu items, the \c enabled, \c checkable,
and \c checked states are synced automatically. For example, in a word processor,
if the user clicks a "Bold" toolbar button, the "Bold" menu item will automatically
be checked. Buttons and menu items get their \c text and \c icon from the action by
default. An action-specific \c text or \c icon can be overridden for a specific
control by specifying \c text or \c icon directly on the control.
\snippet qtquickcontrols-action.qml menuitem
Since Action presents a user interface action, it is intended to be assigned to
a \l MenuItem, \l ToolButton, or any other control that inherits \l AbstractButton.
For keyboard shortcuts, the simpler \l Shortcut type is more appropriate.
\sa MenuItem, ToolButton, Shortcut
*/
/*!
\qmlsignal QtQuick.Controls::Action::toggled(QtObject source)
This signal is emitted when the action is toggled. The \a source argument
identifies the object that toggled the action.
For example, if the action is assigned to a menu item and a toolbar button, the
action is toggled when the control is toggled, the shortcut is activated, or
when \l toggle() is called directly.
*/
/*!
\qmlsignal QtQuick.Controls::Action::triggered(QtObject source)
This signal is emitted when the action is triggered. The \a source argument
identifies the object that triggered the action.
For example, if the action is assigned to a menu item and a toolbar button, the
action is triggered when the control is clicked, the shortcut is activated, or
when \l trigger() is called directly.
*/
#if QT_CONFIG(shortcut)
static QKeySequence variantToKeySequence(const QVariant &var)
{
if (var.metaType().id() == QMetaType::Int)
return QKeySequence(static_cast<QKeySequence::StandardKey>(var.toInt()));
else if (var.metaType().id() == QMetaType::QKeySequence)
return var.value<QKeySequence>();
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)
{
qCDebug(lcShortcutEntry) << "- grab called with" << shortcut << "enabled" << enabled
<< "for" << m_target;
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()
{
qCDebug(lcShortcutEntry).nospace() << "- ungrab called for " << m_target << ", m_shortcutId is "
<< m_shortcutId;
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;
qCDebug(lcAction) << q << "setShortcut called with" << var;
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)
qCDebug(lcAction) << q_func() << "registerItem called with" << item;
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;
qCDebug(lcAction) << q_func() << "unregisterItem called with" << item;
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;
qCDebug(lcAction) << q_func() << "visibility of" << item << "changed to" << item->isVisible()
<< "- grabbing/ungrabbing shortcut";
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) {
// There is an item that is using us as its action; let it have the shortcut.
defaultShortcutEntry->ungrab();
} else if (!defaultShortcutEntry->shortcutId()) {
// There are no items that are using us as their action (or they aren't visible) and we
// haven't already grabbed the shortcut; grab it.
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);
qCDebug(lcAction) << "destroying" << this << d->text;
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
}
/*!
\qmlproperty string QtQuick.Controls::Action::text
This property holds a textual description of the action.
*/
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);
}
/*!
\qmlproperty string QtQuick.Controls::Action::icon.name
\qmlproperty url QtQuick.Controls::Action::icon.source
\qmlproperty int QtQuick.Controls::Action::icon.width
\qmlproperty int QtQuick.Controls::Action::icon.height
\qmlproperty color QtQuick.Controls::Action::icon.color
\qmlproperty bool QtQuick.Controls::Action::icon.cache
\include qquickicon.qdocinc grouped-properties
*/
QQuickIcon QQuickAction::icon() const
{
Q_D(const QQuickAction);
return d->icon;
}
void QQuickAction::setIcon(const QQuickIcon &icon)
{
Q_D(QQuickAction);
// Similar to QQuickAbstractButtonPrivate::updateEffectiveIcon, we don't want to rely
// purely on QQuickIcon::operator==, because it doesn't account for the color being resolved.
// If we didn't check the resolve mask and the user set the color to transparent (the default),
// the resolveMask of d->icon wouldn't indicate that the color was resolved and iconChanged
// wouldn't be emitted, leading to the user's request being ignored.
const bool oldColorResolved = QQuickIconPrivate::isResolved(d->icon, QQuickIconPrivate::ColorResolved);
const bool newColorResolved = QQuickIconPrivate::isResolved(icon, QQuickIconPrivate::ColorResolved);
const bool unchanged = d->icon == icon && oldColorResolved && !newColorResolved;
d->icon = icon;
if (unchanged)
return;
d->icon.ensureRelativeSourceResolved(this);
emit iconChanged(icon);
}
/*!
\qmlproperty bool QtQuick.Controls::Action::enabled
This property holds whether the action is enabled. The default value is \c true.
*/
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);
}
/*!
\qmlproperty bool QtQuick.Controls::Action::checked
This property holds whether the action is checked.
\sa checkable
*/
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);
}
/*!
\qmlproperty bool QtQuick.Controls::Action::checkable
This property holds whether the action is checkable. The default value is \c false.
A checkable action toggles between checked (on) and unchecked (off) when triggered.
\sa 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)
/*!
\qmlproperty keysequence QtQuick.Controls::Action::shortcut
This property holds the action's shortcut. The key sequence can be set to
one of the \l{QKeySequence::StandardKey}{standard keyboard shortcuts}, (for
example, \c StandardKey.Copy), or it can be described with a string
containing a sequence of up to four key presses that are needed to trigger
the shortcut.
\code
Action {
shortcut: "Ctrl+E,Ctrl+W"
onTriggered: edit.wrapMode = TextEdit.Wrap
}
\endcode
*/
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)
/*!
\qmlmethod void QtQuick.Controls::Action::toggle(QtObject source)
Toggles the action and emits \l toggled() if enabled, with an optional \a source object defined.
*/
void QQuickAction::toggle(QObject *source)
{
Q_D(QQuickAction);
if (!d->enabled)
return;
if (d->checkable)
setChecked(!d->checked);
emit toggled(source);
}
/*!
\qmlmethod void QtQuick.Controls::Action::trigger(QtObject source)
Triggers the action and emits \l triggered() if enabled, with an optional \a source object defined.
*/
void QQuickAction::trigger(QObject *source)
{
Q_D(QQuickAction);
d->trigger(source, true);
}
/*!
\internal
Returns \c true if \l {Action::}{triggered()} was emitted.
*/
bool QQuickActionPrivate::trigger(QObject* source, bool doToggle)
{
Q_Q(QQuickAction);
if (!enabled)
return false;
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())
return false;
emit q->triggered(source);
return true;
}
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"