Explicitly changing the Slint's slint::Model<> to slint::VectorModel<> in C++

[allankoechke]

Looking at the memory game shipped as part of the Slint examples for C++, we have the model defined as follows;

in property <[TileData]> memory-tiles : [
        { image: @image-url("icons/at.png") },
        ... others
    ];

On the C++ side, we create a shared slint::VectorModel<> and populate the model. However, in cases where the callback in this case, ui->on_check-if-pair-solved(...); which is handled in C++, needs to add new items to the model, I assume the native way would be to just invoke model->push_back(...) which fails because the model in this context is the default slint::Model<>() instead of slint::VectorModel<>() which was set earlier in the setup.

int main()
{
    auto main_window = MainWindow::create();
    auto old_tiles = main_window->get_memory_tiles();
    std::vector<TileData> new_tiles;
    // ... other code
    auto tiles_model = std::make_shared<slint::VectorModel<TileData>>(new_tiles);
    main_window->set_memory_tiles(tiles_model);
    
    tiles_model->push_back(TileData());         // Here push_back works

    main_window->on_check_if_pair_solved(
            [main_window_weak = slint::ComponentWeakHandle(main_window)] {
                auto main_window = *main_window_weak.lock();
                auto tiles_model = main_window->get_memory_tiles();
                
                tiles_model->push_back(TileData());     // error C2039: 'push_back': is not a member of 'slint::Model<Ti
leData>'

                // ... other code
            });

    // .. other code
}

Is there a way to explicitly set the slint model to always be a VectorModel or convert the model to VectorModel? Or what's the preferred approach to avoiding creating a new VectorModel in every callback call, and copying the data over just to invoke the vector's push_back function to add new items?

[tronical]

I see two options:

1. You share the model upfront. So in the above C++ code that would mean not calling auto tiles_model = main_window->get_memory_tiles(); in the callback, but instead adding a copy of the original tiles_model that has the type std::shared_ptr<slint::VectorModel<TileData>> into the callback's closure as captured variable (by value).
2. If you know that the model is a vector model, I think that you could cast it: auto tiles_model = static_cast<std::shared_ptr<slint::VectorModel<TileData>>>(main_window->get_memory_tiles());.

[allankoechke]

Option (1) works fine, option (2) doesnt seem to work. This throws an error on MSVC that we cant static_cast to VectorModel

[ubruhin]

@allankoechke You need std::dynamic_pointer_cast:

 auto tiles_model = std::dynamic_pointer_cast<slint::VectorModel<TileData>>(main_window->get_memory_tiles());

[allankoechke]

@ubruhin I could get the dynamic pointer cast to do the trick. The resultant pointer is NULL, signalling an invalid cast.

std::cout << "Cart Model: " << ui->get_cart_model() << std::endl;

auto listModel = std::dynamic_pointer_cast<slint::VectorModel<CartData>>(ui->get_cart_model());

std::cout << "Cart Model Dyn: " << listModel << std::endl;

 if(listModel) {
    std::cout << listModel << "\tVector Model created successfully!\n";
} else {
    std::cout << listModel << "\tVector Model was not created!\n";
 }