Struct relm4::MicroComponent

source · [−]

pub struct MicroComponent<Model: MicroModel> { /* private fields */ }

Expand description

MicroComponent is a small component that lives in their parents model, can be modified from their parents model but at the same time have their own widgets and update function

Implementations

source

impl<Model> MicroComponent<Model> where
 Model::Widgets: MicroWidgets<Model> + 'static,
 Model::Msg: 'static,
 Model::Data: 'static,
 Model: MicroModel + 'static,

source

pub fn new(model: Model, data: Model::Data) -> Self

Creates new MicroComponent

Examples found in repository

relm4-examples/examples/micro_components_manual.rs (line 110)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Increment => {
                self.counter = self.counter.wrapping_add(1);

                // Also increment the numbers.
                for num in &self.numbers {
                    let mut model = num.model_mut().unwrap();
                    model.num = model.num.wrapping_add(1);

                    // Make sure to drop the mutable reference before updating the view
                    drop(model);
                    num.update_view().unwrap();
                }
            }
            AppMsg::Decrement => {
                self.counter = self.counter.wrapping_sub(1);
            }
            AppMsg::AddNumber => {
                self.numbers
                    .push(MicroComponent::new(NumberModel { num: self.counter }, ()));
            }
        }
        true
    }

More examples

relm4-examples/examples/micro_components.rs (line 96)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Increment => {
                self.counter = self.counter.wrapping_add(1);

                // Also increment the numbers.
                for num in &self.numbers {
                    let mut model = num.model_mut().unwrap();
                    model.num = model.num.wrapping_add(1);

                    // Make sure to drop the mutable reference before updating the view
                    drop(model);
                    num.update_view().unwrap();
                }
            }
            AppMsg::Decrement => {
                self.counter = self.counter.wrapping_sub(1);
            }
            AppMsg::AddNumber => {
                self.numbers
                    .push(MicroComponent::new(NumberModel { num: self.counter }, ()));
            }
        }
        true
    }

source

pub fn update_view(&self) -> Result<(), MicroComponentError>

Updates a view of this MicroComponent

Examples found in repository

relm4-examples/examples/micro_components_manual.rs (line 102)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Increment => {
                self.counter = self.counter.wrapping_add(1);

                // Also increment the numbers.
                for num in &self.numbers {
                    let mut model = num.model_mut().unwrap();
                    model.num = model.num.wrapping_add(1);

                    // Make sure to drop the mutable reference before updating the view
                    drop(model);
                    num.update_view().unwrap();
                }
            }
            AppMsg::Decrement => {
                self.counter = self.counter.wrapping_sub(1);
            }
            AppMsg::AddNumber => {
                self.numbers
                    .push(MicroComponent::new(NumberModel { num: self.counter }, ()));
            }
        }
        true
    }

More examples

relm4-examples/examples/micro_components.rs (line 88)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Increment => {
                self.counter = self.counter.wrapping_add(1);

                // Also increment the numbers.
                for num in &self.numbers {
                    let mut model = num.model_mut().unwrap();
                    model.num = model.num.wrapping_add(1);

                    // Make sure to drop the mutable reference before updating the view
                    drop(model);
                    num.update_view().unwrap();
                }
            }
            AppMsg::Decrement => {
                self.counter = self.counter.wrapping_sub(1);
            }
            AppMsg::AddNumber => {
                self.numbers
                    .push(MicroComponent::new(NumberModel { num: self.counter }, ()));
            }
        }
        true
    }

source

pub fn model(&self) -> Result<Ref<'_, Model>, BorrowError>

Returns model for this MicroComponent

Use this carefully and make sure reference is dropped. It’s using RefCell internally.

source

pub fn model_mut(&self) -> Result<RefMut<'_, Model>, BorrowMutError>

Returns mutable reference to model for this MicroComponent

Use this carefully and make sure reference is dropped. It’s using RefCell internally. If you don’t drop the reference any call to MicroComponent::update_view will fail.

Examples found in repository

relm4-examples/examples/micro_components_manual.rs (line 97)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Increment => {
                self.counter = self.counter.wrapping_add(1);

                // Also increment the numbers.
                for num in &self.numbers {
                    let mut model = num.model_mut().unwrap();
                    model.num = model.num.wrapping_add(1);

                    // Make sure to drop the mutable reference before updating the view
                    drop(model);
                    num.update_view().unwrap();
                }
            }
            AppMsg::Decrement => {
                self.counter = self.counter.wrapping_sub(1);
            }
            AppMsg::AddNumber => {
                self.numbers
                    .push(MicroComponent::new(NumberModel { num: self.counter }, ()));
            }
        }
        true
    }

More examples

relm4-examples/examples/micro_components.rs (line 83)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Increment => {
                self.counter = self.counter.wrapping_add(1);

                // Also increment the numbers.
                for num in &self.numbers {
                    let mut model = num.model_mut().unwrap();
                    model.num = model.num.wrapping_add(1);

                    // Make sure to drop the mutable reference before updating the view
                    drop(model);
                    num.update_view().unwrap();
                }
            }
            AppMsg::Decrement => {
                self.counter = self.counter.wrapping_sub(1);
            }
            AppMsg::AddNumber => {
                self.numbers
                    .push(MicroComponent::new(NumberModel { num: self.counter }, ()));
            }
        }
        true
    }

source

pub fn widgets(&self) -> Result<RefMut<'_, Model::Widgets>, BorrowMutError>

Returns a mutable reference to the widgets of this MicroComponent or will fail when you already have a reference to the widgets

Use this carefully and make sure the reference to the widgets is dropped after use because otherwise the view function can’t be called as long you own the widgets (it uses RefCell internally).

source