diff --git a/crates/doc/src/params.rs b/crates/doc/src/params.rs index ab4f0a249..bad1ab7df 100644 --- a/crates/doc/src/params.rs +++ b/crates/doc/src/params.rs @@ -234,6 +234,22 @@ impl Document { } } + /// A measured length (mm) written as a value in the design's units, with its unit: `1 in` + /// for 25.4 mm in an inch design. Kept to the micrometre, as a millimetre value would be, so + /// a dimension that restates the geometry moves nothing. Returns (unit, expression). + pub fn design_length(&self, mm: f64) -> (String, String) { + let u = self.units.trim(); + let per_unit = match expr::unit_info(u) { + Some((Kind::Length, s)) if u != "mm" && s.is_finite() && s > 0.0 => s, + _ => return ("mm".into(), format!("{} mm", (mm * 1e6).round() / 1e6)), + }; + let decimals = (-(1e-6 / per_unit).log10()).ceil().clamp(0.0, 12.0) as usize; + let text = format!("{:.*}", decimals, mm / per_unit); + let text = if text.contains('.') { text.trim_end_matches('0').trim_end_matches('.') } else { &text }; + let text = if text == "-0" { "0" } else { text }; + (u.into(), format!("{text} {u}")) + } + /// Every length input of every feature as the geometry reads it (mm; a unit-less result is /// in the design's units), for checking that an edit moves nothing. pub fn length_inputs(&self) -> Vec> { @@ -1088,3 +1104,43 @@ pub(crate) fn numbers_after<'a>(base: &str, names: impl Iterator .filter_map(|digits| digits.parse().ok()) .collect() } + +#[cfg(test)] +mod design_length_tests { + use crate::Document; + + fn written(units: &str, mm: f64) -> (String, String) { + let mut doc = Document::new("Units"); + doc.units = units.into(); + doc.design_length(mm) + } + + #[test] + fn a_measured_length_is_written_in_the_design_units() { + let w = |u: &str, e: &str| (u.to_string(), e.to_string()); + assert_eq!(written("in", 25.4), w("in", "1 in")); + assert_eq!(written("in", 12.7), w("in", "0.5 in")); + assert_eq!(written("in", 10.0), w("in", "0.39370079 in")); + assert_eq!(written("cm", 12.34), w("cm", "1.234 cm")); + assert_eq!(written("mm", 12.3456789), w("mm", "12.345679 mm")); + assert_eq!(written("in", -25.4), w("in", "-1 in")); + assert_eq!(written("in", -1e-12), w("in", "0 in")); + // Unknown or non-length units keep millimetres. + assert_eq!(written("parsec", 5.0), w("mm", "5 mm")); + assert_eq!(written("deg", 5.0), w("mm", "5 mm")); + assert_eq!(written("", 5.0), w("mm", "5 mm")); + } + + #[test] + fn the_written_value_reads_back_within_a_micrometre() { + for units in ["mm", "cm", "m", "in", "ft"] { + let mut doc = Document::new("Units"); + doc.units = units.into(); + for mm in [0.001, 1.0, 12.345_678_9, 25.4, 999.999, 12_345.678] { + let (_, e) = doc.design_length(mm); + let back = doc.eval(&e, crate::expr::Kind::Length).unwrap(); + assert!((back - mm).abs() <= 1e-6, "{units} {mm}: {e} reads {back}"); + } + } + } +} diff --git a/crates/engine/src/cmd/sketch.rs b/crates/engine/src/cmd/sketch.rs index f3a3b4ba1..8b624d543 100644 --- a/crates/engine/src/cmd/sketch.rs +++ b/crates/engine/src/cmd/sketch.rs @@ -2574,8 +2574,8 @@ fn dimension(s: &mut Session, p: &Value) -> Result { before = None; return Ok((String::new(), name, measured(is_angle, cur))); } - let (unit, default_expr) = - if is_angle { ("deg", format!("{} deg", round6(cur.to_degrees()))) } else { ("mm", format!("{} mm", round6(cur))) }; + // With no value, the dimension restates what it measures, in the design's units (#3812). + let (unit, default_expr) = if is_angle { ("deg".into(), format!("{} deg", round6(cur.to_degrees()))) } else { doc.design_length(cur) }; let kind = if is_angle { Kind::Angle } else { Kind::Length }; if let Some((name, rhs)) = &defines { // The new user parameter reads a bare number as the dimension would (the design's @@ -2591,7 +2591,7 @@ fn dimension(s: &mut Session, p: &Value) -> Result { doc.add_user_param(name, &rhs, Some(&unit), None).map_err(|e| bad(cmd, format!("value: {e}")))?; } let e = value.as_ref().map(|e| doc.with_design_unit(e, kind)).unwrap_or(default_expr); - let pname = doc.new_model_param(&e, unit); + let pname = doc.new_model_param(&e, &unit); // The value must evaluate. let (vals, errs) = doc.param_values(); if let Some(err) = errs.get(&pname) { diff --git a/crates/engine/src/cmd/sketch_constraints.rs b/crates/engine/src/cmd/sketch_constraints.rs index efddb171e..f12a394d2 100644 --- a/crates/engine/src/cmd/sketch_constraints.rs +++ b/crates/engine/src/cmd/sketch_constraints.rs @@ -126,8 +126,8 @@ fn try_add(sk: &mut Sketch, doc: &mut solidcraft_doc::Document, k: ConstraintKin let saved = sk.clone(); let param = if dim { let v = k.value()?; - let e = if k.is_angle() { format!("{} deg", (v.to_degrees() * 1e6).round() / 1e6) } else { format!("{} mm", (v * 1e6).round() / 1e6) }; - Some(doc.new_model_param(&e, if k.is_angle() { "deg" } else { "mm" })) + let (unit, e) = if k.is_angle() { ("deg".into(), format!("{} deg", (v.to_degrees() * 1e6).round() / 1e6)) } else { doc.design_length(v) }; + Some(doc.new_model_param(&e, &unit)) } else { None }; @@ -383,13 +383,10 @@ fn toggle_driven(s: &mut Session, p: &Value) -> Result { slot.driven = true; slot.param = None; } else { - let (unit, e) = if c.kind.is_angle() { - ("deg", format!("{} deg", (v.to_degrees() * 1e6).round() / 1e6)) - } else { - ("mm", format!("{} mm", (v * 1e6).round() / 1e6)) - }; + let (unit, e) = + if c.kind.is_angle() { ("deg".into(), format!("{} deg", (v.to_degrees() * 1e6).round() / 1e6)) } else { doc.design_length(v) }; slot.driven = false; - slot.param = Some(doc.new_model_param(&e, unit)); + slot.param = Some(doc.new_model_param(&e, &unit)); before = None; } Ok(driven) diff --git a/crates/engine/src/cmd/sketch_ux_tests.rs b/crates/engine/src/cmd/sketch_ux_tests.rs index acd4cb682..8e073759d 100644 --- a/crates/engine/src/cmd/sketch_ux_tests.rs +++ b/crates/engine/src/cmd/sketch_ux_tests.rs @@ -1790,3 +1790,63 @@ fn dragging_an_end_of_a_tangent_line_leaves_its_other_end_still() { let si = run(&mut s, "sketch.inspect", json!({})); assert!(si["failing"].as_array().is_some_and(Vec::is_empty), "still tangent: {si}"); } + +// --------------------------------------------------------------------------------------------- +// A dimension without a value restates its measurement in the design's units (#3812): `1 in` +// for a 25.4 mm line in an inch design, so the value box opens in the units the text shows. + +/// A sketch with a 25.4 mm line `l1` in a design in `units`. +fn units_line(units: &str) -> Session { + let mut s = Session::default(); + run(&mut s, "sketch.create", json!({"plane": "XY"})); + run(&mut s, "sketch.line", json!({"points": [[0, 0], [25.4, 0]], "ids": ["l1"]})); + run(&mut s, "document.units", json!({"units": units})); + s +} + +fn units_param(s: &Session, name: &str) -> (String, String) { + let p = s.doc.param(name).unwrap(); + (p.expr.clone(), p.unit.clone()) +} + +fn units_line_end(s: &Session) -> f64 { + let state = s.model.state(); + let sk = &state.sketch(s.active_sketch.unwrap()).unwrap().sketch; + sk.point(sk.resolve_point("l1.end").unwrap()).unwrap().x +} + +#[test] +fn a_dimension_without_a_value_is_written_in_the_design_units() { + for (units, expr) in [("in", "1 in"), ("mm", "25.4 mm"), ("cm", "2.54 cm"), ("ft", "0.083333333 ft"), ("m", "0.0254 m")] { + let mut s = units_line(units); + let r = run(&mut s, "sketch.dimension", json!({"entities": ["l1"], "scale_sketch": true})); + let name = r["param"].as_str().unwrap(); + assert_eq!(units_param(&s, name), (expr.to_string(), units.to_string()), "{units}"); + assert!((units_line_end(&s) - 25.4).abs() < 1e-5, "{units}: the restated dimension moves nothing ({})", units_line_end(&s)); + } +} + +#[test] +fn a_typed_bare_number_still_means_the_design_units() { + let mut s = units_line("in"); + let r = run(&mut s, "sketch.dimension", json!({"entities": ["l1"], "value": "2"})); + assert_eq!(units_param(&s, r["param"].as_str().unwrap()).0, "2 in"); + assert!((units_line_end(&s) - 50.8).abs() < 1e-6); +} + +#[test] +fn a_driven_dimension_made_driving_and_autoconstrain_dimensions_use_the_design_units() { + let mut s = units_line("in"); + run(&mut s, "sketch.dimension", json!({"entities": ["l1"], "driven": true})); + let state = s.model.state(); + let id = state.sketch(s.active_sketch.unwrap()).unwrap().sketch.constraints.iter().find(|c| c.driven).unwrap().id.clone(); + run(&mut s, "sketch.toggle_driven", json!({"constraint": id, "driven": false})); + let made = s.doc.params.iter().find(|p| p.model).unwrap(); + assert_eq!((made.expr.as_str(), made.unit.as_str()), ("1 in", "in")); + + let mut s = units_line("in"); + run(&mut s, "sketch.auto_constrain", json!({})); + let lengths: Vec<_> = s.doc.params.iter().filter(|p| p.model && p.unit != "deg").collect(); + assert!(!lengths.is_empty(), "AutoConstrain dimensioned the line"); + assert!(lengths.iter().all(|p| p.unit == "in" && p.expr.ends_with(" in")), "{lengths:?}"); +} diff --git a/crates/ui-egui/tests/scenarios/sketch_dimension_design_units.json b/crates/ui-egui/tests/scenarios/sketch_dimension_design_units.json new file mode 100644 index 000000000..bccaff35e --- /dev/null +++ b/crates/ui-egui/tests/scenarios/sketch_dimension_design_units.json @@ -0,0 +1,18 @@ +[ + {"note": "#3812: in an inch design, the Dimension tool's value box opens in inches (`1 in` for a 25.4 mm line), as the dimension's text shows, not in millimetres (`25.4 mm`). Enter accepts the value as offered."}, + {"call": "engine.execute", "params": {"command": "sketch.create", "params": {"plane": "XY"}}}, + {"call": "engine.execute", "params": {"command": "sketch.line", "params": {"points": [[0, 0], [25.4, 0]], "ids": ["la"]}}}, + {"call": "engine.execute", "params": {"command": "document.units", "params": {"units": "in"}}}, + {"call": "ui.view", "params": {"view": "top"}}, + {"call": "ui.view", "params": {"view": "fit"}}, + {"start": "sketch.dimension"}, + {"click": {"sketch": [12.7, 0]}}, + {"click": {"sketch": [12.7, 6]}}, + {"shot": "value-box"}, + {"key": "Enter"}, + {"expect": {"errors": 0}}, + {"expect": {"query": {"command": "document.inspect", "path": ["params", 0, "expression"], "value": "1 in"}}}, + {"expect": {"query": {"command": "document.inspect", "path": ["params", 0, "unit"], "value": "in"}}}, + {"key": "Escape"}, + {"expect": {"query": {"command": "sketch.inspect", "path": ["curves", 0, "end_at", 0], "value": 25.4}}} +]