Best way to add a row to a StandardTableVie or StandardListView?

[Tsuiban]

I've been trying add a row to a StandardTableView, though this applies to a StandardListView as well, basically trying to do the equivalent of a my_vector.push(new_row). Unfortunately, there doesn't seem to be a way to do it. Here's what I've come up with:

// Return a new model that contains the original model plus the new row.
fn add_row(current_model : &ModleRc<ModelRc<StandardListViewItem>>,
                   new_row : &ModelRc<StandardListViewItem>)
                    -> ModelRc<ModelRc<StandardListViewItem> {
    let new_model = ModelRc::from([new_row]);
    let original_model_iter = current_model.iter();
    let new_model_iter = new_model.iter();
    let all_iter = original_model_iter.chain(new_model_iter);
    let all_iter_vec : Vec<ModelRc<StandardListViewItem>> = all_iter.collect();
    ModelRc::from(all_iter_vec.as_slice())
}

Elsewhere in my rust code

   ui.do_add_row({
      let ui_weak = ui.as_weak();
      { move || {
         let ui = ui_weak.unwrap();
         let original_rows = ui.get_rows_data_property();
         let new_row = construct_new_row();
         let new_model = add_row(&original_rows, &new_row);
         ui.set_rows_data_property(new_model);
      }
   });

In my appwindow.slint code

export component AppWindow inherits Window {
   in-out property <[[StandardListViewItem]]> rows-data-property;
   callback add-row;

   StandardTableView {
      columns: [{ title: "Column 1" }, { title: "Column 2"}, ];
      rows: roster-rows;
   }
   Button {
      text: "Add Row";
      clicked => { root.add-row(); }
   }
}

Replacing the entire model seems to be the only way to add a row? This seems somewhat awkward.

[bjorn]

It looks like you'll want to use VecModel::push instead, which is for adding a new row to your model.

To get the VecModel<StandardListViewItem> from your ModelRc<StandardListViewItem> you would need to cast it (unless you kept a reference to the original model on the Rust side). See the code snippet at Model::as_any.

[latot]

Hi! I'm falling on this, would be nice be able to have some examples about how to this better.

[antis81]

I tried writing a minimal example project in Rust using StandardTableView and I think what makes it difficult is the two dimensional ModelRc type on the rows property (ModelRc<ModelRc<StandardListViewItem>>).

Working with VecModel the backend code would be simiilar to this:

let ui = App::create();  // instance to slint main window
let mut VecModel<VecModel<StandardListViewItem> model;

// I couldn't find a (simple) way to get a valid RC
let model_rc = ModelRc::new(model);    // <--- This will return ModelRc<VecModel<StandardListViewItem>>
ui.set_rows_data_property(model_rc);   //        Then this fails

The StandardTableView component is very limited and it is quite simple to replace it with a ListView and delegates for such use case. With that what @bjorn wrote applies and VecModel::push can be used…

[bjorn]

I've updated my links to the latest docs, especially Model::as_any docs were expanded with some troubleshooting help. Nothing about StandardTableView specifically though. I haven't personally needed to add rows to a StandardTableView, but if you want to set up a new one this is the code that worked for me when I was still using StandardTableView in my application:

https://github.com/bjorn/raccoin/blob/e0cefae031bcee8d8ecbb77c4c3042e710e6c184/src/main.rs#L364-L394

(gains is the data which is eventually set as the rows of a StandardTableView)

[antis81]

Thank you @bjorn - here is a little example for StandardTableView:

import { StandardTableView, VerticalBox, Button } from "std-widgets.slint";

export component Example inherits Window {
    preferred-height: 300px;
    preferred-width: 300px;

    in-out property <[[StandardListViewItem]]> table-data;
    callback add-row();

    VerticalBox {
        table := StandardTableView {
            columns: [
                { title: "Column 1" },
                { title: "Column 2" },
            ];
            // NOTE: rows are managed by the backend
            rows: table-data;
        }

        Button {
            text: "Add row";
            clicked => {
                add-row();
            }
        }
    }
}

And the rust part

use slint::{ModelRc, StandardListViewItem, VecModel};
use std::rc::Rc;

slint::include_modules!();

fn main() {
    let ui = Example::new().unwrap();
    let table_vec: Vec<ModelRc<StandardListViewItem>> = vec![];
    let table_model = Rc::new(VecModel::from(table_vec));

    ui.set_table_data(table_model.to_owned().into());
    ui.on_add_row({
        move || {
            table_model.push(VecModel::from_slice(&[
                StandardListViewItem::from("<new>"),
                StandardListViewItem::from("<new>"),
            ]));
        }
    });

    ui.run().unwrap();
}

[latot]

Thx all! I'm new in the gui part, so at first I did not know Rc must be used to access the elements.
Nice examples!