Struct slint::ModelRc

pub struct ModelRc<T>(/* private fields */);

ModelRc is a type wrapper for a reference counted implementation of the Model trait.

Models are used to represent sequences of the same data type. In .slint code those are represented using the [T] array syntax and typically used in for expressions, array properties, and array struct fields.

For example, a property <[string]> foo will be of type ModelRc<SharedString> and, behind the scenes, wraps a Rc<dyn Model<Data = SharedString>>.

An array struct field will also be of type ModelRc:

export struct AddressBook {
    names: [string]
}

When accessing AddressBook from Rust, the names field will be of type ModelRc<SharedString>.

There are several ways of constructing a ModelRc in Rust:

• An empty ModelRc can be constructed with ModelRc::default().
• A ModelRc can be constructed from a slice or an array using the From trait. This allocates a VecModel.
• Use ModelRc::new() to construct a ModelRc from a type that implements the Model trait, such as VecModel or your own implementation.
• If you have your model already in an Rc, then you can use the From trait to convert from Rc<dyn Model<Data = T>> to ModelRc.

Example

use slint::{slint, SharedString, ModelRc, Model, VecModel};
use std::rc::Rc;
slint!{
    import { Button } from "std-widgets.slint";
    export component Example {
        callback add_item <=> btn.clicked;
        in property <[string]> the_model;
        HorizontalLayout {
            for it in the_model : Text { text: it; }
            btn := Button { text: "Add"; }
        }
    }
}
let ui = Example::new().unwrap();
// Create a VecModel and put it in an Rc.
let the_model : Rc<VecModel<SharedString>> =
        Rc::new(VecModel::from(vec!["Hello".into(), "World".into()]));
// Convert it to a ModelRc.
let the_model_rc = ModelRc::from(the_model.clone());
// Pass the model to the ui: The generated set_the_model setter from the
// the_model property takes a ModelRc.
ui.set_the_model(the_model_rc);

// We have kept a strong reference to the_model, to modify it in a callback.
ui.on_add_item(move || {
    // Use VecModel API: VecModel uses the Model notification mechanism to let Slint
    // know it needs to refresh the UI.
    the_model.push("SomeValue".into());
});

// Alternative: we can re-use a getter.
let ui_weak = ui.as_weak();
ui.on_add_item(move || {
    let ui = ui_weak.unwrap();
    let the_model_rc = ui.get_the_model();
    let the_model = the_model_rc.as_any().downcast_ref::<VecModel<SharedString>>()
        .expect("We know we set a VecModel earlier");
    the_model.push("An Item".into());
});

Implementations

impl<T> ModelRc<T>

pub fn new(model: impl Model<Data = T> + 'static) -> ModelRc<T>

Trait Implementations

impl<T> Clone for ModelRc<T>

fn clone(&self) -> ModelRc<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for ModelRc<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Default for ModelRc<T>

fn default() -> ModelRc<T>

Construct an empty model

impl<T> From<&[T]> for ModelRc<T>

where T: Clone + 'static,

fn from(slice: &[T]) -> ModelRc<T>

Converts to this type from the input type.

impl<T, const N: usize> From<[T; N]> for ModelRc<T>

where T: Clone + 'static,

fn from(array: [T; N]) -> ModelRc<T>

Converts to this type from the input type.

impl<T, M> From<Rc<M>> for ModelRc<T>

where M: Model<Data = T> + 'static,

fn from(model: Rc<M>) -> ModelRc<T>

Converts to this type from the input type.

impl<T> From<Rc<dyn Model<Data = T>>> for ModelRc<T>

fn from(model: Rc<dyn Model<Data = T>>) -> ModelRc<T>

Converts to this type from the input type.

impl<T> Model for ModelRc<T>

type Data = T

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<<ModelRc<T> 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: <ModelRc<T> 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.

impl<T> PartialEq for ModelRc<T>

fn eq(&self, other: &ModelRc<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> TryInto<Rc<dyn Model<Data = T>>> for ModelRc<T>

type Error = ()

The type returned in the event of a conversion error.

fn try_into( self ) -> Result<Rc<dyn Model<Data = T>>, <ModelRc<T> as TryInto<Rc<dyn Model<Data = T>>>>::Error>

Performs the conversion.