qdialogbuttonbox.cpp

Go to the documentation of this file.

// Copyright (C) 2016 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 <QtCore/qhash.h>
#include <QtWidgets/qpushbutton.h>
#include <QtWidgets/qstyle.h>
#include <QtWidgets/qlayout.h>
#include <QtWidgets/qdialog.h>
#include <QtWidgets/qapplication.h>
#include <private/qwidget_p.h>
#include <private/qguiapplication_p.h>
#include <QtGui/qpa/qplatformdialoghelper.h>
#include <QtGui/qpa/qplatformtheme.h>
#include <QtGui/qaction.h>
 
#include "qdialogbuttonbox.h"
#include "qdialogbuttonbox_p.h"
 
QT_BEGIN_NAMESPACE
 
QDialogButtonBoxPrivate::QDialogButtonBoxPrivate(Qt::Orientation orient)
    : orientation(orient), buttonLayout(nullptr), center(false)
{
}
 
void QDialogButtonBoxPrivate::initLayout()
{
    Q_Q(QDialogButtonBox);
    layoutPolicy = QDialogButtonBox::ButtonLayout(q->style()->styleHint(QStyle::SH_DialogButtonLayout, nullptr, q));
    bool createNewLayout = buttonLayout == nullptr
        || (orientation == Qt::Horizontal && qobject_cast<QVBoxLayout *>(buttonLayout) != 0)
        || (orientation == Qt::Vertical && qobject_cast<QHBoxLayout *>(buttonLayout) != 0);
    if (createNewLayout) {
        delete buttonLayout;
        if (orientation == Qt::Horizontal)
            buttonLayout = new QHBoxLayout(q);
        else
            buttonLayout = new QVBoxLayout(q);
    }
 
    int left, top, right, bottom;
    setLayoutItemMargins(QStyle::SE_PushButtonLayoutItem);
    getLayoutItemMargins(&left, &top, &right, &bottom);
    buttonLayout->setContentsMargins(-left, -top, -right, -bottom);
 
    if (!q->testAttribute(Qt::WA_WState_OwnSizePolicy)) {
        QSizePolicy sp(QSizePolicy::Expanding, QSizePolicy::Fixed, QSizePolicy::ButtonBox);
        if (orientation == Qt::Vertical)
            sp.transpose();
        q->setSizePolicy(sp);
        q->setAttribute(Qt::WA_WState_OwnSizePolicy, false);
    }
}
 
void QDialogButtonBoxPrivate::resetLayout()
{
    initLayout();
    layoutButtons();
}
 
void QDialogButtonBoxPrivate::addButtonsToLayout(const QList<QAbstractButton *> &buttonList,
                                                 bool reverse)
{
    int start = reverse ? buttonList.size() - 1 : 0;
    int end = reverse ? -1 : buttonList.size();
    int step = reverse ? -1 : 1;
 
    for (int i = start; i != end; i += step) {
        QAbstractButton *button = buttonList.at(i);
        buttonLayout->addWidget(button);
        button->show();
    }
}
 
void QDialogButtonBoxPrivate::layoutButtons()
{
    Q_Q(QDialogButtonBox);
    const int MacGap = 36 - 8;    // 8 is the default gap between a widget and a spacer item
 
    QBoolBlocker blocker(byPassEventFilter);
    for (int i = buttonLayout->count() - 1; i >= 0; --i) {
        QLayoutItem *item = buttonLayout->takeAt(i);
        if (QWidget *widget = item->widget())
            widget->hide();
        delete item;
    }
 
    int tmpPolicy = layoutPolicy;
 
    static const int M = 5;
    static const int ModalRoles[M] = { QPlatformDialogHelper::AcceptRole, QPlatformDialogHelper::RejectRole,
        QPlatformDialogHelper::DestructiveRole, QPlatformDialogHelper::YesRole, QPlatformDialogHelper::NoRole };
    if (tmpPolicy == QDialogButtonBox::MacLayout) {
        bool hasModalButton = false;
        for (int i = 0; i < M; ++i) {
            if (!buttonLists[ModalRoles[i]].isEmpty()) {
                hasModalButton = true;
                break;
            }
        }
        if (!hasModalButton)
            tmpPolicy = 4;  // Mac modeless
    }
 
    const int *currentLayout = QPlatformDialogHelper::buttonLayout(
        orientation, static_cast<QPlatformDialogHelper::ButtonLayout>(tmpPolicy));
 
    if (center)
        buttonLayout->addStretch();
 
    const QList<QAbstractButton *> &acceptRoleList = buttonLists[QPlatformDialogHelper::AcceptRole];
 
    while (*currentLayout != QPlatformDialogHelper::EOL) {
        int role = (*currentLayout & ~QPlatformDialogHelper::Reverse);
        bool reverse = (*currentLayout & QPlatformDialogHelper::Reverse);
 
        switch (role) {
        case QPlatformDialogHelper::Stretch:
            if (!center)
                buttonLayout->addStretch();
            break;
        case QPlatformDialogHelper::AcceptRole: {
            if (acceptRoleList.isEmpty())
                break;
            // Only the first one
            QAbstractButton *button = acceptRoleList.first();
            buttonLayout->addWidget(button);
            button->show();
        }
            break;
        case QPlatformDialogHelper::AlternateRole:
            if (acceptRoleList.size() > 1)
                addButtonsToLayout(acceptRoleList.mid(1), reverse);
            break;
        case QPlatformDialogHelper::DestructiveRole:
            {
                const QList<QAbstractButton *> &list = buttonLists[role];
 
                /*
                    Mac: Insert a gap on the left of the destructive
                    buttons to ensure that they don't get too close to
                    the help and action buttons (but only if there are
                    some buttons to the left of the destructive buttons
                    (and the stretch, whence buttonLayout->count() > 1
                    and not 0)).
                */
                if (tmpPolicy == QDialogButtonBox::MacLayout
                        && !list.isEmpty() && buttonLayout->count() > 1)
                    buttonLayout->addSpacing(MacGap);
 
                addButtonsToLayout(list, reverse);
 
                /*
                    Insert a gap between the destructive buttons and the
                    accept and reject buttons.
                */
                if (tmpPolicy == QDialogButtonBox::MacLayout && !list.isEmpty())
                    buttonLayout->addSpacing(MacGap);
            }
            break;
        case QPlatformDialogHelper::RejectRole:
        case QPlatformDialogHelper::ActionRole:
        case QPlatformDialogHelper::HelpRole:
        case QPlatformDialogHelper::YesRole:
        case QPlatformDialogHelper::NoRole:
        case QPlatformDialogHelper::ApplyRole:
        case QPlatformDialogHelper::ResetRole:
            addButtonsToLayout(buttonLists[role], reverse);
        }
        ++currentLayout;
    }
 
    QWidget *lastWidget = nullptr;
    q->setFocusProxy(nullptr);
    for (int i = 0; i < buttonLayout->count(); ++i) {
        QLayoutItem *item = buttonLayout->itemAt(i);
        if (QWidget *widget = item->widget()) {
            if (lastWidget)
                QWidget::setTabOrder(lastWidget, widget);
            else
                q->setFocusProxy(widget);
            lastWidget = widget;
        }
    }
 
    if (center)
        buttonLayout->addStretch();
}
 
QPushButton *QDialogButtonBoxPrivate::createButton(QDialogButtonBox::StandardButton sbutton,
                                                   LayoutRule layoutRule)
{
    Q_Q(QDialogButtonBox);
    int icon = 0;
 
    switch (sbutton) {
    case QDialogButtonBox::Ok:
        icon = QStyle::SP_DialogOkButton;
        break;
    case QDialogButtonBox::Save:
        icon = QStyle::SP_DialogSaveButton;
        break;
    case QDialogButtonBox::Open:
        icon = QStyle::SP_DialogOpenButton;
        break;
    case QDialogButtonBox::Cancel:
        icon = QStyle::SP_DialogCancelButton;
        break;
    case QDialogButtonBox::Close:
        icon = QStyle::SP_DialogCloseButton;
        break;
    case QDialogButtonBox::Apply:
        icon = QStyle::SP_DialogApplyButton;
        break;
    case QDialogButtonBox::Reset:
        icon = QStyle::SP_DialogResetButton;
        break;
    case QDialogButtonBox::Help:
        icon = QStyle::SP_DialogHelpButton;
        break;
    case QDialogButtonBox::Discard:
        icon = QStyle::SP_DialogDiscardButton;
        break;
    case QDialogButtonBox::Yes:
        icon = QStyle::SP_DialogYesButton;
        break;
    case QDialogButtonBox::No:
        icon = QStyle::SP_DialogNoButton;
        break;
    case QDialogButtonBox::YesToAll:
        icon = QStyle::SP_DialogYesToAllButton;
        break;
    case QDialogButtonBox::NoToAll:
        icon = QStyle::SP_DialogNoToAllButton;
        break;
    case QDialogButtonBox::SaveAll:
        icon = QStyle::SP_DialogSaveAllButton;
        break;
    case QDialogButtonBox::Abort:
        icon = QStyle::SP_DialogAbortButton;
        break;
    case QDialogButtonBox::Retry:
        icon = QStyle::SP_DialogRetryButton;
        break;
    case QDialogButtonBox::Ignore:
        icon = QStyle::SP_DialogIgnoreButton;
        break;
    case QDialogButtonBox::RestoreDefaults:
        icon = QStyle::SP_RestoreDefaultsButton;
        break;
    case QDialogButtonBox::NoButton:
        return nullptr;
        ;
    }
    QPushButton *button = new QPushButton(QGuiApplicationPrivate::platformTheme()->standardButtonText(sbutton), q);
    QStyle *style = q->style();
    if (style->styleHint(QStyle::SH_DialogButtonBox_ButtonsHaveIcons, nullptr, q) && icon != 0)
        button->setIcon(style->standardIcon(QStyle::StandardPixmap(icon), nullptr, q));
    if (style != QApplication::style()) // Propagate style
        button->setStyle(style);
    standardButtonHash.insert(button, sbutton);
    QPlatformDialogHelper::ButtonRole role = QPlatformDialogHelper::buttonRole(static_cast<QPlatformDialogHelper::StandardButton>(sbutton));
    if (Q_UNLIKELY(role == QPlatformDialogHelper::InvalidRole))
        qWarning("QDialogButtonBox::createButton: Invalid ButtonRole, button not added");
    else
        addButton(button, static_cast<QDialogButtonBox::ButtonRole>(role), layoutRule);
#if QT_CONFIG(shortcut)
    const QKeySequence standardShortcut = QGuiApplicationPrivate::platformTheme()->standardButtonShortcut(sbutton);
    if (!standardShortcut.isEmpty())
        button->setShortcut(standardShortcut);
#endif
    return button;
}
 
void QDialogButtonBoxPrivate::addButton(QAbstractButton *button, QDialogButtonBox::ButtonRole role,
                                        LayoutRule layoutRule, AddRule addRule)
{
    Q_Q(QDialogButtonBox);
    buttonLists[role].append(button);
    switch (addRule) {
    case AddRule::Connect:
        QObjectPrivate::connect(button, &QAbstractButton::clicked,
                               this, &QDialogButtonBoxPrivate::handleButtonClicked);
        QObjectPrivate::connect(button, &QAbstractButton::destroyed,
                               this, &QDialogButtonBoxPrivate::handleButtonDestroyed);
        button->installEventFilter(q);
        break;
    case AddRule::SkipConnect:
        break;
    }
 
    switch (layoutRule) {
    case LayoutRule::DoLayout:
        layoutButtons();
        break;
    case LayoutRule::SkipLayout:
        break;
    }
}
 
void QDialogButtonBoxPrivate::createStandardButtons(QDialogButtonBox::StandardButtons buttons)
{
    uint i = QDialogButtonBox::FirstButton;
    while (i <= QDialogButtonBox::LastButton) {
        if (i & buttons)
            createButton(QDialogButtonBox::StandardButton(i), LayoutRule::SkipLayout);
        i = i << 1;
    }
    layoutButtons();
}
 
void QDialogButtonBoxPrivate::retranslateStrings()
{
    for (auto &&[key, value] : std::as_const(standardButtonHash).asKeyValueRange()) {
        const QString text = QGuiApplicationPrivate::platformTheme()->standardButtonText(value);
        if (!text.isEmpty())
            key->setText(text);
    }
}
 
QDialogButtonBox::QDialogButtonBox(QWidget *parent)
    : QDialogButtonBox(Qt::Horizontal, parent)
{
}
 
QDialogButtonBox::QDialogButtonBox(Qt::Orientation orientation, QWidget *parent)
    : QWidget(*new QDialogButtonBoxPrivate(orientation), parent, { })
{
    d_func()->initLayout();
}
 
QDialogButtonBox::QDialogButtonBox(StandardButtons buttons, QWidget *parent)
    : QDialogButtonBox(buttons, Qt::Horizontal, parent)
{
}
 
QDialogButtonBox::QDialogButtonBox(StandardButtons buttons, Qt::Orientation orientation,
                                   QWidget *parent)
    : QDialogButtonBox(orientation, parent)
{
    d_func()->createStandardButtons(buttons);
}
 
QDialogButtonBox::~QDialogButtonBox()
{
    Q_D(QDialogButtonBox);
 
    d->byPassEventFilter = true;
 
    // QObjectPrivate::connect requires explicit disconnect in destructor
    // otherwise the connection may kick in on child destruction and reach
    // the parent's destroyed private object
    d->disconnectAll();
}
 
 
 
Qt::Orientation QDialogButtonBox::orientation() const
{
    return d_func()->orientation;
}
 
void QDialogButtonBox::setOrientation(Qt::Orientation orientation)
{
    Q_D(QDialogButtonBox);
    if (orientation == d->orientation)
        return;
 
    d->orientation = orientation;
    d->resetLayout();
}
 
void QDialogButtonBox::clear()
{
    Q_D(QDialogButtonBox);
    // Remove the created standard buttons, they should be in the other lists, which will
    // do the deletion
    d->standardButtonHash.clear();
    for (int i = 0; i < NRoles; ++i) {
        QList<QAbstractButton *> &list = d->buttonLists[i];
        while (list.size()) {
            QAbstractButton *button = list.takeAt(0);
            QObjectPrivate::disconnect(button, &QAbstractButton::destroyed,
                                       d, &QDialogButtonBoxPrivate::handleButtonDestroyed);
            delete button;
        }
    }
}
 
QList<QAbstractButton *> QDialogButtonBox::buttons() const
{
    Q_D(const QDialogButtonBox);
    return d->allButtons();
}
 
QList<QAbstractButton *> QDialogButtonBoxPrivate::visibleButtons() const
{
    QList<QAbstractButton *> finalList;
    for (int i = 0; i < QDialogButtonBox::NRoles; ++i) {
        const QList<QAbstractButton *> &list = buttonLists[i];
        for (int j = 0; j < list.size(); ++j)
            finalList.append(list.at(j));
    }
    return finalList;
}
 
QList<QAbstractButton *> QDialogButtonBoxPrivate::allButtons() const
{
    return visibleButtons() << hiddenButtons.keys();
}
 
QDialogButtonBox::ButtonRole QDialogButtonBox::buttonRole(QAbstractButton *button) const
{
    Q_D(const QDialogButtonBox);
    for (int i = 0; i < NRoles; ++i) {
        const QList<QAbstractButton *> &list = d->buttonLists[i];
        for (int j = 0; j < list.size(); ++j) {
            if (list.at(j) == button)
                return ButtonRole(i);
        }
    }
    return d->hiddenButtons.value(button, InvalidRole);
}
 
void QDialogButtonBox::removeButton(QAbstractButton *button)
{
    Q_D(QDialogButtonBox);
    d->removeButton(button, QDialogButtonBoxPrivate::RemoveRule::Disconnect);
}
 
void QDialogButtonBoxPrivate::removeButton(QAbstractButton *button, RemoveRule rule)
{
    Q_Q(QDialogButtonBox);
    if (!button)
        return;
 
    // Remove it from hidden buttons
    hiddenButtons.remove(button);
 
    // Remove it from the standard button hash first and then from the roles
    standardButtonHash.remove(reinterpret_cast<QPushButton *>(button));
    for (int i = 0; i < QDialogButtonBox::NRoles; ++i)
        buttonLists[i].removeOne(button);
 
    switch (rule) {
    case RemoveRule::Disconnect:
        button->setParent(nullptr);
        QObjectPrivate::disconnect(button, &QAbstractButton::clicked,
                                   this, &QDialogButtonBoxPrivate::handleButtonClicked);
        QObjectPrivate::disconnect(button, &QAbstractButton::destroyed,
                                   this, &QDialogButtonBoxPrivate::handleButtonDestroyed);
        button->removeEventFilter(q);
        break;
    case RemoveRule::KeepConnections:
        break;
    }
}
 
void QDialogButtonBox::addButton(QAbstractButton *button, ButtonRole role)
{
    Q_D(QDialogButtonBox);
    if (Q_UNLIKELY(role <= InvalidRole || role >= NRoles)) {
        qWarning("QDialogButtonBox::addButton: Invalid ButtonRole, button not added");
        return;
    }
    removeButton(button);
    button->setParent(this);
    d->addButton(button, role);
}
 
QPushButton *QDialogButtonBox::addButton(const QString &text, ButtonRole role)
{
    Q_D(QDialogButtonBox);
    if (Q_UNLIKELY(role <= InvalidRole || role >= NRoles)) {
        qWarning("QDialogButtonBox::addButton: Invalid ButtonRole, button not added");
        return nullptr;
    }
    QPushButton *button = new QPushButton(text, this);
    d->addButton(button, role);
    return button;
}
 
QPushButton *QDialogButtonBox::addButton(StandardButton button)
{
    Q_D(QDialogButtonBox);
    return d->createButton(button);
}
 
void QDialogButtonBox::setStandardButtons(StandardButtons buttons)
{
    Q_D(QDialogButtonBox);
    // Clear out all the old standard buttons, then recreate them.
    qDeleteAll(d->standardButtonHash.keyBegin(), d->standardButtonHash.keyEnd());
    d->standardButtonHash.clear();
 
    d->createStandardButtons(buttons);
}
 
QDialogButtonBox::StandardButtons QDialogButtonBox::standardButtons() const
{
    Q_D(const QDialogButtonBox);
    StandardButtons standardButtons = NoButton;
    QHash<QPushButton *, StandardButton>::const_iterator it = d->standardButtonHash.constBegin();
    while (it != d->standardButtonHash.constEnd()) {
        standardButtons |= it.value();
        ++it;
    }
    return standardButtons;
}
 
QPushButton *QDialogButtonBox::button(StandardButton which) const
{
    Q_D(const QDialogButtonBox);
    return d->standardButtonHash.key(which);
}
 
QDialogButtonBox::StandardButton QDialogButtonBox::standardButton(QAbstractButton *button) const
{
    Q_D(const QDialogButtonBox);
    return d->standardButtonHash.value(static_cast<QPushButton *>(button));
}
 
void QDialogButtonBoxPrivate::handleButtonClicked()
{
    Q_Q(QDialogButtonBox);
    if (QAbstractButton *button = qobject_cast<QAbstractButton *>(q->sender())) {
        // Can't fetch this *after* emitting clicked, as clicked may destroy the button
        // or change its role. Now changing the role is not possible yet, but arguably
        // both clicked and accepted/rejected/etc. should be emitted "atomically"
        // depending on whatever role the button had at the time of the click.
        const QDialogButtonBox::ButtonRole buttonRole = q->buttonRole(button);
        QPointer<QDialogButtonBox> guard(q);
 
        emit q->clicked(button);
 
        if (!guard)
            return;
 
        switch (QPlatformDialogHelper::ButtonRole(buttonRole)) {
        case QPlatformDialogHelper::AcceptRole:
        case QPlatformDialogHelper::YesRole:
            emit q->accepted();
            break;
        case QPlatformDialogHelper::RejectRole:
        case QPlatformDialogHelper::NoRole:
            emit q->rejected();
            break;
        case QPlatformDialogHelper::HelpRole:
            emit q->helpRequested();
            break;
        default:
            break;
        }
    }
}
 
void QDialogButtonBoxPrivate::handleButtonDestroyed()
{
    Q_Q(QDialogButtonBox);
    if (QObject *object = q->sender())
        removeButton(reinterpret_cast<QAbstractButton *>(object), RemoveRule::KeepConnections);
}
 
bool QDialogButtonBox::eventFilter(QObject *object, QEvent *event)
{
    Q_D(QDialogButtonBox);
    if (d->byPassEventFilter)
        return false;
 
    QAbstractButton *button = qobject_cast<QAbstractButton *>(object);
    if (!button)
        return false;
 
 
    const QEvent::Type type = event->type();
    if (type == QEvent::HideToParent || type == QEvent::ShowToParent)
        return d->handleButtonShowAndHide(button, event);
 
    return false;
}
 
bool QDialogButtonBoxPrivate::handleButtonShowAndHide(QAbstractButton *button, QEvent *event)
{
    Q_Q(QDialogButtonBox);
 
    const QEvent::Type type = event->type();
 
    switch (type) {
    case QEvent::HideToParent: {
        const QDialogButtonBox::ButtonRole role = q->buttonRole(button);
        if (role != QDialogButtonBox::ButtonRole::InvalidRole) {
            removeButton(button, RemoveRule::KeepConnections);
            hiddenButtons.insert(button, role);
            layoutButtons();
        }
        break;
    }
    case QEvent::ShowToParent:
        if (hiddenButtons.contains(button)) {
            const auto role = hiddenButtons.take(button);
            addButton(button, role, LayoutRule::DoLayout, AddRule::SkipConnect);
            if (role == QDialogButtonBox::AcceptRole)
                ensureFirstAcceptIsDefault();
        }
        break;
    default: break;
    }
 
    return false;
}
 
void QDialogButtonBox::setCenterButtons(bool center)
{
    Q_D(QDialogButtonBox);
    if (d->center != center) {
        d->center = center;
        d->resetLayout();
    }
}
 
bool QDialogButtonBox::centerButtons() const
{
    Q_D(const QDialogButtonBox);
    return d->center;
}
 
void QDialogButtonBox::changeEvent(QEvent *event)
{
    typedef QHash<QPushButton *, QDialogButtonBox::StandardButton> StandardButtonHash;
 
    Q_D(QDialogButtonBox);
    switch (event->type()) {
    case QEvent::StyleChange:  // Propagate style
        if (!d->standardButtonHash.empty()) {
            QStyle *newStyle = style();
            const StandardButtonHash::iterator end = d->standardButtonHash.end();
            for (StandardButtonHash::iterator it = d->standardButtonHash.begin(); it != end; ++it)
                it.key()->setStyle(newStyle);
        }
#ifdef Q_OS_MAC
        Q_FALLTHROUGH();
    case QEvent::MacSizeChange:
#endif
        d->resetLayout();
        QWidget::changeEvent(event);
        break;
    default:
        QWidget::changeEvent(event);
        break;
    }
}
 
void QDialogButtonBoxPrivate::ensureFirstAcceptIsDefault()
{
    Q_Q(QDialogButtonBox);
    const QList<QAbstractButton *> &acceptRoleList = buttonLists[QDialogButtonBox::AcceptRole];
    QPushButton *firstAcceptButton = acceptRoleList.isEmpty()
                                   ? nullptr
                                   : qobject_cast<QPushButton *>(acceptRoleList.at(0));
 
    if (!firstAcceptButton)
        return;
 
    bool hasDefault = false;
    QWidget *dialog = nullptr;
    QWidget *p = q;
    while (p && !p->isWindow()) {
        p = p->parentWidget();
        if ((dialog = qobject_cast<QDialog *>(p)))
            break;
    }
 
    QWidget *parent = dialog ? dialog : q;
    Q_ASSERT(parent);
 
    const auto pushButtons = parent->findChildren<QPushButton *>();
    for (QPushButton *pushButton : pushButtons) {
        if (pushButton->isDefault() && pushButton != firstAcceptButton) {
            hasDefault = true;
            break;
        }
    }
    if (!hasDefault && firstAcceptButton)
        firstAcceptButton->setDefault(true);
}
 
void QDialogButtonBoxPrivate::disconnectAll()
{
    Q_Q(QDialogButtonBox);
    const auto buttons = q->findChildren<QAbstractButton *>();
    for (auto *button : buttons)
        button->disconnect(q);
}
 
bool QDialogButtonBox::event(QEvent *event)
{
    Q_D(QDialogButtonBox);
    switch (event->type()) {
    case QEvent::Show:
        d->ensureFirstAcceptIsDefault();
        break;
 
    case QEvent::LanguageChange:
        d->retranslateStrings();
        break;
 
    default: break;
    }
 
    return QWidget::event(event);
}
 
QT_END_NAMESPACE
 
#include "moc_qdialogbuttonbox.cpp"