Struct KeyPressEvent 

pub struct KeyPressEvent {
    pub key: KeyInput,
    pub session_id: SessionId,
    pub client_id: ClientId,
}

Key press event emitted when a key is received.

This event is emitted by the runner’s event loop and handled by registered key handlers. The handler performs key resolution and returns state changes via the result holder.

Synchronous Processing

Key events are processed synchronously via bus.emit() because:

• Key handling must complete before the next key is read
• State mutations need to happen in order
• Latency requirements demand immediate processing

Session Routing

The session_id and client_id identify which session should process the key. Handlers filter events by session ID.

Example

use reovim_kernel::api::v1::{EventBus, EventResult};
use reovim_kernel::api::v1::events::{KeyInput, KeyCode, Modifiers, priority};
use reovim_kernel::api::v1::events::key::{KeyPressEvent, SessionId, ClientId};

let bus = EventBus::new();

// Register handler for session 0
let session_id = SessionId::new(0);
let _sub = bus.subscribe::<KeyPressEvent, _>(priority::CORE, move |event| {
    if event.session_id != session_id {
        return EventResult::NotHandled;
    }
    // Process key...
    EventResult::Handled
});

// Emit key event
let key = KeyInput {
    key: KeyCode::Char('j'),
    modifiers: Modifiers::NONE,
};
bus.emit(KeyPressEvent::new(key, SessionId::new(0), ClientId::new(1)));

Fields

key: KeyInput

The key input from the input driver.

session_id: SessionId

Session ID for routing.

client_id: ClientId

Client ID that originated this key.

Implementations

impl KeyPressEvent

pub const fn new( key: KeyInput, session_id: SessionId, client_id: ClientId, ) -> Self

Create a new key press event.

pub const fn event_type(&self) -> &'static str

Get the event type name for logging.

Trait Implementations

impl Clone for KeyPressEvent

fn clone(&self) -> KeyPressEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KeyPressEvent

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

Formats the value using the given formatter.

impl Event for KeyPressEvent

fn priority(&self) -> u32

Priority for handler dispatch ordering.

fn batchable(&self) -> bool

Whether this event can be batched with similar events.

impl PartialEq for KeyPressEvent

fn eq(&self, other: &KeyPressEvent) -> 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 Eq for KeyPressEvent

impl StructuralPartialEq for KeyPressEvent