qstatusbar.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 "qstatusbar.h"
 
#include "qlist.h"
#include "qdebug.h"
#include "qevent.h"
#include "qlayout.h"
#include "qpainter.h"
#include "qtimer.h"
#include "qstyle.h"
#include "qstyleoption.h"
#if QT_CONFIG(sizegrip)
#include "qsizegrip.h"
#endif
#if QT_CONFIG(mainwindow)
#include "qmainwindow.h"
#endif
 
#if QT_CONFIG(accessibility)
#include "qaccessible.h"
#endif
 
#include <private/qlayoutengine_p.h>
#include <private/qwidget_p.h>
 
QT_BEGIN_NAMESPACE
 
class QStatusBarPrivate : public QWidgetPrivate
{
    Q_DECLARE_PUBLIC(QStatusBar)
public:
    QStatusBarPrivate() {}
 
    enum ItemCategory
    {
        Normal,
        Permanent
    };
 
    struct SBItem {
        QWidget *widget = nullptr;
        int stretch = 0;
        ItemCategory category = Normal;
        bool isPermanent() const { return category == Permanent; }
    };
 
    QList<SBItem> items;
    QString tempItem;
 
    QBoxLayout *box;
    QTimer *timer;
 
#if QT_CONFIG(sizegrip)
    QSizeGrip *resizer;
    bool showSizeGrip;
#endif
 
    int savedStrut;
 
    int indexToLastNonPermanentWidget() const
    {
        int i = items.size() - 1;
        for (; i >= 0; --i) {
            const SBItem &item = items.at(i);
            if (!item.isPermanent())
                break;
        }
        return i;
    }
 
#if QT_CONFIG(sizegrip)
    void tryToShowSizeGrip()
    {
        if (!showSizeGrip)
            return;
        showSizeGrip = false;
        if (!resizer || resizer->isVisible())
            return;
        resizer->setAttribute(Qt::WA_WState_ExplicitShowHide, false);
        QMetaObject::invokeMethod(resizer, "_q_showIfNotHidden", Qt::DirectConnection);
        resizer->setAttribute(Qt::WA_WState_ExplicitShowHide, false);
    }
#endif
 
    QRect messageRect() const;
};
 
 
QRect QStatusBarPrivate::messageRect() const
{
    Q_Q(const QStatusBar);
    const bool rtl = q->layoutDirection() == Qt::RightToLeft;
 
    int left = 6;
    int right = q->width() - 12;
 
#if QT_CONFIG(sizegrip)
    if (resizer && resizer->isVisible()) {
        if (rtl)
            left = resizer->x() + resizer->width();
        else
            right = resizer->x();
    }
#endif
 
    for (const auto &item : items) {
        if (item.isPermanent() && item.widget->isVisible()) {
            if (rtl)
                left = qMax(left, item.widget->x() + item.widget->width() + 2);
            else
                right = qMin(right, item.widget->x() - 2);
            break;
        }
    }
    return QRect(left, 0, right-left, q->height());
}
 
 
QStatusBar::QStatusBar(QWidget * parent)
    : QWidget(*new QStatusBarPrivate, parent, { })
{
    Q_D(QStatusBar);
    d->box = nullptr;
    d->timer = nullptr;
 
#if QT_CONFIG(sizegrip)
    d->resizer = nullptr;
    setSizeGripEnabled(true); // causes reformat()
#else
    reformat();
#endif
}
 
QStatusBar::~QStatusBar()
{
}
 
 
void QStatusBar::addWidget(QWidget * widget, int stretch)
{
    if (!widget)
        return;
    insertWidget(d_func()->indexToLastNonPermanentWidget() + 1, widget, stretch);
}
 
int QStatusBar::insertWidget(int index, QWidget *widget, int stretch)
{
    if (!widget)
        return -1;
 
    Q_D(QStatusBar);
    QStatusBarPrivate::SBItem item{widget, stretch, QStatusBarPrivate::Normal};
 
    int idx = d->indexToLastNonPermanentWidget();
    if (Q_UNLIKELY(index < 0 || index > d->items.size() || (idx >= 0 && index > idx + 1))) {
        qWarning("QStatusBar::insertWidget: Index out of range (%d), appending widget", index);
        index = idx + 1;
    }
    d->items.insert(index, item);
 
    if (!d->tempItem.isEmpty())
        widget->hide();
 
    reformat();
    if (!widget->isHidden() || !widget->testAttribute(Qt::WA_WState_ExplicitShowHide))
        widget->show();
 
    return index;
}
 
void QStatusBar::addPermanentWidget(QWidget * widget, int stretch)
{
    if (!widget)
        return;
    insertPermanentWidget(d_func()->items.size(), widget, stretch);
}
 
int QStatusBar::insertPermanentWidget(int index, QWidget *widget, int stretch)
{
    if (!widget)
        return -1;
 
    Q_D(QStatusBar);
    QStatusBarPrivate::SBItem item{widget, stretch, QStatusBarPrivate::Permanent};
 
    int idx = d->indexToLastNonPermanentWidget();
    if (Q_UNLIKELY(index < 0 || index > d->items.size() || (idx >= 0 && index <= idx))) {
        qWarning("QStatusBar::insertPermanentWidget: Index out of range (%d), appending widget", index);
        index = d->items.size();
    }
    d->items.insert(index, item);
 
    reformat();
    if (!widget->isHidden() || !widget->testAttribute(Qt::WA_WState_ExplicitShowHide))
        widget->show();
 
    return index;
}
 
void QStatusBar::removeWidget(QWidget *widget)
{
    if (!widget)
        return;
 
    Q_D(QStatusBar);
    if (d->items.removeIf([widget](const auto &item) { return item.widget == widget; })) {
        widget->hide();
        reformat();
    }
#if defined(QT_DEBUG)
    else
        qDebug("QStatusBar::removeWidget(): Widget not found.");
#endif
}
 
bool QStatusBar::isSizeGripEnabled() const
{
#if !QT_CONFIG(sizegrip)
    return false;
#else
    Q_D(const QStatusBar);
    return !!d->resizer;
#endif
}
 
void QStatusBar::setSizeGripEnabled(bool enabled)
{
#if !QT_CONFIG(sizegrip)
    Q_UNUSED(enabled);
#else
    Q_D(QStatusBar);
    if (!enabled != !d->resizer) {
        if (enabled) {
            d->resizer = new QSizeGrip(this);
            d->resizer->hide();
            d->resizer->installEventFilter(this);
            d->showSizeGrip = true;
        } else {
            delete d->resizer;
            d->resizer = nullptr;
            d->showSizeGrip = false;
        }
        reformat();
        if (d->resizer && isVisible())
            d->tryToShowSizeGrip();
    }
#endif
}
 
 
void QStatusBar::reformat()
{
    Q_D(QStatusBar);
    if (d->box)
        delete d->box;
 
    QBoxLayout *vbox;
#if QT_CONFIG(sizegrip)
    if (d->resizer) {
        d->box = new QHBoxLayout(this);
        d->box->setContentsMargins(QMargins());
        vbox = new QVBoxLayout;
        d->box->addLayout(vbox);
    } else
#endif
    {
        vbox = d->box = new QVBoxLayout(this);
        d->box->setContentsMargins(QMargins());
    }
    vbox->addSpacing(3);
    QBoxLayout* l = new QHBoxLayout;
    vbox->addLayout(l);
    l->addSpacing(2);
    l->setSpacing(6);
 
    int maxH = fontMetrics().height();
 
    qsizetype i;
    for (i = 0; i < d->items.size(); ++i) {
        const auto &item = d->items.at(i);
        if (item.isPermanent())
            break;
        l->addWidget(item.widget, item.stretch);
        int itemH = qMin(qSmartMinSize(item.widget).height(), item.widget->maximumHeight());
        maxH = qMax(maxH, itemH);
    }
 
    l->addStretch(0);
 
    for (; i < d->items.size(); ++i) {
        const auto &item = d->items.at(i);
        l->addWidget(item.widget, item.stretch);
        int itemH = qMin(qSmartMinSize(item.widget).height(), item.widget->maximumHeight());
        maxH = qMax(maxH, itemH);
    }
#if QT_CONFIG(sizegrip)
    if (d->resizer) {
        maxH = qMax(maxH, d->resizer->sizeHint().height());
        d->box->addSpacing(1);
        d->box->addWidget(d->resizer, 0, Qt::AlignBottom);
    }
#endif
    l->addStrut(maxH);
    d->savedStrut = maxH;
    vbox->addSpacing(2);
    d->box->activate();
    update();
}
 
void QStatusBar::showMessage(const QString &message, int timeout)
{
    Q_D(QStatusBar);
 
    if (timeout > 0) {
        if (!d->timer) {
            d->timer = new QTimer(this);
            connect(d->timer, SIGNAL(timeout()), this, SLOT(clearMessage()));
        }
        d->timer->start(timeout);
    } else if (d->timer) {
        delete d->timer;
        d->timer = nullptr;
    }
    if (d->tempItem == message)
        return;
    d->tempItem = message;
 
    hideOrShow();
}
 
void QStatusBar::clearMessage()
{
    Q_D(QStatusBar);
    if (d->tempItem.isEmpty())
        return;
    if (d->timer) {
        qDeleteInEventHandler(d->timer);
        d->timer = nullptr;
    }
    d->tempItem.clear();
    hideOrShow();
}
 
QString QStatusBar::currentMessage() const
{
    Q_D(const QStatusBar);
    return d->tempItem;
}
 
void QStatusBar::hideOrShow()
{
    Q_D(QStatusBar);
    bool haveMessage = !d->tempItem.isEmpty();
 
    for (const auto &item : std::as_const(d->items)) {
        if (item.isPermanent())
            break;
        if (haveMessage && item.widget->isVisible()) {
            item.widget->hide();
            item.widget->setAttribute(Qt::WA_WState_ExplicitShowHide, false);
        } else if (!haveMessage && !item.widget->testAttribute(Qt::WA_WState_ExplicitShowHide)) {
            item.widget->show();
        }
    }
 
    emit messageChanged(d->tempItem);
 
#if QT_CONFIG(accessibility)
    if (QAccessible::isActive()) {
        QAccessibleEvent event(this, QAccessible::NameChanged);
        QAccessible::updateAccessibility(&event);
    }
#endif
 
    update(d->messageRect());
}
 
void QStatusBar::showEvent(QShowEvent *)
{
#if QT_CONFIG(sizegrip)
    Q_D(QStatusBar);
    if (d->resizer && d->showSizeGrip)
        d->tryToShowSizeGrip();
#endif
}
 
void QStatusBar::paintEvent(QPaintEvent *event)
{
    Q_D(QStatusBar);
    bool haveMessage = !d->tempItem.isEmpty();
 
    QPainter p(this);
    QStyleOption opt;
    opt.initFrom(this);
    style()->drawPrimitive(QStyle::PE_PanelStatusBar, &opt, &p, this);
 
    for (const auto &item : std::as_const(d->items)) {
        if (item.widget->isVisible() && (!haveMessage || item.isPermanent())) {
            QRect ir = item.widget->geometry().adjusted(-2, -1, 2, 1);
            if (event->rect().intersects(ir)) {
                QStyleOption opt(0);
                opt.rect = ir;
                opt.palette = palette();
                opt.state = QStyle::State_None;
                style()->drawPrimitive(QStyle::PE_FrameStatusBarItem, &opt, &p, item.widget);
            }
        }
    }
    if (haveMessage) {
        p.setPen(palette().windowText().color());
        p.drawText(d->messageRect(), Qt::AlignLeading | Qt::AlignVCenter | Qt::TextSingleLine, d->tempItem);
    }
}
 
void QStatusBar::resizeEvent(QResizeEvent * e)
{
    QWidget::resizeEvent(e);
}
 
bool QStatusBar::event(QEvent *e)
{
    Q_D(QStatusBar);
 
    switch (e->type()) {
    case QEvent::LayoutRequest: {
        // Calculate new strut height and call reformat() if it has changed
        int maxH = fontMetrics().height();
 
        for (const auto &item : std::as_const(d->items)) {
            const int itemH = qMin(qSmartMinSize(item.widget).height(), item.widget->maximumHeight());
            maxH = qMax(maxH, itemH);
        }
 
#if QT_CONFIG(sizegrip)
        if (d->resizer)
            maxH = qMax(maxH, d->resizer->sizeHint().height());
#endif
 
        if (maxH != d->savedStrut)
            reformat();
        else
            update();
        break;
    }
    case QEvent::ChildRemoved:
        for (int i = 0; i < d->items.size(); ++i) {
            const auto &item = d->items.at(i);
            if (item.widget == static_cast<QChildEvent *>(e)->child())
                d->items.removeAt(i);
        }
        break;
    default:
        break;
    }
 
    return QWidget::event(e);
}
 
QT_END_NAMESPACE
 
#include "moc_qstatusbar.cpp"