Struct relm4::RelmComponent

pub struct RelmComponent<Model, ParentModel> where
    Model: ComponentUpdate<ParentModel> + 'static,
    ParentModel: ModelTrait,
    Model::Widgets: WidgetsTrait<Model, ParentModel> + 'static,  { /* private fields */ }

A component that can be part of the main application or other components.

A RelmComponent has its own widget, model and message type and can send messages to its parent and its children components.

Multiple RelmComponents that have the same parent are usually bundled in a struct that implements Components.

Implementations

impl<Model, ParentModel> RelmComponent<Model, ParentModel> where
    Model::Widgets: WidgetsTrait<Model, ParentModel> + 'static,
    ParentModel: ModelTrait,
    Model: ComponentUpdate<ParentModel> + 'static, 

pub fn new(
    parent_model: &ParentModel,
    parent_sender: Sender<ParentModel::Msg>
) -> Self

Create a new RelmComponent.

Examples found in repository

relm4-examples/examples/components_old.rs (line 146)

≺ ≻

    fn init_components(parent_model: &AppModel, parent_sender: Sender<AppMsg>) -> Self {
        AppComponents {
            comp1: RelmComponent::new(parent_model, parent_sender.clone()),
            comp2: RelmComponent::new(parent_model, parent_sender),
        }
    }

pub fn connect_parent(&mut self, parent_widgets: &ParentModel::Widgets)

Connect the widgets to the widgets of the parent widget.

Examples found in repository

relm4-examples/examples/components_old.rs (line 152)

≺ ≻

    fn connect_parent(&mut self, parent_widgets: &AppWidgets) {
        self.comp1.connect_parent(parent_widgets);
        self.comp2.connect_parent(parent_widgets);
    }

pub fn send(&self, msg: Model::Msg) -> Result<(), SendError<Model::Msg>>

Send a message to this component. This can be used by the parent to send messages to this component.

Examples found in repository

relm4-examples/examples/components.rs (line 199)

↕

    fn update(&mut self, msg: AppMsg, components: &AppComponents, _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::SetMode(mode) => {
                self.mode = mode;
            }
            AppMsg::CloseRequest => {
                components.dialog.send(DialogMsg::Show).unwrap();
            }
            AppMsg::Close => {
                return false;
            }
        }
        true
    }

relm4-examples/examples/components_old.rs (line 234)

≺ ≻↕

    fn update(&mut self, msg: AppMsg, components: &AppComponents, _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Increment => self.counter = self.counter.saturating_add(1),
            AppMsg::Decrement => self.counter = self.counter.saturating_sub(1),
            AppMsg::ShowComp1 => {
                components.comp1.send(CompMsg::Show).unwrap();
            }
            AppMsg::ShowComp2 => {
                components.comp2.send(CompMsg::Show).unwrap();
            }
        }
        println!("counter: {}", self.counter);
        true
    }

relm4-examples/examples/save_dialog.rs (line 40)

↕

    fn update(&mut self, msg: AppMsg, components: &AppComponents, _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Increment => {
                self.counter = self.counter.wrapping_add(1);
            }
            AppMsg::Decrement => {
                self.counter = self.counter.wrapping_sub(1);
            }
            AppMsg::SaveRequest => {
                components
                    .dialog
                    .send(SaveDialogMsg::SaveAs(format!("Counter_{}", self.counter)))
                    .unwrap();
            }
            AppMsg::SaveResponse(path) => {
                println!("File would have been saved at {:?}", path);
            }
        }
        true
    }

relm4-examples/examples/alert.rs (line 42)

≺ ≻↕

    fn update(&mut self, msg: AppMsg, components: &AppComponents, _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Increment => {
                self.counter = self.counter.wrapping_add(1);
            }
            AppMsg::Decrement => {
                self.counter = self.counter.wrapping_sub(1);
            }
            AppMsg::CloseRequest => {
                if self.counter == 42 {
                    return false;
                } else {
                    self.alert_toggle = !self.alert_toggle;
                    if self.alert_toggle {
                        components.dialog.send(AlertMsg::Show).unwrap();
                    } else {
                        components.second_dialog.send(AlertMsg::Show).unwrap();
                    }
                }
            }
            AppMsg::Save => {
                println!("* Open save dialog here *");
            }
            AppMsg::Close => {
                return false;
            }
            AppMsg::Ignore => (),
        }

        true
    }

relm4-examples/libadwaita/examples/calc-trainer.rs (lines 290-293)

↕

    fn update(&mut self, msg: AppMsg, components: &AppComponents, _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Plus(v) => {
                if self.minus || self.multiply {
                    self.plus = v;
                }
            }
            AppMsg::Multiply(v) => {
                if self.minus || self.plus {
                    self.multiply = v;
                }
            }
            AppMsg::Minus(v) => {
                if self.plus || self.multiply {
                    self.minus = v;
                }
            }
            AppMsg::MaxValue(v) => {
                self.range = v;
                self.calculate_task();
            }
            AppMsg::Entry(v) => {
                if self.correct_value == v as u32 {
                    self.feedback = "<big>😀 That was right!! 💓</big>".to_string();
                    self.pick_random_task_type();
                    self.calculate_task();
                    self.correct_calculations += 1;
                } else {
                    self.feedback = "<big>😕 Unfortunately wrong. 😓</big>".to_string();
                    self.incorrect_calculations += 1;
                }
            }
            AppMsg::EntryError => {
                self.feedback = "<big>Please enter a valid number.</big>".to_string();
            }
            AppMsg::SetTimer(v) => {
                self.timer_init_value = v;
            }
            AppMsg::StartTimer => {
                // if timer is running a press on the button will reset button
                // otherwise initialize the timer with the selected init value
                components.timer_handler.send(TimerMsg::StartStopTimer);
                if self.timer.is_some() {
                    self.timer = None;
                } else {
                    self.pick_random_task_type();
                    self.calculate_task();
                    self.timer = Some(self.timer_init_value);
                    self.correct_calculations = 0;
                    self.incorrect_calculations = 0;
                }
            }
            AppMsg::CountDown => {
                if let Some(t) = &mut self.timer {
                    *t -= 1;

                    // check if time is up
                    if *t == 0 {
                        self.timer = None;
                        // stop timer
                        components.timer_handler.send(TimerMsg::StartStopTimer);
                        // display results
                        components
                            .dialog
                            .send(DialogMsg::Show(
                                self.correct_calculations,
                                self.incorrect_calculations,
                            ))
                            .unwrap();
                    }
                }
            }
        }
        true
    }

pub fn sender(&self) -> Sender<Model::Msg>

Get a sender to send messages to this component.

pub fn root_widget(
    &self
) -> &<Model::Widgets as WidgetsTrait<Model, ParentModel>>::Root

Returns the root widget of this component’s widgets. Can be used by the parent to connect the root widget to the parent’s widgets.

Examples found in repository

relm4-examples/examples/components_old.rs (line 213)

≺ ≻↕

    fn init_view(model: &AppModel, components: &AppComponents, sender: Sender<AppMsg>) -> Self {
        let main = gtk::ApplicationWindow::default();
        let vbox = gtk::Box::builder()
            .orientation(gtk::Orientation::Vertical)
            .spacing(10)
            .build();
        vbox.set_margin_all(5);

        let text = gtk::Label::new(Some(&model.counter.to_string()));

        let inc_button = gtk::Button::with_label("Increment");
        let dec_button = gtk::Button::with_label("Decrement");

        vbox.append(&text);
        vbox.append(&inc_button);
        vbox.append(&dec_button);

        main.set_child(Some(&vbox));

        let sender2 = sender.clone();

        inc_button.connect_clicked(move |_button| {
            sender.send(AppMsg::Increment).unwrap();
        });

        dec_button.connect_clicked(move |_button| {
            sender2.send(AppMsg::Decrement).unwrap();
        });

        vbox.append(components.comp1.root_widget());
        vbox.append(components.comp2.root_widget());

        AppWidgets { main, text, vbox }
    }

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

Returns a mutable reference to the widgets of this component or None if you already have a refernce 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).

Trait Implementations

impl<Model: Debug, ParentModel: Debug> Debug for RelmComponent<Model, ParentModel> where
    Model: ComponentUpdate<ParentModel> + 'static,
    ParentModel: ModelTrait,
    Model::Widgets: WidgetsTrait<Model, ParentModel> + 'static,
    Model::Components: Debug,
    Model::Msg: Debug,
    Model::Widgets: Debug,
    Model::Widgets: Debug, 

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

Formats the value using the given formatter.