`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 ctx = self.renderer.context()?;
 -        ctx.target().flush();
+-
 -        let mut temp_surface = Surface::new(size.width, size.height)?;
 -        let temp_ctx = temp_surface.context()?;
 -        temp_ctx.set_source_surface(self.renderer.surface().cairo_surface(), 0.0, 0.0)?;
 -        temp_ctx.paint()?;
 -        drop(temp_ctx);
+-
 -        let data = temp_surface.data()?;
+-
 -        conn.inner().put_image(
 -            ImageFormat::Z_PIXMAP,
 -            self.window.id(),
 -            self.gc,
 -            size.width as u16,
 -            size.height as u16,
 -            0,
 -            0,
 -            0,
 -            self.window.depth(),
 -            &data,
 -        )?;
 +        let window_id = self.window.id();
 +        let depth = self.window.depth();
 +        let gc = self.gc;
 +        let conn = self.window.connection().clone();
++
 +        // Access surface data directly without copying, blit to X11
 +        self.renderer.surface_mut().with_data(|data| {
 +            let _ = conn.inner().put_image(
 +                ImageFormat::Z_PIXMAP,
 +                window_id,
 +                gc,
 +                size.width as u16,
 +                size.height as u16,
 +                0,
 +                0,
 +                0,
 +                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();
 -        visible.get(self.focused).copied()
 +        self.visible_entry(self.focused)
+     }
      /// 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::Symlink => Color::from_hex("#c678dd").unwrap_or(theme.item_foreground),
 +                    EntryType::Directory => dir_color,
 +                    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);
+-
 -                // Use Pango CENTER alignment for proper text centering (like Dolphin/Nautilus)
 -                let name_style = name_style.clone()
 +                    .color(name_color)
                      .align(TextAlign::Center)
                      .ellipsize(true)
                      .max_width((cell.width - 8) as i32);
 -                // Add "@" suffix for symlinks
 -                let display_name = if entry.is_symlink {
 -                    format!("{}@", entry.name)
 +                // Render text - avoid allocation for non-symlinks
 +                if entry.is_symlink {
 +                    let display_name = format!("{}@", entry.name);
 +                    renderer.text_in_rect(&display_name, text_rect, &name_style)?;
                  } else {
 -                    entry.name.clone()
 -                };
 -                renderer.text_in_rect(&display_name, text_rect, &name_style)?;
 +                    renderer.text_in_rect(&entry.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() {