Enum modalkit::actions::Action

#[non_exhaustive]
pub enum Action<I: ApplicationInfo = EmptyInfo> {
    NoOp,
    Editor(EditorAction),
    Macro(MacroAction),
    Jump(PositionList, MoveDir1D, Count),
    Repeat(RepeatType),
    Scroll(ScrollStyle),
    KeywordLookup,
    RedrawScreen,
    ShowInfoMessage(InfoMessage),
    Suspend,
    Search(MoveDirMod, Count),
    Command(CommandAction),
    CommandBar(CommandBarAction),
    Prompt(PromptAction),
    Tab(TabAction<I>),
    Window(WindowAction<I>),
    Application(I::Action),
}

The result of either pressing a complete keybinding sequence, or parsing a command.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

NoOp

Do nothing.

Editor(EditorAction)

Perform an editor action.

Macro(MacroAction)

Perform a macro-related action.

Jump(PositionList, MoveDir1D, Count)

Navigate through the cursor positions in the specified list.

If the current window cannot satisfy the given Count, then this may jump to other windows.

Repeat(RepeatType)

Repeat an action sequence with the current context.

Scroll(ScrollStyle)

Scroll the viewport in the specified manner.

KeywordLookup

Lookup the keyword under the cursor.

RedrawScreen

Redraw the screen.

ShowInfoMessage(InfoMessage)

Show an InfoMessage.

Suspend

Suspend the process.

Search(MoveDirMod, Count)

Find the n^th occurrence of the current application-level search.

Command(CommandAction)

Perform a command-related action.

CommandBar(CommandBarAction)

Perform a command bar-related action.

Prompt(PromptAction)

Perform a prompt-related action.

Tab(TabAction<I>)

Perform a tab-related action.

Window(WindowAction<I>)

Perform a window-related action.

Application(I::Action)

Application-specific command.

Implementations

impl<I: ApplicationInfo> Action<I>

pub fn is_edit_sequence( &self, motion: SequenceStatus, ctx: &EditContext ) -> SequenceStatus

Indicates how an action gets included in RepeatType::EditSequence.

motion indicates what to do with EditAction::Motion.

pub fn is_last_action(&self, ctx: &EditContext) -> SequenceStatus

Indicates how an action gets included in RepeatType::LastAction.

pub fn is_last_selection(&self, ctx: &EditContext) -> SequenceStatus

Indicates how an action gets included in RepeatType::LastSelection.

pub fn is_switchable(&self, ctx: &EditContext) -> bool

Returns true if this Action is allowed to trigger a WindowAction::Switch after an error.

Trait Implementations

impl<K, I> BindingMachine<K, Action<I>, RepeatType, EditContext> for MixedBindings<K, I>

where K: InputKey, I: ApplicationInfo, InputStep<I>: Step<K, A = Action<I>, Sequence = RepeatType, State = EmacsState<I>>, InputStep<I>: Step<K, A = Action<I>, Sequence = RepeatType, State = VimState<I>>,

fn input_key(&mut self, key: K)

Process a typed key.

fn pop(&mut self) -> Option<(Action<I>, EditContext)>

Fetch the next action produced by previously typed keys.

fn context(&mut self) -> EditContext

Get current output context after the most recent keypress.

fn show_dialog(&mut self, max_rows: usize, max_cols: usize) -> Vec<Cow<'_, str>>

Returns the message to display for the current interactive dialog, if there is one.

fn show_mode(&self) -> Option<String>

Returns a user-friendly string to display for the current mode.

fn get_cursor_indicator(&self) -> Option<char>

Returns a character to show for the cursor.

fn repeat(&mut self, rt: RepeatType, other: Option<EditContext>)

Repeat a recent sequence of tracked actions, and optionally override their original contexts using InputState::merge. The repeated sequence will be inserted at the beginning of the action queue, before any other pending actions.

fn run_dialog(&mut self, dialog: Box<dyn Dialog<Action<I>>>)

Start an interactive user dialog.

impl<I: Clone + ApplicationInfo> Clone for Action<I>

where I::Action: Clone,

fn clone(&self) -> Action<I>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<I: Debug + ApplicationInfo> Debug for Action<I>

where I::Action: Debug,

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

Formats the value using the given formatter.

impl<I: ApplicationInfo> Default for Action<I>

fn default() -> Self

Returns the “default value” for a type.

impl<I: ApplicationInfo> From<CommandAction> for Action<I>

fn from(act: CommandAction) -> Self

Converts to this type from the input type.

impl<I: ApplicationInfo> From<CommandBarAction> for Action<I>

fn from(act: CommandBarAction) -> Self

Converts to this type from the input type.

impl<I: ApplicationInfo> From<CursorAction> for Action<I>

fn from(act: CursorAction) -> Self

Converts to this type from the input type.

impl<I: ApplicationInfo> From<EditorAction> for Action<I>

fn from(act: EditorAction) -> Self

Converts to this type from the input type.

impl<I: ApplicationInfo> From<HistoryAction> for Action<I>

fn from(act: HistoryAction) -> Self

Converts to this type from the input type.

impl<I: ApplicationInfo> From<InsertTextAction> for Action<I>

fn from(act: InsertTextAction) -> Self

Converts to this type from the input type.

impl<I: ApplicationInfo> From<MacroAction> for Action<I>

fn from(act: MacroAction) -> Self

Converts to this type from the input type.

impl<I: ApplicationInfo> From<PromptAction> for Action<I>

fn from(act: PromptAction) -> Self

Converts to this type from the input type.

impl<I: ApplicationInfo> From<SelectionAction> for Action<I>

fn from(act: SelectionAction) -> Self

Converts to this type from the input type.

impl<I: ApplicationInfo> From<TabAction<I>> for Action<I>

fn from(act: TabAction<I>) -> Self

Converts to this type from the input type.

impl<I: ApplicationInfo> From<WindowAction<I>> for Action<I>

fn from(act: WindowAction<I>) -> Self

Converts to this type from the input type.

impl<I: ApplicationInfo> Mode<Action<I>, EmacsState<I>> for EmacsMode

fn enter(&self, _: Self, ctx: &mut EmacsState<I>) -> Vec<Action<I>>

Perform any necessary updates when entering a new mode.

fn show(&self, ctx: &EmacsState<I>) -> Option<String>

Return a string to show on-screen that describes the current mode.

impl<I: ApplicationInfo> Mode<Action<I>, VimState<I>> for VimMode

fn enter(&self, prev: Self, ctx: &mut VimState<I>) -> Vec<Action<I>>

Perform any necessary updates when entering a new mode.

fn show(&self, ctx: &VimState<I>) -> Option<String>

Return a string to show on-screen that describes the current mode.

impl<I: ApplicationInfo> ModeKeys<TerminalKey, Action<I>, EmacsState<I>> for EmacsMode

fn unmapped( &self, ke: &TerminalKey, ctx: &mut EmacsState<I> ) -> (Vec<Action<I>>, Option<Self>)

Return the default behaviour for the current mode when the given key is unmapped.

impl<I: ApplicationInfo> ModeKeys<TerminalKey, Action<I>, VimState<I>> for VimMode

fn unmapped( &self, ke: &TerminalKey, ctx: &mut VimState<I> ) -> (Vec<Action<I>>, Option<Self>)

Return the default behaviour for the current mode when the given key is unmapped.

impl<I: ApplicationInfo> ModeSequence<RepeatType, Action<I>, EmacsState<I>> for EmacsMode

fn sequences( &self, action: &Action<I>, ctx: &EditContext ) -> Vec<(RepeatType, SequenceStatus)>

Controls how and what gets included in the sequences of actions tracked by ModalMachine. When implementing, if there are actions that trigger calls to BindingMachine::repeat, be careful that they do not get included in a way that can create cycles.

impl<I: ApplicationInfo> ModeSequence<RepeatType, Action<I>, VimState<I>> for VimMode

fn sequences( &self, action: &Action<I>, ctx: &EditContext ) -> Vec<(RepeatType, SequenceStatus)>

Controls how and what gets included in the sequences of actions tracked by ModalMachine. When implementing, if there are actions that trigger calls to BindingMachine::repeat, be careful that they do not get included in a way that can create cycles.

impl<I: PartialEq + ApplicationInfo> PartialEq for Action<I>

where I::Action: PartialEq,

fn eq(&self, other: &Action<I>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I: Eq + ApplicationInfo> Eq for Action<I>

where I::Action: Eq,

impl<I: ApplicationInfo> StructuralPartialEq for Action<I>