SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
One tool window for sketch Fillet and the three sketch Chamfers (#789)
William Dunnbdcfe3ff1d39
diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rsindex a73a74f4f7..f04d246592 100644--- a/crates/ui-egui/src/canvas.rs+++ b/crates/ui-egui/src/canvas.rs@@ -62,6 +62,16 @@ pub fn anchor(app: &SolveApp, d: &Dialog) -> Option<(Vec3, Option<Vec3>)> {};(ss.plane.to_world(mid), dir)}+ // A corner picked into a sketch window ("<sketch id>:<point id>", or a bare id when it+ // was selected outside one): the value box sits on the corner itself.+ Sel::SketchPoint { id } => {+ let (sketch, point) = match id.split_once(':') {+ Some((sketch, point)) => (sketch.parse().ok()?, point),+ None => (app.session.active_sketch?, id.as_str()),+ };+ let ss = st.sketch(sketch)?;+ (ss.plane.to_world(ss.sketch.point(ss.sketch.resolve_point(point)?)?), None)+ }Sel::Body { name } => (st.body(name)?.mesh().bounds().center(), None),Sel::Plane { name } => {let pl = solidcraft_engine::geom::Plane::named(name).or_else(|| {diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rsindex b02435b743..21f61ab968 100644--- a/crates/ui-egui/src/dialogs.rs+++ b/crates/ui-egui/src/dialogs.rs@@ -1191,6 +1191,39 @@ pub(crate) fn combo(ui: &mut egui::Ui, id: &str, labels: &[&str], sel: &mut usizpublish_row(&r.response);}+/// A mode choice as a row of icon buttons rather than a drop-down: every mode is on screen at+/// once, each drawn as the shape it makes, with its name as the tooltip. `labels` and `icons`+/// run in step; a mode with no icon gets the fallback square. Publishes the handles a combo+/// does, `dialog:<row label>:<label>` per mode and `dialog:<row label>` for the row.+pub(crate) fn icon_choice(ui: &mut egui::Ui, labels: &[&str], icons: &[&str], sel: &mut usize) {+ let t = Tokens::get();+ let row = ROW.with(|r| r.borrow().clone());+ let mut at = None;+ ui.horizontal(|ui| {+ for (i, label) in labels.iter().enumerate() {+ let on = *sel == i;+ let (r, resp) = ui.allocate_exact_size(vec2(28.0, 24.0), egui::Sense::click());+ if on {+ ui.painter().rect_filled(r, 4.0, t.accent);+ } else if resp.hovered() {+ ui.painter().rect_filled(r, 4.0, t.hover);+ }+ let ink = if on { Color32::WHITE } else { t.icon };+ crate::icons::paint(ui.painter(), r.shrink(3.0), icons.get(i).copied().unwrap_or(""), ink, t.icon_fill, ink);+ crate::scenario::publish_handle(&format!("dialog:{row}:{label}"), r.center());+ if on {+ at = Some(r.center());+ }+ if resp.on_hover_text(tr(label)).clicked() {+ *sel = i;+ }+ }+ });+ if let Some(p) = at {+ crate::scenario::publish_handle(&format!("dialog:{row}"), p);+ }+}+thread_local! {/// The label of the dialog row being laid out (its widgets publish `dialog:<label>` handles).static ROW: std::cell::RefCell<String> = const { std::cell::RefCell::new(String::new()) };@@ -1278,6 +1311,8 @@ fn hint(inp: &SelInput) -> &'static str {"click an axis or sketch line"} else if a & CURVES != 0 {"click sketch curves"+ } else if a & selection::POINTS != 0 {+ "click sketch points"} else if a & BODIES != 0 {"click bodies"} else {@@ -2717,7 +2752,7 @@ fn mid_points(extra: &serde_json::Map<String, Value>) -> Vec<(f64, String)> {.collect()}-const CHAMFER_TYPES: [&str; 3] = ["Equal Distance", "Two Distances", "Distance and Angle"];+pub(crate) const CHAMFER_TYPES: [&str; 3] = ["Equal Distance", "Two Distances", "Distance and Angle"];/// A new Fillet or Chamfer dialog's values.fn fillet_kind(size: &str, chamfer: bool) -> Kind {diff --git a/crates/ui-egui/src/icons.rs b/crates/ui-egui/src/icons.rsindex d2e48bf34a..9467523600 100644--- a/crates/ui-egui/src/icons.rs+++ b/crates/ui-egui/src/icons.rs@@ -887,6 +887,45 @@ pub fn paint(p: &Painter, r: Rect, name: &str, ink: Color32, fill: Color32, acce1.5 * pen.s(),));}+ // The three chamfer types, for the Chamfer Type row of the corner tool window. Each+ // draws the cut it makes: equal legs with a tick on each, two unequal legs, and one leg+ // with the angle the cut leaves it at.+ "sketch_chamfer_equal" => {+ pen.line(&[(4.0, 21.0), (4.0, 12.0)], ink);+ pen.line(&[(12.0, 4.0), (21.0, 4.0)], ink);+ pen.line(&[(4.0, 12.0), (12.0, 4.0)], a);+ pen.line(&[(2.5, 9.5), (5.5, 6.5)], a);+ pen.line(&[(9.5, 2.5), (6.5, 5.5)], a);+ p.add(Shape::dashed_line(+ &[pen.at(4.0, 12.0), pen.at(4.0, 4.0), pen.at(12.0, 4.0)],+ Stroke::new(pen.w * 0.7, ink.gamma_multiply(0.5)),+ 2.0 * pen.s(),+ 1.5 * pen.s(),+ ));+ }+ "sketch_chamfer_two" => {+ pen.line(&[(4.0, 21.0), (4.0, 10.0)], ink);+ pen.line(&[(18.0, 4.0), (21.0, 4.0)], ink);+ pen.line(&[(4.0, 10.0), (18.0, 4.0)], a);+ p.add(Shape::dashed_line(+ &[pen.at(4.0, 10.0), pen.at(4.0, 4.0), pen.at(18.0, 4.0)],+ Stroke::new(pen.w * 0.7, ink.gamma_multiply(0.5)),+ 2.0 * pen.s(),+ 1.5 * pen.s(),+ ));+ }+ "sketch_chamfer_angle" => {+ pen.line(&[(4.0, 21.0), (4.0, 13.0)], ink);+ pen.line(&[(14.0, 4.0), (21.0, 4.0)], ink);+ pen.line(&[(4.0, 13.0), (14.0, 4.0)], a);+ pen.arc(4.0, 13.0, 6.0, -std::f32::consts::FRAC_PI_2, 0.73, a);+ p.add(Shape::dashed_line(+ &[pen.at(4.0, 13.0), pen.at(4.0, 4.0), pen.at(14.0, 4.0)],+ Stroke::new(pen.w * 0.7, ink.gamma_multiply(0.5)),+ 2.0 * pen.s(),+ 1.5 * pen.s(),+ ));+ }"offset" => {pen.closed(&[(8.0, 9.0), (16.0, 9.0), (16.0, 15.0), (8.0, 15.0)], ink);pen.line(&[(8.0, 4.0), (16.0, 4.0)], a);diff --git a/crates/ui-egui/src/locales/de.json b/crates/ui-egui/src/locales/de.jsonindex 70c9e84deb..d7e7962fa5 100644--- a/crates/ui-egui/src/locales/de.json+++ b/crates/ui-egui/src/locales/de.json@@ -49,6 +49,7 @@"ui.centerline": "Mittellinie","ui.chain": "Kette","ui.chamfer": "Abschrägung",+ "ui.chamfer_type": "Fasentyp","ui.change_workspace": "Arbeitsbereich wechseln","ui.chord_length": "Sehnenlänge","ui.circle": "Kreis",@@ -69,6 +70,8 @@"ui.construct": "Konstruktion","ui.construction": "Konstruktionslinie","ui.copy": "Kopieren",+ "ui.corner": "Ecke",+ "ui.corners": "Ecken","ui.counterbore": "Tiefenbohrung","ui.countersink": "Senkung","ui.create": "Erstellen",diff --git a/crates/ui-egui/src/locales/en.json b/crates/ui-egui/src/locales/en.jsonindex 3788b3a1f1..7c2ccc2ab3 100644--- a/crates/ui-egui/src/locales/en.json+++ b/crates/ui-egui/src/locales/en.json@@ -307,6 +307,7 @@"ui.centerline": "Centerline","ui.chain": "Chain","ui.chamfer": "Chamfer",+ "ui.chamfer_type": "Chamfer Type","ui.change_workspace": "Change workspace","ui.chord_length": "Chord Length","ui.circle": "Circle",@@ -331,6 +332,8 @@"ui.construction": "Construction","ui.context_menu": "Context menu","ui.copy": "Copy",+ "ui.corner": "Corner",+ "ui.corners": "Corners","ui.counterbore": "Counterbore","ui.countersink": "Countersink","ui.create": "Create",diff --git a/crates/ui-egui/src/locales/ja.json b/crates/ui-egui/src/locales/ja.jsonindex cc03dd56f1..962f9ac18c 100644--- a/crates/ui-egui/src/locales/ja.json+++ b/crates/ui-egui/src/locales/ja.json@@ -307,6 +307,7 @@"ui.centerline": "中心線","ui.chain": "チェーン","ui.chamfer": "面取り",+ "ui.chamfer_type": "面取りタイプ","ui.change_workspace": "ワークスペースの変更","ui.chord_length": "弦長","ui.circle": "円",@@ -331,6 +332,8 @@"ui.construction": "コンストラクション","ui.context_menu": "コンテキスト メニュー","ui.copy": "コピー",+ "ui.corner": "コーナー",+ "ui.corners": "コーナー","ui.counterbore": "座ぐり","ui.countersink": "皿穴","ui.create": "作成",diff --git a/crates/ui-egui/src/locales/ko.json b/crates/ui-egui/src/locales/ko.jsonindex ea6f1d06b5..2f05071875 100644--- a/crates/ui-egui/src/locales/ko.json+++ b/crates/ui-egui/src/locales/ko.json@@ -49,6 +49,7 @@"ui.centerline": "중심선","ui.chain": "체인","ui.chamfer": "모따기",+ "ui.chamfer_type": "모따기 유형","ui.change_workspace": "작업 공간 변경","ui.chord_length": "현 길이","ui.circle": "원",@@ -69,6 +70,8 @@"ui.construct": "구성","ui.construction": "구성선","ui.copy": "복사",+ "ui.corner": "코너",+ "ui.corners": "코너","ui.counterbore": "카운터보어","ui.countersink": "카운터싱크","ui.create": "만들기",diff --git a/crates/ui-egui/src/sketch_corner_ui_tests.rs b/crates/ui-egui/src/sketch_corner_ui_tests.rsindex 32b346dae1..73107da724 100644--- a/crates/ui-egui/src/sketch_corner_ui_tests.rs+++ b/crates/ui-egui/src/sketch_corner_ui_tests.rs@@ -135,8 +135,43 @@ fn derived_offset_context_action_releases_geometry_and_undo_restores() {assert_eq!(h.app.session.model.state().sketch(sid).unwrap().sketch.freeform_offsets.len(), 1);}+/// The size fields of the open Fillet or Chamfer window, as if they had been typed.+fn set_size(app: &mut SolveApp, text: &str) {+ match app.dialog.as_mut().map(|d| &mut d.kind) {+ Some(crate::dialogs::Kind::SketchModify(crate::sketch_modify_ui::Mod::Corner { size, distance2, .. })) => {+ *size = text.to_string();+ *distance2 = text.to_string();+ }+ other => panic!("the corner window is not open: {other:?}"),+ }+}++/// Replace a dialog field's contents by typing, the way a person does.+fn retype(h: &mut crate::scenario::Harness, handle: &str, text: &str) {+ h.step(&json!({"click":{"handle":handle}})).unwrap();+ h.step(&json!({"key":"A","cmd":true})).unwrap();+ h.step(&json!({"text":text})).unwrap();+ h.frames(2);+}++fn apply(h: &mut crate::scenario::Harness) {+ // Lay the window out once before reading its OK handle. An error line that wraps onto a+ // second row moves the button, and a click on the handle from the frame before then+ // lands above it and commits nothing.+ h.frames(2);+ h.step(&json!({"click":{"handle":"dialog:OK"}})).unwrap();+ h.frames(2);+}++/// Is there a point of the active sketch at `at`?+fn has_point(h: &crate::scenario::Harness, at: Vec2) -> bool {+ let st = h.app.session.world_state();+ let Some(ss) = h.app.session.active_sketch.and_then(|sid| st.sketch(sid)) else { return false };+ ss.sketch.points.iter().any(|p| p.pos.dist(at) < 1e-6)+}+#[test]-fn clicked_origin_corner_fillets_and_chamfers_with_origin_visible() {+fn corner_window_takes_the_corner_then_applies_the_typed_size() {for command in ["sketch.fillet", "sketch.chamfer.equal_distance", "sketch.chamfer.distance_angle", "sketch.chamfer.two_distance"] {let mut h = crate::scenario::Harness::new();h.app.ui.show_origin = true;@@ -146,14 +181,29 @@ fn clicked_origin_corner_fillets_and_chamfers_with_origin_visible() {let sid = h.app.session.active_sketch.unwrap();let proj = crate::viewport::projection(&h.app, h.app.viewport.rect.unwrap());let cursor = proj.to_screen(Vec3::ZERO).unwrap();- // The ordinary snap still finds the fixed origin; the corner tool must instead- // reach the rectangle's overlapping endpoint.+ // The ordinary snap still finds the fixed origin; the window must instead reach the+ // rectangle's overlapping endpoint.assert_eq!(sketch_point_at(&h.app, &proj, cursor).unwrap().1.as_deref(), Some("origin"));+ let before = (h.app.session.doc.to_json(), h.app.session.undo.len());h.step(&json!({"start":command})).unwrap();+ h.frames(2);+ assert!(h.app.tool.is_none(), "{command} must open a window, not a click tool");+ assert!(h.app.dialog.is_some(), "{command} must open a window");h.step(&json!({"move":{"world":[0,0,0]}})).unwrap();- let point = h.app.tool.as_ref().unwrap().hover.as_ref().unwrap().1.as_deref().unwrap();- assert_ne!(point, "origin", "the actual shared endpoint must be highlighted");+ let hover = h.app.viewport.hover.clone();+ let Some(crate::viewport::Hit::SketchPoint { id, .. }) = hover else {+ panic!("{command}: no corner under the cursor: {hover:?}");+ };+ assert_ne!(id, "origin", "the actual shared endpoint must be highlighted");h.step(&json!({"click":{"world":[0,0,0]}})).unwrap();+ h.frames(2);+ assert_eq!(h.app.dialog.as_ref().map(|d| d.inputs[0].items.len()), Some(1), "{command}: the corner belongs in the input");+ assert_eq!((h.app.session.doc.to_json(), h.app.session.undo.len()), before, "{command} must change nothing before OK");+ // 5 mm: the size the click flow used to guess and commit before asking.+ set_size(&mut h.app, "5");+ apply(&mut h);+ assert!(h.app.dialog.is_none(), "{command}: {:?}", h.app.status);+ assert_eq!(h.app.session.undo.len(), before.1 + 1, "{command} must be one undo entry");let st = h.app.session.world_state();let ss = st.sketch(sid).unwrap();assert_eq!(ss.sketch.point(0), Some(Vec2::ZERO));@@ -167,6 +217,7 @@ fn clicked_origin_corner_fillets_and_chamfers_with_origin_visible() {let expected = if command == "sketch.fillet" { 600.0 - 25.0 * (1.0 - std::f64::consts::PI / 4.0) } else { 587.5 };assert_eq!(ss.profiles.len(), 1);assert!((ss.profiles[0].area - expected).abs() < 1e-6, "{command}: {}", ss.profiles[0].area);+ drop(st);h.app.run("edit.undo", json!({})).unwrap();let st = h.app.session.world_state();let ss = st.sketch(sid).unwrap();@@ -175,6 +226,158 @@ fn clicked_origin_corner_fillets_and_chamfers_with_origin_visible() {}}+/// The window's reason to exist: a chamfer angle other than the 45 degrees the command used to+/// receive hard-coded. 10 mm along the first line at 30 degrees puts the second cut at+/// 10 * sin 30 / sin 60 mm, where 45 degrees would put it at 10 mm.+#[test]+fn typed_chamfer_angle_other_than_45_degrees_reaches_the_command() {+ let mut h = crate::scenario::Harness::new();+ h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();+ h.app.run("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,30]})).unwrap();+ h.frames(2);+ h.step(&json!({"start":"sketch.chamfer.distance_angle"})).unwrap();+ h.frames(2);+ h.step(&json!({"click":{"world":[40,0,0]}})).unwrap();+ h.frames(2);+ retype(&mut h, "dialog:Distance 1", "10");+ retype(&mut h, "dialog:Angle", "30");+ apply(&mut h);+ assert!(h.app.dialog.is_none(), "{:?}", h.app.status);+ let second = 10.0 / 3f64.sqrt();+ assert!(has_point(&h, Vec2::new(30.0, 0.0)), "10 mm along the first line");+ assert!(has_point(&h, Vec2::new(40.0, second)), "{second} mm along the second line, not 10 mm");+ assert!(!has_point(&h, Vec2::new(40.0, 10.0)), "45 degrees must no longer be forced");+ let st = h.app.session.world_state();+ let ss = st.sketch(h.app.session.active_sketch.unwrap()).unwrap();+ assert!((ss.profiles[0].area - (1200.0 - 0.5 * 10.0 * second)).abs() < 1e-6, "{}", ss.profiles[0].area);+}++/// One window serves all four commands: the Chamfer Type row of icon buttons switches which+/// chamfer command OK runs, with no drop-down to open.+#[test]+fn the_chamfer_type_icons_switch_which_command_the_window_runs() {+ let mut h = crate::scenario::Harness::new();+ h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();+ h.app.run("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,30]})).unwrap();+ h.frames(2);+ h.step(&json!({"start":"sketch.chamfer.equal_distance"})).unwrap();+ h.frames(2);+ h.step(&json!({"click":{"world":[40,0,0]}})).unwrap();+ h.frames(2);+ // Every mode is a button on screen, not an item behind a drop-down.+ for label in ["Equal Distance", "Two Distances", "Distance and Angle"] {+ assert!(+ crate::scenario::handle_at(&format!("dialog:Chamfer Type:{label}")).is_some(),+ "{label} must be its own button on the Chamfer Type row"+ );+ }+ h.step(&json!({"click":{"handle":"dialog:Chamfer Type:Distance and Angle"}})).unwrap();+ h.frames(2);+ retype(&mut h, "dialog:Distance 1", "10");+ retype(&mut h, "dialog:Angle", "30");+ apply(&mut h);+ assert!(h.app.dialog.is_none(), "{:?}", h.app.status);+ // The Distance and Angle command ran, not the Equal Distance one the window opened on.+ let second = 10.0 / 3f64.sqrt();+ assert!(has_point(&h, Vec2::new(30.0, 0.0)));+ assert!(has_point(&h, Vec2::new(40.0, second)));+ assert!(!has_point(&h, Vec2::new(40.0, 10.0)), "Equal Distance would have cut 10 mm off both legs");+}++/// Two Distances forced its second distance equal to the first. Both are typed now, and Flip+/// names the two lines in the other order so the first distance lands on the other leg.+#[test]+fn two_distance_chamfer_takes_both_distances_and_flip_swaps_the_legs() {+ for (flip, first, second) in [(false, Vec2::new(28.0, 0.0), Vec2::new(40.0, 4.0)), (true, Vec2::new(40.0, 12.0), Vec2::new(36.0, 0.0))] {+ let mut h = crate::scenario::Harness::new();+ h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();+ h.app.run("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,30]})).unwrap();+ h.frames(2);+ h.step(&json!({"start":"sketch.chamfer.two_distance"})).unwrap();+ h.frames(2);+ h.step(&json!({"click":{"world":[40,0,0]}})).unwrap();+ h.frames(2);+ retype(&mut h, "dialog:Distance 1", "12");+ retype(&mut h, "dialog:Distance 2", "4");+ if flip {+ h.step(&json!({"click":{"handle":"dialog:Flip"}})).unwrap();+ h.frames(2);+ }+ apply(&mut h);+ assert!(h.app.dialog.is_none(), "flip {flip}: {:?}", h.app.status);+ assert!(has_point(&h, first), "flip {flip}: the first distance belongs at {first:?}");+ assert!(has_point(&h, second), "flip {flip}: the second distance belongs at {second:?}");+ }+}++#[test]+fn escape_leaves_the_sketch_and_the_history_untouched() {+ let mut h = crate::scenario::Harness::new();+ h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();+ h.app.run("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[20,30]})).unwrap();+ h.frames(2);+ let before = (h.app.session.doc.to_json(), h.app.session.undo.len());+ h.step(&json!({"start":"sketch.fillet"})).unwrap();+ h.frames(2);+ h.step(&json!({"click":{"world":[0,0,0]}})).unwrap();+ h.frames(2);+ set_size(&mut h.app, "5");+ h.frames(2);+ h.step(&json!({"key":"Escape"})).unwrap();+ h.frames(2);+ assert!(h.app.dialog.is_none());+ assert_eq!((h.app.session.doc.to_json(), h.app.session.undo.len()), before);+}++/// A size the corner cannot take is refused with a reason, and the window stays open on it.+#[test]+fn an_impossible_size_keeps_the_window_open_with_its_reason() {+ let mut h = crate::scenario::Harness::new();+ h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();+ h.app.run("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[20,30]})).unwrap();+ h.frames(2);+ let before = (h.app.session.doc.to_json(), h.app.session.undo.len());+ h.step(&json!({"start":"sketch.chamfer.equal_distance"})).unwrap();+ h.frames(2);+ h.step(&json!({"click":{"world":[0,0,0]}})).unwrap();+ h.frames(2);+ for size in ["500", "0", "-3", "not a number"] {+ set_size(&mut h.app, size);+ apply(&mut h);+ assert!(h.app.dialog.as_ref().is_some_and(|d| d.error.is_some()), "{size} must be refused with a reason");+ assert_eq!((h.app.session.doc.to_json(), h.app.session.undo.len()), before, "{size} must change nothing");+ }+ set_size(&mut h.app, "4");+ apply(&mut h);+ assert!(h.app.dialog.is_none(), "{:?}", h.app.status);+ assert_eq!(h.app.session.undo.len(), before.1 + 1);+}++/// A fillet rounds every picked corner to one radius, as one undo entry.+#[test]+fn a_fillet_rounds_every_picked_corner_to_one_radius() {+ let mut h = crate::scenario::Harness::new();+ h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();+ h.app.run("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,30]})).unwrap();+ h.frames(2);+ let undo = h.app.session.undo.len();+ h.step(&json!({"start":"sketch.fillet"})).unwrap();+ h.frames(2);+ for corner in [[40, 0, 0], [40, 30, 0], [0, 30, 0]] {+ h.step(&json!({"click":{"world":corner}})).unwrap();+ h.frames(2);+ }+ assert_eq!(h.app.dialog.as_ref().map(|d| d.inputs[0].items.len()), Some(3));+ set_size(&mut h.app, "5");+ apply(&mut h);+ assert!(h.app.dialog.is_none(), "{:?}", h.app.status);+ assert_eq!(h.app.session.undo.len(), undo + 1, "one radius, one undo entry");+ let st = h.app.session.world_state();+ let ss = st.sketch(h.app.session.active_sketch.unwrap()).unwrap();+ assert_eq!(ss.sketch.curves.iter().filter(|c| matches!(c.kind, CurveKind::Arc { .. })).count(), 3);+ assert!((ss.profiles[0].area - (1200.0 - 3.0 * 25.0 * (1.0 - std::f64::consts::PI / 4.0))).abs() < 1e-6, "{}", ss.profiles[0].area);+}+#[test]fn ordinary_drawing_keeps_origin_snap_and_real_origin_corners_work() {let mut h = crate::scenario::Harness::new();@@ -188,7 +391,12 @@ fn ordinary_drawing_keeps_origin_snap_and_real_origin_corners_work() {h.app.tool = None;h.app.run("sketch.line", json!({"points":["origin",[20,0],[20,20],[0,20],"origin"]})).unwrap();h.step(&json!({"start":"sketch.fillet"})).unwrap();+ h.frames(2);h.step(&json!({"click":{"world":[0,0,0]}})).unwrap();+ h.frames(2);+ set_size(&mut h.app, "5");+ apply(&mut h);+ assert!(h.app.dialog.is_none(), "{:?}", h.app.status);let st = h.app.session.world_state();let ss = st.sketch(h.app.session.active_sketch.unwrap()).unwrap();assert_eq!(ss.sketch.point(0), Some(Vec2::ZERO));diff --git a/crates/ui-egui/src/sketch_modify_ui.rs b/crates/ui-egui/src/sketch_modify_ui.rsindex 82db721b75..0831f4d706 100644--- a/crates/ui-egui/src/sketch_modify_ui.rs+++ b/crates/ui-egui/src/sketch_modify_ui.rs@@ -8,17 +8,30 @@//! right-click, then one more click for the line, with nothing on screen saying what was//! picked. Move joins them too, which had no toolbar placement, no tool and no dialog: its only//! route into the UI was the sketch context menu, and that went through the same-//! empty-parameter fallback and reported an engine error. `sketch.fillet`, the three-//! `sketch.chamfer.*` commands and the sketch patterns are the same gap and join this module-//! later, each its own change.+//! empty-parameter fallback and reported an engine error. `Mod::Corner` joins them here,+//! serving `sketch.fillet` and the three `sketch.chamfer.*` commands together, the way+//! `solid.fillet` and `solid.chamfer` already share one window. Before it, a click committed a+//! size guessed at 20 percent of the shorter leg and then opened a bare parameter editor, so+//! the design changed before any number was asked for. `sketch.chamfer.distance_angle` sent a+//! hard-coded 45 degrees and `sketch.chamfer.two_distance` forced its second distance equal to+//! the first, leaving both values unreachable from the UI. The sketch patterns are the same+//! gap and join this module later, each its own change.+//!+//! The Chamfer Type choice is a row of icon buttons rather than a drop-down: the modes differ+//! in shape, and a picture of each shape names it better than a line of text.+use egui::Pos2;use serde_json::{Map, Value, json};use solidcraft_engine::Sel;use solidcraft_engine::doc::expr::Kind as ValueKind;use crate::SolveApp;-use crate::dialogs::{Kind, check, field, row_label};+use crate::dialogs::{CHAMFER_TYPES, Kind, check, field, icon_choice, row_label};use crate::selection::{AXES, CURVES, POINTS, SelInput};+use crate::viewport::{Hit, Proj};++/// The three chamfer types, drawn as the cut each one makes, in `CHAMFER_TYPES` order.+const CHAMFER_TYPE_ICONS: [&str; 3] = ["sketch_chamfer_equal", "sketch_chamfer_two", "sketch_chamfer_angle"];/// A sketch modify tool window's values.#[derive(Clone, Debug, PartialEq)]@@ -39,6 +52,13 @@ pub enum Mod {/// turn about the centre, and whether the originals stay behind. The command already/// carries the copy flag, so the Create Copy row needs no engine change.Move { x: String, y: String, angle: String, copy: bool },+ /// `sketch.fillet` and the three `sketch.chamfer.*` commands. `chamfer` chooses between a+ /// fillet and a chamfer and never changes while the window is open; `ctype` chooses which+ /// of the three chamfer commands runs (0 equal distance, 1 two distances, 2 distance and+ /// angle). `size` is the radius or the first distance, `distance2` the second distance and+ /// `angle` the angle from the first line. `flip` names the two lines in the other order, so+ /// the first distance lands on the other leg of the corner.+ Corner { chamfer: bool, ctype: usize, size: String, distance2: String, angle: String, flip: bool },}impl Mod {@@ -48,6 +68,8 @@ impl Mod {Mod::Offset { .. } => "OFFSET",Mod::Mirror => "MIRROR",Mod::Move { .. } => "MOVE/COPY",+ Mod::Corner { chamfer: false, .. } => "FILLET",+ Mod::Corner { .. } => "CHAMFER",}}@@ -58,6 +80,8 @@ impl Mod {Mod::Offset { distance, .. } => Some(("Distance", ValueKind::Length, distance)),Mod::Move { x, .. } => Some(("X Distance", ValueKind::Length, x)),Mod::Mirror => None,+ Mod::Corner { chamfer: false, size, .. } => Some(("Radius", ValueKind::Length, size)),+ Mod::Corner { size, .. } => Some(("Distance", ValueKind::Length, size)),}}}@@ -69,16 +93,32 @@ fn inputs(k: &Mod) -> Vec<SelInput> {// AXES is the mask that takes a straight sketch curve (`selection::SelInput::accepts`).Mod::Mirror => vec![SelInput::new("Entities", CURVES | POINTS, true), SelInput::new("Mirror line", AXES, false)],Mod::Move { .. } => vec![SelInput::new("Entities", CURVES | POINTS, true), SelInput::new("Center", POINTS, false)],+ // A fillet rounds any number of corners to one radius (`points`). Each chamfer command+ // cuts one corner, so its input holds one.+ Mod::Corner { chamfer: false, .. } => vec![SelInput::new("Corners", POINTS, true)],+ Mod::Corner { .. } => vec![SelInput::new("Corner", POINTS, false)],}}/// The dialog for a sketch modify command.pub fn start(_app: &SolveApp, id: &str) -> Option<(Kind, Vec<SelInput>)> {+ let corner = |chamfer: bool, ctype: usize| Mod::Corner {+ chamfer,+ ctype,+ size: "2 mm".into(),+ distance2: "2 mm".into(),+ angle: "45 deg".into(),+ flip: false,+ };let k = match id {"sketch.scale" => Mod::Scale { factor: "2".into() },"sketch.offset" => Mod::Offset { distance: "2 mm".into(), chain: true, flip: false },"sketch.mirror" => Mod::Mirror,"sketch.move" => Mod::Move { x: "0 mm".into(), y: "0 mm".into(), angle: "0 deg".into(), copy: false },+ "sketch.fillet" => corner(false, 0),+ "sketch.chamfer.equal_distance" => corner(true, 0),+ "sketch.chamfer.two_distance" => corner(true, 1),+ "sketch.chamfer.distance_angle" => corner(true, 2),_ => return None,};let i = inputs(&k);@@ -121,10 +161,62 @@ pub fn rows(ui: &mut egui::Ui, k: &mut Mod) -> bool {check(ui, copy);ui.end_row();}+ Mod::Corner { chamfer, ctype, size, distance2, angle, flip } => {+ if *chamfer {+ row_label(ui, "Chamfer Type");+ icon_choice(ui, &CHAMFER_TYPES, &CHAMFER_TYPE_ICONS, ctype);+ ui.end_row();+ }+ row_label(ui, size_label(*chamfer, *ctype));+ enter |= field(ui, size);+ ui.end_row();+ if *chamfer && *ctype == 1 {+ row_label(ui, "Distance 2");+ enter |= field(ui, distance2);+ ui.end_row();+ }+ if *chamfer && *ctype == 2 {+ row_label(ui, "Angle");+ enter |= field(ui, angle);+ ui.end_row();+ }+ // With two equal distances there is nothing to swap.+ if *chamfer && *ctype > 0 {+ row_label(ui, "Flip");+ check(ui, flip);+ ui.end_row();+ }+ }}enter}+/// What the first value means for this corner type.+fn size_label(chamfer: bool, ctype: usize) -> &'static str {+ if !chamfer {+ "Radius"+ } else if ctype == 0 {+ "Distance"+ } else {+ "Distance 1"+ }+}++/// The corner under the cursor while the Fillet or Chamfer window is open: the hover hit and+/// the selection it stands for.+///+/// Corners are resolved through `sketch_tools::corner_point` rather than the ordinary+/// nearest-point test. A rectangle drawn from the origin leaves its own endpoint on top of the+/// fixed origin point, and the nearest-point test returns the origin, which ends no two curves.+/// That resolution chooses among the endpoints that actually make a corner instead.+pub(crate) fn corner_hit(app: &SolveApp, proj: &Proj, pos: Pos2) -> Option<(Hit, Sel)> {+ let Some(Kind::SketchModify(Mod::Corner { chamfer, .. })) = app.dialog.as_ref().map(|d| &d.kind) else { return None };+ let sketch = app.session.active_sketch?;+ let (at, id) = crate::sketch_tools::corner_point(app, proj, pos, !*chamfer)?;+ let sel = Sel::SketchPoint { id: format!("{sketch}:{id}") };+ Some((Hit::SketchPoint { sketch, id, at }, sel))+}+/// What input `i` holds.fn items(inputs: &[SelInput], i: usize) -> &[Sel] {inputs.get(i).map(|x| x.items.as_slice()).unwrap_or(&[])@@ -195,6 +287,53 @@ fn signed_length(app: &SolveApp, text: &str, flip: bool) -> Result<f64, String>Ok(if flip { -v } else { v })}+/// Corner point ids picked in input `i`, within the active sketch. A `POINTS` pick is stored as+/// "<sketch id>:<point id>"; a point selected without the window carries the bare id.+fn corner_ids(app: &SolveApp, inputs: &[SelInput], i: usize) -> Vec<String> {+ let active = app.session.active_sketch;+ items(inputs, i)+ .iter()+ .filter_map(|x| match x {+ Sel::SketchPoint { id } => match id.split_once(':') {+ Some((sketch, point)) => (sketch.parse::<u64>().ok() == active).then(|| point.to_string()),+ None => Some(id.clone()),+ },+ _ => None,+ })+ .collect()+}++/// A corner size evaluated against the document's parameters, which every corner command needs+/// to be strictly positive. A bare number means the design's units for a length and degrees for+/// an angle, as every other typed sketch value does. `value` above is the Move window's reading+/// of a field, where an empty row means zero and a negative distance is a direction; neither is+/// a radius or a chamfer leg, so this one is its own.+fn corner_size(app: &SolveApp, label: &str, text: &str, kind: ValueKind) -> Result<f64, String> {+ let doc = &app.session.doc;+ let v = doc.eval(&doc.with_design_unit(text.trim(), kind), kind).map_err(|e| format!("{label}: {e}"))?;+ if !v.is_finite() || v <= 1e-9 {+ return Err(format!("{label} must be a positive number"));+ }+ Ok(v)+}++/// The corner as a chamfer command takes it. Unflipped it is the point itself, and the command+/// resolves the two lines in curve order. Flipped it names those two lines in the other order,+/// so `distance` applies to the other leg.+fn corner_ref(app: &SolveApp, point: &str, flip: bool) -> Result<Value, String> {+ if !flip {+ return Ok(json!({ "point": point }));+ }+ let gone = || "that corner is no longer in the sketch".to_string();+ let sketch = app.session.active_sketch.ok_or("open a sketch first")?;+ let state = app.session.world_state();+ let sk = &state.sketch(sketch).ok_or_else(gone)?.sketch;+ let index = sk.resolve_point(point).ok_or_else(gone)?;+ let (a, b) = crate::sketch_tools::corner_curves(sk, index, false).ok_or("a chamfer needs a corner of exactly two lines")?;+ let id = |c: usize| sk.curves.get(c).map(|x| x.id.clone()).ok_or_else(gone);+ Ok(json!({"a": id(b)?, "b": id(a)?}))+}+/// The command a sketch modify dialog makes. `sketch.scale` takes a plain evaluated number for/// its factor, `sketch.offset` one for its distance and `sketch.move` its distances and angle,/// not expression strings: none has a model parameter to carry one, unlike `sketch.fillet`'s radius.@@ -254,6 +393,31 @@ pub fn commands(app: &SolveApp, k: &Mod, inputs: &[SelInput], extra: &Map<String}("sketch.move", p)}+ Mod::Corner { chamfer: false, size, .. } => {+ let corners = corner_ids(app, inputs, 0);+ if corners.is_empty() {+ return Err("select the corners to round first".into());+ }+ // The radius is checked where it is evaluated, against the document's parameters.+ ("sketch.fillet", json!({"points": corners, "radius": size.trim()}))+ }+ Mod::Corner { ctype, size, distance2, angle, flip, .. } => {+ let point = corner_ids(app, inputs, 0).into_iter().next().ok_or("select the corner to cut first")?;+ let mut p = corner_ref(app, &point, *flip && *ctype > 0)?;+ p["distance"] = json!(corner_size(app, size_label(true, *ctype), size, ValueKind::Length)?);+ match ctype {+ 1 => {+ p["distance2"] = json!(corner_size(app, "Distance 2", distance2, ValueKind::Length)?);+ ("sketch.chamfer.two_distance", p)+ }+ 2 => {+ // The command takes degrees; an evaluated angle is in radians.+ p["angle"] = json!(corner_size(app, "Angle", angle, ValueKind::Angle)?.to_degrees());+ ("sketch.chamfer.distance_angle", p)+ }+ _ => ("sketch.chamfer.equal_distance", p),+ }+ }};if let Value::Object(m) = &mut params {for (key, value) in extra {diff --git a/crates/ui-egui/src/sketch_tools.rs b/crates/ui-egui/src/sketch_tools.rsindex 382944c858..337f88574e 100644--- a/crates/ui-egui/src/sketch_tools.rs+++ b/crates/ui-egui/src/sketch_tools.rs@@ -357,7 +357,6 @@ fn mode(id: &str) -> Option<Mode> {"sketch.text" => Mode::Points(1),"sketch.edit_text" => Mode::Entities(1),"sketch.blend_curve" => Mode::Points(2),- "sketch.fillet" | "sketch.chamfer.equal_distance" | "sketch.chamfer.distance_angle" | "sketch.chamfer.two_distance" => Mode::Entities(1),"sketch.constraint.curvature" | "sketch.circle.two_tangent" => Mode::Entities(2),"sketch.circle.three_tangent" => Mode::Entities(3),"sketch.constrainer" | "sketch.constraint.polygon" => Mode::Entities(0),@@ -414,10 +413,6 @@ pub fn hint(id: &str) -> Option<String> {"sketch.text" => "Text: click where the text starts","sketch.edit_text" => "Edit Text: click a letter interior or outline","sketch.blend_curve" => "Blend curve: click the ends of two curves",- "sketch.fillet" => "Fillet: click the corner of two lines",- "sketch.chamfer.equal_distance" | "sketch.chamfer.distance_angle" | "sketch.chamfer.two_distance" => {- "Chamfer: click the corner of two lines"- }"sketch.constraint.curvature" => "Curvature: click two curves that share an end","sketch.circle.two_tangent" => "2-tangent circle: click two curves (the circle goes near the second click)","sketch.circle.three_tangent" => "3-tangent circle: click three curves",@@ -464,9 +459,30 @@ fn sketch_entity(app: &SolveApp, hits: &[Hit]) -> Option<(String, bool)> {})}+/// The two editable curves that meet at sketch point `pi`, in curve order, which is the order+/// the corner commands resolve them in from a `point` parameter. None unless exactly two meet+/// there and each is one the command can work on: a line always, an arc only for a fillet.+pub(crate) fn corner_curves(sk: &solidcraft_engine::sketch::Sketch, pi: usize, arcs_ok: bool) -> Option<(usize, usize)> {+ use solidcraft_engine::sketch::CurveKind;+ let curves: Vec<_> = sk+ .curves+ .iter()+ .enumerate()+ .filter(|(ci, c)| !sk.is_linked_curve(*ci) && c.kind.ends().is_some_and(|(a, b)| a == pi || b == pi))+ .take(3)+ .collect();+ if curves.iter().any(|(_, c)| !matches!(c.kind, CurveKind::Line { .. }) && !(arcs_ok && matches!(c.kind, CurveKind::Arc { .. }))) {+ return None;+ }+ match curves[..] {+ [(a, _), (b, _)] => Some((a, b)),+ _ => None,+ }+}+/// Corner tools accept endpoints shared by two editable curves. Pick among those endpoints/// directly so the origin, a circle centre or an overlapping loose point cannot hide a corner.-pub(super) fn corner_point(app: &SolveApp, proj: &Proj, pos: Pos2, cmd: &str) -> Option<(Vec2, String)> {+pub(crate) fn corner_point(app: &SolveApp, proj: &Proj, pos: Pos2, arcs_ok: bool) -> Option<(Vec2, String)> {let st = app.session.world_state();let ss = st.sketch(active_sketch(app)?)?;let sk = &ss.sketch;@@ -478,21 +494,7 @@ pub(super) fn corner_point(app: &SolveApp, proj: &Proj, pos: Pos2, cmd: &str) ->if distance >= 8.0 {return None;}- let curves: Vec<_> = sk- .curves- .iter()- .enumerate()- .filter(|(ci, c)| !sk.is_linked_curve(*ci) && c.kind.ends().is_some_and(|(a, b)| a == pi || b == pi))- .take(3)- .collect();- if curves.len() != 2- || curves.iter().any(|(_, c)| {- !matches!(c.kind, solidcraft_engine::sketch::CurveKind::Line { .. })- && (cmd != "sketch.fillet" || !matches!(c.kind, solidcraft_engine::sketch::CurveKind::Arc { .. }))- })- {- return None;- }+ corner_curves(sk, pi, arcs_ok)?;Some((distance, point.pos, point.id.clone()))}).min_by(|a, b| a.0.total_cmp(&b.0))@@ -517,21 +519,6 @@ fn curve_len(app: &SolveApp, id: &str) -> f64 {ss.sketch.curve_index(id).map(|c| ss.sketch.polyline(c).windows(2).map(|w| w[0].dist(w[1])).sum::<f64>()).unwrap_or(10.0)}-/// Lines meeting at a sketch point.-fn corner_len(app: &SolveApp, point: &str) -> f64 {- let st = app.session.world_state();- let Some(ss) = active_sketch(app).and_then(|s| st.sketch(s)) else { return 10.0 };- let sk = &ss.sketch;- let Some(q) = sk.resolve_point(point) else { return 10.0 };- sk.curves- .iter()- .enumerate()- .filter(|(_, c)| c.kind.uses(q) && matches!(c.kind, solidcraft_engine::sketch::CurveKind::Line { .. }))- .map(|(i, _)| sk.polyline(i).windows(2).map(|w| w[0].dist(w[1])).sum::<f64>())- .fold(f64::INFINITY, f64::min)- .min(1e6)-}-fn round_nice(x: f64) -> f64 {if !(x.is_finite() && x > 0.0) {return 1.0;@@ -700,12 +687,6 @@ pub fn on_click(app: &mut SolveApp, tool: &mut Tool, proj: &Proj, pos: Pos2) {place_point(app, tool, p);}Mode::Entities(n) => {- if cmd == "sketch.fillet" || cmd.starts_with("sketch.chamfer.") {- if let Some((_, id)) = corner_point(app, proj, pos, cmd) {- run_corner(app, cmd, &id);- }- return;- }if cmd == "sketch.edit_text" {let selection = hits.first().and_then(|hit| match hit {Hit::SketchCurve { sketch, id, .. } if Some(*sketch) == active_sketch(app) => {@@ -863,21 +844,6 @@ fn run_points(app: &mut SolveApp, t: &Tool) {let _ = app.run(t.cmd, params);}-fn run_corner(app: &mut SolveApp, cmd: &str, point: &str) {- let size = round_nice(corner_len(app, point) * 0.2);- let params = match cmd {- "sketch.fillet" => json!({"point": point, "radius": size}),- "sketch.chamfer.distance_angle" => json!({"point": point, "distance": size, "angle": 45}),- "sketch.chamfer.two_distance" => json!({"point": point, "distance": size, "distance2": size}),- _ => json!({"point": point, "distance": size}),- };- if let Ok(v) = app.run(cmd, params)- && let Some(p) = v["param"].as_str()- {- app.dialog = Some(crate::dialogs::Dialog::edit_param(&app.session, p));- }-}-fn run_entities(app: &mut SolveApp, t: &Tool) {let k = &t.picks;let params = match t.cmd {diff --git a/crates/ui-egui/src/tools.rs b/crates/ui-egui/src/tools.rsindex 98c34d9c1f..32891859fb 100644--- a/crates/ui-egui/src/tools.rs+++ b/crates/ui-egui/src/tools.rs@@ -125,8 +125,6 @@ pub fn on_hover(app: &mut SolveApp, proj: &Proj, pos: Pos2) {crate::sketch3d::on_hover(app, proj, pos);let h = if let Some(point) = app.tool.as_ref().and_then(|tool| crate::sketch_tools::periodic_start_snap(app, tool, proj, pos)) {Some((point, Some("Close smooth loop".into())))- } else if let Some(tool) = app.tool.as_ref().filter(|t| t.cmd == "sketch.fillet" || t.cmd.starts_with("sketch.chamfer.")) {- crate::sketch_tools::corner_point(app, proj, pos, tool.cmd).map(|(at, id)| (at, Some(id)))} else {sketch_point_at(app, proj, pos)};diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rsindex 303eb051b5..52f09b06b0 100644--- a/crates/ui-egui/src/viewport.rs+++ b/crates/ui-egui/src/viewport.rs@@ -2014,7 +2014,16 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {|| app.viewport.orbit_snap.is_some()|| app.cam_anim.is_some();let hits = hover.filter(|_| inside && app.viewport.boxsel.is_none() && !navigating).map(|p| pick_cached(app, &proj, p)).unwrap_or_default();- let cand = if app.tool.is_some() { hits.first().cloned().map(|h| (h, None)) } else { candidate(app, &hits).map(|(h, s)| (h, Some(s))) };+ // The Fillet and Chamfer window resolves its own corners: the nearest sketch point to a+ // corner drawn from the origin is the fixed origin, which ends no two curves.+ let corner = hover.filter(|_| inside && !navigating).and_then(|p| crate::sketch_modify_ui::corner_hit(app, &proj, p));+ let cand = if app.tool.is_some() {+ hits.first().cloned().map(|h| (h, None))+ } else if let Some((hit, sel)) = corner {+ Some((hit, Some(sel)))+ } else {+ candidate(app, &hits).map(|(h, s)| (h, Some(s)))+ };app.viewport.hover = cand.as_ref().map(|c| c.0.clone());// Select Other: a press held still opens the list of everything under it; while the list is// open its row under the pointer is what lights up.diff --git a/crates/ui-egui/tests/scenarios/sketch_corner_window.json b/crates/ui-egui/tests/scenarios/sketch_corner_window.jsonnew file mode 100644index 0000000000..339e626bbd--- /dev/null+++ b/crates/ui-egui/tests/scenarios/sketch_corner_window.json@@ -0,0 +1,56 @@+[+ {"note": "Sketch Fillet and the three Sketch Chamfer commands share one tool window. A click used to commit a size guessed at 20 percent of the shorter leg and then open a bare parameter editor. The chamfer angle was hard-coded to 45 degrees and the second distance was forced equal to the first, so neither was reachable."},+ {"call": "engine.execute", "params": {"command": "sketch.create", "params": {"plane": "XY"}}},+ {"call": "engine.execute", "params": {"command": "sketch.rectangle.two_point", "params": {"p0": [0, 0], "p1": [40, 30]}}},+ {"expect": {"sketch_curves": {"own": 4}, "errors": 0}},++ {"note": "Equal Distance opens the window and commits nothing until values are given. The Chamfer Type row of icon buttons then switches which of the three chamfer commands OK runs."},+ {"start": "sketch.chamfer.equal_distance"},+ {"expect": {"dialog": "Corner { chamfer: true, ctype: 0", "tool": null, "sketch_curves": {"own": 4}}},+ {"click": {"world": [40, 30, 0]}},+ {"expect": {"sketch_curves": {"own": 4}}},+ {"click": {"handle": "dialog:Chamfer Type:Distance and Angle"}},+ {"expect": {"dialog": "Corner { chamfer: true, ctype: 2"}},++ {"click": {"handle": "dialog:Distance 1"}},+ {"key": "A", "cmd": true},+ {"text": "8"},+ {"click": {"handle": "dialog:Angle"}},+ {"key": "A", "cmd": true},+ {"text": "30"},+ {"widget": "OK"},+ {"expect": {"dialog": null, "errors": 0, "sketch_curves": {"own": 5}}},++ {"note": "The typed 8 reached the command: the cut starts 8 mm down the right edge."},+ {"expect": {"query": {"command": "sketch.inspect", "path": ["curves", 4, "type"], "value": "line"}}},+ {"expect": {"query": {"command": "sketch.inspect", "path": ["curves", 4, "start_at", 1], "value": 22}}},+ {"note": "The typed 30 degrees reached it too: 8 * sin 30 / sin 60 = 4.6188 mm off the top edge. A hard-coded 45 degrees would cut 8 mm and leave 32."},+ {"expect": {"query": {"command": "sketch.inspect", "path": ["curves", 4, "end_at", 0], "value": 35.381197846482}}},++ {"note": "Escape leaves the sketch and the history exactly as they were."},+ {"start": "sketch.chamfer.equal_distance"},+ {"expect": {"dialog": "Corner { chamfer: true, ctype: 0"}},+ {"click": {"world": [0, 30, 0]}},+ {"click": {"handle": "dialog:Distance"}},+ {"key": "A", "cmd": true},+ {"text": "5"},+ {"key": "Escape"},+ {"expect": {"dialog": null, "errors": 0, "sketch_curves": {"own": 5}}},++ {"note": "Fillet: the same window with a radius, on a second sketch."},+ {"call": "engine.execute", "params": {"command": "sketch.finish", "params": {}}},+ {"call": "engine.execute", "params": {"command": "sketch.create", "params": {"plane": "XZ"}}},+ {"call": "engine.execute", "params": {"command": "sketch.rectangle.two_point", "params": {"p0": [0, 0], "p1": [40, 30]}}},+ {"start": "sketch.fillet"},+ {"expect": {"dialog": "Corner { chamfer: false", "tool": null}},+ {"click": {"sketch": [40, 0]}},+ {"expect": {"sketch_curves": {"own": 4}}},+ {"click": {"handle": "dialog:Radius"}},+ {"key": "A", "cmd": true},+ {"text": "6"},+ {"key": "Enter"},+ {"expect": {"dialog": null, "errors": 0, "sketch_curves": {"own": 5}}},+ {"note": "The typed 6 reached the command, which the guessed size never let anyone choose."},+ {"expect": {"query": {"command": "sketch.inspect", "path": ["curves", 4, "type"], "value": "arc"}}},+ {"expect": {"query": {"command": "sketch.inspect", "path": ["curves", 4, "radius"], "value": 6}}}+]