Implement type for ListView

[realroot2185]

The ListView's items are now implemented as QML file.
Currently the ListView's item are another ListView.

import QtQuick

Item {
    id: config

    //Inner ListView
    Item {
        id: w001
        property bool defAutomatic: true
        property int sets: 1
        property string woName: "30 seconds"
        property bool initPrep: true

        property int exTotal: w001timers.count
        property alias timers: w001timers
        property int setTotal: w001timers.setTotal
        property int woTotal: w001timers.woTotal

        ListModel {
            id: w001timers
            property int sets: w001.sets
            property string woName: w001.woName
            property bool initPrep: w001.initPrep
            property int setTotal: {
                for (var i = 0; i < count; i++) {
                    setTotal += get(i).countdownValue;
                }
            }
            property int woTotal: setTotal * sets

            ListElement {
                automatic: true
                countdownValue: 30
                timerName: "go"
                prepare: false
            }
        }
    }
    Item {
        id: w002 
        [...]

[ahayzen-kdab]

I'm unsure what you are asking for in Rust code ? Could you try to explain the steps you want to achieve with CXX-Qt ?

I think you might be asking about either nesting QObjects in Rust ( https://github.com/KDAB/cxx-qt/blob/main/examples/qml_features/rust/src/nested_qobjects.rs ) or referring to external Qt types in Rust ( https://github.com/KDAB/cxx-qt/blob/main/examples/qml_features/rust/src/externcxxqt.rs ).

[ahayzen-kdab]

To create the ListModel in C++/Rust you should create a C++ QObject and derive from QAbstractListModel ( https://doc.qt.io/qt-6/qabstractlistmodel.html ) see this example for an example in CXX-Qt where it implements the required methods of the abstract class (eg data, rowCount, roleNames etc) https://github.com/KDAB/cxx-qt/blob/main/examples/qml_features/rust/src/custom_base_class.rs

You could also have properties on this model too.

Then this would become w001timers eg

MyRustModel {
   id: w001timers
}

[realroot2185]

How implement the items of ListModel?

    unsafe extern "RustQt" {
        #[qobject]
        #[base = "QAbstractListModel"]
        #[qml_element]
        #[qproperty(State, state)]
        #[qproperty(QString, name )]
        #[qproperty(i32, sets)]
        #[qproperty(bool, defAutomatic)]
        #[qproperty(bool, initPrep)]
        type MyType = super::MyTypeRust;
    }

Do I add a QVector<OtherClass> that I use in data to retrieve values?

Where OtherClass is the corresponding version of

          ListElement {
                automatic: true
                countdownValue: 30
                timerName: "go"
                prepare: false
            }

[LeonMatthesKDAB]

You can represent the items of the listmodel however you like, using any Rust data structures.

QVector would be one way to go about it, but using Rusts Vec is probably easier to use.
You will have to implement the methods required by QAbstractListModel so that QML can access the values inside the model.
This is unfortunately a bit more complicated than the QML ListModel, but that's the Qt API we have to work with.
See the documentation that @ahayzen-kdab linked earlier.

I hope that helps.

[realroot2185]

I added a new struct but values are never read:

#[derive(Default)]
pub struct OtherType {
    automatic: bool,
    countdownvalue: i32,
    name: String,
    prepare: bool,
}

/// A struct which inherits from QAbstractListModel
#[derive(Default)]
pub struct MyTypeRust {
    state: qobject::State,
    pending_adds: i32,
    name: QString,
    sets: i32,
    defAutomatic: bool,
    initPrep: bool,
    exercises: Vec<Exercise>,
    
    pub(crate) id: u32,
    pub(crate) vector: Vec<(u32, f64)>,
}

warning: fields `automatic`, `countdownvalue`, `name`, and `prepare` are never read
   --> src/cxxqt_object.rs:222:5
    |
221 | pub struct OtherType {
    |            -------- fields in this struct

As before I cannot call set_sets:
main.qml:119: TypeError: Property 'set_sets' of object MyType(0x588baa6a5cb0) is not a function

Initially the ListView is empty, when I add an item sets shows as undefined.

Do I need to change Value?

    enum Roles {
        /// The index of the row
        Id,
        /// The value of the row
        Value,
    }

I am not sure to how make the properties of MyTypeRust available.
data returns a QVariant::from(value).

[ahayzen-kdab]

The fields you are adding like sets would need #[qproperty(i32, sets)] on the type MyType = super::MyTypeRust; for them to appear as Q_PROPERTYs to Qt and have getters and setters. But note these are just properties of the QObject/QAbstractListModel, these are not roles or fields within each row.

For the data in each row of the model these are returned via the data invokable which overrides the virtual method on the base class QAbstractListModel

        #[qinvokable]
        #[cxx_override]
        fn data(self: &CustomBaseClass, index: &QModelIndex, role: i32) -> QVariant;

Then the implementation of this takes the index (which contains the row information) and the role which it is returning, eg the Id or Value.

    pub fn data(&self, index: &QModelIndex, role: i32) -> QVariant {
        let role = qobject::Roles { repr: role };
        if let Some((id, value)) = self.vector.get(index.row() as usize) {
            return match role {
                qobject::Roles::Id => QVariant::from(id),
                qobject::Roles::Value => QVariant::from(value),
                _ => QVariant::default(),
            };
        }

        QVariant::default()
    }

In QML these can be used inside the delegate of eg a ListView by using model.id and model.value as defined in the roles_names method that again overrides the virtual base class method. Here we can see the mapping between enums and string names that are used in QML.

    pub fn role_names(&self) -> QHash<QHashPair_i32_QByteArray> {
        let mut roles = QHash::<QHashPair_i32_QByteArray>::default();
        roles.insert(qobject::Roles::Id.repr, QByteArray::from("id"));
        roles.insert(qobject::Roles::Value.repr, QByteArray::from("value"));
        roles
    }

So you either need to expose the fields as properties of the QObject (but these are then not per row), or you need to move the values inside the vector and then return the relevant row in the data method and ensure that any new roles are added to the enum and matched up in the role names.

If you aren't familiar with how abstract models work in Qt maybe have a read of their examples or there are various videos on our youtube channel about how they work with QML. Once familiar with how this works in C++ I think the Rust implementation will be more obvious as it's very similar.
https://doc.qt.io/qt-6/qtquick-modelviewsdata-cppmodels.html
https://www.youtube.com/watch?v=VIF3cl-LI2E