Struct relm4::component::AsyncComponentBuilder

pub struct AsyncComponentBuilder<C: AsyncComponent> {
    pub root: C::Root,
    /* private fields */
}

A component that is ready for docking and launch.

Fields

root: C::Root

The root widget of the component.

Implementations

impl<C: AsyncComponent> AsyncComponentBuilder<C>

pub fn update_root<F: FnOnce(&mut C::Root)>(self, func: F) -> Self

Configure the root widget before launching.

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

Access the root widget before the component is initialized.

pub fn priority(self, priority: Priority) -> Self

Change the priority at which the messages of this component are handled.

• Use [glib::PRIORITY_HIGH] for high priority event sources.
• Use [glib::PRIORITY_LOW] for very low priority background tasks.
• Use [glib::PRIORITY_DEFAULT_IDLE] for default priority idle functions.
• Use [glib::PRIORITY_HIGH_IDLE] for high priority idle functions.

impl<C: AsyncComponent> AsyncComponentBuilder<C>where
    C::Root: AsRef<Widget>,

pub fn attach_to(self, container: &impl RelmContainerExt) -> Self

Attach the component’s root widget to a given container.

impl<C: AsyncComponent> AsyncComponentBuilder<C>where
    C::Root: AsRef<Window> + Clone,

pub fn transient_for(self, widget: impl AsRef<Widget>) -> Self

Set the component’s root widget transient for a given window. This function doesn’t require a gtk::Window as parameter, but instead uses RelmWidgetExt::toplevel_window() to retrieve the toplevel window of any gtk::Widget. Therefore, you don’t have to pass a window to every component.

If the root widget is a native dialog, such as gtk::FileChooserNative, you should use transient_for_native instead.

impl<C: AsyncComponent> AsyncComponentBuilder<C>where
    C::Root: AsRef<NativeDialog> + Clone,

pub fn transient_for_native(self, widget: impl AsRef<Widget>) -> Self

Set the component’s root widget transient for a given window. This function doesn’t require a gtk::Window as parameter, but instead uses RelmWidgetExt::toplevel_window() to retrieve the toplevel window of any gtk::Widget. Therefore, you don’t have to pass a window to every component.

Applicable to native dialogs only, such as gtk::FileChooserNative. If the root widget is a non-native dialog, you should use transient_for instead.

impl<C: AsyncComponent> AsyncComponentBuilder<C>

pub fn launch(self, payload: C::Init) -> AsyncConnector<C>

Starts the component, passing ownership to a future attached to a [gtk::glib::MainContext].

Examples found in repository

src/app.rs (line 129)

    pub fn run_async_with_args<C, S>(self, payload: C::Init, args: &[S])
    where
        C: AsyncComponent,
        C::Root: IsA<gtk::Window> + WidgetExt,
        S: AsRef<str>,
    {
        use std::cell::Cell;

        let Self { app } = self;

        let payload = Cell::new(Some(payload));

        app.connect_activate(move |app| {
            if let Some(payload) = payload.take() {
                assert!(
                    app.is_registered(),
                    "App should be already registered when activated"
                );

                let builder = AsyncComponentBuilder::<C>::default();
                let connector = builder.launch(payload);

                // Run late initialization for transient windows for example.
                crate::late_initialization::run_late_init();

                let mut controller = connector.detach();
                let window = controller.widget().clone();

                controller.detach_runtime();

                app.add_window(window.as_ref());
                window.show();
            } else {
                panic!("Can't start Relm4 applications twice");
            }
        });

        app.run_with_args(args);
    }

Trait Implementations

impl<C: Debug + AsyncComponent> Debug for AsyncComponentBuilder<C>where
    C::Root: Debug,

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

Formats the value using the given formatter.

impl<C: AsyncComponent> Default for AsyncComponentBuilder<C>

fn default() -> Self

Prepares a component for initialization.