Model of Models

[Finkman]

Hi everyone!

I created a widget that visualize a struct

export struct CompModel{
  type: string,
  compId: int,
  enabled: bool,
  state: MachineState,
  availableInRepo:bool,
  modelConnected: bool
}

In my application, I have a number of CompModel which are setup at run-time, cause I don't know statically.
For this, I use a list of CompModels:

in property <[CompModel]> models

In my c++ code I create a slint::VectorModel< ui::CompModel >, assign it to the model property ui->global< ui::Components >().set_models( models_ ); and add various number of that models. Fine so far.

But I need to modify - let's say - the CompModel::enabled and want the ui to follow.
How to achieve this? I am unaware how to create a struct with fields like properties to which the ui can bind.

Help highly appreciated. Thanks

[hunger]

It's bindings all the way down:-)

If you change a CompModel::enabled then that is a property and triggers a recalculation of any other property using it.

If you delete/recreate an entire CompModel, the entire UI of that particular model will be recreated, resetting that bit of UI to its initial state.

I am using models of models in tools/lsp/preview/ui.rs, maybe you can take a peek there.

[Finkman]

Thanks for the reply.
I cannot follow in detail.
When I

modelVec_->push_back( compModel_ );

then the UI updates. Fine! But compModel_ is gone. push_back copies my model:

    /// from slint.h
    /// Append a new row with the given value
    void push_back(const ModelData &value)
    {
        data.push_back(value);
        this->row_added(data.size() - 1, 1);
    }

Unfortunately, push_back does not return a reference to it (would be a nice Feature Request), so I was looking for a getter:

auto inserted = modelVec_->row_data(index);

But this is a copy, again.

    /// from slint.h
    std::optional<ModelData> row_data(size_t i) const override
    {
        if (i >= row_count())
            return {};
        return std::optional<ModelData> { data[i] };
    }

So... no chance to manipulate the element with type ModelData=CompModel.

Beside this,... I cannot even believe that it could be possible, because slint generates CompModel with primitive types. In case of enabled it is bool, which means, there is no possibility an event could be emitted from that place.

// generated class
    class CompModel {
        public:
        slint::SharedString type;
        int compId;
        bool enabled;
        MachineState state;
        bool availableInRepo;
        bool modelConnected;
        friend auto operator== (const class CompModel &a, const class CompModel &b) -> bool = default;
    };

Am I missing something?

Please mind: I am using c++ not rust. Maybe in rust, the struct is something smarter.

[tronical]

As you have noticed, generated CompModel structure has only fields with the directly used types, so changing enabled for example implies no way of finding out that it changed. The barrier of notification here is not the structure but the model, or specifically the model's row the particular CompModel is in.

If the entire row or just an individual field of the struct changes, the model needs know that the row changed, in order to notify the UI (or view in MVC terms) that it may (or may not) need updating.

If you'r using VectorModel, the pattern would be like this:

auto comp_model = *model->row_data(3);
comp_model.enabled = ...;
model->set_row_data(3, comp_model);

The last call will notify the view.

The other that you have is to sub-class slint::Model and implement your own model, and consequently call the protected slint::Model::row_changed() function.

[Finkman]

I thought this is a common usage of the framework. Could anyone give me a hint?