248 lines
10 KiB
Rust
248 lines
10 KiB
Rust
// src/modes/handlers/event.rs
|
|
use crossterm::event::{Event, KeyEvent};
|
|
use crossterm::cursor::SetCursorStyle;
|
|
use crate::tui::terminal::{
|
|
core::TerminalCore,
|
|
grpc_client::GrpcClient,
|
|
commands::CommandHandler,
|
|
};
|
|
use crate::config::binds::config::Config;
|
|
use crate::ui::handlers::form::FormState;
|
|
use crate::ui::handlers::rat_state::UiStateHandler;
|
|
use crate::modes::{
|
|
common::{command_mode},
|
|
canvas::{edit, read_only, common},
|
|
general::navigation,
|
|
};
|
|
use crate::config::binds::key_sequences::KeySequenceTracker;
|
|
use crate::modes::handlers::mode_manager::{ModeManager, AppMode};
|
|
|
|
pub struct EventHandler {
|
|
pub command_mode: bool,
|
|
pub command_input: String,
|
|
pub command_message: String,
|
|
pub is_edit_mode: bool,
|
|
pub edit_mode_cooldown: bool,
|
|
pub ideal_cursor_column: usize,
|
|
pub key_sequence_tracker: KeySequenceTracker,
|
|
}
|
|
|
|
impl EventHandler {
|
|
pub fn new() -> Self {
|
|
EventHandler {
|
|
command_mode: false,
|
|
command_input: String::new(),
|
|
command_message: String::new(),
|
|
is_edit_mode: false,
|
|
edit_mode_cooldown: false,
|
|
ideal_cursor_column: 0,
|
|
key_sequence_tracker: KeySequenceTracker::new(800),
|
|
}
|
|
}
|
|
|
|
pub async fn handle_event(
|
|
&mut self,
|
|
event: Event,
|
|
config: &Config,
|
|
terminal: &mut TerminalCore,
|
|
grpc_client: &mut GrpcClient,
|
|
command_handler: &mut CommandHandler,
|
|
form_state: &mut FormState,
|
|
app_state: &mut crate::state::state::AppState,
|
|
total_count: u64,
|
|
current_position: &mut u64,
|
|
) -> Result<(bool, String), Box<dyn std::error::Error>> {
|
|
// Determine current mode based on app state and event handler state
|
|
let current_mode = ModeManager::derive_mode(app_state, self);
|
|
app_state.update_mode(current_mode);
|
|
|
|
if let Event::Key(key) = event {
|
|
let key_code = key.code;
|
|
let modifiers = key.modifiers;
|
|
|
|
// Handle common actions across all modes
|
|
if UiStateHandler::toggle_sidebar(&mut app_state.ui, config, key_code, modifiers) {
|
|
return Ok((false, format!("Sidebar {}",
|
|
if app_state.ui.show_sidebar { "shown" } else { "hidden" }
|
|
)));
|
|
}
|
|
|
|
// Mode-specific handling
|
|
match current_mode {
|
|
AppMode::General => {
|
|
return navigation::handle_navigation_event(
|
|
key,
|
|
config,
|
|
form_state,
|
|
app_state,
|
|
&mut self.command_mode,
|
|
&mut self.command_input,
|
|
&mut self.command_message,
|
|
).await;
|
|
},
|
|
|
|
AppMode::ReadOnly => {
|
|
// Check for mode transitions first
|
|
if config.is_enter_edit_mode_before(key_code, modifiers) &&
|
|
ModeManager::can_enter_edit_mode(current_mode) {
|
|
self.is_edit_mode = true;
|
|
self.edit_mode_cooldown = true;
|
|
self.command_message = "Edit mode".to_string();
|
|
terminal.set_cursor_style(SetCursorStyle::BlinkingBar)?;
|
|
return Ok((false, self.command_message.clone()));
|
|
}
|
|
|
|
if config.is_enter_edit_mode_after(key_code, modifiers) &&
|
|
ModeManager::can_enter_edit_mode(current_mode) {
|
|
let current_input = form_state.get_current_input();
|
|
if !current_input.is_empty() && form_state.current_cursor_pos < current_input.len() {
|
|
form_state.current_cursor_pos += 1;
|
|
self.ideal_cursor_column = form_state.current_cursor_pos;
|
|
}
|
|
self.is_edit_mode = true;
|
|
self.edit_mode_cooldown = true;
|
|
self.command_message = "Edit mode (after cursor)".to_string();
|
|
terminal.set_cursor_style(SetCursorStyle::BlinkingBar)?;
|
|
return Ok((false, self.command_message.clone()));
|
|
}
|
|
|
|
// Check for entering command mode
|
|
if let Some(action) = config.get_read_only_action_for_key(key_code, modifiers) {
|
|
if action == "enter_command_mode" && ModeManager::can_enter_command_mode(current_mode) {
|
|
self.command_mode = true;
|
|
self.command_input.clear();
|
|
self.command_message.clear();
|
|
return Ok((false, String::new()));
|
|
}
|
|
}
|
|
|
|
// Check for core application actions (save, quit, etc.)
|
|
// ONLY handle a limited subset of core actions here
|
|
if let Some(action) = config.get_action_for_key_in_mode(
|
|
&config.keybindings.common,
|
|
key_code,
|
|
modifiers
|
|
) {
|
|
match action {
|
|
"save" | "force_quit" | "save_and_quit" | "revert" => {
|
|
return common::handle_core_action(
|
|
action,
|
|
form_state,
|
|
grpc_client,
|
|
command_handler,
|
|
terminal,
|
|
app_state,
|
|
current_position,
|
|
total_count,
|
|
).await;
|
|
},
|
|
_ => {} // For other actions, let the mode-specific handler take care of it
|
|
}
|
|
}
|
|
|
|
// Let read_only mode handle its own actions (including navigation from common bindings)
|
|
return read_only::handle_read_only_event(
|
|
key,
|
|
config,
|
|
form_state,
|
|
&mut self.key_sequence_tracker,
|
|
current_position,
|
|
total_count,
|
|
grpc_client,
|
|
&mut self.command_message,
|
|
&mut self.edit_mode_cooldown,
|
|
&mut self.ideal_cursor_column,
|
|
).await;
|
|
},
|
|
|
|
AppMode::Edit => {
|
|
// Check for exiting edit mode
|
|
if config.is_exit_edit_mode(key_code, modifiers) {
|
|
if form_state.has_unsaved_changes {
|
|
self.command_message = "Unsaved changes! Use :w to save or :q! to discard".to_string();
|
|
return Ok((false, self.command_message.clone()));
|
|
}
|
|
self.is_edit_mode = false;
|
|
self.edit_mode_cooldown = true;
|
|
self.command_message = "Read-only mode".to_string();
|
|
terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?;
|
|
|
|
let current_input = form_state.get_current_input();
|
|
if !current_input.is_empty() && form_state.current_cursor_pos >= current_input.len() {
|
|
form_state.current_cursor_pos = current_input.len() - 1;
|
|
self.ideal_cursor_column = form_state.current_cursor_pos;
|
|
}
|
|
return Ok((false, self.command_message.clone()));
|
|
}
|
|
|
|
// Check for core application actions (save, quit, etc.)
|
|
// ONLY handle a limited subset of core actions here
|
|
if let Some(action) = config.get_action_for_key_in_mode(
|
|
&config.keybindings.common,
|
|
key_code,
|
|
modifiers
|
|
) {
|
|
match action {
|
|
"save" | "force_quit" | "save_and_quit" | "revert" => {
|
|
return common::handle_core_action(
|
|
action,
|
|
form_state,
|
|
grpc_client,
|
|
command_handler,
|
|
terminal,
|
|
app_state,
|
|
current_position,
|
|
total_count,
|
|
).await;
|
|
},
|
|
_ => {} // For other actions, let the mode-specific handler take care of it
|
|
}
|
|
}
|
|
|
|
// Let edit mode handle its own actions (including navigation from common bindings)
|
|
let result = edit::handle_edit_event_internal(
|
|
key,
|
|
config,
|
|
form_state,
|
|
&mut self.ideal_cursor_column,
|
|
&mut self.command_message,
|
|
&mut app_state.ui.is_saved,
|
|
current_position,
|
|
total_count,
|
|
grpc_client,
|
|
).await?;
|
|
|
|
self.key_sequence_tracker.reset();
|
|
return Ok((false, result));
|
|
},
|
|
|
|
AppMode::Command => {
|
|
let (should_exit, message, exit_command_mode) = command_mode::handle_command_event(
|
|
key,
|
|
config,
|
|
form_state,
|
|
&mut self.command_input,
|
|
&mut self.command_message,
|
|
grpc_client,
|
|
&mut app_state.ui.is_saved,
|
|
current_position,
|
|
total_count,
|
|
).await?;
|
|
|
|
if exit_command_mode {
|
|
self.command_mode = false;
|
|
}
|
|
|
|
return Ok((should_exit, message));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Non-key events or if no specific handler was matched
|
|
self.edit_mode_cooldown = false;
|
|
Ok((false, self.command_message.clone()))
|
|
}
|
|
|
|
|
|
}
|