gardesk/garfield / ef80a58

+[[package]]

+name = "adler2"

+version = "2.0.1"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"

+

+[[package]]

+name = "bytemuck"

+version = "1.24.0"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "1fbdf580320f38b612e485521afda1ee26d10cc9884efaaa750d383e13e3c5f4"

+

+[[package]]

+name = "byteorder-lite"

+version = "0.1.0"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"

+

+[[package]]

+name = "color_quant"

+version = "1.1.0"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"

+

+[[package]]

+name = "crc32fast"

+version = "1.5.0"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"

+dependencies = [

+ "cfg-if",

+]

+

+[[package]]

+name = "fdeflate"

+version = "0.3.7"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"

+dependencies = [

+ "simd-adler32",

+]

+

+[[package]]

+name = "flate2"

+version = "1.1.8"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "b375d6465b98090a5f25b1c7703f3859783755aa9a80433b36e0379a3ec2f369"

+dependencies = [

+ "crc32fast",

+ "miniz_oxide",

+]

+

+ "image",

+[[package]]

+name = "gif"

+version = "0.14.1"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "f5df2ba84018d80c213569363bdcd0c64e6933c67fe4c1d60ecf822971a3c35e"

+dependencies = [

+ "color_quant",

+ "weezl",

+]

+

+[[package]]

+name = "image"

+version = "0.25.9"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "e6506c6c10786659413faa717ceebcb8f70731c0a60cbae39795fdf114519c1a"

+dependencies = [

+ "bytemuck",

+ "byteorder-lite",

+ "color_quant",

+ "gif",

+ "image-webp",

+ "moxcms",

+ "num-traits",

+ "png",

+ "zune-core",

+ "zune-jpeg",

+]

+

+[[package]]

+name = "image-webp"

+version = "0.2.4"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "525e9ff3e1a4be2fbea1fdf0e98686a6d98b4d8f937e1bf7402245af1909e8c3"

+dependencies = [

+ "byteorder-lite",

+ "quick-error",

+]

+

+[[package]]

+name = "miniz_oxide"

+version = "0.8.9"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"

+dependencies = [

+ "adler2",

+ "simd-adler32",

+]

+

+[[package]]

+name = "moxcms"

+version = "0.7.11"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "ac9557c559cd6fc9867e122e20d2cbefc9ca29d80d027a8e39310920ed2f0a97"

+dependencies = [

+ "num-traits",

+ "pxfm",

+]

+

+[[package]]

+name = "png"

+version = "0.18.0"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "97baced388464909d42d89643fe4361939af9b7ce7a31ee32a168f832a70f2a0"

+dependencies = [

+ "bitflags",

+ "crc32fast",

+ "fdeflate",

+ "flate2",

+ "miniz_oxide",

+]

+

+[[package]]

+name = "pxfm"

+version = "0.1.27"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "7186d3822593aa4393561d186d1393b3923e9d6163d3fbfd6e825e3e6cf3e6a8"

+dependencies = [

+ "num-traits",

+]

+

+[[package]]

+name = "quick-error"

+version = "2.0.1"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"

+

+[[package]]

+name = "simd-adler32"

+version = "0.3.8"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"

+

+[[package]]

+name = "weezl"

+version = "0.1.12"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"

+

+

+[[package]]

+name = "zune-core"

+version = "0.5.1"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "cb8a0807f7c01457d0379ba880ba6322660448ddebc890ce29bb64da71fb40f9"

+

+[[package]]

+name = "zune-jpeg"

+version = "0.5.11"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "2959ca473aae96a14ecedf501d20b3608d2825ba280d5adb57d651721885b0c2"

+dependencies = [

+ "zune-core",

+]

+# Image handling

+image = { version = "0.25", default-features = false, features = ["jpeg", "png", "gif", "webp", "bmp", "ico"] }

+

+

+# Image handling

+image.workspace = true

+    Clipboard, ClipboardOperation, FileOperation, ImagePreviewLoader, PreviewLoader, UndoStack,

+    /// Async image preview loader.

+    image_preview_loader: ImagePreviewLoader,

+            image_preview_loader: ImagePreviewLoader::new(),

+                InputEvent::Scroll(scroll_event) => {

+                    let pos = Point::new(scroll_event.position.x, scroll_event.position.y);

+                    if self.handle_scroll(pos, scroll_event.delta_x, scroll_event.delta_y) {

+                        ev.request_redraw();

+                    }

+                }

+            // Poll for completed async preview loads (directories)

+            // Poll for completed async image preview loads

+            if let Some(result) = self.image_preview_loader.poll() {

+                if let Some(pane) = self.focused_pane_mut() {

+                    if let Some(tab) = pane.active_tab_mut() {

+                        tab.set_image_preview(&result.path, result.image);

+                    }

+                }

+                ev.request_redraw();

+            }

+

+            // Poll for completed grid view thumbnails

+            if let Some(pane) = self.focused_pane_mut() {

+                if let Some(tab) = pane.active_tab_mut() {

+                    if tab.poll_thumbnails() {

+                        ev.request_redraw();

+                    }

+                }

+            }

+

+            self.process_pending_image_previews();

+

+            // Request thumbnails for visible grid items

+            if let Some(pane) = self.focused_pane_mut() {

+                if let Some(tab) = pane.active_tab_mut() {

+                    tab.request_visible_thumbnails();

+                }

+            }

+    /// Handle mouse scroll. Returns true if a redraw is needed.

+    fn handle_scroll(&mut self, pos: Point, _delta_x: i32, delta_y: i32) -> bool {

+        // Check if scroll is over the content area (not sidebar, toolbar, etc.)

+        if let Some(pane) = self.focused_pane_mut() {

+            if let Some(tab) = pane.active_tab_mut() {

+                if tab.bounds().contains_point(pos) {

+                    return tab.on_scroll(delta_y);

+                }

+            }

+        }

+

+        // Check if scroll is over sidebar

+        if self.sidebar.bounds().contains_point(pos) {

+            return self.sidebar.on_scroll(delta_y);

+        }

+

+        false

+    }

+

+    /// Process pending image preview requests.

+    fn process_pending_image_previews(&mut self) {

+        if let Some(pane) = self.focused_pane_mut() {

+            if let Some(tab) = pane.active_tab_mut() {

+                if let Some((path, max_width, max_height)) = tab.take_pending_image_preview() {

+                    self.image_preview_loader.load(path, max_width, max_height);

+                }

+            }

+        }

+    }

+

+//! Asynchronous image preview loading.

+//!

+//! This module provides non-blocking image loading and scaling to prevent UI lag

+//! when selecting image files for preview.

+

+use std::path::PathBuf;

+use std::sync::mpsc::{self, Receiver, Sender, TryRecvError};

+use std::thread::{self, JoinHandle};

+

+/// Request to load an image preview.

+#[derive(Debug, Clone)]

+pub struct ImagePreviewRequest {

+    /// Path to load.

+    pub path: PathBuf,

+    /// Maximum width for the preview.

+    pub max_width: u32,

+    /// Maximum height for the preview.

+    pub max_height: u32,

+    /// Request ID for matching responses.

+    pub request_id: u64,

+}

+

+/// Result of an image preview load operation.

+#[derive(Debug)]

+pub struct ImagePreviewResult {

+    /// Path that was loaded.

+    pub path: PathBuf,

+    /// Loaded image data (RGBA format), or None if load failed.

+    pub image: Option<ImagePreview>,

+    /// Request ID for matching.

+    pub request_id: u64,

+}

+

+/// Loaded and scaled image preview.

+#[derive(Debug, Clone)]

+pub struct ImagePreview {

+    /// RGBA pixel data.

+    pub data: Vec<u8>,

+    /// Image width.

+    pub width: u32,

+    /// Image height.

+    pub height: u32,

+}

+

+/// Manages asynchronous image preview loading with a worker thread.

+pub struct ImagePreviewLoader {

+    /// Sender to submit load requests.

+    request_tx: Sender<ImagePreviewRequest>,

+    /// Receiver for completed loads.

+    result_rx: Receiver<ImagePreviewResult>,

+    /// 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 ImagePreviewLoader {

+    /// Create a new image preview loader with a background worker thread.

+    pub fn new() -> Self {

+        let (request_tx, request_rx) = mpsc::channel::<ImagePreviewRequest>();

+        let (result_tx, result_rx) = mpsc::channel::<ImagePreviewResult>();

+

+        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<ImagePreviewRequest>, result_tx: Sender<ImagePreviewResult>) {

+        while let Ok(request) = request_rx.recv() {

+            let image = Self::load_and_scale(&request.path, request.max_width, request.max_height);

+

+            // Send result back

+            let _ = result_tx.send(ImagePreviewResult {

+                path: request.path,

+                image,

+                request_id: request.request_id,

+            });

+        }

+    }

+

+    /// Load and scale an image to fit within the given dimensions.

+    fn load_and_scale(path: &PathBuf, max_width: u32, max_height: u32) -> Option<ImagePreview> {

+        use image::GenericImageView;

+

+        // Load the image

+        let img = image::open(path).ok()?;

+

+        let (orig_width, orig_height) = img.dimensions();

+

+        // Calculate scale to fit within max dimensions while preserving aspect ratio

+        let scale_x = max_width as f64 / orig_width as f64;

+        let scale_y = max_height as f64 / orig_height as f64;

+        let scale = scale_x.min(scale_y).min(1.0); // Don't upscale

+

+        let new_width = (orig_width as f64 * scale) as u32;

+        let new_height = (orig_height as f64 * scale) as u32;

+

+        // Resize if needed

+        let resized = if scale < 1.0 {

+            img.resize(new_width, new_height, image::imageops::FilterType::Triangle)

+        } else {

+            img

+        };

+

+        // Convert to RGBA

+        let rgba = resized.to_rgba8();

+        let (width, height) = rgba.dimensions();

+

+        Some(ImagePreview {

+            data: rgba.into_raw(),

+            width,

+            height,

+        })

+    }

+

+    /// Request loading an image preview. Returns the request ID.

+    pub fn load(&mut self, path: PathBuf, max_width: u32, max_height: u32) -> u64 {

+        self.next_request_id += 1;

+        self.current_request_id = self.next_request_id;

+

+        let request = ImagePreviewRequest {

+            path,

+            max_width,

+            max_height,

+            request_id: self.current_request_id,

+        };

+

+        let _ = self.request_tx.send(request);

+        self.current_request_id

+    }

+

+    /// Poll for a completed preview load. Returns None if no result ready.

+    pub fn poll(&mut self) -> Option<ImagePreviewResult> {

+        loop {

+            match self.result_rx.try_recv() {

+                Ok(result) => {

+                    if result.request_id == self.current_request_id {

+                        return Some(result);

+                    }

+                }

+                Err(TryRecvError::Empty) => return None,

+                Err(TryRecvError::Disconnected) => return None,

+            }

+        }

+    }

+

+    /// Cancel any pending requests.

+    pub fn cancel(&mut self) {

+        self.current_request_id = 0;

+    }

+}

+

+impl Default for ImagePreviewLoader {

+    fn default() -> Self {

+        Self::new()

+    }

+}

+

+/// Check if a file extension is a supported image format.

+pub fn is_supported_image(extension: Option<&str>) -> bool {

+    match extension {

+        Some(ext) => matches!(

+            ext.to_lowercase().as_str(),

+            "jpg" | "jpeg" | "png" | "gif" | "webp" | "bmp" | "ico"

+        ),

+        None => false,

+    }

+}

+pub mod image_preview;

+pub mod thumbnail;

+pub use image_preview::{is_supported_image, ImagePreview, ImagePreviewLoader, ImagePreviewResult};

+pub use thumbnail::{Thumbnail, ThumbnailLoader, THUMBNAIL_SIZE};

+//! Thumbnail loading and caching for grid view.

+//!

+//! Provides async thumbnail generation with in-memory caching.

+

+use std::collections::HashMap;

+use std::path::PathBuf;

+use std::sync::mpsc::{self, Receiver, Sender, TryRecvError};

+use std::thread::{self, JoinHandle};

+

+/// Default thumbnail size.

+pub const THUMBNAIL_SIZE: u32 = 64;

+

+/// Maximum number of cached thumbnails.

+const MAX_CACHE_SIZE: usize = 500;

+

+/// A loaded thumbnail.

+#[derive(Debug, Clone)]

+pub struct Thumbnail {

+    /// RGBA pixel data.

+    pub data: Vec<u8>,

+    /// Width in pixels.

+    pub width: u32,

+    /// Height in pixels.

+    pub height: u32,

+}

+

+/// Request to load a thumbnail.

+#[derive(Debug, Clone)]

+struct ThumbnailRequest {

+    path: PathBuf,

+    size: u32,

+    request_id: u64,

+}

+

+/// Result of a thumbnail load.

+#[derive(Debug)]

+pub struct ThumbnailResult {

+    pub path: PathBuf,

+    pub thumbnail: Option<Thumbnail>,

+}

+

+/// Manages async thumbnail loading with caching.

+pub struct ThumbnailLoader {

+    /// Sender for requests.

+    request_tx: Sender<ThumbnailRequest>,

+    /// Receiver for results.

+    result_rx: Receiver<ThumbnailResult>,

+    /// Worker thread.

+    _worker: JoinHandle<()>,

+    /// Request ID counter.

+    next_request_id: u64,

+    /// Paths currently being loaded.

+    pending: HashMap<PathBuf, u64>,

+    /// In-memory cache.

+    cache: HashMap<PathBuf, Thumbnail>,

+    /// LRU order tracking (most recently used at end).

+    lru_order: Vec<PathBuf>,

+}

+

+impl ThumbnailLoader {

+    /// Create a new thumbnail loader.

+    pub fn new() -> Self {

+        let (request_tx, request_rx) = mpsc::channel::<ThumbnailRequest>();

+        let (result_tx, result_rx) = mpsc::channel::<ThumbnailResult>();

+

+        let worker = thread::spawn(move || {

+            Self::worker_loop(request_rx, result_tx);

+        });

+

+        Self {

+            request_tx,

+            result_rx,

+            _worker: worker,

+            next_request_id: 0,

+            pending: HashMap::new(),

+            cache: HashMap::new(),

+            lru_order: Vec::new(),

+        }

+    }

+

+    /// Worker thread loop.

+    fn worker_loop(request_rx: Receiver<ThumbnailRequest>, result_tx: Sender<ThumbnailResult>) {

+        while let Ok(request) = request_rx.recv() {

+            let thumbnail = Self::load_thumbnail(&request.path, request.size);

+            let _ = result_tx.send(ThumbnailResult {

+                path: request.path,

+                thumbnail,

+            });

+        }

+    }

+

+    /// Load and scale a thumbnail.

+    fn load_thumbnail(path: &PathBuf, size: u32) -> Option<Thumbnail> {

+        use image::GenericImageView;

+

+        let img = image::open(path).ok()?;

+        let (orig_w, orig_h) = img.dimensions();

+

+        // Calculate scale to fit within size while preserving aspect ratio

+        let scale = (size as f64 / orig_w as f64).min(size as f64 / orig_h as f64).min(1.0);

+        let new_w = (orig_w as f64 * scale) as u32;

+        let new_h = (orig_h as f64 * scale) as u32;

+

+        // Use fast nearest-neighbor for thumbnails

+        let resized = if scale < 1.0 {

+            img.resize(new_w, new_h, image::imageops::FilterType::Triangle)

+        } else {

+            img

+        };

+

+        let rgba = resized.to_rgba8();

+        let (width, height) = rgba.dimensions();

+

+        Some(Thumbnail {

+            data: rgba.into_raw(),

+            width,

+            height,

+        })

+    }

+

+    /// Get a cached thumbnail, or request loading if not cached.

+    /// Returns Some(thumbnail) if cached, None if loading or not an image.

+    pub fn get_or_load(&mut self, path: &PathBuf) -> Option<&Thumbnail> {

+        // Check cache first

+        if self.cache.contains_key(path) {

+            // Update LRU order

+            self.touch_lru(path);

+            return self.cache.get(path);

+        }

+

+        // Check if already pending

+        if self.pending.contains_key(path) {

+            return None;

+        }

+

+        // Request loading

+        self.next_request_id += 1;

+        let request_id = self.next_request_id;

+

+        let request = ThumbnailRequest {

+            path: path.clone(),

+            size: THUMBNAIL_SIZE,

+            request_id,

+        };

+

+        if self.request_tx.send(request).is_ok() {

+            self.pending.insert(path.clone(), request_id);

+        }

+

+        None

+    }

+

+    /// Poll for completed thumbnail loads.

+    pub fn poll(&mut self) -> Vec<PathBuf> {

+        let mut loaded = Vec::new();

+

+        loop {

+            match self.result_rx.try_recv() {

+                Ok(result) => {

+                    self.pending.remove(&result.path);

+                    if let Some(thumbnail) = result.thumbnail {

+                        self.insert_cache(result.path.clone(), thumbnail);

+                        loaded.push(result.path);

+                    }

+                }

+                Err(TryRecvError::Empty) => break,

+                Err(TryRecvError::Disconnected) => break,

+            }

+        }

+

+        loaded

+    }

+

+    /// Insert into cache with LRU eviction.

+    fn insert_cache(&mut self, path: PathBuf, thumbnail: Thumbnail) {

+        // Evict if at capacity

+        while self.cache.len() >= MAX_CACHE_SIZE {

+            if let Some(oldest) = self.lru_order.first().cloned() {

+                self.cache.remove(&oldest);

+                self.lru_order.remove(0);

+            } else {

+                break;

+            }

+        }

+

+        self.cache.insert(path.clone(), thumbnail);

+        self.lru_order.push(path);

+    }

+

+    /// Update LRU order for a path.

+    fn touch_lru(&mut self, path: &PathBuf) {

+        if let Some(pos) = self.lru_order.iter().position(|p| p == path) {

+            self.lru_order.remove(pos);

+            self.lru_order.push(path.clone());

+        }

+    }

+

+    /// Clear the cache.

+    pub fn clear_cache(&mut self) {

+        self.cache.clear();

+        self.lru_order.clear();

+    }

+

+    /// Check if a path is cached.

+    pub fn is_cached(&self, path: &PathBuf) -> bool {

+        self.cache.contains_key(path)

+    }

+

+    /// Get a cached thumbnail without requesting a load.

+    pub fn get_cached(&self, path: &PathBuf) -> Option<&Thumbnail> {

+        self.cache.get(path)

+    }

+}

+

+impl Default for ThumbnailLoader {

+    fn default() -> Self {

+        Self::new()

+    }

+}

+use crate::core::{read_directory, sort_entries, EntryType, FileEntry, ImagePreview, SortDirection, SortOrder, is_supported_image};

+use gartk_render::{Renderer, TextStyle, Surface};

+    /// Path that needs image preview loading.

+    pending_image_preview_path: Option<PathBuf>,

+    /// Loaded image preview.

+    image_preview: Option<ImagePreview>,

+    /// Path of the loaded image preview (for matching).

+    image_preview_path: Option<PathBuf>,

+    /// Cached Cairo surface for the image preview.

+    image_surface: Option<Surface>,

+            pending_image_preview_path: None,

+            image_preview: None,

+            image_preview_path: None,

+            image_surface: None,

+                // Clear image preview for directories

+                self.pending_image_preview_path = None;

+                self.image_preview = None;

+                self.image_preview_path = None;

+                self.image_surface = None;

+

+                // Check if this is an image file that needs preview

+                if is_supported_image(entry.extension().as_deref()) {

+                    let needs_load = self.image_preview_path.as_ref() != Some(&entry.path);

+                    if needs_load {

+                        self.pending_image_preview_path = Some(entry.path.clone());

+                        // Clear current image preview while loading

+                        self.image_preview = None;

+                        self.image_preview_path = None;

+                        self.image_surface = None;

+                    }

+                } else {

+                    // Not an image - clear image preview

+                    self.pending_image_preview_path = None;

+                    self.image_preview = None;

+                    self.image_preview_path = None;

+                    self.image_surface = None;

+                }

+            self.pending_image_preview_path = None;

+            self.image_preview = None;

+            self.image_preview_path = None;

+            self.image_surface = None;

+    /// Take pending image preview request (path, max_width, max_height).

+    pub fn take_pending_image_preview(&mut self) -> Option<(PathBuf, u32, u32)> {

+        self.pending_image_preview_path.take().map(|path| {

+            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) as u32;

+            let preview_height = self.bounds.height / 2; // Use half height for image

+            (path, preview_width.saturating_sub(32), preview_height.saturating_sub(32))

+        })

+    }

+

+    /// Set loaded image preview.

+    pub fn set_image_preview(&mut self, path: &PathBuf, image: Option<ImagePreview>) {

+        // Only set if this is still the path we're displaying

+        let visible = self.current_column.visible_entries(self.show_hidden);

+        let selected_matches = visible

+            .get(self.current_column.selected)

+            .map(|e| &e.path == path)

+            .unwrap_or(false);

+

+        if selected_matches {

+            if let Some(ref preview) = image {

+                // Create a Cairo surface from the RGBA data

+                self.image_surface = Surface::from_rgba(&preview.data, preview.width, preview.height).ok();

+            } else {

+                self.image_surface = None;

+            }

+            self.image_preview = image;

+            self.image_preview_path = Some(path.clone());

+        }

+    }

+

+    /// Handle mouse scroll. Returns true if scrolled.

+    pub fn on_scroll(&mut self, delta_y: i32) -> bool {

+        // Scroll the current column

+        let visible = self.visible_entries();

+        let total_rows = visible.len();

+        let visible_rows = self.current_column.visible_rows();

+

+        if total_rows <= visible_rows {

+            return false;

+        }

+

+        let max_scroll = total_rows.saturating_sub(visible_rows);

+        let old_offset = self.current_column.scroll_offset;

+

+        if delta_y < 0 {

+            let rows = ((-delta_y) as usize / 3).max(1);

+            self.current_column.scroll_offset = self.current_column.scroll_offset.saturating_sub(rows);

+        } else if delta_y > 0 {

+            let rows = (delta_y as usize / 3).max(1);

+            self.current_column.scroll_offset = (self.current_column.scroll_offset + rows).min(max_scroll);

+        }

+

+        self.current_column.scroll_offset != old_offset

+    }

+

+        let mut y = self.bounds.y + 16;

+        let x = preview_x + 16;

+

+        // Render image preview if available

+        if let Some(ref surface) = self.image_surface {

+            // Center the image in the preview area

+            let img_width = surface.width();

+            let img_height = surface.height();

+            let max_width = preview_width.saturating_sub(32);

+

+            let img_x = preview_x + 16 + (max_width.saturating_sub(img_width) / 2) as i32;

+            let img_y = y;

+

+            // Draw the image using Cairo

+            let ctx = renderer.context()?;

+            ctx.set_source_surface(surface.cairo_surface(), img_x as f64, img_y as f64)?;

+            ctx.paint()?;

+

+            // Move y below the image with padding

+            y += img_height as i32 + 24;

+        } else if is_supported_image(entry.extension().as_deref()) && self.pending_image_preview_path.is_some() {

+            // Show loading indicator for images

+            let loading_style = TextStyle::new()

+                .font_family(&theme.font_family)

+                .font_size(theme.font_size)

+                .color(theme.item_foreground.with_alpha(0.5));

+            renderer.text("Loading preview...", x as f64, y as f64, &loading_style)?;

+            y += 40;

+        }

+

+use crate::core::{is_supported_image, EntryType, FileEntry, SortDirection, SortOrder, ThumbnailLoader};

+use gartk_render::{Renderer, Surface, TextAlign, TextStyle};

+use std::collections::{HashMap, HashSet};

+use std::path::PathBuf;

+    /// Thumbnail loader for image files.

+    thumbnail_loader: ThumbnailLoader,

+    /// Cached thumbnail surfaces.

+    thumbnail_cache: HashMap<PathBuf, Surface>,

+            thumbnail_loader: ThumbnailLoader::new(),

+            thumbnail_cache: HashMap::new(),

+        // Clear thumbnail cache when directory changes

+        self.thumbnail_cache.clear();

+        self.thumbnail_loader.clear_cache();

+    }

+

+    /// Poll for completed thumbnail loads. Returns true if any thumbnails were loaded.

+    pub fn poll_thumbnails(&mut self) -> bool {

+        let loaded = self.thumbnail_loader.poll();

+        let mut any_loaded = false;

+

+        for path in loaded {

+            // Create surface from cached thumbnail (borrow ends after and_then)

+            let surface_opt = self.thumbnail_loader

+                .get_cached(&path)

+                .and_then(|thumbnail| {

+                    Surface::from_rgba(&thumbnail.data, thumbnail.width, thumbnail.height).ok()

+                });

+

+            // Now insert (no borrow of thumbnail_loader active)

+            if let Some(surface) = surface_opt {

+                self.thumbnail_cache.insert(path, surface);

+                any_loaded = true;

+            }

+        }

+

+        any_loaded

+    }

+

+    /// Request thumbnails for visible image files.

+    pub fn request_visible_thumbnails(&mut self) {

+        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_count);

+

+        // Collect paths to load (immutable borrow of entries)

+        let paths_to_load: Vec<PathBuf> = (start_index..end_index)

+            .filter_map(|i| {

+                self.visible_entry(i).and_then(|entry| {

+                    if is_supported_image(entry.extension().as_deref())

+                        && !self.thumbnail_cache.contains_key(&entry.path)

+                    {

+                        Some(entry.path.clone())

+                    } else {

+                        None

+                    }

+                })

+            })

+            .collect();

+

+        // Now request loading (mutable borrow of thumbnail_loader)

+        for path in paths_to_load {

+            self.thumbnail_loader.get_or_load(&path);

+        }

+    /// Handle mouse scroll. Returns true if scrolled.

+    pub fn on_scroll(&mut self, delta_y: i32) -> bool {

+        let visible_count = self.visible_count();

+        let total_rows = (visible_count + self.columns - 1) / self.columns;

+        let visible_rows = self.visible_rows();

+

+        if total_rows <= visible_rows {

+            return false; // No scrolling needed

+        }

+

+        let max_scroll = total_rows.saturating_sub(visible_rows);

+        let old_offset = self.scroll_offset;

+

+        // Scroll by number of rows (negative delta = scroll up)

+        if delta_y < 0 {

+            // Scroll up

+            let rows = ((-delta_y) as usize / 3).max(1);

+            self.scroll_offset = self.scroll_offset.saturating_sub(rows);

+        } else if delta_y > 0 {

+            // Scroll down

+            let rows = (delta_y as usize / 3).max(1);

+            self.scroll_offset = (self.scroll_offset + rows).min(max_scroll);

+        }

+

+        self.scroll_offset != old_offset

+    }

+

+            // Check for cached thumbnail first (for image files)

+            let mut rendered_thumbnail = false;

+            if is_supported_image(entry.extension().as_deref()) {

+                if let Some(surface) = self.thumbnail_cache.get(&entry.path) {

+                    // Render the thumbnail centered in the icon area

+                    let thumb_w = surface.width();

+                    let thumb_h = surface.height();

+                    let icon_area_size = icon_size_px;

+                    let thumb_x = cell.x + (cell.width as i32 - thumb_w as i32) / 2;

+                    let thumb_y = cell.y + 8 + (icon_area_size as i32 - thumb_h as i32) / 2;

+

+                    let ctx = renderer.context()?;

+                    ctx.set_source_surface(surface.cairo_surface(), thumb_x as f64, thumb_y as f64)?;

+                    ctx.paint()?;

+                    rendered_thumbnail = true;

+                // Thumbnails are requested via request_visible_thumbnails() called before render

+            }

+            // Fall back to emoji icon if no thumbnail

+            if !rendered_thumbnail {

+                let icon = match entry.entry_type {

+                    EntryType::Directory => "\u{1F4C1}",  // folder emoji

+                    EntryType::Symlink => "\u{1F517}",    // link emoji

+                    _ => Self::file_icon_for_extension(entry.extension().as_deref()),

+                };

+                let icon_color = if is_selected {

+                    theme.selection_foreground

+                } else {

+                    match entry.entry_type {

+                        EntryType::Directory => dir_color,

+                        EntryType::Symlink => symlink_color,

+                        _ => theme.item_foreground,

+                    }

+                };

+

+                let icon_style = TextStyle::new()

+                    .font_family(&theme.font_family)

+                    .font_size(icon_font_size)

+                    .color(icon_color);

+

+                // Center icon horizontally in cell

+                let icon_center_x = cell.x + cell.width as i32 / 2;

+                let icon_center_y = cell.y + 10 + (icon_font_size / 2.0) as i32;

+                renderer.text_centered(icon, Point::new(icon_center_x, icon_center_y), &icon_style)?;

+            }

+    /// Handle mouse scroll. Returns true if scrolled.

+    pub fn on_scroll(&mut self, delta_y: i32) -> bool {

+        let visible = self.visible_entries();

+        let total_rows = visible.len();

+        let visible_rows = self.visible_rows();

+

+        if total_rows <= visible_rows {

+            return false; // No scrolling needed

+        }

+

+        let max_scroll = total_rows.saturating_sub(visible_rows);

+        let old_offset = self.scroll_offset;

+

+        if delta_y < 0 {

+            // Scroll up

+            let rows = ((-delta_y) as usize / 3).max(1);

+            self.scroll_offset = self.scroll_offset.saturating_sub(rows);

+        } else if delta_y > 0 {

+            // Scroll down

+            let rows = (delta_y as usize / 3).max(1);

+            self.scroll_offset = (self.scroll_offset + rows).min(max_scroll);

+        }

+

+        self.scroll_offset != old_offset

+    }

+

+    /// Handle mouse scroll. Returns true if scrolled.

+    /// Sidebar doesn't currently support scrolling, but this handles the event.

+    pub fn on_scroll(&mut self, _delta_y: i32) -> bool {

+        false // Sidebar doesn't scroll currently

+    }

+

+    /// Get bounds.

+    pub fn bounds(&self) -> Rect {

+        self.bounds

+    }

+

+    /// Handle mouse scroll. Returns true if scrolled.

+    pub fn on_scroll(&mut self, delta_y: i32) -> bool {

+        match self.view_mode {

+            ViewMode::List => self.list_view.on_scroll(delta_y),

+            ViewMode::Grid => self.grid_view.on_scroll(delta_y),

+            ViewMode::Columns => self.column_view.on_scroll(delta_y),

+        }

+    }

+

+

+    /// Take pending image preview request (path, max_width, max_height).

+    pub fn take_pending_image_preview(&mut self) -> Option<(PathBuf, u32, u32)> {

+        if self.view_mode == ViewMode::Columns {

+            self.column_view.take_pending_image_preview()

+        } else {

+            None

+        }

+    }

+

+    /// Set loaded image preview for column view.

+    pub fn set_image_preview(&mut self, path: &PathBuf, image: Option<crate::core::ImagePreview>) {

+        if self.view_mode == ViewMode::Columns {

+            self.column_view.set_image_preview(path, image);

+        }

+    }

+

+    /// Poll for completed grid view thumbnails. Returns true if any loaded.

+    pub fn poll_thumbnails(&mut self) -> bool {

+        self.grid_view.poll_thumbnails()

+    }

+

+    /// Request thumbnails for visible items in grid view.

+    pub fn request_visible_thumbnails(&mut self) {

+        if self.view_mode == ViewMode::Grid {

+            self.grid_view.request_visible_thumbnails();

+        }

+    }