`f49b5d3`

feat: implement focus-based input routing system

Add active window focus system where keyboard input is routed to the
last-activated component instead of using fixed priority.

Changes:
- Add Focus enum (Editor, Terminal, FussMode, ServerManager, Prompt)
- Add HitRegion enum for mouse hit testing
- Add focus field to Editor struct
- Implement hit_test() to determine clicked region
- Implement return_focus() helper for closing components
- Add click-to-focus in mouse handler
- Update toggle handlers to set focus when opening/closing
- Refactor keyboard routing from priority-based to focus-based

Behavior:
- Clicking any component gives it keyboard focus
- Keyboard shortcuts that open components also focus them
- Clicking in split panes makes that pane active
- ESC closes focused component and returns focus sensibly

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 4 months ago

SHA: f49b5d34131913c070f6df62fcdccc339fcc2cb5
Parents: 9905b80
Tree: 0268e1d

1 changed file

Status	File	+	-
M	`src/editor/state.rs`	155	33

src/editor/state.rsmodified

      },
+ }
++/// Which UI component currently has keyboard focus
++#[derive(Debug, Clone, Copy, PartialEq, Eq)]
++pub enum Focus {
++    /// Main editor panes
++    Editor,
++    /// Integrated terminal panel
++    Terminal,
++    /// Fuss mode file tree sidebar
++    FussMode,
++    /// LSP server manager panel
++    ServerManager,
++    /// Active prompt/modal (prompts are exclusive by nature)
++    Prompt,
++}
++
++/// Hit test result for determining which region was clicked
++#[derive(Debug, Clone, Copy)]
++enum HitRegion {
++    /// Editor pane (with index for split panes)
++    Editor { pane_index: usize },
++    /// Terminal panel
++    Terminal,
++    /// Fuss mode sidebar
++    FussMode,
++    /// Server manager panel
++    ServerManager,
++    /// Prompt/modal area
++    Prompt,
++    /// Outside any interactive region
++    None,
++}
++
  /// A single result from multi-file search
  #[derive(Debug, Clone, PartialEq)]
  struct FileSearchResult {
      terminal_resize_start_y: u16,
      /// Terminal resize: starting height when drag began
      terminal_resize_start_height: u16,
++    /// Current keyboard focus target
++    focus: Focus,
+ }
  impl Editor {
              terminal_resize_dragging: false,
              terminal_resize_start_y: 0,
              terminal_resize_start_height: 0,
++            focus: Focus::Editor,
          };
          // If there are backups, show restore prompt
      fn toggle_server_manager(&mut self) {
          if self.server_manager.visible {
              self.server_manager.hide();
++            self.return_focus();
          } else {
              self.server_manager.show();
++            self.focus = Focus::ServerManager;
+         }
+     }
          // Alt+M toggles the panel closed
          if key == Key::Char('m') && mods.alt {
              self.server_manager.hide();
++            self.return_focus();
              return Ok(());
+         }
+         {
              let _ = self.terminal.toggle();
              self.terminal_resize_dragging = false;
++            // Set focus when opening, return focus when closing
++            if self.terminal.visible {
++                self.focus = Focus::Terminal;
++            } else {
++                self.return_focus();
++            }
              return Ok(());
+         }
--        // If terminal is visible, route input to terminal
++        // Focus-based routing for terminal
--        if self.terminal.visible {
++        if self.focus == Focus::Terminal && self.terminal.visible {
--            // ESC hides terminal
++            // ESC hides terminal and returns focus
              if key_event.code == KeyCode::Esc {
                  self.terminal.hide();
                  self.terminal_resize_dragging = false;
++                self.return_focus();
                  return Ok(());
+             }
                          if self.terminal.close_active_session() {
                              self.terminal.hide();
                              self.terminal_resize_dragging = false;
++                            self.return_focus();
+                         }
                          return Ok(());
+                     }
                  || (key_event.code == KeyCode::Char('b')
                      && key_event.modifiers.contains(KeyModifiers::CONTROL))
+             {
--                self.workspace.fuss.toggle();
++                self.toggle_fuss_mode();
                  return Ok(());
+             }
          Ok(())
+     }
++    /// Hit test to determine which UI region contains a screen coordinate
++    fn hit_test(&self, col: u16, row: u16) -> HitRegion {
++        // Check prompt/modal first (overlays everything)
++        // Prompts take up various areas but for click purposes we consider them focused
++        if self.prompt != PromptState::None {
++            return HitRegion::Prompt;
++        }
++
++        // Check server manager panel (right side overlay)
++        if self.server_manager.visible {
++            let panel_width = 50.min(self.screen.cols / 2);
++            let panel_start_col = self.screen.cols.saturating_sub(panel_width);
++            if col >= panel_start_col {
++                return HitRegion::ServerManager;
++            }
++        }
++
++        // Check terminal (bottom region)
++        if self.terminal.visible {
++            let terminal_start_row = self.terminal.render_start_row(self.screen.rows);
++            if row >= terminal_start_row {
++                // Terminal shrinks when fuss mode is active
++                let fuss_width = if self.workspace.fuss.active {
++                    self.workspace.fuss.width(self.screen.cols)
++                } else {
++                    0
++                };
++                if col >= fuss_width {
++                    return HitRegion::Terminal;
++                }
++            }
++        }
++
++        // Check fuss sidebar (left side)
++        if self.workspace.fuss.active {
++            let fuss_width = self.workspace.fuss.width(self.screen.cols);
++            if col < fuss_width {
++                return HitRegion::FussMode;
++            }
++        }
++
++        // Otherwise it's the editor - determine which pane
++        let pane_index = self.workspace.pane_at_position(col, row, self.screen.cols, self.screen.rows);
++        HitRegion::Editor { pane_index }
++    }
++
++    /// Return focus to a sensible default after closing a component
++    fn return_focus(&mut self) {
++        // Return focus to the most recently visible component, defaulting to editor
++        self.focus = Focus::Editor;
++    }
++
      /// Handle mouse input
      fn handle_mouse(&mut self, mouse: Mouse) -> Result<()> {
          // Calculate offsets for fuss mode and tab bar
          };
          let text_start_col = left_offset + line_num_width + 1;
++        // Click-to-focus: determine which region was clicked and set focus
++        if let Mouse::Click { col, row, .. } = mouse {
++            let region = self.hit_test(col, row);
++            match region {
++                HitRegion::Terminal => {
++                    self.focus = Focus::Terminal;
++                }
++                HitRegion::FussMode => {
++                    self.focus = Focus::FussMode;
++                }
++                HitRegion::Editor { pane_index } => {
++                    self.focus = Focus::Editor;
++                    // Also set the active pane when clicking in editor area
++                    self.workspace.tabs[self.workspace.active_tab].active_pane = pane_index;
++                }
++                HitRegion::ServerManager => {
++                    self.focus = Focus::ServerManager;
++                }
++                HitRegion::Prompt => {
++                    self.focus = Focus::Prompt;
++                }
++                HitRegion::None => {}
++            }
++        }
++
          // Handle terminal resize dragging
          if self.terminal.visible {
              let title_row = self.screen.rows.saturating_sub(self.terminal.height);
          };
--        // Render fuss mode sidebar if active
++        // Update fuss mode viewport (actual rendering happens after terminal)
          if self.workspace.fuss.active {
--            // When terminal is visible, fuss mode should only render above it
++            let visible_rows = self.screen.rows.saturating_sub(2) as usize;
--            let max_fuss_rows = if self.terminal.visible {
--                Some(self.terminal.render_start_row(self.screen.rows))
--            } else {
--                None
--            };
--            let visible_rows = max_fuss_rows.unwrap_or(self.screen.rows).saturating_sub(2) as usize;
              self.workspace.fuss.update_viewport(visible_rows);
--
--            if let Some(ref tree) = self.workspace.fuss.tree {
--                let repo_name = self.workspace.repo_name();
--                let branch = self.workspace.git_branch();
--                self.screen.render_fuss(
--                    tree.visible_items(),
--                    self.workspace.fuss.selected,
--                    self.workspace.fuss.scroll,
--                    fuss_width,
--                    self.workspace.fuss.hints_expanded,
--                    &repo_name,
--                    branch.as_deref(),
--                    self.workspace.fuss.git_mode,
--                    max_fuss_rows,
--                )?;
--            }
+         }
          // Build tab info for tab bar
                  self.screen.render_terminal(&self.terminal, fuss_width)?;
+             }
++            // Render fuss mode sidebar if active (after terminal so it paints on top)
++            if self.workspace.fuss.active {
++                if let Some(ref tree) = self.workspace.fuss.tree {
++                    let repo_name = self.workspace.repo_name();
++                    let branch = self.workspace.git_branch();
++                    self.screen.render_fuss(
++                        tree.visible_items(),
++                        self.workspace.fuss.selected,
++                        self.workspace.fuss.scroll,
++                        fuss_width,
++                        self.workspace.fuss.hints_expanded,
++                        &repo_name,
++                        branch.as_deref(),
++                        self.workspace.fuss.git_mode,
++                    )?;
++                }
++            }
++
              // Render rename modal if active
              if let PromptState::RenameModal { ref original_name, ref new_name, .. } = self.prompt {
                  self.screen.render_rename_modal(original_name, new_name)?;
              return self.handle_prompt_key(key);
+         }
--        // Handle server manager panel when visible
++        // Focus-based routing for server manager
--        if self.server_manager.visible {
++        if self.focus == Focus::ServerManager && self.server_manager.visible {
              return self.handle_server_manager_key(key, mods);
+         }
          // Clear message on any key
          self.message = None;
--        // Toggle fuss mode: Ctrl+B or F3 (works in both modes)
++        // Toggle fuss mode: Ctrl+B or F3 (global shortcut that sets focus)
          if matches!((&key, &mods), (Key::Char('b'), Modifiers { ctrl: true, .. }) | (Key::F(3), _)) {
              self.toggle_fuss_mode();
              return Ok(());
+         }
--        // Route to fuss mode handler if active
++        // Focus-based routing for fuss mode
--        if self.workspace.fuss.active {
++        if self.focus == Focus::FussMode && self.workspace.fuss.active {
              return self.handle_fuss_key(key, mods);
+         }
      fn toggle_fuss_mode(&mut self) {
          if !self.workspace.fuss.active {
              self.workspace.fuss.activate(&self.workspace.root);
++            self.focus = Focus::FussMode;
          } else {
              self.workspace.fuss.deactivate();
++            self.return_focus();
+         }
+     }
              (Key::Escape, _) | (Key::F(3), _) => {
                  self.workspace.fuss.filter_clear();
                  self.workspace.fuss.deactivate();
++                self.return_focus();
+             }
              // Navigation