use crossterm::event::{KeyEvent, KeyModifiers, MouseEvent};
use ratatui::layout::Rect;
use std::collections::HashMap;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ComponentId {
KeyList,
ValueViewer,
ConnectionPalette,
ConnectionForm,
WelcomeScreen,
StatusBar,
Help,
QuitConfirmation,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum EventType {
Key,
Mouse,
Scroll,
Resize,
Tick,
Global,
}
#[derive(Debug, Clone)]
pub enum EventKind {
Key(KeyEvent),
Mouse(MouseEvent),
Scroll { column: u16, row: u16, delta: isize },
Resize(u16, u16),
Tick,
}
impl EventKind {
pub fn event_type(&self) -> EventType {
match self {
EventKind::Key(_) => EventType::Key,
EventKind::Mouse(_) => EventType::Mouse,
EventKind::Scroll { .. } => EventType::Scroll,
EventKind::Resize(_, _) => EventType::Resize,
EventKind::Tick => EventType::Tick,
}
}
pub fn is_global(&self) -> bool {
match self {
EventKind::Key(key) => {
use crossterm::event::KeyCode;
matches!(key.code, KeyCode::Esc)
|| (key.modifiers.contains(KeyModifiers::CONTROL)
&& matches!(key.code, KeyCode::Char('c') | KeyCode::Char('q')))
}
EventKind::Resize(_, _) => true, _ => false,
}
}
}
#[derive(Debug, Clone)]
pub struct EventContext {
pub focused_component: Option<ComponentId>,
pub mouse_position: Option<(u16, u16)>,
pub modifiers: KeyModifiers,
pub component_areas: HashMap<ComponentId, Rect>,
pub is_modal_open: bool,
pub active_modal: Option<ComponentId>,
}
impl Default for EventContext {
fn default() -> Self {
Self {
focused_component: None,
mouse_position: None,
modifiers: KeyModifiers::NONE,
component_areas: HashMap::new(),
is_modal_open: false,
active_modal: None,
}
}
}
impl EventContext {
pub fn new() -> Self {
Self::default()
}
pub fn is_focused(&self, component: ComponentId) -> bool {
self.focused_component == Some(component)
}
pub fn point_in_component(&self, component: ComponentId, x: u16, y: u16) -> bool {
self.component_areas
.get(&component)
.map(|area| {
x >= area.x
&& x < area.x.saturating_add(area.width)
&& y >= area.y
&& y < area.y.saturating_add(area.height)
})
.unwrap_or(false)
}
pub fn component_at(&self, x: u16, y: u16) -> Option<ComponentId> {
if let Some(modal) = self.active_modal {
if self.point_in_component(modal, x, y) {
return Some(modal);
}
}
for (&id, area) in &self.component_areas {
if Some(id) != self.active_modal
&& x >= area.x
&& x < area.x.saturating_add(area.width)
&& y >= area.y
&& y < area.y.saturating_add(area.height)
{
return Some(id);
}
}
None
}
pub fn set_component_area(&mut self, component: ComponentId, area: Rect) {
self.component_areas.insert(component, area);
}
pub fn set_focus(&mut self, component: Option<ComponentId>) {
self.focused_component = component;
}
pub fn set_modal(&mut self, modal: Option<ComponentId>) {
self.active_modal = modal;
self.is_modal_open = modal.is_some();
if let Some(m) = modal {
self.focused_component = Some(m);
}
}
}
#[derive(Debug, Clone)]
pub struct Event {
pub kind: EventKind,
pub context: EventContext,
}
impl Event {
pub fn new(kind: EventKind, context: EventContext) -> Self {
Self { kind, context }
}
pub fn event_type(&self) -> EventType {
self.kind.event_type()
}
pub fn is_global(&self) -> bool {
self.kind.is_global()
}
}