perf: async preview loading and optimized mouse move redraws

Status	File	+	-
M	`garfield/src/app.rs`	58	19
M	`garfield/src/core/mod.rs`	2	0
A	`garfield/src/core/preview_loader.rs`	138	0
M	`garfield/src/ui/breadcrumb.rs`	6	3
M	`garfield/src/ui/column_view.rs`	72	10
M	`garfield/src/ui/grid_view.rs`	8	4
M	`garfield/src/ui/list_view.rs`	9	6
M	`garfield/src/ui/sidebar.rs`	7	3
M	`garfield/src/ui/tab.rs`	25	1
M	`garfield/src/ui/tab_bar.rs`	10	5
M	`garfield/src/ui/toolbar.rs`	4	2

garfield/src/app.rsmodified

  //! Application state and event loop.
  use garfield::core::{
--    Clipboard, ClipboardOperation, FileOperation, UndoStack,
++    Clipboard, ClipboardOperation, FileOperation, PreviewLoader, UndoStack,
      copy_files, move_files, delete_files, create_directory,
      trash_files, restore_from_trash,
  };
      undo_stack: UndoStack,
      /// Pending paste operation with conflicts.
      pending_paste: Option<PendingPaste>,
++    /// Async preview loader for column view.
++    preview_loader: PreviewLoader,
+ }
  /// State for a paste operation with conflicts.
              pending_delete_paths: Vec::new(),
              undo_stack: UndoStack::new(),
              pending_paste: None,
++            preview_loader: PreviewLoader::new(),
          };
          app.update_status_bar();
+                 }
                  InputEvent::MouseMove(mouse_event) => {
                      let pos = Point::new(mouse_event.position.x, mouse_event.position.y);
--                    self.handle_mouse_move(pos);
++                    if self.handle_mouse_move(pos) {
--                    ev.request_redraw();
++                        ev.request_redraw();
++                    }
+                 }
                  InputEvent::MouseLeave => {
                      self.toolbar.clear_hover();
                  _ => {}
+             }
++            // Poll for completed async preview loads
++            if let Some(result) = self.preview_loader.poll() {
++                if let Some(entries) = result.entries {
++                    if let Some(pane) = self.focused_pane_mut() {
++                        if let Some(tab) = pane.active_tab_mut() {
++                            tab.set_preview_entries(&result.path, entries);
++                        }
++                    }
++                }
++                ev.request_redraw();
++            }
++
++            // Check for pending preview requests and submit them
++            self.process_pending_previews();
++
              if ev.needs_redraw() {
                  let _ = self.render();
                  ev.redraw_done();
+         }
+     }
--    /// Handle mouse move.
++    /// Handle mouse move. Returns true if a redraw is needed.
--    fn handle_mouse_move(&mut self, pos: Point) {
++    fn handle_mouse_move(&mut self, pos: Point) -> bool {
          // Handle progress dialog hover
          if self.progress_dialog.is_visible() {
              self.progress_dialog.on_mouse_move(pos);
--            return;
++            return true; // Dialogs always redraw for responsiveness
+         }
          // Handle confirm dialog hover
          if self.confirm_dialog.is_visible() {
              self.confirm_dialog.on_mouse_move(pos);
--            return;
++            return true;
+         }
          // Handle conflict dialog hover
          if self.conflict_dialog.is_visible() {
              self.conflict_dialog.on_mouse_move(pos);
--            return;
++            return true;
+         }
          // Handle input dialog hover
          if self.input_dialog.is_visible() {
              self.input_dialog.on_mouse_move(pos);
--            return;
++            return true;
+         }
          // Handle app picker hover
          if self.app_picker.is_visible() {
              self.app_picker.on_mouse_move(pos);
--            return;
++            return true;
+         }
          // Handle context menu hover
          if self.context_menu.is_visible() {
              self.context_menu.on_mouse_move(pos);
--            return;
++            return true;
+         }
          // Handle sidebar resize in progress
              self.sidebar.set_width(new_width);
              let size = self.renderer.size();
              self.update_layout(size.width, size.height);
--            return;
++            return true;
+         }
          // Handle pane divider resize in progress
          if let Some(path) = &self.pane_resize_path {
              let path_clone = path.clone();
              self.root_pane.adjust_split_at(&path_clone, pos);
--            return;
++            return true;
+         }
          // Handle column resize/drag in progress
                  if let Some(tab) = pane.active_tab_mut() {
                      tab.on_mouse_move(pos);
+                 }
--                return;
++                return true;
+             }
+         }
++        let mut needs_redraw = false;
++
          // Handle tab reorder drag in progress
          if self.tab_bar.dragging_tab().is_some() {
              self.tab_bar.update_drag(pos);
++            needs_redraw = true;
+         }
          // Handle bookmark reorder drag in progress
          if self.sidebar.bookmark_drag_index().is_some() {
              self.sidebar.update_bookmark_drag(pos);
++            needs_redraw = true;
+         }
          // Handle bookmark drag in progress (dragging from file view)
                  let is_over_drop_zone = self.sidebar.is_bookmark_drop_zone(pos);
                  self.sidebar.set_drop_highlight(is_over_drop_zone);
+             }
++            needs_redraw = true;
+         }
--        self.toolbar.on_mouse_move(pos);
++        // Check hover states - only redraw if any changed
--        self.breadcrumb.on_mouse_move(pos);
++        needs_redraw |= self.toolbar.on_mouse_move(pos);
--        self.sidebar.on_mouse_move(pos);
++        needs_redraw |= self.breadcrumb.on_mouse_move(pos);
--        self.tab_bar.on_mouse_move(pos);
++        needs_redraw |= self.sidebar.on_mouse_move(pos);
++        needs_redraw |= self.tab_bar.on_mouse_move(pos);
          if let Some(pane) = self.focused_pane_mut() {
              if let Some(tab) = pane.active_tab_mut() {
--                tab.on_mouse_move(pos);
++                needs_redraw |= tab.on_mouse_move(pos);
+             }
+         }
++
++        needs_redraw
+     }
      /// Handle a key press.
+         }
+     }
++    /// Process pending preview requests from column views.
++    fn process_pending_previews(&mut self) {
++        // Check focused pane's active tab for pending preview
++        if let Some(pane) = self.focused_pane_mut() {
++            if let Some(tab) = pane.active_tab_mut() {
++                if let Some((path, sort_order, sort_direction)) = tab.take_pending_preview() {
++                    self.preview_loader.load(path, sort_order, sort_direction);
++                }
++            }
++        }
++    }
++
      /// Update status bar.
      fn update_status_bar(&mut self) {
          let stats = self.focused_pane()

garfield/src/core/mod.rsmodified

  pub mod entry;
  pub mod history;
  pub mod operations;
++pub mod preview_loader;
  pub mod trash;
  pub mod undo;
      copy_files, copy_path, copy_to_path, create_directory, delete_files, delete_path,
      make_unique_name, move_files, move_path, rename_path, OperationResult,
  };
++pub use preview_loader::{PreviewLoader, PreviewResult};
  pub use trash::{empty_trash, restore_from_trash, trash_file, trash_files, trash_dir};
  pub use undo::{FileOperation, UndoStack};

garfield/src/core/preview_loader.rsadded

++//! Asynchronous preview loading for directory contents.
++//!
++//! This module provides non-blocking directory loading to prevent UI lag
++//! when selecting directories with many files.
++
++use crate::core::{read_directory, sort_entries, FileEntry, SortDirection, SortOrder};
++use std::path::PathBuf;
++use std::sync::mpsc::{self, Receiver, Sender, TryRecvError};
++use std::thread::{self, JoinHandle};
++
++/// Request to load a directory preview.
++#[derive(Debug, Clone)]
++pub struct PreviewRequest {
++    /// Path to load.
++    pub path: PathBuf,
++    /// Sort order to apply.
++    pub sort_order: SortOrder,
++    /// Sort direction to apply.
++    pub sort_direction: SortDirection,
++    /// Request ID for matching responses.
++    pub request_id: u64,
++}
++
++/// Result of a preview load operation.
++#[derive(Debug)]
++pub struct PreviewResult {
++    /// Path that was loaded.
++    pub path: PathBuf,
++    /// Loaded entries (None if load failed).
++    pub entries: Option<Vec<FileEntry>>,
++    /// Request ID for matching.
++    pub request_id: u64,
++}
++
++/// Manages asynchronous preview loading with a worker thread.
++pub struct PreviewLoader {
++    /// Sender to submit load requests.
++    request_tx: Sender<PreviewRequest>,
++    /// Receiver for completed loads.
++    result_rx: Receiver<PreviewResult>,
++    /// Worker thread handle.
++    _worker: JoinHandle<()>,
++    /// Current request ID counter.
++    next_request_id: u64,
++    /// ID of the most recent request (for ignoring stale results).
++    current_request_id: u64,
++}
++
++impl PreviewLoader {
++    /// Create a new preview loader with a background worker thread.
++    pub fn new() -> Self {
++        let (request_tx, request_rx) = mpsc::channel::<PreviewRequest>();
++        let (result_tx, result_rx) = mpsc::channel::<PreviewResult>();
++
++        let worker = thread::spawn(move || {
++            Self::worker_loop(request_rx, result_tx);
++        });
++
++        Self {
++            request_tx,
++            result_rx,
++            _worker: worker,
++            next_request_id: 0,
++            current_request_id: 0,
++        }
++    }
++
++    /// Worker thread loop - processes load requests.
++    fn worker_loop(request_rx: Receiver<PreviewRequest>, result_tx: Sender<PreviewResult>) {
++        while let Ok(request) = request_rx.recv() {
++            // Load the directory
++            let entries = read_directory(&request.path).ok().map(|mut entries| {
++                sort_entries(&mut entries, request.sort_order, request.sort_direction);
++                entries
++            });
++
++            // Send result back (ignore send errors - main thread may have dropped receiver)
++            let _ = result_tx.send(PreviewResult {
++                path: request.path,
++                entries,
++                request_id: request.request_id,
++            });
++        }
++    }
++
++    /// Request loading a directory preview. Returns the request ID.
++    pub fn load(&mut self, path: PathBuf, sort_order: SortOrder, sort_direction: SortDirection) -> u64 {
++        self.next_request_id += 1;
++        self.current_request_id = self.next_request_id;
++
++        let request = PreviewRequest {
++            path,
++            sort_order,
++            sort_direction,
++            request_id: self.current_request_id,
++        };
++
++        // Ignore send errors - worker thread may have panicked
++        let _ = self.request_tx.send(request);
++
++        self.current_request_id
++    }
++
++    /// Poll for a completed preview load. Returns None if no result ready.
++    /// Only returns results for the most recent request (ignores stale results).
++    pub fn poll(&mut self) -> Option<PreviewResult> {
++        loop {
++            match self.result_rx.try_recv() {
++                Ok(result) => {
++                    // Only return if this is the current request
++                    if result.request_id == self.current_request_id {
++                        return Some(result);
++                    }
++                    // Otherwise, discard stale result and keep polling
++                }
++                Err(TryRecvError::Empty) => return None,
++                Err(TryRecvError::Disconnected) => return None,
++            }
++        }
++    }
++
++    /// Check if there's a pending load request.
++    pub fn is_loading(&self) -> bool {
++        // We're loading if we've sent a request but haven't received a matching result
++        self.current_request_id > 0
++    }
++
++    /// Cancel any pending requests by invalidating the current request ID.
++    pub fn cancel(&mut self) {
++        self.current_request_id = 0;
++    }
++}
++
++impl Default for PreviewLoader {
++    fn default() -> Self {
++        Self::new()
++    }
++}

garfield/src/ui/breadcrumb.rsmodified


         self.bounds = bounds;
     }
 
+    /// Handle mouse move for hover effects. Returns true if hover state changed.
+    pub fn on_mouse_move(&mut self, pos: Point) -> bool {
+        let old_hovered = self.hovered;
+
         if !self.bounds.contains_point(pos) {
             self.hovered = None;
+            return self.hovered != old_hovered;
         }
 
         self.hovered = self.segments.iter().position(|s| s.bounds.contains_point(pos));
+        self.hovered != old_hovered
     }
 
     /// Handle mouse click. Returns the path to navigate to, if any.

garfield/src/ui/column_view.rsmodified

      current_column: Column,
      /// Preview column (contents of selected dir or file info).
      preview_column: Option<Column>,
++    /// Path that needs preview loading (set when selection changes to a directory).
++    pending_preview_path: Option<PathBuf>,
      /// View bounds.
      bounds: Rect,
      /// Show hidden files.
              parent_column: None,
              current_column: Column::new(Vec::new(), column_bounds),
              preview_column: None,
++            pending_preview_path: None,
              bounds,
              show_hidden: false,
              sort_order: SortOrder::Name,
          self.update_preview();
+     }
--    /// Update preview column based on current selection.
++    /// Mark that preview needs to be updated based on current selection.
++    /// Does not load synchronously - call `take_pending_preview()` to get the path
++    /// that needs loading, then `set_preview_entries()` when data is ready.
      fn update_preview(&mut self) {
          let visible = self.current_column.visible_entries(self.show_hidden);
          if let Some(entry) = visible.get(self.current_column.selected).copied() {
              if entry.is_dir() {
--                let preview_x = self.current_column.bounds.x + self.current_column.bounds.width as i32;
++                // Check if we already have the correct preview loaded
--                let preview_width = self.bounds.x + self.bounds.width as i32 - preview_x;
++                let needs_load = self.pending_preview_path.as_ref() != Some(&entry.path);
--                let preview_bounds = Rect::new(preview_x, self.bounds.y, preview_width as u32, self.bounds.height);
++                if needs_load {
--
++                    self.pending_preview_path = Some(entry.path.clone());
--                let mut entries = read_directory(&entry.path).unwrap_or_default();
++                    // Clear current preview while loading
--                sort_entries(&mut entries, self.sort_order, self.sort_direction);
++                    self.preview_column = None;
--                self.preview_column = Some(Column::new(entries, preview_bounds));
++                }
              } else {
++                self.pending_preview_path = None;
                  self.preview_column = None;
+             }
          } else {
++            self.pending_preview_path = None;
              self.preview_column = None;
+         }
+     }
++    /// Get the path that needs preview loading, if any.
++    /// Returns the path and sort settings. Returns None if no preview needed.
++    pub fn take_pending_preview(&mut self) -> Option<(PathBuf, SortOrder, SortDirection)> {
++        self.pending_preview_path.take().map(|path| {
++            (path, self.sort_order, self.sort_direction)
++        })
++    }
++
++    /// Check if there's a pending preview load for a specific path.
++    pub fn has_pending_preview_for(&self, path: &PathBuf) -> bool {
++        self.pending_preview_path.as_ref() == Some(path)
++    }
++
++    /// Set preview entries from externally loaded data.
++    pub fn set_preview_entries(&mut self, path: &PathBuf, entries: Vec<FileEntry>) {
++        // Only set if this is still the path we're waiting for
++        let visible = self.current_column.visible_entries(self.show_hidden);
++        let selected_is_dir = visible
++            .get(self.current_column.selected)
++            .map(|e| e.is_dir() && &e.path == path)
++            .unwrap_or(false);
++
++        if selected_is_dir {
++            let preview_x = self.current_column.bounds.x + self.current_column.bounds.width as i32;
++            let preview_width = self.bounds.x + self.bounds.width as i32 - preview_x;
++            let preview_bounds = Rect::new(preview_x, self.bounds.y, preview_width as u32, self.bounds.height);
++            self.preview_column = Some(Column::new(entries, preview_bounds));
++        }
++        // Clear pending if this was what we were waiting for
++        if self.pending_preview_path.as_ref() == Some(path) {
++            self.pending_preview_path = None;
++        }
++    }
++
++    /// Check if preview is currently loading.
++    pub fn is_preview_loading(&self) -> bool {
++        self.pending_preview_path.is_some()
++    }
++
      /// Get visible entries in current column.
      pub fn visible_entries(&self) -> Vec<&FileEntry> {
          self.current_column.visible_entries(self.show_hidden)
          self.update_columns();
+     }
--    /// Handle mouse move for hover effects.
++    /// Handle mouse move for hover effects. Returns true if hover state changed.
--    pub fn on_mouse_move(&mut self, pos: Point) {
++    pub fn on_mouse_move(&mut self, pos: Point) -> bool {
++        let mut changed = false;
++
          // Parent column hover
          if let Some(ref mut parent) = self.parent_column {
++            let old_hovered = parent.hovered;
              parent.hovered = None;
              if parent.bounds.contains_point(pos) {
                  let visible = parent.visible_entries(self.show_hidden);
+                     }
+                 }
+             }
++            if parent.hovered != old_hovered {
++                changed = true;
++            }
+         }
          // Current column hover
++        let old_current_hovered = self.current_column.hovered;
          self.current_column.hovered = None;
          if self.current_column.bounds.contains_point(pos) {
              let visible = self.visible_entries();
+                 }
+             }
+         }
++        if self.current_column.hovered != old_current_hovered {
++            changed = true;
++        }
          // Preview column hover
          if let Some(ref mut preview) = self.preview_column {
++            let old_preview_hovered = preview.hovered;
              preview.hovered = None;
              if preview.bounds.contains_point(pos) {
                  let visible = preview.visible_entries(self.show_hidden);
+                     }
+                 }
+             }
++            if preview.hovered != old_preview_hovered {
++                changed = true;
++            }
+         }
++
++        changed
+     }
      /// Get the entry at the given position (for drag detection).

garfield/src/ui/grid_view.rsmodified

          Rect::new(x, y, cell_size, cell_size)
      }
--    /// Handle mouse move for hover effects and rubber band drag.
++    /// Handle mouse move for hover effects and rubber band drag. Returns true if state changed.
--    pub fn on_mouse_move(&mut self, pos: Point) {
++    pub fn on_mouse_move(&mut self, pos: Point) -> bool {
          // Handle rubber band drag
          if self.drag_start.is_some() {
              self.drag_current = Some(pos);
              self.update_rubber_band_selection();
--            return;
++            return true; // Rubber band always needs redraw
          }
++        let old_hovered = self.hovered;
++
          if !self.bounds.contains_point(pos) {
              self.hovered = None;
--            return;
++            return self.hovered != old_hovered;
          }
          let visible = self.visible_entries();
                  break;
              }
          }
++
++        self.hovered != old_hovered
      }
      /// Start rubber band selection.

garfield/src/ui/list_view.rsmodified

          self.resizing_column.is_some()
      }
--    /// Handle mouse move (for hover and resize).
++    /// Handle mouse move (for hover and resize). Returns true if state changed.
--    pub fn on_mouse_move(&mut self, pos: Point) {
++    pub fn on_mouse_move(&mut self, pos: Point) -> bool {
          // Handle active resize
          if let Some(divider_index) = self.resizing_column {
              let new_x = pos.x;
                  }
                  _ => {}
              }
--            return;
++            return true; // Resizing always needs redraw
          }
++        let old_hovered = self.hovered_header;
++
          if !self.bounds.contains_point(pos) {
              self.hovered_header = None;
--            return;
++            return self.hovered_header != old_hovered;
          }
          let header = self.header_bounds();
              // Check for column resize zones
              if self.divider_at(pos).is_some() {
                  self.hovered_header = None;
--                return;
++                return self.hovered_header != old_hovered;
              }
              // Check column headers for hover
              for col in [Column::Name, Column::Size, Column::Modified] {
                  if self.column_header_bounds(col).contains_point(pos) {
                      self.hovered_header = Some(col);
--                    return;
++                    return self.hovered_header != old_hovered;
                  }
              }
          }
          self.hovered_header = None;
++        self.hovered_header != old_hovered
      }
      /// Handle header click for sorting. Returns (new_order, new_direction) if sort changed.

garfield/src/ui/sidebar.rsmodified


         }
     }
 
+    /// Handle mouse move for hover effects. Returns true if hover state changed.
+    pub fn on_mouse_move(&mut self, pos: Point) -> bool {
+        let old_hovered = self.hovered;
+
         if !self.visible || !self.bounds.contains_point(pos) {
             self.hovered = None;
+            return self.hovered != old_hovered;
         }
 
         self.hovered = None;

                 }
             }
         }
+
+        self.hovered != old_hovered
     }
 
     /// Handle mouse click. Returns the path to navigate to, if any.

garfield/src/ui/tab.rsmodified

      // === Mouse handling ===
--    pub fn on_mouse_move(&mut self, pos: Point) {
++    pub fn on_mouse_move(&mut self, pos: Point) -> bool {
          match self.view_mode {
              ViewMode::List => self.list_view.on_mouse_move(pos),
              ViewMode::Grid => self.grid_view.on_mouse_move(pos),
              ViewMode::Columns => self.column_view.render(renderer),
+         }
+     }
++
++    // === Async Preview Support ===
++
++    /// Take pending preview request for column view (if in column mode).
++    /// Returns (path, sort_order, sort_direction) if a preview needs loading.
++    pub fn take_pending_preview(&mut self) -> Option<(PathBuf, SortOrder, SortDirection)> {
++        if self.view_mode == ViewMode::Columns {
++            self.column_view.take_pending_preview()
++        } else {
++            None
++        }
++    }
++
++    /// Set preview entries for column view.
++    pub fn set_preview_entries(&mut self, path: &PathBuf, entries: Vec<FileEntry>) {
++        if self.view_mode == ViewMode::Columns {
++            self.column_view.set_preview_entries(path, entries);
++        }
++    }
++
++    /// Check if preview is currently loading.
++    pub fn is_preview_loading(&self) -> bool {
++        self.view_mode == ViewMode::Columns && self.column_view.is_preview_loading()
++    }
+ }
  impl RenameState {

garfield/src/ui/tab_bar.rsmodified


         })
     }
 
+    /// Handle mouse move for hover effects. Returns true if hover state changed.
+    pub fn on_mouse_move(&mut self, pos: Point) -> bool {
+        let old_hovered_tab = self.hovered_tab;
+        let old_hovered_close = self.hovered_close;
+
         self.hovered_tab = None;
         self.hovered_close = None;
 
         if !self.bounds.contains_point(pos) {
+            return self.hovered_tab != old_hovered_tab || self.hovered_close != old_hovered_close;
         }
 
         for (i, tab_bounds) in self.tab_bounds.iter().enumerate() {

                 if let Some(close_bounds) = self.close_button_bounds(i) {
                     if close_bounds.contains_point(pos) {
                         self.hovered_close = Some(i);
+                        return self.hovered_tab != old_hovered_tab || self.hovered_close != old_hovered_close;
                     }
                 }
                 self.hovered_tab = Some(i);
+                return self.hovered_tab != old_hovered_tab || self.hovered_close != old_hovered_close;
             }
         }
+
+        self.hovered_tab != old_hovered_tab || self.hovered_close != old_hovered_close
     }
 
     /// Handle click. Returns (clicked_tab, is_close_button).

garfield/src/ui/toolbar.rsmodified


         });
     }
 
+    /// Handle mouse move. Returns true if hover state changed.
+    pub fn on_mouse_move(&mut self, pos: Point) -> bool {
+        let old_hovered = self.hovered;
         self.hovered = self.buttons.iter().position(|b| b.bounds.contains_point(pos));
+        self.hovered != old_hovered
     }
 
     /// Clear hover state.

`@@ -84,14 +84,17 @@` impl Breadcrumb {
84	self.bounds = bounds;	84	self.bounds = bounds;
85	}	85	}
86		86
87	- /// Handle mouse move for hover effects.	87	+ /// Handle mouse move for hover effects. Returns true if hover state changed.
88	- pub fn on_mouse_move(&mut self, pos: Point) {	88	+ pub fn on_mouse_move(&mut self, pos: Point) -> bool {
		89	+ let old_hovered = self.hovered;
		90	+
89	if !self.bounds.contains_point(pos) {	91	if !self.bounds.contains_point(pos) {
90	self.hovered = None;	92	self.hovered = None;
91	- return;	93	+ return self.hovered != old_hovered;
92	}	94	}
93		95
94	self.hovered = self.segments.iter().position(\|s\| s.bounds.contains_point(pos));	96	self.hovered = self.segments.iter().position(\|s\| s.bounds.contains_point(pos));
		97	+ self.hovered != old_hovered
95	}	98	}
96		99
97	/// Handle mouse click. Returns the path to navigate to, if any.	100	/// Handle mouse click. Returns the path to navigate to, if any.

`@@ -548,11 +548,13 @@` impl Sidebar {
548	}	548	}
549	}	549	}
550		550
551	- /// Handle mouse move for hover effects.	551	+ /// Handle mouse move for hover effects. Returns true if hover state changed.
552	- pub fn on_mouse_move(&mut self, pos: Point) {	552	+ pub fn on_mouse_move(&mut self, pos: Point) -> bool {
		553	+ let old_hovered = self.hovered;
		554	+
553	if !self.visible \|\| !self.bounds.contains_point(pos) {	555	if !self.visible \|\| !self.bounds.contains_point(pos) {
554	self.hovered = None;	556	self.hovered = None;
555	- return;	557	+ return self.hovered != old_hovered;
556	}	558	}
557		559
558	self.hovered = None;	560	self.hovered = None;
`@@ -564,6 +566,8 @@` impl Sidebar {
564	}	566	}
565	}	567	}
566	}	568	}
		569	+
		570	+ self.hovered != old_hovered
567	}	571	}
568		572
569	/// Handle mouse click. Returns the path to navigate to, if any.	573	/// Handle mouse click. Returns the path to navigate to, if any.

`@@ -125,13 +125,16 @@` impl TabBar {
125	})	125	})
126	}	126	}
127		127
128	- /// Handle mouse move for hover effects.	128	+ /// Handle mouse move for hover effects. Returns true if hover state changed.
129	- pub fn on_mouse_move(&mut self, pos: Point) {	129	+ pub fn on_mouse_move(&mut self, pos: Point) -> bool {
		130	+ let old_hovered_tab = self.hovered_tab;
		131	+ let old_hovered_close = self.hovered_close;
		132	+
130	self.hovered_tab = None;	133	self.hovered_tab = None;
131	self.hovered_close = None;	134	self.hovered_close = None;
132		135
133	if !self.bounds.contains_point(pos) {	136	if !self.bounds.contains_point(pos) {
134	- return;	137	+ return self.hovered_tab != old_hovered_tab \|\| self.hovered_close != old_hovered_close;
135	}	138	}
136		139
137	for (i, tab_bounds) in self.tab_bounds.iter().enumerate() {	140	for (i, tab_bounds) in self.tab_bounds.iter().enumerate() {
`@@ -140,13 +143,15 @@` impl TabBar {
140	if let Some(close_bounds) = self.close_button_bounds(i) {	143	if let Some(close_bounds) = self.close_button_bounds(i) {
141	if close_bounds.contains_point(pos) {	144	if close_bounds.contains_point(pos) {
142	self.hovered_close = Some(i);	145	self.hovered_close = Some(i);
143	- return;	146	+ return self.hovered_tab != old_hovered_tab \|\| self.hovered_close != old_hovered_close;
144	}	147	}
145	}	148	}
146	self.hovered_tab = Some(i);	149	self.hovered_tab = Some(i);
147	- return;	150	+ return self.hovered_tab != old_hovered_tab \|\| self.hovered_close != old_hovered_close;
148	}	151	}
149	}	152	}
		153	+
		154	+ self.hovered_tab != old_hovered_tab \|\| self.hovered_close != old_hovered_close
150	}	155	}
151		156
152	/// Handle click. Returns (clicked_tab, is_close_button).	157	/// Handle click. Returns (clicked_tab, is_close_button).

`@@ -199,9 +199,11 @@` impl Toolbar {
199	});	199	});
200	}	200	}
201		201
202	- /// Handle mouse move.	202	+ /// Handle mouse move. Returns true if hover state changed.
203	- pub fn on_mouse_move(&mut self, pos: Point) {	203	+ pub fn on_mouse_move(&mut self, pos: Point) -> bool {
		204	+ let old_hovered = self.hovered;
204	self.hovered = self.buttons.iter().position(\|b\| b.bounds.contains_point(pos));	205	self.hovered = self.buttons.iter().position(\|b\| b.bounds.contains_point(pos));
		206	+ self.hovered != old_hovered
205	}	207	}
206		208
207	/// Clear hover state.	209	/// Clear hover state.

gardesk/garfield / `4a37cd0`

11 changed files