filipriec/komp_ac
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

complete redesign

Browse Source
This commit is contained in:
filipriec
2025-02-22 23:23:07 +01:00
parent d9e812ac1b
commit 5a81a37678
83 changed files with 3578 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

422
client/src/ui/handlers/event.rs Normal file
View File

@@ -0,0 +1,422 @@
// src/client/ui/handlers/event.rs
use crossterm::event::{Event, KeyCode, KeyModifiers};
use crossterm::cursor::{SetCursorStyle};
use crate::client::terminal::AppTerminal;
use crate::client::config::Config;
use common::proto::multieko2::adresar::{PostAdresarRequest, PutAdresarRequest};
use super::form::FormState;
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,
}
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,
}
}
pub async fn handle_event(
&mut self,
event: Event,
config: &Config,
app_terminal: &mut AppTerminal,
form_state: &mut FormState,
is_saved: &mut bool,
total_count: u64,
current_position: &mut u64,
) -> Result<(bool, String), Box<dyn std::error::Error>> {
if let Event::Key(key) = event {
if !self.is_edit_mode && config.is_enter_edit_mode(key.code, key.modifiers) {
self.is_edit_mode = true;
self.edit_mode_cooldown = true;
self.command_message = "Edit mode".to_string();
app_terminal.set_cursor_style(SetCursorStyle::BlinkingBar)?;
return Ok((false, self.command_message.clone()));
} else if self.is_edit_mode && config.is_exit_edit_mode(key.code, key.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();
app_terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?;
return Ok((false, self.command_message.clone()));
}
if !self.is_edit_mode {
// Handle navigation between entries
if key.code == KeyCode::Left {
let new_position = current_position.saturating_sub(1);
if new_position >= 1 {
*current_position = new_position;
match app_terminal.get_adresar_by_position(*current_position).await {
Ok(response) => {
// Update the ID field - this is what was missing
form_state.id = response.id;
// Update all form fields dynamically
form_state.values = vec![
response.firma,
response.kz,
response.drc,
response.ulica,
response.psc,
response.mesto,
response.stat,
response.banka,
response.ucet,
response.skladm,
response.ico,
response.kontakt,
response.telefon,
response.skladu,
response.fax,
];
let current_input = form_state.get_current_input();
form_state.current_cursor_pos = self.ideal_cursor_column.min(current_input.len());
form_state.has_unsaved_changes = false;
self.command_message = format!("Loaded entry {}", *current_position);
}
Err(e) => {
self.command_message = format!("Error loading entry: {}", e);
}
}
return Ok((false, self.command_message.clone()));
}
} else if key.code == KeyCode::Right {
if *current_position <= total_count {
*current_position += 1;
if *current_position <= total_count {
match app_terminal.get_adresar_by_position(*current_position).await {
Ok(response) => {
// Update the ID field - this was missing
form_state.id = response.id;
// Update all form fields dynamically
form_state.values = vec![
response.firma,
response.kz,
response.drc,
response.ulica,
response.psc,
response.mesto,
response.stat,
response.banka,
response.ucet,
response.skladm,
response.ico,
response.kontakt,
response.telefon,
response.skladu,
response.fax,
];
let current_input = form_state.get_current_input();
form_state.current_cursor_pos = self.ideal_cursor_column.min(current_input.len());
form_state.has_unsaved_changes = false;
self.command_message = format!("Loaded entry {}", *current_position);
}
Err(e) => {
self.command_message = format!("Error loading entry: {}", e);
}
}
} else {
// Clear form when entering new entry position
form_state.reset_to_empty();
form_state.current_field = 0;
form_state.current_cursor_pos = 0;
self.command_message = "New entry mode".to_string();
}
return Ok((false, self.command_message.clone()));
}
} else {
// Handle movement keybindings
if let Some(action) = config.get_action_for_key(key.code, key.modifiers) {
match action {
"move_left" => {
form_state.current_cursor_pos = form_state.current_cursor_pos.saturating_sub(1);
self.ideal_cursor_column = form_state.current_cursor_pos;
return Ok((false, "".to_string()));
}
"move_right" => {
let current_input = form_state.get_current_input();
if form_state.current_cursor_pos < current_input.len() {
form_state.current_cursor_pos += 1;
}
self.ideal_cursor_column = form_state.current_cursor_pos;
return Ok((false, "".to_string()));
}
"move_up" => {
if form_state.current_field == 0 {
// Wrap to the last field when at the top
form_state.current_field = form_state.fields.len() - 1;
} else {
form_state.current_field = form_state.current_field.saturating_sub(1);
}
let current_input = form_state.get_current_input();
form_state.current_cursor_pos = self.ideal_cursor_column.min(current_input.len());
return Ok((false, "".to_string()));
}
"move_down" => {
form_state.current_field = (form_state.current_field + 1) % form_state.fields.len();
let current_input = form_state.get_current_input();
form_state.current_cursor_pos = self.ideal_cursor_column.min(current_input.len());
return Ok((false, "".to_string()));
}
_ => {}
}
}
// Handle other keys (e.g., command mode)
match key.code {
KeyCode::Char(':') => {
self.command_mode = true;
self.command_input.clear();
self.command_message.clear();
}
KeyCode::Esc => {
self.command_mode = false;
self.command_input.clear();
self.command_message.clear();
}
_ => {
if !self.edit_mode_cooldown {
let default_key = "i".to_string();
let edit_key = config.keybindings.get("enter_edit_mode")
.and_then(|keys| keys.first())
.unwrap_or(&default_key);
self.command_message = format!("Read-only mode - press {} to edit", edit_key);
}
}
}
}
} else {
// Edit mode handling
if self.command_mode {
match key.code {
KeyCode::Enter => {
let command = self.command_input.trim();
if command.is_empty() {
self.command_message = "Empty command".to_string();
return Ok((false, self.command_message.clone()));
}
let action = config.get_action_for_command(command)
.unwrap_or("unknown");
if action == "save" {
let is_new = *current_position == total_count + 1;
let message = if is_new {
// POST new entry
let post_request = PostAdresarRequest {
firma: form_state.values[0].clone(),
kz: form_state.values[1].clone(),
drc: form_state.values[2].clone(),
ulica: form_state.values[3].clone(),
psc: form_state.values[4].clone(),
mesto: form_state.values[5].clone(),
stat: form_state.values[6].clone(),
banka: form_state.values[7].clone(),
ucet: form_state.values[8].clone(),
skladm: form_state.values[9].clone(),
ico: form_state.values[10].clone(),
kontakt: form_state.values[11].clone(),
telefon: form_state.values[12].clone(),
skladu: form_state.values[13].clone(),
fax: form_state.values[14].clone(),
};
let response = app_terminal.post_adresar(post_request).await?;
// Update state
let new_total = app_terminal.get_adresar_count().await?;
*current_position = new_total;
form_state.id = response.into_inner().id;
"New entry created".to_string()
} else {
// PUT existing entry
let put_request = PutAdresarRequest {
id: form_state.id,
firma: form_state.values[0].clone(),
kz: form_state.values[1].clone(),
drc: form_state.values[2].clone(),
ulica: form_state.values[3].clone(),
psc: form_state.values[4].clone(),
mesto: form_state.values[5].clone(),
stat: form_state.values[6].clone(),
banka: form_state.values[7].clone(),
ucet: form_state.values[8].clone(),
skladm: form_state.values[9].clone(),
ico: form_state.values[10].clone(),
kontakt: form_state.values[11].clone(),
telefon: form_state.values[12].clone(),
skladu: form_state.values[13].clone(),
fax: form_state.values[14].clone(),
};
let _ = app_terminal.put_adresar(put_request).await?;
"Entry updated".to_string()
};
*is_saved = true;
form_state.has_unsaved_changes = false;
self.command_input.clear(); // Clear the command input
self.command_mode = false; // Reset command mode
self.command_message.clear(); // Clear the command message
return Ok((false, message));
} else {
let (should_exit, message) = app_terminal
.handle_command(action, is_saved)
.await?;
self.command_message = message;
self.command_input.clear(); // Clear the command input
self.command_mode = false; // Reset command mode
return Ok((should_exit, self.command_message.clone()));
}
}
KeyCode::Char(c) => self.command_input.push(c),
KeyCode::Backspace => {
self.command_input.pop();
}
KeyCode::Esc => {
self.command_mode = false;
self.command_input.clear();
self.command_message.clear();
}
_ => {}
}
} else {
// Handle arrow keys in edit mode
match key.code {
KeyCode::Left => {
form_state.current_cursor_pos = form_state.current_cursor_pos.saturating_sub(1);
self.ideal_cursor_column = form_state.current_cursor_pos;
return Ok((false, "".to_string()));
}
KeyCode::Right => {
let current_input = form_state.get_current_input();
if form_state.current_cursor_pos < current_input.len() {
form_state.current_cursor_pos += 1;
self.ideal_cursor_column = form_state.current_cursor_pos;
}
return Ok((false, "".to_string()));
}
KeyCode::Char(':') => {
self.command_mode = true;
self.command_input.clear();
self.command_message.clear();
}
KeyCode::Esc => {
if config.is_exit_edit_mode(key.code, key.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();
return Ok((false, self.command_message.clone()));
}
}
KeyCode::Down => {
form_state.current_field = (form_state.current_field + 1) % form_state.fields.len();
let current_input = form_state.get_current_input();
form_state.current_cursor_pos = self.ideal_cursor_column.min(current_input.len());
}
KeyCode::Up => {
if form_state.current_field == 0 {
form_state.current_field = form_state.fields.len() - 1;
} else {
form_state.current_field = form_state.current_field.saturating_sub(1);
}
let current_input = form_state.get_current_input();
form_state.current_cursor_pos = self.ideal_cursor_column.min(current_input.len());
}
KeyCode::Tab => {
if key.modifiers.contains(KeyModifiers::SHIFT) {
if form_state.current_field == 0 {
form_state.current_field = form_state.fields.len() - 1;
} else {
form_state.current_field = form_state.current_field.saturating_sub(1);
}
} else {
form_state.current_field = (form_state.current_field + 1) % form_state.fields.len();
}
let current_input = form_state.get_current_input();
form_state.current_cursor_pos = self.ideal_cursor_column.min(current_input.len());
}
KeyCode::BackTab => {
if form_state.current_field == 0 {
form_state.current_field = form_state.fields.len() - 1;
} else {
form_state.current_field = form_state.current_field.saturating_sub(1);
}
let current_input = form_state.get_current_input();
form_state.current_cursor_pos = self.ideal_cursor_column.min(current_input.len());
}
KeyCode::Enter => {
form_state.current_field = (form_state.current_field + 1) % form_state.fields.len();
let current_input = form_state.get_current_input();
form_state.current_cursor_pos = self.ideal_cursor_column.min(current_input.len());
}
KeyCode::Char(c) => {
let cursor_pos = form_state.current_cursor_pos;
let field_value = form_state.get_current_input_mut();
let mut chars: Vec<char> = field_value.chars().collect();
if cursor_pos <= chars.len() {
chars.insert(cursor_pos, c);
*field_value = chars.into_iter().collect();
form_state.current_cursor_pos = cursor_pos + 1;
self.ideal_cursor_column = form_state.current_cursor_pos;
form_state.has_unsaved_changes = true;
}
}
KeyCode::Backspace => {
if form_state.current_cursor_pos > 0 {
let cursor_pos = form_state.current_cursor_pos;
let field_value = form_state.get_current_input_mut();
let mut chars: Vec<char> = field_value.chars().collect();
if cursor_pos <= chars.len() && cursor_pos > 0 {
chars.remove(cursor_pos - 1);
*field_value = chars.into_iter().collect();
form_state.current_cursor_pos = cursor_pos - 1;
self.ideal_cursor_column = form_state.current_cursor_pos;
form_state.has_unsaved_changes = true;
}
}
}
KeyCode::Delete => {
let cursor_pos = form_state.current_cursor_pos;
let field_value = form_state.get_current_input_mut();
let chars: Vec<char> = field_value.chars().collect();
if cursor_pos < chars.len() {
let mut new_chars = chars.clone();
new_chars.remove(cursor_pos);
*field_value = new_chars.into_iter().collect();
form_state.has_unsaved_changes = true;
}
}
_ => {}
}
}
}
}
self.edit_mode_cooldown = false;
Ok((false, self.command_message.clone()))
}
}