LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
fix: left panel slow with a large keyword list (#1011)
Matthew James Sivakaa7e0bbc3485
diff --git a/crates/catalog/src/keywords.rs b/crates/catalog/src/keywords.rsindex 92a531951..619967f65 100644--- a/crates/catalog/src/keywords.rs+++ b/crates/catalog/src/keywords.rs@@ -236,63 +236,85 @@ pub struct KeywordNode {impl Catalog {/// The keyword tree: every keyword level with photo counts, sorted by name (case-insensitive).pub fn keyword_tree(&self) -> Vec<KeywordNode> {- use std::collections::{HashMap, HashSet};- // every keyword level (`travel`, `travel|italy`…) by its lower-case path: the name and+ use std::collections::HashMap;+ // every keyword level (`travel`, `travel|italy`…), one per lower-case path: the name and// path as first written, and the photos counted (once per photo, even when two of its- // keywords share a parent)+ // keywords share a parent: `seen` is the last photo counted)struct Level {name: String,path: String,count: usize,- parent: Option<String>,+ parent: Option<usize>,+ seen: usize,}- let mut levels: HashMap<String, Level> = HashMap::new();- let mut this_photo: HashSet<String> = HashSet::new();+ let mut levels: Vec<Level> = Vec::new();+ let mut by_lower: HashMap<String, usize> = HashMap::new();// the keyword list first (no photos counted): a listed keyword is there without photoslet listed: Vec<String> = self.listed_keywords().map(|k| k.path.clone()).collect();+ // each keyword as written → its levels (its own and those above it), worked out once: a+ // large library repeats a few thousand keywords tens of thousands of times (issue #1011)+ let mut chains: HashMap<&str, Vec<usize>> = HashMap::new();let photos = self.photos().filter(|p| p.in_library()).map(|p| (true, p.meta.keywords.as_slice()));- for (counts, keywords) in std::iter::once((false, listed.as_slice())).chain(photos) {- this_photo.clear();+ for (photo, (counts, keywords)) in std::iter::once((false, listed.as_slice())).chain(photos).enumerate() {for k in keywords {- let mut path = String::new();- let mut lower = String::new();- let mut parent: Option<String> = None;- for part in k.split(SEP).map(str::trim).filter(|s| !s.is_empty()) {- if !path.is_empty() {- path.push(SEP);- lower.push(SEP);+ let chain = chains.entry(k.as_str()).or_insert_with(|| {+ let mut chain = Vec::new();+ let mut path = String::new();+ let mut lower = String::new();+ for part in k.split(SEP).map(str::trim).filter(|s| !s.is_empty()) {+ if !path.is_empty() {+ path.push(SEP);+ lower.push(SEP);+ }+ path.push_str(part);+ lower.push_str(&part.to_lowercase());+ let i = match by_lower.get(&lower) {+ Some(&i) => i,+ None => {+ let i = levels.len();+ let parent = chain.last().copied();+ levels.push(Level { name: part.to_string(), path: path.clone(), count: 0, parent, seen: 0 });+ by_lower.insert(lower.clone(), i);+ i+ }+ };+ chain.push(i);}- path.push_str(part);- lower.push_str(&part.to_lowercase());- let l = levels.entry(lower.clone()).or_insert_with(|| Level {- name: part.to_string(),- path: path.clone(),- count: 0,- parent: parent.clone(),- });- if counts && this_photo.insert(lower.clone()) {- l.count += 1;+ chain+ });+ if counts {+ for &i in chain.iter() {+ let Some(l) = levels.get_mut(i) else { continue };+ // photo 0 is the keyword list, which counts nothing+ if l.seen != photo {+ l.seen = photo;+ l.count += 1;+ }}- parent = Some(lower.clone());}}}- let mut kids: HashMap<Option<String>, Vec<String>> = HashMap::new();- for (lower, l) in &levels {- kids.entry(l.parent.clone()).or_default().push(lower.clone());+ // each level's children; `roots` the top level+ let mut kids: Vec<Vec<usize>> = vec![Vec::new(); levels.len()];+ let mut roots = Vec::new();+ for (i, l) in levels.iter().enumerate() {+ match l.parent.and_then(|p| kids.get_mut(p)) {+ Some(k) => k.push(i),+ None => roots.push(i),+ }}- fn build(at: Option<String>, levels: &HashMap<String, Level>, kids: &mut HashMap<Option<String>, Vec<String>>) -> Vec<KeywordNode> {- let Some(mut list) = kids.remove(&at) else { return Vec::new() };- list.sort_by_key(|l| levels[l].name.to_lowercase());+ fn build(mut list: Vec<usize>, levels: &[Level], kids: &mut [Vec<usize>]) -> Vec<KeywordNode> {+ list.sort_by_cached_key(|&i| levels.get(i).map(|l| l.name.to_lowercase()));list.into_iter()- .map(|l| {- let lv = &levels[&l];- let children = build(Some(l.clone()), levels, kids);- KeywordNode { name: lv.name.clone(), path: lv.path.clone(), count: lv.count, children }+ .filter_map(|i| {+ let lv = levels.get(i)?;+ let below = kids.get_mut(i).map(std::mem::take).unwrap_or_default();+ let children = build(below, levels, kids);+ Some(KeywordNode { name: lv.name.clone(), path: lv.path.clone(), count: lv.count, children })}).collect()}- build(None, &levels, &mut kids)+ build(roots, &levels, &mut kids)}/// `SetMeta` ops for every photo whose keywords `f` changes.@@ -804,6 +826,15 @@ mod tests {assert_eq!(c.query(&f, &Default::default()).len(), 3);}+ /// A keyword written twice on a photo, or in two spellings, counts the photo once; the next+ /// photo with it counts again.+ #[test]+ fn tree_counts_a_repeated_keyword_once_per_photo() {+ let (c, _) = lib(&[&["sea|Baltic", "sea|Baltic", "Sea|baltic"], &["sea|baltic"], &[]]);+ let t = c.keyword_tree();+ assert_eq!(tree_paths(&t), [("sea".to_string(), 2), ("sea|Baltic".to_string(), 2)]);+ }+#[test]fn rename_delete_merge_are_single_undoable_batches() {let (mut c, ids) = lib(&[&["travel|italy|rome", "beach"], &["Travel|Italy"], &["italia", "travel|italy"], &["sea"]]);diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex 9a387c77c..749d70f3b 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -80,6 +80,8 @@ mod tests_keyword_list;#[cfg(test)]mod tests_keyword_set;#[cfg(test)]+mod tests_keyword_sidebar;+#[cfg(test)]mod tests_keywording;#[cfg(test)]mod tests_labels;diff --git a/crates/ui-egui/src/panels/left.rs b/crates/ui-egui/src/panels/left.rsindex a14332c82..cec20e7df 100644--- a/crates/ui-egui/src/panels/left.rs+++ b/crates/ui-egui/src/panels/left.rs@@ -21,6 +21,12 @@ pub(crate) fn content_width(ctx: &egui::Context) -> f32 {/// The most a row asks for its name: longer ones are cut when there is no more room.const MAX_NAME_NEED: f32 = 140.0;+/// Height of a sidebar row.+const ROW_HEIGHT: f32 = 29.0;++/// Temp-data key of the keyword (lower-case path) the sidebar scrolls to, and the frame it was asked for.+const KEYWORD_SCROLL_TO: &str = "left-keyword-scroll-to";+/// A row says how wide it needs to be.fn note_width(ui: &egui::Ui, w: f32) {ui.data_mut(|d| {@@ -75,7 +81,7 @@ fn row_sensed() -> egui::Response {let label = if matches!(id, "all" | "recentlyAdded" | "picks" | "missing" | "recentlyDeleted") { crate::i18n::tr(label) } else { label };let t = Tokens::get(ui.ctx());- let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 29.0), sense);+ let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), ROW_HEIGHT), sense);register(ui.ctx(), format!("source:{id}"), r);let said = spoken.unwrap_or(label);let name = match count {@@ -638,6 +644,9 @@ pub fn show(app: &mut LightcraftApp, ui: &mut egui::Ui) {above.push_str(name);set_tree_open(ui, egui::Id::new(("kw-open", above.to_lowercase())), true);}+ // …and the sidebar scrolls to it when its row is drawn (`keyword_rows`)+ let frame = ui.ctx().cumulative_frame_nr();+ ui.data_mut(|d| d.insert_temp(egui::Id::new(KEYWORD_SCROLL_TO), (path.to_lowercase(), frame)));}// Local keeps track of the folder being browsed whether or not it is drawnlet local = local_now(app, ui);@@ -1829,14 +1838,35 @@ fn folder_menu_for_library(app: &mut LightcraftApp, resp: &egui::Response, n: &F/// filters the grid by the keyword (children included), the triangle opens a level, and the/// context menu renames, merges or deletes the keyword across the library.fn keyword_rows(app: &mut LightcraftApp, ui: &mut egui::Ui, nodes: &[KeywordNode], indent: f32) {+ // the keyword just made from the header, to scroll to (asked for a frame or two ago)+ let scroll_id = egui::Id::new(KEYWORD_SCROLL_TO);+ let frame = ui.ctx().cumulative_frame_nr();+ let scroll_to = ui.data(|d| d.get_temp::<(String, u64)>(scroll_id)).filter(|(_, asked)| frame.saturating_sub(*asked) <= 2).map(|(p, _)| p);for n in nodes {- let open_id = egui::Id::new(("kw-open", n.path.to_lowercase()));+ let lower = n.path.to_lowercase();+ let reveal = scroll_to.as_deref() == Some(lower.as_str());+ let open_id = egui::Id::new(("kw-open", lower));let mut open = tree_open(ui, open_id, false);+ // a row out of sight only takes its room: a library can have thousands of keywords, and+ // drawing them all every frame slows the whole app down (issue #1011)+ let next = Rect::from_min_size(ui.cursor().min, vec2(ui.available_width(), ROW_HEIGHT));+ if !reveal && !ui.is_rect_visible(next) {+ ui.allocate_space(next.size());+ note_width(ui, 42.0 + indent + 18.0);+ if open && !n.children.is_empty() {+ keyword_rows(app, ui, &n.children, indent + 16.0);+ }+ continue;+ }let sel = app.session.filter.keyword.as_deref().is_some_and(|k| k.eq_ignore_ascii_case(&n.path));let resp = row(app, ui, &format!("keyword:{}", n.path), Icon::Tag, &n.name, Some(n.count), sel, indent);if !n.children.is_empty() {tree_toggle(ui, &resp, indent, open_id, &mut open, format!("keywordToggle:{}", n.path));}+ if reveal {+ ui.scroll_to_rect_animation(resp.rect, None, egui::style::ScrollAnimation::none());+ ui.data_mut(|d| d.remove::<(String, u64)>(scroll_id));+ }let resp = resp.on_hover_text(if n.children.is_empty() { n.path.clone() } else { format!("{} (includes the keywords below it)", n.path) });if resp.clicked() {let v = if sel { serde_json::Value::Null } else { json!(n.path) };diff --git a/crates/ui-egui/src/tests_keyword_sidebar.rs b/crates/ui-egui/src/tests_keyword_sidebar.rsnew file mode 100644index 000000000..1d7457cd6--- /dev/null+++ b/crates/ui-egui/src/tests_keyword_sidebar.rs@@ -0,0 +1,92 @@+//! Headless tests of the left sidebar's Keywords section on a large library (issue #1011): with+//! thousands of keywords listed, a frame draws only the rows near the screen, and the rows out+//! of sight still take their room, so scrolling reaches the last keyword.++use std::time::{Duration, Instant};++use lightcraft_catalog::{Op, Photo, PhotoId, Source};+use lightcraft_engine::Session;+use serde_json::json;++use crate::headless::Headless;+use crate::{LightcraftApp, Services};++const T: Duration = Duration::from_secs(30);+const SETTLE: Duration = Duration::from_secs(120);++/// `photos` photos with six keywords each out of `keywords` top-level ones (each with a child).+fn library(photos: u64, keywords: u64) -> Session {+ let mut s = Session::new();+ for i in 0..photos {+ let path = format!("/lightcraft-kw-test/IMG_{i:05}.jpg");+ let mut p = Photo::new(PhotoId(i + 1), Source::File { path }, &format!("IMG_{i:05}.jpg"), "JPEG", 60, 40, "2026-01-01T00:00:00");+ p.meta.keywords = (0..6).map(|k| format!("Keyword {:05}|Child", (i * 6 + k) % keywords)).collect();+ s.catalog.apply(Op::AddPhoto { photo: Box::new(p) }).unwrap();+ }+ s+}++fn app(photos: u64, keywords: u64) -> Headless {+ let app = LightcraftApp::new(library(photos, keywords), Services { png: None, ..Default::default() });+ let mut h = Headless::new(app, [1400.0, 900.0], 1.0);+ let r = h.request("ui.set", json!({"view": "photoGrid", "leftPanel": true}), T);+ assert_eq!(r["ok"], true, "{r}");+ h.settle(SETTLE);+ h+}++/// The keyword rows drawn this frame.+fn keyword_rows(h: &Headless) -> Vec<String> {+ h.app.widgets.iter().filter_map(|(w, _)| w.strip_prefix("source:keyword:")).map(str::to_string).collect()+}++/// Given a library with 2,000 keywords, when the sidebar's Keywords section is open, then a frame+/// draws only the few dozen rows that fit on screen (not all 2,000), and scrolling to the end+/// draws the last keyword: the rows out of sight keep their height.+#[test]+fn keywords_section_draws_only_the_rows_near_the_screen() {+ const KEYWORDS: u64 = 2000;+ let mut h = app(KEYWORDS / 6 + 1, KEYWORDS);+ assert_eq!(h.app.caches.keyword_tree(&h.app.session.catalog).len(), KEYWORDS as usize);+ let rows = keyword_rows(&h);+ assert!(!rows.is_empty() && rows.len() < 100, "{} of {KEYWORDS} keyword rows drawn", rows.len());+ assert!(rows.contains(&"Keyword 00000".to_string()), "{rows:?}");+ // all the way down+ h.request("ui.move", json!({"x": 120.0, "y": 400.0}), T);+ for _ in 0..40 {+ let r = h.request("ui.scroll", json!({"dy": -5000.0}), T);+ assert_eq!(r["ok"], true, "{r}");+ h.step();+ }+ h.settle(SETTLE);+ let rows = keyword_rows(&h);+ assert!(!rows.is_empty() && rows.len() < 100, "{} of {KEYWORDS} keyword rows drawn", rows.len());+ assert!(rows.contains(&"Keyword 01999".to_string()), "the last keyword is reached: {rows:?}");+ assert!(!rows.contains(&"Keyword 00000".to_string()), "{rows:?}");+}++/// Timings on a library the size of the report's (58,000 photos): `cargo test --release -p+/// lightcraft-ui-egui --lib probe_keyword_sidebar_cost -- --ignored --nocapture`.+#[test]+#[ignore = "timing probe"]+fn probe_keyword_sidebar_cost() {+ let mut h = app(58_000, 4000);+ let t = Instant::now();+ let tree = h.app.session.catalog.keyword_tree();+ eprintln!("keyword_tree: {:?} ({} top level)", t.elapsed(), tree.len());+ eprintln!("keyword rows drawn: {}", keyword_rows(&h).len());+ let t = Instant::now();+ for _ in 0..10 {+ h.step();+ }+ eprintln!("unchanged frame: {:?}", t.elapsed() / 10);+ let t = Instant::now();+ for i in 0..10u64 {+ let r = h.request("engine.execute", json!({"command": "library.select", "params": {"ids": [i + 1]}}), T);+ assert_eq!(r["ok"], true, "{r}");+ let r = h.request("engine.execute", json!({"command": "photo.rate", "params": {"rating": (i % 5) + 1}}), T);+ assert_eq!(r["ok"], true, "{r}");+ h.step();+ }+ eprintln!("frame after a rating: {:?}", t.elapsed() / 10);+}diff --git a/crates/ui-egui/src/tests_panels.rs b/crates/ui-egui/src/tests_panels.rsindex 25edf3bfa..a94f613a5 100644--- a/crates/ui-egui/src/tests_panels.rs+++ b/crates/ui-egui/src/tests_panels.rs@@ -889,6 +889,10 @@ fn the_keywords_header_creates_a_keyword() {h.step();h.step();assert!(has(&h, "source:keyword:zebra crossing"), "the new keyword is listed");+ // the sidebar scrolls to it: it is listed last, below what the panel shows+ h.settle(SETTLE);+ let (row, panel) = (widget(&h, "source:keyword:zebra crossing"), widget(&h, "panel:left_panel"));+ assert!(panel.contains_rect(row), "the new keyword is in sight: {row:?} in {panel:?}");}/// A folded section's row count sits to the left of its header button; a section without a button