Trait ActionName

pub trait ActionName {
    type Group: ActionGroupName;
    type Target;
    type State;

    const NAME: &'static str;

    // Provided method
    fn action_name() -> String { ... }
}

Define the name of an action.

Required Associated Constants

const NAME: &'static str

The name of the action.

Required Associated Types

type Group: ActionGroupName

The group of this action.

type Target

Target value type for passing values to this action.

Use [()] for actions without target value.

type State

State type of this action.

Use [()] for stateless actions.

Provided Methods

fn action_name() -> String

The full action name (group.action).

Examples found in repository

examples/actions.rs (line 61)

    fn init(
        _init: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let menu_model = gtk::gio::Menu::new();
        menu_model.append(Some("Stateless"), Some(&ExampleAction::action_name()));

        let model = Self { counter: 0 };

        let widgets = view_output!();

        let app = relm4::main_application();
        app.set_accelerators_for_action::<ExampleAction>(&["<primary>W"]);

        let action: RelmAction<ExampleAction> = RelmAction::new_stateless(move |_| {
            println!("Statelesss action!");
            sender.input(Msg::Increment);
        });

        let action2: RelmAction<ExampleU8Action> =
            RelmAction::new_stateful_with_target_value(&0, |_, state, value| {
                println!("Stateful action -> state: {state}, value: {value}");
                *state += value;
            });

        let mut group = RelmActionGroup::<WindowActionGroup>::new();
        group.add_action(action);
        group.add_action(action2);
        group.register_for_widget(&widgets.main_window);

        ComponentParts { model, widgets }
    }

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors