Struct slint::ReverseModel

pub struct ReverseModel<M>(/* private fields */)
where
    M: Model + 'static;

Provides a reversed view of another Model.

When the other Model is updated, the ReverseModel is updated accordingly.

Generic parameters:

• M the type of the wrapped Model.

Example

Here we have a VecModel holding crate::SharedStrings. It is then reversed into a ReverseModel.

let model = VecModel::from(vec![
    SharedString::from("Lorem"),
    SharedString::from("ipsum"),
    SharedString::from("dolor"),
]);

let reverse_model = ReverseModel::new(model);

assert_eq!(reverse_model.row_data(0).unwrap(), SharedString::from("dolor"));
assert_eq!(reverse_model.row_data(1).unwrap(), SharedString::from("ipsum"));
assert_eq!(reverse_model.row_data(2).unwrap(), SharedString::from("Lorem"));

Alternatively you can use the shortcut ModelExt::reverse.

let reverse_model = VecModel::from(vec![
    SharedString::from("Lorem"),
    SharedString::from("ipsum"),
    SharedString::from("dolor"),
]).reverse();
assert_eq!(reverse_model.row_data(0).unwrap(), SharedString::from("dolor"));
assert_eq!(reverse_model.row_data(1).unwrap(), SharedString::from("ipsum"));
assert_eq!(reverse_model.row_data(2).unwrap(), SharedString::from("Lorem"));

If you want to modify the underlying VecModel you can give the ReverseModel a Rc of it:

let model = Rc::new(VecModel::from(vec![
    SharedString::from("Lorem"),
    SharedString::from("ipsum"),
    SharedString::from("dolor"),
]));

let reverse_model = ReverseModel::new(model.clone());

assert_eq!(reverse_model.row_data(0).unwrap(), SharedString::from("dolor"));
assert_eq!(reverse_model.row_data(1).unwrap(), SharedString::from("ipsum"));
assert_eq!(reverse_model.row_data(2).unwrap(), SharedString::from("Lorem"));

model.push(SharedString::from("opsom"));

assert_eq!(reverse_model.row_data(0).unwrap(), SharedString::from("opsom"));
assert_eq!(reverse_model.row_data(1).unwrap(), SharedString::from("dolor"));
assert_eq!(reverse_model.row_data(2).unwrap(), SharedString::from("ipsum"));
assert_eq!(reverse_model.row_data(3).unwrap(), SharedString::from("Lorem"));

Implementations

impl<M> ReverseModel<M>

where M: Model + 'static,

pub fn new(wrapped_model: M) -> ReverseModel<M>

Creates a new ReverseModel based on the given wrapped_model. Alternatively you can use ModelExt::reverse on your Model.

pub fn source_model(&self) -> &M

Returns a reference to the inner model

Trait Implementations

impl<M> Model for ReverseModel<M>

where M: Model + 'static,

type Data = <M as Model>::Data

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

fn row_count(&self) -> usize

The amount of row in the model

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

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

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

Sets the data for a particular row.

fn model_tracker(&self) -> &dyn ModelTracker

The implementation should return a reference to its ModelNotify field.

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

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

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

where Self: Sized,

Returns an iterator visiting all elements of the model.