`bc72349`

grid: add PDF thumbnail support

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

SHA: bc72349b0b7c025e8853280cd039e75345576210
Parents: 1d6e7be
Tree: 2aebf8d

2 changed files

Status	File	+	-
M	`garfield/src/core/thumbnail.rs`	79	0
M	`garfield/src/ui/grid_view.rs`	10	7

garfield/src/core/thumbnail.rsmodified

      /// Load and scale a thumbnail.
      fn load_thumbnail(path: &PathBuf, size: u32) -> Option<Thumbnail> {
++        // Check if it's a PDF
++        let ext = path.extension()
++            .and_then(|e| e.to_str())
++            .map(|e| e.to_lowercase());
++
++        if ext.as_deref() == Some("pdf") {
++            return Self::load_pdf_thumbnail(path, size);
++        }
++
++        Self::load_image_thumbnail(path, size)
++    }
++
++    /// Load thumbnail from an image file.
++    fn load_image_thumbnail(path: &PathBuf, size: u32) -> Option<Thumbnail> {
          use image::GenericImageView;
          let img = image::open(path).ok()?;
          })
+     }
++    /// Load thumbnail from a PDF file (render first page).
++    fn load_pdf_thumbnail(path: &PathBuf, size: u32) -> Option<Thumbnail> {
++        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()?;
++
++        if doc.n_pages() == 0 {
++            return None;
++        }
++
++        // Get the first page
++        let page = doc.page(0)?;
++        let (page_width, page_height) = page.size();
++
++        // Calculate scale to fit within thumbnail size
++        let scale = (size as f64 / page_width).min(size as f64 / page_height);
++        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(Thumbnail {
++            data: rgba,
++            width: width as u32,
++            height: height as u32,
++        })
++    }
++
      /// 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> {

garfield/src/ui/grid_view.rsmodified

  //! Grid/icon view for displaying directory contents.
--use crate::core::{is_supported_image, EntryType, FileEntry, SortDirection, SortOrder, ThumbnailLoader};
++use crate::core::{is_supported_image, is_pdf, EntryType, FileEntry, SortDirection, SortOrder, ThumbnailLoader};
  use crate::ui::tab::RenameState;
  use gartk_core::{Color, Modifiers, Point, Rect};
  use gartk_render::{Renderer, Surface, TextAlign, TextStyle};
          any_loaded
+     }
--    /// Request thumbnails for visible image files.
++    /// Request thumbnails for visible image and PDF files.
      pub fn request_visible_thumbnails(&mut self) {
          let visible_count = self.visible_count();
          let visible_rows = self.visible_rows();
          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())
++                    let ext_owned = entry.extension();
--                        && !self.thumbnail_cache.contains_key(&entry.path)
++                    let ext = ext_owned.as_deref();
--                    {
++                    let is_thumbnailable = is_supported_image(ext) || is_pdf(ext);
++                    if is_thumbnailable && !self.thumbnail_cache.contains_key(&entry.path) {
                          Some(entry.path.clone())
                      } else {
                          None
                  renderer.stroke_rect(cell, theme.selection_background.with_alpha(0.5), 1.0)?;
+             }
--            // Check for cached thumbnail first (for image files)
++            // Check for cached thumbnail first (for image and PDF files)
              let mut rendered_thumbnail = false;
--            if is_supported_image(entry.extension().as_deref()) {
++            let ext_owned = entry.extension();
++            let ext = ext_owned.as_deref();
++            if is_supported_image(ext) || is_pdf(ext) {
                  if let Some(surface) = self.thumbnail_cache.get(&entry.path) {
                      // Render the thumbnail centered in the icon area
                      let thumb_w = surface.width();