SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Pattern dialogs: Quantity fields get up/down step arrows (#4260) (#4264)
Frank1fa0371c756f
diff --git a/crates/ui-egui/src/dialogs_all_tests.rs b/crates/ui-egui/src/dialogs_all_tests.rsindex 99d5a51db9..272dc3e68f 100644--- a/crates/ui-egui/src/dialogs_all_tests.rs+++ b/crates/ui-egui/src/dialogs_all_tests.rs@@ -409,3 +409,48 @@ fn face_editor_refills_named_faces_after_sketch_resize() {assert!(h.app.session.model.results.iter().all(|r| r.error.is_none()));}}++#[test]+fn solid_pattern_quantity_arrows_step_the_count_the_command_receives() {+ let mut h = fixture();+ h.app.run("parameters.add", json!({"name":"copies","expression":"3","unit":""})).unwrap();+ for (command, key, label) in [+ ("solid.pattern.circular", "count", "Quantity"),+ ("solid.pattern.rectangular", "count1", "Quantity"),+ ("solid.pattern.path", "count", "Quantity"),+ ] {+ let mut d = representative(&h, command);+ if command == "solid.pattern.rectangular" {+ d.inputs[1].items = vec![Sel::Axis { name: "X".into() }];+ }+ h.app.dialog = Some(d);+ h.settle();+ let sent = |h: &Harness| {+ let cmds = crate::dialogs::preview_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap_or_else(|e| panic!("{command}: {e}"));+ cmds.iter().find(|(id, _)| id == command).map(|(_, p)| p[key].clone()).unwrap_or_else(|| panic!("{command}: {cmds:?}"))+ };+ let before = sent(&h).as_str().unwrap().parse::<i64>().unwrap();+ h.step(&json!({"click":{"handle":format!("dialog:{label} up")}})).unwrap();+ assert_eq!(sent(&h), json!((before + 1).to_string()), "{command}");+ let set = |h: &mut Harness, text: &str| {+ if let Some(Kind::PatternRect { count, .. } | Kind::PatternCirc { count, .. } | Kind::PathPattern { count, .. }) =+ h.app.dialog.as_mut().map(|d| &mut d.kind)+ {+ *count = text.into();+ }+ h.frames(2);+ };+ // From 1 to the document's 1000 instances.+ set(&mut h, "1");+ h.step(&json!({"click":{"handle":format!("dialog:{label} down")}})).unwrap();+ assert_eq!(sent(&h), json!("1"), "{command}");+ set(&mut h, "1000");+ h.step(&json!({"click":{"handle":format!("dialog:{label} up")}})).unwrap();+ assert_eq!(sent(&h), json!("1000"), "{command}");+ set(&mut h, "copies");+ h.step(&json!({"click":{"handle":format!("dialog:{label} up")}})).unwrap();+ assert_eq!(sent(&h), json!("copies + 1"), "{command}");+ h.step(&json!({"click":{"handle":"dialog:cancel"}})).unwrap();+ h.settle();+ }+}diff --git a/crates/ui-egui/src/dialogs_dense.rs b/crates/ui-egui/src/dialogs_dense.rsindex 53021e3b48..fb30fc73e3 100644--- a/crates/ui-egui/src/dialogs_dense.rs+++ b/crates/ui-egui/src/dialogs_dense.rs@@ -106,6 +106,16 @@ const FILLET_TYPES: [(&str, &str); 5] = [("Spline", "spline"),];+/// The most instances a solid pattern makes in one direction (the document's own limit).+const MAX_PATTERN_INSTANCES: i64 = 1000;++/// A solid pattern's quantity row, with step arrows from 1 to `MAX_PATTERN_INSTANCES`. The+/// count goes to the command as typed, so it is evaluated as the document evaluates it.+fn quantity_row(ui: &mut egui::Ui, doc: &solidcraft_engine::doc::Document, label: &str, value: &mut String) -> bool {+ let eval = |text: &str| doc.eval(text.trim(), solidcraft_engine::doc::expr::Kind::Unitless).ok();+ ui_kit::count_row(ui, label, value, &ui_kit::Count { min: 1, max: MAX_PATTERN_INSTANCES, eval: &eval })+}+fn fillet_type(extra: &serde_json::Map<String, Value>) -> usize {let value = extra.get("type").and_then(Value::as_str).unwrap_or("constant");if value == "g2" { 3 } else { FILLET_TYPES.iter().position(|(_, key)| *key == value).unwrap_or(0) }@@ -198,7 +208,7 @@ pub(super) fn rows(app: &mut SolveApp, ctx: &egui::Context, d: &mut Dialog, ui:}}}- Kind::SketchModify(k) => enter |= crate::sketch_modify_ui::rows(ui, k),+ Kind::SketchModify(k) => enter |= crate::sketch_modify_ui::rows(ui, k, &app.session.doc),Kind::Text(k) => enter |= crate::sketch_text::rows(ui, k, &mut d.inputs, &mut d.active),Kind::TextMove(k) => enter |= crate::sketch_text_move::rows(ui, k),Kind::EditParam { name, expr } => {@@ -469,18 +479,18 @@ pub(super) fn rows(app: &mut SolveApp, ctx: &egui::Context, d: &mut Dialog, ui:}}Kind::PatternRect { count, spacing, count2, spacing2 } => {- for (l, v) in [("Quantity", count), ("Spacing", spacing), ("Quantity 2", count2), ("Spacing 2", spacing2)] {- enter |= expr_row(ui, l, v);- }+ enter |= quantity_row(ui, &app.session.doc, "Quantity", count);+ enter |= expr_row(ui, "Spacing", spacing);+ enter |= quantity_row(ui, &app.session.doc, "Quantity 2", count2);+ enter |= expr_row(ui, "Spacing 2", spacing2);if d.inputs.first().is_some_and(|i| i.accept == selection::FEATURES) {feature_pattern_alignment_row(ui, &mut d.extra, 0);feature_pattern_alignment_row(ui, &mut d.extra, 1);}}Kind::PatternCirc { count, angle } => {- for (l, v) in [("Quantity", count), ("Total angle", angle)] {- enter |= expr_row(ui, l, v);- }+ enter |= quantity_row(ui, &app.session.doc, "Quantity", count);+ enter |= expr_row(ui, "Total angle", angle);if d.inputs.first().is_some_and(|i| i.accept == selection::FEATURES) {feature_pattern_alignment_row(ui, &mut d.extra, 0);}@@ -701,9 +711,8 @@ fn additional_rows(app: &mut SolveApp, d: &mut Dialog, ui: &mut egui::Ui) -> booextra_options(ui, "boundary_options", &mut d.extra, &[("Remove Tools", "remove_tools")]);}Kind::PathPattern { count, spacing } => {- for (l, v) in [("Quantity", count), ("Spacing", spacing)] {- enter |= expr_row(ui, l, v);- }+ enter |= quantity_row(ui, &app.session.doc, "Quantity", count);+ enter |= expr_row(ui, "Spacing", spacing);}Kind::Pipe { diameter, wall } => {enter |= expr_row(ui, "Diameter", diameter);diff --git a/crates/ui-egui/src/dialogs_sketch_tests.rs b/crates/ui-egui/src/dialogs_sketch_tests.rsindex be9bf7cd2e..d84ca5cad9 100644--- a/crates/ui-egui/src/dialogs_sketch_tests.rs+++ b/crates/ui-egui/src/dialogs_sketch_tests.rs@@ -207,3 +207,77 @@ fn apply_keeps_the_panel_open_after_asynchronous_evaluation() {assert!(d.inputs.iter().all(|i| i.items.is_empty()));assert!(!d.repeat_after_apply);}++#[test]+fn circular_pattern_quantity_arrows_step_the_count_within_its_limits_and_keep_parameters() {+ let mut h = fixture();+ h.app.dialog = Some(picked(&h, "sketch.pattern.circular"));+ h.settle();+ let count = |h: &Harness| match &h.app.dialog.as_ref().unwrap().kind {+ Kind::SketchModify(Mod::PatternCirc { count, .. }) => count.clone(),+ other => panic!("not a sketch pattern window: {other:?}"),+ };+ let set = |h: &mut Harness, text: &str| {+ if let Some(Kind::SketchModify(Mod::PatternCirc { count, .. })) = h.app.dialog.as_mut().map(|d| &mut d.kind) {+ *count = text.into();+ }+ h.frames(2);+ };+ let sent = |h: &Harness| apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap()[0].1["count"].clone();+ let previewed = |h: &Harness| crate::dialogs::preview_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap()[0].1["count"].clone();+ assert_eq!(count(&h), "6");+ h.step(&json!({"click":{"handle":"dialog:Quantity up"}})).unwrap();+ assert_eq!(count(&h), "7");+ assert_eq!((sent(&h), previewed(&h)), (json!(7), json!(7)), "the preview follows the arrow as it follows typing");+ h.step(&json!({"click":{"handle":"dialog:Quantity down"}})).unwrap();+ h.step(&json!({"click":{"handle":"dialog:Quantity down"}})).unwrap();+ assert_eq!(count(&h), "5");+ // A circular pattern needs the original and one copy, and makes at most 500.+ set(&mut h, "2");+ h.step(&json!({"click":{"handle":"dialog:Quantity down"}})).unwrap();+ assert_eq!(count(&h), "2");+ set(&mut h, "500");+ h.step(&json!({"click":{"handle":"dialog:Quantity up"}})).unwrap();+ assert_eq!(count(&h), "500");+ // A count typed past the limit steps back inside it.+ set(&mut h, "900");+ h.step(&json!({"click":{"handle":"dialog:Quantity down"}})).unwrap();+ assert_eq!(count(&h), "500");+ // An expression keeps its parameter: the arrows adjust a trailing offset.+ h.app.run("parameters.add", json!({"name":"holes","expression":"4","unit":""})).unwrap();+ set(&mut h, "holes");+ h.step(&json!({"click":{"handle":"dialog:Quantity up"}})).unwrap();+ assert_eq!((count(&h), sent(&h)), ("holes + 1".into(), json!("holes + 1")), "the command keeps the parameter");+ for _ in 0..2 {+ h.step(&json!({"click":{"handle":"dialog:Quantity down"}})).unwrap();+ }+ assert_eq!((count(&h), sent(&h)), ("holes - 1".into(), json!("holes - 1")));+ // Text that is not a count leaves the arrows without effect.+ set(&mut h, "nothing");+ h.step(&json!({"click":{"handle":"dialog:Quantity up"}})).unwrap();+ assert_eq!(count(&h), "nothing");+}++#[test]+fn rectangular_pattern_quantity_arrows_keep_both_directions_within_the_copy_limit() {+ let mut h = fixture();+ h.app.dialog = Some(picked(&h, "sketch.pattern.rectangular"));+ h.settle();+ let counts = |h: &Harness| match &h.app.dialog.as_ref().unwrap().kind {+ Kind::SketchModify(Mod::PatternRect { count, count2, .. }) => (count.clone(), count2.clone()),+ other => panic!("not a sketch pattern window: {other:?}"),+ };+ let (one, _) = counts(&h);+ h.step(&json!({"click":{"handle":"dialog:Quantity 2 up"}})).unwrap();+ assert_eq!(counts(&h), (one.clone(), "2".into()));+ if let Some(Kind::SketchModify(Mod::PatternRect { count, count2, .. })) = h.app.dialog.as_mut().map(|d| &mut d.kind) {+ (*count, *count2) = ("250".into(), "2".into());+ }+ h.frames(2);+ // 250 × 2 is the 500 copies a sketch pattern makes at most.+ h.step(&json!({"click":{"handle":"dialog:Quantity up"}})).unwrap();+ h.step(&json!({"click":{"handle":"dialog:Quantity 2 up"}})).unwrap();+ assert_eq!(counts(&h), ("250".into(), "2".into()));+ h.step(&json!({"click":{"handle":"dialog:Quantity down"}})).unwrap();+ assert_eq!(counts(&h), ("249".into(), "2".into()));+}diff --git a/crates/ui-egui/src/sketch_modify_ui.rs b/crates/ui-egui/src/sketch_modify_ui.rsindex be2263c98d..ae21eaf6e9 100644--- a/crates/ui-egui/src/sketch_modify_ui.rs+++ b/crates/ui-egui/src/sketch_modify_ui.rs@@ -26,6 +26,7 @@use egui::Pos2;use serde_json::{Map, Value, json};use solidcraft_engine::Sel;+use solidcraft_engine::doc::Document;use solidcraft_engine::doc::expr::Kind as ValueKind;use solidcraft_engine::geom::{Vec2, Vec3};use solidcraft_engine::sketch::PatternAlignment;@@ -330,6 +331,20 @@ fn number(ui: &mut egui::Ui, label: &str, value: &mut String) -> bool {ui_kit::row(ui, label, |ui| ui_kit::field(ui, value))}+/// A pattern quantity row with step arrows. They keep the count from `min` up to `max`+/// copies, evaluated against the design's parameters as `whole` evaluates it on OK.+fn quantity(ui: &mut egui::Ui, doc: &Document, label: &str, value: &mut String, min: i64, max: i64) -> bool {+ let eval = |text: &str| doc.eval(text.trim(), ValueKind::Unitless).ok();+ ui_kit::count_row(ui, label, value, &ui_kit::Count { min, max: max.max(min), eval: &eval })+}++/// How many copies the other direction of a rectangular pattern leaves this one, so that+/// both together stay within `MAX_COPIES`. All of them while the other count is not a number.+fn copies_left(doc: &Document, other: &str) -> i64 {+ let other = doc.eval(other.trim(), ValueKind::Unitless).ok().filter(|v| v.is_finite() && *v >= 1.0).map_or(1.0, f64::round);+ (MAX_COPIES / other).floor() as i64+}+fn icons(ui: &mut egui::Ui, label: &str, labels: &[&'static str], icons: &[&'static str], selected: &mut usize) {ui_kit::row(ui, label, |ui| {let choices: Vec<_> =@@ -356,7 +371,8 @@ fn pattern_hint(ui: &mut egui::Ui) {}/// Dense rows after the selection inputs; true when an expression field accepts Enter.-pub fn rows(ui: &mut egui::Ui, k: &mut Mod) -> bool {+/// `doc` evaluates the pattern counts the step arrows change.+pub fn rows(ui: &mut egui::Ui, k: &mut Mod, doc: &Document) -> bool {let mut enter = false;match k {Mod::Scale { factor } => enter |= number(ui, "Factor", factor),@@ -381,12 +397,13 @@ pub fn rows(ui: &mut egui::Ui, k: &mut Mod) -> bool {ui_kit::options(ui, "move_options", &mut [("Create Copy", copy)]);}Mod::PatternRect { count, spacing, count2, spacing2, alignment: a, alignment2, reversed, reversed2 } => {- for (key, title, count, spacing, align, reverse, quantity, distance, align_label) in [- ("direction1", "Direction 1", count, spacing, a, reversed, "Quantity", "Spacing", "Alignment"),- ("direction2", "Direction 2", count2, spacing2, alignment2, reversed2, "Quantity 2", "Spacing 2", "Alignment 2"),+ let (left1, left2) = (copies_left(doc, count2), copies_left(doc, count));+ for (key, title, count, spacing, align, reverse, label, distance, align_label, left) in [+ ("direction1", "Direction 1", count, spacing, a, reversed, "Quantity", "Spacing", "Alignment", left1),+ ("direction2", "Direction 2", count2, spacing2, alignment2, reversed2, "Quantity 2", "Spacing 2", "Alignment 2", left2),] {ui_kit::section(ui, key, title, true, |ui| {- enter |= number(ui, quantity, count);+ enter |= quantity(ui, doc, label, count, 1, left);enter |= number(ui, distance, spacing);alignment(ui, align_label, align, reverse);});@@ -394,7 +411,7 @@ pub fn rows(ui: &mut egui::Ui, k: &mut Mod) -> bool {pattern_hint(ui);}Mod::PatternCirc { count, angle, alignment: a, reversed } => {- enter |= number(ui, "Quantity", count);+ enter |= quantity(ui, doc, "Quantity", count, 2, MAX_COPIES as i64);enter |= number(ui, "Total angle", angle);alignment(ui, "Alignment", a, reversed);pattern_hint(ui);diff --git a/crates/ui-egui/src/ui_kit/fields.rs b/crates/ui-egui/src/ui_kit/fields.rsindex 9df88cf2b5..9b7277b47f 100644--- a/crates/ui-egui/src/ui_kit/fields.rs+++ b/crates/ui-egui/src/ui_kit/fields.rs@@ -27,6 +27,87 @@ pub(crate) fn hint_field(ui: &mut Ui, value: &mut String, hint: &str) -> bool {editor(ui, value, hint, true).0}+/// The whole numbers a count field may hold, and how its text evaluates (parameters and+/// expressions included). `eval` returns None for text that is not a value.+pub(crate) struct Count<'a> {+ pub min: i64,+ pub max: i64,+ pub eval: &'a dyn Fn(&str) -> Option<f64>,+}++/// Expression editor for a whole-number count (a pattern's quantity), with up and down step+/// arrows at its right edge. An arrow steps the evaluated count by one and stays within the+/// limits: a plain number is replaced, an expression keeps its parameters and gains or adjusts+/// a trailing `+ n`. The text changes as if typed, so previews follow. Returns accepted Enter.+/// Tokens: field tokens, `control_border`, `selected_bg`, `form_ink`, `form_dim`.+pub(crate) fn count_field(ui: &mut Ui, value: &mut String, limits: &Count<'_>) -> bool {+ let t = Tokens::get();+ let reserve = (t.control_height * 0.75).round();+ let (enter, _, response) = editor_reserving(ui, value, "", true, reserve);+ let rect = response.rect;+ let column = egui::Rect::from_min_max(egui::pos2((rect.right() - reserve).max(rect.left()), rect.top()), rect.max);+ let painter = ui.painter_at(rect);+ painter.vline(column.left(), column.y_range().shrink(t.space_4), egui::Stroke::new(1.0, t.control_border));+ let row = label(ui).to_owned();+ for (delta, half, name) in [(1, column.split_top_bottom_at_fraction(0.5).0, "up"), (-1, column.split_top_bottom_at_fraction(0.5).1, "down")] {+ let next = step_count(value, delta, limits);+ let arrow = ui.interact(half, ui.id().with(("sc_count_step", &row, name)), egui::Sense::click());+ let enabled = ui.is_enabled() && next.is_some();+ if enabled && arrow.hovered() {+ painter.rect_filled(half.shrink(1.0), t.control_radius, t.selected_bg);+ }+ let ink = if enabled { t.form_ink } else { t.form_dim };+ let (c, w, h) = (half.center(), (reserve * 0.18).max(2.0), (half.height() * 0.2).max(2.0));+ let tip = if delta > 0 { -h } else { h };+ painter.add(egui::Shape::convex_polygon(+ vec![egui::pos2(c.x, c.y + tip * 0.5), egui::pos2(c.x + w, c.y - tip * 0.5), egui::pos2(c.x - w, c.y - tip * 0.5)],+ ink,+ egui::Stroke::NONE,+ ));+ let sign = if delta > 0 { "+1" } else { "−1" };+ arrow.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, enabled, format!("{} {sign}", crate::i18n::tr_label(&row))));+ scenario::publish_handle(&format!("dialog:{row} {name}"), half.center());+ if let (true, true, Some(next)) = (enabled, arrow.clicked(), next) {+ *value = next;+ }+ }+ enter+}++/// `text` stepped by `delta` whole numbers within `limits`, or None when it does not evaluate+/// or the step would leave the limits. A typed number between whole numbers steps to the next+/// one; an expression that evaluates between them is left alone.+fn step_count(text: &str, delta: i64, limits: &Count<'_>) -> Option<String> {+ const SAFE: f64 = 1e15;+ let trimmed = text.trim();+ let now = (limits.eval)(trimmed).filter(|v| v.is_finite() && v.abs() < SAFE)?;+ let from = if delta > 0 { now.floor() } else { now.ceil() } as i64;+ let target = from.saturating_add(delta).clamp(limits.min, limits.max);+ let moves = if delta > 0 { target as f64 > now } else { (target as f64) < now };+ if !moves {+ return None;+ }+ if trimmed.parse::<f64>().is_ok() {+ return Some(target.to_string());+ }+ // An expression: adjust its trailing `+ n` / `- n`, or add one, and check that it now says `target`.+ let offset = |base: &str, n: i64| match n {+ 0 => base.to_owned(),+ n if n > 0 => format!("{base} + {n}"),+ n => format!("{base} - {}", n.unsigned_abs()),+ };+ let tail = trimmed.rfind(['+', '-']).and_then(|at| {+ let (base, number) = (trimmed[..at].trim_end(), trimmed[at + 1..].trim());+ let n: i64 = number.bytes().all(|b| b.is_ascii_digit()).then(|| number.parse().ok()).flatten()?;+ let base_ok = !base.is_empty() && !base.ends_with(['+', '-', '*', '/', '^', '(', ',']);+ base_ok.then(|| (base, if trimmed[at..].starts_with('-') { -n } else { n }))+ });+ let step = target - now.round() as i64;+ let candidates =+ [tail.map(|(base, n)| offset(base, n.saturating_add(step))), Some(offset(trimmed, step)), Some(offset(&format!("({trimmed})"), step))];+ candidates.into_iter().flatten().find(|c| (limits.eval)(c).is_some_and(|v| (v - target as f64).abs() < 1e-9))+}+/// Names, thread designations and plain numeric counts do not accept expression completion./// Plain text editor without expression completion; returns (Enter, changed). Tokens: `same as field`.pub(crate) fn text_field(ui: &mut Ui, value: &mut String, hint: &str) -> (bool, bool) {@@ -141,13 +222,20 @@ pub(crate) fn searchable_dropdown(/// Completion/focus implementation shared by field variants. Tokens: `same as field`.fn editor(ui: &mut Ui, value: &mut String, hint: &str, completion: bool) -> (bool, bool, Response) {+ editor_reserving(ui, value, hint, completion, 0.0)+}++/// `editor` whose text stops `reserve` points short of its right edge, for controls drawn there.+fn editor_reserving(ui: &mut Ui, value: &mut String, hint: &str, completion: bool, reserve: f32) -> (bool, bool, Response) {let t = Tokens::get();let width = dimension(ui.available_width());let font = egui::FontId::monospace(t.font_label);- let response = ui.add_sized(- vec2(width, row_height()),- text_input(egui::TextEdit::singleline(value)).hint_text(hint).font(font).background_color(t.input_fill()).clip_text(true),- );+ let mut edit = text_input(egui::TextEdit::singleline(value)).hint_text(hint).font(font).background_color(t.input_fill()).clip_text(true);+ if reserve > 0.0 {+ let inset = t.form_inset.round() as i8;+ edit = edit.margin(egui::Margin { left: inset, right: inset.saturating_add(reserve.round() as i8), top: 0, bottom: 0 });+ }+ let response = ui.add_sized(vec2(width, row_height()), edit);crate::theme::TabAccent::number_focus(ui, &response);t.input_bevel(ui, &response);let label = crate::i18n::tr_label(label(ui));diff --git a/crates/ui-egui/src/ui_kit/fields_tests.rs b/crates/ui-egui/src/ui_kit/fields_tests.rsindex 032a64b788..a112b75a1f 100644--- a/crates/ui-egui/src/ui_kit/fields_tests.rs+++ b/crates/ui-egui/src/ui_kit/fields_tests.rs@@ -240,3 +240,41 @@ fn bounded_name_editor_keeps_unicode_character_cap() {frame(&ctx, vec![egui::Event::Text("åβ界d".into())], &mut draw);assert_eq!(value, "åβ界");}++#[test]+fn count_steps_stay_within_limits_and_keep_expressions() {+ let eval = |text: &str| -> Option<f64> {+ let text = text.trim();+ match text {+ "n" => Some(4.0),+ "n + 2" => Some(6.0),+ "n + 3" => Some(7.0),+ "n + 1" => Some(5.0),+ "n - 1" => Some(3.0),+ "half" => Some(2.5),+ _ => text.parse().ok(),+ }+ };+ let limits = Count { min: 2, max: 10, eval: &eval };+ let step = |text: &str, delta| super::step_count(text, delta, &limits);+ assert_eq!(step("6", 1).as_deref(), Some("7"));+ assert_eq!(step(" 6 ", -1).as_deref(), Some("5"));+ assert_eq!(step("2", -1), None, "the minimum holds");+ assert_eq!(step("10", 1), None, "the maximum holds");+ assert_eq!(step("40", -1).as_deref(), Some("10"), "a typed count past the limit steps back inside it");+ assert_eq!(step("0", 1).as_deref(), Some("2"));+ assert_eq!(step("3.5", 1).as_deref(), Some("4"), "between whole numbers: the next one up");+ assert_eq!(step("3.5", -1).as_deref(), Some("3"));+ assert_eq!(step("n", 1).as_deref(), Some("n + 1"));+ assert_eq!(step("n", -1).as_deref(), Some("n - 1"));+ assert_eq!(step("n + 2", 1).as_deref(), Some("n + 3"));+ assert_eq!(step("n + 1", -1).as_deref(), Some("n"));+ assert_eq!(step("half", 1), None, "an expression between whole numbers is left alone");+ for junk in ["", "abc", "1e400", "-1e300", "NaN"] {+ assert_eq!(step(junk, 1), None, "{junk}");+ }+ let wide = Count { min: i64::MIN, max: i64::MAX, eval: &eval };+ assert_eq!(super::step_count("1e16", 1, &wide), None, "values past what counts can be are refused");+ assert_eq!(super::step_count("5", i64::MAX, &wide).as_deref(), Some("9223372036854775807"), "steps saturate rather than overflow");+ assert_eq!(super::step_count("5", i64::MIN, &wide).as_deref(), Some("-9223372036854775803"));+}diff --git a/crates/ui-egui/src/ui_kit/gallery.rs b/crates/ui-egui/src/ui_kit/gallery.rsindex 634c55abef..f7d651a921 100644--- a/crates/ui-egui/src/ui_kit/gallery.rs+++ b/crates/ui-egui/src/ui_kit/gallery.rs@@ -774,6 +774,16 @@ const ELEMENTS: &[Element] = &[element!("expr_row", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {expr_row(ui, "Gallery", &mut s.value);}),+ element!("count_row", "dialog:row:Gallery", Some("dialog:Gallery up"), |ui, _| {+ let mut count = "6".to_owned();+ count_row(ui, "Gallery", &mut count, &Count { min: 1, max: 10, eval: &|text: &str| text.trim().parse().ok() });+ }),+ element!("count_field", "dialog:row:Gallery", Some("dialog:Gallery down"), |ui, _| {+ row(ui, "Gallery", |ui| {+ let mut count = "1".to_owned();+ count_field(ui, &mut count, &Count { min: 1, max: 10, eval: &|text: &str| text.trim().parse().ok() });+ });+ }),element!("hint_row", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {hint_row(ui, "Gallery", &mut s.value, "Value");}),diff --git a/crates/ui-egui/src/ui_kit/layout.rs b/crates/ui-egui/src/ui_kit/layout.rsindex c7c2b19699..352e319dd0 100644--- a/crates/ui-egui/src/ui_kit/layout.rs+++ b/crates/ui-egui/src/ui_kit/layout.rs@@ -72,6 +72,11 @@ pub(crate) fn expr_row(ui: &mut Ui, label: &str, value: &mut String) -> bool {row(ui, label, |ui| super::field(ui, value))}+/// Whole-number count row with step arrows; retains completion and accepted Enter. Tokens: `row, count_field`.+pub(crate) fn count_row(ui: &mut Ui, label: &str, value: &mut String, limits: &super::Count<'_>) -> bool {+ row(ui, label, |ui| super::count_field(ui, value, limits))+}+/// Expression row with an empty-value hint. Tokens: `row, hint_field`.pub(crate) fn hint_row(ui: &mut Ui, label: &str, value: &mut String, hint: &str) -> bool {row(ui, label, |ui| super::hint_field(ui, value, hint))diff --git a/docs/ui-kit.md b/docs/ui-kit.mdindex 4f274ebaea..ab84e13d8f 100644--- a/docs/ui-kit.md+++ b/docs/ui-kit.md@@ -24,6 +24,7 @@ preferences, manager cards, prompts, context menus and the sketch palette. Impor- `expr_row`, `hint_row`, `text_row` and `choice_row` compose `row` with the existingexpression, hinted expression, plain text and dropdown controls. They preserve row order,labels, focus IDs and completion; callers keep Enter/change ownership and explicit dropdown IDs.+ `count_row` composes `row` with `count_field` for pattern quantities.- `Panel` owns bounded windows, feature/palette composition, scrolling bodies,pinned actions, compute status and keyboard routing. `wide()` uses three cardwidths. `feature_frame` and `palette_frame` retain docked/floating surfaces.@@ -88,6 +89,7 @@ table. Panel/Window/Confirm compositions also have dedicated geometry and intera| `text`, `Text` | Hint, note, report, inline or cell text; see variants below | `font_small/label`, `text/dim/error`, `control_height`, `space_4` || `text_lines` | Virtualized read-only licence/report lines, horizontal overflow | `font_small`, `text`, `control_height` || fields: `field`, `hint_field`, `focused_field` | Expression editors, optional empty hint or retained focus; returns accepted Enter | `control_height/fill`, `form_inset`, `font_label` |+| `count_field`, `Count` | Expression editor for a whole-number count (a pattern's quantity) with up/down step arrows at its right edge. `Count` gives the limits and the evaluator (the design's parameters); an arrow steps the evaluated count by one within them, replacing a plain number or adjusting an expression's trailing `+ n`, and is dimmed when it can't step. Handles `dialog:<row> up` / `down`; returns accepted Enter | field tokens, `control_border`, `control_radius`, `selected_bg`, `form_ink/dim`, `space_4` || `text_field`, `focused_text_field` | Plain name editor, optionally retaining focus | field tokens || `multiline_text_field` | Three-line plain-text row with stable focus ID | field/row tokens || `password_field` | Stable secret editor; excludes the secret from scenario/accessibility metadata | field tokens |