Struct Connector

pub struct Connector<C: Component> { /* private fields */ }

Contains the post-launch input sender and output receivers with the root widget.

The receiver can be separated from the Connector by choosing a method for handling it.

Implementations

impl<C: Component> Connector<C>

pub fn forward<X: 'static, F: Fn(C::Output) -> X + 'static>( self, sender_: &Sender<X>, transform: F, ) -> Controller<C>

Forwards output events to the designated sender.

Examples found in repository

examples/message_broker.rs (line 193)

    fn init(
        _init: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let header = Header::builder()
            .launch_with_broker((), &HEADER_BROKER)
            .forward(sender.input_sender(), identity);

        let dialog = Dialog::builder()
            .launch(root.clone().upcast())
            .forward(sender.input_sender(), identity);

        let model = App {
            mode: AppMode::View,
            header,
            dialog,
        };

        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

examples/transient_dialog.rs (line 113)

    fn init(
        _init: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        // We don't have access to the parent window from here
        // but we can just use the button to set the transient window for the dialog.
        // Relm4 will get the window later by calling [`WidgetExt::root()`]
        // on the button once all widgets are connected.
        let dialog = Dialog::builder()
            .transient_for(&root)
            .launch_with_broker((), &DIALOG_BROKER)
            .forward(sender.input_sender(), identity);

        let model = Button { dialog };
        let widgets = view_output!();
        ComponentParts { model, widgets }
    }

    fn update(&mut self, _msg: Self::Input, _sender: ComponentSender<Self>) {}
}

#[derive(Debug)]
enum AppMsg {}

struct App {
    button: Controller<Button>,
}

#[relm4::component]
impl SimpleComponent for App {
    type Init = ();
    type Input = AppMsg;
    type Output = ();

    view! {
        main_window = gtk::ApplicationWindow {
            set_default_size: (500, 250),
            set_child: Some(model.button.widget()),
        }
    }

    fn init(
        _init: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let button = Button::builder()
            .launch(())
            .forward(sender.input_sender(), identity);
        let model = App { button };
        let widgets = view_output!();
        ComponentParts { model, widgets }
    }

examples/components.rs (line 184)

    fn init(
        _: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let header = Header::builder()
            .launch(())
            .forward(sender.input_sender(), identity);
        let dialog = Dialog::builder()
            .transient_for(&root)
            .launch(DialogInit {
                text: "Do you want to close before saving?".to_string(),
                secondary_text: Some("All unsaved changes will be lost".to_string()),
                accept_text: "Close".to_string(),
                cancel_text: "Cancel".to_string(),
            })
            .forward(sender.input_sender(), identity);

        let model = App {
            mode: AppMode::View,
            header,
            dialog,
        };
        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

examples/drop_sub_components.rs (lines 75-78)

    fn update_with_view(
        &mut self,
        widgets: &mut Self::Widgets,
        message: Self::Input,
        sender: ComponentSender<Self>,
        root: &Self::Root,
    ) {
        widgets.container.remove_all();
        match message {
            Msg::ShowInitialScreen => {
                let controller =
                    InitialScreen::builder()
                        .launch(())
                        .forward(sender.input_sender(), |msg| match msg {
                            InitialScreenOutput::ShowSubScreen1 => Msg::ShowSubScreen1,
                            InitialScreenOutput::ShowSubScreen2 => Msg::ShowSubScreen2,
                        });
                widgets.container.append(controller.widget());
                self.mode = Some(AppMode::Initial(controller));
            }
            Msg::ShowSubScreen1 => {
                let controller = SubScreen1::builder()
                    .launch(())
                    .forward(sender.input_sender(), |_| Msg::ShowInitialScreen);
                widgets.container.append(controller.widget());
                self.mode = Some(AppMode::SubScreen1(controller));
            }
            Msg::ShowSubScreen2 => {
                let controller = SubScreen2::builder()
                    .launch(())
                    .forward(sender.input_sender(), |_| Msg::ShowInitialScreen);
                widgets.container.append(controller.widget());
                self.mode = Some(AppMode::SubScreen2(controller));
            }
        }
        root.set_default_size(400, 300);
    }

pub fn connect_receiver<F: FnMut(&mut Sender<C::Input>, C::Output) + 'static>( self, func: F, ) -> Controller<C>

Given a mutable closure, captures the receiver for handling.

Examples found in repository

examples/settings_list.rs (lines 29-68)

fn main() {
    gtk::Application::builder()
        .application_id("org.relm4.SettingsListExample")
        .launch(|_app, window| {
            // Initialize a component's root widget
            let mut component = App::builder()
                // Attach the root widget to the given window.
                .attach_to(&window)
                // Start the component service with an initial parameter
                .launch("Settings List Demo".into())
                // Attach the returned receiver's messages to this closure.
                .connect_receiver(move |sender, message| match message {
                    Output::Clicked(id) => {
                        eprintln!("ID {id} Clicked");

                        match id {
                            0 => xdg_open("https://github.com/Relm4/Relm4".into()),
                            1 => xdg_open("https://docs.rs/relm4/".into()),
                            2 => {
                                sender.send(Input::Clear).unwrap();
                            }
                            _ => (),
                        }
                    }

                    Output::Reload => {
                        sender
                            .send(Input::AddSetting {
                                description: "Browse GitHub Repository".into(),
                                button: "GitHub".into(),
                                id: 0,
                            })
                            .unwrap();

                        sender
                            .send(Input::AddSetting {
                                description: "Browse Documentation".into(),
                                button: "Docs".into(),
                                id: 1,
                            })
                            .unwrap();

                        sender
                            .send(Input::AddSetting {
                                description: "Clear List".into(),
                                button: "Clear".into(),
                                id: 2,
                            })
                            .unwrap();
                    }
                });

            // Keep runtime alive after the component is dropped
            component.detach_runtime();

            println!("parent is {:?}", component.widget().toplevel_window());
        });
}

pub fn detach(self) -> Controller<C>

Ignore outputs from the component and finish the builder.

pub fn into_stream(self) -> ComponentStream<C>

Convert his type into a Stream that yields output events as futures.

Examples found in repository

examples/message_stream.rs (line 149)

    fn update(&mut self, msg: Self::Input, sender: ComponentSender<Self>, root: &Self::Root) {
        match msg {
            AppMsg::StartSearch => {
                self.searching = true;

                let stream = Dialog::builder()
                    .transient_for(root)
                    .launch(())
                    .into_stream();
                sender.oneshot_command(async move {
                    // Use the component as stream
                    let result = stream.recv_one().await;

                    if let Some(search) = result {
                        let response =
                            reqwest::get(format!("https://duckduckgo.com/lite/?q={search}"))
                                .await
                                .unwrap();
                        let response_text = response.text().await.unwrap();

                        // Extract the url of the first search result.
                        if let Some(url) = response_text.split("<a rel=\"nofollow\" href=\"").nth(1)
                        {
                            let url = url.split('\"').next().unwrap().replace("amp;", "");
                            Some(format!("https:{url}"))
                        } else {
                            None
                        }
                    } else {
                        None
                    }
                });
            }
        }
    }

Trait Implementations

impl<C: Component> ComponentController<C> for Connector<C>

fn sender(&self) -> &Sender<C::Input>

Provides access to the component’s sender.

fn state(&self) -> &StateWatcher<C>

Provides access to the state of a component.

fn widget(&self) -> &C::Root

Returns the root widget of the component.

fn detach_runtime(&mut self)

Dropping this type will usually stop the runtime of the component. With this method you can give the runtime a static lifetime. In other words, dropping the controller or connector will not stop the runtime anymore, instead it will run until the app is closed.

fn emit(&self, event: C::Input)

Emits an input to the component.

fn model(&self) -> Ref<'_, C>

Returns a reference to the Component.

fn widgets(&self) -> Ref<'_, C::Widgets>

Returns a reference to the Component::Widgets.

impl<C> Debug for Connector<C>

where C: Component + Debug, C::Widgets: Debug,

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

Formats the value using the given formatter.