Qt
Kommunikation zwischen QML und C ++

Einführung

Rufen Sie C ++ in QML auf

Registrieren Sie C ++ - Klassen in QML

Stellen Sie sich vor, wir haben eine Klasse mit dem Namen QmlCppBridge . Sie implementiert eine Methode namens printHello() .

class QmlCppBridge : public QObject
{
    Q_OBJECT
public:
    Q_INVOKABLE static void printHello() {
        qDebug() << "Hello, QML!";
    }
};

Wir wollen es auf der QML-Seite verwenden. Wir sollten die Klasse registrieren, indem Sie qmlRegisterType() aufrufen:

// Register C++ class as a QML module, 1 & 0 are the major and minor version of the QML module
qmlRegisterType<QmlCppBridge>("QmlCppBridge", 1, 0, "QmlCppBridge");

Verwenden Sie in QML den folgenden Code, um ihn aufzurufen:

import QmlCppBridge 1.0    // Import this module, so we can use it in our QML script

QmlCppBridge {
    id: bridge
}
bridge.printHello();

Verwenden von QQmlContext zum QQmlContext von C ++ - Klassen oder QQmlContext in QML

Wir verwenden immer noch die C ++ - Klasse im vorherigen Beispiel:

QQmlApplicationEngine engine;
QQmlContext *context = engine.rootContext();

// Inject C++ class to QML
context->setContextProperty(QStringLiteral("qmlCppBridge"), new QmlCppBridge(&engine));

// Inject C++ variable to QML
QString demoStr = QStringLiteral("demo");
context->setContextProperty(QStringLiteral("demoStr"), demoStr);

Auf der QML-Seite:

qmlCppBridge.printHello();    // Call to C++ function
str: demoStr                  // Fetch value of C++ variable

Hinweis: Dieses Beispiel basiert auf Qt 5.7. Nicht sicher, ob es zu früheren Qt-Versionen passt.

Rufen Sie QML in C ++ auf

Um die QML-Klassen in C ++ aufzurufen, müssen Sie die objectName -Eigenschaft festlegen.

In Ihrer Qml:

import QtQuick.Controls 2.0

Button {
    objectName: "buttonTest"
}

In C ++ können Sie das Objekt dann mit QObject.FindChild<QObject*>(QString)

So wie das:

QQmlApplicationEngine engine;
QQmlComponent component(&engine, QUrl(QLatin1String("qrc:/main.qml")));

QObject *mainPage = component.create();
QObject* item = mainPage->findChild<QObject *>("buttonTest");

Jetzt haben Sie Ihr QML-Objekt in Ihrem C ++. Das könnte aber sinnlos erscheinen, da wir die Komponenten des Objekts nicht wirklich bekommen können.

Wir können es jedoch verwenden, um Signale zwischen der QML und dem C ++ zu senden. Dazu müssen Sie ein Signal in Ihre QML-Datei signal buttonClicked(string str) : signal buttonClicked(string str) . Sobald Sie dies erstellt haben, müssen Sie das Signal ausgeben. Zum Beispiel:

import QtQuick 2.0
import QtQuick.Controls 2.1

    Button {
        id: buttonTest
        objectName: "buttonTest"

        signal clickedButton(string str)
        onClicked: {
            buttonTest.clickedButton("clicked !")
        }
    }

Hier haben wir unseren qml-Button. Wenn wir darauf klicken, wird zur onClicked- Methode (einer Basismethode für Schaltflächen, die aufgerufen wird, wenn Sie die Schaltfläche drücken) aufgerufen. Dann verwenden wir die ID der Schaltfläche und den Namen des Signals, um das Signal auszugeben.

Und in unserem CPP müssen wir das Signal mit einem Slot verbinden. so wie das:

main.cpp

#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QQmlComponent>

#include "ButtonManager.h"

int main(int argc, char *argv[])
{
    QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
    QGuiApplication app(argc, argv);

    QQmlApplicationEngine engine;
    QQmlComponent component(&engine, QUrl(QLatin1String("qrc:/main.qml")));

    QObject *mainPage = component.create();
    QObject* item = mainPage->findChild<QObject *>("buttonTest");

    ButtonManager buttonManager(mainPage);
    QObject::connect(item, SIGNAL(clickedButton(QString)), &buttonManager, SLOT(onButtonClicked(QString)));

    return app.exec();
}

Wie Sie sehen, erhalten wir unseren qml-Button mit findChild wie zuvor und verbinden das Signal mit einem Button-Manager, der eine Klasse erstellt hat und die so aussehen. ButtonManager.h

#ifndef BUTTONMANAGER_H
#define BUTTONMANAGER_H

#include <QObject>

class ButtonManager : public QObject
{
    Q_OBJECT
public:
    ButtonManager(QObject* parent = nullptr);
public slots:
    void onButtonClicked(QString str);
};

#endif // BUTTONMANAGER_H

ButtonManager.cpp

#include "ButtonManager.h"
#include <QDebug>

ButtonManager::ButtonManager(QObject *parent)
    : QObject(parent)
{

}

void ButtonManager::onButtonClicked(QString str)
{
    qDebug() << "button: " << str;
}

Wenn also das Signal empfangen wird, ruft es die Methode onButtonClicked auf, die "button: clicked !" onButtonClicked

Ausgabe: