example 7guis/cells.slint with slint_interpreter

[oheil]

In the 7guis/cells.slint example, the property

in property <[[CellContent]]> cells;

is defined representing the grid of cells.
Implicitly defined for this property is function

main_window.set_cells(ModelRc::from(cells_model));

called in main of 7guis/cells.rs to connect the Model definition with the data of the cells.

Is there a way to do this without knowing the implicit defined name of the set_ function, set_cells in this case, through the slint_interpreter api ?

I was hoping for something like

let model = CellsModel::new();
let _ = instance.unwrap().set_property("cells", model);
// or like
// let _ = instance.unwrap().set_property("cells", Value::Model(model));

but I can't get over type problems with Value expected by set_property.
https://slint.dev/releases/1.3.2/docs/rust/slint_interpreter/struct.ComponentInstance#method.set_property
So I came to the insight, that I am on the wrong track.

I try to use Slint through a rust C-api library where those implicit set_<property> setters are not known at compile time of the rust library.

[ogoffart]

What exact error do you get when using set_property("cells", Value::Model(model));

Note that the Model needs to be backed by a dyn Model<Value> whose Value are themselves Value::Model that are backed by a dyn Model<Value> which are themselves Value::Struct that contains a "value" and "formula" keys.

[oheil]

the Model needs to be backed by a dyn Model whose Value are themselves Value::Model that are backed by a dyn Model which are themselves Value::Struct that contains a "value" and "formula" keys

I can't translate this into code :-(
All examples at https://slint.dev/releases/1.3.2/docs/rust/slint/ are for the generated setter, but it seems, I need an example for the set_property("cells", Value::Model(model)) path.

[ogoffart]

The Value::Model expect a dyn Model<Value>

So like so: (untested)

impl Model for CellsModel {
    type Data = Value;  // Data is Value

    fn row_count(&self) -> usize {
        self.rows.len()
    }

    fn row_data(&self, row: usize) -> Option<Self::Data> {
        // maps the data to a Value
        self.rows.get(row).map(|x| Value::Model(ModelRc::new(x.clone())))
    }

    fn model_tracker(&self) -> &dyn ModelTracker {
        &()
    }
}

Same for the inner mode:

impl Model for RowModel {
    type Data = Value; // again, Data must be Value

    fn row_count(&self) -> usize {
        self.row_elements.borrow().len()
    }

    fn row_data(&self, row: usize) -> Option<Self::Data> {
        // And map to a Value that is a struct
        self.row_elements.borrow().get(row).map(|row| {
             let stru = slint_interpreter::Struct::default();
             stru.set_field("value".into(), Value::Number(row.parse().unwrap_or(0.)));
             stru.set_field("forumula".into(), Value::String(row.into()));
             stru.into();
        }). 
     }

    fn model_tracker(&self) -> &dyn ModelTracker {
        &self.notify
    }

    fn set_row_data(&self, index: usize, data: CellContent) {
        if let Some(cells) = self.base_model.upgrade() {
        }
    }
}

I hope this helps.

Note that I haven't tested this code.
Please paste the error message if it fails.

[oheil]

Awesome, thanks a lot.
It needed some tweaks to make it compile (expected as you said untested) and for the sake of simplicity I want to restrict the cell contents to strings for now, so this is the compiling code, yet not fully functional but at least compiling:

use slint::{Model, ModelRc, ModelTracker, ModelNotify};
use std::cell::RefCell;
use std::rc::Rc;

#[derive(Clone)]
struct CellContent  { 
    value: String,
}
impl Default for CellContent {
    fn default() -> CellContent {
        CellContent{
            //value: String::from("")
            value: String::from("xxx")
        }
    }
}

struct CellsModel {
    rows: Vec<Rc<RowModel>>,
}

impl Model for CellsModel {
    type Data = Value;  // Data is Value

    fn row_count(&self) -> usize {
        self.rows.len()
    }

    fn row_data(&self, row: usize) -> Option<Self::Data> {
        // maps the data to a Value
        self.rows.get(row).map(|x| Value::Model(ModelRc::new(x.clone())))
    }

    fn model_tracker(&self) -> &dyn ModelTracker {
        &()
    }
}

impl CellsModel {
    fn new(nrows: usize, ncols: usize) -> Rc<Self> {
        Rc::new_cyclic(|w| Self {
            rows: (0..(nrows-1))
                .map(|row| {
                    Rc::new(RowModel {
                        row,
                        row_elements: vec![CellContent::default(); ncols].into(),
                        base_model: w.clone(),
                        notify: Default::default(),
                    })
                })
                .collect(),
        })
    }
}

struct RowModel {
    row: usize,
    row_elements: RefCell<Vec<CellContent>>,
    base_model: std::rc::Weak<CellsModel>,
    notify: ModelNotify,
}

impl Model for RowModel {
    type Data = Value; // again, Data must be Value

    fn row_count(&self) -> usize {
        self.row_elements.borrow().len()
    }

    fn row_data(&self, row: usize) -> Option<Self::Data> {
        // And map to a Value that is a struct
        self.row_elements.borrow().get(row).map(|row| {
             let mut stru = slint_interpreter::Struct::default();
             stru.set_field("value".into(), Value::String(row.value.clone().into()));
             //stru.set_field("formula".into(), Value::String(row.into()));
             stru.into()
        }) 
     }

    fn model_tracker(&self) -> &dyn ModelTracker {
        &self.notify
    }

    fn set_row_data(&self, index: usize, data: Value) {
        if let Some(cells) = self.base_model.upgrade() {
        }
    }
}

and setting/using the model:

let model = CellsModel::new(rows as usize,cols as usize);
let _ = instance.unwrap().set_property("cells",Value::Model(model.clone().into()));

Thanks again for your effort!

[oheil]

My code is more or less copy/pasted from the cells.rs example. This is what I have now (last version of trials):

modified code

use slint::{Model, ModelRc, ModelTracker, ModelNotify};
use std::cell::RefCell;
use std::rc::Rc;

#[derive(Clone)]
struct CellContent  { 
    value: String,
}
impl Default for CellContent {
    fn default() -> CellContent {
        CellContent{
            //value: String::from("")
            value: String::from("xxx")
        }
    }
}

struct CellsModel {
    rows: Vec<Rc<RowModel>>,
}

struct RowModel {
    row: usize,
    row_elements: RefCell<Vec<CellContent>>,
    base_model: std::rc::Weak<CellsModel>,
    notify: ModelNotify,
}

impl Model for RowModel {
    type Data = CellContent;

    fn row_count(&self) -> usize {
        self.row_elements.borrow().len()
    }

    fn row_data(&self, row: usize) -> Option<Self::Data> {
        self.row_elements.borrow().get(row).cloned()
    }

    fn model_tracker(&self) -> &dyn ModelTracker {
        &self.notify
    }

    fn set_row_data(&self, index: usize, data: CellContent) {
        if let Some(cells) = self.base_model.upgrade() {
        }
    }
}

impl Model for CellsModel {
    type Data = ModelRc<CellContent>;

    fn row_count(&self) -> usize {
        self.rows.len()
    }

    fn row_data(&self, row: usize) -> Option<Self::Data> {
        self.rows.get(row).map(|x| x.clone().into())
    }

    fn model_tracker(&self) -> &dyn ModelTracker {
        &()
    }
}

impl CellsModel {
    fn new(nrows: usize, ncols: usize) -> Rc<Self> {
        Rc::new_cyclic(|w| Self {
            rows: (0..(nrows-1))
                .map(|row| {
                    Rc::new(RowModel {
                        row,
                        row_elements: vec![CellContent::default(); ncols].into(),
                        base_model: w.clone(),
                        notify: Default::default(),
                    })
                })
                .collect(),
        })
    }
}

The compiler gives me the following error when I try to

let model = CellsModel::new(rows as usize, cols as usize);
let _ = instance.unwrap().set_property("cells",Value::Model(model));

=>

error[E0308]: mismatched types
   --> src\lib.rs:353:73
    |
353 |             let _ = instance.unwrap().set_property("cells",Value::Model(model));
    |                                                            ------------ ^^^^^ expected `ModelRc<Value>`, found `Rc<CellsModel>`
    |                                                            |
    |                                                            arguments to this enum variant are incorrect
    |
    = note: expected struct `ModelRc<slint_interpreter::Value>`
               found struct `Rc<CellsModel>`
note: tuple variant defined here

I have read your hint, but I need some time to think about it and what it means in code (still very new to rust and Slint). For now it sounds as that I am not completely wrong with my attempt.

Wish you a Happy New Year !