将QQmlListProperty从QML传递给C ++作为参数

Question

I have a QML ProviderItem that has objects property returning list of QObject-derived objects.
I want to pass this list to another QML ConsumerItem as property for its function consumeAll. The problem is that I always get empty QQmlListProperty with all callback functions set to 0 and data pointer set to 0 (I think these are default-constructed values)

Something like this:

ProviderItem.h

class ProviderItem : public QObject, public QQmlParserStatus
{
    Q_OBJECT
public:
    Q_PROPERTY(QQmlListProperty<QObject> objects READ objects NOTIFY objectsChanged)

    QQmlListProperty<QObject> objects();
    static int objects_count(QQmlListProperty<QObject> *);
    static QObject* objects_at(QQmlListProperty<QObject> *, int);

private:
    QList<QObject*> m_objects;
}

ProviderItem.cpp

QQmlListProperty<QObject> ProviderItemPrivate::objects()
{
    return QQmlListProperty<QObject>(this, nullptr,
         ProviderItem::objects_count,
         ProviderItem::objects_at);
}

QObject* ProviderItem::objects_at(QQmlListProperty<QObject> *prop, int index)
{
    ProviderItem* provider = qobject_cast<ProviderItem*>(prop->object)
    return provider->m_objects.at(index);
}

int ProviderItem::objects_count(QQmlListProperty<QObject> *prop)
{
    ProviderItem* provider = qobject_cast<ProviderItem*>(prop->object)
    return provider->m_objects.count();
}

ConsumerItem.h

class ConsumerItem: public QObject
{
    Q_OBJECT
public:
    Q_INVOKABLE void consumeAll(QQmlListProperty<QObject> obj);
};

ConsumerItem.cpp

void ConsumerItem::consumeAll(QQmlListProperty<QObject> obj)
{
    qDebug() << obj.count(); // thows exeption as count callback is 0
}

main.qml

Provider {
    id: objectProvider
}

Consumer {
    id: objectConsumer
}

Connections {
    target: objectProvider
    onObjectsChanged: {
        console.debug(objectProvider.objects)        // gives [object Object]
        objectConsumer.consumeAll(objectProvider.objects)

        var test = objectProvider.objects
        console.debug(test)                          // gives [object Object]
        Thermonav.testList(objectProvider.objects)
    }
}

Obviously ProviderItem and ConsumerItem are registered:

main.cpp

qmlRegisterType<ProviderItem>(uri, major, minor, "Provider");
qmlRegisterType<ConsumerItem>(uri, major, minor, "Consumer");

I have also tried:

Q_INVOKABLE void consumeAll(QVariantMap obj);
Q_INVOKABLE void consumeAll(QQmlListProperty<QObject> obj);
Q_INVOKABLE void consumeAll(void* p);
Q_INVOKABLE void consumeAll(QVariant p);

but every time I get default-costructed values.

According to this article :

When integrating with C++, note that any QQmlListProperty value passed into QML from C++ is automatically converted into a list value, and vice-versa.

so output in qml [object Object] looks legit to me, as "list" is not js data type. But it also says that QML list should be converted back in QQmlListProperty that definitely not working for me (or I am doing it wrong).

I am using Qt 5.12.0

So how do I pass QQmlListProperty created in C++ to QML list and then to QQmlListProperty in C++?

Answer 1

If you use QVariant and print:

class ConsumerItem: public QObject
{
    Q_OBJECT
public:
    using QObject::QObject;
    Q_INVOKABLE void consumeAll(QVariant objects){
        qDebug() << objects;
    }
};

You get:

QVariant(QQmlListReference, )

So the solution is to use QQmlListReference :

class ConsumerItem: public QObject
{
    Q_OBJECT
public:
    using QObject::QObject;
    Q_INVOKABLE void consumeAll(const QQmlListReference & objects){
        qDebug() << objects.count();
    }
};

---

Complete code:

main.cpp

#include <QtQml>
#include <QtGui>
class Product: public QObject{
    Q_OBJECT
    Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
public:
    Product(const QString & name="", QObject* parent=nullptr):
        QObject(parent), m_name(name){}
    QString name() const{return m_name;}
    void setName(const QString &name){
        if(m_name == name) return;
        m_name = name;
        Q_EMIT nameChanged(m_name);
    }
    Q_SIGNAL void nameChanged(const QString &);
private:
    QString m_name;
};

class ProviderItem: public QObject{
    Q_OBJECT
    Q_PROPERTY(QQmlListProperty<Product> products READ products NOTIFY productsChanged)
public:
    using QObject::QObject;
    QQmlListProperty<Product> products(){
        return QQmlListProperty<Product>(this, this,
                                         &ProviderItem::appendProduct,
                                         &ProviderItem::productCount,
                                         &ProviderItem::product,
                                         &ProviderItem::clearProducts);
    }
    void appendProduct(Product* p) {
        m_products.append(p);
        Q_EMIT productsChanged();
    }
    int productCount() const{return m_products.count();}
    Product *product(int index) const{ return m_products.at(index);}
    void clearProducts() {
        m_products.clear();
        Q_EMIT productsChanged();
    }
    Q_SIGNAL void productsChanged();
private:
    static void appendProduct(QQmlListProperty<Product>* list, Product* p) {
        reinterpret_cast<ProviderItem* >(list->data)->appendProduct(p);
    }
    static void clearProducts(QQmlListProperty<Product>* list) {
        reinterpret_cast<ProviderItem* >(list->data)->clearProducts();
    }
    static Product* product(QQmlListProperty<Product>* list, int i) {
        return reinterpret_cast<ProviderItem* >(list->data)->product(i);
    }
    static int productCount(QQmlListProperty<Product>* list) {
        return reinterpret_cast<ProviderItem* >(list->data)->productCount();
    }
    QVector<Product *> m_products;
};

class ConsumerItem: public QObject
{
    Q_OBJECT
public:
    using QObject::QObject;
    Q_INVOKABLE void consumeAll(const QQmlListReference & products){
        for(int i=0; i<products.count(); ++i){
            if(Product *product = qobject_cast<Product *>(products.at(i))){
                qDebug()<< product->name();
            }
        }
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
    QGuiApplication app(argc, argv);
    qmlRegisterType<Product>("foo", 1, 0, "Product");
    qmlRegisterType<ProviderItem>("foo", 1, 0, "Provider");
    qmlRegisterType<ConsumerItem>("foo", 1, 0, "Consumer");
    QQmlApplicationEngine engine;
    engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
    if (engine.rootObjects().isEmpty())
        return -1;
    return app.exec();
}
#include "main.moc"

main.qml

import QtQuick 2.9
import QtQuick.Window 2.2
import foo 1.0

Window {
    visible: true
    width: 640
    height: 480
    title: qsTr("Hello World")
    function create_product(){
        var product = Qt.createQmlObject('import foo 1.0; Product {}',
                                         provider,
                                         "dynamicSnippet1");
        product.name = "product"+provider.products.length;
        provider.products.push(product)
    }
    Timer {
        interval: 1000; running: true; repeat: true
        onTriggered: create_product()
    }
    Provider{
        id: provider
        onProductsChanged: consumer.consumeAll(provider.products)
        products: [
            Product{name: "product0"},
            Product{name: "product1"},
            Product{name: "product2"}
        ]
    }
    Consumer{
        id: consumer
    }
}