Полное руководство по моделям и представлениям в QML для начинающих и профессионалов

В этом разделе мы подробно рассмотрим, как эффективно работать с элементами и объектами в QML. Независимо от вашего опыта, понимание способов создания и управления объектами в этом языке имеет решающее значение для успешной разработки приложений. Мы исследуем, как использовать такие концепции, как QObject, QAbstractListModel, и другие, чтобы создавать мощные и гибкие структуры данных.

Одним из ключевых аспектов работы с QML является способность определять и управлять различными объектами и их свойствами. Например, создание кастомных классов, которые наследуются от QObject и используют Q_INVOKABLE функции, позволяет значительно расширить возможности вашего приложения. В этом контексте важно понимать, как QAbstractListModel и его наследники помогают организовать данные для их последующего отображения в элементе ListView.

Для эффективной работы с данными в QML используются разнообразные виды моделей. Каждый тип модели, такой как QAbstractListModel или QAbstractItemModel, имеет свои особенности и требования. Например, при создании модели на основе QAbstractListModel, необходимо определить столбцы и строки данных, а также методы для их управления. QObject и QObjectParent играют здесь ключевую роль, позволяя создавать иерархические структуры данных.

Не менее важным аспектом является использование делегатов для отображения данных. Делегаты позволяют кастомизировать отображение элементов списка, используя различные компоненты QML. Это означает, что вы можете создать уникальные представления для каждого элемента данных, делая ваше приложение более интерактивным и привлекательным. Способность определять и управлять свойствами делегатов через element-setPropertyText или write методы является важным навыком для каждого разработчика.

В результате, понимание всех этих аспектов и их взаимодействия позволяет создавать более сложные и функциональные приложения на QML. Мы рассмотрим, как использовать QString и QAbstractListModelParent, а также другие инструменты для создания мощных и гибких приложений. В следующих разделах мы подробно остановимся на каждом из этих элементов, чтобы у вас было полное понимание того, как работать с данными в QML.

Модели и представления в QML: Полное Руководство

Основные концепции

В QML компоненты, представляющие данные, тесно связаны с объектами, которые эти данные содержат. Классы моделей включают в себя не только саму структуру данных, но и методы для их управления и обновления. Мы начнем с простых примеров, чтобы понять основные принципы.

• Модели могут содержать различные типы данных, включая строки, числа и другие объекты.
• Элементы, которые отображают данные, называются делегатами.
• Роли (roles) определяют, какие именно данные будут представлены в делегате.

Создание простого списка

Для начала рассмотрим, как создать простой список. Этот процесс требует определения модели и делегата. Модель будет содержать данные, а делегат – описывать способ их отображения.

ListView {
width: 200; height: 300
model: ListModel {
ListElement { name: "Alice"; age: 30 }
ListElement { name: "Bob"; age: 25 }
}
delegate: Component {
Row {
Text { text: name }
Text { text: age }
}
}
}

В этом примере мы создаем ListView, который отображает список людей. Модель содержит элементы с именами и возрастами, а делегат определяет, как эти данные будут представлены.

Роли и их использование

Роли являются важной частью моделей в QML. Они позволяют определять, какие данные из модели будут использованы в делегате. Например, для модели, которая включает имя и возраст, можно определить соответствующие роли:

ListView {
width: 200; height: 300
model: ListModel {
ListElement { name: "Alice"; age: 30 }
ListElement { name: "Bob"; age: 25 }
}
delegate: Component {
Row {
Text { text: model.name }
Text { text: model.age }
}
}
}

В этом примере роли name и age используются для доступа к соответствующим данным модели в делегате.

Расширенные возможности и настройки

Для более сложных задач, таких как динамическое обновление данных или работа с большими наборами, может потребоваться использование более сложных моделей и методов. Например, использование сигнала dataChanged позволяет обновлять данные в реальном времени:

ListModel {
id: peopleModel
ListElement { name: "Alice"; age: 30 }
ListElement { name: "Bob"; age: 25 }
}
function updateAge(name, newAge) {
for (var i = 0; i < peopleModel.count; ++i) {
if (peopleModel.get(i).name == name) {
peopleModel.setProperty(i, "age", newAge);
peopleModel.dataChanged(i);
break;
}
}
}

В этом примере функция updateAge обновляет возраст человека и вызывает сигнал dataChanged, чтобы уведомить об изменении данных.

Итоги и рекомендации

Работа с данными в QML требует понимания моделей и делегатов, а также способов управления этими элементами. Использование ролей и методов обновления данных позволяет создавать интерактивные и гибкие интерфейсы, которые легко адаптируются под любые задачи. Мы рассмотрели базовые и продвинутые примеры, которые помогут вам начать и углубить свои знания в этой области.

Дальнейшее изучение документации и экспериментирование с кодом позволят вам еще лучше освоить эти концепции и применять их в своих проектах.

Применение встроенного типа модели

Использование встроенных типов моделей в QML позволяет создавать гибкие и мощные интерфейсы, которые легко адаптируются под различные задачи. Такой подход упрощает управление данными и их отображение, делая процесс разработки более интуитивным и эффективным.

Одним из простых способов работы с данными является использование модели QAbstractListModel. В этом разделе мы рассмотрим пример, который демонстрирует, как можно использовать данный класс для отображения списка объектов.

Представим, что у нас есть список людей (people), каждый из которых имеет имя и цвет. Мы создадим собственный класс, унаследованный от QAbstractListModel, который будет управлять этими данными.

Определение класса модели

Начнем с определения нашего класса модели:

#include <QAbstractListModel>
#include <QString>
#include <QColor>
struct Person {
QString name;
QColor color;
};
class PersonModel : public QAbstractListModel {
Q_OBJECT
public:
enum PersonRoles {
NameRole = Qt::UserRole + 1,
ColorRole
};
PersonModel(QObject *parent = nullptr) : QAbstractListModel(parent) {
// Пример данных
people.append({ "Alice", QColor("red") });
people.append({ "Bob", QColor("green") });
}
int rowCount(const QModelIndex &parent = QModelIndex()) const override {
return people.count();
}
QVariant data(const QModelIndex &index, int role) const override {
if (!index.isValid())
return QVariant();
const Person &person = people[index.row()];
switch (role) {
case NameRole:
return person.name;
case ColorRole:
return person.color;
default:
return QVariant();
}
}
protected:
QHash roleNames() const override {
QHash roles;
roles[NameRole] = "name";
roles[ColorRole] = "color";
return roles;
}
private:
QList<Person> people;
};

Здесь мы определяем класс PersonModel, который наследуется от QAbstractListModel. В нем создается список людей и методы для получения количества строк и данных по индексу. Также определяются роли для имен и цветов.

Использование модели в QML

Теперь мы можем использовать наш класс модели в QML-компоненте ListView. Создадим простой интерфейс для отображения списка людей:

import QtQuick 2.15
import QtQuick.Controls 2.15
ApplicationWindow {
visible: true
width: 400
height: 300
ListView {
width: parent.width
height: parent.height
model: personModel
delegate: Item {
width: parent.width
height: 50
Rectangle {
width: 20
height: 20
color: model.color
anchors.verticalCenter: parent.verticalCenter
}
Text {
text: model.name
anchors.verticalCenter: parent.verticalCenter
anchors.left: rectangle.right
anchors.leftMargin: 10
}
}
}
}

В этом примере мы создаем элемент ListView, который использует нашу модель personModel. Каждый элемент списка отображается с помощью делегата, содержащего прямоугольник и текстовое поле. Прямоугольник окрашивается в цвет, заданный в модели, а текстовое поле отображает имя.

Подключение модели к QML

Чтобы наша модель заработала в QML, нам нужно зарегистрировать ее с помощью qmlRegisterType:

#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QQmlContext>
int main(int argc, char *argv[]) {
QGuiApplication app(argc, argv);
qmlRegisterType<PersonModel>("com.example", 1, 0, "PersonModel");
QQmlApplicationEngine engine;
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
return app.exec();
}

В итоге, мы создаем простое приложение, которое отображает список людей с их именами и цветами, используя встроенные типы моделей и возможности QML. Таким образом, применение встроенных типов моделей позволяет эффективно управлять данными и их отображением в QML-приложениях.

ObjectModel и его особенности

Особенности ObjectModel включают в себя:

• Простота использования и настройки.
• Возможность работы с объектами различных типов.
• Поддержка динамического изменения состава модели.

ObjectModel является наследником QAbstractListModel и предоставляет методы и свойства, необходимые для управления списком объектов. Рассмотрим основные аспекты работы с этим типом модели.

Создание ObjectModel

Чтобы использовать ObjectModel, сначала нужно создать экземпляр класса и зарегистрировать необходимые объекты:

ObjectModel {
id: objectModel
ListElement { name: "Объект 1"; value: 10 }
ListElement { name: "Объект 2"; value: 20 }
}

Каждый элемент в модели является объектом, который может иметь любые свойства. В приведенном примере создаются два объекта с простыми свойствами name и value.

Работа с данными

ObjectModel поддерживает стандартные роли и позволяет определять пользовательские роли с помощью идентификаторов. Пример использования данных модели:

delegate: Text {
text: model.name + ": " + model.value
}

Для работы с данными модели можно использовать методы и сигналы, такие как dataChanged и data. Если требуется обновить данные модели, можно воспользоваться методом setData:

objectModel.set(0, { name: "Обновленный объект 1", value: 30 })

Интерактивное изменение данных

ObjectModel позволяет динамически добавлять и удалять объекты. Для этого можно использовать методы append и remove:

objectModel.append({ name: "Новый объект", value: 40 })
objectModel.remove(1)

Таким образом, мы можем гибко управлять содержимым модели, добавляя и удаляя объекты по мере необходимости.

Пользовательские роли

Для определения пользовательских ролей в ObjectModel можно использовать Qt::UserRole и наследников класса. Пример добавления пользовательской роли:

class CustomModel : public QAbstractListModel {
Q_OBJECT
Q_PROPERTY(QList<QObject*> dataList READ dataList WRITE setDataList NOTIFY dataListChanged)
public:
enum Roles {
NameRole = Qt::UserRole + 1,
ValueRole
};
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override {
if (!index.isValid())
return QVariant();
const auto *item = dataList.at(index.row());
if (role == NameRole)
return item->property("name");
else if (role == ValueRole)
return item->property("value");
return QVariant();
}
};

Таким образом, мы можем расширять возможности ObjectModel, добавляя новые роли и работая с ними в QML.

Заключение

ObjectModel является мощным инструментом для управления данными в QML. Его простота и гибкость делают его идеальным выбором для многих задач. С помощью ObjectModel можно легко управлять объектами, обновлять данные и добавлять новые элементы в коллекцию, что делает разработку более эффективной и удобной.

Использование QList как модель

Одним из ключевых элементов работы с QList является класс QAbstractListModel, который служит базой для создания пользовательских моделей. Давайте рассмотрим, как можно настроить и использовать эту модель с QList. Мы также разберём различные аспекты, такие как добавление новых элементов, обновление данных и их отображение в пользовательском интерфейсе.

Для начала, нам нужно определить класс, который будет содержать данные, например, информацию о пользователях. Этот класс будет наследовать QObject и использовать свойства для хранения нужных данных:

class Person : public QObject {
Q_OBJECT
Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
public:
Person(QObject* parent = nullptr) : QObject(parent) {}
QString name() const { return m_name; }
void setName(const QString& name) {
if (name != m_name) {
m_name = name;
emit nameChanged();
}
}
signals:
void nameChanged();
private:
QString m_name;
};

Теперь создадим класс, который будет наследовать QAbstractListModel и использовать QList для хранения объектов Person:

class PersonModel : public QAbstractListModel {
Q_OBJECT
public:
enum PersonRoles {
NameRole = Qt::UserRole + 1
};
PersonModel(QObject* parent = nullptr) : QAbstractListModel(parent) {}
int rowCount(const QModelIndex& parent = QModelIndex()) const override {
Q_UNUSED(parent);
return m_persons.size();
}
QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override {
if (!index.isValid() || index.row() >= m_persons.size())
return QVariant();
const Person* person = m_persons.at(index.row());
if (role == NameRole)
return person->name();
return QVariant();
}
QHash roleNames() const override {
QHash roles;
roles[NameRole] = "name";
return roles;
}
void addPerson(Person* person) {
beginInsertRows(QModelIndex(), rowCount(), rowCount());
m_persons.append(person);
endInsertRows();
}
private:
QList m_persons;
};

После определения модели, необходимо зарегистрировать её в контексте QML и установить нужные данные:

qmlRegisterType<PersonModel>("com.example", 1, 0, "PersonModel");
PersonModel model;
model.addPerson(new Person(QString::fromStdString("Alice")));
model.addPerson(new Person(QString::fromStdString("Bob")));
engine.rootContext()->setContextProperty("personModel", &model);

Теперь мы можем использовать модель в QML. Пример кода QML:

import QtQuick 2.15
import QtQuick.Controls 2.15
import com.example 1.0
ApplicationWindow {
visible: true
width: 640
height: 480
title: qsTr("Person List")
ListView {
anchors.fill: parent
model: personModel
delegate: Text {
text: model.name
}
}
}

Этот пример демонстрирует использование QList как модели. Он показывает, как создать и настроить модель, а также как интегрировать её с QML для отображения данных. Применение таких моделей позволяет создавать более гибкие и динамичные интерфейсы.

Установка модели для представления

Когда требуется отобразить динамически изменяемые данные в приложении, важно правильно настроить взаимосвязь между данными и их визуальным представлением. Рассмотрим, как задать источник данных и связать его с элементами пользовательского интерфейса, чтобы обеспечить корректное отображение и обновление информации.

Для начала создадим модель, которая будет предоставлять данные. В качестве примера используем QAbstractListModel, который является базовым классом для создания списочных моделей. Определим роли, по которым будет происходить доступ к данным.

#include <QAbstractListModel>
class PersonModel : public QAbstractListModel {
Q_OBJECT
Q_PROPERTY(int count READ rowCount NOTIFY dataChanged)
public:
enum PersonRoles {
NameRole = Qt::UserRole + 1,
AgeRole
};
PersonModel(QObject *parent = nullptr) : QAbstractListModel(parent) {
// Инициализация данных
}
int rowCount(const QModelIndex &parent = QModelIndex()) const override {
return m_data.count();
}
QVariant data(const QModelIndex &index, int role) const override {
if (!index.isValid())
return QVariant();
const auto &person = m_data[index.row()];
if (role == NameRole)
return person.name;
else if (role == AgeRole)
return person.age;
return QVariant();
}
protected:
QHash roleNames() const override {
QHash roles;
roles[NameRole] = "name";
roles[AgeRole] = "age";
return roles;
}
private:
struct Person {
QString name;
int age;
};
QList m_data;
};

После того как модель определена, нужно зарегистрировать её для использования в QML. Это делается с помощью функции qmlRegisterType в основном файле вашего приложения.

#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include "personmodel.h"
int main(int argc, char *argv[]) {
QGuiApplication app(argc, argv);
qmlRegisterType<PersonModel>("com.example", 1, 0, "PersonModel");
QQmlApplicationEngine engine;
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
return app.exec();
}

Теперь перейдём к QML файлу, где создадим экземпляр модели и свяжем его с элементом списка (ListView).

import QtQuick 2.12
import QtQuick.Controls 2.12
import com.example 1.0
ApplicationWindow {
visible: true
width: 640
height: 480
PersonModel {
id: personModel
}
ListView {
anchors.fill: parent
model: personModel
delegate: Item {
width: parent.width
height: 50
Row {
Text {
text: model.name
}
Text {
text: model.age
}
}
}
}
}

Таким образом, PersonModel является источником данных, который используется в ListView. Данные передаются через роли, определённые в модели, и отображаются в делегатах. При изменении данных в модели dataChanged сигнал автоматически обновит представление, что обеспечивает динамическое обновление интерфейса.

Эти шаги помогут вам грамотно настроить источник данных для отображения и обновления в вашем приложении, используя мощные возможности QML и C++.

Создание и использование C++ моделей

Работа с данными в QML может быть значительно расширена благодаря возможностям использования C++ классов. В данном разделе мы рассмотрим, как создаётся связь между C++ и QML, как передать данные и управлять ими, а также как на практике использовать эти данные в компонентах интерфейса.

Одним из основных компонентов является QAbstractListModel, который обеспечивает взаимодействие C++ и QML. На его основе можно определить собственные классы, содержащие нужные элементы данных.

Рассмотрим пример. Создадим модель, представляющую список людей, где каждый человек имеет имя и цвет.

Шаг 1: Определение C++ класса

Создайте файл person.h с описанием класса человека:

#ifndef PERSON_H
#define PERSON_H
#include <QObject>
#include <QString>
class Person : public QObject {
Q_OBJECT
Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
Q_PROPERTY(QString color READ color WRITE setColor NOTIFY colorChanged)
public:
Person(const QString &name, const QString &color, QObject *parent = nullptr)
: QObject(parent), m_name(name), m_color(color) {}
QString name() const { return m_name; }
void setName(const QString &name) {
if (m_name != name) {
m_name = name;
emit nameChanged();
}
}
QString color() const { return m_color; }
void setColor(const QString &color) {
if (m_color != color) {
m_color = color;
emit colorChanged();
}
}
signals:
void nameChanged();
void colorChanged();
private:
QString m_name;
QString m_color;
};
#endif // PERSON_H

Шаг 2: Создание модели на основе QAbstractListModel

Теперь создадим файл personmodel.h для определения модели:

#ifndef PERSONMODEL_H
#define PERSONMODEL_H
#include <QAbstractListModel>
#include <QVector>
#include "person.h"
class PersonModel : public QAbstractListModel {
Q_OBJECT
public:
enum PersonRoles {
NameRole = Qt::UserRole + 1,
ColorRole
};
PersonModel(QObject *parent = nullptr) : QAbstractListModel(parent) {}
void addPerson(const Person &person) {
beginInsertRows(QModelIndex(), rowCount(), rowCount());
m_people.append(person);
endInsertRows();
}
int rowCount(const QModelIndex &parent = QModelIndex()) const override {
Q_UNUSED(parent);
return m_people.count();
}
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override {
if (index.row() < 0 || index.row() >= m_people.count())
return QVariant();
const Person &person = m_people[index.row()];
if (role == NameRole)
return person.name();
else if (role == ColorRole)
return person.color();
return QVariant();
}
protected:
QHash roleNames() const override {
QHash roles;
roles[NameRole] = "name";
roles[ColorRole] = "color";
return roles;
}
private:
QVector m_people;
};
#endif // PERSONMODEL_H

Шаг 3: Регистрация модели в QML

Для использования созданной модели в QML, необходимо зарегистрировать её в main.cpp:

#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QQmlContext>
#include "personmodel.h"
int main(int argc, char *argv[]) {
QGuiApplication app(argc, argv);
PersonModel model;
model.addPerson(Person("Alice", "red"));
model.addPerson(Person("Bob", "blue"));
QQmlApplicationEngine engine;
engine.rootContext()->setContextProperty("personModel", &model);
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
return app.exec();
}

Шаг 4: Использование модели в QML

Теперь мы можем обратиться к нашей модели в QML файле main.qml:

import QtQuick 2.15
import QtQuick.Controls 2.15
ApplicationWindow {
visible: true
width: 640
height: 480
title: qsTr("Person Model Example")
ListView {
width: parent.width
height: parent.height
model: personModel
delegate: Item {
width: parent.width
height: 50
Row {
spacing: 10
Text { text: model.name }
Rectangle {
width: 20
height: 20
color: model.color
}
}
}
}
}

Вот так, используя связку C++ и QML, можно создать мощные и гибкие приложения. Это предоставляет возможность более глубокой интеграции и управления данными, что особенно важно при создании сложных пользовательских интерфейсов.

Классы C++ в виде моделей для QML

Создание класса C++

Начнем с создания простого класса на C++, который будет использоваться в QML. Допустим, у нас есть класс Person, который хранит информацию о человеке, такую как имя и возраст:

class Person : public QObject {
Q_OBJECT
Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
Q_PROPERTY(int age READ age WRITE setAge NOTIFY ageChanged)
public:
Person(QObject *parent = nullptr) : QObject(parent) {}
QString name() const { return m_name; }
void setName(const QString &name) {
if (name != m_name) {
m_name = name;
emit nameChanged();
}
}
int age() const { return m_age; }
void setAge(int age) {
if (age != m_age) {
m_age = age;
emit ageChanged();
}
}
signals:
void nameChanged();
void ageChanged();
private:
QString m_name;
int m_age;
};

Использование класса в QML

Для того чтобы использовать наш класс в QML, нам нужно зарегистрировать его в контексте QML. Это можно сделать с помощью функции qmlRegisterType:

#include 
#include 
#include 
#include "person.h"
int main(int argc, char *argv[]) {
QGuiApplication app(argc, argv);
qmlRegisterType<Person>("com.example", 1, 0, "Person");
QQmlApplicationEngine engine;
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
return app.exec();
}

Пример QML использования

Теперь мы можем использовать наш класс Person в QML:

import QtQuick 2.15
import com.example 1.0
ApplicationWindow {
visible: true
width: 640
height: 480
Person {
id: person
name: "John Doe"
age: 30
}
Text {
text: "Name: " + person.name + ", Age: " + person.age
anchors.centerIn: parent
}
}

Использование класса C++ в качестве модели данных

Для более сложных случаев, когда требуется представить коллекцию объектов, мы можем создать класс, реализующий QAbstractListModel. Ниже приведен пример такого класса:

class PersonModel : public QAbstractListModel {
Q_OBJECT
public:
enum PersonRoles {
NameRole = Qt::UserRole + 1,
AgeRole
};
PersonModel(QObject *parent = nullptr) : QAbstractListModel(parent) {}
void addPerson(const Person &person) {
beginInsertRows(QModelIndex(), rowCount(), rowCount());
m_persons << person;
endInsertRows();
}
int rowCount(const QModelIndex &parent = QModelIndex()) const override {
Q_UNUSED(parent);
return m_persons.count();
}
QVariant data(const QModelIndex &index, int role) const override {
if (index.row() < 0 || index.row() >= m_persons.count())
return QVariant();
const Person &person = m_persons[index.row()];
if (role == NameRole)
return person.name();
else if (role == AgeRole)
return person.age();
return QVariant();
}
protected:
QHash roleNames() const override {
QHash roles;
roles[NameRole] = "name";
roles[AgeRole] = "age";
return roles;
}
private:
QList<Person> m_persons;
};

Пример использования модели данных в QML

Теперь мы можем использовать наш класс PersonModel в QML:

import QtQuick 2.15
import com.example 1.0
ApplicationWindow {
visible: true
width: 640
height: 480
ListView {
width: parent.width
height: parent.height
model: personModel
delegate: Item {
width: parent.width
height: 50
Row {
Text { text: name }
Text { text: " (" + age + ")" }
}
}
}
}

Таким образом, мы можем использовать классы C++ для создания мощных и гибких моделей данных, которые легко интегрируются в QML интерфейсы. Это открывает множество возможностей для создания сложных и интерактивных приложений.

Ключевое слово	Описание
QAbstractListModel	Базовый класс для создания моделей, которые представляют данные в виде списка.
Q_PROPERTY	Макрос для объявления свойств в классах C++, которые могут быть использованы в QML.
Q_INVOKABLE	Макрос, который позволяет методу быть вызываемым из QML.

Переход от QList к QQmlListProperty

В данном разделе мы рассмотрим процесс перехода от использования стандартного QList в Qt к использованию более мощного и адаптированного для QML инструмента – QQmlListProperty. Этот шаг не только расширяет возможности работы с данными в QML, но и упрощает интеграцию объектных моделей с динамическими представлениями пользовательского интерфейса.

Начнем с понимания основных различий между QList и QQmlListProperty. В то время как QList предназначен для хранения объектов определенного типа и обеспечивает базовые операции над коллекциями, QQmlListProperty добавляет контекстное понимание и интеграцию с QML. Это позволяет нам работать не только с объектами, но и с их связями в контексте модели-представления.

Одним из ключевых моментов при использовании QQmlListProperty является его способность работать с QObjects и учитывать их контекстные зависимости. Таким образом, в QML мы можем устанавливать связи между объектами, что облегчает динамическое изменение данных и поведения на уровне пользовательского интерфейса.

Для иллюстрации этого принципа рассмотрим пример использования QList для хранения объектов класса QObject. После этого мы пошагово преобразуем код к использованию QQmlListProperty, демонстрируя возможность установки связей между объектами и контекстное изменение данных в QML. Таким образом, мы сможем полностью оценить преимущества данного подхода.

Видео:

Qt - Модель/представление часть 1