needs improvements but at least it looks like it exists

client/src/state/pages/add_table.rs

@@ -1,4 +1,5 @@
 // src/state/pages/add_table.rs
+use crate::state::pages::canvas_state::CanvasState;
 use ratatui::widgets::TableState;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -16,11 +17,10 @@ pub struct LinkDefinition {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub enum AddTableFocus {
     #[default]
-    TableName,
-    // Input areas (placeholders for now)
-    ColumnInput,
-    IndexInput,
-    LinkInput,
+    InputTableName, // Field 0 for CanvasState
+    InputColumnName, // Field 1 for CanvasState
+    InputColumnType, // Field 2 for CanvasState
+    AddColumnButton,
     // Result Tables
     ColumnsTable,
     IndexesTable,
@@ -34,6 +34,8 @@ pub enum AddTableFocus {
 pub struct AddTableState {
     pub profile_name: String,
     pub table_name: String,
+    pub column_name_input: String,
+    pub column_type_input: String,
     pub columns: Vec<ColumnDefinition>,
     pub indexes: Vec<String>,
     pub links: Vec<LinkDefinition>,
@@ -42,6 +44,9 @@ pub struct AddTableState {
     pub index_table_state: TableState,
     pub link_table_state: TableState,
     pub table_name_cursor_pos: usize,
+    pub column_name_cursor_pos: usize,
+    pub column_type_cursor_pos: usize,
+    pub has_unsaved_changes: bool,
 }
 
 impl Default for AddTableState {
@@ -49,7 +54,9 @@ impl Default for AddTableState {
         // Initialize with some dummy data for demonstration
         AddTableState {
             profile_name: "default".to_string(), // Should be set dynamically
-            table_name: "new_table".to_string(),
+            table_name: String::new(), // Start empty
+            column_name_input: String::new(),
+            column_type_input: String::new(),
             columns: vec![
                 ColumnDefinition { name: "id".to_string(), data_type: "INTEGER".to_string() },
                 ColumnDefinition { name: "name".to_string(), data_type: "TEXT".to_string() },
@@ -59,16 +66,107 @@ impl Default for AddTableState {
                 LinkDefinition { linked_table_name: "related_table".to_string(), is_required: true },
                 LinkDefinition { linked_table_name: "another_table".to_string(), is_required: false },
             ],
-            current_focus: AddTableFocus::TableName,
+            current_focus: AddTableFocus::InputTableName,
             column_table_state: TableState::default().with_selected(0),
             index_table_state: TableState::default().with_selected(0),
             link_table_state: TableState::default().with_selected(0),
             table_name_cursor_pos: 0,
+            column_name_cursor_pos: 0,
+            column_type_cursor_pos: 0,
+            has_unsaved_changes: false,
         }
     }
 }
 
 impl AddTableState {
+    const INPUT_FIELD_COUNT: usize = 3;
 }
 
+// Implement CanvasState for the input fields
+impl CanvasState for AddTableState {
+    fn current_field(&self) -> usize {
+        match self.current_focus {
+            AddTableFocus::InputTableName => 0,
+            AddTableFocus::InputColumnName => 1,
+            AddTableFocus::InputColumnType => 2,
+            // If focus is elsewhere, default to the first field for canvas rendering logic
+            _ => 0,
+        }
+    }
+
+    fn current_cursor_pos(&self) -> usize {
+        match self.current_focus {
+            AddTableFocus::InputTableName => self.table_name_cursor_pos,
+            AddTableFocus::InputColumnName => self.column_name_cursor_pos,
+            AddTableFocus::InputColumnType => self.column_type_cursor_pos,
+            _ => 0, // Default if focus is not on an input field
+        }
+    }
+
+    fn has_unsaved_changes(&self) -> bool {
+        self.has_unsaved_changes
+    }
+
+    fn inputs(&self) -> Vec<&String> {
+        vec![&self.table_name, &self.column_name_input, &self.column_type_input]
+    }
+
+    fn get_current_input(&self) -> &str {
+        match self.current_focus {
+            AddTableFocus::InputTableName => &self.table_name,
+            AddTableFocus::InputColumnName => &self.column_name_input,
+            AddTableFocus::InputColumnType => &self.column_type_input,
+            _ => "", // Should not happen if called correctly
+        }
+    }
+
+    fn get_current_input_mut(&mut self) -> &mut String {
+        match self.current_focus {
+            AddTableFocus::InputTableName => &mut self.table_name,
+            AddTableFocus::InputColumnName => &mut self.column_name_input,
+            AddTableFocus::InputColumnType => &mut self.column_type_input,
+            // This case needs careful handling. If focus isn't on an input,
+            // which mutable string should we return? Returning the first one
+            // might be unexpected. Consider panicking or returning Option if this state is invalid.
+            // For now, returning the first field to avoid panics during rendering.
+            _ => &mut self.table_name,
+        }
+    }
+
+    fn fields(&self) -> Vec<&str> {
+        // These must match the order used in render_add_table
+        vec!["Table name", "Name", "Type"]
+    }
+
+    fn set_current_field(&mut self, index: usize) {
+        self.current_focus = match index {
+            0 => AddTableFocus::InputTableName,
+            1 => AddTableFocus::InputColumnName,
+            2 => AddTableFocus::InputColumnType,
+            _ => self.current_focus, // Stay on current focus if index is out of bounds
+        };
+    }
+
+    fn set_current_cursor_pos(&mut self, pos: usize) {
+        match self.current_focus {
+            AddTableFocus::InputTableName => self.table_name_cursor_pos = pos,
+            AddTableFocus::InputColumnName => self.column_name_cursor_pos = pos,
+            AddTableFocus::InputColumnType => self.column_type_cursor_pos = pos,
+            _ => {} // Do nothing if focus is not on an input field
+        }
+    }
+
+    fn set_has_unsaved_changes(&mut self, changed: bool) {
+        self.has_unsaved_changes = changed;
+    }
+
+    // --- Autocomplete Support (Not needed for this form yet) ---
+    fn get_suggestions(&self) -> Option<&[String]> {
+        None
+    }
+
+    fn get_selected_suggestion_index(&self) -> Option<usize> {
+        None
+    }
+}