`0c9f13c`

fix: use absolute row coordinates for selection to handle scrollback correctly

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

SHA: 0c9f13c7a3cf36f4709fd980fdfdb34c97c15e35
Parents: 80a593e
Tree: 3d3f0f1

3 changed files

Status	File	+	-
M	`garterm/src/app.rs`	38	6
M	`garterm/src/input/selection.rs`	6	5
M	`garterm/src/terminal/grid.rs`	13	2

garterm/src/app.rsmodified

          if bounds.0.row == bounds.1.row && bounds.0.col == bounds.1.col {
              return None;
+         }
++
 +        // Convert absolute rows to visible rows for rendering
 +        // Selection stores absolute rows, but renderer uses viewport-relative rows
 +        let pane = self.tabs.focused_pane()?;
 +        let grid = pane.terminal.grid();
++
 +        // Convert absolute rows to visible, skip if not in viewport
 +        let start_visible = grid.absolute_row_to_visible(bounds.0.row);
 +        let end_visible = grid.absolute_row_to_visible(bounds.1.row);
++
 +        // At least part of selection must be visible
 +        let start_row = start_visible.unwrap_or(0);
 +        let end_row = end_visible.unwrap_or(pane.terminal.rows().saturating_sub(1));
++
 +        // If both are None and not overlapping viewport, skip
 +        if start_visible.is_none() && end_visible.is_none() {
 +            // Check if selection spans the viewport
 +            let scrollback_len = grid.scrollback_len();
 +            let scroll_offset = grid.scroll_offset();
 +            let viewport_start = scrollback_len.saturating_sub(scroll_offset);
 +            let viewport_end = viewport_start + pane.terminal.rows();
 +            if bounds.1.row < viewport_start || bounds.0.row >= viewport_end {
 +                return None;
 +            }
 +        }
++
          Some(SelectionBounds {
 -            start_row: bounds.0.row,
 +            start_row,
              start_col: bounds.0.col,
 -            end_row: bounds.1.row,
 +            end_row,
              end_col: bounds.1.col,
              is_block: matches!(self.selection.mode(), SelectionMode::Block),
          })
                  self.last_click = now;
                  if let Some(pane) = self.tabs.focused_pane() {
 +                    // Convert viewport row to absolute row (accounts for scrollback)
 +                    let abs_row = pane.terminal.grid().visible_row_to_absolute(row);
                      match self.click_count {
 => {
                              // Single click: clear any existing selection, prepare for potential drag
                              } else {
                                  SelectionMode::Normal
                              };
 -                            self.selection.start(row, col, mode);
 +                            self.selection.start(abs_row, col, mode);
+                         }
 => {
 -                            self.selection.select_word(row, col, pane.terminal.grid(), pane.terminal.cols());
 +                            self.selection.select_word(abs_row, col, pane.terminal.grid(), pane.terminal.cols());
+                         }
                          _ => {
 -                            self.selection.select_line(row, pane.terminal.cols());
 +                            self.selection.select_line(abs_row, pane.terminal.cols());
+                         }
+                     }
+                 }
          // Update selection during drag
          if self.selection.is_active() && state & 0x100 != 0 {
 -            self.selection.update(row, col);
 +            if let Some(pane) = self.tabs.focused_pane() {
 +                // Convert viewport row to absolute row
 +                let abs_row = pane.terminal.grid().visible_row_to_absolute(row);
 +                self.selection.update(abs_row, col);
 +            }
              if let Some(pane) = self.tabs.focused_pane_mut() {
                  pane.mark_dirty();
+             }

garterm/src/input/selection.rsmodified

          match self.mode {
              SelectionMode::Normal => {
                  for row in start.row..=end.row {
 -                    if let Some(line) = grid.line(row) {
 +                    // Use line_absolute to access scrollback + active lines
 +                    if let Some(line) = grid.line_absolute(row) {
                          let start_col = if row == start.row { start.col } else { 0 };
                          let end_col = if row == end.row { end.col } else { cols - 1 };
+             }
              SelectionMode::Line => {
                  for row in start.row..=end.row {
 -                    if let Some(line) = grid.line(row) {
 +                    if let Some(line) = grid.line_absolute(row) {
                          // Find last non-space character
                          let mut last_non_space = 0;
                          for col in 0..cols {
                  };
                  for row in start.row..=end.row {
 -                    if let Some(line) = grid.line(row) {
 +                    if let Some(line) = grid.line_absolute(row) {
                          for col in min_col..=max_col.min(cols - 1) {
                              let c = line[col].c;
                              if c != '\0' {
              .join("\n")
+     }
 -    /// Expand selection to word boundaries
 +    /// Expand selection to word boundaries (row is absolute)
      pub fn select_word(&mut self, row: usize, col: usize, grid: &Grid, cols: usize) {
 -        let Some(line) = grid.line(row) else {
 +        let Some(line) = grid.line_absolute(row) else {
              return;
          };

garterm/src/terminal/grid.rsmodified

          })
+     }
 -    /// Get a line reference
 +    /// Get a line reference (active grid only)
      pub fn line(&self, row: usize) -> Option<&Line> {
          self.lines.get(row)
+     }
 -    /// Get a mutable line reference
 +    /// Get a mutable line reference (active grid only)
      pub fn line_mut(&mut self, row: usize) -> Option<&mut Line> {
          self.lines.get_mut(row)
+     }
 +    /// Get a line by absolute row number (scrollback + active)
 +    /// Row 0 is the first line of scrollback, scrollback.len() is the first active line
 +    pub fn line_absolute(&self, abs_row: usize) -> Option<&Line> {
 +        let scrollback_len = self.scrollback.len();
 +        if abs_row < scrollback_len {
 +            self.scrollback.get(abs_row)
 +        } else {
 +            self.lines.get(abs_row - scrollback_len)
 +        }
 +    }
++
      /// Scroll the grid up by n lines within a scroll region
      /// Lines scrolled out of the top go to scrollback
      pub fn scroll_up(&mut self, n: usize, top: usize, bottom: usize) {