QFutureWatcher Class Reference |
QFutureWatcher ( QObject * parent = 0 ) | |
~QFutureWatcher () | |
QFuture<T> | future () const |
bool | isCanceled () const |
bool | isFinished () const |
bool | isPaused () const |
bool | isRunning () const |
bool | isStarted () const |
int | progressMaximum () const |
int | progressMinimum () const |
QString | progressText () const |
int | progressValue () const |
T | result () const |
T | resultAt ( int index ) const |
void | setFuture ( const QFuture<T> & future ) |
void | setPendingResultsLimit ( int limit ) |
void | waitForFinished () |
void | cancel () |
void | pause () |
void | resume () |
void | setPaused ( bool paused ) |
void | togglePaused () |
void | canceled () |
void | finished () |
void | paused () |
void | progressRangeChanged ( int minimum, int maximum ) |
void | progressTextChanged ( const QString & progressText ) |
void | progressValueChanged ( int progressValue ) |
void | resultReadyAt ( int index ) |
void | resultsReadyAt ( int beginIndex, int endIndex ) |
void | resumed () |
void | started () |
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(), isPaused(), waitForFinished(), result(), and resultAt(). The cancel(), setPaused(), pause(), resume(), and togglePaused() functions are slots in QFutureWatcher.
Status changes are reported via the started(), finished(), canceled(), paused(), 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:
// Instantiate the objects and connect to the finished signal. MyClass myObject; QFutureWatcher<int> watcher; connect(&watcher, SIGNAL(finished()), &myObject, SLOT(handleFinished())); // Start the computation. QFuture<int> future = QtConcurrent::run(...); watcher.setFuture(future);
Be aware that not all asynchronous computations can be canceled or paused. 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.
See also QFuture and Qt Concurrent.
Constructs a new QFutureWatcher with the given parent.
Destroys the QFutureWatcher.
Cancels the asynchronous computation represented by the future(). Note that the cancelation is asynchronous. Use waitForFinished() after calling cancel() when you need synchronous cancelation.
Currently available results may still be accessed on a canceled QFuture, but new results will 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 asynchronous computations can be canceled. For example, the QFuture returned by QtConcurrent::run() cannot be canceled; but the QFuture returned by QtConcurrent::mappedReduced() can.
This signal is emitted if the watched future is canceled.
This signal is emitted when the watched future finishes.
Returns the watched future.
See also setFuture().
Returns true if the asynchronous computation has been canceled with the cancel() function; otherwise returns false.
Be aware that the computation may still be running even though this function returns true. See cancel() for more details.
Returns true if the asynchronous computation represented by the future() has finished; otherwise returns false.
Returns true if the asynchronous computation has been paused with the pause() function; otherwise returns false.
Be aware that the computation may still be running even though this function returns true. See setPaused() for more details.
See also setPaused() and togglePaused().
Returns true if the asynchronous computation represented by the future() is currently running; otherwise returns false.
Returns true if the asynchronous computation represented by the future() has been started; otherwise returns false.
Pauses the asynchronous computation represented by the future(). This is a convenience method that simply calls setPaused(true).
See also resume().
This signal is emitted when the watched future is paused.
See also setPaused().
Returns the maximum progressValue().
See also progressValue() and progressMinimum().
Returns the minimum progressValue().
See also progressValue() and progressMaximum().
The progress range for the watched future has changed to minimum and maximum
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.
This signal is emitted when the watched future reports textual progress information, progressText.
Returns the current progress value, which is between the progressMinimum() and progressMaximum().
See also progressMinimum() and progressMaximum().
This signal is emitted when the watched future reports progress, 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 progressValue equals the maximum value) will always be delivered.
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).
See also resultAt().
Returns the result at index in the future(). If the result is not immediately available, this function will block and wait for the result to become available.
See also result().
This signal is emitted when the watched future reports a ready result at 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 future().result(index);
This signal is emitted when the watched future reports ready results. The results are indexed from beginIndex to endIndex.
Resumes the asynchronous computation represented by the future(). This is a convenience method that simply calls setPaused(false).
See also pause().
This signal is emitted when the watched future is resumed.
Starts watching the given future.
One of the signals might be emitted for the current state of the future. For example, if the future is already stopped, the finished signal will be emitted.
To avoid a race condition, it is important to call this function
after doing the connections.
See also future().
If paused is true, this function pauses the asynchronous computation represented by the future(). If the computation is already paused, this function does nothing. This QFutureWatcher will stop delivering progress and result ready signals while the future is paused. Signal delivery will continue once the computation is resumed.
If 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.
See also paused(), pause(), resume(), and togglePaused().
The setPendingResultsLimit() provides throttling control. 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.
This signal is emitted when this QFutureWatcher starts watching the future set with setFuture().
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 becomes paused. This is a convenience method for calling setPaused(!isPaused()).
See also setPaused(), pause(), and resume().
Waits for the asynchronous computation to finish (including cancel()ed computations).
Cette page est une traduction d'une page de la documentation de Qt, écrite par Nokia Corporation and/or its subsidiary(-ies). Les éventuels problèmes résultant d'une mauvaise traduction ne sont pas imputables à Nokia. | Qt 4.6 | |
Copyright © 2012 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon, vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD. | ||
Vous avez déniché une erreur ? Un bug ? Une redirection cassée ? Ou tout autre problème, quel qu'il soit ? Ou bien vous désirez participer à ce projet de traduction ? N'hésitez pas à nous contacter ou par MP ! |
Copyright © 2000-2012 - www.developpez.com