qactiongroup.cpp

Go to the documentation of this file.

// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qactiongroup.h"
 
#include "qaction.h"
#include "qaction_p.h"
#include "qactiongroup_p.h"
#include "qevent.h"
#include "qlist.h"
 
QT_BEGIN_NAMESPACE
 
QActionGroupPrivate::QActionGroupPrivate() :
    enabled(1), visible(1)
{
}
 
QActionGroupPrivate::~QActionGroupPrivate() = default;
 
void QActionGroup::_q_actionChanged()
{
    Q_D(QActionGroup);
    auto action = qobject_cast<QAction*>(sender());
    Q_ASSERT_X(action != nullptr, "QActionGroup::_q_actionChanged", "internal error");
    if (d->exclusionPolicy != QActionGroup::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 QActionGroup::_q_actionTriggered()
{
    auto action = qobject_cast<QAction*>(sender());
    Q_ASSERT_X(action != nullptr, "QActionGroup::_q_actionTriggered", "internal error");
    emit triggered(action);
}
 
void QActionGroup::_q_actionHovered()
{
    auto action = qobject_cast<QAction*>(sender());
    Q_ASSERT_X(action != nullptr, "QActionGroup::_q_actionHovered", "internal error");
    emit hovered(action);
}
 
QActionGroup::QActionGroup(QObject* parent) :
    QActionGroup(*new QActionGroupPrivate, parent)
{
}
 
QActionGroup::QActionGroup(QActionGroupPrivate &dd, QObject *parent) :
    QObject(dd, parent)
{
}
 
QActionGroup::~QActionGroup() = default;
 
QAction *QActionGroup::addAction(QAction* a)
{
    Q_D(QActionGroup);
    if (!d->actions.contains(a)) {
        d->actions.append(a);
        QObject::connect(a, &QAction::triggered, this, &QActionGroup::_q_actionTriggered);
        QObject::connect(a, &QAction::changed, this, &QActionGroup::_q_actionChanged);
        QObject::connect(a, &QAction::hovered, this, &QActionGroup::_q_actionHovered);
    }
    a->d_func()->setEnabled(d->enabled, true);
    if (!a->d_func()->forceInvisible)
        a->d_func()->setVisible(d->visible);
    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();
    }
    return a;
}
 
QAction *QActionGroup::addAction(const QString &text)
{
    return new QAction(text, this);
}
 
QAction *QActionGroup::addAction(const QIcon &icon, const QString &text)
{
    return new QAction(icon, text, this);
}
 
void QActionGroup::removeAction(QAction *action)
{
    Q_D(QActionGroup);
    if (d->actions.removeAll(action)) {
        if (action == d->current)
            d->current = nullptr;
        QObject::disconnect(action, &QAction::triggered, this, &QActionGroup::_q_actionTriggered);
        QObject::disconnect(action, &QAction::changed, this, &QActionGroup::_q_actionChanged);
        QObject::disconnect(action, &QAction::hovered, this, &QActionGroup::_q_actionHovered);
        action->d_func()->group = nullptr;
    }
}
 
QList<QAction*> QActionGroup::actions() const
{
    Q_D(const QActionGroup);
    return d->actions;
}
 
void QActionGroup::setExclusive(bool b)
{
    setExclusionPolicy(b ? QActionGroup::ExclusionPolicy::Exclusive
                         : QActionGroup::ExclusionPolicy::None);
}
 
bool QActionGroup::isExclusive() const
{
    return exclusionPolicy() != QActionGroup::ExclusionPolicy::None;
}
 
void QActionGroup::setExclusionPolicy(QActionGroup::ExclusionPolicy policy)
{
    Q_D(QActionGroup);
    d->exclusionPolicy = policy;
}
 
QActionGroup::ExclusionPolicy QActionGroup::exclusionPolicy() const
{
    Q_D(const QActionGroup);
    return d->exclusionPolicy;
}
 
void QActionGroup::setEnabled(bool b)
{
    Q_D(QActionGroup);
    d->enabled = b;
    for (auto action : std::as_const(d->actions)) {
        action->d_func()->setEnabled(b, true);
    }
}
 
bool QActionGroup::isEnabled() const
{
    Q_D(const QActionGroup);
    return d->enabled;
}
 
QAction *QActionGroup::checkedAction() const
{
    Q_D(const QActionGroup);
    return d->current.data();
}
 
void QActionGroup::setVisible(bool b)
{
    Q_D(QActionGroup);
    d->visible = b;
    for (auto action : std::as_const(d->actions)) {
        if (!action->d_func()->forceInvisible)
            action->d_func()->setVisible(b);
    }
}
 
bool QActionGroup::isVisible() const
{
    Q_D(const QActionGroup);
    return d->visible;
}
 
QT_END_NAMESPACE
 
#include "moc_qactiongroup.cpp"