Struct ComposedKeyHandler 

pub struct ComposedKeyHandler<H: KeyHandler> { /* private fields */ }

A composable key handler wrapper with pre-processing hooks.

ComposedKeyHandler wraps an inner handler and allows adding hooks that run before the inner handler processes keys. This enables:

• Intercepting specific keys before they reach the inner handler
• Adding logging or debugging behavior
• Implementing layered key handling (e.g., modal modes on top of base handler)

Example

let base_handler = DefaultKeyHandler::new(KeyBindings::emacs());
let handler = ComposedKeyHandler::new(base_handler)
    .with_pre_hook(|key, _ctx| {
        // Intercept F1 for help
        if key.code == KeyCode::F(1) {
            return Some(AppKeyResult::Action(AppKeyAction::custom(ShowHelp)));
        }
        None // Let inner handler process
    });

Implementations

impl<H: KeyHandler> ComposedKeyHandler<H>

pub fn new(inner: H) -> Self

Create a new composed handler wrapping the given inner handler.

pub fn with_pre_hook<F>(self, hook: F) -> Self

where F: Fn(&KeyEvent, &KeyContext) -> Option<AppKeyResult> + Send + 'static,

Add a hook that runs before the inner handler.

If the hook returns Some(result), that result is used and the inner handler is skipped. If the hook returns None, processing continues to the next hook or the inner handler.

Hooks are called in the order they were added.

Arguments

• hook - A function that receives the key event and context, returning Some(AppKeyResult) to handle the key or None to pass through

Example

let handler = ComposedKeyHandler::new(DefaultKeyHandler::default())
    .with_pre_hook(|key, ctx| {
        // Log all key presses
        eprintln!("Key: {:?}", key);
        None // Don't consume, let inner handler process
    })
    .with_pre_hook(|key, _ctx| {
        // Intercept Ctrl+H for custom help
        if key.code == KeyCode::Char('h') && key.modifiers == KeyModifiers::CONTROL {
            return Some(AppKeyResult::Action(AppKeyAction::custom(MyHelp)));
        }
        None
    });

pub fn inner(&self) -> &H

Get a reference to the inner handler.

pub fn inner_mut(&mut self) -> &mut H

Get a mutable reference to the inner handler.

Trait Implementations

impl<H: KeyHandler> KeyHandler for ComposedKeyHandler<H>

fn handle_key(&mut self, key: KeyEvent, context: &KeyContext) -> AppKeyResult

Handle a key event.

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

Get a status hint to display in the status bar.

fn bindings(&self) -> &KeyBindings

Get a reference to the key bindings.