SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sketch: name = value in a drawing tool's value box defines the parameter (#7567) (#7660)
Erlis Vidalc8c5c882de25
diff --git a/crates/engine/src/cmd/sketch.rs b/crates/engine/src/cmd/sketch.rsindex 3e6bfbb1e5..7f0691b38e 100644--- a/crates/engine/src/cmd/sketch.rs+++ b/crates/engine/src/cmd/sketch.rs@@ -51,7 +51,7 @@ pub static COMMANDS: &[CommandSpec] = &[.params(concat!("points: [[x,y] | \"l1.end\" | {at, ref}…] (x and y each a number or an expression over the design's parameters, \"W / 2\": such a point is fixed where it comes to and follows the parameters; likewise wherever a point argument also takes a point id), closed?: bool, construction?: bool, ids?: [..], infer?: bool (add horizontal/vertical)", connect_doc!(), created_doc!())),CommandSpec::new("sketch.draw.dimensioned", "Draw Dimensioned Sketch Geometry", draw_dimensioned).icon("dimension").enabled(in_sketch)- .params(concat!("command: sketch creation command, params: object, dimensions: object of role to numeric or expression value; creates geometry and all driving dimensions atomically in one undo step", created_doc!())),+ .params(concat!("command: sketch creation command, params: object, dimensions: object of role to numeric or expression value, or `name = expression` (also `#name = expression`), which defines the user parameter `name` as sketch.dimension does (the reply's `defined` lists the names); creates geometry and all driving dimensions atomically in one undo step", created_doc!())),CommandSpec::new("sketch.rectangle.two_point", "2-Point Rectangle", rect_two_point).at("SKETCH", "CREATE").icon("rect")diff --git a/crates/engine/src/cmd/sketch_dimensioned.rs b/crates/engine/src/cmd/sketch_dimensioned.rsindex 9c828984f0..3d563b37bd 100644--- a/crates/engine/src/cmd/sketch_dimensioned.rs+++ b/crates/engine/src/cmd/sketch_dimensioned.rs@@ -1,6 +1,6 @@//! Shape creation and its typed driving dimensions form one command and one undo step.use serde_json::{Value, json};-use solidcraft_doc::expr::Kind;+use solidcraft_doc::expr::{Kind, definition};use crate::{Result, Session,@@ -38,7 +38,14 @@ pub(super) fn draw(s: &mut Session, p: &Value) -> Result<Value> {.filter(|e| e.len() <= 4096).ok_or_else(|| bad(cmd, "dimension values must be bounded expressions or finite numbers"))?;let kind = if role == "angle" || role == "sweep" { Kind::Angle } else { Kind::Length };- let evaluated = s.doc.eval(&e, kind)?;+ // `name = expression` is checked by its right-hand side, read as the user parameter+ // `sketch.dimension` defines will hold it (a bare number in the design's unit) (#7567).+ let rhs = match definition(&e) {+ Some((name, "")) => return Err(bad(cmd, format!("{role}: `{name} =` needs a value after the `=`"))),+ Some((_, rhs)) => rhs,+ None => e.as_str(),+ };+ let evaluated = s.doc.eval(&s.doc.with_design_unit(rhs, kind), kind)?;if role == "length" {overall_length = Some(evaluated);}@@ -85,6 +92,7 @@ pub(super) fn draw(s: &mut Session, p: &Value) -> Result<Value> {curves.get(index).filter(|v| v.is_string()).cloned().ok_or_else(|| bad(cmd, "creator did not return the expected curve"))};let mut added = serde_json::Map::new();+ let mut defined = Vec::new();for (role, value) in dimensions {let (entities, ty) = match (create, role.as_str()) {("sketch.line" | "sketch.line.midpoint", "length") => (vec![curve(0)?], "length"),@@ -120,12 +128,18 @@ pub(super) fn draw(s: &mut Session, p: &Value) -> Result<Value> {dimension["sketch"] = sketch.clone();}let result = scratch.execute("sketch.dimension", &dimension)?;+ if let Some(name) = result.get("defined").filter(|v| v.is_string()) {+ defined.push(name.clone());+ }added.insert(role.clone(), result);}// Session::execute records the wrapper's before snapshot. Nested history must not leak.scratch.undo.clear();s.accept_computed(scratch);out["dimensions"] = Value::Object(added);+ if !defined.is_empty() {+ out["defined"] = Value::Array(defined);+ }Ok(out)}diff --git a/crates/engine/src/cmd/sketch_dimensioned_tests.rs b/crates/engine/src/cmd/sketch_dimensioned_tests.rsindex 3ff5e84a8d..a3728e9bda 100644--- a/crates/engine/src/cmd/sketch_dimensioned_tests.rs+++ b/crates/engine/src/cmd/sketch_dimensioned_tests.rs@@ -227,3 +227,81 @@ fn dimensioned_authoring_uses_selected_occurrence_and_keeps_local_geometry() {close(sk.points[a].pos.x, 0.0);close(sk.points[b].pos.x, 5.0 / std::f64::consts::SQRT_2);}++/// The expression of the parameter driving the first dimension `kind` matches.+fn driving(s: &Session, kind: fn(&ConstraintKind) -> bool) -> String {+ let sk = sketch(s);+ let c = sk.constraints.iter().find(|c| kind(&c.kind)).unwrap();+ s.doc.param(c.param.as_deref().unwrap()).unwrap().expr.clone()+}++/// A typed box value `name = expression` defines the user parameter `name`, which drives the+/// dimension, as the Dimension tool's value does (#7567).+#[test]+fn a_typed_definition_defines_the_parameter_that_drives_the_dimension() {+ let is_diameter = |k: &ConstraintKind| matches!(k, ConstraintKind::Diameter { .. });+ let mut s = session();+ let undo = s.undo.len();+ let out = draw(&mut s, "sketch.circle.center", json!({"center":[0,0],"radius":3}), json!({"diameter":"width = 20"}));+ assert_eq!(s.undo.len(), undo + 1);+ assert_eq!(out["defined"], json!(["width"]), "{out}");+ close(measure(&s, is_diameter), 20.0);+ let width = s.doc.param("width").unwrap();+ assert_eq!((width.expr.as_str(), width.unit.as_str(), width.model), ("20", "mm", false));+ assert_eq!(driving(&s, is_diameter), "width");+ run(&mut s, "edit.undo", json!({}));+ assert!(sketch(&s).curves.is_empty() && s.doc.param("width").is_none());++ // A bare number is in the design's unit, in the size checks too.+ let mut s = session();+ run(&mut s, "document.units", json!({"units":"in"}));+ draw(&mut s, "sketch.circle.center", json!({"center":[0,0],"radius":3}), json!({"diameter":"#w = 2"}));+ close(measure(&s, is_diameter), 50.8);+ assert_eq!(s.doc.param("w").unwrap().unit, "in");+ let mut s = session();+ run(&mut s, "document.units", json!({"units":"in"}));+ let slot = json!({"p0":[0,0],"p1":[60,0],"width":10,"connect":false});+ draw(&mut s, "sketch.slot.overall", slot.clone(), json!({"length":"len = 2","width":"0.5"}));+ close(measure(&s, |k| matches!(k, ConstraintKind::SlotOverallLength { .. })), 50.8);++ // Both boxes of a rectangle may define a name.+ let mut s = session();+ let out = draw(&mut s, "sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[5,5]}), json!({"width":"w = 30","height":"h=10"}));+ assert_eq!(out["defined"], json!(["h", "w"]), "{out}");+ let is_length = |k: &ConstraintKind| matches!(k, ConstraintKind::Length { .. });+ let sk = sketch(&s);+ let mut lengths: Vec<_> =+ sk.constraints.iter().filter(|c| is_length(&c.kind)).map(|c| solidcraft_sketch::measure_dimension(&sk, &c.kind).unwrap()).collect();+ lengths.sort_by(f64::total_cmp);+ assert_eq!(lengths.len(), 2);+ close(lengths[0], 10.0);+ close(lengths[1], 30.0);+}++#[test]+fn a_refused_typed_definition_changes_nothing() {+ let mut s = session();+ run(&mut s, "parameters.add", json!({"name":"taken","expression":"5","unit":"mm"}));+ let circle = |value: &str| json!({"command":"sketch.circle.center","params":{"center":[0,0],"radius":3},"dimensions":{"diameter":value}});+ let rect =+ |w: &str, h: &str| json!({"command":"sketch.rectangle.two_point","params":{"p0":[0,0],"p1":[5,5]},"dimensions":{"width":w,"height":h}});+ for (params, says) in [+ (circle("taken = 20"), "already a parameter"),+ (circle("w ="), "needs a value"),+ (circle("2 = 3"), ""),+ (circle("w == 3"), ""),+ (circle("w = -4"), "invalid diameter"),+ (circle(&format!("w = {}", "1".repeat(4096))), "bounded"),+ // The same name twice: the second box finds it taken.+ (rect("w = 30", "w = 10"), "already a parameter"),+ // A box's value can't use a name the other box defines: neither exists yet.+ (rect("w = 30", "h = w / 2"), ""),+ ] {+ let snapshot = serde_json::to_value(&*s.doc).unwrap();+ let undo = s.undo.len();+ let error = s.execute("sketch.draw.dimensioned", ¶ms).expect_err(¶ms.to_string()).to_string();+ assert!(error.contains(says), "{params}: {error}");+ assert_eq!(serde_json::to_value(&*s.doc).unwrap(), snapshot, "{params}");+ assert_eq!(s.undo.len(), undo);+ }+}diff --git a/crates/ui-egui/src/sketch_dims.rs b/crates/ui-egui/src/sketch_dims.rsindex 756feb83e4..e26abefe78 100644--- a/crates/ui-egui/src/sketch_dims.rs+++ b/crates/ui-egui/src/sketch_dims.rs@@ -2,12 +2,14 @@//! boxes (line length and angle, rectangle width and height, circle diameter…) sit next to the//! segment they measure and follow the cursor. Typing goes straight into the first box and//! locks that value; Tab moves to the next box; Enter places the shape with the typed values,-//! which become dimension constraints. Values are expressions ("25", "1 in", "d1 * 2").+//! which become dimension constraints. Values are expressions ("25", "1 in", "d1 * 2"), or+//! `name = expression`, which also defines the user parameter `name` (#7567).use crate::ui_kit::{Container, Surface};use egui::{Pos2, vec2};use serde_json::{Value, json};-use solidcraft_engine::doc::expr::Kind as ValueKind;+use solidcraft_engine::doc::Document;+use solidcraft_engine::doc::expr::{Kind as ValueKind, definition};use solidcraft_engine::geom::Vec2;use crate::SolveApp;@@ -57,7 +59,19 @@ pub fn boxes_for(cmd: &str, n: usize) -> Vec<DimBox> {/// A locked box's value (mm or radians).fn locked(app: &SolveApp, t: &Tool, label: &str) -> Option<f64> {let b = t.dims.iter().chain(&t.dim_history).find(|b| b.label == label && b.locked)?;- crate::length_input::eval(&app.session.doc, &b.value, b.kind).ok().filter(|v| v.is_finite())+ eval(&app.session.doc, &b.value, b.kind).ok().filter(|v| v.is_finite())+}++/// A box value's size. `name = expression` is the right-hand side's: the size the parameter+/// `name` will hold once the shape is placed.+fn eval(doc: &Document, text: &str, kind: ValueKind) -> solidcraft_engine::doc::Result<f64> {+ crate::length_input::eval(doc, definition(text).map_or(text, |(_, rhs)| rhs), kind)+}++/// Whether a box becomes one of the shape's dimensions. A rounded rectangle's radius is its own+/// parameter (sent with the shape); sides and rho are counts and shape factors.+fn is_dimension(t: &Tool, label: &str) -> bool {+ !matches!(label, "Sides" | "Rho") && !(t.cmd == "sketch.rectangle.rounded" && label == "Radius")}fn dir_or_x(v: Vec2) -> Vec2 {@@ -346,10 +360,7 @@ pub fn dimensions(t: &Tool) -> Value {.dim_history.iter().chain(&t.dims)- // A rounded rectangle's radius is its own parameter (sent with the shape), not a dimension.- .filter(|dimension| {- dimension.locked && !matches!(dimension.label, "Sides" | "Rho") && !(t.cmd == "sketch.rectangle.rounded" && dimension.label == "Radius")- })+ .filter(|dimension| dimension.locked && is_dimension(t, dimension.label)).map(|dimension| (dimension.label.to_ascii_lowercase(), json!(dimension.value))).collect::<serde_json::Map<_, _>>();Value::Object(values)@@ -361,8 +372,15 @@ pub fn validate(app: &SolveApp, t: &Tool) -> Result<(), String> {if dimension.value.len() > 4096 {return Err(format!("{} expression is too long", dimension.label));}- let value =- crate::length_input::eval(&app.session.doc, &dimension.value, dimension.kind).map_err(|error| format!("{}: {error}", dimension.label))?;+ if let Some((name, rhs)) = definition(&dimension.value) {+ if !is_dimension(t, dimension.label) {+ return Err(format!("{}: only a box that becomes a dimension can define `{name}`; type the value alone", dimension.label));+ }+ if rhs.is_empty() {+ return Err(format!("{}: `{name} =` needs a value after the `=`", dimension.label));+ }+ }+ let value = eval(&app.session.doc, &dimension.value, dimension.kind).map_err(|error| format!("{}: {error}", dimension.label))?;if !value.is_finite() || value.abs() > 1e9 {return Err(format!("{} must be finite and within the model's size limits", dimension.label));}diff --git a/crates/ui-egui/src/sketch_dims_tests.rs b/crates/ui-egui/src/sketch_dims_tests.rsindex d57a82f5ef..4f4c10ac8a 100644--- a/crates/ui-egui/src/sketch_dims_tests.rs+++ b/crates/ui-egui/src/sketch_dims_tests.rs@@ -454,3 +454,66 @@ fn value_boxes_stay_in_view_and_off_the_cursor() {let tiny = egui::Rect::from_min_size(egui::pos2(0.0, 0.0), egui::vec2(80.0, 30.0));assert!(tiny.contains_rect(egui::Rect::from_min_size(in_view(egui::pos2(-200.0, -200.0), Some(tiny), Some(egui::pos2(40.0, 15.0))), BOX)));}++/// `name = expression` in a value box, as in the Dimension tool's: the shape takes the+/// expression's size while it is typed and when placed, and the new parameter `name` drives its+/// dimension (#7567).+#[test]+fn a_box_typed_name_equals_value_defines_the_parameter_driving_the_dimension() {+ let mut h = drawing("sketch.circle.center");+ type_value(&mut h, "width=20");+ let tool = h.app.tool.as_ref().unwrap();+ assert_eq!(crate::sketch_dims::locked_value(&h.app, tool, "Diameter"), Some(20.0), "the preview follows the typed size");+ h.step(&json!({"key": "Enter"})).unwrap();+ let state = h.app.session.world_state();+ let sk = &state.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch;+ assert_eq!(sk.curves.len(), 1, "{:?}", h.app.status);+ assert!(sk.radius(0).is_some_and(|r| (r - 10.0).abs() < 1e-6), "{:?}", sk.radius(0));+ let width = h.app.session.doc.param("width").expect("the parameter is defined");+ assert_eq!((width.expr.as_str(), width.unit.as_str(), width.model), ("20", "mm", false));+ let dimension = sk.constraints.iter().find_map(|c| c.param.as_deref()).expect("a driving dimension");+ assert_eq!(h.app.session.doc.param(dimension).unwrap().expr, "width");+ assert_eq!(h.app.status.as_ref().map(|(text, _, error)| (text.as_str(), *error)), Some(("Parameter `width` defined", false)));++ // In an inch design the right-hand side is in inches, while typing too.+ let mut h = Harness::new();+ h.app.run("document.units", json!({"units":"in"})).unwrap();+ h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();+ h.step(&json!({"start":"sketch.rectangle.two_point"})).unwrap();+ h.step(&json!({"click":{"world":[0,0,0]}})).unwrap();+ h.step(&json!({"move":{"world":[25.4,12.7,0]}})).unwrap();+ type_value(&mut h, "#w = 2");+ tab(&mut h, false);+ type_value(&mut h, "h = 1");+ let tool = h.app.tool.as_ref().unwrap();+ assert!((crate::sketch_dims::locked_value(&h.app, tool, "Width").unwrap() - 50.8).abs() < 1e-6);+ h.step(&json!({"key":"Enter"})).unwrap();+ assert_eq!(h.app.session.doc.param("w").map(|p| p.unit.as_str()), Some("in"), "{:?}", h.app.status);+ assert!(h.app.session.doc.param("h").is_some());+ assert_eq!(h.app.status.as_ref().map(|(text, _, _)| text.as_str()), Some("Parameters `h`, `w` defined"));+}++/// A box that is not a dimension (a polygon's sides, a rounded rectangle's corner radius) has+/// nothing for a parameter to drive: `name = ...` there is refused, not quietly dropped.+#[test]+fn a_definition_in_a_box_that_is_not_a_dimension_is_refused() {+ for (command, tabs, text, says) in [+ ("sketch.polygon.inscribed", 1, "n = 6", "Sides: only a box that becomes a dimension can define `n`"),+ ("sketch.rectangle.rounded", 2, "r = 2", "Radius: only a box that becomes a dimension can define `r`"),+ ("sketch.circle.center", 0, "w =", "Diameter: `w =` needs a value after the `=`"),+ ] {+ let mut h = drawing(command);+ for _ in 0..tabs {+ tab(&mut h, false);+ }+ type_value(&mut h, text);+ h.step(&json!({"key": "Enter"})).unwrap();+ let state = h.app.session.world_state();+ let sk = &state.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch;+ assert!(sk.curves.is_empty(), "{command} {text}: placed {:?}", h.app.status);+ assert!(h.app.session.doc.params.iter().all(|p| p.model), "{command} {text}: no user parameter");+ let status = h.app.status.as_ref().expect("the refusal is reported");+ assert!(status.2 && status.0.starts_with(says), "{command} {text}: {status:?}");+ assert_eq!(h.app.tool.as_ref().unwrap().pts.len(), 1, "{command} {text}: the first point stays down");+ }+}diff --git a/crates/ui-egui/src/tools.rs b/crates/ui-egui/src/tools.rsindex 33d67dea0a..9938f76311 100644--- a/crates/ui-egui/src/tools.rs+++ b/crates/ui-egui/src/tools.rs@@ -508,6 +508,13 @@ pub(crate) fn draw(app: &mut SolveApp, t: &Tool, params: Value) -> Result<Value,let history = std::mem::take(&mut app.session.undo);crate::sketch_palette::apply_mode(app, t.cmd, &result);app.session.undo = history;+ // A box typed `name = expression` defined the parameter `name` (#7567).+ let defined: Vec<_> = result["defined"].as_array().into_iter().flatten().filter_map(Value::as_str).map(|name| format!("`{name}`")).collect();+ match defined.as_slice() {+ [] => {}+ [name] => app.set_status(format!("Parameter {name} defined"), false),+ names => app.set_status(format!("Parameters {} defined", names.join(", ")), false),+ }Ok(result)}}diff --git a/docs/book/src/guide/parameters.md b/docs/book/src/guide/parameters.mdindex e00119a997..1e148b0648 100644--- a/docs/book/src/guide/parameters.md+++ b/docs/book/src/guide/parameters.md@@ -12,7 +12,9 @@ cursor, replacing selected text and keeping what you typed, so typing `10 + ` an`d1` gives `10 + d1`. Add arithmetic such as `/ 2` to build a dependent dimension. Press **Enter** to applythe expression or **Escape** to cancel the edit. When placing a new dimension, `width = 40` (or `#width = 40`) addsthe user parameter `width` with that value (a bare number is in the design's units) and-dimensions with it; a name that is already taken is refused.+dimensions with it; a name that is already taken is refused. The value boxes shown while drawing+a shape (a line's length, a rectangle's width and height, a circle's diameter) take the same+form: the shape is drawn at that size, and its dimension uses the new parameter.Add and edit user parameters through the existing **Change Parameters** command.In the MANAGE tab's PARAMETERS section, click **Parameters** to open the user and modeldiff --git a/docs/book/src/guide/sketching.md b/docs/book/src/guide/sketching.mdindex 64550f518c..e2a2b202c7 100644--- a/docs/book/src/guide/sketching.md+++ b/docs/book/src/guide/sketching.md@@ -44,6 +44,14 @@ drop-down. The button and the family's shortcut start the variant you picked lasshortcut such as L can start a Midpoint Line; pick the variant you want from the drop-down tochange it ([Keyboard shortcuts](shortcuts.md)).+Once a shape's first point is down, value boxes (a line's length and angle, a rectangle's width+and height, a circle's diameter…) follow the cursor. Typing goes into the first box, Tab moves to+the next and Enter places the shape; each typed value becomes a dimension. A value is an+expression (`25`, `1 in`, `d1 * 2`), or `width = 20` (also `#width = 20`), which also adds the+user parameter `width` and dimensions with it, as when [placing a dimension](parameters.md). A+box that does not become a dimension (a polygon's sides, a rounded rectangle's corner radius)+takes a value only.+The Sketch Palette's **Construction Geometries** option hides construction curves while youwork. A hidden construction curve cannot be picked by a click or by a box. Nothing invisibleis selectable. The option belongs to one sketch and is saved with the design. Centerlines are