How to enable and disable an action?

[ExcaliburZero]

How can you dynamically enable and disable a RelmAction?

Context

I'm trying to create a GUI for an application that allows a user to open a file, edit specific values in it, and save the file.

I have created two actions, one for opening a file and one for saving a file:

relm4::new_action_group!(WindowActionGroup, "win");

relm4::new_stateless_action!(OpenAction, WindowActionGroup, "open");
relm4::new_stateless_action!(SaveAction, WindowActionGroup, "save");

And registered them in a RelmActionGroup:

        let app = relm4::main_application();

        app.set_accelerators_for_action::<OpenAction>(&["<primary>o"]);
        let open_sender = sender.clone();
        let open_action: RelmAction<OpenAction> = {
            RelmAction::new_stateless(move |_| {
                println!("Open!");
                open_sender.input(AppMsg::OpenRequest);
            })
        };

        app.set_accelerators_for_action::<SaveAction>(&["<primary>s"]);
        let save_sender = sender.clone();
        let save_action: RelmAction<SaveAction> = {
            RelmAction::new_stateless(move |_| {
                println!("Save!");
                save_sender.input(AppMsg::SaveRequest);
            })
        };


        let mut group = RelmActionGroup::<WindowActionGroup>::new();
        group.add_action(open_action);
        group.add_action(save_action);

Because of the type of file the application is meant to edit, it does not make sense to allow the user to save a file if they have not already opened a file. So I would like to disable the save action until the user opens a file.

    fn init(
        _: Self::Init,
        root: &Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        // ...

        let mut group = RelmActionGroup::<WindowActionGroup>::new();
        group.add_action(open_action);
        group.add_action(save_action);

        // disable save action

        // ...
    }

    fn update(&mut self, msg: Self::Input, sender: ComponentSender<Self>) {
        match msg {
            AppMsg::SaveRequest => self.save_dialog.emit(SaveDialogMsg::Save),
            AppMsg::SaveResponse(path) => {
                // ...
            }
            AppMsg::OpenRequest => self.open_dialog.emit(OpenDialogMsg::Open),
            AppMsg::OpenResponse(path) => {
                // ...
                
                // enable save action
                
                // ...
            }
    }

How can I disable and enable the save action?

Things I've looked into

The api docs for relm4::actions::RelmAction mention that it wraps around gio::SimpleAction. The docs for gio::SimpleAction list a set_enabled method that looks like the functionality I'm looking for, however I have not been able to figure out a way to access the underlying gio::SimpleAction for a RelmAction.

https://docs.rs/relm4/latest/relm4/actions/struct.RelmAction.html
https://relm4.org/docs/stable/gio/struct.SimpleAction.html

I also tried seeing if there are any methods for RelmAction or RelmActionGroup, but I didn't see any that would allow me to disable an action or access the underlying gio::SimpleAction (without moving the action group like in RelmActionGroup::into_action_group).

[AaronErhardt]

The api docs for relm4::actions::RelmAction mention that it wraps around gio::SimpleAction. The docs for gio::SimpleAction list a set_enabled method that looks like the functionality I'm looking for, however I have not been able to figure out a way to access the underlying gio::SimpleAction for a RelmAction.

I think you're right. Relm4 should at least expose the gio::SimpleAction for more complex use-cases. I'll convert this into an issue.

[lessneek]

Ok, now we have set_enabled for RelmAction, but it is not clonable by default, because new_stateless_action! macro doesn't implement Clone trait for an action. Cloning is needed to store a RelmAction in a model to use in update functions. Now I need to manually implement a Clone trait for an action struct. I think it will be better to simply add #[derive(Clone)] for an action struct in the macro.