qprogressdialog.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 "qprogressdialog.h"
 
#if QT_CONFIG(shortcut)
#  include "qshortcut.h"
#endif
#include "qpainter.h"
#include "qdrawutil.h"
#include "qlabel.h"
#include "qprogressbar.h"
#include "qapplication.h"
#include "qstyle.h"
#include "qpushbutton.h"
#include "qtimer.h"
#include "qelapsedtimer.h"
#include "qscopedvaluerollback.h"
#include <private/qdialog_p.h>
 
#include <QtCore/qpointer.h>
 
#include <limits.h>
 
using namespace std::chrono_literals;
 
QT_BEGIN_NAMESPACE
 
// If the operation is expected to take this long (as predicted by
// progress time), show the progress dialog.
static constexpr auto defaultShowTime = 4000ms;
// Wait at least this long before attempting to make a prediction.
static constexpr auto minWaitTime = 50ms;
 
class QProgressDialogPrivate : public QDialogPrivate
{
    Q_DECLARE_PUBLIC(QProgressDialog)
 
public:
    QProgressDialogPrivate() = default;
 
    void init(const QString &labelText, const QString &cancelText, int min, int max);
    void layout();
    void retranslateStrings();
    void setCancelButtonText(const QString &cancelButtonText);
    void adoptChildWidget(QWidget *c);
    void ensureSizeIsAtLeastSizeHint();
    void _q_disconnectOnClose();
 
    QLabel *label = nullptr;
    QPushButton *cancel = nullptr;
    QProgressBar *bar = nullptr;
    QTimer *forceTimer = nullptr;
#ifndef QT_NO_SHORTCUT
    QShortcut *escapeShortcut = nullptr;
#endif
    QPointer<QObject> receiverToDisconnectOnClose;
    QElapsedTimer starttime;
    QByteArray memberToDisconnectOnClose;
    std::chrono::milliseconds showTime = defaultShowTime;
    bool processingEvents = false;
    bool shownOnce = false;
    bool autoClose = true;
    bool autoReset = true;
    bool forceHide = false;
    bool cancellationFlag = false;
    bool setValueCalled = false;
    bool useDefaultCancelText = false;
};
 
void QProgressDialogPrivate::init(const QString &labelText, const QString &cancelText,
                                  int min, int max)
{
    Q_Q(QProgressDialog);
    label = new QLabel(labelText, q);
    bar = new QProgressBar(q);
    bar->setRange(min, max);
    int align = q->style()->styleHint(QStyle::SH_ProgressDialog_TextLabelAlignment, nullptr, q);
    label->setAlignment(Qt::Alignment(align));
    QObject::connect(q, SIGNAL(canceled()), q, SLOT(cancel()));
    forceTimer = new QTimer(q);
    QObject::connect(forceTimer, SIGNAL(timeout()), q, SLOT(forceShow()));
    if (useDefaultCancelText) {
        retranslateStrings();
    } else {
        q->setCancelButtonText(cancelText);
    }
    starttime.start();
    forceTimer->start(showTime);
}
 
void QProgressDialogPrivate::layout()
{
    Q_Q(QProgressDialog);
    int sp = q->style()->pixelMetric(QStyle::PM_LayoutVerticalSpacing, nullptr, q);
    int mb = q->style()->pixelMetric(QStyle::PM_LayoutBottomMargin, nullptr, q);
    int ml = qMin(q->width() / 10, q->style()->pixelMetric(QStyle::PM_LayoutLeftMargin, nullptr, q));
    int mr = qMin(q->width() / 10, q->style()->pixelMetric(QStyle::PM_LayoutRightMargin, nullptr, q));
    const bool centered =
        bool(q->style()->styleHint(QStyle::SH_ProgressDialog_CenterCancelButton, nullptr, q));
 
    int additionalSpacing = 0;
    QSize cs = cancel ? cancel->sizeHint() : QSize(0,0);
    QSize bh = bar->sizeHint();
    int cspc;
    int lh = 0;
 
    // Find spacing and sizes that fit.  It is important that a progress
    // dialog can be made very small if the user demands it so.
    for (int attempt=5; attempt--;) {
        cspc = cancel ? cs.height() + sp : 0;
        lh = qMax(0, q->height() - mb - bh.height() - sp - cspc);
 
        if (lh < q->height()/4) {
            // Getting cramped
            sp /= 2;
            mb /= 2;
            if (cancel) {
                cs.setHeight(qMax(4,cs.height()-sp-2));
            }
            bh.setHeight(qMax(4,bh.height()-sp-1));
        } else {
            break;
        }
    }
 
    if (cancel) {
        cancel->setGeometry(
            centered ? q->width()/2 - cs.width()/2 : q->width() - mr - cs.width(),
            q->height() - mb - cs.height(),
            cs.width(), cs.height());
    }
 
    if (label)
        label->setGeometry(ml, additionalSpacing, q->width() - ml - mr, lh);
    bar->setGeometry(ml, lh + sp + additionalSpacing, q->width() - ml - mr, bh.height());
}
 
void QProgressDialogPrivate::retranslateStrings()
{
    if (useDefaultCancelText)
        setCancelButtonText(QProgressDialog::tr("Cancel"));
}
 
void QProgressDialogPrivate::_q_disconnectOnClose()
{
    Q_Q(QProgressDialog);
    if (receiverToDisconnectOnClose) {
        QObject::disconnect(q, SIGNAL(canceled()), receiverToDisconnectOnClose,
                            memberToDisconnectOnClose);
        receiverToDisconnectOnClose = nullptr;
    }
    memberToDisconnectOnClose.clear();
}
 
QProgressDialog::QProgressDialog(QWidget *parent, Qt::WindowFlags f)
    : QDialog(*(new QProgressDialogPrivate), parent, f)
{
    Q_D(QProgressDialog);
    d->useDefaultCancelText = true;
    d->init(QString::fromLatin1(""), QString(), 0, 100);
}
 
QProgressDialog::QProgressDialog(const QString &labelText,
                                 const QString &cancelButtonText,
                                 int minimum, int maximum,
                                 QWidget *parent, Qt::WindowFlags f)
    : QDialog(*(new QProgressDialogPrivate), parent, f)
{
    Q_D(QProgressDialog);
    d->init(labelText, cancelButtonText, minimum, maximum);
}
 
 
QProgressDialog::~QProgressDialog()
{
}
 
void QProgressDialog::setLabel(QLabel *label)
{
    Q_D(QProgressDialog);
    if (label == d->label) {
        if (Q_UNLIKELY(label))
            qWarning("QProgressDialog::setLabel: Attempt to set the same label again");
        return;
    }
    delete d->label;
    d->label = label;
    d->adoptChildWidget(label);
}
 
 
QString QProgressDialog::labelText() const
{
    Q_D(const QProgressDialog);
    if (d->label)
        return d->label->text();
    return QString();
}
 
void QProgressDialog::setLabelText(const QString &text)
{
    Q_D(QProgressDialog);
    if (d->label) {
        d->label->setText(text);
        d->ensureSizeIsAtLeastSizeHint();
    }
}
 
 
void QProgressDialog::setCancelButton(QPushButton *cancelButton)
{
    Q_D(QProgressDialog);
    if (d->cancel == cancelButton) {
        if (Q_UNLIKELY(cancelButton))
            qWarning("QProgressDialog::setCancelButton: Attempt to set the same button again");
        return;
    }
    delete d->cancel;
    d->cancel = cancelButton;
    if (cancelButton) {
        connect(d->cancel, SIGNAL(clicked()), this, SIGNAL(canceled()));
#ifndef QT_NO_SHORTCUT
        d->escapeShortcut = new QShortcut(QKeySequence::Cancel, this, SIGNAL(canceled()));
#endif
    } else {
#ifndef QT_NO_SHORTCUT
        delete d->escapeShortcut;
        d->escapeShortcut = nullptr;
#endif
    }
    d->adoptChildWidget(cancelButton);
}
 
void QProgressDialog::setCancelButtonText(const QString &cancelButtonText)
{
    Q_D(QProgressDialog);
    d->useDefaultCancelText = false;
    d->setCancelButtonText(cancelButtonText);
}
 
void QProgressDialogPrivate::setCancelButtonText(const QString &cancelButtonText)
{
    Q_Q(QProgressDialog);
 
    if (!cancelButtonText.isNull()) {
        if (cancel) {
            cancel->setText(cancelButtonText);
        } else {
            q->setCancelButton(new QPushButton(cancelButtonText, q));
        }
    } else {
        q->setCancelButton(nullptr);
    }
    ensureSizeIsAtLeastSizeHint();
}
 
 
void QProgressDialog::setBar(QProgressBar *bar)
{
    Q_D(QProgressDialog);
    if (Q_UNLIKELY(!bar)) {
        qWarning("QProgressDialog::setBar: Cannot set a null progress bar");
        return;
    }
#ifndef QT_NO_DEBUG
    if (Q_UNLIKELY(value() > 0))
        qWarning("QProgressDialog::setBar: Cannot set a new progress bar "
                  "while the old one is active");
#endif
    if (Q_UNLIKELY(bar == d->bar)) {
        qWarning("QProgressDialog::setBar: Attempt to set the same progress bar again");
        return;
    }
    delete d->bar;
    d->bar = bar;
    d->adoptChildWidget(bar);
}
 
void QProgressDialogPrivate::adoptChildWidget(QWidget *c)
{
    Q_Q(QProgressDialog);
 
    if (c) {
        if (c->parentWidget() == q)
            c->hide(); // until after ensureSizeIsAtLeastSizeHint()
        else
            c->setParent(q, { });
    }
    ensureSizeIsAtLeastSizeHint();
    //The layout should be updated again to prevent layout errors when the new 'widget' is replaced
    layout();
    if (c)
        c->show();
}
 
void QProgressDialogPrivate::ensureSizeIsAtLeastSizeHint()
{
    Q_Q(QProgressDialog);
 
    QSize size = q->sizeHint();
    if (q->isVisible())
        size = size.expandedTo(q->size());
    q->resize(size);
}
 
 
bool QProgressDialog::wasCanceled() const
{
    Q_D(const QProgressDialog);
    return d->cancellationFlag;
}
 
 
int QProgressDialog::maximum() const
{
    Q_D(const QProgressDialog);
    return d->bar->maximum();
}
 
void QProgressDialog::setMaximum(int maximum)
{
    Q_D(QProgressDialog);
    d->bar->setMaximum(maximum);
}
 
int QProgressDialog::minimum() const
{
    Q_D(const QProgressDialog);
    return d->bar->minimum();
}
 
void QProgressDialog::setMinimum(int minimum)
{
    Q_D(QProgressDialog);
    d->bar->setMinimum(minimum);
}
 
void QProgressDialog::setRange(int minimum, int maximum)
{
    Q_D(QProgressDialog);
    d->bar->setRange(minimum, maximum);
}
 
 
void QProgressDialog::reset()
{
    Q_D(QProgressDialog);
    if (d->autoClose || d->forceHide)
        hide();
    d->bar->reset();
    d->cancellationFlag = false;
    d->shownOnce = false;
    d->setValueCalled = false;
    d->forceTimer->stop();
 
    /*
        I wish we could disconnect the user slot provided to open() here but
        unfortunately reset() is usually called before the slot has been invoked.
        (reset() is itself invoked when canceled() is emitted.)
    */
    if (d->receiverToDisconnectOnClose)
        QMetaObject::invokeMethod(this, "_q_disconnectOnClose", Qt::QueuedConnection);
}
 
void QProgressDialog::cancel()
{
    Q_D(QProgressDialog);
    d->forceHide = true;
    reset();
    d->forceHide = false;
    d->cancellationFlag = true;
}
 
 
int QProgressDialog::value() const
{
    Q_D(const QProgressDialog);
    return d->bar->value();
}
 
void QProgressDialog::setValue(int progress)
{
    Q_D(QProgressDialog);
    if (d->setValueCalled && progress == d->bar->value())
        return;
 
    d->bar->setValue(progress);
 
    if (d->shownOnce) {
        if (isModal() && !d->processingEvents) {
            const QScopedValueRollback guard(d->processingEvents, true);
            QCoreApplication::processEvents();
        }
    } else {
        if ((!d->setValueCalled && progress == 0 /* for compat with Qt < 5.4 */) || progress == minimum()) {
            d->starttime.start();
            d->forceTimer->start(d->showTime);
            d->setValueCalled = true;
            return;
        } else {
            d->setValueCalled = true;
            bool need_show = false;
            using namespace std::chrono;
            nanoseconds elapsed = d->starttime.durationElapsed();
            if (elapsed >= d->showTime) {
                need_show = true;
            } else {
                if (elapsed > minWaitTime) {
                    const int totalSteps = maximum() - minimum();
                    const int myprogress = std::max(progress - minimum(), 1);
                    const int remainingSteps = totalSteps - myprogress;
                    nanoseconds estimate;
                    if (remainingSteps >= INT_MAX / elapsed.count())
                        estimate = (remainingSteps / myprogress) * elapsed;
                    else
                        estimate = (elapsed * remainingSteps) / myprogress;
                    need_show = estimate >= d->showTime;
                }
            }
            if (need_show) {
                d->ensureSizeIsAtLeastSizeHint();
                show();
                d->shownOnce = true;
            }
        }
    }
 
    if (progress == d->bar->maximum() && d->autoReset)
        reset();
}
 
QSize QProgressDialog::sizeHint() const
{
    Q_D(const QProgressDialog);
    QSize labelSize = d->label ? d->label->sizeHint() : QSize(0, 0);
    QSize barSize = d->bar->sizeHint();
    int marginBottom = style()->pixelMetric(QStyle::PM_LayoutBottomMargin, 0, this);
    int spacing = style()->pixelMetric(QStyle::PM_LayoutVerticalSpacing, 0, this);
    int marginLeft = style()->pixelMetric(QStyle::PM_LayoutLeftMargin, 0, this);
    int marginRight = style()->pixelMetric(QStyle::PM_LayoutRightMargin, 0, this);
 
    int height = marginBottom * 2 + barSize.height() + labelSize.height() + spacing;
    if (d->cancel)
        height += d->cancel->sizeHint().height() + spacing;
    return QSize(qMax(200, labelSize.width() + marginLeft + marginRight), height);
}
 
void QProgressDialog::resizeEvent(QResizeEvent *)
{
    Q_D(QProgressDialog);
    d->layout();
}
 
void QProgressDialog::changeEvent(QEvent *ev)
{
    Q_D(QProgressDialog);
    if (ev->type() == QEvent::StyleChange) {
        d->layout();
    } else if (ev->type() == QEvent::LanguageChange) {
        d->retranslateStrings();
    }
    QDialog::changeEvent(ev);
}
 
void QProgressDialog::setMinimumDuration(int ms)
{
    Q_D(QProgressDialog);
    std::chrono::milliseconds msecs{ms};
    d->showTime = msecs;
    if (d->bar->value() == d->bar->minimum()) {
        d->forceTimer->stop();
        d->forceTimer->start(msecs);
    }
}
 
int QProgressDialog::minimumDuration() const
{
    Q_D(const QProgressDialog);
    return int(d->showTime.count());
}
 
 
void QProgressDialog::closeEvent(QCloseEvent *e)
{
    emit canceled();
    QDialog::closeEvent(e);
}
 
void QProgressDialog::setAutoReset(bool b)
{
    Q_D(QProgressDialog);
    d->autoReset = b;
}
 
bool QProgressDialog::autoReset() const
{
    Q_D(const QProgressDialog);
    return d->autoReset;
}
 
void QProgressDialog::setAutoClose(bool close)
{
    Q_D(QProgressDialog);
    d->autoClose = close;
}
 
bool QProgressDialog::autoClose() const
{
    Q_D(const QProgressDialog);
    return d->autoClose;
}
 
void QProgressDialog::showEvent(QShowEvent *e)
{
    Q_D(QProgressDialog);
    QDialog::showEvent(e);
    d->ensureSizeIsAtLeastSizeHint();
    d->forceTimer->stop();
}
 
void QProgressDialog::forceShow()
{
    Q_D(QProgressDialog);
    d->forceTimer->stop();
    if (d->shownOnce || d->cancellationFlag)
        return;
 
    show();
    d->shownOnce = true;
}
 
void QProgressDialog::open(QObject *receiver, const char *member)
{
    Q_D(QProgressDialog);
    connect(this, SIGNAL(canceled()), receiver, member);
    d->receiverToDisconnectOnClose = receiver;
    d->memberToDisconnectOnClose = member;
    QDialog::open();
}
 
QT_END_NAMESPACE
 
#include "moc_qprogressdialog.cpp"