Multi-column support

src/app.rs

@@ -146,8 +146,8 @@ impl App {
                 (KeyCode::Char('q'), _) => return Ok(true),
                 (KeyCode::Char('j'), _) | (KeyCode::Down, _) => self.move_selection(1),
                 (KeyCode::Char('k'), _) | (KeyCode::Up, _) => self.move_selection(-1),
-                (KeyCode::Char('h'), _) | (KeyCode::Left, _) => self.change_pane(-1),
-                (KeyCode::Char('l'), _) | (KeyCode::Right, _) => self.change_pane(1),
+                (KeyCode::Char('h'), _) | (KeyCode::Left, _) => self.move_column(-1),
+                (KeyCode::Char('l'), _) | (KeyCode::Right, _) => self.move_column(1),
                 (KeyCode::Char('n'), KeyModifiers::CONTROL) => self.change_pane(1),
                 (KeyCode::Char('p'), KeyModifiers::CONTROL) => self.change_pane(-1),
                 (KeyCode::Enter, _) => self.toggle_current_item()?,
@@ -1085,24 +1085,136 @@ impl App {
     }
 
     fn move_selection(&mut self, delta: i32) {
-        let items_len = match self.state.current_pane {
-            0 => self.state.permanent_items.len(),
-            1 => self.state.recurring_items.len(),
-            2 => self.state.recent_items.len(),
+        let items = match self.state.current_pane {
+            0 => &self.state.permanent_items,
+            1 => &self.state.recurring_items,
+            2 => &self.state.recent_items,
             _ => return,
         };
 
-        if items_len == 0 {
+        if items.is_empty() {
             return;
         }
 
         let current = self.state.selected_indices[self.state.current_pane] as i32;
-        let new_index = (current + delta).rem_euclid(items_len as i32) as usize;
-        self.state.selected_indices[self.state.current_pane] = new_index;
+        let items_len = items.len() as i32;
+        
+        // Check if we're using two-column mode
+        let use_two_columns = self.config.multi_column && items.len() > 6;
+        
+        if use_two_columns {
+            let mid_point = (items.len() + 1) / 2;
+            let (col_start, col_end) = if self.state.current_column == 0 {
+                (0, mid_point as i32 - 1)
+            } else {
+                (mid_point as i32, items_len - 1)
+            };
+            
+            let new_index = current + delta;
+            
+            if new_index < col_start && delta < 0 {
+                // Moving up beyond column - go to previous pane
+                self.change_pane(-1);
+                let new_items = match self.state.current_pane {
+                    0 => &self.state.permanent_items,
+                    1 => &self.state.recurring_items,
+                    2 => &self.state.recent_items,
+                    _ => return,
+                };
+                if !new_items.is_empty() {
+                    self.state.selected_indices[self.state.current_pane] = new_items.len() - 1;
+                    // Stay in right column if new pane has enough items
+                    if self.config.multi_column && new_items.len() > 6 {
+                        self.state.current_column = 1;
+                    } else {
+                        self.state.current_column = 0;
+                    }
+                }
+            } else if new_index > col_end && delta > 0 {
+                // Moving down beyond column - go to next pane
+                self.change_pane(1);
+                self.state.selected_indices[self.state.current_pane] = 0;
+                self.state.current_column = 0;
+            } else {
+                // Normal movement within column
+                self.state.selected_indices[self.state.current_pane] = 
+                    new_index.clamp(col_start, col_end) as usize;
+            }
+        } else {
+            // Single column mode
+            let new_index = current + delta;
+            
+            if new_index < 0 && delta < 0 {
+                // At top, move to previous pane
+                self.change_pane(-1);
+                let new_items = match self.state.current_pane {
+                    0 => &self.state.permanent_items,
+                    1 => &self.state.recurring_items,
+                    2 => &self.state.recent_items,
+                    _ => return,
+                };
+                if !new_items.is_empty() {
+                    self.state.selected_indices[self.state.current_pane] = new_items.len() - 1;
+                }
+            } else if new_index >= items_len && delta > 0 {
+                // At bottom, move to next pane
+                self.change_pane(1);
+                self.state.selected_indices[self.state.current_pane] = 0;
+            } else {
+                // Normal movement within pane
+                self.state.selected_indices[self.state.current_pane] = 
+                    new_index.clamp(0, items_len - 1) as usize;
+            }
+        }
     }
-
+    
+    fn move_column(&mut self, delta: i32) {
+        if !self.config.multi_column {
+            return;
+        }
+        
+        let items = match self.state.current_pane {
+            0 => &self.state.permanent_items,
+            1 => &self.state.recurring_items,
+            2 => &self.state.recent_items,
+            _ => return,
+        };
+        
+        // Only switch columns if we have enough items for two columns
+        if items.len() <= 6 {
+            return;
+        }
+        
+        let mid_point = (items.len() + 1) / 2;
+        let new_column = if delta > 0 { 1 } else { 0 };
+        
+        if new_column != self.state.current_column {
+            let current_selected = self.state.selected_indices[self.state.current_pane];
+            
+            // Calculate which row we're on in the current column
+            let current_row = if self.state.current_column == 0 {
+                current_selected  // In left column
+            } else {
+                current_selected.saturating_sub(mid_point)  // In right column
+            };
+            
+            // Switch column and jump to the same row in the new column
+            self.state.current_column = new_column;
+            
+            if new_column == 0 {
+                // Moving to left column - jump to same row
+                self.state.selected_indices[self.state.current_pane] = current_row.min(mid_point - 1);
+            } else {
+                // Moving to right column - jump to same row
+                let right_items_len = items.len() - mid_point;
+                self.state.selected_indices[self.state.current_pane] = (mid_point + current_row).min(items.len() - 1).min(mid_point + right_items_len - 1);
+            }
+        }
+    }
+    
     fn change_pane(&mut self, delta: i32) {
         self.state.current_pane = ((self.state.current_pane as i32 + delta).rem_euclid(3)) as usize;
+        self.state.current_column = 0;
     }
 
     fn get_current_item(&self) -> Option<TimeItem> {