decoder: Use GFile instead of PathBuf

This allows to show images from locations that don't
have a representation with path.

This also works around not being able to read files in trash:///

Closes #56

Part-of: <https://gitlab.gnome.org/Incubator/loupe/-/merge_requests/174>

data/gtk/window.ui

@@ -59,7 +59,7 @@
     <property name="title" translatable="yes">Loupe</property>
     <binding name="title">
       <closure type="gchararray" function="window_title">
-        <lookup name="path">
+        <lookup name="file">
           <lookup name="image">
             <lookup name="current-page">image_view</lookup>
           </lookup>

src/application.rs

@@ -73,7 +73,7 @@ mod imp {
             let application = self.obj();
             for file in files {
                 let win = LpWindow::new(&*application);
-                win.set_image_from_file(&file);
+                win.set_image_from_file(file);
             }
         }
     }

src/decoder/formats/heif.rs

@@ -3,14 +3,14 @@ use super::*;
 use crate::decoder::tiling::{self, FrameBufferExt};
 use crate::deps::*;
 use crate::util::gettext::*;
-use gtk::prelude::*;
+use crate::util::ToBufRead;
 
 use anyhow::Context;
 use arc_swap::ArcSwap;
+use gtk::prelude::*;
 use libheif_rs::{ColorSpace, HeifContext, LibHeif, Plane, RgbChroma};
 use once_cell::sync::Lazy;
 
-use std::path::PathBuf;
 use std::sync::Arc;
 
 #[derive(Debug)]
@@ -21,14 +21,24 @@ static LIBHEIF: Lazy<LibHeif> = Lazy::new(LibHeif::new);
 
 impl Heif {
     pub fn new(
-        path: PathBuf,
+        file: gio::File,
         updater: UpdateSender,
         tiles: Arc<ArcSwap<tiling::FrameBuffer>>,
     ) -> Self {
         log::debug!("Loading HEIF");
         updater.spawn_error_handled(move || {
-            let ctx = HeifContext::read_from_file(&path.display().to_string())
+            let file_size = file
-                .context(gettext("Failed to read image"))?;
+                .query_info(
+                    gio::FILE_ATTRIBUTE_STANDARD_SIZE,
+                    gio::FileQueryInfoFlags::NONE,
+                    gio::Cancellable::NONE,
+                )
+                .context(gettext("Failed to read image file information"))?
+                .size();
+            let buf_reader = file.to_buf_read()?;
+            let stream_reader = libheif_rs::StreamReader::new(buf_reader, file_size as u64);
+            let ctx = HeifContext::read_from_reader(Box::new(stream_reader))
+                .context(gettext("Failed to decode image"))?;
             let handle = ctx.primary_image_handle()?;
 
             tiles.set_original_dimensions((handle.width(), handle.height()));

src/decoder/formats/image_rs_other.rs

@@ -3,15 +3,13 @@ use super::*;
 use crate::decoder::tiling::{self, FrameBufferExt};
 use crate::deps::*;
 use crate::util::gettext::*;
+use crate::util::{BufReadSeek, ToBufRead};
 
 use anyhow::Context;
 use arc_swap::ArcSwap;
 use gtk::prelude::*;
 use image_rs::AnimationDecoder;
 
-use std::fs::File;
-use std::io::BufReader;
-use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
 #[derive(Debug)]
@@ -32,17 +30,17 @@ impl Drop for ImageRsOther {
 
 impl ImageRsOther {
     fn reader(
-        path: &Path,
+        file: &gio::File,
         format: image_rs::ImageFormat,
-    ) -> anyhow::Result<image_rs::io::Reader<BufReader<File>>> {
+    ) -> anyhow::Result<image_rs::io::Reader<Box<dyn BufReadSeek>>> {
-        let mut reader =
+        let buf_read = file.to_buf_read()?;
-            image_rs::io::Reader::open(path).context(gettext("Failed to open image"))?;
+        let mut reader = image_rs::io::Reader::new(buf_read);
         reader.set_format(format);
         Ok(reader)
     }
 
     pub fn new(
-        path: PathBuf,
+        file: gio::File,
         format: image_rs::ImageFormat,
         updater: UpdateSender,
         tiles: Arc<ArcSwap<tiling::FrameBuffer>>,
@@ -53,14 +51,14 @@ impl ImageRsOther {
             image_rs::ImageFormat::Gif
             | image_rs::ImageFormat::WebP
             | image_rs::ImageFormat::Png => Some(Self::new_animated(
-                path,
+                file,
                 format,
                 updater,
                 tiles,
                 abort.clone(),
             )),
             _ => {
-                Self::new_static(path, format, updater, tiles);
+                Self::new_static(file, format, updater, tiles);
                 None
             }
         };
@@ -72,20 +70,20 @@ impl ImageRsOther {
     }
 
     fn new_static(
-        path: PathBuf,
+        file: gio::File,
         format: image_rs::ImageFormat,
         updater: UpdateSender,
         tiles: Arc<ArcSwap<tiling::FrameBuffer>>,
     ) {
         updater.spawn_error_handled(move || {
-            let reader = Self::reader(&path, format)?;
+            let reader = Self::reader(&file, format)?;
             let dimensions = reader
                 .into_dimensions()
                 .context("Failed to read image dimensions")?;
 
             tiles.set_original_dimensions(dimensions);
 
-            let mut reader = Self::reader(&path, format)?;
+            let mut reader = Self::reader(&file, format)?;
 
             reader.limits(image_rs::io::Limits::no_limits());
 
@@ -107,7 +105,7 @@ impl ImageRsOther {
     }
 
     fn new_animated(
-        path: PathBuf,
+        file: gio::File,
         format: image_rs::ImageFormat,
         updater: UpdateSender,
         tiles: Arc<ArcSwap<tiling::FrameBuffer>>,
@@ -119,30 +117,30 @@ impl ImageRsOther {
             // We are currently decoding for each repetition of the animation
             // TODO: Check if/how that can be solved differently
             loop {
-                let file = std::fs::File::open(&path)?;
+                let buf_reader = file.to_buf_read()?;
 
                 let (frames, animated_format) = match format {
                     image_rs::ImageFormat::Gif => (
-                        image_rs::codecs::gif::GifDecoder::new(file)?.into_frames(),
+                        image_rs::codecs::gif::GifDecoder::new(buf_reader)?.into_frames(),
                         ImageFormat::AnimatedGif,
                     ),
                     image_rs::ImageFormat::WebP => {
-                        let decoder = image_rs::codecs::webp::WebPDecoder::new(file)?;
+                        let decoder = image_rs::codecs::webp::WebPDecoder::new(buf_reader)?;
                         if decoder.has_animation() {
                             (decoder.into_frames(), ImageFormat::AnimatedWebP)
                         } else {
                             // Static WebP images need a different decoder
-                            Self::new_static(path, format, updater, tiles);
+                            Self::new_static(file, format, updater, tiles);
                             return Ok(());
                         }
                     }
                     image_rs::ImageFormat::Png => {
-                        let decoder = image_rs::codecs::png::PngDecoder::new(file)?;
+                        let decoder = image_rs::codecs::png::PngDecoder::new(buf_reader)?;
                         if decoder.is_apng() {
                             (decoder.apng().into_frames(), ImageFormat::AnimatedPng)
                         } else {
                             // Static PNG images need a different decoder
-                            Self::new_static(path, format, updater, tiles);
+                            Self::new_static(file, format, updater, tiles);
                             return Ok(());
                         }
                     }

src/decoder/formats/svg.rs

@@ -8,7 +8,6 @@ use anyhow::Context;
 use arc_swap::ArcSwap;
 use gtk::prelude::*;
 
-use std::path::PathBuf;
 use std::sync::Arc;
 
 /// Current librsvg limit on maximum dimensions. See
@@ -45,7 +44,7 @@ impl Drop for Svg {
 
 impl Svg {
     pub fn new(
-        path: PathBuf,
+        file: gio::File,
         updater: UpdateSender,
         tiles: Arc<ArcSwap<tiling::FrameBuffer>>,
     ) -> Self {
@@ -53,7 +52,7 @@ impl Svg {
         let request_store = current_request.clone();
 
         let thread_handle = updater.spawn_error_handled(move || {
-            let handle = rsvg::Loader::new().read_path(path)?;
+            let handle = rsvg::Loader::new().read_file(&file, gio::Cancellable::NONE)?;
             let renderer = rsvg::CairoRenderer::new(&handle);
 
             let (original_width, original_height) = svg_dimensions(&renderer);
@@ -85,7 +84,7 @@ impl Svg {
                             tile_size: tiling::TILE_SIZE,
                             original_dimensions: (original_width, original_height),
                             zoom: tile_request.zoom,
-                            bleed: 2,
+                            bleed: 0,
                         };
 
                         let relevant_tiles = tiling.relevant_tiles(&tile_request.viewport);

src/decoder/mod.rs

@@ -7,16 +7,16 @@ pub use formats::ImageDimensionDetails;
 use crate::deps::*;
 use crate::image_metadata::ImageMetadata;
 use crate::util::gettext::*;
+use crate::util::ToBufRead;
 use formats::*;
 use tiling::FrameBufferExt;
 
-use anyhow::{anyhow, bail, Context};
+use anyhow::{anyhow, bail, Context, Result};
 use arc_swap::ArcSwap;
 use futures::channel::mpsc;
 use gio::prelude::*;
 
 use std::io::Read;
-use std::path::PathBuf;
 use std::sync::Arc;
 
 pub use formats::{ImageFormat, RSVG_MAX_SIZE};
@@ -95,13 +95,12 @@ impl Decoder {
         file: gio::File,
         tiles: Arc<ArcSwap<tiling::FrameBuffer>>,
     ) -> anyhow::Result<(Self, mpsc::UnboundedReceiver<DecoderUpdate>)> {
-        let path = file.path().context("Need a file path")?;
         let (sender, receiver) = mpsc::unbounded();
 
         let update_sender = UpdateSender { sender };
         tiles.set_update_sender(update_sender.clone());
 
-        let decoder = gio::spawn_blocking(move || Self::format_decoder(update_sender, path, tiles))
+        let decoder = gio::spawn_blocking(move || Self::format_decoder(update_sender, file, tiles))
             .await
             .map_err(|_| anyhow!("Constructing the FormatDecoder failed unexpectedly"))??;
 
@@ -110,31 +109,23 @@ impl Decoder {
 
     fn format_decoder(
         update_sender: UpdateSender,
-        path: PathBuf,
+        file: gio::File,
         tiles: Arc<ArcSwap<tiling::FrameBuffer>>,
     ) -> anyhow::Result<FormatDecoder> {
-        update_sender.send(DecoderUpdate::Metadata(ImageMetadata::load(&path)));
+        update_sender.send(DecoderUpdate::Metadata(ImageMetadata::load(&file)));
 
-        let mut buf = Vec::new();
+        let format = Self::guess_format(&file)?;
-        let file = std::fs::File::open(&path).context(gettext("Could not open image"))?;
-        file.take(64)
-            .read_to_end(&mut buf)
-            .context(gettext("Could not read image"))?;
 
-        // Try magic bytes first and than file name extension
+        if let Some(format) = format {
-        let format =
-            image_rs::guess_format(&buf).or_else(|_| image_rs::ImageFormat::from_path(&path));
-
-        if let Ok(format) = format {
             match format {
                 image_rs::ImageFormat::Avif => {
                     update_sender.send(DecoderUpdate::Format(ImageFormat::Heif));
-                    return Ok(FormatDecoder::Heif(Heif::new(path, update_sender, tiles)));
+                    return Ok(FormatDecoder::Heif(Heif::new(file, update_sender, tiles)));
                 }
                 format => {
                     update_sender.send(DecoderUpdate::Format(ImageFormat::ImageRs(format)));
                     return Ok(FormatDecoder::ImageRsOther(ImageRsOther::new(
-                        path,
+                        file,
                         format,
                         update_sender,
                         tiles,
@@ -142,7 +133,7 @@ impl Decoder {
                 }
             }
         } else {
-            let file_info = gio::File::for_path(&path)
+            let file_info = file
                 .query_info(
                     gio::FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
                     gio::FileQueryInfoFlags::NONE,
@@ -159,12 +150,12 @@ impl Decoder {
                 // - image/svg+xml-compressed
                 if content_type.split('+').next() == Some("image/svg") {
                     update_sender.send(DecoderUpdate::Format(ImageFormat::Svg));
-                    return Ok(FormatDecoder::Svg(Svg::new(path, update_sender, tiles)));
+                    return Ok(FormatDecoder::Svg(Svg::new(file, update_sender, tiles)));
                 } else if ["image/avif", "image/heif", "image/heic"]
                     .contains(&content_type.as_str())
                 {
                     update_sender.send(DecoderUpdate::Format(ImageFormat::Heif));
-                    return Ok(FormatDecoder::Heif(Heif::new(path, update_sender, tiles)));
+                    return Ok(FormatDecoder::Heif(Heif::new(file, update_sender, tiles)));
                 } else {
                     bail!(gettext_f(
                         "Unknown image format: {}",
@@ -193,4 +184,25 @@ impl Decoder {
             log::error!("Trying to fill frame buffer for decoder without animation support");
         }
     }
+
+    fn guess_format(file: &gio::File) -> anyhow::Result<Option<image_rs::ImageFormat>> {
+        let mut buf = Vec::new();
+        let fs_file = file
+            .to_buf_read()
+            .context(gettext("Could not open image"))?;
+        fs_file
+            .take(64)
+            .read_to_end(&mut buf)
+            .context(gettext("Could not read image"))?;
+
+        // Try magic bytes first and than file name extension
+
+        if let Ok(format) = image_rs::guess_format(&buf) {
+            Ok(Some(format))
+        } else if let Some(basename) = file.basename() {
+            Ok(image_rs::ImageFormat::from_path(basename).ok())
+        } else {
+            Ok(None)
+        }
+    }
 }

src/file_model.rs

@@ -25,7 +25,7 @@ use anyhow::Context;
 use gio::prelude::*;
 use gio::subclass::prelude::*;
 use glib::GString;
-use indexmap::{IndexMap, IndexSet};
+use indexmap::IndexMap;
 use once_cell::sync::{Lazy, OnceCell};
 use std::cell::RefCell;
 
@@ -35,8 +35,8 @@ mod imp {
 
     #[derive(Debug, Default)]
     pub struct LpFileModel {
-        /// Use and IndexSet such that we can put the elements into an arbitrary order
+        /// Use and IndexMap such that we can put the elements into an arbitrary order
-        /// while still having fast hash access via `PathBuf`.
+        /// while still having fast hash access via file URI.
         pub(super) files: RefCell<IndexMap<GString, gio::File>>,
         pub(super) directory: OnceCell<gio::File>,
         /// Track file changes.
@@ -167,7 +167,7 @@ impl LpFileModel {
     }
 
     pub fn before(&self, file: &gio::File) -> Option<gio::File> {
-        let index = self.index_of(&file)?;
+        let index = self.index_of(file)?;
 
         self.imp()
             .files
@@ -188,7 +188,7 @@ impl LpFileModel {
             .cloned()
     }
 
-    /// Returns `n` elements before and after given path
+    /// Returns `n` elements before and after given file
     pub fn files_around(&self, file: &gio::File, n: usize) -> IndexMap<GString, gio::File> {
         let Some(index) = self.index_of(file) else {
             log::error!("URI not in model: {}", file.uri());
@@ -207,12 +207,12 @@ impl LpFileModel {
             .collect()
     }
 
-    /// Return first path
+    /// Return first file
     pub fn first(&self) -> Option<gio::File> {
         self.imp().files.borrow().first().map(|x| x.1).cloned()
     }
 
-    /// Returns last path
+    /// Returns last file
     pub fn last(&self) -> Option<gio::File> {
         self.imp().files.borrow().last().map(|x| x.1).cloned()
     }
@@ -232,7 +232,7 @@ impl LpFileModel {
 
     fn is_image_file(file: &gio::File) -> bool {
         let Ok(info) = util::query_attributes(file, vec![gio::FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE]) else {
-            log::warn!("Could not query file info: {:?}", file.path());
+            log::warn!("Could not query file info: {}", file.uri());
             return false;
         };
 

src/image_metadata/mod.rs

@@ -9,12 +9,11 @@ mod obj;
 pub use gps::GPSLocation;
 pub use obj::LpImageMetadata;
 
-use crate::util;
 use crate::util::gettext::*;
+use crate::util::{self, ToBufRead};
 
-use gtk::glib;
+use crate::deps::*;
-
+use gio::prelude::*;
-use std::path::Path;
 
 #[derive(Default)]
 pub enum ImageMetadata {
@@ -45,10 +44,9 @@ impl std::fmt::Debug for ImageMetadata {
 }
 
 impl ImageMetadata {
-    pub fn load(path: &Path) -> Self {
+    pub fn load(file: &gio::File) -> Self {
-        log::debug!("Loading metadata for {:?}", path);
+        log::debug!("Loading metadata for {}", file.uri());
-        if let Ok(file) = std::fs::File::open(path) {
+        if let Ok(mut bufreader) = file.to_buf_read() {
-            let mut bufreader = std::io::BufReader::new(&file);
             let exifreader = exif::Reader::new();
 
             if let Ok(exif) = exifreader.read_from_container(&mut bufreader) {

src/image_metadata/obj.rs

@@ -7,17 +7,16 @@ use gtk::glib;
 use once_cell::sync::Lazy;
 
 use std::cell::RefCell;
-use std::path::Path;
 
 glib::wrapper! {
     pub struct LpImageMetadata(ObjectSubclass<imp::LpImageMetadata>);
 }
 
 impl LpImageMetadata {
-    pub fn load(path: &Path) -> Self {
+    pub fn load(file: &gio::File) -> Self {
         let obj = glib::Object::new::<Self>();
 
-        let metadata = ImageMetadata::load(path);
+        let metadata = ImageMetadata::load(file);
         obj.imp().metadata.replace(metadata);
 
         obj

src/util/mod.rs

@@ -154,6 +154,25 @@ pub async fn untrash(path: &Path) -> anyhow::Result<()> {
     error
 }
 
+pub trait BufReadSeek: std::io::BufRead + std::io::Seek {}
+
+impl BufReadSeek for std::io::BufReader<gio::InputStreamRead<gio::FileInputStream>> {}
+
+pub trait ToBufRead {
+    fn to_buf_read(&self) -> anyhow::Result<Box<dyn BufReadSeek>>;
+}
+
+impl ToBufRead for gio::File {
+    fn to_buf_read(&self) -> anyhow::Result<Box<dyn BufReadSeek>> {
+        let read = self
+            .read(gio::Cancellable::NONE)
+            .context(gettext("Failed to open image"))?
+            .into_read();
+
+        Ok(Box::new(std::io::BufReader::new(read)))
+    }
+}
+
 #[derive(Debug, Clone, Copy)]
 pub enum Position {
     First,

src/widgets/image.rs

@@ -32,7 +32,6 @@ use crate::deps::*;
 use crate::decoder::tiling::FrameBufferExt;
 use crate::decoder::{self, tiling, Decoder, DecoderUpdate};
 use crate::image_metadata::LpImageMetadata;
-use crate::util::gettext::*;
 use crate::util::Gesture;
 
 use crate::util::spawn;
@@ -43,7 +42,6 @@ use once_cell::sync::Lazy;
 use once_cell::unsync::OnceCell;
 
 use std::cell::{Cell, RefCell};
-use std::path::PathBuf;
 use std::sync::Arc;
 
 /// Default background color around images and behind transparent images
@@ -107,7 +105,6 @@ mod imp {
     #[derive(Debug, Default)]
     pub struct LpImage {
         pub(super) file: RefCell<Option<gio::File>>,
-        pub(super) path: RefCell<Option<PathBuf>>,
         pub(super) is_deleted: Cell<bool>,
         /// Track changes to this image
         pub(super) file_monitor: RefCell<Option<gio::FileMonitor>>,
@@ -194,9 +191,6 @@ mod imp {
                     glib::ParamSpecObject::builder::<gio::File>("file")
                         .read_only()
                         .build(),
-                    glib::ParamSpecVariant::builder("path", glib::VariantTy::BYTE_STRING)
-                        .read_only()
-                        .build(),
                     glib::ParamSpecBoolean::builder("is-deleted")
                         .read_only()
                         .build(),
@@ -242,7 +236,6 @@ mod imp {
             let obj = self.obj();
             match pspec.name() {
                 "file" => obj.file().to_value(),
-                "path" => obj.path().to_variant().to_value(),
                 "is-deleted" => obj.is_deleted().to_value(),
                 "is-loaded" => obj.is_loaded().to_value(),
                 "error" => obj.error().to_value(),
@@ -743,15 +736,9 @@ glib::wrapper! {
 
 impl LpImage {
     pub async fn load(&self, file: &gio::File) {
-        let path = file.path().unwrap();
+        log::debug!("Loading file {}", file.uri());
-        self.set_file(&file);
 
-        if !path.is_file() {
+        self.set_file(file);
-            self.set_error(anyhow::Error::msg(gettext("File does not exist")));
-            return;
-        }
-
-        log::debug!("Loading file {path:?}");
 
         let tiles = &self.imp().frame_buffer;
 
@@ -920,16 +907,10 @@ impl LpImage {
         self.imp().file.borrow().clone()
     }
 
-    pub fn path(&self) -> Option<PathBuf> {
-        self.imp().path.borrow().clone()
-    }
-
     pub(super) fn set_file(&self, file: &gio::File) {
         let imp = self.imp();
 
         imp.file.replace(Some(file.clone()));
-        imp.path.replace(file.path());
-        self.notify("path");
 
         let monitor = file.monitor_file(gio::FileMonitorFlags::WATCH_MOVES, gio::Cancellable::NONE);
         if let Ok(m) = &monitor {
@@ -953,7 +934,7 @@ impl LpImage {
         match event {
             gio::FileMonitorEvent::Renamed => {
                 if let Some(file) = file_b {
-                    log::debug!("Moved to {:?}", file.path());
+                    log::debug!("Moved to {}", file.uri());
                     self.set_file(file);
                 }
             }

src/widgets/image_page.rs

@@ -31,8 +31,6 @@ use gtk::prelude::*;
 use gtk::CompositeTemplate;
 use once_cell::sync::Lazy;
 
-use std::path::PathBuf;
-
 mod imp {
     use super::*;
 
@@ -151,7 +149,7 @@ impl LpImagePage {
     pub fn from_file(file: &gio::File) -> Self {
         let obj = glib::Object::new::<Self>();
 
-        obj.imp().image.set_file(&file);
+        obj.imp().image.set_file(file);
 
         spawn(clone!(@weak obj, @strong file => async move {
             let imp = obj.imp();

src/widgets/image_view.rs

@@ -44,7 +44,6 @@ use gtk::CompositeTemplate;
 use once_cell::sync::Lazy;
 
 use std::cell::{Cell, RefCell};
-use std::path::{Path, PathBuf};
 
 // The number of pages we want to buffer
 // on either side of the current page.
@@ -139,7 +138,7 @@ mod imp {
 
             let view = &*obj;
             signal_group.connect_closure(
-                "notify::path",
+                "notify::file",
                 true,
                 glib::closure_local!(@watch view => move |_: LpImage, _: glib::ParamSpec| {
                     view.current_image_path_changed();
@@ -333,7 +332,7 @@ impl LpImageView {
             .and_then(|x| self.model().index_of(&x))
             .unwrap_or_default();
 
-        let page = if let Some(page) = sliding_view.get(&new_file) {
+        let page = if let Some(page) = sliding_view.get(new_file) {
             page
         } else {
             let page = LpImagePage::from_file(new_file);
@@ -362,22 +361,22 @@ impl LpImageView {
 
         self.imp().preserve_content.set(false);
 
-        let existing = dbg!(sliding_view.pages());
+        let existing = sliding_view.pages();
-        let target = dbg!(self.model().files_around(current_file, BUFFER));
+        let target = self.model().files_around(current_file, BUFFER);
 
         // remove old pages
         for (uri, page) in &existing {
             if !target.contains_key(uri) {
-                sliding_view.remove(dbg!(page));
+                sliding_view.remove(page);
             }
         }
 
         // add missing pages or put in correct position
         for (position, (_, file)) in target.iter().enumerate() {
             if let Some(page) = existing.get(&file.uri()) {
-                sliding_view.move_to(page, dbg!(position));
+                sliding_view.move_to(page, position);
             } else {
-                sliding_view.insert(&LpImagePage::from_file(file), dbg!(position));
+                sliding_view.insert(&LpImagePage::from_file(file), position);
             }
         }
 

src/widgets/sliding_view.rs

@@ -11,7 +11,6 @@ use indexmap::IndexMap;
 use once_cell::sync::{Lazy, OnceCell};
 
 use std::cell::{Cell, RefCell};
-//use std::path::{Path, PathBuf};
 
 static SCROLL_DAMPING_RATIO: f64 = 1.;
 static SCROLL_MASS: f64 = 0.5;

src/window.rs

@@ -678,9 +678,9 @@ impl LpWindow {
     // have multiple `match` or `if let` branches, and without needing
     // to unwrap.
     #[template_callback]
-    fn window_title(&self, path: glib::variant::Variant) -> String {
+    fn window_title(&self, file: Option<&gio::File>) -> String {
         // ensure that templates are initialized
-        if path.as_maybe().is_none() {
+        if file.is_none() {
             gettext("Loupe")
         } else {
             self.imp()