Qt5中QML注册自定义C++项访问后端数据模型的实现问询

Step 1: Add Data Update Signal to DataModelClass #

Modify your DataModelClass to emit a signal whenever its internal data is updated. This signal will notify all connected EllipseItem instances of changes.

DataModelClass Header (datamodelclass.h) #

#include <QObject>

class DataModelClass : public QObject
{
    Q_OBJECT
public:
    explicit DataModelClass(QObject *parent = nullptr);
    // Public method to retrieve data (adjust return type to match your data structure)
    QVariant getData() const;

signals:
    // Emit this signal every time data is updated
    void dataUpdated();

private:
    // Internal data storage
    QVariant m_data;
};

DataModelClass Implementation (datamodelclass.cpp) #

#include "datamodelclass.h"

DataModelClass::DataModelClass(QObject *parent) : QObject(parent) {}

QVariant DataModelClass::getData() const {
    return m_data;
}

// Example method for updating data (e.g., after receiving server data)
void DataModelClass::updateData(const QVariant &newData) {
    m_data = newData;
    emit dataUpdated(); // Notify all listeners of the change
}

Step 2: Add DataModel Property to EllipseItem #

Update EllipseItem to hold a pointer to DataModelClass, connect to its update signal, and fetch the latest data when notified.

EllipseItem Header (ellipseitem.h) #

#include <QQuickPaintedItem>

// Forward declaration to avoid circular include issues
class DataModelClass;

class EllipseItem : public QQuickPaintedItem
{
    Q_OBJECT
    // Expose dataModel property to QML for easy assignment
    Q_PROPERTY(DataModelClass* dataModel READ dataModel WRITE setDataModel NOTIFY dataModelChanged)

public:
    explicit EllipseItem(QQuickItem *parent = nullptr);

    DataModelClass* dataModel() const;
    void setDataModel(DataModelClass* model);

    // Override paint method to use updated data
    void paint(QPainter *painter) override;

signals:
    void dataModelChanged();

private slots:
    // Handle data updates from DataModelClass
    void onDataUpdated();

private:
    DataModelClass* m_dataModel = nullptr;
    // Cached data for painting (avoids repeated getData() calls)
    QVariant m_currentData;
};

EllipseItem Implementation (ellipseitem.cpp) #

#include "ellipseitem.h"
#include "datamodelclass.h"
#include <QPainter>

EllipseItem::EllipseItem(QQuickItem *parent) : QQuickPaintedItem(parent) {}

DataModelClass* EllipseItem::dataModel() const {
    return m_dataModel;
}

void EllipseItem::setDataModel(DataModelClass* model) {
    if (m_dataModel == model) return;

    // Disconnect from old model if it exists
    if (m_dataModel) {
        disconnect(m_dataModel, &DataModelClass::dataUpdated, this, &EllipseItem::onDataUpdated);
    }

    m_dataModel = model;

    // Connect to new model's signal and initialize with current data
    if (m_dataModel) {
        connect(m_dataModel, &DataModelClass::dataUpdated, this, &EllipseItem::onDataUpdated);
        m_currentData = m_dataModel->getData();
        update(); // Trigger initial paint with current data
    }

    emit dataModelChanged();
}

void EllipseItem::onDataUpdated() {
    if (!m_dataModel) return;

    // Fetch latest data and trigger repaint
    m_currentData = m_dataModel->getData();
    update(); // Uses your existing GUI refresh mechanism
}

void EllipseItem::paint(QPainter *painter) {
    // Customize this logic to draw your ellipse using m_currentData
    painter->setRenderHint(QPainter::Antialiasing);
    int radius = m_currentData.toInt(); // Adjust based on your actual data type
    painter->drawEllipse(boundingRect().center() - QPoint(radius/2, radius/2), radius/2, radius/2);
}

Step 3: Link DataModelClass to EllipseItem in QML #

Since you've already exposed DataModelClass to QML via setContextProperty (e.g., named dataModel), assign this instance to the dataModel property of each EllipseItem.

Example QML Code #

import QtQuick 2.0
import YourCustomModule 1.0 // Replace with your actual module name

Rectangle {
    width: 400
    height: 400

    // Create multiple EllipseItem instances linked to the same DataModelClass
    EllipseItem {
        x: 50
        y: 50
        width: 100
        height: 100
        dataModel: dataModel // Connect to the exposed DataModelClass instance
    }

    EllipseItem {
        x: 250
        y: 250
        width: 100
        height: 100
        dataModel: dataModel
    }
}

Key Notes #

• Forward Declaration: Using class DataModelClass; in ellipseitem.h prevents circular include errors between the two classes.
• Signal-Slot Connection: Each EllipseItem connects individually to DataModelClass's signal, ensuring all instances receive updates when data changes.
• Data Caching: Storing m_currentData in EllipseItem avoids redundant calls to getData() during painting, improving performance.

内容的提问来源于stack exchange，提问作者Mathieu Gauquelin