Project: Quick Future - Using QFuture in QML

  • Qt Champions 2016

    Project: Quick Future

    QuickFuture is a QML wrapper of QFuture. It allows user to access and listen from a QFuture object generated by a QObject class. So that QML could respond to the result of a threaded calculation.


    import Future 1.0
    var future =“tmp.txt”);
    // FileActor is a C++ class registered as context property
    // QFuture<QString> FileActor::read(const QString&file);
    // It is not a part of the library
    Future.onFinished(future, function(value) {
      // do something when it is finished.
    Future.promise(future).then(function(value) {
      // Future.promise creates a promise object by using Quick Promise.
      // It is useful when you have multiple asynchronous tasks pending.


    qpm install quick.future.pri

    Custom Type Registration

    By default, QFuture<T> is not a standard type recognized by QML. It must be registered as a QMetaType per template type in order to get rid the error message.

    The same rule applies in Quick Future too. Common types are pre-registered already.
    For your own custom type, you can register it by:

    #include <QFFuture>
    int main(int argc, char *argv[])

    Pre-registered data type list: bool, int, qreal, QString, QByteArray, QVariantMap, void.


    (More API will be added upon request)


    Returns true if the asynchronous computation represented by this future has finished; otherwise returns false.

    Future.onFinished(future, callback)

    The callback will be invoked when the watched future finishes.


    Create a promise object which will be resolved when the future has finished. It must have QuickPromise installed and setup properly before using this function.

    [Moved to Showcase ~kshegunov]

  • Qt Champions 2017

    Pretty neat. Thanks for sharing!

  • Thanks for sharing. Your work is much appreciated!

  • Qt Champions 2016

    v1.0.2 has been released!

    Critical Changes

    1. The QML package name has been changed from Future to QuickFuture
    import QuickFuture 1.0
    1. Custom type registration is done by QuickFuture::registerType instead of QFFuture::registerType
    #include <QuickFuture>
    int main(int argc, char *argv[])

    New API



    Future.onCanceled(future, callback)


    Future.sync(future, propertyAtFuture, target, propertyAtTarget)

    Synchronize a property in future object to target object.


    QtObject {
        id: target1
        property var isRunning
        property var isFinished
    // Future.sync(future,"isRunning", target1, "isRunning");
    // Future.sync(future,"isFinished", target1);

    Supported properties: "isRunning", "isCanceled", "isFinished"

  • Qt Champions 2016

    Quick Future v1.0.3 has been released. This version supports a custom type converter for making a QML friendly data structure from QFuture<YourCustomType>. Calling an async function and obtain the result from QML on a C++ class is much easier now.

    New Features

    Custom Converter function

    QuickFuture::registerType() now supports to assign a custom converter for making a QML friendly data structure (e.g QVariantMap) from the custom type. The value could be obtained by using Future.result()

    class Actor : public QObject {
      class Reply {
          int code;
          QString message;
      QFuture<Reply> read(QString source);
    static void init() {
        QuickFuture::registerType<Actor::Reply>([](Actor::Reply reply) -> QVariant {
            // Optional converter function.
            QVariantMap map;
            map["code"] = reply.code;
            map["message"] = reply.message;
            return map;
    var future =;
    console.log(Future.result(future)); // Print { code: 0, message: ""} if the reply is empty

  • Banned

    This post is deleted!

Log in to reply

Looks like your connection to Qt Forum was lost, please wait while we try to reconnect.