Merge pull request #116 from narrrl/perf/photos-main-thread

perf(gui): keep Photos decoding and file access off the main thread
This commit is contained in:
nvrl authored and GitHub committed 2026-11-20 20:57:38 +01:00
commit 2ad0bad09c
7 files changed
+702 -143

No files matched your search

-1
View File
@@ -154,7 +154,6 @@ fn follow_changes(ui: &Rc<Ui>, state: &FeedState, topics: &[Topic]) {
ui.gallery.decode_queue.borrow_mut().clear(); ui.gallery.decode_queue.borrow_mut().clear();
ui.gallery.thumb_wanted.borrow_mut().clear(); ui.gallery.thumb_wanted.borrow_mut().clear();
ui.gallery.photo_tex.borrow_mut().clear(); ui.gallery.photo_tex.borrow_mut().clear();
ui.gallery.photo_tex_order.borrow_mut().clear();
ui.gallery.model.remove_all(); ui.gallery.model.remove_all();
ui.gallery.groups.remove_all(); ui.gallery.groups.remove_all();
ui.gallery.row_by_photo.borrow_mut().clear(); ui.gallery.row_by_photo.borrow_mut().clear();
+248
View File
@@ -0,0 +1,248 @@
//! A least-recently-used cache with a cost budget.
//!
//! Each entry carries a cost (bytes for a texture cache, `1` for a cache capped
//! by count). Inserting past the budget drops the entries used longest ago.
//! Lookups and touches are logarithmic, so a cache of a few thousand textures
//! can be touched on every tile bind without a linear scan.
use std::borrow::Borrow;
use std::collections::{BTreeMap, HashMap};
use std::hash::Hash;
struct Entry<V> {
value: V,
cost: usize,
stamp: u64,
}
pub(crate) struct Lru<K, V> {
entries: HashMap<K, Entry<V>>,
/// Entries by the stamp of their last use, oldest first.
order: BTreeMap<u64, K>,
next: u64,
used: usize,
budget: usize,
}
impl<K: Eq + Hash + Clone, V> Lru<K, V> {
pub(crate) fn new(budget: usize) -> Self {
Self {
entries: HashMap::new(),
order: BTreeMap::new(),
next: 0,
used: 0,
budget,
}
}
/// Look an entry up without marking it used.
pub(crate) fn get<Q>(&self, key: &Q) -> Option<&V>
where
K: Borrow<Q>,
Q: Eq + Hash + ?Sized,
{
self.entries.get(key).map(|entry| &entry.value)
}
pub(crate) fn contains_key<Q>(&self, key: &Q) -> bool
where
K: Borrow<Q>,
Q: Eq + Hash + ?Sized,
{
self.entries.contains_key(key)
}
/// Mark an entry as just used, so it is the last to be evicted. Returns
/// whether it was there.
pub(crate) fn touch<Q>(&mut self, key: &Q) -> bool
where
K: Borrow<Q>,
Q: Eq + Hash + ?Sized,
{
let stamp = self.next;
let Some(entry) = self.entries.get_mut(key) else {
return false;
};
if let Some(held) = self.order.remove(&entry.stamp) {
self.order.insert(stamp, held);
}
entry.stamp = stamp;
self.next += 1;
true
}
/// Look an entry up and mark it used.
pub(crate) fn fetch<Q>(&mut self, key: &Q) -> Option<&V>
where
K: Borrow<Q>,
Q: Eq + Hash + ?Sized,
{
if !self.touch(key) {
return None;
}
self.get(key)
}
/// Store `value` as the most recently used entry, then evict the least
/// recently used ones until the total cost fits the budget again. The new
/// entry itself is never evicted, even when it alone is over budget.
pub(crate) fn insert(&mut self, key: K, value: V, cost: usize) {
self.remove(&key);
let stamp = self.next;
self.next += 1;
self.order.insert(stamp, key.clone());
self.entries.insert(key, Entry { value, cost, stamp });
self.used += cost;
while self.used > self.budget && self.order.len() > 1 {
let Some((_, oldest)) = self.order.pop_first() else {
break;
};
if let Some(entry) = self.entries.remove(&oldest) {
self.used -= entry.cost;
}
}
}
pub(crate) fn remove<Q>(&mut self, key: &Q) -> Option<V>
where
K: Borrow<Q>,
Q: Eq + Hash + ?Sized,
{
let entry = self.entries.remove(key)?;
self.order.remove(&entry.stamp);
self.used -= entry.cost;
Some(entry.value)
}
/// Keep only the entries `keep` accepts.
pub(crate) fn retain(&mut self, mut keep: impl FnMut(&K, &V) -> bool) {
let order = &mut self.order;
let used = &mut self.used;
self.entries.retain(|key, entry| {
let kept = keep(key, &entry.value);
if !kept {
order.remove(&entry.stamp);
*used -= entry.cost;
}
kept
});
}
pub(crate) fn clear(&mut self) {
self.entries.clear();
self.order.clear();
self.used = 0;
}
#[cfg(test)]
pub(crate) fn len(&self) -> usize {
self.entries.len()
}
#[cfg(test)]
pub(crate) fn used(&self) -> usize {
self.used
}
}
#[cfg(test)]
mod tests {
use super::Lru;
#[test]
fn evicts_least_recently_used_past_budget() {
let mut cache = Lru::new(3);
cache.insert("a", 1, 1);
cache.insert("b", 2, 1);
cache.insert("c", 3, 1);
assert!(cache.touch("a"));
cache.insert("d", 4, 1);
assert!(cache.contains_key("a"));
assert!(!cache.contains_key("b"));
assert!(cache.contains_key("c"));
assert!(cache.contains_key("d"));
assert_eq!(cache.len(), 3);
}
#[test]
fn budget_counts_cost_not_entries() {
let mut cache = Lru::new(100);
cache.insert("small", (), 10);
cache.insert("medium", (), 40);
cache.insert("large", (), 60);
// 110 > 100: the oldest goes, and that is enough.
assert!(!cache.contains_key("small"));
assert_eq!(cache.used(), 100);
cache.insert("huge", (), 90);
assert_eq!(cache.used(), 90);
assert_eq!(cache.len(), 1);
}
#[test]
fn keeps_a_single_entry_over_budget() {
let mut cache = Lru::new(10);
cache.insert("a", (), 5);
cache.insert("big", (), 50);
assert!(cache.contains_key("big"));
assert!(!cache.contains_key("a"));
assert_eq!(cache.used(), 50);
}
#[test]
fn remove_and_clear_keep_cost_in_step() {
let mut cache = Lru::new(100);
cache.insert("a", (), 10);
cache.insert("b", (), 20);
assert_eq!(cache.remove("a"), Some(()));
assert_eq!(cache.used(), 20);
cache.clear();
assert_eq!(cache.used(), 0);
assert_eq!(cache.len(), 0);
}
#[test]
fn reinsert_replaces_cost_and_refreshes() {
let mut cache = Lru::new(30);
cache.insert("a", 1, 10);
cache.insert("b", 2, 10);
cache.insert("a", 3, 15);
assert_eq!(cache.used(), 25);
assert_eq!(cache.get("a"), Some(&3));
cache.insert("c", 4, 10);
// "b" was used longest ago now.
assert!(!cache.contains_key("b"));
assert!(cache.contains_key("a"));
}
#[test]
fn fetch_touches_and_get_does_not() {
let mut cache = Lru::new(2);
cache.insert("a", 1, 1);
cache.insert("b", 2, 1);
assert_eq!(cache.get("a"), Some(&1));
cache.insert("c", 3, 1);
assert!(!cache.contains_key("a"));
assert_eq!(cache.fetch("b"), Some(&2));
cache.insert("d", 4, 1);
assert!(cache.contains_key("b"));
assert!(!cache.contains_key("c"));
assert_eq!(cache.fetch("missing"), None);
}
#[test]
fn retain_drops_rejected_entries_and_their_cost() {
let mut cache = Lru::new(100);
cache.insert((true, "a".to_string()), (), 10);
cache.insert((false, "b".to_string()), (), 20);
cache.insert((true, "c".to_string()), (), 30);
cache.retain(|(private, _), _| !private);
assert_eq!(cache.used(), 20);
assert_eq!(cache.len(), 1);
assert!(cache.remove(&(false, "b".to_string())).is_some());
assert_eq!(cache.used(), 0);
cache.insert((true, "d".to_string()), (), 10);
cache.clear();
assert_eq!(cache.used(), 0);
assert_eq!(cache.len(), 0);
}
}
+14 -20
View File
@@ -6,6 +6,7 @@ pub(crate) mod dates;
pub(crate) mod events; pub(crate) mod events;
#[path = "../i18n.rs"] #[path = "../i18n.rs"]
pub(crate) mod i18n; pub(crate) mod i18n;
pub(crate) mod lru;
pub(crate) mod pages; pub(crate) mod pages;
pub(crate) mod reload; pub(crate) mod reload;
#[path = "../theme.rs"] #[path = "../theme.rs"]
@@ -15,6 +16,7 @@ pub(crate) mod widgets;
use compat::*; use compat::*;
use events::*; use events::*;
use lru::Lru;
use pages::activity::*; use pages::activity::*;
use pages::albums::*; use pages::albums::*;
use pages::browser::*; use pages::browser::*;
@@ -190,16 +192,11 @@ impl Ui {
/// Scrolling back over a day then repaints from memory rather than decoding /// Scrolling back over a day then repaints from memory rather than decoding
/// the same JPEGs off disk again. /// the same JPEGs off disk again.
fn store_texture(&self, uid: &str, texture: gtk4::gdk::Texture) { fn store_texture(&self, uid: &str, texture: gtk4::gdk::Texture) {
let mut cache = self.gallery.photo_tex.borrow_mut(); let bytes = texture_bytes(texture.width(), texture.height());
let mut order = self.gallery.photo_tex_order.borrow_mut(); self.gallery
if cache.insert(uid.to_string(), texture).is_none() { .photo_tex
order.push_back(uid.to_string()); .borrow_mut()
} .insert(uid.to_string(), texture, bytes);
while order.len() > TEXTURE_CACHE_MAX {
if let Some(old) = order.pop_front() {
cache.remove(&old);
}
}
} }
/// Mark a cached thumbnail as freshly used, so eviction takes the tiles /// Mark a cached thumbnail as freshly used, so eviction takes the tiles
@@ -208,14 +205,7 @@ impl Ui {
/// Insertion order alone evicts the top of the timeline first — exactly what /// Insertion order alone evicts the top of the timeline first — exactly what
/// a scroll back up then asks for again. /// a scroll back up then asks for again.
fn touch_texture(&self, uid: &str) { fn touch_texture(&self, uid: &str) {
let mut order = self.gallery.photo_tex_order.borrow_mut(); self.gallery.photo_tex.borrow_mut().touch(uid);
if order.back().is_some_and(|back| back == uid) {
return;
}
if let Some(at) = order.iter().position(|held| held == uid) {
order.remove(at);
order.push_back(uid.to_string());
}
} }
} }
@@ -631,8 +621,7 @@ fn build_window(app: &adw::Application) {
library: Cell::new(true), library: Cell::new(true),
page_waiters: RefCell::new(Vec::new()), page_waiters: RefCell::new(Vec::new()),
width: Cell::new(0), width: Cell::new(0),
photo_tex: RefCell::new(HashMap::new()), photo_tex: RefCell::new(Lru::new(TEXTURE_CACHE_BYTES)),
photo_tex_order: RefCell::new(VecDeque::new()),
photo_nothumb: RefCell::new(HashSet::new()), photo_nothumb: RefCell::new(HashSet::new()),
thumb_wanted: RefCell::new(HashMap::new()), thumb_wanted: RefCell::new(HashMap::new()),
thumb_queue: RefCell::new(VecDeque::new()), thumb_queue: RefCell::new(VecDeque::new()),
@@ -640,6 +629,7 @@ fn build_window(app: &adw::Application) {
thumb_generation: Cell::new(0), thumb_generation: Cell::new(0),
decode_queue: RefCell::new(VecDeque::new()), decode_queue: RefCell::new(VecDeque::new()),
decode_idle: Cell::new(false), decode_idle: Cell::new(false),
decode_inflight: RefCell::default(),
thumb_source: RefCell::new(None), thumb_source: RefCell::new(None),
relayout_source: RefCell::new(None), relayout_source: RefCell::new(None),
bound: RefCell::new(BTreeMap::new()), bound: RefCell::new(BTreeMap::new()),
@@ -738,6 +728,10 @@ fn build_window(app: &adw::Application) {
resume_button: takeout_widgets.resume_button.clone(), resume_button: takeout_widgets.resume_button.clone(),
inflight: Cell::new(false), inflight: Cell::new(false),
running: Cell::new(false), running: Cell::new(false),
restored: Cell::new(false),
save_seq: Cell::new(0),
saved_seq: Default::default(),
repaint_seq: Cell::new(0),
}, },
update, update,
}); });
+106 -29
View File
@@ -1,10 +1,32 @@
use crate::*; use crate::*;
use base64::{Engine, engine::general_purpose::STANDARD}; use base64::{Engine, engine::general_purpose::STANDARD};
use pdfs_core::control::{GalleryAction, GalleryAlbum, GalleryFolder, GalleryPlace}; use pdfs_core::control::{GalleryAction, GalleryAlbum, GalleryFolder, GalleryPlace};
use std::collections::VecDeque;
const PAGE: usize = 150; const PAGE: usize = 150;
/// Decoded thumbnails kept, the least recently shown dropped first.
const THUMB_CACHE: usize = 256; const THUMB_CACHE: usize = 256;
/// What a new content width asks of the rows.
#[derive(Debug, PartialEq, Eq)]
enum Reflow {
/// Nothing changed, or there is no width yet.
None,
/// The first real width: lay the rows out now, nothing is on screen yet.
Now,
/// A resize: wait for it to settle, since the rows are rebuilt from
/// scratch and a drag resizes on every frame.
Debounced,
}
fn reflow_for(previous: i32, width: i32) -> Reflow {
if width <= 0 || width == previous {
Reflow::None
} else if previous <= 0 {
Reflow::Now
} else {
Reflow::Debounced
}
}
type ThumbnailKey = (u64, bool, String); type ThumbnailKey = (u64, bool, String);
type ThumbnailTarget = (glib::WeakRef<gtk4::Picture>, glib::WeakRef<gtk4::Image>); type ThumbnailTarget = (glib::WeakRef<gtk4::Picture>, glib::WeakRef<gtk4::Image>);
@@ -45,12 +67,15 @@ pub(crate) struct Browser {
albums: RefCell<Vec<GalleryAlbum>>, albums: RefCell<Vec<GalleryAlbum>>,
items: RefCell<Vec<PhotoItem>>, items: RefCell<Vec<PhotoItem>>,
width: Cell<i32>, width: Cell<i32>,
/// The pending re-flow after a resize, replaced by each new width.
reflow: RefCell<Option<glib::SourceId>>,
generation: Cell<u64>, generation: Cell<u64>,
total: Cell<usize>, total: Cell<usize>,
loading: Cell<bool>, loading: Cell<bool>,
unlocked: Cell<bool>, unlocked: Cell<bool>,
thumbnail_slots: tokio::sync::Semaphore, thumbnail_slots: tokio::sync::Semaphore,
thumbnails: RefCell<VecDeque<(bool, String, gtk4::gdk::Texture)>>, /// Decoded thumbnails by whether they are hidden-album ones and uid.
thumbnails: RefCell<Lru<(bool, String), gtk4::gdk::Texture>>,
thumb_pending: RefCell<HashMap<ThumbnailKey, Vec<ThumbnailTarget>>>, thumb_pending: RefCell<HashMap<ThumbnailKey, Vec<ThumbnailTarget>>>,
} }
@@ -86,7 +111,7 @@ impl Browser {
} }
self.thumbnails self.thumbnails
.borrow_mut() .borrow_mut()
.retain(|(private, _, _)| !private); .retain(|(private, _), _| !private);
self.thumb_pending.borrow_mut().clear(); self.thumb_pending.borrow_mut().clear();
self.trail.borrow_mut().clear(); self.trail.borrow_mut().clear();
self.chooser.borrow_mut().take(); self.chooser.borrow_mut().take();
@@ -602,6 +627,13 @@ impl Browser {
let generation = self.generation.get(); let generation = self.generation.get();
glib::spawn_future_local(async move { glib::spawn_future_local(async move {
let result = reply.recv().await; let result = reply.recv().await;
// Decoded before the checks below, so they see the state after it.
let decoded = match &result {
Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) if private => {
decode_thumbnail_off_thread(data.clone()).await
}
_ => None,
};
let close = |token| { let close = |token| {
let _ = spawn_request( let _ = spawn_request(
browser.ui.dirs.control_socket(), browser.ui.dirs.control_socket(),
@@ -646,8 +678,8 @@ impl Browser {
picture.set_vexpand(true); picture.set_vexpand(true);
content.append(&picture); content.append(&picture);
} }
Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) if private => { Ok(Ok(Response::GalleryThumbnail { data: Some(_) })) if private => {
let Some(texture) = decode_thumbnail(&data) else { let Some(texture) = decoded else {
browser browser
.status .status
.set_label(&gettext("Couldn't open the photo.")); .set_label(&gettext("Couldn't open the photo."));
@@ -744,12 +776,13 @@ pub(crate) fn wire(
albums: RefCell::new(Vec::new()), albums: RefCell::new(Vec::new()),
items: RefCell::new(Vec::new()), items: RefCell::new(Vec::new()),
width: Cell::new(0), width: Cell::new(0),
reflow: RefCell::new(None),
generation: Cell::new(0), generation: Cell::new(0),
total: Cell::new(0), total: Cell::new(0),
loading: Cell::new(false), loading: Cell::new(false),
unlocked: Cell::new(false), unlocked: Cell::new(false),
thumbnail_slots: tokio::sync::Semaphore::new(8), thumbnail_slots: tokio::sync::Semaphore::new(8),
thumbnails: RefCell::default(), thumbnails: RefCell::new(Lru::new(THUMB_CACHE)),
thumb_pending: RefCell::default(), thumb_pending: RefCell::default(),
}); });
*ui.drive_galleries.borrow_mut() = Rc::downgrade(&browser); *ui.drive_galleries.borrow_mut() = Rc::downgrade(&browser);
@@ -999,8 +1032,27 @@ pub(crate) fn wire(
return glib::ControlFlow::Break; return glib::ControlFlow::Break;
}; };
let width = scroll.width(); let width = scroll.width();
if width > 0 && browser.width.replace(width) != width { match reflow_for(browser.width.get(), width) {
browser.rebuild(); Reflow::None => {}
Reflow::Now => {
browser.width.set(width);
browser.rebuild();
}
Reflow::Debounced => {
browser.width.set(width);
if let Some(source) = browser.reflow.borrow_mut().take() {
source.remove();
}
let weak = Rc::downgrade(&browser);
let source =
glib::timeout_add_local_once(super::photos::RELAYOUT_DEBOUNCE, move || {
if let Some(browser) = weak.upgrade() {
browser.reflow.borrow_mut().take();
browser.rebuild();
}
});
*browser.reflow.borrow_mut() = Some(source);
}
} }
glib::ControlFlow::Continue glib::ControlFlow::Continue
} }
@@ -1088,6 +1140,15 @@ fn decode_thumbnail(data: &str) -> Option<gtk4::gdk::Texture> {
gtk4::gdk::Texture::from_bytes(&glib::Bytes::from_owned(bytes)).ok() gtk4::gdk::Texture::from_bytes(&glib::Bytes::from_owned(bytes)).ok()
} }
/// [`decode_thumbnail`] on gio's blocking pool, so neither the base64 nor the
/// image decoder runs on the GTK thread.
async fn decode_thumbnail_off_thread(data: String) -> Option<gtk4::gdk::Texture> {
gio::spawn_blocking(move || decode_thumbnail(&data))
.await
.ok()
.flatten()
}
impl Browser { impl Browser {
fn want_thumbnail( fn want_thumbnail(
self: &Rc<Self>, self: &Rc<Self>,
@@ -1099,20 +1160,17 @@ impl Browser {
if private && !self.unlocked.get() { if private && !self.unlocked.get() {
return; return;
} }
{ let cached = self
let mut cache = self.thumbnails.borrow_mut(); .thumbnails
if let Some(index) = cache .borrow_mut()
.iter() .fetch(&(private, uid.to_owned()))
.position(|(p, id, _)| *p == private && id == uid) .cloned();
{ if let Some(texture) = cached {
let cached = cache.remove(index).unwrap(); picture.set_paintable(Some(&texture));
picture.set_paintable(Some(&cached.2)); if let Some(icon) = icon.upgrade() {
if let Some(icon) = icon.upgrade() { icon.set_visible(false);
icon.set_visible(false);
}
cache.push_back(cached);
return;
} }
return;
} }
let key = (self.generation.get(), private, uid.to_owned()); let key = (self.generation.get(), private, uid.to_owned());
{ {
@@ -1151,6 +1209,12 @@ impl Browser {
}, },
); );
let response = request.recv().await; let response = request.recv().await;
let texture = match response {
Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) => {
decode_thumbnail_off_thread(data).await
}
_ => None,
};
let targets = browser let targets = browser
.thumb_pending .thumb_pending
.borrow_mut() .borrow_mut()
@@ -1159,9 +1223,7 @@ impl Browser {
if key.0 != browser.generation.get() || private && !browser.unlocked.get() { if key.0 != browser.generation.get() || private && !browser.unlocked.get() {
return; return;
} }
if let Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) = response if let Some(texture) = texture {
&& let Some(texture) = decode_thumbnail(&data)
{
for (picture, icon) in targets { for (picture, icon) in targets {
if let Some(picture) = picture.upgrade() { if let Some(picture) = picture.upgrade() {
picture.set_paintable(Some(&texture)); picture.set_paintable(Some(&texture));
@@ -1170,12 +1232,27 @@ impl Browser {
icon.set_visible(false); icon.set_visible(false);
} }
} }
let mut cache = browser.thumbnails.borrow_mut(); // Capped by count, like before: every entry costs one.
if cache.len() >= THUMB_CACHE { browser
cache.pop_front(); .thumbnails
} .borrow_mut()
cache.push_back((private, key.2, texture)); .insert((private, key.2), texture, 1);
} }
}); });
} }
} }
#[cfg(test)]
mod tests {
use super::{Reflow, reflow_for};
#[test]
fn the_first_width_lays_out_at_once_and_a_resize_waits() {
assert_eq!(reflow_for(0, 0), Reflow::None);
assert_eq!(reflow_for(0, 800), Reflow::Now);
assert_eq!(reflow_for(800, 800), Reflow::None);
assert_eq!(reflow_for(800, 760), Reflow::Debounced);
// A collapsed widget reports no width; keep the last layout.
assert_eq!(reflow_for(800, 0), Reflow::None);
}
}
+133 -70
View File
@@ -160,11 +160,10 @@ pub(crate) struct GalleryState {
/// Content width the grid is currently laid out to. Updated when the /// Content width the grid is currently laid out to. Updated when the
/// ListView is resized, which re-flows the visible sections. /// ListView is resized, which re-flows the visible sections.
pub(crate) width: Cell<i32>, pub(crate) width: Cell<i32>,
/// Decoded thumbnails by photo uid, with the insertion order that evicts the /// Decoded thumbnails by photo uid, the least recently used evicted once
/// oldest past [`TEXTURE_CACHE_MAX`]. Scrolling back over a day therefore /// their pixels pass [`TEXTURE_CACHE_BYTES`]. Scrolling back over a day
/// repaints from memory instead of re-decoding from disk. /// therefore repaints from memory instead of re-decoding from disk.
pub(crate) photo_tex: RefCell<HashMap<String, gtk4::gdk::Texture>>, pub(crate) photo_tex: RefCell<Lru<String, gtk4::gdk::Texture>>,
pub(crate) photo_tex_order: RefCell<VecDeque<String>>,
/// Photos the daemon reported as having no thumbnail at all, so a tile that /// Photos the daemon reported as having no thumbnail at all, so a tile that
/// can never be filled isn't requested again on every scroll past it. /// can never be filled isn't requested again on every scroll past it.
pub(crate) photo_nothumb: RefCell<HashSet<String>>, pub(crate) photo_nothumb: RefCell<HashSet<String>>,
@@ -186,12 +185,14 @@ pub(crate) struct GalleryState {
pub(crate) thumb_inflight: RefCell<HashSet<String>>, pub(crate) thumb_inflight: RefCell<HashSet<String>>,
pub(crate) thumb_generation: Cell<u64>, pub(crate) thumb_generation: Cell<u64>,
/// Thumbnails on disk waiting to be turned into textures, as `(uid, path)`. /// Thumbnails on disk waiting to be turned into textures, as `(uid, path)`.
/// Decoding happens on the GTK thread (textures are not `Send`), so it is fed /// [`schedule_decode`] decodes them on worker threads a few at a time, so
/// a few at a time from an idle callback rather than in one blocking burst /// the scroll never waits on a JPEG decoder. [`Self::decode_idle`] is the
/// that would stutter the scroll. [`Self::decode_idle`] is the "callback /// "decoder already running" guard, and [`Self::decode_inflight`] the uids
/// already scheduled" guard. /// being decoded right now, so a tile rebound meanwhile doesn't queue its
/// photo a second time.
pub(crate) decode_queue: RefCell<VecDeque<(String, String)>>, pub(crate) decode_queue: RefCell<VecDeque<(String, String)>>,
pub(crate) decode_idle: Cell<bool>, pub(crate) decode_idle: Cell<bool>,
pub(crate) decode_inflight: RefCell<HashSet<String>>,
/// Pending debounce timers for the thumbnail queue flush and the section /// Pending debounce timers for the thumbnail queue flush and the section
/// re-flow, replaced on each new trigger so only the last one fires. /// re-flow, replaced on each new trigger so only the last one fires.
pub(crate) thumb_source: RefCell<Option<glib::SourceId>>, pub(crate) thumb_source: RefCell<Option<glib::SourceId>>,
@@ -351,11 +352,23 @@ pub(crate) const THUMB_DEBOUNCE: Duration = Duration::from_millis(60);
/// in seconds, not milliseconds. /// in seconds, not milliseconds.
pub(crate) const THUMB_RETRY: Duration = Duration::from_secs(4); pub(crate) const THUMB_RETRY: Duration = Duration::from_secs(4);
/// Decoded thumbnails held in memory, evicted least-recently-*used* first. Each /// Decoded thumbnail pixels held in memory, evicted least-recently-*used*
/// is a few hundred KiB of GPU texture, and at the justified row density 600 was /// first. Budgeted by bytes rather than by count, because one oversized
/// under two screens' worth — a scroll down and back up then had to re-fetch and /// thumbnail costs as much as dozens of ordinary ones. A 512 px thumbnail is
/// re-decode everything it had just shown. /// about 600 KiB decoded, so this holds roughly 900 of them: at the justified
pub(crate) const TEXTURE_CACHE_MAX: usize = 1500; /// row density 600 was under two screens' worth, and a scroll down and back up
/// then had to re-fetch and re-decode everything it had just shown.
pub(crate) const TEXTURE_CACHE_BYTES: usize = 512 * 1024 * 1024;
/// What a decoded texture costs [`TEXTURE_CACHE_BYTES`]: four bytes a pixel.
pub(crate) fn texture_bytes(width: i32, height: i32) -> usize {
let width = usize::try_from(width).unwrap_or(0);
let height = usize::try_from(height).unwrap_or(0);
width.saturating_mul(height).saturating_mul(4).max(1)
}
/// How many thumbnails [`schedule_decode`] decodes at once.
const DECODE_BATCH: usize = 4;
/// How many tiles beyond the realised rows [`prefetch_thumbs`] warms, so a tile /// How many tiles beyond the realised rows [`prefetch_thumbs`] warms, so a tile
/// is decoded before it is scrolled onto rather than after. /// is decoded before it is scrolled onto rather than after.
@@ -3260,6 +3273,7 @@ pub(crate) fn want_thumb(ui: &Rc<Ui>, photo: &PhotoItem, picture: &gtk4::Picture
let mut decode = ui.gallery.decode_queue.borrow_mut(); let mut decode = ui.gallery.decode_queue.borrow_mut();
if decode.iter().any(|(uid, _)| uid == &photo.uid) if decode.iter().any(|(uid, _)| uid == &photo.uid)
|| ui.gallery.decode_inflight.borrow().contains(&photo.uid)
|| ui.gallery.thumb_inflight.borrow().contains(&photo.uid) || ui.gallery.thumb_inflight.borrow().contains(&photo.uid)
{ {
return; return;
@@ -3451,9 +3465,16 @@ fn prefetch_thumbs(ui: &Rc<Ui>, mut batch: Vec<String>) -> Vec<String> {
batch batch
} }
/// Decode queued thumbnails into textures on an idle callback, a few per pass, so /// Decode queued thumbnails into textures on worker threads, a few at a time,
/// a big batch fills in progressively instead of freezing the scroll for the /// and hand each finished texture to the tiles still waiting for it.
/// length of the whole decode. ///
/// Decoding a JPEG takes milliseconds; four of them per idle pass on the GTK
/// thread were enough to stutter a scroll. The main thread now only picks the
/// next batch (visible tiles first) and paints what comes back. A batch that
/// lands after the timeline was reset is dropped, and a tile that was rebound
/// or unbound meanwhile is no longer in [`GalleryState::thumb_wanted`], so it
/// is not painted. [`GalleryState::decode_idle`] is the "decoder running"
/// guard.
pub(crate) fn schedule_decode(ui: &Rc<Ui>) { pub(crate) fn schedule_decode(ui: &Rc<Ui>) {
if ui.gallery.decode_idle.get() || ui.gallery.decode_queue.borrow().is_empty() { if ui.gallery.decode_idle.get() || ui.gallery.decode_queue.borrow().is_empty() {
return; return;
@@ -3461,63 +3482,95 @@ pub(crate) fn schedule_decode(ui: &Rc<Ui>) {
ui.gallery.decode_idle.set(true); ui.gallery.decode_idle.set(true);
let ui = ui.clone(); let ui = ui.clone();
glib::idle_add_local(move || { glib::spawn_future_local(async move {
let batch: Vec<(String, String)> = { loop {
let mut queue = ui.gallery.decode_queue.borrow_mut(); let batch = next_decode_batch(&ui);
let wanted = ui.gallery.thumb_wanted.borrow(); if batch.is_empty() {
let list = &ui.gallery.list; break;
let visible = |uid: &str| {
wanted.get(uid).is_some_and(|pictures| {
pictures.iter().any(|picture| {
if !picture.is_mapped() {
return false;
}
!picture.is_ancestor(list)
|| picture.compute_bounds(list).is_some_and(|bounds| {
bounds.y() + bounds.height() > 0.0
&& bounds.y() < list.height() as f32
})
})
})
};
queue.retain(|(uid, _)| wanted.contains_key(uid));
(0..4)
.filter_map(|_| {
queue
.iter()
.position(|(uid, _)| visible(uid))
.and_then(|index| queue.remove(index))
.or_else(|| queue.pop_front())
})
.collect()
};
for (uid, path) in batch {
if ui.gallery.photo_tex.borrow().contains_key(&uid) {
continue;
} }
let texture = match gtk4::gdk::Texture::from_filename(&path) { let generation = ui.gallery.thumb_generation.get();
Ok(texture) => texture, ui.gallery
Err(e) => { .decode_inflight
tracing::debug!("cannot decode thumbnail {path}: {e}"); .borrow_mut()
ui.gallery.photo_nothumb.borrow_mut().insert(uid); .extend(batch.iter().map(|(uid, _)| uid.clone()));
// All of the batch decodes at once, on the worker pool; the results
// are collected in the order they were picked.
let jobs: Vec<_> = batch
.into_iter()
.map(|(uid, path)| {
let job = gio::spawn_blocking({
let path = path.clone();
move || gtk4::gdk::Texture::from_filename(&path)
});
(uid, path, job)
})
.collect();
for (uid, path, job) in jobs {
let decoded = job.await;
ui.gallery.decode_inflight.borrow_mut().remove(&uid);
if generation != ui.gallery.thumb_generation.get() {
continue; continue;
} }
}; let texture = match decoded {
ui.store_texture(&uid, texture.clone()); Ok(Ok(texture)) => texture,
let waiting = ui.gallery.thumb_wanted.borrow_mut().remove(&uid); Ok(Err(e)) => {
for picture in waiting.into_iter().flatten() { tracing::debug!("cannot decode thumbnail {path}: {e}");
picture.set_paintable(Some(&texture)); ui.gallery.photo_nothumb.borrow_mut().insert(uid);
continue;
}
Err(_) => {
tracing::debug!("thumbnail decoder for {path} panicked");
ui.gallery.photo_nothumb.borrow_mut().insert(uid);
continue;
}
};
if ui.gallery.photo_tex.borrow().contains_key(&uid) {
continue;
}
ui.store_texture(&uid, texture.clone());
let waiting = ui.gallery.thumb_wanted.borrow_mut().remove(&uid);
for picture in waiting.into_iter().flatten() {
picture.set_paintable(Some(&texture));
}
} }
} }
ui.gallery.decode_idle.set(false);
if ui.gallery.decode_queue.borrow().is_empty() {
ui.gallery.decode_idle.set(false);
return glib::ControlFlow::Break;
}
glib::ControlFlow::Continue
}); });
} }
/// Take the next few thumbnails to decode off the queue: the ones on screen
/// first, then in queue order, skipping tiles nobody waits for any more and
/// photos already decoded.
fn next_decode_batch(ui: &Rc<Ui>) -> Vec<(String, String)> {
let mut queue = ui.gallery.decode_queue.borrow_mut();
let wanted = ui.gallery.thumb_wanted.borrow();
let cached = ui.gallery.photo_tex.borrow();
let list = &ui.gallery.list;
let visible = |uid: &str| {
wanted.get(uid).is_some_and(|pictures| {
pictures.iter().any(|picture| {
if !picture.is_mapped() {
return false;
}
!picture.is_ancestor(list)
|| picture.compute_bounds(list).is_some_and(|bounds| {
bounds.y() + bounds.height() > 0.0 && bounds.y() < list.height() as f32
})
})
})
};
queue.retain(|(uid, _)| wanted.contains_key(uid) && !cached.contains_key(uid));
(0..DECODE_BATCH)
.filter_map(|_| {
queue
.iter()
.position(|(uid, _)| visible(uid))
.and_then(|index| queue.remove(index))
.or_else(|| queue.pop_front())
})
.collect()
}
/// Re-flow the sections on screen shortly. Debounced, because the triggers (a /// Re-flow the sections on screen shortly. Debounced, because the triggers (a
/// window resize, a zoom step) arrive in floods and only the final state /// window resize, a zoom step) arrive in floods and only the final state
/// matters. /// matters.
@@ -4787,13 +4840,23 @@ pub(crate) fn gallery_unreachable(ui: &Rc<Ui>) {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::{ use super::{
Grouping, PHOTOS_PAGE, ROW_DEFAULT, ROW_MAX, ROW_MIN, ROW_STEP, TILE_GAP, TILE_RATIO_MAX, Grouping, PHOTOS_PAGE, ROW_DEFAULT, ROW_MAX, ROW_MIN, ROW_STEP, TEXTURE_CACHE_BYTES,
TILE_RATIO_MIN, active_filters, copy_without_overwrite, empty_timeline_text, grouping_for, TILE_GAP, TILE_RATIO_MAX, TILE_RATIO_MIN, active_filters, copy_without_overwrite,
memory_years, month_index, month_range, plan_grid, plan_justified, section_heading, empty_timeline_text, grouping_for, memory_years, month_index, month_range, plan_grid,
tile_ratio, viewport_unfilled, plan_justified, section_heading, texture_bytes, tile_ratio, viewport_unfilled,
}; };
use pdfs_core::control::{PhotoItem, PhotoKind, PhotoMonth}; use pdfs_core::control::{PhotoItem, PhotoKind, PhotoMonth};
#[test]
fn the_texture_cache_is_budgeted_by_decoded_pixels() {
assert_eq!(texture_bytes(512, 384), 512 * 384 * 4);
// A broken size still costs something, so it can't pile up for free.
assert_eq!(texture_bytes(0, 512), 1);
assert_eq!(texture_bytes(-1, -1), 1);
// Ordinary thumbnails: well over two dense screens' worth fit.
assert!(TEXTURE_CACHE_BYTES / texture_bytes(512, 384) >= 600);
}
#[test] #[test]
fn the_scrubber_finds_the_month_a_photo_was_taken_in() { fn the_scrubber_finds_the_month_a_photo_was_taken_in() {
let months = [(2026, 3), (2025, 12), (2025, 11)].map(|(year, month)| PhotoMonth { let months = [(2026, 3), (2025, 12), (2025, 11)].map(|(year, month)| PhotoMonth {
+79 -4
View File
@@ -67,6 +67,11 @@ const COVER_PX: i32 = 128;
/// How many street-map tiles stay in memory. /// How many street-map tiles stay in memory.
const TILE_CACHE: usize = 160; const TILE_CACHE: usize = 160;
/// Photo marker covers kept, 64 KiB each. A town's own cover is never
/// dropped (it only arrives with the town's card), but the photos zoomed past
/// one by one would otherwise pile up for as long as the map is open.
const COVER_CACHE: usize = 1024;
/// How long a tile that couldn't be had is left alone before it is tried /// How long a tile that couldn't be had is left alone before it is tried
/// again. /// again.
const TILE_RETRY: Duration = Duration::from_secs(60); const TILE_RETRY: Duration = Duration::from_secs(60);
@@ -232,8 +237,11 @@ struct MapState {
/// for from close up. /// for from close up.
locations: HashMap<u32, Vec<(PhotoItem, World)>>, locations: HashMap<u32, Vec<(PhotoItem, World)>>,
asked_locations: HashSet<u32>, asked_locations: HashSet<u32>,
/// Marker photos, scaled and cropped to a square, by photo uid. /// Marker photos, scaled and cropped to a square, by photo uid, with the
covers: HashMap<String, cairo::ImageSurface>, /// draw they were last shown in.
covers: HashMap<String, (cairo::ImageSurface, u64)>,
/// Counts draws, for dropping the covers shown longest ago.
draws: u64,
asked_thumbs: HashSet<String>, asked_thumbs: HashSet<String>,
view: View, view: View,
/// False until the view has been fitted to the places at a real size, and /// False until the view has been fitted to the places at a real size, and
@@ -349,6 +357,7 @@ impl PlacesMap {
locations: HashMap::new(), locations: HashMap::new(),
asked_locations: HashSet::new(), asked_locations: HashSet::new(),
covers: HashMap::new(), covers: HashMap::new(),
draws: 0,
asked_thumbs: HashSet::new(), asked_thumbs: HashSet::new(),
view: View { view: View {
center: World { x: 0.5, y: 0.5 }, center: World { x: 0.5, y: 0.5 },
@@ -486,7 +495,18 @@ impl PlacesMap {
let Some(cover) = square_cover(texture) else { let Some(cover) = square_cover(texture) else {
return; return;
}; };
self.state.borrow_mut().covers.insert(uid.to_owned(), cover); let mut state = self.state.borrow_mut();
let state = &mut *state;
state.covers.insert(uid.to_owned(), (cover, state.draws));
let towns: HashSet<&str> = state
.places
.iter()
.map(|(place, _)| place.cover.uid.as_str())
.collect();
for dropped in evict_covers(&mut state.covers, &towns, state.draws) {
// Asked for again once it is back on screen.
state.asked_thumbs.remove(&dropped);
}
self.area.queue_draw(); self.area.queue_draw();
} }
@@ -840,6 +860,7 @@ impl PlacesMap {
let mut state = self.state.borrow_mut(); let mut state = self.state.borrow_mut();
let state = &mut *state; let state = &mut *state;
let view = state.view; let view = state.view;
state.draws += 1;
paint_outline(cr, view, size, colors); paint_outline(cr, view, size, colors);
let labels = match state.online.as_mut() { let labels = match state.online.as_mut() {
Some(online) => paint_tiles(cr, online, view, size, dark, area.scale_factor()), Some(online) => paint_tiles(cr, online, view, size, dark, area.scale_factor()),
@@ -863,7 +884,10 @@ impl PlacesMap {
} }
for bubble in &state.bubbles { for bubble in &state.bubbles {
let marker = &state.markers[bubble.members[0]]; let marker = &state.markers[bubble.members[0]];
let cover = state.covers.get(&marker.cover); let cover = state.covers.get_mut(&marker.cover).map(|(cover, drawn)| {
*drawn = state.draws;
&*cover
});
if cover.is_none() if cover.is_none()
&& let Target::Photo { place, index } = marker.target && let Target::Photo { place, index } = marker.target
&& state.asked_thumbs.insert(marker.cover.clone()) && state.asked_thumbs.insert(marker.cover.clone())
@@ -1121,6 +1145,35 @@ fn evict(cache: &mut HashMap<TileKey, CachedTile>, frame: u64) {
} }
} }
/// Drop the photo covers drawn longest ago, down to [`COVER_CACHE`]. Never
/// one drawn in the current draw, and never a town's cover. Returns the uids
/// dropped.
fn evict_covers<T>(
covers: &mut HashMap<String, (T, u64)>,
towns: &HashSet<&str>,
draw: u64,
) -> Vec<String> {
if covers.len() <= COVER_CACHE {
return Vec::new();
}
let mut ages: Vec<(u64, &String)> = covers
.iter()
.filter(|(uid, (_, drawn))| *drawn < draw && !towns.contains(uid.as_str()))
.map(|(uid, (_, drawn))| (*drawn, uid))
.collect();
ages.sort_unstable_by_key(|(drawn, _)| *drawn);
let excess = covers.len() - COVER_CACHE;
let dropped: Vec<String> = ages
.into_iter()
.take(excess)
.map(|(_, uid)| uid.clone())
.collect();
for uid in &dropped {
covers.remove(uid);
}
dropped
}
/// Set the names of the tiles on screen, the most important first, leaving /// Set the names of the tiles on screen, the most important first, leaving
/// out any that would overlap one already set. /// out any that would overlap one already set.
fn paint_labels( fn paint_labels(
@@ -1654,6 +1707,28 @@ fn set_color(cr: &cairo::Context, color: &gtk4::gdk::RGBA, alpha: f32) {
mod tests { mod tests {
use super::*; use super::*;
#[test]
fn covers_past_the_cap_drop_the_stalest_photos_but_no_town() {
let mut covers: HashMap<String, ((), u64)> = (0..COVER_CACHE as u64 + 3)
.map(|n| (format!("p{n}"), ((), n)))
.collect();
let towns: HashSet<&str> = ["p0"].into_iter().collect();
let mut dropped = evict_covers(&mut covers, &towns, COVER_CACHE as u64);
dropped.sort();
assert_eq!(dropped, ["p1", "p2", "p3"]);
assert_eq!(covers.len(), COVER_CACHE);
assert!(covers.contains_key("p0"));
}
#[test]
fn covers_drawn_this_frame_are_kept_even_past_the_cap() {
let mut covers: HashMap<String, ((), u64)> = (0..COVER_CACHE + 2)
.map(|n| (format!("p{n}"), ((), 7)))
.collect();
assert!(evict_covers(&mut covers, &HashSet::new(), 7).is_empty());
assert_eq!(covers.len(), COVER_CACHE + 2);
}
#[test] #[test]
fn projection_puts_the_equator_and_meridian_in_the_middle() { fn projection_puts_the_equator_and_meridian_in_the_middle() {
let p = project(0.0, 0.0); let p = project(0.0, 0.0);
+122 -19
View File
@@ -52,8 +52,9 @@ fn staged_path(ui: &Rc<Ui>) -> PathBuf {
/// Read the remembered set, dropping any archive that has since been moved or /// Read the remembered set, dropping any archive that has since been moved or
/// deleted — a stale path would only fail at launch, and silently is worse. /// deleted — a stale path would only fail at launch, and silently is worse.
fn load_staged(ui: &Rc<Ui>) -> Vec<PathBuf> { /// Blocking: run it off the GTK thread.
let Ok(text) = std::fs::read_to_string(staged_path(ui)) else { fn load_staged(path: &Path) -> Vec<PathBuf> {
let Ok(text) = std::fs::read_to_string(path) else {
return Vec::new(); return Vec::new();
}; };
let paths: Vec<String> = serde_json::from_str(&text).unwrap_or_default(); let paths: Vec<String> = serde_json::from_str(&text).unwrap_or_default();
@@ -64,9 +65,39 @@ fn load_staged(ui: &Rc<Ui>) -> Vec<PathBuf> {
.collect() .collect()
} }
/// Restore whatever was staged when the window last closed, read on a worker.
/// Anything the user staged meanwhile is kept alongside it.
fn restore_staged(ui: &Rc<Ui>) {
let path = staged_path(ui);
let ui = ui.clone();
glib::spawn_future_local(async move {
let restored = gio::spawn_blocking(move || load_staged(&path))
.await
.unwrap_or_default();
{
let mut staged = ui.takeout.archives.borrow_mut();
for path in restored {
if !staged.contains(&path) {
staged.push(path);
}
}
staged.sort();
}
ui.takeout.restored.set(true);
repaint_archives(&ui);
});
}
/// Remember the staged set. Best-effort: failing to write it costs the user a /// Remember the staged set. Best-effort: failing to write it costs the user a
/// re-pick next time, which is not worth interrupting them over now. /// re-pick next time, which is not worth interrupting them over now.
///
/// Written on a worker. Nothing is written before the remembered set has been
/// read back, so the empty list shown meanwhile can't overwrite it, and a
/// write that lands after a newer one is skipped.
fn save_staged(ui: &Rc<Ui>) { fn save_staged(ui: &Rc<Ui>) {
if !ui.takeout.restored.get() {
return;
}
let paths: Vec<String> = ui let paths: Vec<String> = ui
.takeout .takeout
.archives .archives
@@ -75,12 +106,24 @@ fn save_staged(ui: &Rc<Ui>) {
.map(|p| p.display().to_string()) .map(|p| p.display().to_string())
.collect(); .collect();
let path = staged_path(ui); let path = staged_path(ui);
let written = serde_json::to_string(&paths) let seq = ui.takeout.save_seq.get() + 1;
.map_err(|e| e.to_string()) ui.takeout.save_seq.set(seq);
.and_then(|text| std::fs::write(&path, text).map_err(|e| e.to_string())); let saved = ui.takeout.saved_seq.clone();
if let Err(e) = written { gio::spawn_blocking(move || {
tracing::warn!("cannot remember staged Takeout archives: {e}"); let Ok(mut last) = saved.lock() else {
} return;
};
if *last > seq {
return;
}
*last = seq;
let written = serde_json::to_string(&paths)
.map_err(|e| e.to_string())
.and_then(|text| std::fs::write(&path, text).map_err(|e| e.to_string()));
if let Err(e) = written {
tracing::warn!("cannot remember staged Takeout archives: {e}");
}
});
} }
fn empty_list_description() -> String { fn empty_list_description() -> String {
@@ -121,6 +164,16 @@ pub(crate) struct TakeoutState {
pub(crate) inflight: Cell<bool>, pub(crate) inflight: Cell<bool>,
/// Whether the daemon reported an import running on the last poll. /// Whether the daemon reported an import running on the last poll.
pub(crate) running: Cell<bool>, pub(crate) running: Cell<bool>,
/// Whether the remembered staged set has been read back yet; until then
/// nothing is saved over it.
pub(crate) restored: Cell<bool>,
/// The last save started, and the last one written by a worker, so an
/// older save that lands late doesn't overwrite a newer one.
pub(crate) save_seq: Cell<u64>,
pub(crate) saved_seq: std::sync::Arc<std::sync::Mutex<u64>>,
/// Bumped by every repaint of the archive list, so the sizes of an older
/// list that arrive late are not painted over a newer one.
pub(crate) repaint_seq: Cell<u64>,
} }
/// Widgets the Import page hands back for wiring. /// Widgets the Import page hands back for wiring.
@@ -490,10 +543,10 @@ pub(crate) fn wire_takeout(ui: &Rc<Ui>, widgets: &TakeoutWidgets) {
.back_button .back_button
.connect_clicked(move |_| ui_back.stack.set_visible_child_name("gallery")); .connect_clicked(move |_| ui_back.stack.set_visible_child_name("gallery"));
// Restore whatever was staged when the window last closed, before the first // Restore whatever was staged when the window last closed, so the page
// paint, so the page comes up as the user left it. // comes up as the user left it.
*ui.takeout.archives.borrow_mut() = load_staged(ui);
repaint_archives(ui); repaint_archives(ui);
restore_staged(ui);
} }
/// Stage `paths`, keeping only `.zip` files and skipping ones already staged. /// Stage `paths`, keeping only `.zip` files and skipping ones already staged.
@@ -503,15 +556,36 @@ pub(crate) fn wire_takeout(ui: &Rc<Ui>, widgets: &TakeoutWidgets) {
/// the scan reads the archives' central directories, and an extracted tree has /// the scan reads the archives' central directories, and an extracted tree has
/// none — silently importing half of it would be worse than saying no. /// none — silently importing half of it would be worse than saying no.
pub(crate) fn add_archives(ui: &Rc<Ui>, paths: Vec<PathBuf>) { pub(crate) fn add_archives(ui: &Rc<Ui>, paths: Vec<PathBuf>) {
// Whether each is a regular file is asked of the filesystem, which may be
// a slow network mount: on a worker.
let ui = ui.clone();
glib::spawn_future_local(async move {
let checked = gio::spawn_blocking(move || {
paths
.into_iter()
.map(|path| {
let file = path.is_file();
(path, file)
})
.collect::<Vec<_>>()
})
.await
.unwrap_or_default();
stage_archives(&ui, checked);
});
}
/// Stage the archives [`add_archives`] checked, as `(path, is a file)`.
fn stage_archives(ui: &Rc<Ui>, paths: Vec<(PathBuf, bool)>) {
let mut added = 0usize; let mut added = 0usize;
let mut rejected = 0usize; let mut rejected = 0usize;
{ {
let mut staged = ui.takeout.archives.borrow_mut(); let mut staged = ui.takeout.archives.borrow_mut();
for path in paths { for (path, file) in paths {
let is_zip = path let is_zip = path
.extension() .extension()
.is_some_and(|ext| ext.eq_ignore_ascii_case("zip")); .is_some_and(|ext| ext.eq_ignore_ascii_case("zip"));
if !is_zip || !path.is_file() { if !is_zip || !file {
rejected += 1; rejected += 1;
continue; continue;
} }
@@ -542,12 +616,44 @@ pub(crate) fn add_archives(ui: &Rc<Ui>, paths: Vec<PathBuf>) {
} }
/// Rebuild the staged-archive list and re-derive which actions are available. /// Rebuild the staged-archive list and re-derive which actions are available.
///
/// The archives' sizes are read on a worker, and the list is rebuilt once
/// they are in.
pub(crate) fn repaint_archives(ui: &Rc<Ui>) { pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
let seq = ui.takeout.repaint_seq.get().wrapping_add(1);
ui.takeout.repaint_seq.set(seq);
let staged = ui.takeout.archives.borrow().clone();
save_staged(ui);
sync_takeout_actions(ui);
if staged.is_empty() {
paint_archives(ui, Vec::new());
return;
}
let ui = ui.clone();
glib::spawn_future_local(async move {
let sized = gio::spawn_blocking(move || {
staged
.into_iter()
.map(|path| {
let size = std::fs::metadata(&path).map(|m| m.len()).unwrap_or(0);
(path, size)
})
.collect::<Vec<_>>()
})
.await
.unwrap_or_default();
if ui.takeout.repaint_seq.get() == seq {
paint_archives(&ui, sized);
}
});
}
/// Fill the staged-archive list with `staged`, as `(path, size)`.
fn paint_archives(ui: &Rc<Ui>, staged: Vec<(PathBuf, u64)>) {
for row in ui.takeout.rows.borrow_mut().drain(..) { for row in ui.takeout.rows.borrow_mut().drain(..) {
ui.takeout.list_group.remove(&row); ui.takeout.list_group.remove(&row);
} }
let staged = ui.takeout.archives.borrow().clone();
let mut rows: Vec<adw::PreferencesRow> = Vec::new(); let mut rows: Vec<adw::PreferencesRow> = Vec::new();
if staged.is_empty() { if staged.is_empty() {
ui.takeout ui.takeout
@@ -558,8 +664,8 @@ pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
rows.push(row.upcast()); rows.push(row.upcast());
} else { } else {
let mut total = 0u64; let mut total = 0u64;
for path in &staged { for (path, size) in &staged {
let size = std::fs::metadata(path).map(|m| m.len()).unwrap_or(0); let size = *size;
total += size; total += size;
let row = adw::ActionRow::builder() let row = adw::ActionRow::builder()
.title( .title(
@@ -601,9 +707,6 @@ pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
))); )));
} }
*ui.takeout.rows.borrow_mut() = rows; *ui.takeout.rows.borrow_mut() = rows;
save_staged(ui);
sync_takeout_actions(ui);
} }
/// Enable exactly the actions that make sense right now: nothing to launch /// Enable exactly the actions that make sense right now: nothing to launch