mirror of
https://github.com/crystalidea/qt6windows7.git
synced 2025-03-15 03:29:59 +08:00
705 lines
23 KiB
C++
705 lines
23 KiB
C++
// 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 "qfuturewatcher.h"
|
|
#include "qfuturewatcher_p.h"
|
|
|
|
#include <QtCore/qcoreevent.h>
|
|
#include <QtCore/qcoreapplication.h>
|
|
#include <QtCore/qmetaobject.h>
|
|
#include <QtCore/qthread.h>
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
/*! \class QFutureWatcher
|
|
\reentrant
|
|
\since 4.4
|
|
|
|
\inmodule QtCore
|
|
\ingroup thread
|
|
|
|
\brief The QFutureWatcher class allows monitoring a QFuture using signals
|
|
and slots.
|
|
|
|
QFutureWatcher provides information and notifications about a QFuture. Use
|
|
the setFuture() function to start watching a particular QFuture. The
|
|
future() function returns the future set with setFuture().
|
|
|
|
For convenience, several of QFuture's functions are also available in
|
|
QFutureWatcher: progressValue(), progressMinimum(), progressMaximum(),
|
|
progressText(), isStarted(), isFinished(), isRunning(), isCanceled(),
|
|
isSuspending(), isSuspended(), waitForFinished(), result(), and resultAt().
|
|
The cancel(), setSuspended(), suspend(), resume(), and toggleSuspended() functions
|
|
are slots in QFutureWatcher.
|
|
|
|
Status changes are reported via the started(), finished(), canceled(),
|
|
suspending(), suspended(), resumed(), resultReadyAt(), and resultsReadyAt()
|
|
signals. Progress information is provided from the progressRangeChanged(),
|
|
void progressValueChanged(), and progressTextChanged() signals.
|
|
|
|
Throttling control is provided by the setPendingResultsLimit() function.
|
|
When the number of pending resultReadyAt() or resultsReadyAt() signals
|
|
exceeds the limit, the computation represented by the future will be
|
|
throttled automatically. The computation will resume once the number of
|
|
pending signals drops below the limit.
|
|
|
|
Example: Starting a computation and getting a slot callback when it's
|
|
finished:
|
|
|
|
\snippet code/src_corelib_thread_qfuturewatcher.cpp 0
|
|
|
|
Be aware that not all running asynchronous computations can be canceled or
|
|
suspended. For example, the future returned by QtConcurrent::run() cannot be
|
|
canceled; but the future returned by QtConcurrent::mappedReduced() can.
|
|
|
|
QFutureWatcher<void> is specialized to not contain any of the result
|
|
fetching functions. Any QFuture<T> can be watched by a
|
|
QFutureWatcher<void> as well. This is useful if only status or progress
|
|
information is needed; not the actual result data.
|
|
|
|
\sa QFuture, {Qt Concurrent}
|
|
*/
|
|
|
|
/*! \fn template <typename T> QFutureWatcher<T>::QFutureWatcher(QObject *parent)
|
|
|
|
Constructs a new QFutureWatcher with the given \a parent. Until a future is
|
|
set with setFuture(), the functions isStarted(), isCanceled(), and
|
|
isFinished() return \c true.
|
|
*/
|
|
QFutureWatcherBase::QFutureWatcherBase(QObject *parent)
|
|
:QObject(*new QFutureWatcherBasePrivate, parent)
|
|
{ }
|
|
|
|
/*! \fn template <typename T> QFutureWatcher<T>::~QFutureWatcher()
|
|
|
|
Destroys the QFutureWatcher.
|
|
*/
|
|
|
|
/*! \fn template <typename T> void QFutureWatcher<T>::cancel()
|
|
|
|
Cancels the asynchronous computation represented by the future(). Note that
|
|
the cancellation is asynchronous. Use waitForFinished() after calling
|
|
cancel() when you need synchronous cancellation.
|
|
|
|
Currently available results may still be accessed on a canceled QFuture,
|
|
but new results will \e not become available after calling this function.
|
|
Also, this QFutureWatcher will not deliver progress and result ready
|
|
signals once canceled. This includes the progressValueChanged(),
|
|
progressRangeChanged(), progressTextChanged(), resultReadyAt(), and
|
|
resultsReadyAt() signals.
|
|
|
|
Be aware that not all running asynchronous computations can be canceled.
|
|
For example, the QFuture returned by QtConcurrent::run() cannot be
|
|
canceled; but the QFuture returned by QtConcurrent::mappedReduced() can.
|
|
*/
|
|
void QFutureWatcherBase::cancel()
|
|
{
|
|
futureInterface().cancel();
|
|
}
|
|
|
|
#if QT_DEPRECATED_SINCE(6, 0)
|
|
/*! \fn template <typename T> void QFutureWatcher<T>::setPaused(bool paused)
|
|
|
|
\deprecated [6.6] Use setSuspended() instead.
|
|
|
|
If \a paused is true, this function pauses the asynchronous computation
|
|
represented by the future(). If the computation is already paused, this
|
|
function does nothing. QFutureWatcher will not immediately stop delivering
|
|
progress and result ready signals when the future is paused. At the moment
|
|
of pausing there may still be computations that are in progress and cannot
|
|
be stopped. Signals for such computations will still be delivered after
|
|
pause.
|
|
|
|
If \a paused is false, this function resumes the asynchronous computation.
|
|
If the computation was not previously paused, this function does nothing.
|
|
|
|
Be aware that not all computations can be paused. For example, the
|
|
QFuture returned by QtConcurrent::run() cannot be paused; but the QFuture
|
|
returned by QtConcurrent::mappedReduced() can.
|
|
|
|
\sa suspend(), resume(), toggleSuspended()
|
|
*/
|
|
void QFutureWatcherBase::setPaused(bool paused)
|
|
{
|
|
futureInterface().setSuspended(paused);
|
|
}
|
|
|
|
/*! \fn template <typename T> void QFutureWatcher<T>::pause()
|
|
|
|
\deprecated
|
|
Use suspend() instead.
|
|
|
|
Pauses the asynchronous computation represented by the future(). This is a
|
|
convenience method that simply calls setPaused(true).
|
|
|
|
\sa resume()
|
|
*/
|
|
void QFutureWatcherBase::pause()
|
|
{
|
|
futureInterface().setSuspended(true);
|
|
}
|
|
|
|
#endif // QT_DEPRECATED_SINCE(6, 0)
|
|
|
|
/*! \fn template <typename T> void QFutureWatcher<T>::setSuspended(bool suspend)
|
|
|
|
\since 6.0
|
|
|
|
If \a suspend is true, this function suspends the asynchronous computation
|
|
represented by the future(). If the computation is already suspended, this
|
|
function does nothing. QFutureWatcher will not immediately stop delivering
|
|
progress and result ready signals when the future is suspended. At the moment
|
|
of suspending there may still be computations that are in progress and cannot
|
|
be stopped. Signals for such computations will still be delivered.
|
|
|
|
If \a suspend is false, this function resumes the asynchronous computation.
|
|
If the computation was not previously suspended, this function does nothing.
|
|
|
|
Be aware that not all computations can be suspended. For example, the
|
|
QFuture returned by QtConcurrent::run() cannot be suspended; but the QFuture
|
|
returned by QtConcurrent::mappedReduced() can.
|
|
|
|
\sa suspend(), resume(), toggleSuspended()
|
|
*/
|
|
void QFutureWatcherBase::setSuspended(bool suspend)
|
|
{
|
|
futureInterface().setSuspended(suspend);
|
|
}
|
|
|
|
/*! \fn template <typename T> void QFutureWatcher<T>::suspend()
|
|
|
|
\since 6.0
|
|
|
|
Suspends the asynchronous computation represented by this future. This is a
|
|
convenience method that simply calls setSuspended(true).
|
|
|
|
\sa resume()
|
|
*/
|
|
void QFutureWatcherBase::suspend()
|
|
{
|
|
futureInterface().setSuspended(true);
|
|
}
|
|
|
|
/*! \fn template <typename T> void QFutureWatcher<T>::resume()
|
|
|
|
Resumes the asynchronous computation represented by the future(). This is
|
|
a convenience method that simply calls setSuspended(false).
|
|
|
|
\sa suspend()
|
|
*/
|
|
|
|
void QFutureWatcherBase::resume()
|
|
{
|
|
futureInterface().setSuspended(false);
|
|
}
|
|
|
|
#if QT_DEPRECATED_SINCE(6, 0)
|
|
/*! \fn template <typename T> void QFutureWatcher<T>::togglePaused()
|
|
|
|
\deprecated [6.0] Use toggleSuspended() instead.
|
|
|
|
Toggles the paused state of the asynchronous computation. In other words,
|
|
if the computation is currently paused, calling this function resumes it;
|
|
if the computation is running, it is paused. This is a convenience method
|
|
for calling setPaused(!isPaused()).
|
|
|
|
\sa setSuspended(), suspend(), resume()
|
|
*/
|
|
void QFutureWatcherBase::togglePaused()
|
|
{
|
|
futureInterface().toggleSuspended();
|
|
}
|
|
#endif // QT_DEPRECATED_SINCE(6, 0)
|
|
|
|
/*! \fn template <typename T> void QFutureWatcher<T>::toggleSuspended()
|
|
|
|
\since 6.0
|
|
|
|
Toggles the suspended state of the asynchronous computation. In other words,
|
|
if the computation is currently suspending or suspended, calling this
|
|
function resumes it; if the computation is running, it is suspended. This is a
|
|
convenience method for calling setSuspended(!(isSuspending() || isSuspended())).
|
|
|
|
\sa setSuspended(), suspend(), resume()
|
|
*/
|
|
void QFutureWatcherBase::toggleSuspended()
|
|
{
|
|
futureInterface().toggleSuspended();
|
|
}
|
|
|
|
/*! \fn template <typename T> int QFutureWatcher<T>::progressValue() const
|
|
|
|
Returns the current progress value, which is between the progressMinimum()
|
|
and progressMaximum().
|
|
|
|
\sa progressMinimum(), progressMaximum()
|
|
*/
|
|
int QFutureWatcherBase::progressValue() const
|
|
{
|
|
return futureInterface().progressValue();
|
|
}
|
|
|
|
/*! \fn template <typename T> int QFutureWatcher<T>::progressMinimum() const
|
|
|
|
Returns the minimum progressValue().
|
|
|
|
\sa progressValue(), progressMaximum()
|
|
*/
|
|
int QFutureWatcherBase::progressMinimum() const
|
|
{
|
|
return futureInterface().progressMinimum();
|
|
}
|
|
|
|
/*! \fn template <typename T> int QFutureWatcher<T>::progressMaximum() const
|
|
|
|
Returns the maximum progressValue().
|
|
|
|
\sa progressValue(), progressMinimum()
|
|
*/
|
|
int QFutureWatcherBase::progressMaximum() const
|
|
{
|
|
return futureInterface().progressMaximum();
|
|
}
|
|
|
|
/*! \fn template <typename T> QString QFutureWatcher<T>::progressText() const
|
|
|
|
Returns the (optional) textual representation of the progress as reported
|
|
by the asynchronous computation.
|
|
|
|
Be aware that not all computations provide a textual representation of the
|
|
progress, and as such, this function may return an empty string.
|
|
*/
|
|
QString QFutureWatcherBase::progressText() const
|
|
{
|
|
return futureInterface().progressText();
|
|
}
|
|
|
|
/*! \fn template <typename T> bool QFutureWatcher<T>::isStarted() const
|
|
|
|
Returns \c true if the asynchronous computation represented by the future()
|
|
has been started, or if no future has been set; otherwise returns \c false.
|
|
*/
|
|
bool QFutureWatcherBase::isStarted() const
|
|
{
|
|
return futureInterface().queryState(QFutureInterfaceBase::Started);
|
|
}
|
|
|
|
/*! \fn template <typename T> bool QFutureWatcher<T>::isFinished() const
|
|
|
|
Returns \c true if the asynchronous computation represented by the future()
|
|
has finished, or if no future has been set; otherwise returns \c false.
|
|
*/
|
|
bool QFutureWatcherBase::isFinished() const
|
|
{
|
|
return futureInterface().isFinished();
|
|
}
|
|
|
|
/*! \fn template <typename T> bool QFutureWatcher<T>::isRunning() const
|
|
|
|
Returns \c true if the asynchronous computation represented by the future()
|
|
is currently running; otherwise returns \c false.
|
|
*/
|
|
bool QFutureWatcherBase::isRunning() const
|
|
{
|
|
return futureInterface().queryState(QFutureInterfaceBase::Running);
|
|
}
|
|
|
|
/*! \fn template <typename T> bool QFutureWatcher<T>::isCanceled() const
|
|
|
|
Returns \c true if the asynchronous computation has been canceled with the
|
|
cancel() function, or if no future has been set; otherwise returns \c false.
|
|
|
|
Be aware that the computation may still be running even though this
|
|
function returns \c true. See cancel() for more details.
|
|
*/
|
|
bool QFutureWatcherBase::isCanceled() const
|
|
{
|
|
return futureInterface().queryState(QFutureInterfaceBase::Canceled);
|
|
}
|
|
|
|
#if QT_DEPRECATED_SINCE(6, 0)
|
|
|
|
/*! \fn template <typename T> bool QFutureWatcher<T>::isPaused() const
|
|
|
|
\deprecated [6.0] Use isSuspending() or isSuspended() instead.
|
|
|
|
Returns \c true if the asynchronous computation has been paused with the
|
|
pause() function; otherwise returns \c false.
|
|
|
|
Be aware that the computation may still be running even though this
|
|
function returns \c true. See setPaused() for more details. To check
|
|
if pause actually took effect, use isSuspended() instead.
|
|
|
|
\sa setSuspended(), toggleSuspended(), isSuspended()
|
|
*/
|
|
|
|
bool QFutureWatcherBase::isPaused() const
|
|
{
|
|
QT_WARNING_PUSH
|
|
QT_WARNING_DISABLE_DEPRECATED
|
|
return futureInterface().isPaused();
|
|
QT_WARNING_POP
|
|
}
|
|
#endif // QT_DEPRECATED_SINCE(6, 0)
|
|
|
|
/*! \fn template <typename T> bool QFutureWatcher<T>::isSuspending() const
|
|
|
|
\since 6.0
|
|
|
|
Returns \c true if the asynchronous computation has been suspended with the
|
|
suspend() function, but the work is not yet suspended, and computation is still
|
|
running. Returns \c false otherwise.
|
|
|
|
To check if suspension is actually in effect, use isSuspended() instead.
|
|
|
|
\sa setSuspended(), toggleSuspended(), isSuspended()
|
|
*/
|
|
bool QFutureWatcherBase::isSuspending() const
|
|
{
|
|
return futureInterface().isSuspending();
|
|
}
|
|
|
|
/*! \fn template <typename T> bool QFutureWatcher<T>::isSuspended() const
|
|
|
|
\since 6.0
|
|
|
|
Returns \c true if a suspension of the asynchronous computation has been
|
|
requested, and it is in effect, meaning that no more results or progress
|
|
changes are expected.
|
|
|
|
\sa suspended(), setSuspended(), isSuspending()
|
|
*/
|
|
bool QFutureWatcherBase::isSuspended() const
|
|
{
|
|
return futureInterface().isSuspended();
|
|
}
|
|
|
|
/*! \fn template <typename T> void QFutureWatcher<T>::waitForFinished()
|
|
|
|
Waits for the asynchronous computation to finish (including cancel()ed
|
|
computations), i.e. until isFinished() returns \c true.
|
|
*/
|
|
void QFutureWatcherBase::waitForFinished()
|
|
{
|
|
futureInterface().waitForFinished();
|
|
}
|
|
|
|
bool QFutureWatcherBase::event(QEvent *event)
|
|
{
|
|
Q_D(QFutureWatcherBase);
|
|
if (event->type() == QEvent::FutureCallOut) {
|
|
QFutureCallOutEvent *callOutEvent = static_cast<QFutureCallOutEvent *>(event);
|
|
d->sendCallOutEvent(callOutEvent);
|
|
return true;
|
|
}
|
|
return QObject::event(event);
|
|
}
|
|
|
|
/*! \fn template <typename T> void QFutureWatcher<T>::setPendingResultsLimit(int limit)
|
|
|
|
The setPendingResultsLimit() provides throttling control. When the number
|
|
of pending resultReadyAt() or resultsReadyAt() signals exceeds the
|
|
\a limit, the computation represented by the future will be throttled
|
|
automatically. The computation will resume once the number of pending
|
|
signals drops below the \a limit.
|
|
*/
|
|
void QFutureWatcherBase::setPendingResultsLimit(int limit)
|
|
{
|
|
Q_D(QFutureWatcherBase);
|
|
d->maximumPendingResultsReady = limit;
|
|
}
|
|
|
|
void QFutureWatcherBase::connectNotify(const QMetaMethod &signal)
|
|
{
|
|
Q_D(QFutureWatcherBase);
|
|
static const QMetaMethod resultReadyAtSignal = QMetaMethod::fromSignal(&QFutureWatcherBase::resultReadyAt);
|
|
if (signal == resultReadyAtSignal)
|
|
d->resultAtConnected.ref();
|
|
#ifndef QT_NO_DEBUG
|
|
static const QMetaMethod finishedSignal = QMetaMethod::fromSignal(&QFutureWatcherBase::finished);
|
|
if (signal == finishedSignal) {
|
|
if (futureInterface().isRunning()) {
|
|
//connections should be established before calling stFuture to avoid race.
|
|
// (The future could finish before the connection is made.)
|
|
qWarning("QFutureWatcher::connect: connecting after calling setFuture() is likely to produce race");
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void QFutureWatcherBase::disconnectNotify(const QMetaMethod &signal)
|
|
{
|
|
Q_D(QFutureWatcherBase);
|
|
static const QMetaMethod resultReadyAtSignal = QMetaMethod::fromSignal(&QFutureWatcherBase::resultReadyAt);
|
|
if (signal == resultReadyAtSignal)
|
|
d->resultAtConnected.deref();
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
*/
|
|
QFutureWatcherBasePrivate::QFutureWatcherBasePrivate()
|
|
: maximumPendingResultsReady(QThread::idealThreadCount() * 2),
|
|
resultAtConnected(0)
|
|
{ }
|
|
|
|
/*!
|
|
\internal
|
|
*/
|
|
void QFutureWatcherBase::connectOutputInterface()
|
|
{
|
|
futureInterface().d->connectOutputInterface(d_func());
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
*/
|
|
void QFutureWatcherBase::disconnectOutputInterface(bool pendingAssignment)
|
|
{
|
|
if (pendingAssignment) {
|
|
Q_D(QFutureWatcherBase);
|
|
d->pendingResultsReady.storeRelaxed(0);
|
|
}
|
|
|
|
futureInterface().d->disconnectOutputInterface(d_func());
|
|
}
|
|
|
|
void QFutureWatcherBasePrivate::postCallOutEvent(const QFutureCallOutEvent &callOutEvent)
|
|
{
|
|
Q_Q(QFutureWatcherBase);
|
|
|
|
if (callOutEvent.callOutType == QFutureCallOutEvent::ResultsReady) {
|
|
if (pendingResultsReady.fetchAndAddRelaxed(1) >= maximumPendingResultsReady)
|
|
q->futureInterface().d->internal_setThrottled(true);
|
|
}
|
|
|
|
QCoreApplication::postEvent(q, callOutEvent.clone());
|
|
}
|
|
|
|
void QFutureWatcherBasePrivate::callOutInterfaceDisconnected()
|
|
{
|
|
QCoreApplication::removePostedEvents(q_func(), QEvent::FutureCallOut);
|
|
}
|
|
|
|
void QFutureWatcherBasePrivate::sendCallOutEvent(QFutureCallOutEvent *event)
|
|
{
|
|
Q_Q(QFutureWatcherBase);
|
|
|
|
switch (event->callOutType) {
|
|
case QFutureCallOutEvent::Started:
|
|
emit q->started();
|
|
break;
|
|
case QFutureCallOutEvent::Finished:
|
|
emit q->finished();
|
|
break;
|
|
case QFutureCallOutEvent::Canceled:
|
|
pendingResultsReady.storeRelaxed(0);
|
|
emit q->canceled();
|
|
break;
|
|
case QFutureCallOutEvent::Suspending:
|
|
if (q->futureInterface().isCanceled())
|
|
break;
|
|
emit q->suspending();
|
|
#if QT_DEPRECATED_SINCE(6, 0)
|
|
QT_WARNING_PUSH
|
|
QT_WARNING_DISABLE_DEPRECATED
|
|
emit q->paused();
|
|
QT_WARNING_POP
|
|
#endif
|
|
break;
|
|
case QFutureCallOutEvent::Suspended:
|
|
if (q->futureInterface().isCanceled())
|
|
break;
|
|
emit q->suspended();
|
|
break;
|
|
case QFutureCallOutEvent::Resumed:
|
|
if (q->futureInterface().isCanceled())
|
|
break;
|
|
emit q->resumed();
|
|
break;
|
|
case QFutureCallOutEvent::ResultsReady: {
|
|
if (q->futureInterface().isCanceled())
|
|
break;
|
|
|
|
if (pendingResultsReady.fetchAndAddRelaxed(-1) <= maximumPendingResultsReady)
|
|
q->futureInterface().setThrottled(false);
|
|
|
|
const int beginIndex = event->index1;
|
|
const int endIndex = event->index2;
|
|
|
|
emit q->resultsReadyAt(beginIndex, endIndex);
|
|
|
|
if (resultAtConnected.loadRelaxed() <= 0)
|
|
break;
|
|
|
|
for (int i = beginIndex; i < endIndex; ++i)
|
|
emit q->resultReadyAt(i);
|
|
|
|
} break;
|
|
case QFutureCallOutEvent::Progress:
|
|
if (q->futureInterface().isCanceled())
|
|
break;
|
|
|
|
emit q->progressValueChanged(event->index1);
|
|
if (!event->text.isNull()) // ###
|
|
emit q->progressTextChanged(event->text);
|
|
break;
|
|
case QFutureCallOutEvent::ProgressRange:
|
|
emit q->progressRangeChanged(event->index1, event->index2);
|
|
break;
|
|
default: break;
|
|
}
|
|
}
|
|
|
|
|
|
/*! \fn template <typename T> const T &QFutureWatcher<T>::result() const
|
|
|
|
Returns the first result in the future(). If the result is not immediately
|
|
available, this function will block and wait for the result to become
|
|
available. This is a convenience method for calling resultAt(0).
|
|
|
|
\sa resultAt()
|
|
*/
|
|
|
|
/*! \fn template <typename T> const T &QFutureWatcher<T>::resultAt(int index) const
|
|
|
|
Returns the result at \a index in the future(). If the result is not
|
|
immediately available, this function will block and wait for the result to
|
|
become available.
|
|
|
|
\sa result()
|
|
*/
|
|
|
|
/*! \fn template <typename T> void QFutureWatcher<T>::setFuture(const QFuture<T> &future)
|
|
|
|
Starts watching the given \a future.
|
|
|
|
If \a future has already started, the watcher will initially emit signals
|
|
that bring their listeners up to date about the future's state. The
|
|
following signals will, if applicable, be emitted in the given order:
|
|
started(), progressRangeChanged(), progressValueChanged(),
|
|
progressTextChanged(), resultsReadyAt(), resultReadyAt(), suspending(),
|
|
suspended(), canceled(), and finished(). Of these, resultsReadyAt() and
|
|
resultReadyAt() may be emitted several times to cover all available
|
|
results. progressValueChanged() and progressTextChanged() will only be
|
|
emitted once for the latest available progress value and text.
|
|
|
|
To avoid a race condition, it is important to call this function
|
|
\e after doing the connections.
|
|
*/
|
|
|
|
/*! \fn template <typename T> QFuture<T> QFutureWatcher<T>::future() const
|
|
|
|
Returns the watched future.
|
|
*/
|
|
|
|
/*! \fn template <typename T> void QFutureWatcher<T>::started()
|
|
|
|
This signal is emitted when this QFutureWatcher starts watching the future
|
|
set with setFuture().
|
|
*/
|
|
|
|
/*!
|
|
\fn template <typename T> void QFutureWatcher<T>::finished()
|
|
This signal is emitted when the watched future finishes.
|
|
*/
|
|
|
|
/*!
|
|
\fn template <typename T> void QFutureWatcher<T>::canceled()
|
|
This signal is emitted if the watched future is canceled.
|
|
*/
|
|
|
|
/*! \fn template <typename T> void QFutureWatcher<T>::suspending()
|
|
|
|
\since 6.0
|
|
|
|
This signal is emitted when the state of the watched future is
|
|
set to suspended.
|
|
|
|
\note This signal only informs that suspension has been requested. It
|
|
doesn't indicate that all background operations are stopped. Signals
|
|
for computations that were in progress at the moment of suspending will
|
|
still be delivered. To be informed when suspension actually
|
|
took effect, use the suspended() signal.
|
|
|
|
\sa setSuspended(), suspend(), suspended()
|
|
*/
|
|
|
|
#if QT_DEPRECATED_SINCE(6, 0)
|
|
/*! \fn template <typename T> void QFutureWatcher<T>::paused()
|
|
|
|
\deprecated [6.0] Use suspending() instead.
|
|
|
|
This signal is emitted when the state of the watched future is
|
|
set to paused.
|
|
|
|
\note This signal only informs that pause has been requested. It
|
|
doesn't indicate that all background operations are stopped. Signals
|
|
for computations that were in progress at the moment of pausing will
|
|
still be delivered. To to be informed when pause() actually
|
|
took effect, use the suspended() signal.
|
|
|
|
\sa setSuspended(), suspend(), suspended()
|
|
*/
|
|
#endif // QT_DEPRECATED_SINCE(6, 0)
|
|
|
|
/*! \fn template <typename T> void QFutureWatcher<T>::suspended()
|
|
|
|
\since 6.0
|
|
|
|
This signal is emitted when suspend() took effect, meaning that there are
|
|
no more running computations. After receiving this signal no more result
|
|
ready or progress reporting signals are expected.
|
|
|
|
\sa setSuspended(), suspend(), suspended()
|
|
*/
|
|
|
|
/*! \fn template <typename T> void QFutureWatcher<T>::resumed()
|
|
This signal is emitted when the watched future is resumed.
|
|
*/
|
|
|
|
/*!
|
|
\fn template <typename T> void QFutureWatcher<T>::progressRangeChanged(int minimum, int maximum)
|
|
|
|
The progress range for the watched future has changed to \a minimum and
|
|
\a maximum
|
|
*/
|
|
|
|
/*!
|
|
\fn template <typename T> void QFutureWatcher<T>::progressValueChanged(int progressValue)
|
|
|
|
This signal is emitted when the watched future reports progress,
|
|
\a progressValue gives the current progress. In order to avoid overloading
|
|
the GUI event loop, QFutureWatcher limits the progress signal emission
|
|
rate. This means that listeners connected to this slot might not get all
|
|
progress reports the future makes. The last progress update (where
|
|
\a progressValue equals the maximum value) will always be delivered.
|
|
*/
|
|
|
|
/*! \fn template <typename T> void QFutureWatcher<T>::progressTextChanged(const QString &progressText)
|
|
|
|
This signal is emitted when the watched future reports textual progress
|
|
information, \a progressText.
|
|
*/
|
|
|
|
/*!
|
|
\fn template <typename T> void QFutureWatcher<T>::resultReadyAt(int index)
|
|
|
|
This signal is emitted when the watched future reports a ready result at
|
|
\a index. If the future reports multiple results, the index will indicate
|
|
which one it is. Results can be reported out-of-order. To get the result,
|
|
call resultAt(index);
|
|
*/
|
|
|
|
/*!
|
|
\fn template <typename T> void QFutureWatcher<T>::resultsReadyAt(int beginIndex, int endIndex);
|
|
|
|
This signal is emitted when the watched future reports ready results.
|
|
The results are indexed from \a beginIndex to \a endIndex.
|
|
|
|
*/
|
|
|
|
QT_END_NAMESPACE
|
|
|
|
#include "moc_qfuturewatcher.cpp"
|