LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
LRC-LIB-SMARTCOLL: a standalone album picker with a tree and search
Nathaniel Ledford94de255e7461
diff --git a/crates/ui-egui/locales/de.json b/crates/ui-egui/locales/de.jsonindex fa06ae57e..bc4ef39b4 100644--- a/crates/ui-egui/locales/de.json+++ b/crates/ui-egui/locales/de.json@@ -1932,5 +1932,8 @@"Su": "So","Pick a date": "Datum wählen","would make this album include itself through other smart albums": "würde dieses Album über andere Smart-Alben sich selbst enthalten lassen",- "Smart Albums": "Smart-Alben"+ "Search albums": "Alben suchen",+ "No albums match": "Kein Album passt",+ "This is the album you're editing": "Das ist das Album, das du bearbeitest",+ "It tests this album, so testing it back would loop": "Es prüft dieses Album; es zurückzuprüfen wäre ein Kreis"}diff --git a/crates/ui-egui/locales/es.json b/crates/ui-egui/locales/es.jsonindex faf2a4e21..9e30e2667 100644--- a/crates/ui-egui/locales/es.json+++ b/crates/ui-egui/locales/es.json@@ -1777,5 +1777,8 @@"Su": "Do","Pick a date": "Elegir una fecha","would make this album include itself through other smart albums": "haría que este álbum se incluyera a sí mismo a través de otros álbumes inteligentes",- "Smart Albums": "Álbumes inteligentes"+ "Search albums": "Buscar álbumes",+ "No albums match": "Ningún álbum coincide",+ "This is the album you're editing": "Es el álbum que estás editando",+ "It tests this album, so testing it back would loop": "Comprueba este álbum, así que comprobarlo a su vez crearía un bucle"}diff --git a/crates/ui-egui/locales/ja.json b/crates/ui-egui/locales/ja.jsonindex 11882d7f5..dfc6405aa 100644--- a/crates/ui-egui/locales/ja.json+++ b/crates/ui-egui/locales/ja.json@@ -1781,5 +1781,8 @@"Su": "日","Pick a date": "日付を選択","would make this album include itself through other smart albums": "ほかのスマートアルバムを通じて、このアルバム自身を含むことになります",- "Smart Albums": "スマートアルバム"+ "Search albums": "アルバムを検索",+ "No albums match": "一致するアルバムはありません",+ "This is the album you're editing": "編集中のアルバムです",+ "It tests this album, so testing it back would loop": "このアルバムを条件にしているため、逆に指定すると循環します"}diff --git a/crates/ui-egui/locales/pt-br.json b/crates/ui-egui/locales/pt-br.jsonindex cefdaeb23..dd3ef316d 100644--- a/crates/ui-egui/locales/pt-br.json+++ b/crates/ui-egui/locales/pt-br.json@@ -1777,5 +1777,8 @@"Su": "Dom","Pick a date": "Escolher uma data","would make this album include itself through other smart albums": "faria este álbum incluir a si mesmo por meio de outros álbuns inteligentes",- "Smart Albums": "Álbuns inteligentes"+ "Search albums": "Buscar álbuns",+ "No albums match": "Nenhum álbum corresponde",+ "This is the album you're editing": "É o álbum que você está editando",+ "It tests this album, so testing it back would loop": "Ele testa este álbum, então testá-lo de volta criaria um ciclo"}diff --git a/crates/ui-egui/locales/ru.json b/crates/ui-egui/locales/ru.jsonindex 40beb384a..2b58d95d8 100644--- a/crates/ui-egui/locales/ru.json+++ b/crates/ui-egui/locales/ru.json@@ -1469,5 +1469,8 @@"Su": "Вс","Pick a date": "Выбрать дату","would make this album include itself through other smart albums": "альбом включал бы сам себя через другие смарт-альбомы",- "Smart Albums": "Смарт-альбомы"+ "Search albums": "Поиск альбомов",+ "No albums match": "Нет подходящих альбомов",+ "This is the album you're editing": "Это альбом, который вы изменяете",+ "It tests this album, so testing it back would loop": "Он проверяет этот альбом, поэтому обратная проверка создаст цикл"}diff --git a/crates/ui-egui/locales/zh-hans.json b/crates/ui-egui/locales/zh-hans.jsonindex c4dcefbdd..adf2f3cfb 100644--- a/crates/ui-egui/locales/zh-hans.json+++ b/crates/ui-egui/locales/zh-hans.json@@ -1777,5 +1777,8 @@"Su": "日","Pick a date": "选择日期","would make this album include itself through other smart albums": "会通过其他智能相册让此相册包含自身",- "Smart Albums": "智能相册"+ "Search albums": "搜索相册",+ "No albums match": "没有匹配的相册",+ "This is the album you're editing": "这是正在编辑的相册",+ "It tests this album, so testing it back would loop": "它引用了此相册,反过来引用会形成循环"}diff --git a/crates/ui-egui/locales/zh-hant.json b/crates/ui-egui/locales/zh-hant.jsonindex 6918e393f..3a93d1ed7 100644--- a/crates/ui-egui/locales/zh-hant.json+++ b/crates/ui-egui/locales/zh-hant.json@@ -1777,5 +1777,8 @@"Su": "日","Pick a date": "選擇日期","would make this album include itself through other smart albums": "會透過其他智慧型相簿讓此相簿包含自身",- "Smart Albums": "智慧型相簿"+ "Search albums": "搜尋相簿",+ "No albums match": "沒有符合的相簿",+ "This is the album you're editing": "這是正在編輯的相簿",+ "It tests this album, so testing it back would loop": "它引用了此相簿,反過來引用會形成循環"}diff --git a/crates/ui-egui/src/album_picker.rs b/crates/ui-egui/src/album_picker.rsnew file mode 100644index 000000000..7800363c0--- /dev/null+++ b/crates/ui-egui/src/album_picker.rs@@ -0,0 +1,371 @@+//! An album picker: a button that opens a popup to pick an album or a smart album, by browsing a+//! tree like the sidebar's or by typing part of its name.+//!+//! Standalone: it edits an `Option<u64>` album id over a list of [`AlbumEntry`]s, in tree order+//! ([`entries_from`] builds it from a catalog in the sidebar's order). Folders are for browsing,+//! not picking. An entry can be `blocked` with a reason: shown greyed, the reason on hover.+//!+//! With nothing typed it shows the tree, folders closed except those holding the current choice.+//! Typing lists the albums whose path ("Folder / Name") holds every word typed, names starting+//! with it first; ↑ / ↓ move through them, Enter picks, Esc closes. Widget ids for tests and agents:+//! `albumPicker:<id>` (the button), `albumPickerSearch:<id>`, `albumPickerFolder:<folder>:<id>`+//! and `albumPickerItem:<album>:<id>`.++use egui::{Response, RichText, Ui, vec2};++use crate::icons::Icon;+use crate::widgets::register;++/// One row of the picker: an album, a smart album or a folder.+#[derive(Clone, Debug, PartialEq)]+pub struct AlbumEntry {+ pub id: u64,+ pub name: String,+ pub parent: Option<u64>,+ /// How deep in folders (0 at the top), from [`set_depths`].+ pub depth: usize,+ pub folder: bool,+ pub smart: bool,+ /// Why it can't be picked, when it can't (shown on hover).+ pub blocked: Option<String>,+}++/// Every album, smart album and folder of `cat` in the sidebar's order (folders first, the user's+/// order, else by name), each folder followed by what it holds. `blocked` says why an album can't+/// be picked, if so.+pub fn entries_from(cat: &lightcraft_catalog::Catalog, blocked: impl Fn(&lightcraft_catalog::Album) -> Option<String>) -> Vec<AlbumEntry> {+ let kids = cat.album_children_by_parent();+ let mut out = Vec::new();+ // depth-first, guarded against a parent loop in a damaged catalog+ let mut stack: Vec<(Option<lightcraft_catalog::AlbumId>, usize)> = vec![(None, 0)];+ let mut seen = std::collections::HashSet::new();+ fn walk(+ parent: Option<lightcraft_catalog::AlbumId>,+ kids: &std::collections::HashMap<Option<lightcraft_catalog::AlbumId>, Vec<&lightcraft_catalog::Album>>,+ blocked: &dyn Fn(&lightcraft_catalog::Album) -> Option<String>,+ seen: &mut std::collections::HashSet<lightcraft_catalog::AlbumId>,+ out: &mut Vec<AlbumEntry>,+ depth: usize,+ ) {+ if depth > 64 {+ return;+ }+ for a in kids.get(&parent).map(Vec::as_slice).unwrap_or_default() {+ if !seen.insert(a.id) {+ continue;+ }+ out.push(AlbumEntry {+ id: a.id.0,+ name: a.name.clone(),+ parent: a.parent.map(|p| p.0),+ depth,+ folder: a.folder,+ smart: a.is_smart(),+ blocked: if a.folder { None } else { blocked(a) },+ });+ if a.folder {+ walk(Some(a.id), kids, blocked, seen, out, depth + 1);+ }+ }+ }+ stack.clear();+ walk(None, &kids, &blocked, &mut seen, &mut out, 0);+ out+}++/// Fill in each entry's depth from its parents (for lists built by hand).+pub fn set_depths(entries: &mut [AlbumEntry]) {+ let depths: Vec<usize> = entries.iter().map(|e| ancestors(entries, e.id).len()).collect();+ for (e, d) in entries.iter_mut().zip(depths) {+ e.depth = d;+ }+}++/// The folders holding album `id`, nearest first; empty at the top level or for an unknown id.+pub fn ancestors(entries: &[AlbumEntry], id: u64) -> Vec<u64> {+ let mut out = Vec::new();+ let mut at = entries.iter().find(|e| e.id == id).and_then(|e| e.parent);+ while let Some(p) = at {+ if out.contains(&p) || out.len() > 64 {+ break;+ }+ out.push(p);+ at = entries.iter().find(|e| e.id == p).and_then(|e| e.parent);+ }+ out+}++/// "Folder / Sub / Name" for album `id`; empty for an unknown id.+pub fn path_label(entries: &[AlbumEntry], id: u64) -> String {+ let Some(entry) = entries.iter().find(|e| e.id == id) else { return String::new() };+ let mut parts: Vec<&str> =+ ancestors(entries, id).iter().rev().filter_map(|p| entries.iter().find(|e| e.id == *p)).map(|e| e.name.as_str()).collect();+ parts.push(&entry.name);+ parts.join(" / ")+}++/// The rows a tree shows with the folders in `open` open: indexes into `entries`.+pub fn visible_tree(entries: &[AlbumEntry], open: &[u64]) -> Vec<usize> {+ (0..entries.len()).filter(|&i| ancestors(entries, entries[i].id).iter().all(|a| open.contains(a))).collect()+}++/// The albums (not folders) whose path holds every word of `query`, any case: those whose own+/// name starts with the query first, then the rest, each in tree order. Indexes into `entries`.+pub fn search(entries: &[AlbumEntry], query: &str) -> Vec<usize> {+ let query = query.trim().to_lowercase();+ let words: Vec<&str> = query.split_whitespace().collect();+ if words.is_empty() {+ return Vec::new();+ }+ let hits: Vec<usize> = (0..entries.len())+ .filter(|&i| !entries[i].folder)+ .filter(|&i| {+ let path = path_label(entries, entries[i].id).to_lowercase();+ words.iter().all(|w| path.contains(w))+ })+ .collect();+ let (first, rest): (Vec<usize>, Vec<usize>) = hits.into_iter().partition(|&i| entries[i].name.to_lowercase().starts_with(&query));+ first.into_iter().chain(rest).collect()+}++/// A small filled triangle centred on `c`: pointing down (`down`), else right.+fn triangle(p: &egui::Painter, c: egui::Pos2, down: bool, color: egui::Color32) {+ let pts = if down {+ vec![c + vec2(-4.0, -2.0), c + vec2(4.0, -2.0), c + vec2(0.0, 3.0)]+ } else {+ vec![c + vec2(-2.0, -4.0), c + vec2(3.0, 0.0), c + vec2(-2.0, 4.0)]+ };+ p.add(egui::Shape::convex_polygon(pts, color, egui::Stroke::NONE));+}++/// What the open popup remembers between frames.+#[derive(Clone, Default)]+struct State {+ query: String,+ open: Vec<u64>,+ /// The highlighted search result (↑ / ↓, Enter).+ highlight: usize,+ focus: bool,+}++/// A button that edits an album id; see the module docs.+pub struct AlbumPicker<'a> {+ id: String,+ value: &'a mut Option<u64>,+ entries: &'a [AlbumEntry],+ width: f32,+}++impl<'a> AlbumPicker<'a> {+ /// `id` must be unique among the pickers on screen (it names their widgets and keeps their+ /// state apart); `value` is the album picked (`None`: none yet); `entries` in tree order.+ pub fn new(id: impl Into<String>, value: &'a mut Option<u64>, entries: &'a [AlbumEntry]) -> Self {+ AlbumPicker { id: id.into(), value, entries, width: 180.0 }+ }++ /// The button's width (180 by default).+ pub fn width(mut self, width: f32) -> Self {+ self.width = width;+ self+ }++ /// The button and, while open, the popup. The response is `changed()` when an album was picked.+ pub fn show(self, ui: &mut Ui) -> Response {+ let AlbumPicker { id, value, entries, width } = self;+ let chosen = value.filter(|v| entries.iter().any(|e| e.id == *v && !e.folder));+ let text = chosen.map_or_else(|| crate::i18n::tr("Choose an album…").to_string(), |c| path_label(entries, c));+ // the name, and a drop-down arrow painted at the right (the UI font has no arrow glyph)+ let mut button = ui.add_sized(vec2(width, ui.spacing().interact_size.y), egui::Button::new(text).truncate().right_text(" "));+ let arrow_color = crate::theme::Tokens::get(ui.ctx()).icon;+ triangle(ui.painter(), egui::pos2(button.rect.right() - 10.0, button.rect.center().y), true, arrow_color);+ register(ui.ctx(), format!("albumPicker:{id}"), button.rect);+ let key = egui::Id::new(("albumPicker", id.as_str()));+ if button.clicked() {+ // open on the chosen album's folders, with the search empty and ready for typing+ let open = chosen.map(|c| ancestors(entries, c)).unwrap_or_default();+ ui.data_mut(|d| d.insert_temp(key, State { open, focus: true, ..Default::default() }));+ }+ let mut state: State = ui.data(|d| d.get_temp(key)).unwrap_or_default();+ let mut picked: Option<u64> = None;+ egui::Popup::from_toggle_button_response(&button).close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside).show(|ui| {+ ui.set_min_width(width.max(260.0));+ ui.set_max_width(width.max(260.0) + 120.0);+ let search_box =+ ui.add(egui::TextEdit::singleline(&mut state.query).hint_text(crate::i18n::tr("Search albums")).desired_width(f32::INFINITY));+ register(ui.ctx(), format!("albumPickerSearch:{id}"), search_box.rect);+ if state.focus {+ search_box.request_focus();+ state.focus = false;+ }+ if search_box.changed() {+ state.highlight = 0;+ }+ let t = crate::theme::Tokens::get(ui.ctx());+ let row = |ui: &mut Ui, e: &AlbumEntry, label: &str, indent: f32, highlighted: bool, picked: &mut Option<u64>| {+ ui.horizontal(|ui| {+ ui.add_space(indent);+ let (r, _) = ui.allocate_exact_size(vec2(14.0, 14.0), egui::Sense::hover());+ let icon = if e.smart { Icon::SmartAlbum } else { Icon::Album };+ crate::icons::paint(ui.painter(), r, icon, if e.blocked.is_some() { t.text_disabled } else { t.icon });+ let resp = ui.add_enabled(e.blocked.is_none(), egui::Button::selectable(Some(e.id) == chosen || highlighted, label));+ register(ui.ctx(), format!("albumPickerItem:{}:{id}", e.id), resp.rect);+ let resp = match &e.blocked {+ Some(why) => resp.on_disabled_hover_text(why.as_str()),+ None => resp,+ };+ if resp.clicked() {+ *picked = Some(e.id);+ }+ if highlighted {+ resp.scroll_to_me(None);+ }+ });+ };+ egui::ScrollArea::vertical().max_height(320.0).auto_shrink([false, true]).show(ui, |ui| {+ if state.query.trim().is_empty() {+ for i in visible_tree(entries, &state.open) {+ let e = &entries[i];+ let indent = e.depth as f32 * 16.0;+ if e.folder {+ // a folder row folds and unfolds, like the sidebar's: triangle, icon, name+ let open = state.open.contains(&e.id);+ let height = ui.spacing().interact_size.y;+ let (rect, r) = ui.allocate_exact_size(vec2(ui.available_width(), height), egui::Sense::click());+ if r.hovered() {+ ui.painter().rect_filled(rect, 3.0, t.hover);+ }+ let x = rect.left() + indent;+ triangle(ui.painter(), egui::pos2(x + 7.0, rect.center().y), open, if r.hovered() { t.text } else { t.text_dim });+ let icon = egui::Rect::from_center_size(egui::pos2(x + 23.0, rect.center().y), vec2(14.0, 14.0));+ crate::icons::paint(ui.painter(), icon, Icon::Folder, t.icon);+ ui.painter().text(+ egui::pos2(x + 36.0, rect.center().y),+ egui::Align2::LEFT_CENTER,+ &e.name,+ egui::TextStyle::Button.resolve(ui.style()),+ t.text_label,+ );+ register(ui.ctx(), format!("albumPickerFolder:{}:{id}", e.id), r.rect);+ if r.clicked() {+ if open {+ state.open.retain(|o| *o != e.id);+ } else {+ state.open.push(e.id);+ }+ }+ } else {+ // past the triangle column, so names line up with folder names+ row(ui, e, &e.name, indent + 14.0, false, &mut picked);+ }+ }+ if entries.iter().all(|e| e.folder) {+ ui.label(RichText::new(crate::i18n::tr("No albums yet")).weak());+ }+ } else {+ let hits = search(entries, &state.query);+ // ↑ / ↓ move through the results that can be picked, Enter picks one+ let pickable: Vec<usize> = hits.iter().copied().filter(|&i| entries[i].blocked.is_none()).collect();+ let (down, up, enter) = ui.input_mut(|i| {+ (+ i.consume_key(egui::Modifiers::NONE, egui::Key::ArrowDown),+ i.consume_key(egui::Modifiers::NONE, egui::Key::ArrowUp),+ i.consume_key(egui::Modifiers::NONE, egui::Key::Enter),+ )+ });+ if down {+ state.highlight = (state.highlight + 1).min(pickable.len().saturating_sub(1));+ }+ if up {+ state.highlight = state.highlight.saturating_sub(1);+ }+ let highlighted = pickable.get(state.highlight).copied();+ if enter && let Some(i) = highlighted {+ picked = Some(entries[i].id);+ }+ for i in &hits {+ let e = &entries[*i];+ row(ui, e, &path_label(entries, e.id), 0.0, highlighted == Some(*i), &mut picked);+ }+ if hits.is_empty() {+ ui.label(RichText::new(crate::i18n::tr("No albums match")).weak());+ }+ }+ });+ // Esc closes the popup and stops there: the dialog around it keeps its edits+ if ui.input(|i| i.key_pressed(egui::Key::Escape)) {+ crate::widgets::take_escape(ui.ctx());+ ui.close();+ }+ if picked.is_some() {+ ui.close();+ }+ });+ ui.data_mut(|d| d.insert_temp(key, state));+ if let Some(p) = picked {+ *value = Some(p);+ button.mark_changed();+ }+ button+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ fn e(id: u64, name: &str, parent: Option<u64>, folder: bool, smart: bool) -> AlbumEntry {+ AlbumEntry { id, name: name.into(), parent, depth: 0, folder, smart, blocked: None }+ }++ /// [UTILS] (folder) > Excluded | Hidden Photos (smart), Uncurated (smart); Trip; Weddings >+ /// Tuscany Wedding+ fn sample() -> Vec<AlbumEntry> {+ let mut v = vec![+ e(1, "[UTILS]", None, true, false),+ e(2, "Excluded | Hidden Photos", Some(1), false, true),+ e(3, "Uncurated", Some(1), false, true),+ e(4, "Trip", None, false, false),+ e(5, "Weddings", None, true, false),+ e(6, "Tuscany Wedding", Some(5), false, true),+ ];+ set_depths(&mut v);+ v+ }++ #[test]+ fn paths_and_depths_follow_the_folders() {+ let v = sample();+ assert_eq!(path_label(&v, 2), "[UTILS] / Excluded | Hidden Photos");+ assert_eq!(path_label(&v, 4), "Trip");+ assert_eq!(path_label(&v, 99), "");+ assert_eq!(v.iter().map(|e| e.depth).collect::<Vec<_>>(), vec![0, 1, 1, 0, 0, 1]);+ assert_eq!(ancestors(&v, 6), vec![5]);+ assert!(ancestors(&v, 4).is_empty());+ }++ #[test]+ fn the_tree_hides_what_closed_folders_hold() {+ let v = sample();+ let ids = |open: &[u64]| visible_tree(&v, open).into_iter().map(|i| v[i].id).collect::<Vec<_>>();+ assert_eq!(ids(&[]), vec![1, 4, 5], "folders closed: only the top level");+ assert_eq!(ids(&[1]), vec![1, 2, 3, 4, 5]);+ assert_eq!(ids(&[1, 5]), vec![1, 2, 3, 4, 5, 6]);+ }++ /// Every word typed is in the album's path (folders included), in any case; names that start+ /// with it come first; folders themselves aren't results.+ #[test]+ fn search_finds_albums_by_any_part_of_their_path() {+ let v = sample();+ let ids = |q: &str| search(&v, q).into_iter().map(|i| v[i].id).collect::<Vec<_>>();+ assert_eq!(ids("excl"), vec![2]);+ assert_eq!(ids("UTILS"), vec![2, 3], "a folder's name finds what it holds");+ assert_eq!(ids("utils uncur"), vec![3], "every word must match");+ assert_eq!(ids("t"), vec![4, 6, 2, 3], "names starting with it first (Trip, Tuscany Wedding), then the rest, each in sidebar order");+ assert_eq!(ids(" "), Vec::<u64>::new(), "an empty search isn't a search");+ assert_eq!(ids("zzz"), Vec::<u64>::new());+ let mut accents = vec![e(7, "Été", None, false, false)];+ set_depths(&mut accents);+ assert_eq!(search(&accents, "été").len(), 1);+ }+}diff --git a/crates/ui-egui/src/i18n.rs b/crates/ui-egui/src/i18n.rsindex 2661095d1..4ed092e51 100644--- a/crates/ui-egui/src/i18n.rs+++ b/crates/ui-egui/src/i18n.rs@@ -765,7 +765,15 @@ mod tests {assert_eq!(problem_text_in(Locale::En, &g[0]), "This group is empty: add a rule or remove it.");// the issues, the operators their hints name and the album picker's words, in every languagefor language in Locale::ALL.iter().filter(|l| **l != Locale::En) {- for word in ["Choose an album…", "No albums yet", "Smart Albums", "Fix the marked rules to save this album."] {+ for word in [+ "Choose an album…",+ "No albums yet",+ "Search albums",+ "No albums match",+ "This is the album you're editing",+ "It tests this album, so testing it back would loop",+ "Fix the marked rules to save this album.",+ ] {assert!(language.catalog().contains_key(word), "{} lacks {word:?}", language.code());}for issue in Issue::ALL {diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex 8f4e0bb2d..9a743e916 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -6,6 +6,7 @@#![forbid(unsafe_code)]#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]+pub mod album_picker;pub mod control;pub mod credits;pub mod date_picker;@@ -33,6 +34,8 @@ pub mod theme;pub mod titlebar;pub mod widgets;+#[cfg(test)]+mod tests_album_picker;#[cfg(test)]mod tests_curve;#[cfg(test)]diff --git a/crates/ui-egui/src/panels/dialogs.rs b/crates/ui-egui/src/panels/dialogs.rsindex 22768a03e..e790d8d3a 100644--- a/crates/ui-egui/src/panels/dialogs.rs+++ b/crates/ui-egui/src/panels/dialogs.rs@@ -251,8 +251,7 @@ pub fn show(app: &mut LightcraftApp, ctx: &egui::Context) {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_choices(&app.session.catalog, *id, false),- smart_albums: album_choices(&app.session.catalog, *id, true),+ albums: album_entries(&app.session.catalog, *id),};egui::ScrollArea::vertical().max_height(360.0).auto_shrink([false, true]).show(ui, |ui| {crate::panels::rules_editor::edit(ui, rules, "rules", 0, &[], &env);@@ -1033,23 +1032,15 @@ fn created_in(app: &mut LightcraftApp, command: &str, params: serde_json::Value)Ok(r)}-/// The albums (`smart` false) or smart albums an Album rule in smart album `editing` can test, as-/// (id, "Folder / Name"), sorted by name: no folders, and no smart album that is `editing` itself-/// or tests it (that would loop back).-fn album_choices(cat: &lightcraft_catalog::Catalog, editing: Option<u64>, smart: bool) -> Vec<(u64, String)> {+/// 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> {let editing = editing.map(lightcraft_catalog::AlbumId);- let mut albums: Vec<(u64, String)> = cat- .albums()- .filter(|a| !a.folder && a.is_smart() == smart)- .filter(|a| editing.is_none_or(|e| a.id != e && !cat.album_reaches(a.id, e)))- .map(|a| {- // "Folder / Album", so albums of the same name in two folders differ- let folder = a.parent.and_then(|f| cat.album(f)).map(|f| f.name.as_str());- (a.id.0, folder.map_or_else(|| a.name.clone(), |f| format!("{f} / {}", a.name)))- })- .collect();- albums.sort_by_key(|a| a.1.to_lowercase());- albums+ 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()),+ Some(e) if cat.album_reaches(a.id, e) => Some(crate::i18n::tr("It tests this album, so testing it back would loop").to_string()),+ _ => None,+ })}pub fn confirm_dialog(app: &mut LightcraftApp, dlg: &Dialog) -> Result<serde_json::Value, String> {diff --git a/crates/ui-egui/src/panels/rules_editor.rs b/crates/ui-egui/src/panels/rules_editor.rsindex 571be6011..9b8c994f1 100644--- a/crates/ui-egui/src/panels/rules_editor.rs+++ b/crates/ui-egui/src/panels/rules_editor.rs@@ -6,6 +6,7 @@ use lightcraft_catalog::rules::{FIELD_GROUPS, Kind, Problem, TOP_LEVEL_FIELDS, buse lightcraft_catalog::{Match, Rule, RuleSet};use serde_json::{Value, json};+use crate::album_picker::{AlbumEntry, AlbumPicker};use crate::date_picker::{DatePicker, PickedDate};use crate::theme::Tokens;use crate::widgets::register;@@ -110,48 +111,21 @@ pub struct Env {pub problems: Vec<Problem>,/// Today (`YYYY-MM-DD…`, the session's clock): where a date picker opens when a rule has no date.pub today: String,- /// The albums an Album rule can test: (id, name shown, with its folder when it is in one),- /// sorted by that name.- pub albums: Vec<(u64, String)>,- /// The smart albums it can test, the same way: not the album being edited, nor one that tests- /// it (that would loop back).- pub smart_albums: Vec<(u64, String)>,+ /// The albums, smart albums and folders an Album rule picks from, in the sidebar's order+ /// ([`crate::album_picker::entries_from`]); the album being edited and those that would loop+ /// back to it are blocked, with the reason.+ pub albums: Vec<AlbumEntry>,}-/// The album of `albums` an Album rule's value names, read as the catalog reads it (`3`, `"3"`).-fn chosen_album<'a>(v: &Value, albums: &'a [(u64, String)]) -> Option<&'a (u64, String)> {- let id = lightcraft_catalog::rules::album_rule_id(v)?;- albums.iter().find(|a| a.0 == id.0)-}--/// An Album rule's value: an album or a smart album, picked by name.+/// An Album rule's value: an album or a smart album, picked from the tree or by typing+/// ([`AlbumPicker`]). The id is read as the catalog reads it (`3`, `"3"`) and written as a number.fn album_value(ui: &mut egui::Ui, v: &mut Value, salt: &str, env: &Env) {- let chosen = chosen_album(v, &env.albums).or_else(|| chosen_album(v, &env.smart_albums));- let cur = chosen.map(|a| a.0);- let text = chosen.map_or_else(|| crate::i18n::tr("Choose an album…").to_string(), |a| a.1.clone());- let r = egui::ComboBox::from_id_salt(format!("{salt}-album")).width(160.0).selected_text(text).show_ui(ui, |ui| {- let mut item = |ui: &mut egui::Ui, id: u64, name: &str| {- let r = ui.selectable_label(cur == Some(id), name);- register(ui.ctx(), format!("ruleAlbumItem:{id}:{salt}"), r.rect);- if r.clicked() {- *v = json!(id);- }- };- for (id, name) in &env.albums {- item(ui, *id, name);- }- if !env.smart_albums.is_empty() {- ui.separator();- ui.label(RichText::new(crate::i18n::tr("Smart Albums")).weak().small());- for (id, name) in &env.smart_albums {- item(ui, *id, name);- }- }- if env.albums.is_empty() && env.smart_albums.is_empty() {- ui.label(crate::i18n::tr("No albums yet"));- }- });- register(ui.ctx(), format!("ruleAlbum:{salt}"), r.response.rect);+ let mut chosen = lightcraft_catalog::rules::album_rule_id(v).map(|a| a.0);+ if AlbumPicker::new(salt, &mut chosen, &env.albums).width(200.0).show(ui).changed()+ && let Some(id) = chosen+ {+ *v = json!(id);+ }}/// The value editor for one rule.@@ -438,11 +412,6 @@ mod tests {assert_eq!(default_value("captureDate", "is"), json!("2026"));assert_eq!(default_value("captureDate", "between"), json!(["2026-01", "2026-12"]));lightcraft_catalog::rules::set_now(None);- // the picker shows the album a rule names, however the id is written- let albums = vec![(3, "Trip".to_string())];- assert_eq!(chosen_album(&json!(3), &albums).map(|a| a.1.as_str()), Some("Trip"));- assert_eq!(chosen_album(&json!("3"), &albums).map(|a| a.1.as_str()), Some("Trip"));- assert_eq!(chosen_album(&json!(4), &albums), None);assert_eq!(default_value("shutterSpeed", "gte"), json!("1/250"));assert_eq!(default_value("shutterSpeed", "between"), json!(["1/1000", "1/125"]));}diff --git a/crates/ui-egui/src/tests_album_picker.rs b/crates/ui-egui/src/tests_album_picker.rsnew file mode 100644index 000000000..fd9121d5e--- /dev/null+++ b/crates/ui-egui/src/tests_album_picker.rs@@ -0,0 +1,116 @@+//! The album picker in the smart-album rule editor: a tree like the sidebar's, a search that+//! narrows it as you type, keys to pick with, and albums that can't be picked shown greyed.++use std::time::Duration;++use lightcraft_catalog::Rule;+use serde_json::json;++use crate::headless::Headless;+use crate::{LightcraftApp, Services};++const T: Duration = Duration::from_secs(20);+const SETTLE: Duration = Duration::from_secs(120);++fn exec(h: &mut Headless, command: &str, params: serde_json::Value) -> serde_json::Value {+ let r = h.request("engine.execute", json!({"command": command, "params": params}), T);+ assert_eq!(r["ok"], true, "{command}: {r}");+ r["result"].clone()+}++fn id(v: serde_json::Value) -> u64 {+ v["id"].as_u64().expect("an id")+}++fn click(h: &mut Headless, id: &str) {+ let r = h.request("ui.clickWidget", json!({"id": id}), T);+ assert_eq!(r["ok"], true, "{id}: {r}");+ h.settle(SETTLE);+}++fn has(h: &Headless, id: &str) -> bool {+ h.app.widgets.iter().any(|(w, _)| w == id)+}++fn value(h: &Headless) -> serde_json::Value {+ let Some(crate::state::Dialog::SmartRules { rules, .. }) = &h.app.ui.dialog else { panic!("no rule editor") };+ let Some(Rule::Field { value, .. }) = rules.rules.first() else { panic!("no rule") };+ value.clone()+}++struct Library {+ h: Headless,+ utils: u64,+ excluded: u64,+ uncurated: u64,+ trip: u64,+}++/// [UTILS] > Excluded (smart), Uncurated (smart); Trip; and the rule editor on a new album with one+/// Album rule.+fn library() -> Library {+ let app = LightcraftApp::new(lightcraft_engine::Session::with_demo(), Services { png: None, ..Default::default() });+ let mut h = Headless::new(app, [1200.0, 800.0], 1.0);+ let utils = id(exec(&mut h, "album.create", json!({"name": "[UTILS]", "folder": true})));+ let excluded = id(exec(&mut h, "album.createSmart", json!({"name": "Excluded", "rules": {"rating": 1}, "parent": utils})));+ let uncurated = id(exec(&mut h, "album.createSmart", json!({"name": "Uncurated", "rules": {"rating": 0}, "parent": utils})));+ let trip = id(exec(&mut h, "album.create", json!({"name": "Trip", "addSelected": false})));+ exec(&mut h, "dialog.smartAlbum", json!({"name": "Travel"}));+ let Some(crate::state::Dialog::SmartRules { rules, .. }) = &mut h.app.ui.dialog else { panic!("no rule editor") };+ rules.rules = vec![serde_json::from_value(json!({"field": "album", "op": "isNot", "value": null})).unwrap()];+ h.settle(SETTLE);+ Library { h, utils, excluded, uncurated, trip }+}++/// With nothing typed, the picker shows the sidebar's tree: folders start closed and open on click.+#[test]+fn the_tree_opens_folder_by_folder() {+ let Library { mut h, utils, excluded, trip, .. } = library();+ click(&mut h, "albumPicker:rules-0");+ assert!(has(&h, &format!("albumPickerFolder:{utils}:rules-0")) && has(&h, &format!("albumPickerItem:{trip}:rules-0")));+ assert!(!has(&h, &format!("albumPickerItem:{excluded}:rules-0")), "inside a closed folder");+ click(&mut h, &format!("albumPickerFolder:{utils}:rules-0"));+ click(&mut h, &format!("albumPickerItem:{excluded}:rules-0"));+ assert_eq!(value(&h), json!(excluded));+ assert!(!has(&h, &format!("albumPickerItem:{trip}:rules-0")), "picking closes it");+ // it opens again on the chosen album's folder+ click(&mut h, "albumPicker:rules-0");+ assert!(has(&h, &format!("albumPickerItem:{excluded}:rules-0")));+}++/// Typing narrows the albums to those whose path holds every word; Enter picks the first, the+/// arrow keys move through them.+#[test]+fn typing_finds_and_keys_pick() {+ let Library { mut h, excluded, uncurated, trip, .. } = library();+ click(&mut h, "albumPicker:rules-0");+ let r = h.request("ui.text", json!({"text": "utils"}), T);+ assert_eq!(r["ok"], true, "{r}");+ h.settle(SETTLE);+ assert!(has(&h, &format!("albumPickerItem:{excluded}:rules-0")) && has(&h, &format!("albumPickerItem:{uncurated}:rules-0")));+ assert!(!has(&h, &format!("albumPickerItem:{trip}:rules-0")), "Trip doesn't match");+ for key in ["ArrowDown", "Enter"] {+ let r = h.request("ui.key", json!({"key": key}), T);+ assert_eq!(r["ok"], true, "{r}");+ h.settle(SETTLE);+ }+ assert_eq!(value(&h), json!(uncurated), "the second match");+ assert!(h.app.ui.dialog.is_some(), "Enter picked, it didn't confirm the dialog");+}++/// Albums that can't be picked (the one being edited, one that would loop) are shown greyed, not+/// hidden, and clicking them does nothing.+#[test]+fn albums_that_would_loop_are_greyed() {+ let Library { mut h, excluded, .. } = library();+ let rules = json!({"ruleSet": {"rules": [{"field": "album", "op": "isNot", "value": excluded}]}});+ let travel = id(exec(&mut h, "album.createSmart", json!({"name": "Travel", "rules": rules})));+ exec(&mut h, "dialog.smartAlbum", json!({"id": excluded}));+ let Some(crate::state::Dialog::SmartRules { rules, .. }) = &mut h.app.ui.dialog else { panic!("no rule editor") };+ rules.rules = vec![serde_json::from_value(json!({"field": "album", "op": "is", "value": null})).unwrap()];+ h.settle(SETTLE);+ click(&mut h, "albumPicker:rules-0");+ assert!(has(&h, &format!("albumPickerItem:{travel}:rules-0")), "shown");+ click(&mut h, &format!("albumPickerItem:{travel}:rules-0"));+ assert_eq!(value(&h), json!(null), "but not picked");+}diff --git a/crates/ui-egui/src/tests_masking.rs b/crates/ui-egui/src/tests_masking.rsindex 5cf53d1c0..fdf351391 100644--- a/crates/ui-egui/src/tests_masking.rs+++ b/crates/ui-egui/src/tests_masking.rs@@ -392,13 +392,13 @@ fn smart_album_editor_picks_an_album_from_a_list() {rules.rules[0] = serde_json::from_value(json!({"field": "album", "op": "is", "value": 0})).unwrap();h.settle(SETTLE);assert!(h.app.widgets.iter().any(|(w, _)| w == "ruleProblem:rules-0"), "no album chosen yet");- let r = h.request("ui.clickWidget", json!({"id": "ruleAlbum:rules-0"}), T);+ let r = h.request("ui.clickWidget", json!({"id": "albumPicker:rules-0"}), T);assert_eq!(r["ok"], true, "{r}");h.settle(SETTLE);let has = |h: &Headless, id: String| h.app.widgets.iter().any(|(w, _)| *w == id);- assert!(has(&h, format!("ruleAlbumItem:{trip}:rules-0")), "plain albums are offered");- assert!(has(&h, format!("ruleAlbumItem:{smart}:rules-0")), "smart albums too");- let r = h.request("ui.clickWidget", json!({"id": format!("ruleAlbumItem:{trip}:rules-0")}), T);+ assert!(has(&h, format!("albumPickerItem:{trip}:rules-0")), "plain albums are offered");+ assert!(has(&h, format!("albumPickerItem:{smart}:rules-0")), "smart albums too");+ let r = h.request("ui.clickWidget", json!({"id": format!("albumPickerItem:{trip}:rules-0")}), T);assert_eq!(r["ok"], true, "{r}");h.settle(SETTLE);let Some(crate::state::Dialog::SmartRules { rules, .. }) = &h.app.ui.dialog else { panic!("no rule editor") };@@ -480,8 +480,8 @@ fn sidebar_marks_smart_albums_with_problems() {assert!(marked(&h), "its album is gone");}-/// Editing "Excluded Photos" while "Travel" tests it: the list offers neither the album itself nor-/// Travel (testing it would loop back), and a rule set to Travel by other means is marked.+/// Editing "Excluded Photos" while "Travel" tests it: the list shows the album itself and Travel+/// greyed (testing Travel would loop back), and a rule set to Travel by other means is marked.#[test]fn smart_album_editor_keeps_albums_from_including_themselves() {let mut h = detail("panel.edit");@@ -496,13 +496,19 @@ fn smart_album_editor_keeps_albums_from_including_themselves() {h.settle(SETTLE);};set(&mut h, json!(null));- let r = h.request("ui.clickWidget", json!({"id": "ruleAlbum:rules-0"}), T);+ let r = h.request("ui.clickWidget", json!({"id": "albumPicker:rules-0"}), T);assert_eq!(r["ok"], true, "{r}");h.settle(SETTLE);let has = |h: &Headless, id: String| h.app.widgets.iter().any(|(w, _)| *w == id);- assert!(has(&h, format!("ruleAlbumItem:{trip}:rules-0")));- assert!(!has(&h, format!("ruleAlbumItem:{excluded}:rules-0")), "not itself");- assert!(!has(&h, format!("ruleAlbumItem:{travel}:rules-0")), "not an album that tests it");+ assert!(has(&h, format!("albumPickerItem:{trip}:rules-0")));+ // itself and an album that tests it are shown, greyed: clicking them picks nothing+ for blocked in [excluded, travel] {+ let r = h.request("ui.clickWidget", json!({"id": format!("albumPickerItem:{blocked}:rules-0")}), T);+ assert_eq!(r["ok"], true, "{r}");+ h.settle(SETTLE);+ let Some(crate::state::Dialog::SmartRules { rules, .. }) = &h.app.ui.dialog else { panic!("no rule editor") };+ assert!(matches!(&rules.rules[0], Rule::Field { value, .. } if value.is_null()), "{blocked} wasn't picked");+ }let _ = h.request("ui.key", json!({"key": "Escape"}), T);h.settle(SETTLE);set(&mut h, json!(travel));