How to make a dialog transient to the parent window when it's a subcomponent?

[paveloom]

Yep, I hit it again. The problem was described before (#212) and the solution was found (#213 (comment)). Now I have trouble porting it to v0.5.

So, we don't have the parent! macro anymore, but we can access the component's widget from the parent. So I thought I would solve it like so:

fn init(
    _init: Self::Init,
    root: &Self::Root,
    sender: ComponentSender<Self>,
) -> ComponentParts<Self> {
    // <...>
    // Initialize the components
    let dialog = dialog::Model::builder()
        .launch_with_broker((), &dialog::BROKER)
        .forward(sender.input_sender(), identity);
    dbg!(dialog
        .widget()
        .toplevel_window()
        .as_ref()
        .is_some());
    // Set the components as transient to the root
    dialog
        .widget()
        .set_transient_for(dialog.widget().toplevel_window().as_ref());
    // Initialize the model
    let model = Self {
        // <...>
        dialog,
    };
    let widgets = view_output!();
    ComponentParts { model, widgets }
}

Which compiles! And the value in the dbg! call is reported as true. However, the dialog isn't actually transient. How can I fix this?

[AaronErhardt]

I think the problem is that the component you've created is it's own top-level window. You should be able to get the top-level window from the root of your component though.

And btw. there's this convenience method in ComponentBuilder: https://relm4.org/docs/next/relm4/component/struct.ComponentBuilder.html#method.transient_for

[paveloom]

Getting the top-level window from the middle component (see below) seems to be unsuccessful. I can't use the transient_for method without a window, since it accepts a value instead of the Option, like the widget's one.

I've also seen that the window is passed as a Self::Init in the components example, but that's a lot of cloning for deeper nested components.

Here's the example:

use std::convert::identity;

use gtk::prelude::{ButtonExt, GtkWindowExt, WidgetExt};
use relm4::{gtk, MessageBroker, RelmWidgetExt};
use relm4::{
    Component, ComponentController, ComponentParts, ComponentSender, Controller, RelmApp,
    SimpleComponent,
};

static DIALOG_BROKER: MessageBroker<Dialog> = MessageBroker::new();

struct Dialog {
    visible: bool,
}

#[derive(Debug)]
enum DialogMsg {
    Show,
    Hide,
}

#[relm4::component]
impl Component for Dialog {
    type Init = ();
    type Input = DialogMsg;
    type Output = ButtonMsg;
    type Widgets = DialogWidgets;
    type CommandOutput = ();
    view! {
        dialog = gtk::Dialog {
            #[watch]
            set_visible: model.visible,
            set_modal: true,
            #[wrap(Some)]
            set_child = &gtk::Label {
                set_width_request: 200,
                set_height_request: 80,
                set_halign: gtk::Align::Center,
                set_valign: gtk::Align::Center,
                set_label: "Am I transient?",
            },
            connect_close_request[sender] => move |_| {
                sender.input(DialogMsg::Hide);
                gtk::Inhibit(false)
            }
        }
    }
    fn init(
        _init: Self::Init,
        root: &Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let model = Dialog { visible: false };
        let widgets = view_output!();
        // Reported as `true`
        dbg!(root.toplevel_window().as_ref().is_some());
        // Doesn't work since the top-level window here is the dialog itself
        widgets
            .dialog
            .set_transient_for(root.toplevel_window().as_ref());
        ComponentParts { model, widgets }
    }
    fn update(&mut self, msg: Self::Input, _sender: ComponentSender<Self>) {
        match msg {
            DialogMsg::Show => self.visible = true,
            DialogMsg::Hide => self.visible = false,
        }
    }
}

struct Button {
    #[allow(dead_code)]
    dialog: Controller<Dialog>,
}

#[derive(Debug)]
enum ButtonMsg {}

#[relm4::component]
impl SimpleComponent for Button {
    type Init = ();
    type Input = ButtonMsg;
    type Output = AppMsg;
    type Widgets = MiddleComponentWidgets;
    view! {
        button = &gtk::Button {
            set_label: "Show the dialog",
            connect_clicked => move |_| {
                DIALOG_BROKER.send(DialogMsg::Show);
            }
        }
    }
    fn init(
        _init: Self::Init,
        root: &Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let dialog = Dialog::builder()
            .launch_with_broker((), &DIALOG_BROKER)
            .forward(sender.input_sender(), identity);
        let model = Button { dialog };
        // Reported as `false`, so can't get the top-level window
        dbg!(root.toplevel_window().as_ref().is_some());
        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 = ();
    type Widgets = AppWidgets;
    view! {
        main_window = gtk::ApplicationWindow {
            set_default_width: 500,
            set_default_height: 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 }
    }
    fn update(&mut self, _msg: Self::Input, _sender: ComponentSender<Self>) {}
}

fn main() {
    let app = RelmApp::new("relm4.test.dialog");
    app.run::<App>(());
}