fixed, removed log library

Cargo.lock

@@ -1656,9 +1656,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.26"
+version = "0.4.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30bde2b3dc3671ae49d8e2e9f044c7c005836e7a023ee57cffa25ab82764bb9e"
+checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
 
 [[package]]
 name = "lru"

client/config.toml

@@ -15,6 +15,7 @@ toggle_sidebar = ["ctrl+t"]
 toggle_buffer_list = ["ctrl+b"]
 next_field = ["Tab"]
 prev_field = ["Shift+Tab"]
+exit_table_scroll = ["esc"]
 
 [keybindings.common]
 save = ["ctrl+s"]
@@ -60,16 +61,17 @@ enter_highlight_mode_linewise = ["ctrl+v"]
 # BIG CHANGES NOW EXIT HANDLES EITHER IF THOSE
 # exit_edit_mode = ["esc","ctrl+e"]
 # exit_suggestion_mode = ["esc"]
+# select_suggestion = ["enter"]
+# next_field = ["enter"]
+enter_decider = ["enter"]
+prev_field = ["shift+enter"]
 exit = ["esc", "ctrl+e"]
 delete_char_forward = ["delete"]
 delete_char_backward = ["backspace"]
-next_field = ["enter"]
-prev_field = ["shift+enter"]
 move_left = ["left"]
 move_right = ["right"]
 suggestion_down = ["ctrl+n", "tab"]
 suggestion_up = ["ctrl+p", "shift+tab"]
-select_suggestion = ["enter"]
 
 [keybindings.command]
 exit_command_mode = ["ctrl+g", "esc"]

client/src/components/admin/add_table.rs

@@ -13,6 +13,7 @@ use ratatui::{
     Frame,
 };
 use crate::components::handlers::canvas::render_canvas;
+use crate::components::common::dialog;
 
 /// Renders the Add New Table page layout, structuring the display of table information,
 /// input fields, and action buttons. Adapts layout based on terminal width.
@@ -20,7 +21,7 @@ pub fn render_add_table(
     f: &mut Frame,
     area: Rect,
     theme: &Theme,
-    _app_state: &AppState, // Currently unused, might be needed later
+    app_state: &AppState, // Currently unused, might be needed later
     add_table_state: &mut AddTableState,
     is_edit_mode: bool, // Determines if canvas inputs are in edit mode
     highlight_state: &HighlightState, // For text highlighting in canvas
@@ -48,6 +49,46 @@ pub fn render_add_table(
     let inner_area = main_block.inner(area);
     f.render_widget(main_block, area);
 
+    // --- Fullscreen Columns Table Check (Narrow Screens Only) ---
+    if area.width < NARROW_LAYOUT_THRESHOLD && add_table_state.current_focus == AddTableFocus::InsideColumnsTable {
+        // Render ONLY the columns table taking the full inner area
+        let columns_border_style = Style::default().fg(theme.highlight); // Always highlighted when fullscreen
+        let column_rows: Vec<Row<'_>> = add_table_state
+            .columns
+            .iter()
+            .map(|col_def| {
+                Row::new(vec![
+                    Cell::from(if col_def.selected { "[*]" } else { "[ ]" }),
+                    Cell::from(col_def.name.clone()),
+                    Cell::from(col_def.data_type.clone()),
+                ])
+                .style(Style::default().fg(theme.fg))
+            })
+            .collect();
+        let header_cells = ["Sel", "Name", "Type"]
+            .iter()
+            .map(|h| Cell::from(*h).style(Style::default().fg(theme.accent)));
+        let header = Row::new(header_cells).height(1).bottom_margin(1);
+        let columns_table = Table::new(column_rows, [Constraint::Length(5), Constraint::Percentage(50), Constraint::Percentage(50)])
+            .header(header)
+            .block(
+                Block::default()
+                    .title(Span::styled(" Columns (Fullscreen) ", theme.fg)) // Indicate fullscreen
+                    .title_alignment(Alignment::Center)
+                    .borders(Borders::ALL)
+                    .border_type(BorderType::Rounded)
+                    .border_style(columns_border_style),
+            )
+            .row_highlight_style(
+                Style::default()
+                .add_modifier(Modifier::REVERSED)
+                .fg(theme.highlight),
+            )
+            .highlight_symbol(" > "); // Use the inside symbol
+        f.render_stateful_widget(columns_table, inner_area, &mut add_table_state.column_table_state);
+        return; // IMPORTANT: Stop rendering here for fullscreen mode
+    }
+
     // --- Area Variable Declarations ---
     let top_info_area: Rect;
     let columns_area: Rect;
@@ -77,8 +118,8 @@ pub fn render_add_table(
         let middle_chunks = Layout::default()
             .direction(Direction::Horizontal)
             .constraints([
-                Constraint::Percentage(60), // Left: Columns Table
-                Constraint::Percentage(40), // Right: Inputs etc.
+                Constraint::Percentage(50), // Left: Columns Table
+                Constraint::Percentage(50), // Right: Inputs etc.
             ])
             .split(middle_area);
 
@@ -186,8 +227,7 @@ pub fn render_add_table(
     // --- Common Widget Rendering (Uses calculated areas) ---
 
     // --- Columns Table Rendering ---
-    let columns_focused =
-        add_table_state.current_focus == AddTableFocus::ColumnsTable;
+    let columns_focused = matches!(add_table_state.current_focus, AddTableFocus::ColumnsTable | AddTableFocus::InsideColumnsTable);
     let columns_border_style = if columns_focused {
         Style::default().fg(theme.highlight)
     } else {
@@ -198,27 +238,32 @@ pub fn render_add_table(
         .iter()
         .map(|col_def| {
             Row::new(vec![
+                Cell::from(if col_def.selected { "[*]" } else { "[ ]" }),
                 Cell::from(col_def.name.clone()),
                 Cell::from(col_def.data_type.clone()),
             ])
             .style(Style::default().fg(theme.fg))
         })
         .collect();
-    // Use different headers/constraints based on layout? For now, keep consistent.
-    let header_cells = ["Name", "Type"]
+    let header_cells = ["Sel", "Name", "Type"]
         .iter()
         .map(|h| Cell::from(*h).style(Style::default().fg(theme.accent)));
     let header = Row::new(header_cells).height(1).bottom_margin(1);
+    let columns_highlight_symbol = if add_table_state.current_focus == AddTableFocus::InsideColumnsTable { " > " } else { "   " };
     let columns_table = Table::new(
         column_rows,
-        [Constraint::Percentage(60), Constraint::Percentage(40)],
+        [ // Define constraints for 3 columns: Sel, Name, Type
+            Constraint::Length(5),
+            Constraint::Percentage(60),
+            Constraint::Percentage(35),
+        ],
     )
     .header(header)
     .block(
         Block::default()
             .title(Span::styled(" Columns ", theme.fg))
             .title_alignment(Alignment::Center)
-            .borders(Borders::ALL) // Use ALL borders for consistency
+            .borders(Borders::ALL)
             .border_type(BorderType::Rounded)
             .border_style(columns_border_style),
     )
@@ -249,22 +294,22 @@ pub fn render_add_table(
 
     // --- Button Style Helpers ---
     let get_button_style = |button_focus: AddTableFocus, current_focus| {
+        // Only handles text style (FG + Bold) now, no BG
         let is_focused = current_focus == button_focus;
         let base_style = Style::default().fg(if is_focused {
-            theme.bg // Reversed text color
+            theme.highlight // Highlighted text color
         } else {
             theme.secondary // Normal text color
         });
         if is_focused {
-            base_style
-                .add_modifier(Modifier::BOLD)
-                .bg(theme.highlight) // Reversed background
+            base_style.add_modifier(Modifier::BOLD)
         } else {
             base_style
         }
     };
-    let get_button_border_style = |button_focus: AddTableFocus, current_focus| {
-        if current_focus == button_focus {
+    // Updated signature to accept bool and theme
+    let get_button_border_style = |is_focused: bool, theme: &Theme| {
+        if is_focused {
             Style::default().fg(theme.highlight)
         } else {
             Style::default().fg(theme.secondary)
@@ -272,26 +317,25 @@ pub fn render_add_table(
     };
 
     // --- Add Button Rendering ---
+    // Determine if the add button is focused
+    let is_add_button_focused = add_table_state.current_focus == AddTableFocus::AddColumnButton;
+
+    // Create the Add button Paragraph widget
     let add_button = Paragraph::new(" Add ")
-        .style(get_button_style(
-            AddTableFocus::AddColumnButton,
-            add_table_state.current_focus,
-        ))
+        .style(get_button_style(AddTableFocus::AddColumnButton, add_table_state.current_focus)) // Use existing closure
         .alignment(Alignment::Center)
         .block(
             Block::default()
-                .borders(Borders::ALL)
-                .border_type(BorderType::Rounded)
-                .border_style(get_button_border_style(
-                    AddTableFocus::AddColumnButton,
-                    add_table_state.current_focus,
-                )),
+            .borders(Borders::ALL)
+            .border_type(BorderType::Rounded)
+            .border_style(get_button_border_style(is_add_button_focused, theme)), // Pass bool and theme
         );
-    f.render_widget(add_button, add_button_area); // Render into the calculated area
+
+    // Render the button in its designated area
+    f.render_widget(add_button, add_button_area);
 
     // --- Indexes Table Rendering ---
-    let indexes_focused =
-        add_table_state.current_focus == AddTableFocus::IndexesTable;
+    let indexes_focused = matches!(add_table_state.current_focus, AddTableFocus::IndexesTable | AddTableFocus::InsideIndexesTable);
     let indexes_border_style = if indexes_focused {
         Style::default().fg(theme.highlight)
     } else {
@@ -309,6 +353,7 @@ pub fn render_add_table(
         .iter()
         .map(|h| Cell::from(*h).style(Style::default().fg(theme.accent)));
     let index_header = Row::new(index_header_cells).height(1).bottom_margin(1);
+    let indexes_highlight_symbol = if add_table_state.current_focus == AddTableFocus::InsideIndexesTable { " > " } else { "   " };
     let indexes_table =
         Table::new(index_rows, [Constraint::Percentage(100)])
             .header(index_header)
@@ -333,7 +378,7 @@ pub fn render_add_table(
     );
 
     // --- Links Table Rendering ---
-    let links_focused = add_table_state.current_focus == AddTableFocus::LinksTable;
+    let links_focused = matches!(add_table_state.current_focus, AddTableFocus::LinksTable | AddTableFocus::InsideLinksTable);
     let links_border_style = if links_focused {
         Style::default().fg(theme.highlight)
     } else {
@@ -350,10 +395,11 @@ pub fn render_add_table(
             .style(Style::default().fg(theme.fg))
         })
         .collect();
-    let link_header_cells = ["Linked Table", "Req"]
+    let link_header_cells = ["Linked Table", "Selected"]
         .iter()
         .map(|h| Cell::from(*h).style(Style::default().fg(theme.accent)));
     let link_header = Row::new(link_header_cells).height(1).bottom_margin(1);
+    let links_highlight_symbol = if add_table_state.current_focus == AddTableFocus::InsideLinksTable { " > " } else { "   " };
     let links_table =
         Table::new(link_rows, [Constraint::Percentage(80), Constraint::Min(5)])
             .header(link_header)
@@ -381,9 +427,9 @@ pub fn render_add_table(
     let bottom_button_chunks = Layout::default()
         .direction(Direction::Horizontal)
         .constraints([
-           Constraint::Percentage(33), // Save Button
-           Constraint::Percentage(34), // Delete Button
-           Constraint::Percentage(33), // Cancel Button
+            Constraint::Percentage(33), // Save Button
+            Constraint::Percentage(34), // Delete Button
+            Constraint::Percentage(33), // Cancel Button
         ])
         .split(bottom_buttons_area);
 
@@ -398,28 +444,28 @@ pub fn render_add_table(
                 .borders(Borders::ALL)
                 .border_type(BorderType::Rounded)
                 .border_style(get_button_border_style(
-                    AddTableFocus::SaveButton,
-                    add_table_state.current_focus,
+                    add_table_state.current_focus == AddTableFocus::SaveButton, // Pass bool
+                    theme,
                 )),
         );
     f.render_widget(save_button, bottom_button_chunks[0]);
 
-   let delete_button = Paragraph::new(" Delete Selected ")
-       .style(get_button_style(
-           AddTableFocus::DeleteSelectedButton,
-           add_table_state.current_focus,
-       ))
-       .alignment(Alignment::Center)
-       .block(
-           Block::default()
-               .borders(Borders::ALL)
-               .border_type(BorderType::Rounded)
-               .border_style(get_button_border_style(
-                   AddTableFocus::DeleteSelectedButton,
-                   add_table_state.current_focus,
-               )),
-       );
-   f.render_widget(delete_button, bottom_button_chunks[1]);
+    let delete_button = Paragraph::new(" Delete Selected ")
+        .style(get_button_style(
+            AddTableFocus::DeleteSelectedButton,
+            add_table_state.current_focus,
+        ))
+        .alignment(Alignment::Center)
+        .block(
+            Block::default()
+                .borders(Borders::ALL)
+                .border_type(BorderType::Rounded)
+                .border_style(get_button_border_style(
+                    add_table_state.current_focus == AddTableFocus::DeleteSelectedButton, // Pass bool
+                    theme,
+                )),
+        );
+    f.render_widget(delete_button, bottom_button_chunks[1]);
 
     let cancel_button = Paragraph::new(" Cancel ")
         .style(get_button_style(
@@ -432,9 +478,24 @@ pub fn render_add_table(
                 .borders(Borders::ALL)
                 .border_type(BorderType::Rounded)
                 .border_style(get_button_border_style(
-                    AddTableFocus::CancelButton,
-                    add_table_state.current_focus,
+                    add_table_state.current_focus == AddTableFocus::CancelButton, // Pass bool
+                    theme,
                 )),
         );
     f.render_widget(cancel_button, bottom_button_chunks[2]);
+
+    // --- DIALOG ---
+    // Render the dialog overlay if it's active
+    if app_state.ui.dialog.dialog_show { // Use the passed-in app_state
+        dialog::render_dialog(
+            f,
+            f.area(), // Render over the whole frame area
+            theme,
+            &app_state.ui.dialog.dialog_title,
+            &app_state.ui.dialog.dialog_message,
+            &app_state.ui.dialog.dialog_buttons,
+            app_state.ui.dialog.dialog_active_button_index,
+            app_state.ui.dialog.is_loading,
+        );
+    }
 }

client/src/components/auth/login.rs

@@ -142,7 +142,8 @@ pub fn render_login(
             &app_state.ui.dialog.dialog_title,
             &app_state.ui.dialog.dialog_message,
             &app_state.ui.dialog.dialog_buttons, // Pass buttons slice
-            app_state.ui.dialog.dialog_active_button_index, // Pass active index
+            app_state.ui.dialog.dialog_active_button_index, 
+            app_state.ui.dialog.is_loading,
         );
     }
 }

client/src/components/auth/register.rs

@@ -168,6 +168,7 @@ pub fn render_register(
             &app_state.ui.dialog.dialog_message,
             &app_state.ui.dialog.dialog_buttons,
             app_state.ui.dialog.dialog_active_button_index,
+            app_state.ui.dialog.is_loading,
         );
     }
 }

client/src/components/common/dialog.rs

@@ -18,6 +18,7 @@ pub fn render_dialog(
     dialog_message: &str,
     dialog_buttons: &[String],
     dialog_active_button_index: usize,
+    is_loading: bool,
 ) {
     // Calculate required height based on the actual number of lines in the message
     let message_lines: Vec<_> = dialog_message.lines().collect();
@@ -63,27 +64,36 @@ pub fn render_dialog(
         vertical: 1,   // Top/Bottom padding inside border
     });
 
-    // Layout for Message and Buttons based on actual message height
-    let mut constraints = vec![
-        // Allocate space for message, ensuring at least 1 line height
-        Constraint::Length(message_height.max(1)), // Use actual calculated height
-    ];
-    if button_row_height > 0 {
-        constraints.push(Constraint::Length(button_row_height));
-    }
+    if is_loading {
+        // --- Loading State ---
+        let loading_text = Paragraph::new(dialog_message) // Use the message passed for loading
+            .style(Style::default().fg(theme.fg).add_modifier(Modifier::ITALIC))
+            .alignment(Alignment::Center);
+        // Render loading message centered in the inner area
+        f.render_widget(loading_text, inner_area);
+    } else {
+        // --- Normal State (Message + Buttons) ---
 
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints(constraints)
-        .split(inner_area);
+        // Layout for Message and Buttons based on actual message height
+        let mut constraints = vec![
+            // Allocate space for message, ensuring at least 1 line height
+            Constraint::Length(message_height.max(1)), // Use actual calculated height
+        ];
+        if button_row_height > 0 {
+            constraints.push(Constraint::Length(button_row_height));
+        }
 
-    // Render Message
-    let available_width = inner_area.width as usize;
-    let ellipsis = "...";
-    let ellipsis_width = UnicodeWidthStr::width(ellipsis);
+        let chunks = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints(constraints)
+            .split(inner_area);
 
-    let processed_lines: Vec<Line> =
-        message_lines
+        // Render Message
+        let available_width = inner_area.width as usize;
+        let ellipsis = "...";
+        let ellipsis_width = UnicodeWidthStr::width(ellipsis);
+
+        let processed_lines: Vec<Line> = message_lines
             .into_iter()
             .map(|line| {
                 let line_width = UnicodeWidthStr::width(line);
@@ -91,81 +101,83 @@ pub fn render_dialog(
                     // Truncate with ellipsis
                     let mut truncated_len = 0;
                     let mut current_width = 0;
-                    // Iterate over graphemes to handle multi-byte characters correctly
                     for (idx, grapheme) in line.grapheme_indices(true) {
                         let grapheme_width = UnicodeWidthStr::width(grapheme);
-                        if current_width + grapheme_width > available_width.saturating_sub(ellipsis_width) {
-                            break; // Stop before exceeding width needed for text + ellipsis
+                        if current_width + grapheme_width
+                            > available_width.saturating_sub(ellipsis_width)
+                        {
+                            break;
                         }
                         current_width += grapheme_width;
-                        truncated_len = idx + grapheme.len(); // Store the byte index of the end of the last fitting grapheme
+                        truncated_len = idx + grapheme.len();
                     }
-                    let truncated_line = format!("{}{}", &line[..truncated_len], ellipsis);
-                    Line::from(Span::styled(truncated_line, Style::default().fg(theme.fg)))
+                    let truncated_line =
+                        format!("{}{}", &line[..truncated_len], ellipsis);
+                    Line::from(Span::styled(
+                            truncated_line,
+                            Style::default().fg(theme.fg),
+                    ))
                 } else {
-                    // Line fits, use it as is
                     Line::from(Span::styled(line, Style::default().fg(theme.fg)))
                 }
             })
-            .collect();
+        .collect();
 
-    let message_paragraph =
-        Paragraph::new(Text::from(processed_lines)).alignment(Alignment::Center);
-    // Render message in the first chunk
-    f.render_widget(message_paragraph, chunks[0]);
+        let message_paragraph =
+            Paragraph::new(Text::from(processed_lines)).alignment(Alignment::Center);
+        f.render_widget(message_paragraph, chunks[0]); // Render message in the first chunk
 
-    // Render Buttons if they exist and there's a chunk for them
-    if !dialog_buttons.is_empty() && chunks.len() > 1 {
-        let button_area = chunks[1];
-        let button_count = dialog_buttons.len();
+        // Render Buttons if they exist and there's a chunk for them
+        if !dialog_buttons.is_empty() && chunks.len() > 1 {
+            let button_area = chunks[1];
+            let button_count = dialog_buttons.len();
 
-        // Use Ratio for potentially more even distribution with few buttons
-        let button_constraints = std::iter::repeat(Constraint::Ratio(
-            1,
-            button_count as u32,
-        ))
-        .take(button_count)
-        .collect::<Vec<_>>();
+            let button_constraints = std::iter::repeat(Constraint::Ratio(
+                    1,
+                    button_count as u32,
+            ))
+                .take(button_count)
+                .collect::<Vec<_>>();
 
-        let button_chunks = Layout::default()
-            .direction(Direction::Horizontal)
-            .constraints(button_constraints)
-            .horizontal_margin(1) // Add space between buttons
-            .split(button_area);
+            let button_chunks = Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints(button_constraints)
+                .horizontal_margin(1) // Add space between buttons
+                .split(button_area);
 
-        for (i, button_label) in dialog_buttons.iter().enumerate() {
-            // Ensure we don't try to render into a non-existent chunk
-            if i >= button_chunks.len() {
-                break;
-            }
+            for (i, button_label) in dialog_buttons.iter().enumerate() {
+                if i >= button_chunks.len() {
+                    break;
+                }
 
-            let is_active = i == dialog_active_button_index;
-            let (button_style, border_style) = if is_active {
-                (
-                    Style::default()
+                let is_active = i == dialog_active_button_index;
+                let (button_style, border_style) = if is_active {
+                    (
+                        Style::default()
                         .fg(theme.highlight)
                         .add_modifier(Modifier::BOLD),
-                    Style::default().fg(theme.accent), // Highlight border
-                )
-            } else {
-                (
-                    Style::default().fg(theme.fg),
-                    Style::default().fg(theme.border), // Normal border
-                )
-            };
+                        Style::default().fg(theme.accent),
+                    )
+                } else {
+                    (
+                        Style::default().fg(theme.fg),
+                        Style::default().fg(theme.border),
+                    )
+                };
 
-            let button_block = Block::default()
-                .borders(Borders::ALL)
-                .border_type(BorderType::Plain)
-                .border_style(border_style);
+                let button_block = Block::default()
+                    .borders(Borders::ALL)
+                    .border_type(BorderType::Plain)
+                    .border_style(border_style);
 
-            f.render_widget(
-                Paragraph::new(button_label.as_str())
+                f.render_widget(
+                    Paragraph::new(button_label.as_str())
                     .block(button_block)
                     .style(button_style)
                     .alignment(Alignment::Center),
-                button_chunks[i],
-            );
+                    button_chunks[i],
+                );
+            }
         }
     }
 }

client/src/functions/modes/edit/add_table_e.rs

@@ -186,8 +186,11 @@ pub async fn execute_edit_action(
             let num_fields = AddTableState::INPUT_FIELD_COUNT;
             if num_fields > 0 {
                 let current_field = state.current_field();
-                let new_field = (current_field + 1) % num_fields;
-                state.set_current_field(new_field);
+                let last_field_index = num_fields - 1;
+                // Prevent cycling forward
+                if current_field < last_field_index {
+                    state.set_current_field(current_field + 1);
+                }
                 let current_input = state.get_current_input();
                 let max_pos = current_input.len();
                 state.set_current_cursor_pos((*ideal_cursor_column).min(max_pos));
@@ -198,12 +201,9 @@ pub async fn execute_edit_action(
             let num_fields = AddTableState::INPUT_FIELD_COUNT;
             if num_fields > 0 {
                 let current_field = state.current_field();
-                let new_field = if current_field == 0 {
-                    num_fields - 1
-                } else {
-                    current_field - 1
-                };
-                state.set_current_field(new_field);
+                if current_field > 0 {
+                    state.set_current_field(current_field - 1);
+                }
                 let current_input = state.get_current_input();
                 let max_pos = current_input.len();
                 state.set_current_cursor_pos((*ideal_cursor_column).min(max_pos));
@@ -227,18 +227,16 @@ pub async fn execute_edit_action(
             Ok("".to_string())
         }
         "move_up" => {
-            let num_fields = AddTableState::INPUT_FIELD_COUNT;
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                if current_field > 0 {
-                    let new_field = current_field - 1;
-                    state.set_current_field(new_field);
-                    let current_input = state.get_current_input();
-                    let max_pos = current_input.len();
-                    state.set_current_cursor_pos((*ideal_cursor_column).min(max_pos));
-                }
+            let current_field = state.current_field();
+            // Prevent moving up from the first field
+            if current_field > 0 {
+                let new_field = current_field - 1;
+                state.set_current_field(new_field);
+                let current_input = state.get_current_input();
+                let max_pos = current_input.len();
+                state.set_current_cursor_pos((*ideal_cursor_column).min(max_pos));
             }
-            Ok("".to_string())
+            Ok("ahoj".to_string())
         }
         "move_down" => {
             let num_fields = AddTableState::INPUT_FIELD_COUNT;

client/src/functions/modes/navigation/add_table_nav.rs

@@ -7,6 +7,7 @@ use crate::state::{
 use crossterm::event::{KeyEvent};
 use ratatui::widgets::TableState;
 use crate::tui::functions::common::add_table::handle_add_column_action;
+use crate::ui::handlers::context::DialogPurpose;
 
 /// Handles navigation events specifically for the Add Table view.
 /// Returns true if the event was handled, false otherwise.
@@ -23,45 +24,74 @@ pub fn handle_add_table_navigation(
     let mut new_focus = current_focus; // Initialize new_focus
 
     // Define focus groups for horizontal navigation
-    let is_left_pane_focus = matches!(current_focus,
+    let is_left_pane_block_focus = matches!(current_focus, // Focus on the table blocks
         AddTableFocus::ColumnsTable | AddTableFocus::IndexesTable | AddTableFocus::LinksTable
     );
+    let is_inside_table_focus = matches!(current_focus, // Focus inside for scrolling
+        AddTableFocus::InsideColumnsTable | AddTableFocus::InsideIndexesTable | AddTableFocus::InsideLinksTable
+    );
     let is_right_pane_general_focus = matches!(current_focus, // Non-canvas elements in right pane
-         AddTableFocus::AddColumnButton | AddTableFocus::SaveButton | AddTableFocus::CancelButton
+         AddTableFocus::AddColumnButton | AddTableFocus::SaveButton | AddTableFocus::DeleteSelectedButton | AddTableFocus::CancelButton
      );
     let is_canvas_input_focus = matches!(current_focus,
         AddTableFocus::InputTableName | AddTableFocus::InputColumnName | AddTableFocus::InputColumnType
     );
 
     match action.as_deref() {
+       // --- Handle Exiting Table Scroll Mode ---
+       Some("exit_table_scroll") => {
+           match current_focus {
+               AddTableFocus::InsideColumnsTable => {
+                   add_table_state.column_table_state.select(None);
+                   new_focus = AddTableFocus::ColumnsTable;
+                   *command_message = "Exited Columns Table".to_string();
+               }
+               AddTableFocus::InsideIndexesTable => {
+                   add_table_state.index_table_state.select(None);
+                   new_focus = AddTableFocus::IndexesTable;
+                   *command_message = "Exited Indexes Table".to_string();
+               }
+               AddTableFocus::InsideLinksTable => {
+                   add_table_state.link_table_state.select(None);
+                   new_focus = AddTableFocus::LinksTable;
+                   *command_message = "Exited Links Table".to_string();
+               }
+               _ => {
+                   // Action triggered but not applicable in this focus state
+                   handled = false;
+               }
+           }
+           // If handled (i.e., focus changed), handled remains true.
+           // If not handled, handled becomes false.
+       }
+
         // --- Vertical Navigation (Up/Down) ---
         Some("move_up") => {
             match current_focus {
-                AddTableFocus::InputTableName => new_focus = AddTableFocus::CancelButton, // Wrap top (right pane)
+                AddTableFocus::InputTableName => new_focus = AddTableFocus::CancelButton,
                 AddTableFocus::InputColumnName => new_focus = AddTableFocus::InputTableName,
                 AddTableFocus::InputColumnType => new_focus = AddTableFocus::InputColumnName,
                 AddTableFocus::AddColumnButton => new_focus = AddTableFocus::InputColumnType,
-                AddTableFocus::ColumnsTable => { // Left pane navigation
-                    if !navigate_table_up(&mut add_table_state.column_table_state, add_table_state.columns.len()) {
-                        // If at top of columns, potentially wrap to bottom of left pane (LinksTable) or stay? Let's stay for now.
-                        // Or maybe move to AddColumnButton? Let's try moving up from right pane instead.
-                        new_focus = AddTableFocus::AddColumnButton; // Tentative: move focus up from right pane
-                    }
+                // Navigate between blocks when focus is on the table block itself
+                AddTableFocus::ColumnsTable => new_focus = AddTableFocus::AddColumnButton, // Move up to right pane
+                AddTableFocus::IndexesTable => new_focus = AddTableFocus::ColumnsTable,
+                AddTableFocus::LinksTable => new_focus = AddTableFocus::IndexesTable,
+                // Scroll inside the table when focus is internal
+                AddTableFocus::InsideColumnsTable => {
+                    navigate_table_up(&mut add_table_state.column_table_state, add_table_state.columns.len());
+                    // Stay inside the table, don't change new_focus
                 }
-                AddTableFocus::IndexesTable => {
-                    if !navigate_table_up(&mut add_table_state.index_table_state, add_table_state.indexes.len()) {
-                        new_focus = AddTableFocus::ColumnsTable;
-                    }
+                AddTableFocus::InsideIndexesTable => {
+                    navigate_table_up(&mut add_table_state.index_table_state, add_table_state.indexes.len());
+                    // Stay inside the table
                 }
-                AddTableFocus::LinksTable => {
-                    if !navigate_table_up(&mut add_table_state.link_table_state, add_table_state.links.len()) {
-                        new_focus = AddTableFocus::IndexesTable;
-                    }
+                AddTableFocus::InsideLinksTable => {
+                    navigate_table_up(&mut add_table_state.link_table_state, add_table_state.links.len());
+                    // Stay inside the table
                 }
-                AddTableFocus::SaveButton => new_focus = AddTableFocus::LinksTable, // Move up to left pane bottom
+                AddTableFocus::SaveButton => new_focus = AddTableFocus::LinksTable,
                 AddTableFocus::DeleteSelectedButton => new_focus = AddTableFocus::SaveButton,
                 AddTableFocus::CancelButton => new_focus = AddTableFocus::DeleteSelectedButton,
-
             }
         }
         Some("move_down") => {
@@ -69,57 +99,46 @@ pub fn handle_add_table_navigation(
                 AddTableFocus::InputTableName => new_focus = AddTableFocus::InputColumnName,
                 AddTableFocus::InputColumnName => new_focus = AddTableFocus::InputColumnType,
                 AddTableFocus::InputColumnType => new_focus = AddTableFocus::AddColumnButton,
-                AddTableFocus::AddColumnButton => new_focus = AddTableFocus::ColumnsTable, // Move down to left pane top
-                AddTableFocus::ColumnsTable => { // Left pane navigation
-                    if !navigate_table_down(&mut add_table_state.column_table_state, add_table_state.columns.len()) {
-                        new_focus = AddTableFocus::IndexesTable; // Move to next left pane item
-                    }
+                AddTableFocus::AddColumnButton => new_focus = AddTableFocus::ColumnsTable,
+                // Navigate between blocks when focus is on the table block itself
+                AddTableFocus::ColumnsTable => new_focus = AddTableFocus::IndexesTable,
+                AddTableFocus::IndexesTable => new_focus = AddTableFocus::LinksTable,
+                AddTableFocus::LinksTable => new_focus = AddTableFocus::SaveButton, // Move down to right pane
+                // Scroll inside the table when focus is internal
+                AddTableFocus::InsideColumnsTable => {
+                    navigate_table_down(&mut add_table_state.column_table_state, add_table_state.columns.len());
+                    // Stay inside the table
                 }
-                AddTableFocus::IndexesTable => {
-                    if !navigate_table_down(&mut add_table_state.index_table_state, add_table_state.indexes.len()) {
-                        new_focus = AddTableFocus::LinksTable;
-                    }
+                AddTableFocus::InsideIndexesTable => {
+                    navigate_table_down(&mut add_table_state.index_table_state, add_table_state.indexes.len());
+                    // Stay inside the table
                 }
-                AddTableFocus::LinksTable => {
-                    if !navigate_table_down(&mut add_table_state.link_table_state, add_table_state.links.len()) {
-                        new_focus = AddTableFocus::SaveButton; // Move down to right pane bottom
-                    }
+                AddTableFocus::InsideLinksTable => {
+                    navigate_table_down(&mut add_table_state.link_table_state, add_table_state.links.len());
+                    // Stay inside the table
                 }
                 AddTableFocus::SaveButton => new_focus = AddTableFocus::DeleteSelectedButton,
                 AddTableFocus::DeleteSelectedButton => new_focus = AddTableFocus::CancelButton,
-                AddTableFocus::CancelButton => new_focus = AddTableFocus::InputTableName, // Wrap bottom (right pane)
+                AddTableFocus::CancelButton => new_focus = AddTableFocus::InputTableName,
             }
         }
 
         // --- Horizontal Navigation (Left/Right) ---
         Some("next_option") => { // 'l' or Right: Move from Left Pane to Right Pane
-            if is_left_pane_focus {
-                new_focus = match current_focus {
-                    // Map left pane items to corresponding right pane items (approximate vertical alignment)
-                    AddTableFocus::ColumnsTable => AddTableFocus::InputTableName,
-                    AddTableFocus::IndexesTable => AddTableFocus::InputColumnName, // Or AddColumnButton?
-                    AddTableFocus::LinksTable => AddTableFocus::SaveButton,
-                    _ => current_focus, // Should not happen based on is_left_pane_focus
-                };
-            } else if is_right_pane_general_focus || is_canvas_input_focus {
-                 // If already in right pane, maybe wrap Save -> Cancel or stay? Let's handle Save->Cancel only.
-                 if current_focus == AddTableFocus::SaveButton {
-                     new_focus = AddTableFocus::CancelButton;
-                 }
-            }
+            // Horizontal nav within bottom buttons
+            if current_focus == AddTableFocus::SaveButton {
+                new_focus = AddTableFocus::DeleteSelectedButton;
+            } else if current_focus == AddTableFocus::DeleteSelectedButton {
+                new_focus = AddTableFocus::CancelButton;
+            }        
         }
         Some("previous_option") => { // 'h' or Left: Move from Right Pane to Left Pane
-            if is_right_pane_general_focus {
-                 new_focus = match current_focus {
-                    // Map right pane items back to left pane items (approximate vertical alignment)
-                    AddTableFocus::InputTableName | AddTableFocus::InputColumnName | AddTableFocus::InputColumnType | AddTableFocus::AddColumnButton => AddTableFocus::ColumnsTable, // Go to top of left pane
-                    AddTableFocus::SaveButton | AddTableFocus::CancelButton => AddTableFocus::LinksTable, // Go to bottom of left pane
-                    _ => current_focus, // Should not happen
-                 };
-            } else if is_left_pane_focus {
-                 // If already in left pane, pressing 'h' could wrap to Cancel button?
-                 new_focus = AddTableFocus::CancelButton; // Wrap left-to-right bottom
-            }
+            // Horizontal nav within bottom buttons
+            if current_focus == AddTableFocus::CancelButton {
+                new_focus = AddTableFocus::DeleteSelectedButton;
+            } else if current_focus == AddTableFocus::DeleteSelectedButton {
+                new_focus = AddTableFocus::SaveButton;
+            }        
         }
 
         // --- Tab / Shift+Tab Navigation (Keep as vertical cycle) ---
@@ -129,9 +148,10 @@ pub fn handle_add_table_navigation(
                 AddTableFocus::InputColumnName => AddTableFocus::InputColumnType,
                 AddTableFocus::InputColumnType => AddTableFocus::AddColumnButton,
                 AddTableFocus::AddColumnButton => AddTableFocus::ColumnsTable,
-                AddTableFocus::ColumnsTable => AddTableFocus::IndexesTable,
-                AddTableFocus::IndexesTable => AddTableFocus::LinksTable,
-                AddTableFocus::LinksTable => AddTableFocus::SaveButton,
+                // Treat Inside* same as block focus for tabbing out
+                AddTableFocus::ColumnsTable | AddTableFocus::InsideColumnsTable => AddTableFocus::IndexesTable,
+                AddTableFocus::IndexesTable | AddTableFocus::InsideIndexesTable => AddTableFocus::LinksTable,
+                AddTableFocus::LinksTable | AddTableFocus::InsideLinksTable => AddTableFocus::SaveButton,
                 AddTableFocus::SaveButton => AddTableFocus::DeleteSelectedButton,
                 AddTableFocus::DeleteSelectedButton => AddTableFocus::CancelButton,
                 AddTableFocus::CancelButton => AddTableFocus::InputTableName, // Wrap
@@ -143,9 +163,10 @@ pub fn handle_add_table_navigation(
                 AddTableFocus::InputColumnName => AddTableFocus::InputTableName,
                 AddTableFocus::InputColumnType => AddTableFocus::InputColumnName,
                 AddTableFocus::AddColumnButton => AddTableFocus::InputColumnType,
-                AddTableFocus::ColumnsTable => AddTableFocus::AddColumnButton,
-                AddTableFocus::IndexesTable => AddTableFocus::ColumnsTable,
-                AddTableFocus::LinksTable => AddTableFocus::IndexesTable,
+                // Treat Inside* same as block focus for tabbing out
+                AddTableFocus::ColumnsTable | AddTableFocus::InsideColumnsTable => AddTableFocus::AddColumnButton,
+                AddTableFocus::IndexesTable | AddTableFocus::InsideIndexesTable => AddTableFocus::ColumnsTable,
+                AddTableFocus::LinksTable | AddTableFocus::InsideLinksTable => AddTableFocus::IndexesTable,
                 AddTableFocus::SaveButton => AddTableFocus::LinksTable,
                 AddTableFocus::DeleteSelectedButton => AddTableFocus::SaveButton,
                 AddTableFocus::CancelButton => AddTableFocus::DeleteSelectedButton,
@@ -155,6 +176,75 @@ pub fn handle_add_table_navigation(
         // --- Selection ---
         Some("select") => {
             match current_focus {
+                // --- Enter/Exit Table Focus ---
+                AddTableFocus::ColumnsTable => {
+                    new_focus = AddTableFocus::InsideColumnsTable;
+                    // Select first item if none selected when entering
+                    if add_table_state.column_table_state.selected().is_none() && !add_table_state.columns.is_empty() {
+                        add_table_state.column_table_state.select(Some(0));
+                    }
+                    *command_message = "Entered Columns Table (Scroll with Up/Down, Select to exit)".to_string();
+                }
+                AddTableFocus::IndexesTable => {
+                    new_focus = AddTableFocus::InsideIndexesTable;
+                    if add_table_state.index_table_state.selected().is_none() && !add_table_state.indexes.is_empty() {
+                        add_table_state.index_table_state.select(Some(0));
+                    }
+                    *command_message = "Entered Indexes Table (Scroll with Up/Down, Select to exit)".to_string();
+                }
+                AddTableFocus::LinksTable => {
+                    new_focus = AddTableFocus::InsideLinksTable;
+                    if add_table_state.link_table_state.selected().is_none() && !add_table_state.links.is_empty() {
+                        add_table_state.link_table_state.select(Some(0));
+                    }
+                    *command_message = "Entered Links Table (Scroll with Up/Down, Select to toggle/exit)".to_string();
+                }
+                AddTableFocus::InsideColumnsTable => {
+                    // Toggle selection when pressing select *inside* the columns table
+                    if let Some(index) = add_table_state.column_table_state.selected() {
+                        if let Some(col) = add_table_state.columns.get_mut(index) {
+                            col.selected = !col.selected;
+                            add_table_state.has_unsaved_changes = true;
+                            *command_message = format!(
+                                "Toggled selection for column: {} to {}",
+                                col.name, col.selected
+                            );
+                        }
+                    } else {
+                        *command_message = "No column highlighted to toggle selection".to_string();
+                    }
+                }
+                AddTableFocus::InsideIndexesTable => {
+                    // Select does nothing here anymore, only Esc exits.
+                    if let Some(index) = add_table_state.index_table_state.selected() {
+                        *command_message = format!("Selected index index {} (Press Esc to exit scroll mode)", index);
+                    } else {
+                        *command_message = "No index selected (Press Esc to exit scroll mode)".to_string();
+                    }
+                }
+                AddTableFocus::InsideLinksTable => {
+                    // Toggle selection when pressing select *inside* the links table
+                    if let Some(index) = add_table_state.link_table_state.selected() {
+                        if let Some(link) = add_table_state.links.get_mut(index) {
+                            link.selected = !link.selected; // Toggle the selected state
+                            add_table_state.has_unsaved_changes = true; // Mark changes
+                            *command_message = format!(
+                                "Toggled selection for link: {} to {}",
+                                link.linked_table_name, link.selected
+                            );
+                        } else {
+                            *command_message = "Error: Selected link index out of bounds".to_string();
+                        }
+                    } else {
+                        *command_message = "No link selected to toggle".to_string();
+                    }
+                    // Stay inside the links table after toggling
+                    new_focus = AddTableFocus::InsideLinksTable;
+                    // Alternative: Exit after toggle:
+                    // new_focus = AddTableFocus::LinksTable;
+                    // *command_message = format!("{} - Exited Links Table", command_message);
+                }
+                // --- Other Select Actions ---
                 AddTableFocus::AddColumnButton => {
                     if let Some(focus_after_add) = handle_add_column_action(add_table_state, command_message) {
                         new_focus = focus_after_add;
@@ -165,28 +255,45 @@ pub fn handle_add_table_navigation(
                     // TODO: Implement logic
                 }
                 AddTableFocus::DeleteSelectedButton => {
-                    *command_message = "Action: Delete selected".to_string();
-                    // TODO: Implement logic
+                    // --- Show Confirmation Dialog ---
+                    // Collect tuples of (index, name, type) for selected columns
+                    let columns_to_delete: Vec<(usize, String, String)> = add_table_state
+                        .columns
+                        .iter()
+                        .enumerate() // Get index along with the column
+                        .filter(|(_index, col)| col.selected) // Filter based on selection
+                        .map(|(index, col)| (index, col.name.clone(), col.data_type.clone())) // Map to (index, name, type)
+                        .collect();
+
+                    if columns_to_delete.is_empty() {
+                        *command_message = "No columns selected for deletion.".to_string();
+                    } else {
+                        // Format the message to include index, name, and type
+                        let column_details: String = columns_to_delete
+                            .iter()
+                            // Add 1 to index for 1-based numbering for user display
+                            .map(|(index, name, dtype)| format!("{}. {} ({})", index + 1, name, dtype))
+                            .collect::<Vec<String>>()
+                            .join("\n");
+
+                        // Use the formatted column_details string in the message
+                        let message = format!(
+                            "Delete the following columns?\n\n{}",
+                            column_details
+                        );
+                        let buttons = vec!["Confirm".to_string(), "Cancel".to_string()];
+                        app_state.show_dialog(
+                            "Confirm Deletion",
+                            &message,
+                            buttons,
+                            DialogPurpose::ConfirmDeleteColumns,
+                        );
+                    }
                 }
                 AddTableFocus::CancelButton => {
                     *command_message = "Action: Cancel Add Table".to_string();
                     // TODO: Implement logic
                 }
-                AddTableFocus::ColumnsTable => {
-                     if let Some(index) = add_table_state.column_table_state.selected() {
-                         *command_message = format!("Selected column index {}", index);
-                     } else { *command_message = "No column selected".to_string(); }
-                }
-                 AddTableFocus::IndexesTable => {
-                     if let Some(index) = add_table_state.index_table_state.selected() {
-                         *command_message = format!("Selected index index {}", index);
-                     } else { *command_message = "No index selected".to_string(); }
-                 }
-                 AddTableFocus::LinksTable => {
-                     if let Some(index) = add_table_state.link_table_state.selected() {
-                         *command_message = format!("Selected link index {}", index);
-                     } else { *command_message = "No link selected".to_string(); }
-                 }
                 _ => { // Input fields
                     *command_message = format!("Select on {:?}", current_focus);
                     handled = false; // Let main loop handle edit mode toggle maybe
@@ -207,32 +314,19 @@ pub fn handle_add_table_navigation(
     // Update focus state if it changed and was handled
     if handled && current_focus != new_focus {
         add_table_state.current_focus = new_focus;
-        *command_message = format!("Focus set to {:?}", add_table_state.current_focus);
+        // Avoid overwriting specific messages set during 'select' handling
+        if command_message.is_empty() || command_message.starts_with("Focus set to") {
+             *command_message = format!("Focus set to {:?}", add_table_state.current_focus);
+        }
 
-        // --- THIS IS THE KEY PART ---
         // Check if the *new* focus target is one of the canvas input fields
         let new_is_canvas_input_focus = matches!(new_focus,
             AddTableFocus::InputTableName | AddTableFocus::InputColumnName | AddTableFocus::InputColumnType
         );
-        // Set focus_outside_canvas based on whether the new focus is NOT an input field
-        app_state.ui.focus_outside_canvas = !new_is_canvas_input_focus; // <--- Sets the flag correctly
-        // --- END KEY PART ---
-
-
-        // Select first item when focusing a table
-        match add_table_state.current_focus {
-            AddTableFocus::ColumnsTable if add_table_state.column_table_state.selected().is_none() && !add_table_state.columns.is_empty() => {
-                    add_table_state.column_table_state.select(Some(0));
-            }
-            AddTableFocus::IndexesTable if add_table_state.index_table_state.selected().is_none() && !add_table_state.indexes.is_empty() => {
-                    add_table_state.index_table_state.select(Some(0));
-            }
-            AddTableFocus::LinksTable if add_table_state.link_table_state.selected().is_none() && !add_table_state.links.is_empty() => {
-                    add_table_state.link_table_state.select(Some(0));
-            }_ => {}
-        }
+        // Focus is outside canvas if it's not an input field
+        app_state.ui.focus_outside_canvas = !new_is_canvas_input_focus;
     } else if !handled {
-        // ...
+        // command_message.clear(); // Optional: Clear message if not handled here
     }
 
     handled
@@ -248,14 +342,14 @@ fn navigate_table_up(table_state: &mut TableState, item_count: usize) -> bool {
         Some(index) => {
             if index > 0 {
                 table_state.select(Some(index - 1));
-                true
+                true // Navigation happened
             } else {
                 false // Was at the top
             }
         }
-        None => {
-            table_state.select(Some(item_count - 1)); // Select last item
-            true
+        None => { // No item selected, select the last one
+            table_state.select(Some(item_count - 1));
+            true // Navigation happened (selection set)
         }
     }
 }
@@ -269,14 +363,14 @@ fn navigate_table_down(table_state: &mut TableState, item_count: usize) -> bool
         Some(index) => {
             if index < item_count - 1 {
                 table_state.select(Some(index + 1));
-                true
+                true // Navigation happened
             } else {
                 false // Was at the bottom
             }
         }
-        None => {
-             table_state.select(Some(0)); // Select first item
-             true
+        None => { // No item selected, select the first one
+             table_state.select(Some(0));
+             true // Navigation happened (selection set)
         }
     }
 }

client/src/modes/canvas/edit.rs

@@ -6,10 +6,10 @@ use crate::state::pages::{
     canvas_state::CanvasState,
 };
 use crate::state::pages::form::FormState;
-use crate::state::pages::add_table::AddTableState; // Added
+use crate::state::pages::add_table::AddTableState;
 use crate::modes::handlers::event::EventOutcome;
 use crate::functions::modes::edit::{auth_e, form_e};
-use crate::functions::modes::edit::add_table_e; // Added
+use crate::functions::modes::edit::add_table_e;
 use crate::state::app::state::AppState;
 use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
 
@@ -25,7 +25,7 @@ pub async fn handle_edit_event(
     form_state: &mut FormState,
     login_state: &mut LoginState,
     register_state: &mut RegisterState,
-    add_table_state: &mut AddTableState, // Added
+    add_table_state: &mut AddTableState,
     ideal_cursor_column: &mut usize,
     current_position: &mut u64,
     total_count: u64,
@@ -38,9 +38,6 @@ pub async fn handle_edit_event(
         key.code,
         key.modifiers,
     ) {
-        // This mode change should likely be handled in event.rs
-        // Returning a message here might prevent the mode switch.
-        // Consider if this check is necessary here.
         return Ok(EditEventOutcome::Message(
             "Command mode entry handled globally.".to_string(),
         ));
@@ -62,7 +59,6 @@ pub async fn handle_edit_event(
                 )
                 .await?
             } else if app_state.ui.show_register {
-                // Keeping this block as requested
                 auth_e::execute_common_action(
                     action,
                     register_state,
@@ -70,14 +66,13 @@ pub async fn handle_edit_event(
                     current_position,
                     total_count,
                 )
-                .await? // Results in String on success
+                .await?
             } else if app_state.ui.show_add_table {
-                // Placeholder - common actions for AddTable might be different
                 format!(
                     "Action '{}' not fully implemented for Add Table view here.",
                     action
                 )
-            } else { // Assuming FormState otherwise
+            } else {
                 let outcome = form_e::execute_common_action(
                     action,
                     form_state,
@@ -103,11 +98,65 @@ pub async fn handle_edit_event(
     if let Some(action) =
         config.get_edit_action_for_key(key.code, key.modifiers)
             .as_deref() {
+        // Handle enter_decider first
+        if action == "enter_decider" {
+            let effective_action = if app_state.ui.show_register 
+                && register_state.in_suggestion_mode 
+                && register_state.current_field() == 4 {
+                "select_suggestion"
+            } else {
+                "next_field"
+            };
+            
+            let msg = if app_state.ui.show_login {
+                auth_e::execute_edit_action(
+                    effective_action,
+                    key,
+                    login_state,
+                    ideal_cursor_column,
+                    grpc_client,
+                    current_position,
+                    total_count,
+                )
+                .await?
+            } else if app_state.ui.show_add_table {
+                add_table_e::execute_edit_action(
+                    effective_action,
+                    key,
+                    add_table_state,
+                    ideal_cursor_column,
+                )
+                .await?
+            } else if app_state.ui.show_register {
+                auth_e::execute_edit_action(
+                    effective_action,
+                    key,
+                    register_state,
+                    ideal_cursor_column,
+                    grpc_client,
+                    current_position,
+                    total_count,
+                )
+                .await?
+            } else {
+                form_e::execute_edit_action(
+                    effective_action,
+                    key,
+                    form_state,
+                    ideal_cursor_column,
+                    grpc_client,
+                    current_position,
+                    total_count,
+                )
+                .await?
+            };
+            return Ok(EditEventOutcome::Message(msg));
+        }
+
         if action == "exit" {
-            // Handle exiting suggestion mode in Register view first
             if app_state.ui.show_register && register_state.in_suggestion_mode {
                 let msg = auth_e::execute_edit_action(
-                    "exit_suggestion_mode", // Specific action for suggestion exit
+                    "exit_suggestion_mode",
                     key,
                     register_state,
                     ideal_cursor_column,
@@ -118,14 +167,12 @@ pub async fn handle_edit_event(
                 .await?;
                 return Ok(EditEventOutcome::Message(msg));
             } else {
-                // Signal exit from Edit mode
                 return Ok(EditEventOutcome::ExitEditMode);
             }
         }
 
         // Special handling for role field suggestions (Register view only)
         if app_state.ui.show_register && register_state.current_field() == 4 {
-            // Check if Tab was pressed to *enter* suggestion mode
             if !register_state.in_suggestion_mode
                 && key.code == KeyCode::Tab
                 && key.modifiers == KeyModifiers::NONE
@@ -133,7 +180,7 @@ pub async fn handle_edit_event(
                 register_state.update_role_suggestions();
                 if !register_state.role_suggestions.is_empty() {
                     register_state.in_suggestion_mode = true;
-                    register_state.selected_suggestion_index = Some(0); // Select first suggestion
+                    register_state.selected_suggestion_index = Some(0);
                     return Ok(EditEventOutcome::Message(
                         "Suggestions shown".to_string(),
                     ));
@@ -143,17 +190,14 @@ pub async fn handle_edit_event(
                     ));
                 }
             }
-            // Handle suggestion navigation/selection if already in suggestion mode
             if register_state.in_suggestion_mode
                 && matches!(
                     action,
-                    "suggestion_down"
-                        | "suggestion_up"
-                        | "select_suggestion"
+                    "suggestion_down" | "suggestion_up"
                 )
             {
                 let msg = auth_e::execute_edit_action(
-                    action, // Pass the specific suggestion action
+                    action,
                     key,
                     register_state,
                     ideal_cursor_column,
@@ -184,7 +228,6 @@ pub async fn handle_edit_event(
                 key,
                 add_table_state,
                 ideal_cursor_column,
-                // Pass other necessary params if add_table_e needs them
             )
             .await?
         } else if app_state.ui.show_register {
@@ -199,7 +242,6 @@ pub async fn handle_edit_event(
             )
             .await?
         } else {
-            // Assuming FormState otherwise
             form_e::execute_edit_action(
                 action,
                 key,
@@ -216,18 +258,16 @@ pub async fn handle_edit_event(
 
     // --- Character insertion ---
     if let KeyCode::Char(c) = key.code {
-        // Exit suggestion mode in Register view if a character is typed
         if app_state.ui.show_register && register_state.in_suggestion_mode {
             register_state.in_suggestion_mode = false;
             register_state.show_role_suggestions = false;
             register_state.selected_suggestion_index = None;
         }
 
-        // Execute insert_char action based on the current view
         let msg = if app_state.ui.show_login {
             auth_e::execute_edit_action(
                 "insert_char",
-                key, // Pass the key event containing the char
+                key,
                 login_state,
                 ideal_cursor_column,
                 grpc_client,
@@ -255,7 +295,6 @@ pub async fn handle_edit_event(
             )
             .await?
         } else {
-            // Assuming FormState otherwise
             form_e::execute_edit_action(
                 "insert_char",
                 key,
@@ -267,7 +306,7 @@ pub async fn handle_edit_event(
             )
             .await?
         };
-        // Update role suggestions after insertion if needed (Register view)
+        
         if app_state.ui.show_register && register_state.current_field() == 4 {
              register_state.update_role_suggestions();
         }
@@ -277,7 +316,6 @@ pub async fn handle_edit_event(
 
     // --- Handle Backspace/Delete ---
     if matches!(key.code, KeyCode::Backspace | KeyCode::Delete) {
-        // Exit suggestion mode in Register view
         if app_state.ui.show_register && register_state.in_suggestion_mode {
             register_state.in_suggestion_mode = false;
             register_state.show_role_suggestions = false;
@@ -290,7 +328,6 @@ pub async fn handle_edit_event(
             "delete_char_forward"
         };
 
-        // Execute delete action based on the current view
         let result_msg: String = if app_state.ui.show_login {
             auth_e::execute_edit_action(
                 action_str,
@@ -322,8 +359,7 @@ pub async fn handle_edit_event(
             )
             .await?
         } else {
-            // Assuming FormState otherwise
-             form_e::execute_edit_action(
+            form_e::execute_edit_action(
                 action_str,
                 key,
                 form_state,
@@ -333,7 +369,7 @@ pub async fn handle_edit_event(
                 total_count
             ).await?
         };
-         // Update role suggestions after deletion if needed (Register view)
+         
         if app_state.ui.show_register && register_state.current_field() == 4 {
              register_state.update_role_suggestions();
         }
@@ -341,7 +377,5 @@ pub async fn handle_edit_event(
         return Ok(EditEventOutcome::Message(result_msg));
     }
 
-    // Default return if no other handler matched
     Ok(EditEventOutcome::Message("".to_string()))
 }
-

client/src/modes/general/dialog.rs

@@ -6,10 +6,11 @@ use crate::ui::handlers::context::DialogPurpose;
 use crate::state::app::state::AppState;
 use crate::state::app::buffer::BufferState;
 use crate::state::pages::auth::AuthState;
-use crate::state::pages::auth::LoginState;
-use crate::state::pages::auth::RegisterState;
+use crate::state::pages::auth::{LoginState, RegisterState};
+use crate::state::pages::admin::AdminState;
 use crate::modes::handlers::event::EventOutcome;
 use crate::tui::functions::common::{login, register};
+use crate::tui::functions::common::add_table::handle_delete_selected_columns;
 
 /// Handles key events specifically when a dialog is active.
 /// Returns Some(Result<EventOutcome, Error>) if the event was handled (consumed),
@@ -22,6 +23,7 @@ pub async fn handle_dialog_event(
     login_state: &mut LoginState,
     register_state: &mut RegisterState,
     buffer_state: &mut BufferState,
+    admin_state: &mut AdminState,
 ) -> Option<Result<EventOutcome, Box<dyn std::error::Error>>> {
     if let Event::Key(key) = event {
         // Always allow Esc to dismiss
@@ -114,6 +116,20 @@ pub async fn handle_dialog_event(
                                 }
                             }
                         }
+                        DialogPurpose::ConfirmDeleteColumns => {
+                            match selected_index {
+                                0 => { // "Confirm" button selected
+                                    let outcome_message = handle_delete_selected_columns(&mut admin_state.add_table_state);
+                                    app_state.hide_dialog();
+                                    return Some(Ok(EventOutcome::Ok(outcome_message)));
+                                }
+                                1 => { // "Cancel" button selected
+                                    app_state.hide_dialog();
+                                    return Some(Ok(EventOutcome::Ok("Deletion cancelled.".to_string())));
+                                }
+                                _ => { /* Handle unexpected index */ }
+                            }
+                        }
                     }
                 }
                 _ => {} // Ignore other general actions when dialog is shown

client/src/modes/handlers/event.rs

@@ -6,6 +6,7 @@ use crate::services::auth::AuthClient;
 use crate::config::binds::config::Config;
 use crate::ui::handlers::rat_state::UiStateHandler;
 use crate::ui::handlers::context::UiContext;
+use crate::ui::handlers::context::DialogPurpose;
 use crate::functions::common::buffer;
 use crate::tui::{
     terminal::core::TerminalCore,
@@ -116,7 +117,14 @@ impl EventHandler {
 
         if app_state.ui.dialog.dialog_show {
             if let Some(dialog_result) = dialog::handle_dialog_event(
-                &event, config, app_state, auth_state, login_state, register_state, buffer_state
+                &event,
+                config,
+                app_state,
+                auth_state,
+                login_state,
+                register_state,
+                buffer_state,
+                admin_state,
             ).await {
                 return dialog_result;
             }
@@ -219,11 +227,21 @@ impl EventHandler {
                                     message = format!("Intro Option {} selected", index);
                                 }
                                 UiContext::Login => {
-                                    message = match index {
-                                        0 => login::save(auth_state, login_state, &mut self.auth_client, app_state).await?,
+                                    let login_action_message = match index {
+                                        0 => { // Index 0 corresponds to the "Login" button
+                                            match login::initiate_login(app_state, login_state).await {
+                                                Ok(outcome) => return Ok(outcome),
+                                                Err(e) => {
+                                                    app_state.show_dialog("Error", &format!("Failed to initiate login: {}", e), vec!["OK".to_string()], DialogPurpose::LoginFailed);
+                                                    login_state.login_request_pending = false;
+                                                    "Error initiating login".to_string()
+                                                }
+                                            }
+                                        },
                                         1 => login::back_to_main(login_state, app_state, buffer_state).await,
                                         _ => "Invalid Login Option".to_string(),
                                     };
+                                    message = login_action_message;
                                 }
                                 UiContext::Register => {
                                     message = match index {

client/src/state/app/state.rs

@@ -12,6 +12,7 @@ pub struct DialogState {
     pub dialog_buttons: Vec<String>,
     pub dialog_active_button_index: usize,
     pub purpose: Option<DialogPurpose>,
+    pub is_loading: bool,
 }
 
 pub struct UiState {
@@ -86,10 +87,41 @@ impl AppState {
         self.ui.dialog.dialog_buttons = buttons;
         self.ui.dialog.dialog_active_button_index = 0;
         self.ui.dialog.purpose = Some(purpose);
+        self.ui.dialog.is_loading = false;
         self.ui.dialog.dialog_show = true;
         self.ui.focus_outside_canvas = true;
     }
 
+    /// Shows a dialog specifically for loading states.
+    pub fn show_loading_dialog(&mut self, title: &str, message: &str) {
+        self.ui.dialog.dialog_title = title.to_string();
+        self.ui.dialog.dialog_message = message.to_string();
+        self.ui.dialog.dialog_buttons.clear(); // No buttons during loading
+        self.ui.dialog.dialog_active_button_index = 0;
+        self.ui.dialog.purpose = None; // Purpose is set when loading finishes
+        self.ui.dialog.is_loading = true;
+        self.ui.dialog.dialog_show = true;
+        self.ui.focus_outside_canvas = true; // Keep focus management consistent
+    }
+
+    /// Updates the content of an existing dialog, typically after loading.
+    pub fn update_dialog_content(
+        &mut self,
+        message: &str,
+        buttons: Vec<String>,
+        purpose: DialogPurpose,
+    ) {
+        if self.ui.dialog.dialog_show {
+            self.ui.dialog.dialog_message = message.to_string();
+            self.ui.dialog.dialog_buttons = buttons;
+            self.ui.dialog.dialog_active_button_index = 0; // Reset focus
+            self.ui.dialog.purpose = Some(purpose);
+            self.ui.dialog.is_loading = false; // Loading finished
+                                               // Keep dialog_show = true
+                                               // Keep focus_outside_canvas = true
+        }
+    }
+
     /// Hides the dialog and clears its content.
     pub fn hide_dialog(&mut self) {
         self.ui.dialog.dialog_show = false;
@@ -156,6 +188,7 @@ impl Default for DialogState {
             dialog_buttons: Vec::new(),
             dialog_active_button_index: 0,
             purpose: None,
+            is_loading: false,
         }
     }
 }

client/src/state/pages/add_table.rs

@@ -6,12 +6,14 @@ use ratatui::widgets::TableState;
 pub struct ColumnDefinition {
     pub name: String,
     pub data_type: String,
+    pub selected: bool,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct LinkDefinition {
     pub linked_table_name: String,
     pub is_required: bool,
+    pub selected: bool,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
@@ -25,6 +27,10 @@ pub enum AddTableFocus {
     ColumnsTable,
     IndexesTable,
     LinksTable,
+    // Inside Tables (Scrolling Focus)
+    InsideColumnsTable,
+    InsideIndexesTable,
+    InsideLinksTable,
     // Buttons
     SaveButton,
     DeleteSelectedButton,

client/src/state/pages/auth.rs

@@ -29,6 +29,7 @@ pub struct LoginState {
     pub current_field: usize,
     pub current_cursor_pos: usize,
     pub has_unsaved_changes: bool,
+    pub login_request_pending: bool,
 }
 
 /// Represents the state of the Registration form UI
@@ -71,6 +72,7 @@ impl LoginState {
             current_field: 0,
             current_cursor_pos: 0,
             has_unsaved_changes: false,
+            login_request_pending: false,
         }
     }
 }

client/src/tui/functions/common/add_table.rs

@@ -36,6 +36,7 @@ pub fn handle_add_column_action(
             let new_column = ColumnDefinition {
                 name: column_name_in.to_string(),
                 data_type: column_type_in.to_string(),
+                selected: false,
             };
             add_table_state.columns.push(new_column.clone()); // Clone for msg
             msg.push_str(&format!("Column '{}' added.", new_column.name));
@@ -73,3 +74,27 @@ pub fn handle_add_column_action(
         }
     }
 }
+
+/// Handles deleting columns marked as selected in the AddTableState.
+pub fn handle_delete_selected_columns(
+    add_table_state: &mut AddTableState,
+) -> String {
+    let initial_count = add_table_state.columns.len();
+    // Keep only the columns that are NOT selected
+    add_table_state.columns.retain(|col| !col.selected);
+    let deleted_count = initial_count - add_table_state.columns.len();
+
+    if deleted_count > 0 {
+        add_table_state.has_unsaved_changes = true;
+        // Reset selection highlight as indices have changed
+        add_table_state.column_table_state.select(None);
+        // Optionally, select the first item if the list is not empty
+        // if !add_table_state.columns.is_empty() {
+        //     add_table_state.column_table_state.select(Some(0));
+        // }
+        format!("Deleted {} selected column(s).", deleted_count)
+    } else {
+        "No columns marked for deletion.".to_string()
+    }
+}
+

client/src/tui/functions/common/login.rs

@@ -7,9 +7,11 @@ use crate::state::app::state::AppState;
 use crate::state::app::buffer::{AppView, BufferState};
 use crate::state::pages::canvas_state::CanvasState;
 use crate::ui::handlers::context::DialogPurpose;
+use crate::modes::handlers::event::EventOutcome; // Make sure this is imported
 
 /// Attempts to log the user in using the provided credentials via gRPC.
 /// Updates AuthState and AppState on success or failure.
+/// (This is your existing function - remains unchanged)
 pub async fn save(
     auth_state: &mut AuthState,
     login_state: &mut LoginState,
@@ -21,24 +23,25 @@ pub async fn save(
 
     // Clear previous error/dialog state before attempting
     login_state.error_message = None;
-    // Use the helper to ensure dialog is hidden and cleared properly
-    app_state.hide_dialog();
+    app_state.hide_dialog(); // Hide any previous dialog
 
     // Call the gRPC login method
     match auth_client.login(identifier, password).await {
         Ok(response) => {
-            // Store authentication details on success
+            // Store authentication details using correct field names
             auth_state.auth_token = Some(response.access_token.clone());
             auth_state.user_id = Some(response.user_id.clone());
             auth_state.role = Some(response.role.clone());
             auth_state.decoded_username = Some(response.username.clone());
             login_state.set_has_unsaved_changes(false);
+            login_state.error_message = None;
 
+            // Format the success message using response data
             let success_message = format!(
                 "Login Successful!\n\n\
-                 Username: {}\n\
-                 User ID: {}\n\
-                 Role: {}",
+                Username: {}\n\
+                User ID: {}\n\
+                Role: {}",
                 response.username,
                 response.user_id,
                 response.role
@@ -50,37 +53,53 @@ pub async fn save(
                 vec!["Menu".to_string(), "Exit".to_string()],
                 DialogPurpose::LoginSuccess,
             );
-
+            login_state.password.clear();
+            login_state.current_cursor_pos = 0;
             Ok("Login successful, details shown in dialog.".to_string())
         }
         Err(e) => {
             let error_message = format!("{}", e);
-
-            // Use the helper method to configure and show the dialog
             app_state.show_dialog(
                 "Login Failed",
                 &error_message,
                 vec!["OK".to_string()],
                 DialogPurpose::LoginFailed,
             );
-
+            login_state.error_message = Some(error_message.clone());
             login_state.set_has_unsaved_changes(true);
-
             Ok(format!("Login failed: {}", error_message))
         }
     }
 }
 
+// --- Add this new function ---
+/// Sets the stage for login: shows loading dialog and sets the pending flag.
+/// Call this from the event handler when login is triggered.
+pub async fn initiate_login(
+    app_state: &mut AppState,
+    login_state: &mut LoginState,
+) -> Result<EventOutcome, Box<dyn std::error::Error>> {
+    // Show the loading dialog immediately
+    app_state.show_loading_dialog("Logging In", "Please wait...");
+    // Set the flag in LoginState to indicate the actual save should run next loop
+    login_state.login_request_pending = true;
+    // Return immediately to allow redraw
+    Ok(EventOutcome::Ok("Login initiated.".to_string()))
+}
+// --- End of new function ---
+
+
 /// Reverts the login form fields to empty and returns to the previous screen (Intro).
 pub async fn revert(
     login_state: &mut LoginState,
-    app_state: &mut AppState,
+    _app_state: &mut AppState, // Keep signature consistent if needed elsewhere
 ) -> String {
     // Clear the input fields
     login_state.username.clear();
     login_state.password.clear();
     login_state.error_message = None;
     login_state.set_has_unsaved_changes(false);
+    login_state.login_request_pending = false; // Ensure flag is reset on revert
 
     "Login reverted".to_string()
 }
@@ -95,9 +114,10 @@ pub async fn back_to_main(
     login_state.password.clear();
     login_state.error_message = None;
     login_state.set_has_unsaved_changes(false);
+    login_state.login_request_pending = false; // Ensure flag is reset
 
     // Ensure dialog is hidden if revert is called
-    app_state.hide_dialog(); // Uncomment if needed
+    app_state.hide_dialog();
 
     // Navigation logic
     buffer_state.close_active_buffer();
@@ -109,3 +129,4 @@ pub async fn back_to_main(
 
     "Returned to main menu".to_string()
 }
+

client/src/ui/handlers/context.rs

@@ -15,6 +15,7 @@ pub enum DialogPurpose {
     LoginFailed,
     RegisterSuccess,
     RegisterFailed,
+    ConfirmDeleteColumns, // add_table delete selected Columns
     // TODO in the future:
     // ConfirmQuit,
 }

client/src/ui/handlers/ui.rs

@@ -3,6 +3,7 @@
 use crate::config::binds::config::Config;
 use crate::config::colors::themes::Theme;
 use crate::services::grpc_client::GrpcClient;
+use crate::services::auth::AuthClient; // <-- Add AuthClient import
 use crate::services::ui_service::UiService;
 use crate::modes::common::commands::CommandHandler;
 use crate::modes::handlers::event::{EventHandler, EventOutcome};
@@ -17,11 +18,15 @@ use crate::state::pages::intro::IntroState;
 use crate::state::app::buffer::BufferState;
 use crate::state::app::buffer::AppView;
 use crate::state::app::state::AppState;
- // Import SaveOutcome
+use crate::ui::handlers::context::DialogPurpose; // <-- Add DialogPurpose import
+// Import SaveOutcome
 use crate::tui::terminal::{EventReader, TerminalCore};
 use crate::ui::handlers::render::render_ui;
+use crate::tui::functions::common::login; // <-- Add login module import
 use std::time::Instant;
 use crossterm::cursor::SetCursorStyle;
+use crossterm::event as crossterm_event;
+use tracing::{info, error};
 
 pub async fn run_ui() -> Result<(), Box<dyn std::error::Error>> {
     let config = Config::load()?;
@@ -57,9 +62,6 @@ pub async fn run_ui() -> Result<(), Box<dyn std::error::Error>> {
     let mut current_fps = 0.0;
 
     loop {
-        // Determine edit mode based on EventHandler state
-        let is_edit_mode = event_handler.is_edit_mode;
-
         // --- Synchronize UI View from Active Buffer ---
         if let Some(active_view) = buffer_state.get_active_view() {
             // Reset all flags first
@@ -87,6 +89,10 @@ pub async fn run_ui() -> Result<(), Box<dyn std::error::Error>> {
         }
         // --- End Synchronization ---
 
+        // --- 3. Draw UI ---
+        // Draw the current state *first*. This ensures the loading dialog
+        // set in the *previous* iteration gets rendered before the pending
+        // action check below.
         terminal.draw(|f| {
             render_ui(
                 f,
@@ -98,7 +104,7 @@ pub async fn run_ui() -> Result<(), Box<dyn std::error::Error>> {
                 &mut admin_state,
                 &buffer_state,
                 &theme,
-                is_edit_mode,
+                event_handler.is_edit_mode, // Use event_handler's state
                 &event_handler.highlight_state,
                 app_state.total_count,
                 app_state.current_position,
@@ -112,77 +118,108 @@ pub async fn run_ui() -> Result<(), Box<dyn std::error::Error>> {
         })?;
 
         // --- Cursor Visibility Logic ---
+        // (Keep existing cursor logic here - depends on state drawn above)
         let current_mode = ModeManager::derive_mode(&app_state, &event_handler);
         match current_mode {
-            AppMode::Edit => {
-                terminal.show_cursor()?;
-            }
-            AppMode::Highlight => {
-                terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?;
-                terminal.show_cursor()?;
-            }
+            AppMode::Edit => { terminal.show_cursor()?; }
+            AppMode::Highlight => { terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?; terminal.show_cursor()?; }
             AppMode::ReadOnly => {
-                if !app_state.ui.focus_outside_canvas {
-                    terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?;
-                } else {
-                    terminal.set_cursor_style(SetCursorStyle::SteadyUnderScore)?;
-                }
+                if !app_state.ui.focus_outside_canvas { terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?; }
+                else { terminal.set_cursor_style(SetCursorStyle::SteadyUnderScore)?; }
                 terminal.show_cursor()?;
             }
             AppMode::General => {
-                if app_state.ui.focus_outside_canvas {
-                    terminal.set_cursor_style(SetCursorStyle::SteadyUnderScore)?;
-                    terminal.show_cursor()?;
-                } else {
-                    terminal.hide_cursor()?;
-                }
-            }
-            AppMode::Command => {
-                terminal.set_cursor_style(SetCursorStyle::SteadyUnderScore)?;
-                terminal.show_cursor()?;
+                if app_state.ui.focus_outside_canvas { terminal.set_cursor_style(SetCursorStyle::SteadyUnderScore)?; terminal.show_cursor()?; }
+                else { terminal.hide_cursor()?; }
             }
+            AppMode::Command => { terminal.set_cursor_style(SetCursorStyle::SteadyUnderScore)?; terminal.show_cursor()?; }
         }
         // --- End Cursor Visibility Logic ---
 
-        let total_count = app_state.total_count; // Keep track for save logic
+        // --- 2. Check for Pending Login Action ---
+        if login_state.login_request_pending {
+            // Reset the flag *before* calling save
+            login_state.login_request_pending = false;
+
+            // Create AuthClient and call save
+            match AuthClient::new().await {
+                Ok(mut auth_client_instance) => {
+                    // Call the ORIGINAL save function from the login module
+                    let save_result = login::save(
+                        &mut auth_state,
+                        &mut login_state,
+                        &mut auth_client_instance, // Pass the new client instance
+                        &mut app_state,
+                    ).await;
+
+                    // Use tracing for logging the outcome
+                    match save_result {
+                        // save returns Result<String, Error>, Ok contains the message
+                        Ok(msg) => info!(message = %msg, "Login save result"), // Use tracing::info!
+                        Err(e) => error!(error = %e, "Error during login save"), // Use tracing::error!
+                    }
+                    // Note: save already handles showing the final dialog (success/failure)
+                }
+                Err(e) => {
+                    // Handle client connection error - show dialog directly
+                    // Ensure flag is already false here
+                    app_state.show_dialog( // Use show_dialog, not update_dialog_content
+                        "Login Failed",
+                        &format!("Connection Error: {}", e),
+                        vec!["OK".to_string()],
+                        DialogPurpose::LoginFailed, // Use appropriate purpose
+                    );
+                    login_state.error_message = Some(format!("Connection Error: {}", e));
+                    error!(error = %e, "Failed to create AuthClient"); // Use tracing::error!
+                }
+            }
+            // After save runs, the state (dialog content, etc.) is updated.
+            // The *next* iteration's draw call will show the final result.
+        } // --- End Pending Login Check ---
+
+        let total_count = app_state.total_count;
         let mut current_position = app_state.current_position;
         let position_before_event = current_position;
 
-        let event = event_reader.read_event()?;
-
-        // Get the outcome from the event handler
-        let event_outcome_result = event_handler
-            .handle_event(
-                event,
-                &config,
-                &mut terminal,
-                &mut grpc_client,
-                &mut command_handler,
-                &mut form_state,
-                &mut auth_state,
-                &mut login_state,
-                &mut register_state,
-                &mut intro_state,
-                &mut admin_state,
-                &mut buffer_state,
-                &mut app_state,
-                total_count,
-                &mut current_position,
-            )
-            .await;
+        // --- 1. Handle Terminal Events ---
+        let mut event_outcome_result = Ok(EventOutcome::Ok(String::new()));
+        // Poll for events *after* drawing and checking pending actions
+        if crossterm_event::poll(std::time::Duration::from_millis(20))? {
+            let event = event_reader.read_event()?;
+            event_outcome_result = event_handler
+                .handle_event(
+                    event,
+                    &config,
+                    &mut terminal,
+                    &mut grpc_client,
+                    &mut command_handler,
+                    &mut form_state,
+                    &mut auth_state,
+                    &mut login_state,
+                    &mut register_state,
+                    &mut intro_state,
+                    &mut admin_state,
+                    &mut buffer_state,
+                    &mut app_state,
+                    total_count,
+                    &mut current_position,
+                )
+                .await;
+        }
 
         // Update position based on handler's modification
+        // This happens *after* the event is handled
         app_state.current_position = current_position;
 
         // --- Centralized Consequence Handling ---
         let mut should_exit = false;
         match event_outcome_result {
-            // Handle the Result first
             Ok(outcome) => match outcome {
-                // Handle the Ok variant containing EventOutcome
                 EventOutcome::Ok(message) => {
                     if !message.is_empty() {
-                        event_handler.command_message = message;
+                        // Update command message only if event handling produced one
+                        // Avoid overwriting messages potentially set by pending actions
+                        // event_handler.command_message = message;
                     }
                 }
                 EventOutcome::Exit(message) => {
@@ -191,8 +228,6 @@ pub async fn run_ui() -> Result<(), Box<dyn std::error::Error>> {
                 }
                 EventOutcome::DataSaved(save_outcome, message) => {
                     event_handler.command_message = message; // Show save status
-
-                    // *** Delegate outcome handling to UiService ***
                     if let Err(e) = UiService::handle_save_outcome(
                         save_outcome,
                         &mut grpc_client,
@@ -201,30 +236,26 @@ pub async fn run_ui() -> Result<(), Box<dyn std::error::Error>> {
                     )
                     .await
                     {
-                        // Handle potential errors from the outcome handler itself
                         event_handler.command_message =
                             format!("Error handling save outcome: {}", e);
                     }
-                    // No count update needed for UpdatedExisting or NoChange
                 }
-                EventOutcome::ButtonSelected { context, index } => {
-                    event_handler.command_message = "Internal error: Unexpected button state".to_string();
+                EventOutcome::ButtonSelected { context: _, index: _ } => {
+                    // This case should ideally be fully handled within handle_event
+                    // If initiate_login was called, it returned early.
+                    // If not, the message was set and returned via Ok(message).
+                    // Log if necessary, but likely no action needed here.
+                    // log::warn!("ButtonSelected outcome reached main loop unexpectedly.");
                 }
             },
             Err(e) => {
-                // Handle errors from handle_event, e.g., log or display
                 event_handler.command_message = format!("Error: {}", e);
-                // Decide if the error is fatal, maybe set should_exit = true;
             }
-        }
+        } // --- End Consequence Handling ---
 
-        // --- Position Change Handling (after outcome processing) ---
-        let position_changed =
-            app_state.current_position != position_before_event; // Calculate after potential update
-                                                                 // Recalculate total_count *after* potential update
+        // --- Position Change Handling (after outcome processing and pending actions) ---
+        let position_changed = app_state.current_position != position_before_event;
         let current_total_count = app_state.total_count;
-
-        // Handle position changes and update form state (Only when form is shown)
         if app_state.ui.show_form {
             if position_changed && !event_handler.is_edit_mode {
                 let current_input = form_state.get_current_input();
@@ -295,7 +326,7 @@ pub async fn run_ui() -> Result<(), Box<dyn std::error::Error>> {
                     event_handler.ideal_cursor_column.min(max_cursor_pos);
             }
         } else if app_state.ui.show_register {
-            if !event_handler.is_edit_mode {
+             if !event_handler.is_edit_mode {
                 let current_input = register_state.get_current_input();
                 let max_cursor_pos = if !current_input.is_empty() {
                     current_input.len() - 1
@@ -305,7 +336,7 @@ pub async fn run_ui() -> Result<(), Box<dyn std::error::Error>> {
                 register_state.current_cursor_pos = event_handler.ideal_cursor_column.min(max_cursor_pos);
             }
         } else if app_state.ui.show_login {
-            if !event_handler.is_edit_mode {
+             if !event_handler.is_edit_mode {
                 let current_input = login_state.get_current_input();
                 let max_cursor_pos = if !current_input.is_empty() {
                     current_input.len() - 1
@@ -315,10 +346,10 @@ pub async fn run_ui() -> Result<(), Box<dyn std::error::Error>> {
                 login_state.current_cursor_pos = event_handler.ideal_cursor_column.min(max_cursor_pos);
             }
         }
+        // --- End Position Change Handling ---
 
-        // Check exit condition *after* processing outcome
+        // Check exit condition *after* all processing for the iteration
         if should_exit {
-            // terminal.cleanup()?; // Optional: Drop handles this
             return Ok(());
         }
 
@@ -329,6 +360,6 @@ pub async fn run_ui() -> Result<(), Box<dyn std::error::Error>> {
         if frame_duration.as_secs_f64() > 1e-6 {
             current_fps = 1.0 / frame_duration.as_secs_f64();
         }
-    }
+    } // End main loop
 }