Struct 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());
});

Updating the Model from a Thread

ModelRc is not Send and can only be used in the main thread. If you want to update the model based on data coming from another thread, you need to send back the data to the main thread using invoke_from_event_loop or Weak::upgrade_in_event_loop.

use slint::Model;
slint::slint!{
    export component TestCase inherits Window {
        in property <[string]> the_model;
        //...
    }
}
let ui = TestCase::new().unwrap();
// set a model (a VecModel)
let model = std::rc::Rc::new(slint::VecModel::<slint::SharedString>::default());
ui.set_the_model(model.clone().into());

// do some work in a thread
let ui_weak = ui.as_weak();
let thread = std::thread::spawn(move || {
    // do some work
    let new_strings = vec!["foo".into(), "bar".into()];
    // send the data back to the main thread
    ui_weak.upgrade_in_event_loop(move |ui| {
        let model = ui.get_the_model();
        let model = model.as_any().downcast_ref::<slint::VecModel<slint::SharedString>>()
            .expect("We know we set a VecModel earlier");
        model.set_vec(new_strings);
    });
});
ui.run().unwrap();

Implementations

impl<T> ModelRc<T>

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

Trait Implementations

impl<T> Clone for ModelRc<T>

fn clone(&self) -> Self

Returns a duplicate 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

Formats the value using the given formatter.

impl<T> Default for ModelRc<T>

fn default() -> Self

Construct an empty model

impl<T: Clone + 'static> From<&[T]> for ModelRc<T>

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

Converts to this type from the input type.

impl<T: Clone + 'static, const N: usize> From<[T; N]> for ModelRc<T>

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

Converts to this type from the input type.

impl<T, M: Model<Data = T> + 'static> From<Rc<M>> for ModelRc<T>

fn from(model: Rc<M>) -> Self

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> + 'static>) -> Self

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 rows and each row has this data

fn row_count(&self) -> usize

The number of rows in the model

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

Returns the data for a particular row.

fn set_row_data(&self, row: usize, data: Self::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

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: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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>>, Self::Error>

Performs the conversion.