`9f89f23`

grid: optimize rubber band selection, fix status bar update

- throttle render requests during drag to ~60fps
- add visible_indices cache to avoid repeated allocations
- pre-compute colors and font sizes outside render loop
- call final selection update in stop_drag before clearing state
- add select_by_path to Tab for selecting renamed files
- add lightweight status bar update for drag operations

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

SHA: 9f89f2331c86e3d06840cac90b322c731f4cebe2
Parents: cbd3758
Tree: 38726f3

4 changed files

Status	File	+	-
M	`garfield/src/app.rs`	44	27
M	`garfield/src/ui/grid_view.rs`	117	48
M	`garfield/src/ui/status_bar.rs`	5	0
M	`garfield/src/ui/tab.rs`	23	0

garfield/src/app.rsmodified

  use garfield::ui::{AddressBar, AppPickerDialog, AppPickerResult, Breadcrumb, ConfirmDialog, ConflictAction, ConflictDialog, ContextMenu, ContextMenuAction, ContextType, DialogResult, HelpModal, InputDialog, InputResult, Pane, ProgressDialog, Sidebar, StatusBar, TabBar, TabInfo, Toolbar, ToolbarAction, ViewMode, TAB_BAR_HEIGHT, TOOLBAR_HEIGHT};
  use anyhow::Result;
  use gartk_core::{InputEvent, Key, MouseButton, Point, Rect, Theme};
--use gartk_render::{Renderer, Surface, TextStyle};
++use gartk_render::{Renderer, TextStyle};
  use gartk_x11::{Connection, EventLoop, EventLoopConfig, Window, WindowConfig};
  use std::path::PathBuf;
  use std::time::Instant;
                      tab.on_click(pos, modifiers);
+                 }
+             }
++            // Update status bar with new selection
++            self.update_status_bar();
              // Capture drag source from entry at click position (for bookmark drag)
              let entry_at_click = self.focused_pane()
          self.pane_resize_path = None;
          self.sidebar_resizing = false;
++        let was_dragging = self.focused_pane().map(|p| p.is_dragging()).unwrap_or(false);
++
          if let Some(pane) = self.focused_pane_mut() {
              if pane.is_resizing() {
                  pane.stop_resize();
                  pane.stop_drag();
+             }
+         }
++
++        // Update status bar after any mouse release (ensures rubber band selection is reflected)
++        if was_dragging {
++            self.update_status_bar();
++        }
+     }
      /// Handle mouse move. Returns true if a redraw is needed.
          needs_redraw |= self.sidebar.on_mouse_move(pos);
          needs_redraw |= self.tab_bar.on_mouse_move(pos);
++        let mut is_dragging = false;
++        let mut selection_count = 0;
          if let Some(pane) = self.focused_pane_mut() {
              if let Some(tab) = pane.active_tab_mut() {
                  needs_redraw |= tab.on_mouse_move(pos);
++                is_dragging = tab.is_dragging();
++                if is_dragging {
++                    selection_count = tab.selection_count();
++                }
+             }
+         }
++        // Update status bar selection count if rubber band is active (lightweight update)
++        if is_dragging {
++            self.status_bar.update_selection_count(selection_count);
++        }
++
          needs_redraw
+     }
                      });
+                 }
                  self.status_bar.set_status_message(format!("Renamed to '{}'", new_name));
++                // Update status bar with new entry count
++                self.update_status_bar();
+             }
              Some(Err(msg)) => {
                  self.status_bar.set_status_message(format!("Rename failed: {}", msg));
      /// Blit the rendered surface to the window.
      fn blit_surface(&mut self) -> Result<()> {
          let size = self.renderer.size();
--        let conn = self.window.connection();
++        let window_id = self.window.id();
--
++        let depth = self.window.depth();
--        let ctx = self.renderer.context()?;
++        let gc = self.gc;
--        ctx.target().flush();
++        let conn = self.window.connection().clone();
--
++
--        let mut temp_surface = Surface::new(size.width, size.height)?;
++        // Access surface data directly without copying, blit to X11
--        let temp_ctx = temp_surface.context()?;
++        self.renderer.surface_mut().with_data(|data| {
--        temp_ctx.set_source_surface(self.renderer.surface().cairo_surface(), 0.0, 0.0)?;
++            let _ = conn.inner().put_image(
--        temp_ctx.paint()?;
++                ImageFormat::Z_PIXMAP,
--        drop(temp_ctx);
++                window_id,
--
++                gc,
--        let data = temp_surface.data()?;
++                size.width as u16,
--
++                size.height as u16,
--        conn.inner().put_image(
++                0,
--            ImageFormat::Z_PIXMAP,
++                0,
--            self.window.id(),
++                0,
--            self.gc,
++                depth,
--            size.width as u16,
++                data,
--            size.height as u16,
++            );
--            0,
++        })?;
--            0,
--            0,
--            self.window.depth(),
--            &data,
--        )?;
--        conn.flush()?;
++        self.window.connection().flush()?;
          Ok(())
+     }

garfield/src/ui/grid_view.rsmodified

  use gartk_core::{Color, Modifiers, Point, Rect};
  use gartk_render::{Renderer, TextAlign, TextStyle};
  use std::collections::HashSet;
++use std::time::{Duration, Instant};
  /// Padding around cells.
  pub const CELL_PADDING: u32 = 8;
  pub struct GridView {
      /// Entries to display.
      entries: Vec<FileEntry>,
++    /// Cached indices of visible entries (respecting hidden filter).
++    visible_indices: Vec<usize>,
      /// Currently focused index (for keyboard nav).
      focused: usize,
      /// Selected indices (for multi-select).
      drag_current: Option<Point>,
      /// Icon size setting.
      icon_size: IconSize,
++    /// Last time rubber band selection was updated (for throttling).
++    last_selection_update: Option<Instant>,
++    /// Last time we requested a redraw during drag (for frame rate limiting).
++    last_drag_render: Option<Instant>,
+ }
  impl GridView {
          let columns = Self::calculate_columns_for_size(bounds.width, icon_size);
          Self {
              entries: Vec::new(),
++            visible_indices: Vec::new(),
              focused: 0,
              selected: HashSet::new(),
              selection_anchor: None,
              drag_start: None,
              drag_current: None,
              icon_size,
++            last_selection_update: None,
++            last_drag_render: None,
+         }
+     }
++    /// Rebuild the visible indices cache.
++    fn rebuild_visible_cache(&mut self) {
++        self.visible_indices = self.entries
++            .iter()
++            .enumerate()
++            .filter(|(_, e)| self.show_hidden || !e.hidden)
++            .map(|(i, _)| i)
++            .collect();
++    }
++
      /// Calculate number of columns that fit in the given width for a specific icon size.
      fn calculate_columns_for_size(width: u32, icon_size: IconSize) -> usize {
          let cell_size = icon_size.cell_size();
      /// Set the entries to display.
      pub fn set_entries(&mut self, entries: Vec<FileEntry>) {
          self.entries = entries;
++        self.rebuild_visible_cache();
          self.focused = 0;
          self.selected.clear();
          self.selected.insert(0);
+     }
      /// Get visible entries (respecting hidden filter).
++    /// Uses cached indices for efficiency.
      pub fn visible_entries(&self) -> Vec<&FileEntry> {
--        self.entries
++        self.visible_indices
              .iter()
--            .filter(|e| self.show_hidden || !e.hidden)
++            .filter_map(|&i| self.entries.get(i))
              .collect()
+     }
++    /// Get visible entry count without allocation.
++    #[inline]
++    pub fn visible_count(&self) -> usize {
++        self.visible_indices.len()
++    }
++
++    /// Get entry at visible index without allocation.
++    #[inline]
++    pub fn visible_entry(&self, visible_idx: usize) -> Option<&FileEntry> {
++        self.visible_indices.get(visible_idx).and_then(|&i| self.entries.get(i))
++    }
++
      /// Get the currently focused entry.
      pub fn selected_entry(&self) -> Option<&FileEntry> {
--        let visible = self.visible_entries();
++        self.visible_entry(self.focused)
--        visible.get(self.focused).copied()
+     }
      /// Get the focused index.
      /// Get all selected entries.
      pub fn selected_entries(&self) -> Vec<&FileEntry> {
--        let visible = self.visible_entries();
          self.selected
              .iter()
--            .filter_map(|&i| visible.get(i).copied())
++            .filter_map(|&i| self.visible_entry(i))
              .collect()
+     }
      /// Toggle hidden files visibility.
      pub fn toggle_hidden(&mut self) {
          self.show_hidden = !self.show_hidden;
--        let visible_count = self.visible_entries().len();
++        self.rebuild_visible_cache();
++        let visible_count = self.visible_count();
          if self.focused >= visible_count && visible_count > 0 {
              self.focused = visible_count - 1;
+         }
      /// Move selection down (to next row).
      pub fn select_next(&mut self) {
--        let visible_count = self.visible_entries().len();
++        let visible_count = self.visible_count();
          if self.focused + self.columns < visible_count {
              self.focused += self.columns;
          } else if self.focused < visible_count.saturating_sub(1) {
      /// Move selection right.
      pub fn select_right(&mut self) {
--        let visible_count = self.visible_entries().len();
++        let visible_count = self.visible_count();
          if self.focused + 1 < visible_count {
              self.focused += 1;
              self.update_single_selection();
      /// Jump to last entry.
      pub fn select_last(&mut self) {
--        let visible_count = self.visible_entries().len();
++        let visible_count = self.visible_count();
          if visible_count > 0 {
              self.focused = visible_count - 1;
              self.update_single_selection();
      /// Page down.
      pub fn page_down(&mut self) {
--        let visible_count = self.visible_entries().len();
++        let visible_count = self.visible_count();
          let page_size = self.visible_rows() * self.columns;
          self.focused = (self.focused + page_size).min(visible_count.saturating_sub(1));
          self.update_single_selection();
      /// Select all entries (Ctrl+A).
      pub fn select_all(&mut self) {
--        let visible_count = self.visible_entries().len();
++        let visible_count = self.visible_count();
          self.selected = (0..visible_count).collect();
+     }
          // Handle rubber band drag
          if self.drag_start.is_some() {
              self.drag_current = Some(pos);
--            self.update_rubber_band_selection();
++
--            return true; // Rubber band always needs redraw
++            // Throttle both selection updates AND render requests to ~60fps
++            let should_update = match self.last_selection_update {
++                Some(last) => last.elapsed() >= Duration::from_millis(16),
++                None => true,
++            };
++
++            if should_update {
++                self.update_rubber_band_selection();
++                self.last_selection_update = Some(Instant::now());
++                self.last_drag_render = Some(Instant::now());
++                return true; // Request redraw at throttled rate
++            }
++
++            // Also limit render requests independently (in case selection didn't change)
++            let should_render = match self.last_drag_render {
++                Some(last) => last.elapsed() >= Duration::from_millis(16),
++                None => true,
++            };
++
++            if should_render {
++                self.last_drag_render = Some(Instant::now());
++                return true;
++            }
++
++            return false; // Skip redraw, we're within throttle window
+         }
          let old_hovered = self.hovered;
              return self.hovered != old_hovered;
+         }
--        let visible = self.visible_entries();
++        let visible_count = self.visible_count();
          let start_index = self.scroll_offset * self.columns;
--        let end_index = (start_index + self.visible_rows() * self.columns).min(visible.len());
++        let end_index = (start_index + self.visible_rows() * self.columns).min(visible_count);
          self.hovered = None;
          for i in start_index..end_index {
          self.drag_start = Some(pos);
          self.drag_current = Some(pos);
          self.selected.clear();
++        self.last_selection_update = None;
++        self.last_drag_render = None;
+     }
      /// Check if rubber band drag is active.
      /// Stop rubber band selection.
      pub fn stop_drag(&mut self) {
++        // Final selection update before clearing drag state
++        self.update_rubber_band_selection();
          self.drag_start = None;
          self.drag_current = None;
++        self.last_selection_update = None;
++        self.last_drag_render = None;
+     }
      /// Get the rubber band rectangle (if dragging).
      /// Update selection based on rubber band rectangle.
      fn update_rubber_band_selection(&mut self) {
          if let Some(band) = self.rubber_band_rect() {
--            let visible = self.visible_entries();
++            let visible_count = self.visible_count();
              let start_index = self.scroll_offset * self.columns;
--            let end_index = (start_index + self.visible_rows() * self.columns).min(visible.len());
++            let end_index = (start_index + self.visible_rows() * self.columns).min(visible_count);
              self.selected.clear();
              for i in start_index..end_index {
              return None;
+         }
--        let visible = self.visible_entries();
++        let visible_count = self.visible_count();
          let start_index = self.scroll_offset * self.columns;
--        let end_index = (start_index + self.visible_rows() * self.columns).min(visible.len());
++        let end_index = (start_index + self.visible_rows() * self.columns).min(visible_count);
          for i in start_index..end_index {
              if self.cell_bounds(i).contains_point(pos) {
--                return visible.get(i).copied();
++                return self.visible_entry(i);
+             }
+         }
              return None;
+         }
--        let visible = self.visible_entries();
++        let visible_count = self.visible_count();
          let start_index = self.scroll_offset * self.columns;
--        let end_index = (start_index + self.visible_rows() * self.columns).min(visible.len());
++        let end_index = (start_index + self.visible_rows() * self.columns).min(visible_count);
          for i in start_index..end_index {
              if self.cell_bounds(i).contains_point(pos) {
      /// Render the grid view.
      pub fn render(&self, renderer: &Renderer, rename_state: Option<&RenameState>) -> anyhow::Result<()> {
          let theme = renderer.theme();
--        let visible = self.visible_entries();
++        let visible_count = self.visible_count();
          let visible_rows = self.visible_rows();
          let start_index = self.scroll_offset * self.columns;
--        let end_index = (start_index + visible_rows * self.columns).min(visible.len());
++        let end_index = (start_index + visible_rows * self.columns).min(visible_count);
++
++        // Pre-compute colors to avoid parsing hex strings in the loop
++        let dir_color = Color::new(0.36, 0.62, 0.85, 1.0); // #5c9fd8
++        let symlink_color = Color::new(0.78, 0.47, 0.87, 1.0); // #c678dd
++
++        // Pre-compute icon font size
++        let icon_font_size = match self.icon_size {
++            IconSize::Small => 24.0,
++            IconSize::Medium => 32.0,
++            IconSize::Large => 48.0,
++        };
++        let name_font_size = self.icon_size.font_size();
++        let icon_size_px = self.icon_size.icon_size();
          for i in start_index..end_index {
--            let entry = visible[i];
++            let entry = match self.visible_entry(i) {
++                Some(e) => e,
++                None => continue,
++            };
              let cell = self.cell_bounds(i);
              // Skip cells outside visible area
                  theme.selection_foreground
              } else {
                  match entry.entry_type {
--                    EntryType::Directory => Color::from_hex("#5c9fd8").unwrap_or(theme.item_foreground),
++                    EntryType::Directory => dir_color,
--                    EntryType::Symlink => Color::from_hex("#c678dd").unwrap_or(theme.item_foreground),
++                    EntryType::Symlink => symlink_color,
                      _ => theme.item_foreground,
+                 }
              };
--            // Scale icon font size based on icon size setting
--            let icon_font_size = match self.icon_size {
--                IconSize::Small => 24.0,
--                IconSize::Medium => 32.0,
--                IconSize::Large => 48.0,
--            };
              let icon_style = TextStyle::new()
                  .font_family(&theme.font_family)
                  .font_size(icon_font_size)
              renderer.text_centered(icon, Point::new(icon_center_x, icon_center_y), &icon_style)?;
              // Rectangle for the text area below the icon
--            let icon_size = self.icon_size.icon_size();
              let text_rect = Rect::new(
                  cell.x + 4,
--                cell.y + icon_size as i32 + 8,
++                cell.y + icon_size_px as i32 + 8,
                  cell.width - 8,
--                cell.height - icon_size - 12,
++                cell.height - icon_size_px - 12,
              );
              if is_renaming {
                      theme.item_foreground
                  };
--                let name_font_size = self.icon_size.font_size();
++                // Use Pango CENTER alignment for proper text centering
                  let name_style = TextStyle::new()
                      .font_family(&theme.font_family)
                      .font_size(name_font_size)
--                    .color(name_color);
++                    .color(name_color)
--
--                // Use Pango CENTER alignment for proper text centering (like Dolphin/Nautilus)
--                let name_style = name_style.clone()
                      .align(TextAlign::Center)
                      .ellipsize(true)
                      .max_width((cell.width - 8) as i32);
--                // Add "@" suffix for symlinks
++                // Render text - avoid allocation for non-symlinks
--                let display_name = if entry.is_symlink {
++                if entry.is_symlink {
--                    format!("{}@", entry.name)
++                    let display_name = format!("{}@", entry.name);
++                    renderer.text_in_rect(&display_name, text_rect, &name_style)?;
                  } else {
--                    entry.name.clone()
++                    renderer.text_in_rect(&entry.name, text_rect, &name_style)?;
--                };
++                }
--                renderer.text_in_rect(&display_name, text_rect, &name_style)?;
+             }
+         }

garfield/src/ui/status_bar.rsmodified

          self.selected_size = selected_size;
+     }
++    /// Light-weight update of just the selection count (for drag operations).
++    pub fn update_selection_count(&mut self, selected_count: usize) {
++        self.selected_count = selected_count;
++    }
++
      /// Set the current view mode name.
      pub fn set_view_mode(&mut self, mode: &str) {
          self.view_mode = mode.to_string();

garfield/src/ui/tab.rsmodified

          match rename_path(&entry_path, new_name) {
              Ok(new_path) => {
                  self.refresh();
++                // Select the renamed file
++                self.select_by_path(&new_path);
                  Ok((entry_path, new_path, new_name.to_string()))
+             }
              Err(e) => Err(e.to_string()),
+         }
+     }
++    /// Select a file by its path.
++    fn select_by_path(&mut self, path: &std::path::Path) {
++        let visible = self.visible_entries();
++        for (i, entry) in visible.iter().enumerate() {
++            if entry.path == path {
++                match self.view_mode {
++                    ViewMode::List => {
++                        self.list_view.set_focused(i);
++                    }
++                    ViewMode::Grid => {
++                        self.grid_view.set_focused(i);
++                    }
++                    ViewMode::Columns => {
++                        self.column_view.set_focused(i);
++                    }
++                }
++                return;
++            }
++        }
++    }
++
      /// Handle keyboard input during rename. Returns true if handled.
      pub fn handle_rename_key(&mut self, key: &Key) -> bool {
          let state = match self.renaming.as_mut() {