Struct mg::Mg

pub struct Mg<COMM, SETT> where
    COMM: Clone + EnumFromStr + EnumMetaData + SpecialCommand + 'static,
    SETT: Default + EnumMetaData + Settings + SettingCompletion + 'static,  { /* fields omitted */ }

Implementations

impl<COMM, SETT> Mg<COMM, SETT> where
    COMM: Clone + EnumFromStr + EnumMetaData + SpecialCommand + 'static,
    SETT: Default + EnumMetaData + Settings + SettingCompletion + 'static, 

pub fn default_completers() -> Completers

Get the default completers. One to complete the commands, the other to complete the settings.

pub fn delete_current_completion_item(&self)

Delete the current completion item.

pub fn show_completion(&self)

Show the completion view.

pub fn update_completions(&self)

Update the items of the completion view.

impl<COMM, SETT> Mg<COMM, SETT> where
    COMM: Clone + EnumFromStr + EnumMetaData + SpecialCommand + 'static,
    SETT: Default + EnumMetaData + Settings + SettingCompletion + 'static, 

pub fn get_foreground_color(&self) -> RGBA

Get the color of the text.

pub fn reset_colors(&self)

Reset the background and foreground colors of the status bar.

pub fn set_dark_theme(&mut self, use_dark: bool)

Use the dark variant of the theme if available.

impl<COMM, SETT> Mg<COMM, SETT> where
    COMM: Clone + EnumFromStr + EnumMetaData + SpecialCommand + 'static,
    SETT: Default + EnumMetaData + Settings + SettingCompletion + 'static, 

pub fn action_to_command(&self, action: &str) -> ShortcutCommand

Convert an action String to a command String.

pub fn command_activate(&mut self, input: String)

Handle the command entry activate event.

pub fn execute_commands(
    &mut self,
    parse_result: ParseResult<COMM>,
    activated: bool
)

Execute the commands and show the errors contained in the parse result.

pub fn handle_command(
    &mut self,
    command: String,
    activated: bool,
    prefix: Option<u32>
) -> Option<Msg<COMM, SETT>>

Handle the command activate event.

pub fn handle_special_command(
    &mut self,
    activation_type: ActivationType,
    command: &str
) -> Option<Msg<COMM, SETT>>

Handle a special command activate or key press event.

impl<COMM, SETT> Mg<COMM, SETT> where
    COMM: Clone + EnumFromStr + EnumMetaData + SpecialCommand + 'static,
    SETT: Default + EnumMetaData + Settings + SettingCompletion + 'static, 

pub fn blocking_custom_dialog(
    &mut self,
    responder: Box<dyn Responder>,
    builder: DialogBuilder
)

Ask a question to the user and block until the user provides it (or cancel).

pub fn blocking_input(
    &mut self,
    responder: Box<dyn Responder>,
    message: String,
    default_answer: String
)

Ask a question to the user and block until the user provides it (or cancel).

pub fn blocking_question(
    &mut self,
    responder: Box<dyn Responder>,
    message: String,
    choices: Vec<char>
)

Ask a multiple-choice question to the user and block until the user provides it (or cancel).

pub fn blocking_yes_no_question(
    &mut self,
    responder: Box<dyn Responder>,
    message: String
)

Show a blocking yes/no question.

pub fn input(
    &mut self,
    responder: Box<dyn Responder>,
    message: String,
    default_answer: String
)

Ask a question to the user.

pub fn question(
    &mut self,
    responder: Box<dyn Responder>,
    message: String,
    choices: &[char]
)

Ask a multiple-choice question to the user.

pub fn set_dialog_answer(&mut self, answer: &str)

Set the answer to return to the caller of the dialog.

pub fn show_dialog(&mut self, dialog_builder: DialogBuilder)

Show a dialog created with a DialogBuilder.

pub fn show_dialog_without_shortcuts(&mut self, dialog_builder: DialogBuilder)

Show a dialog created with a DialogBuilder which does not contain shortcut.

pub fn yes_no_question(
    &mut self,
    responder: Box<dyn Responder>,
    message: String
)

Show a yes/no question.

impl<COMM, SETT> Mg<COMM, SETT> where
    COMM: Clone + EnumFromStr + EnumMetaData + SpecialCommand + 'static,
    SETT: Default + EnumMetaData + Settings + SettingCompletion + 'static, 

pub fn inhibit_key_press(
    current_mode: &Rc<Cell<Mode>>,
    key: &EventKey
) -> Inhibit

Check if the key should be inhibitted.

pub fn key_press(&mut self, key: &EventKey)

Handle the key press event.

pub fn key_release(&mut self, key: &EventKey)

Handle the key release event.

impl<COMM, SETT> Mg<COMM, SETT> where
    COMM: Clone + EnumFromStr + EnumMetaData + SpecialCommand + 'static,
    SETT: Default + EnumMetaData + Settings + SettingCompletion + 'static, 

pub fn add_to_shortcut(&mut self, key: Key)

Add the key to the current shortcut.

pub fn clear_shortcut(&mut self)

Clear the current shortcut buffer.

pub fn handle_input_shortcut(&mut self, key: &EventKey) -> bool

Handle a shortcut in input mode.

pub fn inhibit_handle_shortcut(
    current_mode: &Rc<Cell<Mode>>,
    key: &EventKey
) -> Inhibit

Check if the key should be inhibitted for the shortcut.

pub fn handle_shortcut(&mut self, key: &EventKey) -> Option<Msg<COMM, SETT>>

Handle a possible input of a shortcut.

Trait Implementations

impl<COMM, SETT> Container for Mg<COMM, SETT> where
    COMM: Clone + EnumFromStr + EnumMetaData + SpecialCommand + 'static,
    SETT: Default + EnumMetaData + Settings + SettingCompletion + 'static, 

type Container = Box

The type of the containing widget, i.e. where the child widgets will be added.

type Containers = MgContainers

Type to contain the additional container widgets.

fn container(&self) -> &Self::Container

Get the containing widget, i.e. the widget where the children will be added.

fn other_containers(&self) -> Self::Containers

Get additional container widgets. This is useful to create a multi-container.

fn add_widget<WIDGET: Widget>(
    container: &ContainerComponent<Self>,
    widget: &Component<WIDGET>
) -> Container

Add a relm widget to this container. Return the widget that will be send to Widget::on_add().

impl<COMM, SETT> Update for Mg<COMM, SETT> where
    COMM: Clone + EnumFromStr + EnumMetaData + SpecialCommand + 'static,
    SETT: Default + EnumMetaData + Settings + SettingCompletion + 'static, 

type Msg = Msg<COMM, SETT>

The type of the messages sent to the update() method.

type Model = Model<COMM, SETT>

The type of the model.

type ModelParam = (Modes, Result<PathBuf>, Option<PathBuf>, Vec<DefaultConfig>)

The type of the parameter of the model() function used to initialize the model.

fn update(&mut self, event: Msg<COMM, SETT>)

Method called when a message is received from an event.

fn model(
    relm: &Relm<Self>,
    (user_modes, settings_filename, include_path, default_config): (Modes, Result<PathBuf>, Option<PathBuf>, Vec<DefaultConfig>)
) -> Model<COMM, SETT>

Create the initial model.

pub fn subscriptions(&mut self, _relm: &Relm<Self>)

Connect the subscriptions. Subscriptions are Future/Stream that are spawn when the object is created.

impl<COMM, SETT> Widget for Mg<COMM, SETT> where
    COMM: Clone + EnumFromStr + EnumMetaData + SpecialCommand + 'static,
    SETT: Default + EnumMetaData + Settings + SettingCompletion + 'static, 

An Mg application window contains a status bar where the user can type a command and a central widget.

fn init_view(&mut self)

Update the view after it is initially created. This method is only useful when using the #[widget] attribute, because when not using it, you can use the view() method instead.

fn view(relm: &Relm<Self>, __relm_model: Self::Model) -> Self

Create the initial view.

type Root = Window

The type of the root widget.

fn root(&self) -> Self::Root

Get the root widget of the view.

pub fn on_add<W>(&self, _parent: W) where
    W: IsA<Widget> + IsA<Object>, 

Method called when the widget is added to its parent. This is currently only used to set the child properties of a widget as relm widget could have child properties and we don't know its parent when it is defined. Thus, we call on_add() when it is added to its parent to set the child properties.

pub fn parent_id() -> Option<&'static str>

Get the parent ID. This is useful for custom Container implementation: when you implement the Container::add_widget(), you might want to insert widgets elsewhere depending of this id.

pub fn run(model_param: Self::ModelParam) -> Result<(), ()> where
    Self: 'static, 

Create the window from this widget and start the main loop.