AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Extract QGuiAction(Group) from QAction(Group) into QtGui

Browse Source 
Simply moving QAction to QtGui was not deemed possible since
it operates on a set of controls of some kind. The approach to
extract a base class was taken instead, named QGuiAction
following the QGuiApplication scheme. QAction remains in
widgets, but changes base class.

For QActionGroup, the functions addAction(text/icon), which
create an action, cannot be implemented in QtGui, hence a base
class is needed, too (unless they are deprecated and removed).

- Extract base classes providing functionality not based on
  QtWidgets, using virtuals in QGuiActionPrivate to provide
  customization points

- Change QActionEvent to take QGuiAction, removing
  the need to forward declare QAction in QtGui

[ChangeLog][QtGui] Added QGuiAction(Group) and made the equivalent
existing classes in Qt Widgets derive from them. This provides
basic functionality for implementing actions in QML.

Task-number: QTBUG-69478
Change-Id: Ic490a5e3470939ee8af612d46ff41d4c8c91fbdf
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Reviewed-by: Mitch Curtis <mitch.curtis@qt.io>
Reviewed-by: Oliver Wolff <oliver.wolff@qt.io>
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>
This commit is contained in:
Friedemann Kleint 2019-06-19 13:00:11 +02:00
parent d273076b44
commit cff492fed1
26 changed files with 2202 additions and 1545 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/gui/kernel/kernel.pri
View File

@ -126,6 +126,18 @@ SOURCES += \
kernel/qhighdpiscaling.cpp \
kernel/qtestsupport_gui.cpp
qtConfig(action) {
HEADERS += \
kernel/qguiaction.h \
kernel/qguiaction_p.h \
kernel/qguiactiongroup.h \
kernel/qguiactiongroup_p.h
SOURCES += \
kernel/qguiactiongroup.cpp \
kernel/qguiaction.cpp
}
qtConfig(draganddrop) {
HEADERS += \
kernel/qdnd_p.h \

10
src/gui/kernel/qevent.cpp
View File

@ -3324,18 +3324,18 @@ QWhatsThisClickedEvent::~QWhatsThisClickedEvent()
/*!
\class QActionEvent
\brief The QActionEvent class provides an event that is generated
when a QAction is added, removed, or changed.
when a QGuiAction is added, removed, or changed.
\ingroup events
\inmodule QtGui
Actions can be added to widgets using QWidget::addAction(). This
generates an \l ActionAdded event, which you can handle to provide
Actions can be added to controls, for example by using QWidget::addAction().
This generates an \l ActionAdded event, which you can handle to provide
custom behavior. For example, QToolBar reimplements
QWidget::actionEvent() to create \l{QToolButton}s for the
actions.
\sa QAction, QWidget::addAction(), QWidget::removeAction(), QWidget::actions()
\sa QGuiAction, QWidget::addAction(), QWidget::removeAction(), QWidget::actions()
*/
/*!
@ -3346,7 +3346,7 @@ QWhatsThisClickedEvent::~QWhatsThisClickedEvent()
type is ActionAdded, the action is to be inserted before the
action \a before. If \a before is 0, the action is appended.
*/
QActionEvent::QActionEvent(int type, QAction *action, QAction *before)
QActionEvent::QActionEvent(int type, QGuiAction *action, QGuiAction *before)
: QEvent(static_cast<QEvent::Type>(type)), act(action), bef(before)
{}

10
src/gui/kernel/qevent.h
View File

@ -61,7 +61,7 @@
QT_BEGIN_NAMESPACE
class QAction;
class QGuiAction;
#ifndef QT_NO_GESTURES
class QGesture;
#endif
@ -756,13 +756,13 @@ private:
#ifndef QT_NO_ACTION
class Q_GUI_EXPORT QActionEvent : public QEvent
{
QAction *act, *bef;
QGuiAction *act, *bef;
public:
QActionEvent(int type, QAction *action, QAction *before = nullptr);
QActionEvent(int type, QGuiAction *action, QGuiAction *before = nullptr);
~QActionEvent();
inline QAction *action() const { return act; }
inline QAction *before() const { return bef; }
inline QGuiAction *action() const { return act; }
inline QGuiAction *before() const { return bef; }
};
#endif

1214
src/gui/kernel/qguiaction.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

198
src/gui/kernel/qguiaction.h Normal file
View File

@ -0,0 +1,198 @@
/****************************************************************************
**
** 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 QGUIACTION_H
#define QGUIACTION_H
#include <QtGui/qtguiglobal.h>
#if QT_CONFIG(shortcut)
# include <QtGui/qkeysequence.h>
#endif
#include <QtGui/qicon.h>
#include <QtCore/qstring.h>
#include <QtCore/qvariant.h>
QT_REQUIRE_CONFIG(action);
QT_BEGIN_NAMESPACE
class QActionEvent;
class QGuiActionGroup;
class QGuiActionPrivate;
class Q_GUI_EXPORT QGuiAction : public QObject
{
Q_OBJECT
Q_DECLARE_PRIVATE(QGuiAction)
Q_PROPERTY(bool checkable READ isCheckable WRITE setCheckable NOTIFY changed)
Q_PROPERTY(bool checked READ isChecked WRITE setChecked DESIGNABLE isCheckable NOTIFY toggled)
Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY changed)
Q_PROPERTY(QIcon icon READ icon WRITE setIcon NOTIFY changed)
Q_PROPERTY(QString text READ text WRITE setText NOTIFY changed)
Q_PROPERTY(QString iconText READ iconText WRITE setIconText NOTIFY changed)
Q_PROPERTY(QString toolTip READ toolTip WRITE setToolTip NOTIFY changed)
Q_PROPERTY(QString statusTip READ statusTip WRITE setStatusTip NOTIFY changed)
Q_PROPERTY(QString whatsThis READ whatsThis WRITE setWhatsThis NOTIFY changed)
Q_PROPERTY(QFont font READ font WRITE setFont NOTIFY changed)
#if QT_CONFIG(shortcut)
Q_PROPERTY(QKeySequence shortcut READ shortcut WRITE setShortcut NOTIFY changed)
Q_PROPERTY(Qt::ShortcutContext shortcutContext READ shortcutContext WRITE setShortcutContext NOTIFY changed)
Q_PROPERTY(bool autoRepeat READ autoRepeat WRITE setAutoRepeat NOTIFY changed)
#endif // QT_CONFIG(shortcut)
Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY changed)
Q_PROPERTY(MenuRole menuRole READ menuRole WRITE setMenuRole NOTIFY changed)
Q_PROPERTY(bool iconVisibleInMenu READ isIconVisibleInMenu WRITE setIconVisibleInMenu NOTIFY changed)
Q_PROPERTY(bool shortcutVisibleInContextMenu READ isShortcutVisibleInContextMenu WRITE setShortcutVisibleInContextMenu NOTIFY changed)
Q_PROPERTY(Priority priority READ priority WRITE setPriority)
public:
// note this is copied into qplatformmenu.h, which must stay in sync
enum MenuRole { NoRole = 0, TextHeuristicRole, ApplicationSpecificRole, AboutQtRole,
AboutRole, PreferencesRole, QuitRole };
Q_ENUM(MenuRole)
enum Priority { LowPriority = 0,
NormalPriority = 128,
HighPriority = 256};
Q_ENUM(Priority)
explicit QGuiAction(QObject *parent = nullptr);
explicit QGuiAction(const QString &text, QObject *parent = nullptr);
explicit QGuiAction(const QIcon &icon, const QString &text, QObject *parent = nullptr);
~QGuiAction();
void setActionGroup(QGuiActionGroup *group);
QGuiActionGroup *guiActionGroup() const;
void setIcon(const QIcon &icon);
QIcon icon() const;
void setText(const QString &text);
QString text() const;
void setIconText(const QString &text);
QString iconText() const;
void setToolTip(const QString &tip);
QString toolTip() const;
void setStatusTip(const QString &statusTip);
QString statusTip() const;
void setWhatsThis(const QString &what);
QString whatsThis() const;
void setPriority(Priority priority);
Priority priority() const;
void setSeparator(bool b);
bool isSeparator() const;
#if QT_CONFIG(shortcut)
void setShortcut(const QKeySequence &shortcut);
QKeySequence shortcut() const;
void setShortcuts(const QList<QKeySequence> &shortcuts);
void setShortcuts(QKeySequence::StandardKey);
QList<QKeySequence> shortcuts() const;
void setShortcutContext(Qt::ShortcutContext context);
Qt::ShortcutContext shortcutContext() const;
void setAutoRepeat(bool);
bool autoRepeat() const;
#endif // QT_CONFIG(shortcut)
void setFont(const QFont &font);
QFont font() const;
void setCheckable(bool);
bool isCheckable() const;
QVariant data() const;
void setData(const QVariant &var);
bool isChecked() const;
bool isEnabled() const;
bool isVisible() const;
enum ActionEvent { Trigger, Hover };
void activate(ActionEvent event);
void setMenuRole(MenuRole menuRole);
MenuRole menuRole() const;
void setIconVisibleInMenu(bool visible);
bool isIconVisibleInMenu() const;
void setShortcutVisibleInContextMenu(bool show);
bool isShortcutVisibleInContextMenu() const;
protected:
bool event(QEvent *) override;
QGuiAction(QGuiActionPrivate &dd, QObject *parent);
public Q_SLOTS:
void trigger() { activate(Trigger); }
void hover() { activate(Hover); }
void setChecked(bool);
void toggle();
void setEnabled(bool);
inline void setDisabled(bool b) { setEnabled(!b); }
void setVisible(bool);
Q_SIGNALS:
void changed();
void triggered(bool checked = false);
void hovered();
void toggled(bool);
private:
Q_DISABLE_COPY(QGuiAction)
friend class QGuiActionGroup;
};
#ifndef QT_NO_DEBUG_STREAM
Q_GUI_EXPORT QDebug operator<<(QDebug, const QGuiAction *);
#endif
QT_END_NAMESPACE
#endif // QGUIACTION_H

128
src/gui/kernel/qguiaction_p.h Normal file
View File

@ -0,0 +1,128 @@
/****************************************************************************
**
** 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 QGUIACTION_P_H
#define QGUIACTION_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists for the convenience
// of other Qt classes. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include <QtGui/private/qtguiglobal_p.h>
#include <QtGui/qguiaction.h>
#include <QtGui/qfont.h>
#if QT_CONFIG(shortcut)
# include <QtGui/private/qshortcutmap_p.h>
#endif
#include "private/qobject_p.h"
QT_REQUIRE_CONFIG(action);
QT_BEGIN_NAMESPACE
class QShortcutMap;
class Q_GUI_EXPORT QGuiActionPrivate : public QObjectPrivate
{
Q_DECLARE_PUBLIC(QGuiAction)
public:
QGuiActionPrivate();
~QGuiActionPrivate();
#if QT_CONFIG(shortcut)
virtual QShortcutMap::ContextMatcher contextMatcher() const;
#endif
static QGuiActionPrivate *get(QGuiAction *q)
{
return q->d_func();
}
QPointer<QGuiActionGroup> group;
QString text;
QString iconText;
QIcon icon;
QString tooltip;
QString statustip;
QString whatsthis;
#if QT_CONFIG(shortcut)
QKeySequence shortcut;
QList<QKeySequence> alternateShortcuts;
#endif
QVariant userData;
#if QT_CONFIG(shortcut)
int shortcutId = 0;
QVector<int> alternateShortcutIds;
Qt::ShortcutContext shortcutContext = Qt::WindowShortcut;
uint autorepeat : 1;
#endif
QFont font;
uint enabled : 1, forceDisabled : 1;
uint visible : 1, forceInvisible : 1;
uint checkable : 1;
uint checked : 1;
uint separator : 1;
uint fontSet : 1;
int iconVisibleInMenu : 2; // Only has values -1, 0, and 1
int shortcutVisibleInContextMenu : 2; // Only has values -1, 0, and 1
QGuiAction::MenuRole menuRole = QGuiAction::TextHeuristicRole;
QGuiAction::Priority priority = QGuiAction::NormalPriority;
#if QT_CONFIG(shortcut)
void redoGrab(QShortcutMap &map);
void redoGrabAlternate(QShortcutMap &map);
void setShortcutEnabled(bool enable, QShortcutMap &map);
#endif // QT_NO_SHORTCUT
void sendDataChanged();
};
QT_END_NAMESPACE
#endif // QACTION_P_H

345
src/gui/kernel/qguiactiongroup.cpp Normal file
View File

@ -0,0 +1,345 @@
/****************************************************************************
**
** 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 "qguiactiongroup.h"
#include "qguiaction.h"
#include "qguiaction_p.h"
#include "qguiactiongroup_p.h"
#include "qevent.h"
#include "qlist.h"
QT_BEGIN_NAMESPACE
QGuiActionGroupPrivate::QGuiActionGroupPrivate() :
enabled(1), visible(1)
{
}
QGuiActionGroupPrivate::~QGuiActionGroupPrivate() = default;
void QGuiActionGroup::_q_actionChanged()
{
Q_D(QGuiActionGroup);
auto action = qobject_cast<QGuiAction*>(sender());
Q_ASSERT_X(action != nullptr, "QGuiActionGroup::_q_actionChanged", "internal error");
if (d->exclusionPolicy != QGuiActionGroup::ExclusionPolicy::None) {
if (action->isChecked()) {
if (action != d->current) {
if (!d->current.isNull())
d->current->setChecked(false);
d->current = action;
}
} else if (action == d->current) {
d->current = nullptr;
}
}
}
void QGuiActionGroup::_q_actionTriggered()
{
Q_D(QGuiActionGroup);
auto action = qobject_cast<QGuiAction*>(sender());
Q_ASSERT_X(action != nullptr, "QGuiActionGroup::_q_actionTriggered", "internal error");
d->emitSignal(QGuiActionGroupPrivate::Triggered, action);
}
void QGuiActionGroup::_q_actionHovered()
{
Q_D(QGuiActionGroup);
auto action = qobject_cast<QGuiAction*>(sender());
Q_ASSERT_X(action != nullptr, "QGuiActionGroup::_q_actionHovered", "internal error");
d->emitSignal(QGuiActionGroupPrivate::Hovered, action);
}
/*!
\class QGuiActionGroup
\brief The QGuiActionGroup class groups actions together.
\since 6.0
\inmodule QtGui
QGuiActionGroup is a base class for classes grouping
classes inhheriting QGuiAction objects together.
In some situations it is useful to group QGuiAction objects together.
For example, if you have a \uicontrol{Left Align} action, a \uicontrol{Right
Align} action, a \uicontrol{Justify} action, and a \uicontrol{Center} action,
only one of these actions should be active at any one time. One
simple way of achieving this is to group the actions together in
an action group, inheriting QGuiActionGroup.
\sa QGuiAction
*/
/*!
\enum QGuiActionGroup::ExclusionPolicy
This enum specifies the different policies that can be used to
control how the group performs exclusive checking on checkable actions.
\value None
The actions in the group can be checked independently of each other.
\value Exclusive
Exactly one action can be checked at any one time.
This is the default policy.
\value ExclusiveOptional
At most one action can be checked at any one time. The actions
can also be all unchecked.
\sa exclusionPolicy
*/
/*!
Constructs an action group for the \a parent object.
The action group is exclusive by default. Call setExclusive(false)
to make the action group non-exclusive. To make the group exclusive
but allow unchecking the active action call instead
setExclusionPolicy(QGuiActionGroup::ExclusionPolicy::ExclusiveOptional)
*/
QGuiActionGroup::QGuiActionGroup(QObject* parent) :
QGuiActionGroup(*new QGuiActionGroupPrivate, parent)
{
}
QGuiActionGroup::QGuiActionGroup(QGuiActionGroupPrivate &dd, QObject *parent) :
QObject(dd, parent)
{
}
/*!
Destroys the action group.
*/
QGuiActionGroup::~QGuiActionGroup() = default;
/*!
\fn QGuiAction *QGuiActionGroup::addAction(QGuiAction *action)
Adds the \a action to this group, and returns it.
Normally an action is added to a group by creating it with the
group as its parent, so this function is not usually used.
\sa QGuiAction::setActionGroup()
*/
QGuiAction *QGuiActionGroup::addAction(QGuiAction* a)
{
Q_D(QGuiActionGroup);
if (!d->actions.contains(a)) {
d->actions.append(a);
QObject::connect(a, &QGuiAction::triggered, this, &QGuiActionGroup::_q_actionTriggered);
QObject::connect(a, &QGuiAction::changed, this, &QGuiActionGroup::_q_actionChanged);
QObject::connect(a, &QGuiAction::hovered, this, &QGuiActionGroup::_q_actionHovered);
}
if (!a->d_func()->forceDisabled) {
a->setEnabled(d->enabled);
a->d_func()->forceDisabled = false;
}
if (!a->d_func()->forceInvisible) {
a->setVisible(d->visible);
a->d_func()->forceInvisible = false;
}
if (a->isChecked())
d->current = a;
QGuiActionGroup *oldGroup = a->d_func()->group;
if (oldGroup != this) {
if (oldGroup)
oldGroup->removeAction(a);
a->d_func()->group = this;
a->d_func()->sendDataChanged();
}
return a;
}
/*!
Removes the \a action from this group. The action will have no
parent as a result.
\sa QGuiAction::setActionGroup()
*/
void QGuiActionGroup::removeAction(QGuiAction *action)
{
Q_D(QGuiActionGroup);
if (d->actions.removeAll(action)) {
if (action == d->current)
d->current = nullptr;
QObject::disconnect(action, &QGuiAction::triggered, this, &QGuiActionGroup::_q_actionTriggered);
QObject::disconnect(action, &QGuiAction::changed, this, &QGuiActionGroup::_q_actionChanged);
QObject::disconnect(action, &QGuiAction::hovered, this, &QGuiActionGroup::_q_actionHovered);
action->d_func()->group = nullptr;
}
}
/*!
Returns the list of this groups's actions. This may be empty.
*/
QList<QGuiAction*> QGuiActionGroup::guiActions() const
{
Q_D(const QGuiActionGroup);
return d->actions;
}
/*!
\brief Enable or disable the group exclusion checking
This is a convenience method that calls
setExclusionPolicy(ExclusionPolicy::Exclusive).
\sa QGuiActionGroup::exclusionPolicy
*/
void QGuiActionGroup::setExclusive(bool b)
{
setExclusionPolicy(b ? QGuiActionGroup::ExclusionPolicy::Exclusive
: QGuiActionGroup::ExclusionPolicy::None);
}
/*!
\brief Returs true if the group is exclusive
The group is exclusive if the ExclusionPolicy is either Exclusive
or ExclusionOptional.
*/
bool QGuiActionGroup::isExclusive() const
{
return exclusionPolicy() != QGuiActionGroup::ExclusionPolicy::None;
}
/*!
\property QGuiActionGroup::exclusionPolicy
\brief This property holds the group exclusive checking policy
If exclusionPolicy is set to Exclusive, only one checkable
action in the action group can ever be active at any time. If the user
chooses another checkable action in the group, the one they chose becomes
active and the one that was active becomes inactive. If exclusionPolicy is
set to ExclusionOptional the group is exclusive but the active checkable
action in the group can be unchecked leaving the group with no actions
checked.
\sa QGuiAction::checkable
*/
void QGuiActionGroup::setExclusionPolicy(QGuiActionGroup::ExclusionPolicy policy)
{
Q_D(QGuiActionGroup);
d->exclusionPolicy = policy;
}
QGuiActionGroup::ExclusionPolicy QGuiActionGroup::exclusionPolicy() const
{
Q_D(const QGuiActionGroup);
return d->exclusionPolicy;
}
/*!
\fn void QGuiActionGroup::setDisabled(bool b)
This is a convenience function for the \l enabled property, that
is useful for signals--slots connections. If \a b is true the
action group is disabled; otherwise it is enabled.
*/
/*!
\property QGuiActionGroup::enabled
\brief whether the action group is enabled
Each action in the group will be enabled or disabled unless it
has been explicitly disabled.
\sa QGuiAction::setEnabled()
*/
void QGuiActionGroup::setEnabled(bool b)
{
Q_D(QGuiActionGroup);
d->enabled = b;
for (auto action : qAsConst(d->actions)) {
if (!action->d_func()->forceDisabled) {
action->setEnabled(b);
action->d_func()->forceDisabled = false;
}
}
}
bool QGuiActionGroup::isEnabled() const
{
Q_D(const QGuiActionGroup);
return d->enabled;
}
/*!
Returns the currently checked action in the group, or \nullptr if
none are checked.
*/
QGuiAction *QGuiActionGroup::checkedGuiAction() const
{
Q_D(const QGuiActionGroup);
return d->current.data();
}
/*!
\property QGuiActionGroup::visible
\brief whether the action group is visible
Each action in the action group will match the visible state of
this group unless it has been explicitly hidden.
\sa QGuiAction::setEnabled()
*/
void QGuiActionGroup::setVisible(bool b)
{
Q_D(QGuiActionGroup);
d->visible = b;
for (auto action : qAsConst(d->actions)) {
if (!action->d_func()->forceInvisible) {
action->setVisible(b);
action->d_func()->forceInvisible = false;
}
}
}
bool QGuiActionGroup::isVisible() const
{
Q_D(const QGuiActionGroup);
return d->visible;
}
QT_END_NAMESPACE

104
src/gui/kernel/qguiactiongroup.h Normal file
View File

@ -0,0 +1,104 @@
/****************************************************************************
**
** 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 QGUIACTIONGROUP_H
#define QGUIACTIONGROUP_H
#include <QtGui/qtguiglobal.h>
#include <QtGui/qguiaction.h>
QT_REQUIRE_CONFIG(action);
QT_BEGIN_NAMESPACE
class QGuiActionGroupPrivate;
class Q_GUI_EXPORT QGuiActionGroup : public QObject
{
Q_OBJECT
Q_DECLARE_PRIVATE(QGuiActionGroup)
Q_PROPERTY(QGuiActionGroup::ExclusionPolicy exclusionPolicy READ exclusionPolicy WRITE setExclusionPolicy)
Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled)
Q_PROPERTY(bool visible READ isVisible WRITE setVisible)
public:
enum class ExclusionPolicy {
None,
Exclusive,
ExclusiveOptional
};
Q_ENUM(ExclusionPolicy)
explicit QGuiActionGroup(QObject *parent);
~QGuiActionGroup();
QGuiAction *addAction(QGuiAction *a);
void removeAction(QGuiAction *a);
QList<QGuiAction*> guiActions() const;
QGuiAction *checkedGuiAction() const;
bool isExclusive() const;
bool isEnabled() const;
bool isVisible() const;
ExclusionPolicy exclusionPolicy() const;
public Q_SLOTS:
void setEnabled(bool);
inline void setDisabled(bool b) { setEnabled(!b); }
void setVisible(bool);
void setExclusive(bool);
void setExclusionPolicy(ExclusionPolicy policy);
private Q_SLOTS:
void _q_actionTriggered();
void _q_actionHovered();
void _q_actionChanged();
protected:
QGuiActionGroup(QGuiActionGroupPrivate &dd, QObject *parent);
private:
Q_DISABLE_COPY(QGuiActionGroup)
};
QT_END_NAMESPACE
#endif // QGUIACTIONGROUP_H

91
src/gui/kernel/qguiactiongroup_p.h Normal file
View File

@ -0,0 +1,91 @@
/****************************************************************************
**
** 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 QGUIACTIONGROUP_P_H
#define QGUIACTIONGROUP_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists for the convenience
// of other Qt classes. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include <QtGui/private/qtguiglobal_p.h>
#include <QtGui/qguiactiongroup.h>
#include <QtGui/qfont.h>
#if QT_CONFIG(shortcut)
# include <QtGui/private/qshortcutmap_p.h>
#endif
#include "private/qobject_p.h"
QT_REQUIRE_CONFIG(action);
QT_BEGIN_NAMESPACE
class Q_GUI_EXPORT QGuiActionGroupPrivate : public QObjectPrivate
{
Q_DECLARE_PUBLIC(QGuiActionGroup)
public:
enum Signal { Triggered, Hovered };
QGuiActionGroupPrivate();
~QGuiActionGroupPrivate();
virtual void emitSignal(Signal, QGuiAction *) {}
QList<QGuiAction *> actions;
QPointer<QGuiAction> current;
uint enabled : 1;
uint visible : 1;
QGuiActionGroup::ExclusionPolicy exclusionPolicy = QGuiActionGroup::ExclusionPolicy::Exclusive;
private:
void _q_actionTriggered(); //private slot
void _q_actionChanged(); //private slot
void _q_actionHovered(); //private slot
};
QT_END_NAMESPACE
#endif // QACTIONGROUP_P_H

1
src/widgets/graphicsview/qgraphicswidget.h
View File

@ -42,6 +42,7 @@
#include <QtWidgets/qtwidgetsglobal.h>
#include <QtGui/qfont.h>
#include <QtWidgets/qaction.h>
#include <QtWidgets/qgraphicslayoutitem.h>
#include <QtWidgets/qgraphicsitem.h>
#include <QtGui/qpalette.h>

1060
src/widgets/kernel/qaction.cpp
View File

File diff suppressed because it is too large Load Diff

127
src/widgets/kernel/qaction.h
View File

@ -41,13 +41,10 @@
#define QACTION_H
#include <QtWidgets/qtwidgetsglobal.h>
#if QT_CONFIG(shortcut)
# include <QtGui/qkeysequence.h>
#endif
#include <QtGui/qguiaction.h>
#include <QtCore/qstring.h>
#include <QtWidgets/qwidget.h>
#include <QtCore/qvariant.h>
#include <QtGui/qicon.h>
QT_BEGIN_NAMESPACE
@ -59,121 +56,25 @@ class QActionGroup;
class QActionPrivate;
class QGraphicsWidget;
class Q_WIDGETS_EXPORT QAction : public QObject
class Q_WIDGETS_EXPORT QAction : public QGuiAction
{
Q_OBJECT
Q_DECLARE_PRIVATE(QAction)
Q_PROPERTY(bool checkable READ isCheckable WRITE setCheckable NOTIFY changed)
Q_PROPERTY(bool checked READ isChecked WRITE setChecked DESIGNABLE isCheckable NOTIFY toggled)
Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY changed)
Q_PROPERTY(QIcon icon READ icon WRITE setIcon NOTIFY changed)
Q_PROPERTY(QString text READ text WRITE setText NOTIFY changed)
Q_PROPERTY(QString iconText READ iconText WRITE setIconText NOTIFY changed)
Q_PROPERTY(QString toolTip READ toolTip WRITE setToolTip NOTIFY changed)
Q_PROPERTY(QString statusTip READ statusTip WRITE setStatusTip NOTIFY changed)
Q_PROPERTY(QString whatsThis READ whatsThis WRITE setWhatsThis NOTIFY changed)
Q_PROPERTY(QFont font READ font WRITE setFont NOTIFY changed)
#if QT_CONFIG(shortcut)
Q_PROPERTY(QKeySequence shortcut READ shortcut WRITE setShortcut NOTIFY changed)
Q_PROPERTY(Qt::ShortcutContext shortcutContext READ shortcutContext WRITE setShortcutContext NOTIFY changed)
Q_PROPERTY(bool autoRepeat READ autoRepeat WRITE setAutoRepeat NOTIFY changed)
#endif
Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY changed)
Q_PROPERTY(MenuRole menuRole READ menuRole WRITE setMenuRole NOTIFY changed)
Q_PROPERTY(bool iconVisibleInMenu READ isIconVisibleInMenu WRITE setIconVisibleInMenu NOTIFY changed)
Q_PROPERTY(bool shortcutVisibleInContextMenu READ isShortcutVisibleInContextMenu WRITE setShortcutVisibleInContextMenu NOTIFY changed)
Q_PROPERTY(Priority priority READ priority WRITE setPriority)
public:
// note this is copied into qplatformmenu.h, which must stay in sync
enum MenuRole { NoRole = 0, TextHeuristicRole, ApplicationSpecificRole, AboutQtRole,
AboutRole, PreferencesRole, QuitRole };
Q_ENUM(MenuRole)
enum Priority { LowPriority = 0,
NormalPriority = 128,
HighPriority = 256};
Q_ENUM(Priority)
explicit QAction(QObject *parent = nullptr);
explicit QAction(const QString &text, QObject *parent = nullptr);
explicit QAction(const QIcon &icon, const QString &text, QObject *parent = nullptr);
QAction(QObject* parent = nullptr);
QAction(const QString &text, QObject* parent = nullptr);
QAction(const QIcon &icon, const QString &text, QObject* parent);
~QAction();
void setActionGroup(QActionGroup *group);
QActionGroup *actionGroup() const;
void setIcon(const QIcon &icon);
QIcon icon() const;
void setText(const QString &text);
QString text() const;
void setIconText(const QString &text);
QString iconText() const;
void setToolTip(const QString &tip);
QString toolTip() const;
void setStatusTip(const QString &statusTip);
QString statusTip() const;
void setWhatsThis(const QString &what);
QString whatsThis() const;
void setPriority(Priority priority);
Priority priority() const;
#if QT_CONFIG(menu)
QMenu *menu() const;
void setMenu(QMenu *menu);
#endif
void setSeparator(bool b);
bool isSeparator() const;
#if QT_CONFIG(shortcut)
void setShortcut(const QKeySequence &shortcut);
QKeySequence shortcut() const;
void setShortcuts(const QList<QKeySequence> &shortcuts);
void setShortcuts(QKeySequence::StandardKey);
QList<QKeySequence> shortcuts() const;
void setShortcutContext(Qt::ShortcutContext context);
Qt::ShortcutContext shortcutContext() const;
void setAutoRepeat(bool);
bool autoRepeat() const;
#endif
void setFont(const QFont &font);
QFont font() const;
void setCheckable(bool);
bool isCheckable() const;
QVariant data() const;
void setData(const QVariant &var);
bool isChecked() const;
bool isEnabled() const;
bool isVisible() const;
enum ActionEvent { Trigger, Hover };
void activate(ActionEvent event);
bool showStatusText(QWidget *widget = nullptr);
void setMenuRole(MenuRole menuRole);
MenuRole menuRole() const;
void setIconVisibleInMenu(bool visible);
bool isIconVisibleInMenu() const;
void setShortcutVisibleInContextMenu(bool show);
bool isShortcutVisibleInContextMenu() const;
QWidget *parentWidget() const;
QList<QWidget *> associatedWidgets() const;
@ -182,30 +83,14 @@ public:
#endif
protected:
bool event(QEvent *) override;
QAction(QActionPrivate &dd, QObject *parent);
public Q_SLOTS:
void trigger() { activate(Trigger); }
void hover() { activate(Hover); }
void setChecked(bool);
void toggle();
void setEnabled(bool);
inline void setDisabled(bool b) { setEnabled(!b); }
void setVisible(bool);
Q_SIGNALS:
void changed();
void triggered(bool checked = false);
void hovered();
void toggled(bool);
bool event(QEvent *) override;
private:
Q_DISABLE_COPY(QAction)
friend class QGraphicsWidget;
friend class QWidget;
friend class QActionGroup;
friend class QMenu;
friend class QMenuPrivate;
friend class QMenuBar;

49
src/widgets/kernel/qaction_p.h
View File

@ -52,6 +52,7 @@
//
#include <QtWidgets/private/qtwidgetsglobal_p.h>
#include <QtGui/private/qguiaction_p.h>
#include "QtWidgets/qaction.h"
#if QT_CONFIG(menu)
#include "QtWidgets/qmenu.h"
@ -68,12 +69,15 @@ QT_BEGIN_NAMESPACE
class QShortcutMap;
class Q_WIDGETS_EXPORT QActionPrivate : public QObjectPrivate
class Q_WIDGETS_EXPORT QActionPrivate : public QGuiActionPrivate
{
Q_DECLARE_PUBLIC(QAction)
public:
QActionPrivate();
~QActionPrivate();
QActionPrivate() = default;
#if QT_CONFIG(shortcut)
QShortcutMap::ContextMatcher contextMatcher() const override;
#endif
static QActionPrivate *get(QAction *q)
{
@ -82,50 +86,11 @@ public:
bool showStatusText(QWidget *w, const QString &str);
QPointer<QActionGroup> group;
QString text;
QString iconText;
QIcon icon;
QString tooltip;
QString statustip;
QString whatsthis;
#if QT_CONFIG(shortcut)
QKeySequence shortcut;
QList<QKeySequence> alternateShortcuts;
#endif
QVariant userData;
#if QT_CONFIG(shortcut)
int shortcutId = 0;
QVector<int> alternateShortcutIds;
Qt::ShortcutContext shortcutContext = Qt::WindowShortcut;
uint autorepeat : 1;
#endif
QFont font;
QPointer<QMenu> menu;
uint enabled : 1, forceDisabled : 1;
uint visible : 1, forceInvisible : 1;
uint checkable : 1;
uint checked : 1;
uint separator : 1;
uint fontSet : 1;
int iconVisibleInMenu : 2; // Only has values -1, 0, and 1
int shortcutVisibleInContextMenu : 2; // Only has values -1, 0, and 1
QAction::MenuRole menuRole = QAction::TextHeuristicRole;
QAction::Priority priority = QAction::NormalPriority;
QWidgetList widgets;
#if QT_CONFIG(graphicsview)
QList<QGraphicsWidget *> graphicsWidgets;
#endif
#if QT_CONFIG(shortcut)
void redoGrab(QShortcutMap &map);
void redoGrabAlternate(QShortcutMap &map);
void setShortcutEnabled(bool enable, QShortcutMap &map);
#endif // QT_NO_SHORTCUT
void sendDataChanged();
};
#endif // QT_NO_ACTION

304
src/widgets/kernel/qactiongroup.cpp
View File

@ -38,68 +38,32 @@
****************************************************************************/
#include "qactiongroup.h"
#include <QtGui/private/qguiactiongroup_p.h>
#ifndef QT_NO_ACTION
#include "qaction_p.h"
#include "qevent.h"
#include "qlist.h"
#include "qaction.h"
QT_BEGIN_NAMESPACE
class QActionGroupPrivate : public QObjectPrivate
class QActionGroupPrivate : public QGuiActionGroupPrivate
{
Q_DECLARE_PUBLIC(QActionGroup)
public:
QActionGroupPrivate() : enabled(1),
visible(1),
exclusionPolicy(QActionGroup::ExclusionPolicy::Exclusive)
{
}
QList<QAction *> actions;
QPointer<QAction> current;
uint enabled : 1;
uint visible : 1;
QActionGroup::ExclusionPolicy exclusionPolicy;
private:
void _q_actionTriggered(); //private slot
void _q_actionChanged(); //private slot
void _q_actionHovered(); //private slot
void emitSignal(Signal, QGuiAction *) override;
};
void QActionGroupPrivate::_q_actionChanged()
void QActionGroupPrivate::emitSignal(Signal s, QGuiAction *action)
{
Q_Q(QActionGroup);
QAction *action = qobject_cast<QAction*>(q->sender());
Q_ASSERT_X(action != nullptr, "QActionGroup::_q_actionChanged", "internal error");
if (exclusionPolicy != QActionGroup::ExclusionPolicy::None) {
if (action->isChecked()) {
if (action != current) {
if(current)
current->setChecked(false);
current = action;
switch (s) {
case QGuiActionGroupPrivate::Triggered:
emit q->triggered(static_cast<QAction *>(action));
break;
case QGuiActionGroupPrivate::Hovered:
emit q->hovered(static_cast<QAction *>(action));
break;
}
} else if (action == current) {
current = 0;
}
}
}
void QActionGroupPrivate::_q_actionTriggered()
{
Q_Q(QActionGroup);
QAction *action = qobject_cast<QAction*>(q->sender());
Q_ASSERT_X(action != nullptr, "QActionGroup::_q_actionTriggered", "internal error");
emit q->triggered(action);
}
void QActionGroupPrivate::_q_actionHovered()
{
Q_Q(QActionGroup);
QAction *action = qobject_cast<QAction*>(q->sender());
Q_ASSERT_X(action != nullptr, "QActionGroup::_q_actionHovered", "internal error");
emit q->hovered(action);
}
/*!
@ -153,27 +117,6 @@ void QActionGroupPrivate::_q_actionHovered()
\sa QAction
*/
/*!
\enum QActionGroup::ExclusionPolicy
This enum specifies the different policies that can be used to
control how the group performs exclusive checking on checkable actions.
\value None
The actions in the group can be checked independently of each other.
\value Exclusive
Exactly one action can be checked at any one time.
This is the default policy.
\value ExclusiveOptional
At most one action can be checked at any one time. The actions
can also be all unchecked.
\sa exclusionPolicy
\since 5.14
*/
/*!
Constructs an action group for the \a parent object.
@ -182,53 +125,24 @@ void QActionGroupPrivate::_q_actionHovered()
but allow unchecking the active action call instead
setExclusionPolicy(QActionGroup::ExclusionPolicy::ExclusiveOptional)
*/
QActionGroup::QActionGroup(QObject* parent) : QObject(*new QActionGroupPrivate, parent)
QActionGroup::QActionGroup(QObject* parent) :
QGuiActionGroup(*new QActionGroupPrivate, parent)
{
}
/*!
Destroys the action group.
*/
QActionGroup::~QActionGroup()
QActionGroup::~QActionGroup() = default;
QAction *QActionGroup::checkedAction() const
{
return static_cast<QAction *>(checkedGuiAction());
}
/*!
\fn QAction *QActionGroup::addAction(QAction *action)
Adds the \a action to this group, and returns it.
Normally an action is added to a group by creating it with the
group as its parent, so this function is not usually used.
\sa QAction::setActionGroup()
*/
QAction *QActionGroup::addAction(QAction* a)
QAction *QActionGroup::addAction(QAction *a)
{
Q_D(QActionGroup);
if(!d->actions.contains(a)) {
d->actions.append(a);
QObject::connect(a, SIGNAL(triggered()), this, SLOT(_q_actionTriggered()));
QObject::connect(a, SIGNAL(changed()), this, SLOT(_q_actionChanged()));
QObject::connect(a, SIGNAL(hovered()), this, SLOT(_q_actionHovered()));
}
if(!a->d_func()->forceDisabled) {
a->setEnabled(d->enabled);
a->d_func()->forceDisabled = false;
}
if(!a->d_func()->forceInvisible) {
a->setVisible(d->visible);
a->d_func()->forceInvisible = false;
}
if(a->isChecked())
d->current = a;
QActionGroup *oldGroup = a->d_func()->group;
if(oldGroup != this) {
if (oldGroup)
oldGroup->removeAction(a);
a->d_func()->group = this;
a->d_func()->sendDataChanged();
}
QGuiActionGroup::addAction(a);
return a;
}
@ -260,185 +174,19 @@ QAction *QActionGroup::addAction(const QIcon &icon, const QString &text)
return new QAction(icon, text, this);
}
/*!
Removes the \a action from this group. The action will have no
parent as a result.
\sa QAction::setActionGroup()
*/
void QActionGroup::removeAction(QAction *action)
{
Q_D(QActionGroup);
if (d->actions.removeAll(action)) {
if (action == d->current)
d->current = 0;
QObject::disconnect(action, SIGNAL(triggered()), this, SLOT(_q_actionTriggered()));
QObject::disconnect(action, SIGNAL(changed()), this, SLOT(_q_actionChanged()));
QObject::disconnect(action, SIGNAL(hovered()), this, SLOT(_q_actionHovered()));
action->d_func()->group = 0;
}
}
/*!
Returns the list of this groups's actions. This may be empty.
*/
QList<QAction*> QActionGroup::actions() const
{
Q_D(const QActionGroup);
return d->actions;
QList<QAction*> result;
const auto baseActions = guiActions();
result.reserve(baseActions.size());
for (auto baseAction : baseActions)
result.append(static_cast<QAction*>(baseAction));
return result;
}
/*!
\brief Enable or disable the group exclusion checking
This is a convenience method that calls
setExclusionPolicy(ExclusionPolicy::Exclusive).
\sa QActionGroup::exclusionPolicy
*/
void QActionGroup::setExclusive(bool b)
{
setExclusionPolicy(b ? QActionGroup::ExclusionPolicy::Exclusive
: QActionGroup::ExclusionPolicy::None);
}
/*!
\brief Returs true if the group is exclusive
The group is exclusive if the ExclusionPolicy is either Exclusive
or ExclusionOptional.
*/
bool QActionGroup::isExclusive() const
{
return exclusionPolicy() != QActionGroup::ExclusionPolicy::None;
}
/*!
\property QActionGroup::exclusionPolicy
\brief This property holds the group exclusive checking policy
If exclusionPolicy is set to Exclusive, only one checkable
action in the action group can ever be active at any time. If the user
chooses another checkable action in the group, the one they chose becomes
active and the one that was active becomes inactive. If exclusionPolicy is
set to ExclusionOptional the group is exclusive but the active checkable
action in the group can be unchecked leaving the group with no actions
checked.
\sa QAction::checkable
\since 5.14
*/
void QActionGroup::setExclusionPolicy(QActionGroup::ExclusionPolicy policy)
{
Q_D(QActionGroup);
d->exclusionPolicy = policy;
}
QActionGroup::ExclusionPolicy QActionGroup::exclusionPolicy() const
{
Q_D(const QActionGroup);
return d->exclusionPolicy;
}
/*!
\fn void QActionGroup::setDisabled(bool b)
This is a convenience function for the \l enabled property, that
is useful for signals--slots connections. If \a b is true the
action group is disabled; otherwise it is enabled.
*/
/*!
\property QActionGroup::enabled
\brief whether the action group is enabled
Each action in the group will be enabled or disabled unless it
has been explicitly disabled.
\sa QAction::setEnabled()
*/
void QActionGroup::setEnabled(bool b)
{
Q_D(QActionGroup);
d->enabled = b;
for (auto action : qAsConst(d->actions)) {
if (!action->d_func()->forceDisabled) {
action->setEnabled(b);
action->d_func()->forceDisabled = false;
}
}
}
bool QActionGroup::isEnabled() const
{
Q_D(const QActionGroup);
return d->enabled;
}
/*!
Returns the currently checked action in the group, or \nullptr if
none are checked.
*/
QAction *QActionGroup::checkedAction() const
{
Q_D(const QActionGroup);
return d->current;
}
/*!
\property QActionGroup::visible
\brief whether the action group is visible
Each action in the action group will match the visible state of
this group unless it has been explicitly hidden.
\sa QAction::setEnabled()
*/
void QActionGroup::setVisible(bool b)
{
Q_D(QActionGroup);
d->visible = b;
for (auto action : qAsConst(d->actions)) {
if (!action->d_func()->forceInvisible) {
action->setVisible(b);
action->d_func()->forceInvisible = false;
}
}
}
bool QActionGroup::isVisible() const
{
Q_D(const QActionGroup);
return d->visible;
}
/*!
\fn void QActionGroup::triggered(QAction *action)
This signal is emitted when the given \a action in the action
group is activated by the user; for example, when the user clicks
a menu option, toolbar button, or presses an action's shortcut key
combination.
Connect to this signal for command actions.
\sa QAction::activate()
*/
/*!
\fn void QActionGroup::hovered(QAction *action)
This signal is emitted when the given \a action in the action
group is highlighted by the user; for example, when the user
pauses with the cursor over a menu option, toolbar button, or
presses an action's shortcut key combination.
\sa QAction::activate()
*/
QT_END_NAMESPACE
#include "moc_qactiongroup.cpp"
#endif // QT_NO_ACTION

37
src/widgets/kernel/qactiongroup.h
View File

@ -41,6 +41,7 @@
#define QACTIONGROUP_H
#include <QtWidgets/qtwidgetsglobal.h>
#include <QtGui/qguiactiongroup.h>
#include <QtWidgets/qaction.h>
QT_BEGIN_NAMESPACE
@ -50,55 +51,29 @@ QT_BEGIN_NAMESPACE
class QActionGroupPrivate;
class Q_WIDGETS_EXPORT QActionGroup : public QObject
class Q_WIDGETS_EXPORT QActionGroup : public QGuiActionGroup
{
Q_OBJECT
Q_DECLARE_PRIVATE(QActionGroup)
Q_PROPERTY(QActionGroup::ExclusionPolicy exclusionPolicy READ exclusionPolicy WRITE setExclusionPolicy)
Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled)
Q_PROPERTY(bool visible READ isVisible WRITE setVisible)
public:
enum class ExclusionPolicy {
None,
Exclusive,
ExclusiveOptional
};
Q_ENUM(ExclusionPolicy)
explicit QActionGroup(QObject* parent);
~QActionGroup();
QAction *addAction(QAction* a);
QAction *checkedAction() const;
QAction *addAction(QAction *a);
QAction *addAction(const QString &text);
QAction *addAction(const QIcon &icon, const QString &text);
void removeAction(QAction *a);
QList<QAction*> actions() const;
QAction *checkedAction() const;
bool isExclusive() const;
bool isEnabled() const;
bool isVisible() const;
ExclusionPolicy exclusionPolicy() const;
public Q_SLOTS:
void setEnabled(bool);
inline void setDisabled(bool b) { setEnabled(!b); }
void setVisible(bool);
void setExclusive(bool);
void setExclusionPolicy(ExclusionPolicy policy);
Q_SIGNALS:
void triggered(QAction *);
void hovered(QAction *);
private:
Q_DISABLE_COPY(QActionGroup)
Q_PRIVATE_SLOT(d_func(), void _q_actionTriggered())
Q_PRIVATE_SLOT(d_func(), void _q_actionChanged())
Q_PRIVATE_SLOT(d_func(), void _q_actionHovered())
};
#endif // QT_NO_ACTION

2
src/widgets/styles/qstyleoption.cpp
View File

@ -1760,7 +1760,7 @@ QStyleOptionMenuItem::QStyleOptionMenuItem(int version)
\value Exclusive The item is an exclusive check item (like a radio button).
\value NonExclusive The item is a non-exclusive check item (like a check box).
\sa checkType, QAction::checkable, QAction::checked, QActionGroup::exclusionPolicy
\sa checkType, QGuiAction::checkable, QGuiAction::checked, QGuiActionGroup::exclusionPolicy
*/
/*!

6
src/widgets/widgets/qlineedit_p.cpp
View File

@ -370,7 +370,7 @@ void QLineEditIconButton::actionEvent(QActionEvent *e)
{
switch (e->type()) {
case QEvent::ActionChanged: {
const QAction *action = e->action();
const auto *action = e->action();
if (isVisibleTo(parentWidget()) != action->isVisible()) {
setVisible(action->isVisible());
if (QLineEditPrivate *lep = lineEditPrivate())
@ -545,7 +545,7 @@ void QLineEditPrivate::positionSideWidgets()
}
}
QLineEditPrivate::SideWidgetLocation QLineEditPrivate::findSideWidget(const QAction *a) const
QLineEditPrivate::SideWidgetLocation QLineEditPrivate::findSideWidget(const QGuiAction *a) const
{
int i = 0;
for (const auto &e : leadingSideWidgets) {
@ -634,7 +634,7 @@ QWidget *QLineEditPrivate::addAction(QAction *newAction, QAction *before, QLineE
return w;
}
void QLineEditPrivate::removeAction(QAction *action)
void QLineEditPrivate::removeAction(QGuiAction *action)
{
#if QT_CONFIG(action)
Q_Q(QLineEdit);

4
src/widgets/widgets/qlineedit_p.h
View File

@ -239,7 +239,7 @@ public:
QString placeholderText;
QWidget *addAction(QAction *newAction, QAction *before, QLineEdit::ActionPosition, int flags = 0);
void removeAction(QAction *action);
void removeAction(QGuiAction *action);
SideWidgetParameters sideWidgetParameters() const;
QIcon clearButtonIcon() const;
void setClearButtonEnabled(bool enabled);
@ -261,7 +261,7 @@ private:
};
friend class QTypeInfo<SideWidgetLocation>;
SideWidgetLocation findSideWidget(const QAction *a) const;
SideWidgetLocation findSideWidget(const QGuiAction *a) const;
SideWidgetEntryList leadingSideWidgets;
SideWidgetEntryList trailingSideWidgets;

12
src/widgets/widgets/qmenu.cpp
View File

@ -157,10 +157,11 @@ public:
Q_D(QTornOffMenu);
if(menu != d->causedMenu)
return;
auto action = static_cast<QAction *>(act->action());
if (act->type() == QEvent::ActionAdded) {
insertAction(act->before(), act->action());
insertAction(static_cast<QAction *>(act->before()), action);
} else if (act->type() == QEvent::ActionRemoved)
removeAction(act->action());
removeAction(action);
}
void actionEvent(QActionEvent *e) override
{
@ -3547,15 +3548,16 @@ void QMenu::actionEvent(QActionEvent *e)
wa->releaseWidget(widget);
}
}
d->widgetItems.remove(e->action());
d->widgetItems.remove(static_cast<QAction *>(e->action()));
}
if (!d->platformMenu.isNull()) {
auto action = static_cast<QAction *>(e->action());
if (e->type() == QEvent::ActionAdded) {
QPlatformMenuItem *beforeItem = e->before()
? d->platformMenu->menuItemForTag(reinterpret_cast<quintptr>(e->before()))
: nullptr;
d->insertActionInPlatformMenu(e->action(), beforeItem);
d->insertActionInPlatformMenu(action, beforeItem);
} else if (e->type() == QEvent::ActionRemoved) {
QPlatformMenuItem *menuItem = d->platformMenu->menuItemForTag(reinterpret_cast<quintptr>(e->action()));
d->platformMenu->removeMenuItem(menuItem);
@ -3563,7 +3565,7 @@ void QMenu::actionEvent(QActionEvent *e)
} else if (e->type() == QEvent::ActionChanged) {
QPlatformMenuItem *menuItem = d->platformMenu->menuItemForTag(reinterpret_cast<quintptr>(e->action()));
if (menuItem) {
d->copyActionToPlatformItem(e->action(), menuItem);
d->copyActionToPlatformItem(action, menuItem);
d->platformMenu->syncMenuItem(menuItem);
}
}

17
src/widgets/widgets/qmenubar.cpp
View File

@ -1288,21 +1288,22 @@ void QMenuBar::actionEvent(QActionEvent *e)
if (!nativeMenuBar)
return;
auto action = static_cast<QAction *>(e->action());
if (e->type() == QEvent::ActionAdded) {
QPlatformMenu *menu = d->getPlatformMenu(e->action());
QPlatformMenu *menu = d->getPlatformMenu(action);
if (menu) {
d->copyActionToPlatformMenu(e->action(), menu);
d->copyActionToPlatformMenu(action, menu);
QPlatformMenu *beforeMenu = d->findInsertionPlatformMenu(e->action());
QPlatformMenu *beforeMenu = d->findInsertionPlatformMenu(action);
d->platformMenuBar->insertMenu(menu, beforeMenu);
}
} else if (e->type() == QEvent::ActionRemoved) {
QPlatformMenu *menu = d->getPlatformMenu(e->action());
QPlatformMenu *menu = d->getPlatformMenu(action);
if (menu)
d->platformMenuBar->removeMenu(menu);
} else if (e->type() == QEvent::ActionChanged) {
QPlatformMenu *cur = d->platformMenuBar->menuForTag(reinterpret_cast<quintptr>(e->action()));
QPlatformMenu *menu = d->getPlatformMenu(e->action());
QPlatformMenu *menu = d->getPlatformMenu(action);
// the menu associated with the action can change, need to
// remove and/or insert the new platform menu
@ -1310,13 +1311,13 @@ void QMenuBar::actionEvent(QActionEvent *e)
if (cur)
d->platformMenuBar->removeMenu(cur);
if (menu) {
d->copyActionToPlatformMenu(e->action(), menu);
d->copyActionToPlatformMenu(action, menu);
QPlatformMenu *beforeMenu = d->findInsertionPlatformMenu(e->action());
QPlatformMenu *beforeMenu = d->findInsertionPlatformMenu(action);
d->platformMenuBar->insertMenu(menu, beforeMenu);
}
} else if (menu) {
d->copyActionToPlatformMenu(e->action(), menu);
d->copyActionToPlatformMenu(action, menu);
d->platformMenuBar->syncMenu(menu);
}
}

2
src/widgets/widgets/qtoolbar.cpp
View File

@ -961,7 +961,7 @@ QAction *QToolBar::actionAt(const QPoint &p) const
void QToolBar::actionEvent(QActionEvent *event)
{
Q_D(QToolBar);
QAction *action = event->action();
auto action = static_cast<QAction *>(event->action());
QWidgetAction *widgetAction = qobject_cast<QWidgetAction *>(action);
switch (event->type()) {

2
src/widgets/widgets/qtoolbarlayout.cpp
View File

@ -207,7 +207,7 @@ void QToolBarLayout::insertAction(int index, QAction *action)
}
}
int QToolBarLayout::indexOf(QAction *action) const
int QToolBarLayout::indexOf(const QGuiAction *action) const
{
for (int i = 0; i < items.count(); ++i) {
if (items.at(i)->action == action)

2
src/widgets/widgets/qtoolbarlayout_p.h
View File

@ -96,7 +96,7 @@ public:
QSize sizeHint() const override;
void insertAction(int index, QAction *action);
int indexOf(QAction *action) const;
int indexOf(const QGuiAction *action) const;
using QLayout::indexOf; // bring back the hidden members
bool layoutActions(const QSize &size);

2
src/widgets/widgets/qtoolbutton.cpp
View File

@ -466,7 +466,7 @@ void QToolButton::paintEvent(QPaintEvent *)
void QToolButton::actionEvent(QActionEvent *event)
{
Q_D(QToolButton);
QAction *action = event->action();
auto action = static_cast<QAction *>(event->action());
switch (event->type()) {
case QEvent::ActionChanged:
if (action == d->defaultAction)

2
tests/auto/widgets/kernel/qaction/tst_qaction.cpp
View File

@ -79,7 +79,7 @@ private slots:
private:
QEvent::Type m_lastEventType;
const int m_keyboardScheme;
QAction *m_lastAction;
QGuiAction *m_lastAction;
};
tst_QAction::tst_QAction()

2
tests/auto/widgets/kernel/qactiongroup/tst_qactiongroup.cpp
View File

@ -259,7 +259,7 @@ void tst_QActionGroup::unCheckCurrentAction()
action1.setChecked(true);
QVERIFY(action1.isChecked());
QVERIFY(!action2.isChecked());
QAction *current = group.checkedAction();
auto current = group.checkedAction();
QCOMPARE(current, &action1);
current->setChecked(false);
QVERIFY(!action1.isChecked());