Trait slint::Model

pub trait Model {
    type Data;

    // Required methods
    fn row_count(&self) -> usize;
    fn row_data(&self, row: usize) -> Option<Self::Data>;
    fn model_tracker(&self) -> &dyn ModelTracker;

    // Provided methods
    fn set_row_data(&self, _row: usize, _data: Self::Data) { ... }
    fn iter(&self) -> ModelIterator<'_, Self::Data> 
       where Self: Sized { ... }
    fn as_any(&self) -> &(dyn Any + 'static) { ... }
}
Expand description

A Model is providing Data for the Repeater or ListView elements of the .slint language

If the model can be changed, the type implementing the Model trait should holds a ModelNotify, and is responsible to call functions on it to let the UI know that something has changed.

Example

As an example, let’s see the implementation of VecModel.

pub struct VecModel<T> {
    // the backing data, stored in a `RefCell` as this model can be modified
    array: std::cell::RefCell<Vec<T>>,
    // the ModelNotify will allow to notify the UI that the model changes
    notify: ModelNotify,
}

impl<T: Clone + 'static> Model for VecModel<T> {
    type Data = T;

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

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

    fn set_row_data(&self, row: usize, data: Self::Data) {
        self.array.borrow_mut()[row] = data;
        // don't forget to call row_changed
        self.notify.row_changed(row);
    }

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

    fn as_any(&self) -> &dyn core::any::Any {
        // a typical implementation just return `self`
        self
    }
}

// when modifying the model, we call the corresponding function in
// the ModelNotify
impl<T> VecModel<T> {
    /// Add a row at the end of the model
    pub fn push(&self, value: T) {
        self.array.borrow_mut().push(value);
        self.notify.row_added(self.array.borrow().len() - 1, 1)
    }

    /// Remove the row at the given index from the model
    pub fn remove(&self, index: usize) {
        self.array.borrow_mut().remove(index);
        self.notify.row_removed(index, 1)
    }
}

Required Associated Types§

type Data

The model data: A model is a set of row and each row has this data

Required Methods§

fn row_count(&self) -> usize

The amount of row in the model

fn row_data(&self, row: usize) -> Option<Self::Data>

Returns the data for a particular row. This function should be called with row < row_count().

This function does not register dependencies on the current binding. For an equivalent function that tracks dependencies, see ModelExt::row_data_tracked

fn model_tracker(&self) -> &dyn ModelTracker

The implementation should return a reference to its ModelNotify field.

You can return &() if you your Model is constant and does not have a ModelNotify field.

Provided Methods§

fn set_row_data(&self, _row: usize, _data: Self::Data)

Sets the data for a particular row.

This function should be called with row < row_count(), otherwise the implementation can panic.

If the model cannot support data changes, then it is ok to do nothing. The default implementation will print a warning to stderr.

If the model can update the data, it should also call ModelNotify::row_changed on its internal ModelNotify.

fn iter(&self) -> ModelIterator<'_, Self::Data> where Self: Sized,

Returns an iterator visiting all elements of the model.

fn as_any(&self) -> &(dyn Any + 'static)

Return something that can be downcast’ed (typically self)

This is useful to get back to the actual model from a ModelRc stored in a component.

let handle = ModelRc::new(VecModel::from(vec![1i32, 2, 3]));
// later:
handle.as_any().downcast_ref::<VecModel<i32>>().unwrap().push(4);
assert_eq!(handle.row_data(3).unwrap(), 4);

Note: the default implementation returns nothing interesting. this method should be implemented by model implementation to return something useful. For example:

fn as_any(&self) -> &dyn core::any::Any { self }

Implementations on Foreign Types§

§

impl Model for usize

§

type Data = i32

§

fn row_count(&self) -> usize

§

fn row_data(&self, row: usize) -> Option<<usize as Model>::Data>

§

fn as_any(&self) -> &(dyn Any + 'static)

§

fn model_tracker(&self) -> &dyn ModelTracker

§

impl Model for bool

§

type Data = ()

§

fn row_count(&self) -> usize

§

fn row_data(&self, row: usize) -> Option<<bool as Model>::Data>

§

fn as_any(&self) -> &(dyn Any + 'static)

§

fn model_tracker(&self) -> &dyn ModelTracker

§

impl<M> Model for Rc<M>where M: Model,

§

type Data = <M as Model>::Data

§

fn row_count(&self) -> usize

§

fn row_data(&self, row: usize) -> Option<<Rc<M> as Model>::Data>

§

fn model_tracker(&self) -> &dyn ModelTracker

§

fn as_any(&self) -> &(dyn Any + 'static)

§

fn set_row_data(&self, row: usize, data: <Rc<M> as Model>::Data)

Implementors§

§

impl<M, F> Model for FilterModel<M, F>where M: Model + 'static, F: Fn(&<M as Model>::Data) -> bool + 'static,

§

type Data = <M as Model>::Data

§

impl<M, F, T, U> Model for MapModel<M, F>where M: 'static + Model<Data = T>, F: 'static + Fn(T) -> U,

§

type Data = U

§

impl<M, S> Model for SortModel<M, S>where M: Model + 'static, S: SortHelper<<M as Model>::Data>,

§

type Data = <M as Model>::Data

§

impl<T> Model for ModelRc<T>

§

type Data = T

§

impl<T> Model for VecModel<T>where T: Clone + 'static,

§

type Data = T

§

impl<T> Model for SharedVectorModel<T>where T: Clone + 'static,

§

type Data = T