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

trying restoring functionality we are not in there correctly yet

Browse Source
This commit is contained in:
filipriec
2025-04-02 21:06:49 +02:00
parent d577ff6715
commit 43edadde0c
2 changed files with 168 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files

240
client/src/modes/canvas/read_only.rs
View File

@@ -3,7 +3,7 @@
use crate::config::binds::config::Config;
use crate::config::binds::key_sequences::KeySequenceTracker;
use crate::services::grpc_client::GrpcClient;
use crate::state::canvas_state::CanvasState; // Import the trait
use crate::state::canvas_state::CanvasState;
use crate::state::pages::auth::AuthState;
use crate::state::pages::form::FormState;
use crossterm::event::KeyEvent;
@@ -19,26 +19,23 @@ pub async fn handle_read_only_event(
app_state: &crate::state::state::AppState,
key: KeyEvent,
config: &Config,
form_state: &mut FormState, // Keep specific types here for routing
auth_state: &mut AuthState, // Keep specific types here for routing
form_state: &mut FormState,
auth_state: &mut AuthState,
key_sequence_tracker: &mut KeySequenceTracker,
current_position: &mut u64, // Needed for form actions
total_count: u64, // Needed for form actions
grpc_client: &mut GrpcClient, // Needed for form actions
current_position: &mut u64,
total_count: u64,
grpc_client: &mut GrpcClient,
command_message: &mut String,
edit_mode_cooldown: &mut bool,
ideal_cursor_column: &mut usize,
) -> Result<(bool, String), Box<dyn std::error::Error>> {
// Check for entering Edit mode from Read-Only mode
if config.is_enter_edit_mode_before(key.code, key.modifiers) {
*edit_mode_cooldown = true;
*command_message = "Entering Edit mode".to_string();
// The actual mode switch happens in event.rs based on this return
return Ok((false, command_message.clone()));
}
if config.is_enter_edit_mode_after(key.code, key.modifiers) {
// Use the correct state based on context
let (current_input, current_pos) = if app_state.ui.show_login {
(
auth_state.get_current_input(),
@@ -52,7 +49,6 @@ pub async fn handle_read_only_event(
};
if !current_input.is_empty() && current_pos < current_input.len() {
// Update the correct state
if app_state.ui.show_login {
auth_state.set_current_cursor_pos(current_pos + 1);
*ideal_cursor_column = auth_state.current_cursor_pos();
@@ -63,23 +59,31 @@ pub async fn handle_read_only_event(
}
*edit_mode_cooldown = true;
*command_message = "Entering Edit mode (after cursor)".to_string();
// The actual mode switch happens in event.rs based on this return
return Ok((false, command_message.clone()));
}
// Handle Read-Only mode keybindings
const CONTEXT_ACTIONS_FORM: &[&str] = &[
"previous_entry",
"next_entry",
"move_up",
"move_down",
"move_first_line",
"move_last_line",
];
const CONTEXT_ACTIONS_LOGIN: &[&str] = &[
"move_up",
"move_down",
"move_first_line",
"move_last_line",
];
if key.modifiers.is_empty() {
key_sequence_tracker.add_key(key.code);
let sequence = key_sequence_tracker.get_sequence();
// Try to match the current sequence against Read-Only mode bindings
if let Some(action) = config.matches_key_sequence_generalized(&sequence)
{
// Handle context-specific actions first
let result = if app_state.ui.show_form
&& (action == "previous_entry" || action == "next_entry")
{
// Form-specific navigation
let result = if app_state.ui.show_form && CONTEXT_ACTIONS_FORM.contains(&action) {
crate::tui::functions::form::handle_action(
action,
form_state,
@@ -89,35 +93,18 @@ pub async fn handle_read_only_event(
ideal_cursor_column,
)
.await?
} else if app_state.ui.show_login
&& (action == "move_up" || action == "move_down")
{
// Login-specific field navigation
} else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) {
crate::tui::functions::login::handle_action(
action,
auth_state,
ideal_cursor_column,
)
.await?
} else if app_state.ui.show_form
&& (action == "move_up" || action == "move_down")
{
// Form-specific field navigation (can reuse login handler logic if identical)
crate::tui::functions::form::handle_action(
action,
form_state,
grpc_client, // Might not be needed for simple up/down
current_position,
total_count,
ideal_cursor_column,
)
.await?
} else {
// Handle common navigation actions generically
if app_state.ui.show_login {
execute_action(
action,
auth_state, // Pass AuthState
auth_state,
ideal_cursor_column,
key_sequence_tracker,
command_message,
@@ -126,7 +113,7 @@ pub async fn handle_read_only_event(
} else {
execute_action(
action,
form_state, // Pass FormState
form_state,
ideal_cursor_column,
key_sequence_tracker,
command_message,
@@ -138,21 +125,15 @@ pub async fn handle_read_only_event(
return Ok((false, result));
}
// Check if this might be a prefix of a longer sequence
if config.is_key_sequence_prefix(&sequence) {
return Ok((false, command_message.clone()));
}
// Since it's not part of a multi-key sequence, check for a direct action
if sequence.len() == 1 && !config.is_key_sequence_prefix(&sequence) {
if let Some(action) =
config.get_read_only_action_for_key(key.code, key.modifiers)
{
// Handle context-specific actions first
let result = if app_state.ui.show_form
&& action == "previous_entry"
{
// Form-specific navigation
let result = if app_state.ui.show_form && CONTEXT_ACTIONS_FORM.contains(&action) {
crate::tui::functions::form::handle_action(
action,
form_state,
@@ -162,12 +143,18 @@ pub async fn handle_read_only_event(
ideal_cursor_column,
)
.await?
} else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) {
crate::tui::functions::login::handle_action(
action,
auth_state,
ideal_cursor_column,
)
.await?
} else {
// Handle common navigation actions generically
if app_state.ui.show_login {
execute_action(
action,
auth_state, // Pass AuthState
auth_state,
ideal_cursor_column,
key_sequence_tracker,
command_message,
@@ -176,7 +163,7 @@ pub async fn handle_read_only_event(
} else {
execute_action(
action,
form_state, // Pass FormState
form_state,
ideal_cursor_column,
key_sequence_tracker,
command_message,
@@ -188,18 +175,15 @@ pub async fn handle_read_only_event(
return Ok((false, result));
}
}
key_sequence_tracker.reset();
} else {
// If modifiers are pressed, check for direct key bindings
key_sequence_tracker.reset();
if let Some(action) =
config.get_read_only_action_for_key(key.code, key.modifiers)
{
// Handle context-specific actions first
let result = if app_state.ui.show_form
&& action == "previous_entry"
{
// Form-specific navigation
let result = if app_state.ui.show_form && CONTEXT_ACTIONS_FORM.contains(&action) {
crate::tui::functions::form::handle_action(
action,
form_state,
@@ -209,12 +193,18 @@ pub async fn handle_read_only_event(
ideal_cursor_column,
)
.await?
} else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) {
crate::tui::functions::login::handle_action(
action,
auth_state,
ideal_cursor_column,
)
.await?
} else {
// Handle common navigation actions generically
if app_state.ui.show_login {
execute_action(
action,
auth_state, // Pass AuthState
auth_state,
ideal_cursor_column,
key_sequence_tracker,
command_message,
@@ -223,7 +213,7 @@ pub async fn handle_read_only_event(
} else {
execute_action(
action,
form_state, // Pass FormState
form_state,
ideal_cursor_column,
key_sequence_tracker,
command_message,
@@ -235,7 +225,6 @@ pub async fn handle_read_only_event(
}
}
// Show a helpful message when no binding was found
if !*edit_mode_cooldown {
let default_key = "i".to_string();
let edit_key = config
@@ -243,32 +232,26 @@ pub async fn handle_read_only_event(
.read_only
.get("enter_edit_mode_before")
.and_then(|keys| keys.first())
.unwrap_or(&default_key);
.map(|k| k.to_string())
.unwrap_or(default_key);
*command_message = format!("Read-only mode - press {} to edit", edit_key);
}
*edit_mode_cooldown = false;
Ok((false, command_message.clone()))
}
// Make this function generic over CanvasState
async fn execute_action<S: CanvasState>(
action: &str,
state: &mut S, // Use generic state
state: &mut S,
ideal_cursor_column: &mut usize,
key_sequence_tracker: &mut KeySequenceTracker, // Keep for resetting
command_message: &mut String, // Keep for clearing
key_sequence_tracker: &mut KeySequenceTracker,
command_message: &mut String,
) -> Result<String, Box<dyn std::error::Error>> {
match action {
// These actions are handled outside now based on context
"previous_entry" | "next_entry" => {
key_sequence_tracker.reset();
Ok(format!(
"Action '{}' should be handled by context-specific logic",
action
))
}
// These actions are handled outside now based on context
"move_up" | "move_down" => {
"previous_entry" | "next_entry" | "move_up" | "move_down" |
"move_first_line" | "move_last_line" => {
key_sequence_tracker.reset();
Ok(format!(
"Action '{}' should be handled by context-specific logic",
@@ -276,7 +259,6 @@ async fn execute_action<S: CanvasState>(
))
}
"exit_edit_mode" => {
// This action is primarily for Edit mode, but might be bound here too
key_sequence_tracker.reset();
command_message.clear();
Ok("".to_string())
@@ -284,19 +266,18 @@ async fn execute_action<S: CanvasState>(
"move_left" => {
let current_pos = state.current_cursor_pos();
let new_pos = current_pos.saturating_sub(1);
state.set_current_cursor_pos(new_pos); // Use trait setter
state.set_current_cursor_pos(new_pos);
*ideal_cursor_column = new_pos;
Ok("".to_string())
}
"move_right" => {
let current_input = state.get_current_input();
let current_pos = state.current_cursor_pos();
// In read-only, cursor stops AT the last character, not after
if !current_input.is_empty()
&& current_pos < current_input.len().saturating_sub(1)
{
let new_pos = current_pos + 1;
state.set_current_cursor_pos(new_pos); // Use trait setter
state.set_current_cursor_pos(new_pos);
*ideal_cursor_column = new_pos;
}
Ok("".to_string())
@@ -306,9 +287,8 @@ async fn execute_action<S: CanvasState>(
if !current_input.is_empty() {
let new_pos =
find_next_word_start(current_input, state.current_cursor_pos());
// Clamp to last valid character index in read-only
let final_pos = new_pos.min(current_input.len().saturating_sub(1));
state.set_current_cursor_pos(final_pos); // Use trait setter
state.set_current_cursor_pos(final_pos);
*ideal_cursor_column = final_pos;
}
Ok("".to_string())
@@ -316,11 +296,17 @@ async fn execute_action<S: CanvasState>(
"move_word_end" => {
let current_input = state.get_current_input();
if !current_input.is_empty() {
// 1. Find the index of the last character of the target word
let new_pos =
find_word_end(current_input, state.current_cursor_pos());
// Clamp to last valid character index in read-only
let final_pos = new_pos.min(current_input.len().saturating_sub(1));
state.set_current_cursor_pos(final_pos); // Use trait setter
// 2. Clamp the position for Read-Only mode
// max_valid_index is the index of the VERY LAST character in the input string
let max_valid_index = current_input.len().saturating_sub(1);
let final_pos = new_pos.min(max_valid_index);
// 3. Set the cursor
state.set_current_cursor_pos(final_pos);
*ideal_cursor_column = final_pos;
}
Ok("".to_string())
@@ -332,7 +318,7 @@ async fn execute_action<S: CanvasState>(
current_input,
state.current_cursor_pos(),
);
state.set_current_cursor_pos(new_pos); // Use trait setter
state.set_current_cursor_pos(new_pos);
*ideal_cursor_column = new_pos;
}
Ok("".to_string())
@@ -344,13 +330,13 @@ async fn execute_action<S: CanvasState>(
current_input,
state.current_cursor_pos(),
);
state.set_current_cursor_pos(new_pos); // Use trait setter
state.set_current_cursor_pos(new_pos);
*ideal_cursor_column = new_pos;
}
Ok("Moved to previous word end".to_string())
}
"move_line_start" => {
state.set_current_cursor_pos(0); // Use trait setter
state.set_current_cursor_pos(0);
*ideal_cursor_column = 0;
Ok("".to_string())
}
@@ -358,47 +344,21 @@ async fn execute_action<S: CanvasState>(
let current_input = state.get_current_input();
if !current_input.is_empty() {
let new_pos = current_input.len().saturating_sub(1);
state.set_current_cursor_pos(new_pos); // Use trait setter
state.set_current_cursor_pos(new_pos);
*ideal_cursor_column = new_pos;
} else {
state.set_current_cursor_pos(0); // Handle empty input case
state.set_current_cursor_pos(0);
*ideal_cursor_column = 0;
}
Ok("".to_string())
}
"move_first_line" => {
// Field change is handled outside based on context
// Just set cursor position based on ideal column
let current_input = state.get_current_input();
let max_cursor_pos = if !current_input.is_empty() {
current_input.len().saturating_sub(1)
} else {
0
};
state.set_current_cursor_pos(
(*ideal_cursor_column).min(max_cursor_pos),
);
Ok("Moved to first line".to_string()) // Message might be inaccurate now
}
"move_last_line" => {
// Field change is handled outside based on context
// Just set cursor position based on ideal column
let current_input = state.get_current_input();
let max_cursor_pos = if !current_input.is_empty() {
current_input.len().saturating_sub(1)
} else {
0
};
state.set_current_cursor_pos(
(*ideal_cursor_column).min(max_cursor_pos),
);
Ok("Moved to last line".to_string()) // Message might be inaccurate now
}
_ => Ok(format!("Unknown read-only action: {}", action)),
_ => {
key_sequence_tracker.reset();
Ok(format!("Unknown read-only action: {}", action))
},
}
}
// Helper functions remain unchanged as they operate on &str
fn get_char_type(c: char) -> CharType {
if c.is_whitespace() {
CharType::Whitespace
@@ -411,23 +371,22 @@ fn get_char_type(c: char) -> CharType {
fn find_next_word_start(text: &str, current_pos: usize) -> usize {
let chars: Vec<char> = text.chars().collect();
if chars.is_empty() || current_pos >= chars.len() {
if chars.is_empty() {
return 0;
}
let current_pos = current_pos.min(chars.len());
if current_pos == chars.len() {
return current_pos;
}
let mut pos = current_pos;
// Handle edge case where current_pos might be out of bounds after edits
if pos >= chars.len() {
return chars.len();
}
let initial_type = get_char_type(chars[pos]);
// Move past characters of the same type
while pos < chars.len() && get_char_type(chars[pos]) == initial_type {
pos += 1;
}
// Move past whitespace
while pos < chars.len() && get_char_type(chars[pos]) == CharType::Whitespace {
pos += 1;
}
@@ -435,29 +394,23 @@ fn find_next_word_start(text: &str, current_pos: usize) -> usize {
pos
}
fn find_word_end(text: &str, current_pos: usize) -> usize {
let chars: Vec<char> = text.chars().collect();
if chars.is_empty() {
return 0;
}
// Handle edge case where current_pos might be out of bounds
let mut pos = current_pos.min(chars.len().saturating_sub(1));
// If starting on whitespace, move to the next non-whitespace
if get_char_type(chars[pos]) == CharType::Whitespace {
while pos + 1 < chars.len() && get_char_type(chars[pos + 1]) == CharType::Whitespace {
pos += 1;
}
// If we are still on whitespace (meaning end of string or only whitespace left), return current pos
if pos + 1 >= chars.len() || get_char_type(chars[pos + 1]) == CharType::Whitespace {
return pos;
}
// Move to the start of the next word
pos += 1;
}
// Now we are on a non-whitespace character
let word_type = get_char_type(chars[pos]);
while pos + 1 < chars.len() && get_char_type(chars[pos + 1]) == word_type {
pos += 1;
@@ -466,7 +419,6 @@ fn find_word_end(text: &str, current_pos: usize) -> usize {
pos
}
fn find_prev_word_start(text: &str, current_pos: usize) -> usize {
let chars: Vec<char> = text.chars().collect();
if chars.is_empty() || current_pos == 0 {
@@ -475,64 +427,56 @@ fn find_prev_word_start(text: &str, current_pos: usize) -> usize {
let mut pos = current_pos.saturating_sub(1);
// Move past whitespace
while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
pos -= 1;
}
// Now on a non-whitespace or at the beginning
if get_char_type(chars[pos]) != CharType::Whitespace {
let word_type = get_char_type(chars[pos]);
// Move to the beginning of the word
while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
pos -= 1;
}
}
// If pos is 0 and it's whitespace, keep it at 0. Otherwise, it's the start of the word.
if pos == 0 && get_char_type(chars[pos]) == CharType::Whitespace {
if pos == 0 && get_char_type(chars[0]) == CharType::Whitespace {
0
} else {
pos
}
}
fn find_prev_word_end(text: &str, current_pos: usize) -> usize {
let chars: Vec<char> = text.chars().collect();
if chars.is_empty() || current_pos <= 1 { // Need at least 2 chars to find a *previous* word end
if chars.is_empty() || current_pos == 0 {
return 0;
}
let mut pos = current_pos.saturating_sub(1); // Start looking one char back
let mut pos = current_pos.saturating_sub(1);
// Skip trailing whitespace from the current position
while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
pos -= 1;
}
// Now we are at the end of the word the cursor was in/after, or at the start
if pos == 0 {
return 0; // Reached the beginning
if pos == 0 && get_char_type(chars[0]) == CharType::Whitespace {
return 0;
}
if pos == 0 && get_char_type(chars[0]) != CharType::Whitespace {
return 0;
}
// Skip the word itself
let word_type = get_char_type(chars[pos]);
while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
pos -= 1;
}
// Skip whitespace before that word
while pos > 0 && get_char_type(chars[pos - 1]) == CharType::Whitespace {
pos -= 1;
}
// Now pos is at the beginning of the word *or* the end of the *previous* word.
// If we moved back, pos-1 is the index we want.
if pos > 0 {
pos - 1
} else {
0 // We were at the first word
0
}
}

95
client/src/tui/functions/form.rs
View File

@@ -1,6 +1,7 @@
// src/tui/functions/form.rs
use crate::state::pages::form::FormState;
use crate::services::grpc_client::GrpcClient;
use crate::state::canvas_state::CanvasState;
pub async fn handle_action(
action: &str,
@@ -74,36 +75,90 @@ pub async fn handle_action(
Ok("Already at last entry".into())
}
}
"move_up" => {
// Change field first
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);
"move_first_line" => {
// *** GUARD CLAUSE ***
if form_state.fields.is_empty() {
// Or log an error, or do nothing gracefully
return Ok("No fields to navigate to.".to_string());
}
// Get current input AFTER changing field
// Set the field index
form_state.set_current_field(0);
// Get input of the *new* current field (index 0)
let current_input = form_state.get_current_input();
let max_cursor_pos = if !current_input.is_empty() {
current_input.len() - 1
} else {
// Calculate the maximum valid cursor position for read-only mode
// Cursor should be ON the last char, or at 0 if empty.
let max_cursor_pos = if current_input.is_empty() {
0
} else {
current_input.len().saturating_sub(1)
};
form_state.current_cursor_pos = (*ideal_cursor_column).min(max_cursor_pos);
// Set the cursor position, clamped by ideal column and max valid position
form_state.set_current_cursor_pos((*ideal_cursor_column).min(max_cursor_pos));
Ok("".to_string()) // Or a confirmation message
}
"move_last_line" => {
// *** GUARD CLAUSE ***
if form_state.fields.is_empty() {
return Ok("No fields to navigate to.".to_string());
}
let last_field_index = form_state.fields.len() - 1;
form_state.set_current_field(last_field_index);
let current_input = form_state.get_current_input();
let max_cursor_pos = if current_input.is_empty() {
0
} else {
current_input.len().saturating_sub(1)
};
form_state.set_current_cursor_pos((*ideal_cursor_column).min(max_cursor_pos));
Ok("".to_string())
}
"move_down" => {
// Change field first
form_state.current_field = (form_state.current_field + 1) % form_state.fields.len();
// Get current input AFTER changing field
let current_input = form_state.get_current_input();
let max_cursor_pos = if !current_input.is_empty() {
current_input.len() - 1
"move_up" => {
if form_state.fields.is_empty() {
return Ok("No fields to navigate.".to_string());
}
let current_field = form_state.current_field();
let new_field = if current_field == 0 {
form_state.fields.len() - 1
} else {
0
current_field - 1
};
form_state.current_cursor_pos = (*ideal_cursor_column).min(max_cursor_pos);
form_state.set_current_field(new_field);
let current_input = form_state.get_current_input();
let max_cursor_pos = if current_input.is_empty() {
0
} else {
current_input.len().saturating_sub(1) // Adjust for read-only if needed
};
form_state.set_current_cursor_pos((*ideal_cursor_column).min(max_cursor_pos));
Ok("".to_string())
}
"move_down" => {
if form_state.fields.is_empty() {
return Ok("No fields to navigate.".to_string());
}
let current_field = form_state.current_field();
let new_field = (current_field + 1) % form_state.fields.len();
form_state.set_current_field(new_field);
let current_input = form_state.get_current_input();
let max_cursor_pos = if current_input.is_empty() {
0
} else {
current_input.len().saturating_sub(1) // Adjust for read-only if needed
};
form_state.set_current_cursor_pos((*ideal_cursor_column).min(max_cursor_pos));
Ok("".to_string())
}
_ => Err("Unknown form action".into())