Struct EventBus 

pub struct EventBus<S, A, Id, Ctx>
where
    A: Action,
    Id: ComponentId,
    Ctx: BindingContext,
{ /* private fields */ }

Event bus that manages subscriptions and dispatches events.

Implementations

impl<S, A, Id, Ctx> EventBus<S, A, Id, Ctx>

where S: 'static, A: Action, Id: ComponentId + 'static, Ctx: BindingContext + 'static,

pub fn new() -> EventBus<S, A, Id, Ctx>

Create a new event bus.

pub fn with_global_key_policy( self, policy: GlobalKeyPolicy, ) -> EventBus<S, A, Id, Ctx>

Set the global key policy.

Controls which key events are treated as “global” — global events bypass modal blocking and are delivered to global subscribers.

Example

// Don't treat Esc as global (useful for modal-heavy apps)
let bus = EventBus::new()
    .with_global_key_policy(GlobalKeyPolicy::without_esc());

pub fn register<F>(&mut self, component: Id, handler: F)

where F: for<'a, 'ctx> FnMut(RoutedEvent<'ctx, Id, Ctx>, &'a S) -> HandlerResponse<A> + 'static,

Register a handler for a component ID.

pub fn register_handler<H>(&mut self, component: Id, handler: H)

where H: EventHandler<S, A, Id, Ctx> + 'static,

Register a component handler that implements EventHandler.

pub fn register_global<F>(&mut self, handler: F)

where F: for<'a, 'ctx> FnMut(RoutedEvent<'ctx, Id, Ctx>, &'a S) -> HandlerResponse<A> + 'static,

Register a global handler (not tied to a component).

pub fn register_global_handler<H>(&mut self, handler: H)

where H: EventHandler<S, A, Id, Ctx> + 'static,

Register a global handler that implements EventHandler.

pub fn unregister( &mut self, component: Id, ) -> Option<Box<dyn for<'a, 'ctx> FnMut(RoutedEvent<'ctx, Id, Ctx>, &'a S) -> HandlerResponse<A>>>

Unregister a component handler.

pub fn subscribe(&mut self, component: Id, event_type: EventType)

Subscribe a component to an event type.

pub fn subscribe_many(&mut self, component: Id, event_types: &[EventType])

Subscribe a component to multiple event types.

pub fn unsubscribe(&mut self, component: Id, event_type: EventType)

Unsubscribe a component from an event type.

pub fn unsubscribe_all(&mut self, component: Id)

Unsubscribe a component from all event types.

pub fn get_subscribers(&self, event_type: EventType) -> Vec<Id>

Get subscribers for an event type.

pub fn context_mut(&mut self) -> &mut EventContext<Id>

Get mutable reference to context.

pub fn context(&self) -> &EventContext<Id>

Get reference to context.

pub fn handle_event( &mut self, event: &EventKind, state: &S, keybindings: &Keybindings<Ctx>, ) -> EventOutcome<A>

where S: EventRoutingState<Id, Ctx>,

Route an event through the bus and collect actions.

Routing priority: Modal → Hovered → Focused → Subscribers → Global handlers. Modal blocks non-broadcast events from reaching other components.

Trait Implementations

impl<S, A, Id, Ctx> Default for EventBus<S, A, Id, Ctx>

where S: 'static, A: Action, Id: ComponentId + 'static, Ctx: BindingContext + 'static,

fn default() -> EventBus<S, A, Id, Ctx>

Returns the “default value” for a type.