qpushbutton.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 "qapplication.h"
#include "qbitmap.h"
#if QT_CONFIG(dialog)
#include <private/qdialog_p.h>
#endif
#include "qdrawutil.h"
#include "qevent.h"
#include "qfontmetrics.h"
#include "qstylepainter.h"
#include "qpixmap.h"
#include "qpointer.h"
#include "qpushbutton.h"
#include "qstyle.h"
#include "qstyleoption.h"
#if QT_CONFIG(toolbar)
#include "qtoolbar.h"
#endif
#include "qdebug.h"
#include "qlayoutitem.h"
#if QT_CONFIG(dialogbuttonbox)
#include "qdialogbuttonbox.h"
#endif
 
#if QT_CONFIG(accessibility)
#include "qaccessible.h"
#endif
 
#if QT_CONFIG(menu)
#include "qmenu.h"
#include "private/qmenu_p.h"
#endif
#include "private/qpushbutton_p.h"
 
QT_BEGIN_NAMESPACE
 
 
QPushButton::QPushButton(QWidget *parent)
    : QAbstractButton(*new QPushButtonPrivate, parent)
{
    Q_D(QPushButton);
    d->init();
}
 
QPushButton::QPushButton(const QString &text, QWidget *parent)
    : QPushButton(parent)
{
    setText(text);
}
 
 
QPushButton::QPushButton(const QIcon& icon, const QString &text, QWidget *parent)
    : QPushButton(*new QPushButtonPrivate, parent)
{
    setText(text);
    setIcon(icon);
}
 
QPushButton::QPushButton(QPushButtonPrivate &dd, QWidget *parent)
    : QAbstractButton(dd, parent)
{
    Q_D(QPushButton);
    d->init();
}
 
QPushButton::~QPushButton()
{
}
 
#if QT_CONFIG(dialog)
QDialog *QPushButtonPrivate::dialogParent() const
{
    Q_Q(const QPushButton);
    const QWidget *p = q;
    while (p && !p->isWindow()) {
        p = p->parentWidget();
        if (const QDialog *dialog = qobject_cast<const QDialog *>(p))
            return const_cast<QDialog *>(dialog);
    }
    return nullptr;
}
#endif
 
void QPushButton::initStyleOption(QStyleOptionButton *option) const
{
    if (!option)
        return;
 
    Q_D(const QPushButton);
    option->initFrom(this);
    option->features = QStyleOptionButton::None;
    if (d->flat)
        option->features |= QStyleOptionButton::Flat;
#if QT_CONFIG(menu)
    if (d->menu)
        option->features |= QStyleOptionButton::HasMenu;
#endif
    if (autoDefault())
        option->features |= QStyleOptionButton::AutoDefaultButton;
    if (d->defaultButton)
        option->features |= QStyleOptionButton::DefaultButton;
    if (d->down || d->menuOpen)
        option->state |= QStyle::State_Sunken;
    if (d->checked)
        option->state |= QStyle::State_On;
    if (!d->flat && !d->down)
        option->state |= QStyle::State_Raised;
    if (underMouse() && hasMouseTracking())
        option->state.setFlag(QStyle::State_MouseOver, d->hovering);
    option->text = d->text;
    option->icon = d->icon;
    option->iconSize = iconSize();
}
 
void QPushButton::setAutoDefault(bool enable)
{
    Q_D(QPushButton);
    uint state = enable ? QPushButtonPrivate::On : QPushButtonPrivate::Off;
    if (d->autoDefault != QPushButtonPrivate::Auto && d->autoDefault == state)
        return;
    d->autoDefault = state;
    d->sizeHint = QSize();
    update();
    updateGeometry();
}
 
bool QPushButton::autoDefault() const
{
    Q_D(const QPushButton);
    if (d->autoDefault == QPushButtonPrivate::Auto)
        return ( d->dialogParent() != nullptr );
    return d->autoDefault;
}
 
void QPushButton::setDefault(bool enable)
{
    Q_D(QPushButton);
    if (d->defaultButton == enable)
        return;
    d->defaultButton = enable;
#if QT_CONFIG(dialog)
    if (d->defaultButton) {
        if (QDialog *dlg = d->dialogParent())
            dlg->d_func()->setMainDefault(this);
    }
#endif
    update();
#if QT_CONFIG(accessibility)
    QAccessible::State s;
    s.defaultButton = true;
    QAccessibleStateChangeEvent event(this, s);
    QAccessible::updateAccessibility(&event);
#endif
}
 
bool QPushButton::isDefault() const
{
    Q_D(const QPushButton);
    return d->defaultButton;
}
 
QSize QPushButton::sizeHint() const
{
    Q_D(const QPushButton);
    if (d->sizeHint.isValid() && d->lastAutoDefault == autoDefault())
        return d->sizeHint;
    d->lastAutoDefault = autoDefault();
    ensurePolished();
 
    int w = 0, h = 0;
 
    QStyleOptionButton opt;
    initStyleOption(&opt);
 
    // calculate contents size...
#if !defined(QT_NO_ICON) && QT_CONFIG(dialogbuttonbox)
    bool showButtonBoxIcons = qobject_cast<QDialogButtonBox*>(parentWidget())
                          && style()->styleHint(QStyle::SH_DialogButtonBox_ButtonsHaveIcons);
 
    if (!icon().isNull() || showButtonBoxIcons) {
        int ih = opt.iconSize.height();
        int iw = opt.iconSize.width() + 4;
        w += iw;
        h = qMax(h, ih);
    }
#endif
    QString s(text());
    bool empty = s.isEmpty();
    if (empty)
        s = QStringLiteral("XXXX");
    QFontMetrics fm = fontMetrics();
    QSize sz = fm.size(Qt::TextShowMnemonic, s);
    if (!empty || !w)
        w += sz.width();
    if (!empty || !h)
        h = qMax(h, sz.height());
    opt.rect.setSize(QSize(w, h)); // PM_MenuButtonIndicator depends on the height
#if QT_CONFIG(menu)
    if (menu())
        w += style()->pixelMetric(QStyle::PM_MenuButtonIndicator, &opt, this);
#endif
    d->sizeHint = style()->sizeFromContents(QStyle::CT_PushButton, &opt, QSize(w, h), this);
    return d->sizeHint;
}
 
QSize QPushButton::minimumSizeHint() const
{
    return sizeHint();
}
 
 
void QPushButton::paintEvent(QPaintEvent *)
{
    QStylePainter p(this);
    QStyleOptionButton option;
    initStyleOption(&option);
    p.drawControl(QStyle::CE_PushButton, option);
}
 
 
void QPushButton::keyPressEvent(QKeyEvent *e)
{
    Q_D(QPushButton);
    switch (e->key()) {
    case Qt::Key_Enter:
    case Qt::Key_Return:
        if (autoDefault() || d->defaultButton) {
            click();
            break;
        }
        Q_FALLTHROUGH();
    default:
        QAbstractButton::keyPressEvent(e);
    }
}
 
void QPushButton::focusInEvent(QFocusEvent *e)
{
    Q_D(QPushButton);
    if (e->reason() != Qt::PopupFocusReason && autoDefault() && !d->defaultButton) {
        d->defaultButton = true;
#if QT_CONFIG(dialog)
        QDialog *dlg = qobject_cast<QDialog*>(window());
        if (dlg)
            dlg->d_func()->setDefault(this);
#endif
    }
    QAbstractButton::focusInEvent(e);
}
 
void QPushButton::focusOutEvent(QFocusEvent *e)
{
    Q_D(QPushButton);
    if (e->reason() != Qt::PopupFocusReason && autoDefault() && d->defaultButton) {
#if QT_CONFIG(dialog)
        QDialog *dlg = qobject_cast<QDialog*>(window());
        if (dlg)
            dlg->d_func()->setDefault(nullptr);
        else
            d->defaultButton = false;
#endif
    }
 
    QAbstractButton::focusOutEvent(e);
#if QT_CONFIG(menu)
    if (d->menu && d->menu->isVisible())        // restore pressed status
        setDown(true);
#endif
}
 
void QPushButton::mouseMoveEvent(QMouseEvent *e)
{
    Q_D(QPushButton);
 
    if (testAttribute(Qt::WA_Hover)) {
        bool hit = false;
        if (underMouse())
            hit = hitButton(e->position().toPoint());
 
        if (hit != d->hovering) {
            update(rect());
            d->hovering = hit;
        }
    }
 
    QAbstractButton::mouseMoveEvent(e);
}
 
bool QPushButton::hitButton(const QPoint &pos) const
{
    QStyleOptionButton option;
    initStyleOption(&option);
    const QRect bevel = style()->subElementRect(QStyle::SE_PushButtonBevel, &option, this);
    return bevel.contains(pos);
}
 
#if QT_CONFIG(menu)
void QPushButton::setMenu(QMenu* menu)
{
    Q_D(QPushButton);
    if (menu == d->menu)
        return;
 
    if (menu && !d->menu) {
        connect(this, SIGNAL(pressed()), this, SLOT(_q_popupPressed()), Qt::UniqueConnection);
    }
    if (d->menu)
        removeAction(d->menu->menuAction());
    d->menu = menu;
    if (d->menu)
        addAction(d->menu->menuAction());
 
    d->resetLayoutItemMargins();
    d->sizeHint = QSize();
    update();
    updateGeometry();
}
 
QMenu* QPushButton::menu() const
{
    Q_D(const QPushButton);
    return d->menu;
}
 
void QPushButton::showMenu()
{
    Q_D(QPushButton);
    if (!d || !d->menu)
        return;
    setDown(true);
    d->_q_popupPressed();
}
 
void QPushButtonPrivate::_q_popupPressed()
{
    Q_Q(QPushButton);
    if (!down || !menu)
        return;
 
    menu->setNoReplayFor(q);
 
    QPoint menuPos = adjustedMenuPosition();
 
    QMenuPrivate::get(menu)->causedPopup.widget = q;
 
    //Because of a delay in menu effects, we must keep track of the
    //menu visibility to avoid flicker on button release
    menuOpen = true;
    QObject::connect(menu, &QMenu::aboutToHide,
                     q, [q]{ q->setDown(false); }, Qt::SingleShotConnection);
    menu->popup(menuPos);
}
 
QPoint QPushButtonPrivate::adjustedMenuPosition()
{
    Q_Q(QPushButton);
 
    bool horizontal = true;
#if QT_CONFIG(toolbar)
    QToolBar *tb = qobject_cast<QToolBar*>(parent);
    if (tb && tb->orientation() == Qt::Vertical)
        horizontal = false;
#endif
 
    QWidgetItem item(q);
    QRect rect = item.geometry();
    rect.setRect(rect.x() - q->x(), rect.y() - q->y(), rect.width(), rect.height());
 
    QSize menuSize = menu->sizeHint();
    QPoint globalPos = q->mapToGlobal(rect.topLeft());
    int x = globalPos.x();
    int y = globalPos.y();
    const QRect availableGeometry = QWidgetPrivate::availableScreenGeometry(q, q->mapToGlobal(rect.center()));
    if (horizontal) {
        if (globalPos.y() + rect.height() + menuSize.height() <= availableGeometry.bottom()) {
            y += rect.height();
        } else if (globalPos.y() - menuSize.height() >= availableGeometry.y()) {
            y -= menuSize.height();
        }
        if (q->layoutDirection() == Qt::RightToLeft)
            x += rect.width() - menuSize.width();
    } else {
        if (globalPos.x() + rect.width() + menu->sizeHint().width() <= availableGeometry.right()) {
            x += rect.width();
        } else if (globalPos.x() - menuSize.width() >= availableGeometry.x()) {
            x -= menuSize.width();
        }
    }
 
    return QPoint(x,y);
}
 
#endif // QT_CONFIG(menu)
 
void QPushButtonPrivate::init()
{
    Q_Q(QPushButton);
    q->setAttribute(Qt::WA_MacShowFocusRect);
    resetLayoutItemMargins();
}
 
void QPushButtonPrivate::resetLayoutItemMargins()
{
    Q_Q(QPushButton);
    QStyleOptionButton opt;
    q->initStyleOption(&opt);
    setLayoutItemMargins(QStyle::SE_PushButtonLayoutItem, &opt);
}
 
void QPushButton::setFlat(bool flat)
{
    Q_D(QPushButton);
    if (d->flat == flat)
        return;
    d->flat = flat;
    d->resetLayoutItemMargins();
    d->sizeHint = QSize();
    update();
    updateGeometry();
}
 
bool QPushButton::isFlat() const
{
    Q_D(const QPushButton);
    return d->flat;
}
 
bool QPushButton::event(QEvent *e)
{
    Q_D(QPushButton);
    if (e->type() == QEvent::ParentChange) {
#if QT_CONFIG(dialog)
        if (QDialog *dialog = d->dialogParent()) {
            if (d->defaultButton)
                dialog->d_func()->setMainDefault(this);
        }
#endif
    } else if (e->type() == QEvent::StyleChange
#ifdef Q_OS_MAC
               || e->type() == QEvent::MacSizeChange
#endif
               ) {
        d->resetLayoutItemMargins();
        updateGeometry();
    } else if (e->type() == QEvent::PolishRequest) {
        updateGeometry();
    }
    return QAbstractButton::event(e);
}
 
QT_END_NAMESPACE
 
#include "moc_qpushbutton.cpp"