Enum 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<I>),
    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<I>)

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<I: Clone + ApplicationInfo> Clone for Action<I>

where I::Action: Clone,

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

Returns a duplicate 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<I>> for Action<I>

fn from(act: CommandBarAction<I>) -> 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: PartialEq + ApplicationInfo> PartialEq for Action<I>

where I::Action: PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

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

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>