Struct slint::FilterModel

pub struct FilterModel<M, F>(_)
where
         M: Model + 'static,
         F: Fn(&<M as Model>::Data) -> bool + 'static;

Provides a filtered subset of rows by another Model.

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

Generic parameters:

• M the type of the wrapped Model.
• F the filter function.

Example

Here we have a VecModel holding crate::SharedStrings. It is then filtered into a FilterModel.

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

let filtered_model = FilterModel::new(model, |s| s.contains('o'));

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

Alternatively you can use the shortcut ModelExt::filter.

let filtered_model = VecModel::from(vec![
    SharedString::from("Lorem"),
    SharedString::from("ipsum"),
    SharedString::from("dolor"),
]).filter(|s| s.contains('o'));

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

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

let filtered_model = FilterModel::new(model.clone(), |s| s.contains('o'));

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

model.set_row_data(1, SharedString::from("opsom"));

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

Implementations

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

pub fn new(wrapped_model: M, filter_function: F) -> FilterModel<M, F>

Creates a new FilterModel based on the given wrapped_model and filtered by filter_function. Alternativly you can use ModelExt::filter on your Model.

pub fn apply_filter(&self)

👎Deprecated: Use reset() instead

Manually reapply the filter. You need to run this e.g. if the filtering function depends on mutable state and it has changed. This method is deprecated use reset instead.

pub fn reset(&self)

Manually reapply the filter. You need to run this e.g. if the filtering function depends on mutable state and it has changed.

pub fn unfiltered_row(&self, filtered_row: usize) -> usize

Gets the row index of the underlying unfiltered model for a given filtered row index.

Trait Implementations

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

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<<FilterModel<M, F> 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: <FilterModel<M, F> 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 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)