gardesk/garfield / 1d6e7be

+ "cairo-sys-rs 0.20.10",

+ "glib 0.20.12",

+ "libc",

+]

+

+[[package]]

+name = "cairo-rs"

+version = "0.21.5"

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

+checksum = "b01fe135c0bd16afe262b6dea349bd5ea30e6de50708cec639aae7c5c14cc7e4"

+dependencies = [

+ "bitflags",

+ "cairo-sys-rs 0.21.5",

+ "glib 0.21.5",

+ "glib-sys 0.20.10",

+ "libc",

+ "system-deps",

+]

+

+[[package]]

+name = "cairo-sys-rs"

+version = "0.21.5"

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

+checksum = "06c28280c6b12055b5e39e4554271ae4e6630b27c0da9148c4cf6485fc6d245c"

+dependencies = [

+ "glib-sys 0.21.5",

+ "cairo-rs 0.21.5",

+ "poppler-rs",

+ "cairo-rs 0.20.12",

+ "gio-sys 0.20.10",

+ "glib 0.20.12",

+ "libc",

+ "pin-project-lite",

+ "smallvec",

+]

+

+[[package]]

+name = "gio"

+version = "0.21.5"

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

+checksum = "c5ff48bf600c68b476e61dc6b7c762f2f4eb91deef66583ba8bb815c30b5811a"

+dependencies = [

+ "futures-channel",

+ "futures-core",

+ "futures-io",

+ "futures-util",

+ "gio-sys 0.21.5",

+ "glib 0.21.5",

+ "glib-sys 0.20.10",

+ "gobject-sys 0.20.10",

+[[package]]

+name = "gio-sys"

+version = "0.21.5"

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

+checksum = "0071fe88dba8e40086c8ff9bbb62622999f49628344b1d1bf490a48a29d80f22"

+dependencies = [

+ "glib-sys 0.21.5",

+ "gobject-sys 0.21.5",

+ "libc",

+ "system-deps",

+ "windows-sys 0.61.2",

+]

+

+ "gio-sys 0.20.10",

+ "glib-macros 0.20.12",

+ "glib-sys 0.20.10",

+ "gobject-sys 0.20.10",

+ "libc",

+ "memchr",

+ "smallvec",

+]

+

+[[package]]

+name = "glib"

+version = "0.21.5"

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

+checksum = "16de123c2e6c90ce3b573b7330de19be649080ec612033d397d72da265f1bd8b"

+dependencies = [

+ "bitflags",

+ "futures-channel",

+ "futures-core",

+ "futures-executor",

+ "futures-task",

+ "futures-util",

+ "gio-sys 0.21.5",

+ "glib-macros 0.21.5",

+ "glib-sys 0.21.5",

+ "gobject-sys 0.21.5",

+[[package]]

+name = "glib-macros"

+version = "0.21.5"

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

+checksum = "cf59b675301228a696fe01c3073974643365080a76cc3ed5bc2cbc466ad87f17"

+dependencies = [

+ "heck",

+ "proc-macro-crate",

+ "proc-macro2",

+ "quote",

+ "syn",

+]

+

+[[package]]

+name = "glib-sys"

+version = "0.21.5"

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

+checksum = "2d95e1a3a19ae464a7286e14af9a90683c64d70c02532d88d87ce95056af3e6c"

+dependencies = [

+ "libc",

+ "system-deps",

+]

+

+ "glib-sys 0.20.10",

+ "libc",

+ "system-deps",

+]

+

+[[package]]

+name = "gobject-sys"

+version = "0.21.5"

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

+checksum = "2dca35da0d19a18f4575f3cb99fe1c9e029a2941af5662f326f738a21edaf294"

+dependencies = [

+ "glib-sys 0.21.5",

+ "gio 0.20.12",

+ "glib 0.20.12",

+ "glib-sys 0.20.10",

+ "gobject-sys 0.20.10",

+ "cairo-rs 0.20.12",

+ "glib 0.20.12",

+ "cairo-sys-rs 0.20.10",

+ "glib-sys 0.20.10",

+[[package]]

+name = "poppler-rs"

+version = "0.25.0"

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

+checksum = "f654ec8b83bca9adb0ea7e62194a1e5767a094d282d77630ff0ddb2edbc30139"

+dependencies = [

+ "cairo-rs 0.21.5",

+ "gio 0.21.5",

+ "glib 0.21.5",

+ "libc",

+ "poppler-sys-rs",

+]

+

+[[package]]

+name = "poppler-sys-rs"

+version = "0.25.0"

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

+checksum = "7f59d8616943cf71be2a33d866dee973eaaa3e507eb21eb102c6424f773ea6ad"

+dependencies = [

+ "cairo-sys-rs 0.21.5",

+ "gio-sys 0.21.5",

+ "glib-sys 0.21.5",

+ "gobject-sys 0.21.5",

+ "libc",

+ "system-deps",

+]

+

+# PDF rendering

+poppler-rs = "0.25"

+cairo-rs = { version = "0.21", features = ["png"] }

+

+

+# PDF rendering

+poppler-rs.workspace = true

+cairo-rs.workspace = true

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

+    /// Async PDF preview loader.

+    pdf_preview_loader: PdfPreviewLoader,

+            pdf_preview_loader: PdfPreviewLoader::new(),

+            // Poll for completed async PDF preview loads

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

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

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

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

+                    }

+                }

+                ev.request_redraw();

+            }

+

+            self.process_pending_pdf_previews();

+    /// Process pending PDF preview requests.

+    fn process_pending_pdf_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_pdf_preview() {

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

+                }

+            }

+        }

+    }

+

+pub mod pdf_preview;

+pub use pdf_preview::{is_pdf, PdfPreview, PdfPreviewLoader, PdfPreviewResult};

+//! Asynchronous PDF preview loading.

+//!

+//! This module provides non-blocking PDF rendering to prevent UI lag

+//! when selecting PDF files for preview.

+

+use std::path::PathBuf;

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

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

+

+/// Request to load a PDF preview.

+#[derive(Debug, Clone)]

+pub struct PdfPreviewRequest {

+    /// 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 a PDF preview load operation.

+#[derive(Debug)]

+pub struct PdfPreviewResult {

+    /// Path that was loaded.

+    pub path: PathBuf,

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

+    pub image: Option<PdfPreview>,

+    /// Request ID for matching.

+    pub request_id: u64,

+}

+

+/// Loaded and rendered PDF preview (first page).

+#[derive(Debug, Clone)]

+pub struct PdfPreview {

+    /// RGBA pixel data.

+    pub data: Vec<u8>,

+    /// Image width.

+    pub width: u32,

+    /// Image height.

+    pub height: u32,

+    /// Total number of pages in the PDF.

+    pub page_count: usize,

+}

+

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

+pub struct PdfPreviewLoader {

+    /// Sender to submit load requests.

+    request_tx: Sender<PdfPreviewRequest>,

+    /// Receiver for completed loads.

+    result_rx: Receiver<PdfPreviewResult>,

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

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

+    pub fn new() -> Self {

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

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

+

+        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<PdfPreviewRequest>, result_tx: Sender<PdfPreviewResult>) {

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

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

+

+            // Send result back

+            let _ = result_tx.send(PdfPreviewResult {

+                path: request.path,

+                image,

+                request_id: request.request_id,

+            });

+        }

+    }

+

+    /// Render the first page of a PDF to an image.

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

+        use cairo::{Context, Format, ImageSurface};

+        use poppler::Document;

+

+        // Load the PDF document

+        let uri = format!("file://{}", path.display());

+        let doc = Document::from_file(&uri, None).ok()?;

+

+        let page_count = doc.n_pages() as usize;

+        if page_count == 0 {

+            return None;

+        }

+

+        // Get the first page

+        let page = doc.page(0)?;

+        let (page_width, page_height) = page.size();

+

+        // Calculate scale to fit within max dimensions

+        let scale_x = max_width as f64 / page_width;

+        let scale_y = max_height as f64 / page_height;

+        let scale = scale_x.min(scale_y).min(2.0); // Cap at 2x for quality

+

+        let width = (page_width * scale) as i32;

+        let height = (page_height * scale) as i32;

+

+        // Create a Cairo surface to render to

+        let mut surface = ImageSurface::create(Format::ARgb32, width, height).ok()?;

+

+        {

+            let ctx = Context::new(&surface).ok()?;

+

+            // Fill with white background

+            ctx.set_source_rgb(1.0, 1.0, 1.0);

+            ctx.paint().ok()?;

+

+            // Scale and render the page

+            ctx.scale(scale, scale);

+            page.render(&ctx);

+        }

+

+        // Get the pixel data

+        surface.flush();

+        let stride = surface.stride() as usize;

+        let data = surface.data().ok()?;

+

+        // Convert from ARGB (Cairo) to RGBA

+        let mut rgba = Vec::with_capacity((width * height * 4) as usize);

+        for y in 0..height as usize {

+            for x in 0..width as usize {

+                let offset = y * stride + x * 4;

+                let b = data[offset];

+                let g = data[offset + 1];

+                let r = data[offset + 2];

+                let a = data[offset + 3];

+                rgba.push(r);

+                rgba.push(g);

+                rgba.push(b);

+                rgba.push(a);

+            }

+        }

+

+        Some(PdfPreview {

+            data: rgba,

+            width: width as u32,

+            height: height as u32,

+            page_count,

+        })

+    }

+

+    /// Request loading a PDF 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 = PdfPreviewRequest {

+            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<PdfPreviewResult> {

+        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 PdfPreviewLoader {

+    fn default() -> Self {

+        Self::new()

+    }

+}

+

+/// Check if a file extension is a PDF.

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

+    matches!(extension.map(|e| e.to_lowercase()).as_deref(), Some("pdf"))

+}

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

+    /// Path that needs PDF preview loading.

+    pending_pdf_preview_path: Option<PathBuf>,

+    /// Loaded PDF preview.

+    pdf_preview: Option<PdfPreview>,

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

+    pdf_preview_path: Option<PathBuf>,

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

+    pdf_surface: Option<Surface>,

+            pending_pdf_preview_path: None,

+            pdf_preview: None,

+            pdf_preview_path: None,

+            pdf_surface: None,

+                // Clear image/PDF preview for directories

+                self.clear_file_previews();

+                    // Clear PDF preview when showing image

+                    self.pending_pdf_preview_path = None;

+                    self.pdf_preview = None;

+                    self.pdf_preview_path = None;

+                    self.pdf_surface = None;

+                } else if is_pdf(entry.extension().as_deref()) {

+                    // Check if this is a PDF file that needs preview

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

+                    if needs_load {

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

+                        // Clear current PDF preview while loading

+                        self.pdf_preview = None;

+                        self.pdf_preview_path = None;

+                        self.pdf_surface = None;

+                    }

+                    // Clear image preview when showing PDF

+                } else {

+                    // Not an image or PDF - clear both previews

+                    self.clear_file_previews();

+            self.clear_file_previews();

+    /// Clear all file preview state (image and PDF).

+    fn clear_file_previews(&mut self) {

+        self.pending_image_preview_path = None;

+        self.image_preview = None;

+        self.image_preview_path = None;

+        self.image_surface = None;

+        self.pending_pdf_preview_path = None;

+        self.pdf_preview = None;

+        self.pdf_preview_path = None;

+        self.pdf_surface = None;

+    }

+

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

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

+        self.pending_pdf_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 PDF

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

+        })

+    }

+

+    /// Set loaded PDF preview.

+    pub fn set_pdf_preview(&mut self, path: &PathBuf, pdf: Option<PdfPreview>) {

+        // 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) = pdf {

+                // Create a Cairo surface from the RGBA data

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

+            } else {

+                self.pdf_surface = None;

+            }

+            self.pdf_preview = pdf;

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

+        }

+    }

+

+        } else if let Some(ref surface) = self.pdf_surface {

+            // Render PDF preview

+            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 PDF preview using Cairo

+            let ctx = renderer.context()?;

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

+            ctx.paint()?;

+

+            // Show page count if available

+            if let Some(ref pdf) = self.pdf_preview {

+                let page_info = format!("Page 1 of {}", pdf.page_count);

+                let page_style = TextStyle::new()

+                    .font_family(&theme.font_family)

+                    .font_size(theme.font_size - 2.0)

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

+                renderer.text(&page_info, (img_x + 4) as f64, (img_y + img_height as i32 + 4) as f64, &page_style)?;

+            }

+

+            // Move y below the preview with padding

+            y += img_height as i32 + 32;

+        } else if is_pdf(entry.extension().as_deref()) && self.pending_pdf_preview_path.is_some() {

+            // Show loading indicator for PDFs

+            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 PDF preview...", x as f64, y as f64, &loading_style)?;

+            y += 40;

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

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

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

+            self.column_view.take_pending_pdf_preview()

+        } else {

+            None

+        }

+    }

+

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

+    pub fn set_pdf_preview(&mut self, path: &PathBuf, pdf: Option<crate::core::PdfPreview>) {

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

+            self.column_view.set_pdf_preview(path, pdf);

+        }

+    }

+