Enum AppKeyAction 

pub enum AppKeyAction {
    MoveUp,
    MoveDown,
    MoveLeft,
    MoveRight,
    MoveLineStart,
    MoveLineEnd,
    DeleteCharBefore,
    DeleteCharAt,
    KillLine,
    InsertNewline,
    InsertChar(char),
    Submit,
    Interrupt,
    Quit,
    RequestExit,
    ActivateSlashPopup,
    Custom(Arc<dyn Any + Send + Sync>),
}

Application-level key actions.

These are commands that the App knows how to execute. The KeyHandler doesn’t call methods directly - it returns an Action and the App executes it. This keeps the handler decoupled from App internals.

Note: This enum implements Clone and PartialEq manually due to the Custom variant containing a trait object. Custom actions are compared by Arc pointer equality and cloned by Arc reference counting.

Variants

MoveUp

Move cursor up one line.

MoveDown

Move cursor down one line.

MoveLeft

Move cursor left one character.

MoveRight

Move cursor right one character.

MoveLineStart

Move cursor to the start of the current line.

MoveLineEnd

Move cursor to the end of the current line.

DeleteCharBefore

Delete character before cursor (Backspace).

DeleteCharAt

Delete character at cursor (Delete).

KillLine

Kill text from cursor to end of line.

InsertNewline

Insert a newline character in multi-line input.

InsertChar(char)

Insert a character.

Submit

Submit the current message.

Interrupt

Interrupt the current LLM request.

Quit

Quit the application immediately (force quit, Ctrl+Q).

RequestExit

Request exit - handler manages confirmation, App calls ExitHandler.

ActivateSlashPopup

Activate the slash command popup.

Custom(Arc<dyn Any + Send + Sync>)

Custom action for user-defined behavior.

The handler returns this, and the app receives it via a callback. Use Arc to allow cheap cloning and type-erased storage.

Example

// Define your custom action type
struct MyAction { command: String }

// Create a custom action
let action = AppKeyAction::custom(MyAction { command: "foo".into() });

// In your app, downcast to handle it
if let AppKeyAction::Custom(any) = action {
    if let Some(my_action) = any.downcast_ref::<MyAction>() {
        println!("Command: {}", my_action.command);
    }
}

Implementations

impl AppKeyAction

pub fn custom<T: Any + Send + Sync + 'static>(value: T) -> Self

Create a custom action from any type that is Send + Sync + ’static.

Trait Implementations

impl Clone for AppKeyAction

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AppKeyAction

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

Formats the value using the given formatter.

impl PartialEq for AppKeyAction

fn eq(&self, other: &Self) -> 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.