LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
LRC-LIB-SMARTCOLL: rule dialog and sidebar problems cached per change, not per frame
Nathaniel Ledforde8678bb28e87
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex 9a743e916..beed233e1 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -1068,6 +1068,12 @@ pub struct Caches {album_counts: Option<(u64, std::sync::Arc<std::collections::HashMap<lightcraft_catalog::AlbumId, usize>>)>,/// How often the album counts were recomputed (tests check that unchanged frames don't).pub album_count_scans: usize,+ /// What the open smart-album rule dialog shows besides the rules ([`Caches::rules_view`]).+ rules_view: Option<(u64, std::sync::Arc<RulesView>)>,+ pub rules_view_scans: usize,+ /// The problems of every saved smart album that has some ([`Caches::smart_album_problems`]).+ smart_problems: Option<(u64, std::sync::Arc<std::collections::HashMap<lightcraft_catalog::AlbumId, Vec<lightcraft_catalog::rules::Problem>>>)>,+ pub smart_problem_scans: usize,/// AI denoise: what the pump last saw, the model list and the downloads being watched.pub denoise: panels::denoise::Ui,/// Bumped when a face model is installed, removed or chosen, so Settings re-reads the list at once.@@ -1117,6 +1123,14 @@ pub struct FilterValues {pub keywords: Vec<String>,}+/// What the smart-album rule dialog shows besides the rules themselves: their problems (each row+/// marks its own), how many photos they match and the albums an Album rule picks from.+pub struct RulesView {+ pub problems: Vec<lightcraft_catalog::rules::Problem>,+ pub count: usize,+ pub albums: Vec<album_picker::AlbumEntry>,+}+pub(crate) fn key_of(parts: impl std::hash::Hash) -> u64 {use std::hash::{BuildHasher, BuildHasherDefault, DefaultHasher};BuildHasherDefault::<DefaultHasher>::default().hash_one(parts)@@ -1244,6 +1258,56 @@ impl Caches {/// all bump its revision) and — only while some smart album has an "in the last…" rule —/// when `now` (the session clock, ISO) enters a new minute, so such counts follow the clock/// within a minute without rescanning every frame.+ /// [`RulesView`] for `rules` edited in smart album `editing` (`None`: a new album), within+ /// `folder` when it was made from a folder view: worked out again only when the catalog, the+ /// rules, the language or (for "in the last…" rules) the minute changes, not every frame.+ pub fn rules_view(+ &mut self,+ cat: &lightcraft_catalog::Catalog,+ rules: &lightcraft_catalog::RuleSet,+ editing: Option<u64>,+ folder: Option<String>,+ now: &str,+ ) -> std::sync::Arc<RulesView> {+ let relative = rules.depends_on_now();+ let minute = if relative { now.get(..16).unwrap_or(now) } else { "" };+ let k = key_of((cat.revision, serde_json::to_string(rules).unwrap_or_default(), editing, &folder, minute, i18n::language().code()));+ if let Some((key, v)) = &self.rules_view+ && *key == k+ {+ return v.clone();+ }+ if relative {+ lightcraft_catalog::rules::set_now(Some(now.to_string()));+ }+ let problems = rules.check_for(cat, editing.map(lightcraft_catalog::AlbumId));+ let filter = lightcraft_catalog::Filter { rule_set: Some(rules.clone()), library_folder: folder, ..Default::default() };+ let count = if problems.is_empty() { cat.query(&filter, &Default::default()).len() } else { 0 };+ let v = std::sync::Arc::new(RulesView { problems, count, albums: panels::dialogs::album_entries(cat, editing) });+ self.rules_view_scans += 1;+ self.rules_view = Some((k, v.clone()));+ v+ }++ /// The problems of every saved smart album that has some (`Catalog::smart_album_problems`),+ /// for the sidebar's ⚠ marks: worked out again only when the catalog changes.+ pub fn smart_album_problems(+ &mut self,+ cat: &lightcraft_catalog::Catalog,+ ) -> std::sync::Arc<std::collections::HashMap<lightcraft_catalog::AlbumId, Vec<lightcraft_catalog::rules::Problem>>> {+ if let Some((rev, v)) = &self.smart_problems+ && *rev == cat.revision+ {+ return v.clone();+ }+ let v: std::sync::Arc<std::collections::HashMap<_, _>> = std::sync::Arc::new(+ cat.albums().filter(|a| a.is_smart()).map(|a| (a.id, cat.smart_album_problems(a.id))).filter(|(_, p)| !p.is_empty()).collect(),+ );+ self.smart_problem_scans += 1;+ self.smart_problems = Some((cat.revision, v.clone()));+ v+ }+pub fn album_counts(&mut self,cat: &lightcraft_catalog::Catalog,@@ -1319,6 +1383,42 @@ mod cache_tests {lightcraft_catalog::rules::set_now(None);}+ /// The rule dialog's problems, live count and album list are worked out once per change to the+ /// catalog or the rules, not every frame; so are the sidebar's smart-album problems.+ #[test]+ fn rule_dialog_and_problems_are_cached_until_something_changes() {+ let mut cat = Catalog::default();+ let mut c = super::Caches::default();+ for i in 0..3u64 {+ cat.apply(photo(i + 1, "2026-09-30T11:00:00", if i == 0 { 5 } else { 1 })).unwrap();+ }+ let rules =+ |v: u64| -> RuleSet { serde_json::from_value(serde_json::json!({"rules": [{"field": "rating", "op": "gte", "value": v}]})).unwrap() };+ let now = "2026-09-30T12:00:00";+ let view = c.rules_view(&cat, &rules(3), None, None, now);+ assert_eq!((view.count, view.problems.len()), (1, 0));+ for _ in 0..10 {+ c.rules_view(&cat, &rules(3), None, None, now);+ }+ assert_eq!(c.rules_view_scans, 1, "unchanged frames reuse it");+ assert_eq!(c.rules_view(&cat, &rules(1), None, None, now).count, 3, "a rule change");+ assert_eq!(c.rules_view(&cat, &rules(9), None, None, now).problems.len(), 1);+ cat.apply(Op::SetRating { id: PhotoId(2), rating: 4 }).unwrap();+ assert_eq!(c.rules_view(&cat, &rules(3), None, None, now).count, 2, "a catalog change");+ assert_eq!(c.rules_view_scans, 4);+ // the sidebar's problems+ cat.apply(Op::AddAlbum { album: lightcraft_catalog::Album::new(AlbumId(20), "Trip") }).unwrap();+ cat.apply(smart(21, serde_json::json!({"rules": [{"field": "album", "op": "is", "value": 20}]}))).unwrap();+ assert!(c.smart_album_problems(&cat).get(&AlbumId(21)).is_none_or(Vec::is_empty));+ for _ in 0..10 {+ c.smart_album_problems(&cat);+ }+ assert_eq!(c.smart_problem_scans, 1);+ cat.apply(Op::RemoveAlbum { id: AlbumId(20) }).unwrap();+ assert!(c.smart_album_problems(&cat).get(&AlbumId(21)).is_some_and(|p| !p.is_empty()), "its album is gone");+ assert_eq!(c.smart_problem_scans, 2);+ }+/// Without "in the last…" rules the clock never causes a rescan.#[test]fn absolute_rules_ignore_the_clock() {diff --git a/crates/ui-egui/src/panels/dialogs.rs b/crates/ui-egui/src/panels/dialogs.rsindex e790d8d3a..facbb8b56 100644--- a/crates/ui-egui/src/panels/dialogs.rs+++ b/crates/ui-egui/src/panels/dialogs.rs@@ -247,22 +247,18 @@ pub fn show(app: &mut LightcraftApp, ctx: &egui::Context) {let r = ui.add(egui::TextEdit::singleline(name).hint_text(crate::i18n::tr("Name")).desired_width(f32::INFINITY));crate::widgets::register(ui.ctx(), "field:smartName", r.rect);ui.add_space(6.0);- // checked before drawing, so each row marks its own problem- let env = crate::panels::rules_editor::Env {- problems: rules.check_for(&app.session.catalog, id.map(lightcraft_catalog::AlbumId)),- today: (app.session.clock)(),- albums: album_entries(&app.session.catalog, *id),- };+ // the folder an album made from a folder view carries is not in the editor, but it counts+ let folder = id.and_then(|id| app.session.catalog.album(lightcraft_catalog::AlbumId(id))).and_then(|a| a.smart.as_deref().and_then(|f| f.library_folder.clone()));+ // problems, count and albums: cached until the catalog or the rules change (not per frame)+ let now = (app.session.clock)();+ let view = app.caches.rules_view(&app.session.catalog, rules, *id, folder, &now);+ let env = crate::panels::rules_editor::Env { problems: view.problems.clone(), today: now, albums: view.albums.clone() };egui::ScrollArea::vertical().max_height(360.0).auto_shrink([false, true]).show(ui, |ui| {crate::panels::rules_editor::edit(ui, rules, "rules", 0, &[], &env);});- let problems = rules.check_for(&app.session.catalog, id.map(lightcraft_catalog::AlbumId));- // the folder an album made from a folder view carries is not in the editor, but it counts- let folder = id.and_then(|id| app.session.catalog.album(lightcraft_catalog::AlbumId(id))).and_then(|a| a.smart.as_deref().and_then(|f| f.library_folder.clone()));- let f = lightcraft_catalog::Filter { rule_set: Some(rules.clone()), library_folder: folder, ..Default::default() };- let n = if problems.is_empty() { app.session.catalog.query(&f, &Default::default()).len() } else { 0 };+ let n = view.count;ui.add_space(4.0);- if problems.is_empty() {+ if view.problems.is_empty() {ui.label(egui::RichText::new(crate::i18n::tr_format!("{n} photo{} match · updates automatically as photos change", if n == 1 { "" } else { "s" }, n = n)).color(t.text_dim),@@ -1034,7 +1030,7 @@ fn created_in(app: &mut LightcraftApp, command: &str, params: serde_json::Value)/// The albums an Album rule in smart album `editing` picks from, in the sidebar's order: the album/// itself and any smart album that tests it (testing it back would loop) are blocked, with why.-fn album_entries(cat: &lightcraft_catalog::Catalog, editing: Option<u64>) -> Vec<crate::album_picker::AlbumEntry> {+pub(crate) fn album_entries(cat: &lightcraft_catalog::Catalog, editing: Option<u64>) -> Vec<crate::album_picker::AlbumEntry> {let editing = editing.map(lightcraft_catalog::AlbumId);crate::album_picker::entries_from(cat, |a| match editing {Some(e) if a.id == e => Some(crate::i18n::tr("This is the album you're editing").to_string()),diff --git a/crates/ui-egui/src/panels/left.rs b/crates/ui-egui/src/panels/left.rsindex 5a21b54e0..64a727ea5 100644--- a/crates/ui-egui/src/panels/left.rs+++ b/crates/ui-egui/src/panels/left.rs@@ -728,7 +728,7 @@ fn albums_tree(app: &mut LightcraftApp, ui: &mut egui::Ui, all: &AlbumKids, pareapp.session.target_album.filter(|t| app.session.catalog.album(*t).is_some()).or_else(|| app.session.catalog.quick_collection());let label = if target == Some(a.id) { format!("{} +", a.name) } else { a.name.clone() };// a smart album whose rules no longer check (an album they test was deleted) says so- let problems = app.session.catalog.smart_album_problems(a.id);+ let problems = app.caches.smart_album_problems(&app.session.catalog).get(&a.id).cloned().unwrap_or_default();let label = if problems.is_empty() { label } else { format!("⚠ {label}") };let mut resp = row_sensed(app, ui, &format!("album:{}", a.id.0), icon, &label, None, Some(n), sel, indent, Sense::click_and_drag());if !problems.is_empty() {