SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sketch: a driven dimension nothing fixes any more takes a value again (#10018) (#10023)
austin62jakeea9ea7bba85c
diff --git a/crates/ui-egui/src/dim_view.rs b/crates/ui-egui/src/dim_view.rsindex 93678d0204..7494c1380f 100644--- a/crates/ui-egui/src/dim_view.rs+++ b/crates/ui-egui/src/dim_view.rs@@ -8,9 +8,10 @@//! its dimension line), a double-click (or one click with the Dimension tool) edits its value//! in place with parameter completion. A finished sketch's shown dimensions (Show Dimensions,//! drawn by `crate::browser::dims_overlay`) take the same double-click from the model view: the-//! value is edited without editing the sketch.+//! value is edited without editing the sketch. A driven dimension that nothing else fixes any+//! more opens at its measured value too, and the value makes it driving.//! Everything acts through commands: `sketch.dimension_text`, `sketch.delete`,-//! `parameters.change`.+//! `sketch.toggle_driven`, `parameters.change`.use crate::ui_kit::{Container, Surface};use std::cell::RefCell;@@ -62,6 +63,9 @@ struct Edit {/// A shown dimension of a finished sketch, edited from the model view without editing the/// sketch (its id). None: a dimension of the sketch being edited.sketch: Option<u64>,+ /// A driven dimension that nothing else fixes any more, which the value makes driving (its+ /// constraint id; `param` names the parameter it gets).+ driven: Option<String>,}#[derive(Clone, Copy, Debug)]@@ -154,8 +158,19 @@ pub fn begin_dimension(app: &mut SolveApp, entities: Vec<String>, at: Vec2) -> Rreturn Ok(());}EDIT.with(|edit| {- *edit.borrow_mut() =- Some(Edit { param, expr, at: None, fresh: FRESH, wait: 10, draft: Some(draft), live: None, selection: None, picked: None, sketch: None })+ *edit.borrow_mut() = Some(Edit {+ param,+ expr,+ at: None,+ fresh: FRESH,+ wait: 10,+ draft: Some(draft),+ live: None,+ selection: None,+ picked: None,+ sketch: None,+ driven: None,+ })});PLACEMENT.with(|preview| *preview.borrow_mut() = None);Ok(())@@ -175,8 +190,19 @@ pub fn begin_live(app: &mut SolveApp, entities: Vec<String>, pointer: Option<Pos}let live = Some(Live { origin: pointer, moved: false, typed: false });EDIT.with(|edit| {- *edit.borrow_mut() =- Some(Edit { param, expr, at: None, fresh: FRESH, wait: 10, draft: Some(draft), live, selection: None, picked: None, sketch: None })+ *edit.borrow_mut() = Some(Edit {+ param,+ expr,+ at: None,+ fresh: FRESH,+ wait: 10,+ draft: Some(draft),+ live,+ selection: None,+ picked: None,+ sketch: None,+ driven: None,+ })});PLACEMENT.with(|preview| *preview.borrow_mut() = None);Ok(true)@@ -404,6 +430,7 @@ pub fn model_double_click(app: &mut SolveApp, pos: Pos2) -> bool {selection: None,picked: None,sketch: Some(d.sketch),+ driven: None,})});true@@ -477,11 +504,19 @@ fn open_editor(app: &mut SolveApp, id: Option<String>) -> bool {let Some(d) = id.and_then(|id| DRAWN.with(|d| d.borrow().iter().find(|x| x.id == id).cloned())) else {return false;};- let Some(param) = d.param else {- app.set_status("A driven dimension measures the sketch; it has no value to edit", false);- return true;+ let (param, expr, driven) = match d.param {+ Some(param) => {+ let expr = app.session.doc.param(¶m).map(|p| p.expr.clone()).unwrap_or_default();+ (param, expr, None)+ }+ None => match freed(app, &d.id) {+ Some((param, expr)) => (param, expr, Some(d.id.clone())),+ None => {+ app.set_status("A driven dimension measures the sketch; it has no value to edit", false);+ return true;+ }+ },};- let expr = app.session.doc.param(¶m).map(|p| p.expr.clone()).unwrap_or_default();EDIT.with(|e| {*e.borrow_mut() = Some(Edit {param,@@ -494,11 +529,63 @@ fn open_editor(app: &mut SolveApp, id: Option<String>) -> bool {selection: None,picked: None,sketch: None,+ driven,})});true}+/// A driven dimension that nothing else fixes any more, such as one placed while a Tangent+/// held its circle and left driven when the Tangent was deleted (#10018): the parameter it gets+/// as a driving one and its measured value, from making it driving on a scratch copy. None+/// while something still fixes what it measures (it can only measure).+fn freed(app: &SolveApp, constraint: &str) -> Option<(String, String)> {+ let sketch = app.session.active_sketch?;+ let mut scratch = app.session.scratch();+ scratch.execute("sketch.toggle_driven", &json!({"constraint": constraint, "driven": false})).ok()?;+ let param = scratch.doc.sketch(sketch).ok()?.constraints.iter().find(|c| c.id == constraint)?.param.clone()?;+ let expr = scratch.doc.param(¶m)?.expr.clone();+ Some((param, expr))+}++/// The value typed for a driven dimension (`freed`): it becomes driving at its measured value+/// (`sketch.toggle_driven`), then takes the value (`parameters.change`), in one undo step. When+/// the value is refused the design goes back to the checkpoint taken first, so it stays driven.+fn make_driving(app: &mut SolveApp, constraint: &str, typed: &str) -> Result<serde_json::Value, String> {+ let depth = app.session.undo.len();+ let checkpoint = app.run("edit.checkpoint", json!({}))?["checkpoint"].clone();+ let result = app+ .run("sketch.toggle_driven", json!({"constraint": constraint, "driven": false}))+ .map_err(|err| shown_error("sketch.toggle_driven", &err))+ .and_then(|_| {+ let param = app+ .session+ .active_sketch+ .and_then(|sketch| app.session.doc.sketch(sketch).ok()?.constraints.iter().find(|c| c.id == constraint)?.param.clone())+ .ok_or("The dimension value is unavailable")?;+ change_value(app, ¶m, typed)+ });+ let forget = result.is_ok();+ let _ = app.run("edit.restore_checkpoint", json!({"checkpoint": checkpoint, "forget": forget}));+ if forget {+ app.session.undo.truncate(depth + 1);+ }+ result+}++/// Set dimension parameter `param` to the expression typed for it, in the parameter's unit.+fn change_value(app: &mut SolveApp, param: &str, typed: &str) -> Result<serde_json::Value, String> {+ let kind = app+ .session+ .doc+ .param(param)+ .and_then(|p| solidcraft_engine::doc::expr::unit_info(&p.unit))+ .map(|(k, _)| k)+ .unwrap_or(solidcraft_engine::doc::expr::Kind::Unitless);+ let expression = crate::length_input::expression(&app.session.doc, typed, kind);+ app.run("parameters.change", json!({"name": param, "expression": expression})).map_err(|err| shown_error("parameters.change", &err))+}+/// Start dragging the text of the dimension under `press` (true: a dimension took the drag)./// Its lines take it only off sketch geometry (`on_geometry`: a point or curve is under `press`).pub fn drag_start(app: &SolveApp, press: Pos2, press_sketch: Vec2, on_geometry: bool) -> bool {@@ -778,6 +865,7 @@ pub fn edit_param(app: &SolveApp, param: &str) {selection: None,picked: None,sketch: None,+ driven: None,})});}@@ -946,16 +1034,10 @@ fn edit_box(app: &mut SolveApp, ctx: &egui::Context) {} else {Err("The sketch changed; place the dimension again".into())}+ } else if let Some(constraint) = &e.driven {+ make_driving(app, constraint, &e.expr)} else {- let kind = app- .session- .doc- .param(&e.param)- .and_then(|p| solidcraft_engine::doc::expr::unit_info(&p.unit))- .map(|(k, _)| k)- .unwrap_or(solidcraft_engine::doc::expr::Kind::Unitless);- let expression = crate::length_input::expression(&app.session.doc, &e.expr, kind);- app.run("parameters.change", json!({"name": e.param, "expression": expression})).map_err(|err| shown_error("parameters.change", &err))+ change_value(app, &e.param, &e.expr)};match result {Err(err) => {diff --git a/crates/ui-egui/src/dimension_create_ui_tests.rs b/crates/ui-egui/src/dimension_create_ui_tests.rsindex 7484dd234f..310420f979 100644--- a/crates/ui-egui/src/dimension_create_ui_tests.rs+++ b/crates/ui-egui/src/dimension_create_ui_tests.rs@@ -574,6 +574,82 @@ fn an_over_constraining_dimension_is_placed_as_a_driven_one() {assert_eq!(h.app.session.doc.to_json(), original);}+/// A dimension placed while a constraint fixed what it measures is driven; once that constraint+/// is deleted, a double-click opens its value, and the value makes it driving, in one undo step+/// (#10018). While the constraint holds it stays read-only, and a value refused leaves it driven.+#[test]+fn a_driven_dimension_nothing_fixes_any_more_takes_a_value() {+ let mut h = line([20., 0.]);+ h.app.run("sketch.dimension", json!({"entities":["l1"],"value":"20 mm","text_at":[10,6]})).unwrap();+ h.app.run("sketch.circle.center", json!({"center":[0,0],"radius":15})).unwrap();+ // The circle's centre is on the origin and the line's end on the circle: its size is fixed.+ let coincident = h.app.run("sketch.constraint.coincident", json!({"a":"l1.end","b":"c1"})).unwrap()["constraint"].as_str().unwrap().to_owned();+ h.app.run("sketch.dimension", json!({"entities":["c1"],"driven":true,"text_at":[-14,14]})).unwrap();+ h.settle();+ let sketch = h.app.session.active_sketch.unwrap();+ let dim = |h: &Harness| {+ let state = h.app.session.world_state();+ let sk = &state.sketch(sketch).unwrap().sketch;+ sk.constraints+ .iter()+ .find(|c| {+ matches!(+ c.kind,+ solidcraft_engine::sketch::ConstraintKind::Diameter { .. } | solidcraft_engine::sketch::ConstraintKind::Radius { .. }+ )+ })+ .cloned()+ .unwrap()+ };+ let id = dim(&h).id;+ assert!(dim(&h).driven && dim(&h).param.is_none(), "{:?}", dim(&h));+ let double_click = |h: &mut Harness| {+ h.frames(40);+ h.step(&json!({"click":{"dimension":id},"double":true})).unwrap();+ };++ // The Coincident still fixes the circle: the dimension only measures.+ let fixed = h.app.session.doc.to_json();+ double_click(&mut h);+ assert!(!crate::dim_view::editing(), "a dimension the sketch determines has no value to edit");+ assert!(h.app.status.as_ref().is_some_and(|s| s.0.contains("driven")), "{:?}", h.app.status);+ assert_eq!(h.app.session.doc.to_json(), fixed);++ // Without it, the value opens at what the dimension measures, named as the parameter it gets.+ h.app.run("sketch.delete", json!({"entities":[coincident]})).unwrap();+ h.settle();+ let before = h.app.session.doc.to_json();+ let undo = h.app.session.undo.len();+ let name = h.app.session.doc.next_d_name();+ let measured = dim(&h).kind.value().unwrap();+ double_click(&mut h);+ assert!(crate::dim_view::editing(), "{:?}", h.app.status);+ assert!(h.widget(&format!("Dimension: {name}")).is_some(), "{}", h.call("ui.inspect", json!({})));++ // A value the design refuses leaves it driven, and the design and its history as they were.+ type_value(&mut h, "nosuch * 2");+ h.step(&json!({"key":"Enter"})).unwrap();+ assert!(crate::dim_view::editing(), "a refused value keeps the box open");+ assert_eq!(h.app.session.doc.to_json(), before);+ assert_eq!(h.app.session.undo.len(), undo);++ // A value it takes makes it driving at that value.+ type_value(&mut h, "30");+ h.step(&json!({"key":"Enter"})).unwrap();+ assert!(!crate::dim_view::editing(), "{:?}", h.app.status);+ let driving = dim(&h);+ assert!(!driving.driven && driving.param.as_deref() == Some(name.as_str()), "{driving:?}");+ let value = driving.kind.value().unwrap();+ assert!((value - 30.0).abs() < 1e-6 && (measured - 30.0).abs() > 1.0, "{measured} → {value}");+ assert!(h.app.session.world_state().sketch(sketch).unwrap().report.ok());++ // One undo step puts the driven dimension back.+ assert_eq!(h.app.session.undo.len(), undo + 1);+ h.app.run("edit.undo", json!({})).unwrap();+ assert_eq!(h.app.session.doc.to_json(), before);+ crate::dim_view::cancel();+}+// ---- Type-first: D, click, type, Enter ----/// A sketch with `setup` drawn, the Top view centred on `centre`, and the Dimension tool on.