Skip to content

LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust

LRC-LIB-SMARTCOLL: date picker review fixes: Esc, paging limits, strict parse

Nathaniel Ledford034ef489ed48
diff --git a/crates/ui-egui/src/date_picker.rs b/crates/ui-egui/src/date_picker.rs
index ef801ac08..c04c309af 100644
--- a/crates/ui-egui/src/date_picker.rs
+++ b/crates/ui-egui/src/date_picker.rs
@@ -71,12 +71,16 @@ impl PickedDate {
return Some(PickedDate { year, month: Some(month), day: None });
}
let day = u8::try_from(num(8, 10)?).ok().filter(|d| (1..=days_in_month(year, month)).contains(d))?;
- let time = s.get(10..11);
- (s.get(7..8) == Some("-") && (s.len() == 10 || matches!(time, Some("T" | " ")))).then_some(PickedDate {
- year,
- month: Some(month),
- day: Some(day),
- })
+ // a time after the day (read past) must be one: T10, T10:00 or T10:00:00 (or a space for the T)
+ let time_ok = match s.len() {
+ 10 => true,
+ 13 | 16 | 19 => {
+ matches!(s.get(10..11), Some("T" | " "))
+ && s.char_indices().skip(11).all(|(i, c)| if i == 13 || i == 16 { c == ':' } else { c.is_ascii_digit() })
+ }
+ _ => false,
+ };
+ (s.get(7..8) == Some("-") && time_ok).then_some(PickedDate { year, month: Some(month), day: Some(day) })
}
/// `2026`, `2026-08` or `2026-08-14`.
@@ -149,6 +153,42 @@ struct View {
month: u8,
}
+impl View {
+ /// The view opened on `at`: years kept to 0000–9999 and months to 1–12, whatever a caller's
+ /// value holds.
+ fn open(at: PickedDate, precision: Precision) -> View {
+ View { precision, year: at.year.clamp(0, 9999), month: at.month.unwrap_or(1).clamp(1, 12) }
+ }
+}
+
+/// The page before (`forward` false) or after `v`: a month, a year or twelve years. Paging stops at
+/// years 0000 and 9999 rather than wrapping or leaving four-digit years.
+fn step(v: View, forward: bool) -> View {
+ let (year, month) = match v.precision {
+ Precision::Day => {
+ let m = i32::from(v.month) - 1 + if forward { 1 } else { -1 };
+ (v.year.saturating_add(m.div_euclid(12)), u8::try_from(m.rem_euclid(12) + 1).unwrap_or(1))
+ }
+ Precision::Month => (v.year.saturating_add(if forward { 1 } else { -1 }), v.month),
+ Precision::Year => {
+ // pages of twelve years (2016–2027); the first and last pages hold the ends
+ let page = v.year.div_euclid(12).saturating_add(if forward { 1 } else { -1 });
+ (page.saturating_mul(12), v.month)
+ }
+ };
+ let years = 0..=9999;
+ let fits = match v.precision {
+ Precision::Year => years.contains(&year) || years.contains(&year.saturating_add(11)),
+ _ => years.contains(&year),
+ };
+ if fits { View { year, month, ..v } } else { v }
+}
+
+/// Whether picking `cell` would cover today: its day, its month or its year.
+fn holds_today(cell: &PickedDate, today: Option<PickedDate>) -> bool {
+ today.is_some_and(|t| t.first_day() >= cell.first_day() && t.first_day() <= cell.last_day())
+}
+
/// A calendar button that edits a [`PickedDate`]; see the module docs.
pub struct DatePicker<'a> {
id: String,
@@ -160,8 +200,9 @@ pub struct DatePicker<'a> {
}
impl<'a> DatePicker<'a> {
- /// `id` keeps pickers apart (and names their widgets); `value` is what they edit (`None`: no
- /// date yet, or one that couldn't be read).
+ /// `id` keeps pickers apart and names their widgets, so it must be unique among the pickers
+ /// on screen (two with the same id share their open page); `value` is what they edit (`None`:
+ /// no date yet, or one that couldn't be read).
pub fn new(id: impl Into<String>, value: &'a mut Option<PickedDate>) -> Self {
DatePicker { id: id.into(), value, precisions: &Precision::ALL, min: None, max: None, today: None }
}
@@ -204,7 +245,7 @@ impl<'a> DatePicker<'a> {
let at = value.or(today).unwrap_or(PickedDate::year(2026));
let fallback = if precisions.contains(&Precision::Day) { Precision::Day } else { precisions.first().copied().unwrap_or(Precision::Day) };
let precision = value.map(|v| v.precision()).filter(|p| precisions.contains(p)).unwrap_or(fallback);
- ui.data_mut(|d| d.insert_temp(state, View { precision, year: at.year, month: at.month.unwrap_or(1) }));
+ ui.data_mut(|d| d.insert_temp(state, View::open(at, precision)));
}
let mut picked: Option<PickedDate> = None;
let mut view = ui.data(|d| d.get_temp::<View>(state)).unwrap_or(View { precision: Precision::Day, year: 2026, month: 1 });
@@ -239,28 +280,17 @@ impl<'a> DatePicker<'a> {
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
let next = ui.small_button("›");
register(ui.ctx(), format!("datePickerNext:{id}"), next.rect);
- let step = |v: &mut View, forward: bool| match v.precision {
- Precision::Day => {
- let m = i32::from(v.month) - 1 + if forward { 1 } else { -1 };
- v.year += m.div_euclid(12);
- v.month = u8::try_from(m.rem_euclid(12) + 1).unwrap_or(1);
- }
- Precision::Month => v.year += if forward { 1 } else { -1 },
- Precision::Year => v.year += if forward { 12 } else { -12 },
- };
if next.clicked() {
- step(&mut view, true);
+ view = step(view, true);
}
if prev.clicked() {
- step(&mut view, false);
+ view = step(view, false);
}
});
});
- // four-digit years, as dates are written
- view.year = view.year.clamp(0, 9999);
let cell = |ui: &mut Ui, date: PickedDate, text: String, picked: &mut Option<PickedDate>| {
let allowed = in_bounds(&date, min.as_ref(), max.as_ref());
- let text = if today == Some(date) { RichText::new(text).strong().underline() } else { RichText::new(text) };
+ let text = if holds_today(&date, today) { RichText::new(text).strong().underline() } else { RichText::new(text) };
let r = ui.add_enabled(allowed, egui::Button::selectable(*value == Some(date), text).min_size(vec2(26.0, 0.0)));
register(ui.ctx(), format!("datePickerCell:{}:{id}", date.iso()), r.rect);
if r.clicked() {
@@ -310,6 +340,11 @@ impl<'a> DatePicker<'a> {
}
}
});
+ // Esc closes the calendar 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();
}
@@ -358,6 +393,48 @@ mod tests {
assert_eq!(month_grid(2026, 6).first(), Some(&Some(1)), "June 2026 starts on a Monday");
}
+ /// Paging stops at years 0000 and 9999 instead of wrapping (‹ on January 0000 stays there),
+ /// and a view opened on a year beyond them starts at the nearest end.
+ #[test]
+ fn paging_stops_at_the_ends() {
+ let v = |precision, year, month| View { precision, year, month };
+ let at = |v: View| (v.year, v.month);
+ assert_eq!(at(step(v(Precision::Day, 2026, 12), true)), (2027, 1));
+ assert_eq!(at(step(v(Precision::Day, 2026, 1), false)), (2025, 12));
+ assert_eq!(at(step(v(Precision::Day, 0, 1), false)), (0, 1));
+ assert_eq!(at(step(v(Precision::Day, 9999, 12), true)), (9999, 12));
+ assert_eq!(at(step(v(Precision::Month, 0, 5), false)), (0, 5));
+ assert_eq!(at(step(v(Precision::Month, 9999, 5), true)), (9999, 5));
+ assert_eq!(at(step(v(Precision::Year, 5, 1), false)), (5, 1), "the first page of years");
+ assert_eq!(at(step(v(Precision::Year, 9990, 1), true)), (9996, 1), "the page holding 9996–9999");
+ assert_eq!(at(step(v(Precision::Year, 9996, 1), true)), (9996, 1), "the last page");
+ assert_eq!(at(step(v(Precision::Year, 2026, 1), false)), (2004, 1), "the page 2004–2015");
+ let huge = PickedDate { year: i32::MAX, month: Some(13), day: None };
+ assert_eq!(at(View::open(huge, Precision::Day)), (9999, 12));
+ assert_eq!(at(View::open(PickedDate { year: i32::MIN, month: Some(0), day: None }, Precision::Day)), (0, 1));
+ }
+
+ /// The picker reads a date the way the rule check does: a time after it must be a time.
+ #[test]
+ fn a_trailing_time_must_be_a_time() {
+ for ok in ["2026-08-14T10", "2026-08-14T10:00", "2026-08-14 10:00:00"] {
+ assert!(PickedDate::parse(ok).is_some(), "{ok}");
+ }
+ for bad in ["2026-08-14Tjunk", "2026-08-14T", "2026-08-14T1", "2026-08-14T10:0", "2026-08-14T10:00Z"] {
+ assert_eq!(PickedDate::parse(bad), None, "{bad}");
+ }
+ }
+
+ /// Today is marked in every view: its day, its month, its year.
+ #[test]
+ fn today_is_marked_at_every_precision() {
+ let d = |s: &str| PickedDate::parse(s).unwrap();
+ let today = Some(d("2026-10-09"));
+ assert!(holds_today(&d("2026-10-09"), today) && holds_today(&d("2026-10"), today) && holds_today(&d("2026"), today));
+ assert!(!holds_today(&d("2026-10-08"), today) && !holds_today(&d("2026-09"), today) && !holds_today(&d("2025"), today));
+ assert!(!holds_today(&d("2026"), None));
+ }
+
#[test]
fn bounds_keep_whole_values_in_range() {
let d = |s: &str| PickedDate::parse(s).unwrap();
diff --git a/crates/ui-egui/src/i18n.rs b/crates/ui-egui/src/i18n.rs
index 445028562..7ba6a47e2 100644
--- a/crates/ui-egui/src/i18n.rs
+++ b/crates/ui-egui/src/i18n.rs
@@ -779,7 +779,7 @@ mod tests {
#[test]
fn date_picker_words_are_translated() {
for language in Locale::ALL.iter().filter(|l| **l != Locale::En) {
- for word in crate::date_picker::WEEKDAY_SHORT.iter().chain(&["Pick a date"]) {
+ for word in crate::date_picker::WEEKDAY_SHORT.iter().chain(&["Pick a date", "Year", "Month", "Day"]) {
assert!(language.catalog().contains_key(*word), "{} lacks {word:?}", language.code());
}
}
diff --git a/crates/ui-egui/src/panels/dialogs.rs b/crates/ui-egui/src/panels/dialogs.rs
index d540baa9d..91d1af6ef 100644
--- a/crates/ui-egui/src/panels/dialogs.rs
+++ b/crates/ui-egui/src/panels/dialogs.rs
@@ -877,8 +877,9 @@ pub fn show(app: &mut LightcraftApp, ctx: &egui::Context) {
ctx.move_to_top(w.response.layer_id);
crate::widgets::register(ctx, "dialog:window", w.response.rect);
}
- // (while the shortcuts editor records a key, it takes Esc itself to cancel)
- if ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
+ // (while the shortcuts editor records a key, it takes Esc itself to cancel; an open popup in
+ // the dialog, such as a date picker's calendar, takes it to close itself)
+ if ctx.input(|i| i.key_pressed(egui::Key::Escape)) && !crate::widgets::escape_taken(ctx) {
close = true;
}
if confirm {
diff --git a/crates/ui-egui/src/panels/rules_editor.rs b/crates/ui-egui/src/panels/rules_editor.rs
index a29487ba6..7d7b2c4b7 100644
--- a/crates/ui-egui/src/panels/rules_editor.rs
+++ b/crates/ui-egui/src/panels/rules_editor.rs
@@ -91,7 +91,8 @@ fn number_value(ui: &mut egui::Ui, v: &mut Value, field: &str) {
}
/// A rule date's calendar ([`DatePicker`]): opens on the date as written (or today), keeps its
-/// precision, and writes what is picked as `2026`, `2026-08` or `2026-08-14`.
+/// precision, and writes what is picked as `2026`, `2026-08` or `2026-08-14`. It picks dates, not
+/// times: picking a day for "2026-08-14T10:00" leaves "2026-08-14" (a time is typed).
fn date_picker(ui: &mut egui::Ui, v: &mut Value, salt: &str, min: Option<PickedDate>, max: Option<PickedDate>, env: &Env) {
let mut date = v.as_str().and_then(PickedDate::parse);
let today = PickedDate::parse(&env.today);
diff --git a/crates/ui-egui/src/shortcuts.rs b/crates/ui-egui/src/shortcuts.rs
index cd69b2daa..0ebb0808c 100644
--- a/crates/ui-egui/src/shortcuts.rs
+++ b/crates/ui-egui/src/shortcuts.rs
@@ -296,11 +296,15 @@ pub fn handle(app: &mut LightcraftApp, ctx: &egui::Context) {
let keymap = &app.ui.settings.keymap;
// keys the user gave to a command: the fixed bindings below (aliases, ratings) yield to them
let taken: Vec<(Modifiers, Key)> = keymap.values().filter_map(|s| parse(s)).collect();
+ // an open popup (a menu, a date picker's calendar) closes on Esc itself: Esc's command (Back,
+ // which also closes dialogs) waits until nothing is open
+ let popup_open = egui::Popup::is_any_open(ctx);
ctx.input(|i| {
for b in bindable() {
if let Some(sc) = binding(keymap, b.id, b.default)
&& let Some((m, k)) = parse(sc)
&& !native(sc)
+ && !(k == Key::Escape && popup_open)
&& matches(i, m, k)
{
fire.push(b.id.to_string());
@@ -308,6 +312,7 @@ pub fn handle(app: &mut LightcraftApp, ctx: &egui::Context) {
}
for (sc, id, params) in ALIASES {
if let Some((m, k)) = parse(sc).filter(|_| !native(sc))
+ && !(k == Key::Escape && popup_open)
&& !taken.contains(&(m, k))
&& matches(i, m, k)
{
diff --git a/crates/ui-egui/src/tests_date_picker.rs b/crates/ui-egui/src/tests_date_picker.rs
index 63565b22d..ba5e28113 100644
--- a/crates/ui-egui/src/tests_date_picker.rs
+++ b/crates/ui-egui/src/tests_date_picker.rs
@@ -88,3 +88,16 @@ fn an_unreadable_date_opens_on_this_month() {
assert!(has(&h, "datePickerCell:2026-10-09:rules-0"));
assert_eq!(value(&h, 0), json!("banana"), "opening doesn't change the rule");
}
+
+/// Esc closes the calendar only, not the rule editor around it (and its unsaved edits).
+#[test]
+fn escape_closes_only_the_calendar() {
+ let mut h = editor(json!([{"field": "captureDate", "op": "is", "value": "2026-01-20"}]));
+ click(&mut h, "datePicker:rules-0");
+ assert!(has(&h, "datePickerCell:2026-01-20:rules-0"));
+ let r = h.request("ui.key", json!({"key": "Escape"}), T);
+ assert_eq!(r["ok"], true, "{r}");
+ h.settle(SETTLE);
+ assert!(!has(&h, "datePickerCell:2026-01-20:rules-0"), "the calendar closed");
+ assert!(h.app.ui.dialog.is_some(), "the editor stays open");
+}
diff --git a/crates/ui-egui/src/widgets.rs b/crates/ui-egui/src/widgets.rs
index c98baf41f..b221f725e 100644
--- a/crates/ui-egui/src/widgets.rs
+++ b/crates/ui-egui/src/widgets.rs
@@ -19,6 +19,19 @@ pub fn register(ctx: &egui::Context, id: impl Into<String>, rect: Rect) {
ctx.data_mut(|d| d.get_temp_mut_or_default::<Registry>(egui::Id::new("lc-registry")).0.push((id, rect)));
}
+/// Esc was handled this frame by something nested (an open popup closed on it): containers such
+/// as dialogs shouldn't close too. Kept for the whole frame, since egui may run it in more than one
+/// pass and the popup is already closed in the later ones.
+pub fn take_escape(ctx: &egui::Context) {
+ let frame = ctx.cumulative_frame_nr();
+ ctx.data_mut(|d| d.insert_temp(egui::Id::new("lc-escape-taken"), frame));
+}
+
+/// Whether [`take_escape`] was called this frame.
+pub fn escape_taken(ctx: &egui::Context) -> bool {
+ ctx.data(|d| d.get_temp::<u64>(egui::Id::new("lc-escape-taken"))) == Some(ctx.cumulative_frame_nr())
+}
+
pub fn take_registry(ctx: &egui::Context) -> Vec<(String, Rect)> {
ctx.data_mut(|d| std::mem::take(&mut d.get_temp_mut_or_default::<Registry>(egui::Id::new("lc-registry")).0))
}
diff --git a/docs/whats-new.md b/docs/whats-new.md
index 0db41edb3..2f5799b9e 100644
--- a/docs/whats-new.md
+++ b/docs/whats-new.md
@@ -18,7 +18,8 @@
album that is gone or smart, or an empty group is reported with its rule ("rule 2.1: rating is 0–5, not 9")
instead of quietly matching nothing or everything. New date rules start at the current year.
- Date rules have a calendar button: pick a day, a month or a whole year (Year / Month / Day), in your language; the
- two dates of a "between" can't be picked out of order. Typing still works, and "2026-10-01 10:00" (a space for the
+ two dates of a "between" can't be picked out of order; Esc closes just the calendar. It picks dates, not times (a
+ time is typed, and picking a day replaces one). Typing still works, and "2026-10-01 10:00" (a space for the
T) now matches; a time zone is refused, since capture times are local.
- Rule problems are shown in your language and name the field the way the menu does ("Title: needs something to look
for").