diff --git a/assets/locales/pending/parameters-sort-by-name.json b/assets/locales/pending/parameters-sort-by-name.json new file mode 100644 index 000000000..10c0370fb --- /dev/null +++ b/assets/locales/pending/parameters-sort-by-name.json @@ -0,0 +1,47 @@ +{ + "en": { + "Back to the original order": "Back to the original order", + "Sort A to Z": "Sort A to Z", + "Sort Z to A": "Sort Z to A" + }, + "ar": { + "Back to the original order": "العودة إلى الترتيب الأصلي", + "Sort A to Z": "فرز تصاعدي", + "Sort Z to A": "فرز تنازلي" + }, + "de": { + "Back to the original order": "Zurück zur ursprünglichen Reihenfolge", + "Sort A to Z": "Von A bis Z sortieren", + "Sort Z to A": "Von Z bis A sortieren" + }, + "es": { + "Back to the original order": "Volver al orden original", + "Sort A to Z": "Ordenar de la A a la Z", + "Sort Z to A": "Ordenar de la Z a la A" + }, + "fr": { + "Back to the original order": "Revenir à l'ordre d'origine", + "Sort A to Z": "Trier de A à Z", + "Sort Z to A": "Trier de Z à A" + }, + "he": { + "Back to the original order": "חזרה לסדר המקורי", + "Sort A to Z": "מיון בסדר עולה", + "Sort Z to A": "מיון בסדר יורד" + }, + "ja": { + "Back to the original order": "元の順序に戻す", + "Sort A to Z": "昇順で並べ替え", + "Sort Z to A": "降順で並べ替え" + }, + "vi": { + "Back to the original order": "Trở về thứ tự ban đầu", + "Sort A to Z": "Sắp xếp từ A đến Z", + "Sort Z to A": "Sắp xếp từ Z đến A" + }, + "zh": { + "Back to the original order": "恢复原始顺序", + "Sort A to Z": "升序排序", + "Sort Z to A": "降序排序" + } +} diff --git a/crates/ui-egui/src/params_dialog.rs b/crates/ui-egui/src/params_dialog.rs index 0cf012147..edce94980 100644 --- a/crates/ui-egui/src/params_dialog.rs +++ b/crates/ui-egui/src/params_dialog.rs @@ -2,7 +2,8 @@ //! //! A window over the engine's `parameters.*` commands: favourites first, then user parameters //! (name, unit, expression, value, comment; add, rename, delete) and model parameters grouped by -//! the sketch or feature they drive (editable). Expressions validate as you type +//! the sketch or feature they drive (editable). The Name heading sorts each section, and each +//! model group, by name in natural order (#8563). Expressions validate as you type //! (`expr.evaluate`) with a live model preview; Enter or leaving the field applies them. //! Escape closes the window and discards pending edits and their preview. //! Import and export go through `parameters.import` / `parameters.export`. @@ -27,6 +28,9 @@ const UNITS: [&str; 10] = ["mm", "cm", "m", "in", "ft", "deg", "rad", "", "um", #[derive(Default)] pub struct ParamsDialog { pub filter: String, + /// The order by name inside each section (#8563); remembered across openings like the + /// sections' open state. + pub(crate) sort: ui_kit::Sort, reset_scroll: bool, /// Expressions being edited, by parameter name. pub editing: std::collections::BTreeMap, @@ -185,6 +189,8 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) { publish(app, ctx); } let Some(mut d) = app.params.take() else { return }; + d.sort = ctx.data_mut(|m| m.get_persisted(sort_id())).unwrap_or_default(); + let sort = d.sort; ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Enter)); let viewport = crate::agent_chat::tool_space(app, crate::shell::content_rect(app, app.viewport.rect.unwrap_or_else(|| ctx.content_rect()))); if !viewport.is_finite() || !viewport.is_positive() { @@ -278,30 +284,16 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) { .map(|r| ui_kit::ContentWidth::name(ui, &r.name)) .fold(crate::theme::Tokens::get().form_label_width, f32::max) .min(crate::theme::Tokens::get().form_card_width); - let favorites: Vec<_> = visible.iter().copied().filter(|r| r.favorite).collect(); + let Sections { favorites, users, groups } = sections(&visible, d.sort); if !favorites.is_empty() { ui_kit::section_count(ui, "favorites", "Favorites", true, Some(favorites.len()), |ui| { table(app, ui, &mut d, &favorites, "fav", name_floor) }); } - let users: Vec<_> = visible.iter().copied().filter(|r| r.source == "user").collect(); ui_kit::section_count(ui, "users", "User Parameters", true, Some(users.len()), |ui| { table(app, ui, &mut d, &users, "user", name_floor); }); ui_kit::section(ui, "models", "Model Parameters", true, |ui| { - // Group once, in listing order, rather than scanning every parameter for - // each feature on every frame (#2733). - let mut groups: Vec<(&str, Vec<&Row>)> = Vec::new(); - let mut indices = std::collections::HashMap::new(); - for r in visible.iter().filter(|r| r.source != "user") { - let index = *indices.entry(r.group.as_str()).or_insert_with(|| { - groups.push((&r.group, Vec::new())); - groups.len() - 1 - }); - if let Some((_, members)) = groups.get_mut(index) { - members.push(r); - } - } ui.scope(|ui| { ui.spacing_mut().indent = crate::theme::Tokens::get().space_14; ui.indent("model_groups", |ui| { @@ -344,11 +336,58 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) { if let Some(rect) = crate::scenario::rect_of("dialog:header") { crate::scenario::publish_handle("params:title", rect.center()); } + if d.sort != sort { + let chosen = d.sort; + ctx.data_mut(|m| m.insert_persisted(sort_id(), chosen)); + } if !close { app.params = Some(d); } } +/// Where the chosen order is kept: egui's persisted memory, like a section's open state. +fn sort_id() -> egui::Id { + egui::Id::new("sc_params_sort") +} + +/// The dialog's sections, each in the chosen order. +struct Sections<'a> { + favorites: Vec<&'a Row>, + users: Vec<&'a Row>, + /// Model parameters by the sketch or feature that drives them, groups in listing order. + groups: Vec<(&'a str, Vec<&'a Row>)>, +} + +/// Split the listed rows into sections and sort each one by name on its own (#8563): a sort +/// orders the rows inside Favorites, User Parameters and each model group, never moves a row +/// to another section, and keeps the groups themselves in the design's order. +fn sections<'a>(visible: &[&'a Row], sort: ui_kit::Sort) -> Sections<'a> { + fn by_name<'o>(r: &'o &Row) -> &'o str { + &r.name + } + let mut favorites: Vec<_> = visible.iter().copied().filter(|r| r.favorite).collect(); + sort.apply(&mut favorites, by_name); + let mut users: Vec<_> = visible.iter().copied().filter(|r| r.source == "user").collect(); + sort.apply(&mut users, by_name); + // Group once, in listing order, rather than scanning every parameter for each feature on + // every frame (#2733). + let mut groups: Vec<(&str, Vec<&Row>)> = Vec::new(); + let mut indices = std::collections::HashMap::new(); + for r in visible.iter().copied().filter(|r| r.source != "user") { + let index = *indices.entry(r.group.as_str()).or_insert_with(|| { + groups.push((&r.group, Vec::new())); + groups.len() - 1 + }); + if let Some((_, members)) = groups.get_mut(index) { + members.push(r); + } + } + for (_, members) in &mut groups { + sort.apply(members, by_name); + } + Sections { favorites, users, groups } +} + fn model_group(app: &mut SolveApp, ui: &mut egui::Ui, d: &mut ParamsDialog, group: &str, rows: &[&Row], name_floor: f32) { // Focused editors and pending drafts must still receive focus-loss/commit events after // scrolling away. The measured size is used only while the group is idle. @@ -417,7 +456,16 @@ fn table(app: &mut SolveApp, ui: &mut egui::Ui, d: &mut ParamsDialog, rows: &[&R Column::new("Comment", 1.0).flex(), Column::new("Actions", 0.0).icon_only().min_content_width(ui_kit::table_row_height()), ]; - ui_kit::table(ui, salt, &columns, crate::i18n::tr("manage.empty"), |ui, table| { + ui_kit::table_custom(ui, salt, &columns, crate::i18n::tr("manage.empty"), |ui, table| { + // The Name heading sorts every section at once, each inside itself (#8563). + table.headers(ui, |ui, index| { + if index != 1 { + return false; + } + let response = ui_kit::sort_header(ui, "Name", &mut d.sort); + crate::scenario::publish_handle(&format!("params:sort:{salt}"), response.rect.center()); + true + }); for (index, r) in rows.iter().enumerate() { // Skip cells outside the clip while preserving the table's row geometry (#2723). // Drafts remain live until their edits have been committed. @@ -433,11 +481,14 @@ fn table(app: &mut SolveApp, ui: &mut egui::Ui, d: &mut ParamsDialog, rows: &[&R d.error = app.run("parameters.favorite", json!({"name": r.name, "favorite": !r.favorite})).err(); } if salt == "user" { + // A sorted list doesn't show the stored order, so moving a row in it + // would jump to a place nobody sees; moving waits for the listed order. + let listed = d.sort == ui_kit::Sort::Listed; for (glyph, tip, neighbour, side) in [ (ui_kit::MOVE_UP, "Move up", index.checked_sub(1).and_then(|i| rows.get(i)), "before"), (ui_kit::MOVE_DOWN, "Move down", rows.get(index + 1), "after"), ] { - let response = ui_kit::compact_button(ui, glyph, tip, neighbour.is_some(), false); + let response = ui_kit::compact_button(ui, glyph, tip, listed && neighbour.is_some(), false); crate::scenario::publish_handle(&format!("param:{side}:{}", r.name), response.rect.center()); if response.clicked() && let Some(neighbour) = neighbour @@ -1162,6 +1213,110 @@ mod tests { assert!(h.app.params.as_ref().unwrap().error.is_none()); } + /// #8563: sorting orders each section, and each model group, by itself. + #[test] + fn sorting_orders_each_section_and_model_group_on_its_own() { + let row = |name: &str, source: &str, group: &str, favorite: bool| Row { + name: name.into(), + source: source.into(), + group: group.into(), + favorite, + ..Default::default() + }; + let listed = [ + row("d10", "user", "", true), + row("width", "user", "", false), + row("d2", "user", "", false), + row("Alpha", "user", "", true), + row("d1", "user", "", false), + row("s_d3", "sketch", "Sketch1", false), + row("s_d1", "sketch", "Sketch1", true), + row("b_len", "feature", "Box1", false), + row("b_h", "feature", "Box1", false), + row("s_d2", "sketch", "Sketch1", false), + ]; + let visible: Vec<&Row> = listed.iter().collect(); + fn names<'a>(rows: &[&'a Row]) -> Vec<&'a str> { + rows.iter().map(|r| r.name.as_str()).collect() + } + let shown = |sort| { + let s = sections(&visible, sort); + (names(&s.favorites), names(&s.users), s.groups.iter().map(|(g, m)| (g.to_string(), names(m))).collect::>()) + }; + let (fav, users, groups) = shown(ui_kit::Sort::Listed); + assert_eq!((fav, users), (vec!["d10", "Alpha", "s_d1"], vec!["d10", "width", "d2", "Alpha", "d1"]), "unsorted: the listed order"); + assert_eq!(groups, [("Sketch1".into(), vec!["s_d3", "s_d1", "s_d2"]), ("Box1".into(), vec!["b_len", "b_h"])]); + let (fav, users, groups) = shown(ui_kit::Sort::Ascending); + assert_eq!(fav, ["Alpha", "d10", "s_d1"]); + assert_eq!(users, ["Alpha", "d1", "d2", "d10", "width"]); + assert_eq!( + groups, + [("Sketch1".into(), vec!["s_d1", "s_d2", "s_d3"]), ("Box1".into(), vec!["b_h", "b_len"])], + "groups keep the design's order" + ); + let (fav, users, groups) = shown(ui_kit::Sort::Descending); + assert_eq!(fav, ["s_d1", "d10", "Alpha"]); + assert_eq!(users, ["width", "d10", "d2", "d1", "Alpha"]); + assert_eq!(groups, [("Sketch1".into(), vec!["s_d3", "s_d2", "s_d1"]), ("Box1".into(), vec!["b_len", "b_h"])]); + } + + /// #8563: clicking a Name heading sorts every table in the window, the choice outlives the + /// window, and moving a user parameter waits for the listed order. + #[test] + fn the_name_heading_sorts_the_window_and_is_remembered() { + let mut h = crate::scenario::Harness::new(); + h.app.home.open = false; + h.call("ui.resize", json!({"width": 1600, "height": 1400})); + h.app.run("solid.box", json!({"length": 10, "width": 20, "height": 30})).unwrap(); + for name in ["t10", "span", "t2", "Alpha", "t1"] { + h.app.run("parameters.add", json!({"name": name, "expression": "10 mm"})).unwrap(); + } + h.app.start("parameters.change"); + h.frames(6); + let order = |table: &str, names: &[String]| { + let mut rows: Vec<_> = + names.iter().map(|n| (crate::scenario::rect_of(&format!("dialog:table:{table}:{n}")).expect(n).top(), n.clone())).collect(); + rows.sort_by(|a, b| a.0.total_cmp(&b.0)); + rows.into_iter().map(|(_, n)| n).collect::>() + }; + let users: Vec = ["t10", "span", "t2", "Alpha", "t1"].map(String::from).to_vec(); + let group = h.app.params.as_ref().unwrap().listed.as_ref().unwrap().1.iter().find(|r| r.source != "user").unwrap().group.clone(); + let model: Vec = + h.app.params.as_ref().unwrap().listed.as_ref().unwrap().1.iter().filter(|r| r.group == group).map(|r| r.name.clone()).collect(); + assert_eq!(order("user", &users), users, "the listed order by default"); + assert!(model.len() > 1, "the box drives several parameters: {model:?}"); + let mut sorted_model = model.clone(); + ui_kit::Sort::Ascending.apply(&mut sorted_model, |s| s.as_str()); + + h.step(&json!({"click": {"handle": "params:sort:user"}})).unwrap(); + h.frames(3); + assert_eq!(order("user", &users), ["Alpha", "span", "t1", "t2", "t10"]); + // The bounded card may not show the model group below the user table: filter to it. + h.app.params.as_mut().unwrap().filter = group.clone(); + h.frames(4); + assert_eq!(order(&group, &model), sorted_model, "a model group sorts too"); + h.app.params.as_mut().unwrap().filter.clear(); + h.frames(4); + assert!(crate::scenario::handle_at("param:after:Alpha").is_some()); + let before = h.app.session.doc.params.iter().map(|p| p.name.clone()).collect::>(); + h.step(&json!({"click": {"handle": "param:after:Alpha"}})).unwrap(); + h.frames(2); + assert_eq!(h.app.session.doc.params.iter().map(|p| p.name.clone()).collect::>(), before, "no move while sorted"); + + // Closed and opened again: still sorted. + h.app.params = None; + h.frames(2); + h.app.start("parameters.change"); + h.frames(4); + assert_eq!(h.app.params.as_ref().unwrap().sort, ui_kit::Sort::Ascending); + h.step(&json!({"click": {"handle": "params:sort:user"}})).unwrap(); + h.frames(3); + assert_eq!(order("user", &users), ["t10", "t2", "t1", "span", "Alpha"]); + h.step(&json!({"click": {"handle": "params:sort:user"}})).unwrap(); + h.frames(3); + assert_eq!(order("user", &users), users, "the third click goes back to the listed order"); + } + /// A design with hundreds of chained parameters. fn big_design() -> crate::scenario::Harness { let mut h = crate::scenario::Harness::new(); diff --git a/crates/ui-egui/src/ui_kit/gallery.rs b/crates/ui-egui/src/ui_kit/gallery.rs index 4ef81e7a0..6debc7ad0 100644 --- a/crates/ui-egui/src/ui_kit/gallery.rs +++ b/crates/ui-egui/src/ui_kit/gallery.rs @@ -981,6 +981,12 @@ const ELEMENTS: &[Element] = &[ removable_header(ui, "Width"); }); }), + element!("sort_header", |ui, _| { + ui.allocate_ui(vec2(140.0, row_height()), |ui| { + ui.set_min_size(vec2(140.0, row_height())); + sort_header(ui, "Name", &mut Sort::Ascending); + }); + }), element!("plus_header", |ui, _| { ui.allocate_ui(vec2(140.0, row_height()), |ui| { ui.set_min_size(vec2(140.0, row_height())); diff --git a/crates/ui-egui/src/ui_kit/table.rs b/crates/ui-egui/src/ui_kit/table.rs index 674be3f10..7568b02bf 100644 --- a/crates/ui-egui/src/ui_kit/table.rs +++ b/crates/ui-egui/src/ui_kit/table.rs @@ -308,6 +308,101 @@ fn header_label(ui: &mut Ui, label: &str) { .on_hover_text(crate::i18n::tr_label(label)); } +/// How a table orders its rows by one column. `Listed` keeps the order the owner gave them. +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub(crate) enum Sort { + #[default] + Listed, + Ascending, + Descending, +} + +impl Sort { + /// A click on the header steps ascending, descending, then back to the listed order. + pub(crate) fn next(self) -> Self { + match self { + Sort::Listed => Sort::Ascending, + Sort::Ascending => Sort::Descending, + Sort::Descending => Sort::Listed, + } + } + + /// Order `items` by `key` in natural order (stable: equal names keep their listed order). + pub(crate) fn apply(self, items: &mut [T], key: impl Fn(&T) -> &str) { + match self { + Sort::Listed => {} + Sort::Ascending => items.sort_by(|a, b| natural_cmp(key(a), key(b))), + Sort::Descending => items.sort_by(|a, b| natural_cmp(key(b), key(a))), + } + } +} + +/// Natural order for names: runs of digits compare by value ("d2" before "d10"), letters +/// ignore case ("Alpha" between "a" and "b"); exact ties fall back to the plain comparison. +fn natural_cmp(a: &str, b: &str) -> std::cmp::Ordering { + use std::cmp::Ordering; + let (mut x, mut y) = (a.chars().peekable(), b.chars().peekable()); + while let (Some(&p), Some(&q)) = (x.peek(), y.peek()) { + let order = if p.is_ascii_digit() && q.is_ascii_digit() { + let run = |it: &mut std::iter::Peekable>| { + let mut digits = String::new(); + while let Some(c) = it.next_if(char::is_ascii_digit) { + digits.push(c); + } + digits + }; + let (m, n) = (run(&mut x), run(&mut y)); + let (m_value, n_value) = (m.trim_start_matches('0'), n.trim_start_matches('0')); + // Compare the values by length then digits, so no run can overflow an integer; + // "01" sorts after "1". + m_value.len().cmp(&n_value.len()).then_with(|| m_value.cmp(n_value)).then_with(|| m.len().cmp(&n.len())) + } else { + x.next(); + y.next(); + p.to_lowercase().cmp(q.to_lowercase()) + }; + if order != Ordering::Equal { + return order; + } + } + x.next().is_some().cmp(&y.next().is_some()).then_with(|| a.cmp(b)) +} + +/// A header that sorts the table by its column. Clicking steps through [`Sort::next`]; the +/// chevron shows the current direction (up for ascending), and none when rows are as listed. +/// Tokens: control_radius, hover, space_4/14, font_small, form_dim/primary. +pub(crate) fn sort_header(ui: &mut Ui, label: &str, sort: &mut Sort) -> Response { + let t = Tokens::get(); + let rect = ui.max_rect(); + let response = ui.allocate_rect(rect, egui::Sense::click()); + if response.hovered() { + ui.painter().rect_filled(rect, t.control_radius, t.hover); + } + let text = crate::i18n::tr_label(label); + let font = crate::fonts::semibold(t.font_small); + let width = ui.painter().layout_no_wrap(text.to_owned(), font.clone(), t.form_dim).size().x.ceil(); + let text_rect = egui::Rect::from_min_max(rect.min, egui::pos2((rect.left() + width).min(rect.right() - t.space_14 - t.space_4), rect.bottom())); + super::text::paint_text(ui, text_rect, text, font, t.form_dim, false); + let icon = + egui::Rect::from_center_size(egui::pos2(text_rect.right() + t.space_4 + t.space_14 * 0.5, rect.center().y), vec2(t.space_14, t.space_14)); + match *sort { + Sort::Ascending => crate::icons::paint_ink_flipped(ui.painter(), icon, "chevron", t.form_primary), + Sort::Descending => crate::icons::paint_ink(ui.painter(), icon, "chevron", t.form_primary), + Sort::Listed if response.hovered() => crate::icons::paint_ink(ui.painter(), icon, "chevron", t.form_dim.gamma_multiply(0.5)), + Sort::Listed => {} + } + if response.clicked() { + *sort = sort.next(); + } + let tip = match *sort { + Sort::Listed => "Sort A to Z", + Sort::Ascending => "Sort Z to A", + Sort::Descending => "Back to the original order", + }; + response.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, ui.is_enabled(), text)); + response.on_hover_cursor(egui::CursorIcon::PointingHand).on_hover_text(crate::i18n::tr_label(tip)) +} + /// Column removal appears inside the hovered header only. Keeps the former × button handle. pub(crate) fn removable_header(ui: &mut Ui, label: &str) -> bool { let t = Tokens::get(); diff --git a/crates/ui-egui/src/ui_kit/table_tests.rs b/crates/ui-egui/src/ui_kit/table_tests.rs index 81093035b..4579cd84c 100644 --- a/crates/ui-egui/src/ui_kit/table_tests.rs +++ b/crates/ui-egui/src/ui_kit/table_tests.rs @@ -348,3 +348,19 @@ fn name_list_gives_the_name_the_width_the_other_cells_leave() { assert_eq!(scenario::count_of("dialog:name:b.step:cut"), Some(0.0)); } } + +/// #8563: names sort in natural order: numbers by value, letters without regard to case. +#[test] +fn natural_order_compares_numbers_by_value_and_ignores_case() { + let mut names = vec!["d10", "width", "d2", "Alpha", "d1", "alpha", "Beta", "d02", "x", "x1", "p99999999999999999999999", "p100"]; + Sort::Ascending.apply(&mut names, |s| *s); + assert_eq!(names, ["Alpha", "alpha", "Beta", "d1", "d2", "d02", "d10", "p100", "p99999999999999999999999", "width", "x", "x1"]); + Sort::Descending.apply(&mut names, |s| *s); + assert_eq!(names, ["x1", "x", "width", "p99999999999999999999999", "p100", "d10", "d02", "d2", "d1", "Beta", "alpha", "Alpha"]); + let mut listed = vec!["d10", "d2", "d1"]; + Sort::Listed.apply(&mut listed, |s| *s); + assert_eq!(listed, ["d10", "d2", "d1"], "the listed order is left alone"); + assert_eq!(natural_cmp("", ""), std::cmp::Ordering::Equal); + assert_eq!(natural_cmp("", "a"), std::cmp::Ordering::Less); + assert_eq!([Sort::Listed.next(), Sort::Ascending.next(), Sort::Descending.next()], [Sort::Ascending, Sort::Descending, Sort::Listed]); +}