SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sketch: preview slot outlines before committing (#2535) (#2537)
takuto-NA77c3b1e765f7
diff --git a/crates/ui-egui/src/sketch_display_preview_tests.rs b/crates/ui-egui/src/sketch_display_preview_tests.rsindex c7fc01e000..06e54483b4 100644--- a/crates/ui-egui/src/sketch_display_preview_tests.rs+++ b/crates/ui-egui/src/sketch_display_preview_tests.rs@@ -86,7 +86,7 @@ fn pixel_preview_temporary_curves_match_committed_geometry_and_sampling() {];for (command, points, hover, sweep, rho, params) in cases {let tool = tool(command, &points);- let preview = preview_curve(&tool, Vec2::new(hover[0], hover[1]), sweep, rho).unwrap();+ let preview = preview_curve(&tool, Vec2::new(hover[0], hover[1]), sweep, rho, None).unwrap();let mut h = Harness::new();h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();h.app.run(command, params).unwrap();@@ -129,7 +129,7 @@ fn pixel_preview_temporary_curves_match_committed_geometry_and_sampling() {#[test]fn pixel_preview_fully_offscreen_circle_is_clipped_without_false_connections() {- let curve = preview_curve(&tool("sketch.circle.center", &[[0., 0.]]), Vec2::X, None, None).unwrap();+ let curve = preview_curve(&tool("sketch.circle.center", &[[0., 0.]]), Vec2::X, None, None, None).unwrap();let proj = projection(1000.0);// The viewport half diagonal is about 832px: a 1000px circle never enters it.assert!((proj.rect.width() * 0.5).hypot(proj.rect.height() * 0.5) < 1000.0);@@ -138,10 +138,10 @@ fn pixel_preview_fully_offscreen_circle_is_clipped_without_false_connections() {#[test]fn pixel_preview_rejects_degenerate_and_unbounded_input_without_changing_document() {- assert!(preview_curve(&tool("sketch.circle.center", &[[0., 0.]]), Vec2::new(f64::NAN, 0.), None, None).is_none());- assert!(preview_curve(&tool("sketch.arc.three_point", &[[0., 0.], [1., 0.]]), Vec2::new(2., 0.), None, None).is_none());+ assert!(preview_curve(&tool("sketch.circle.center", &[[0., 0.]]), Vec2::new(f64::NAN, 0.), None, None, None).is_none());+ assert!(preview_curve(&tool("sketch.arc.three_point", &[[0., 0.], [1., 0.]]), Vec2::new(2., 0.), None, None, None).is_none());let points = vec![[0., 0.]; 500];- assert!(preview_curve(&tool("sketch.spline.fit_point", &points), Vec2::X, None, None).is_none());+ assert!(preview_curve(&tool("sketch.spline.fit_point", &points), Vec2::X, None, None, None).is_none());}#[test]@@ -173,3 +173,136 @@ fn polygon_preview_rejects_invalid_or_unbounded_input() {let t = tool("sketch.polygon.inscribed", &[[f64::INFINITY, 0.0]]);assert!(polygon_outline(&t, Vec2::X, 6.0).is_none());}++#[test]+fn slot_preview_matches_every_committed_side_and_cap() {+ let cases = [+ ("sketch.slot.center_to_center", vec![[0., 0.], [40., 0.]], [20., 8.], json!({"p0":[0,0],"p1":[40,0],"width":16})),+ // Free pointer input retains the final click's minimum width.+ ("sketch.slot.center_to_center", vec![[0., 0.], [40., 0.]], [20., 0.], json!({"p0":[0,0],"p1":[40,0],"width":0.001})),+ ("sketch.slot.overall", vec![[0., 0.], [40., 0.]], [20., -8.], json!({"p0":[0,0],"p1":[40,0],"width":16})),+ ("sketch.slot.center_point", vec![[0., 0.], [20., 0.]], [10., 8.], json!({"center":[0,0],"end":[20,0],"width":16})),+ ("sketch.slot.arc_center", vec![[0., 0.], [20., 0.], [0., 20.]], [0., 24.], json!({"center":[0,0],"start":[20,0],"end":[0,20],"width":8})),+ (+ "sketch.slot.arc_three_point",+ vec![[20., 0.], [0., 20.], [-20., 0.]],+ [-20., 4.],+ json!({"start":[20,0],"through":[0,20],"end":[-20,0],"width":8}),+ ),+ // A sloping, reversed axis and the opposite side of a three-point centre arc.+ ("sketch.slot.center_to_center", vec![[30., 40.], [0., 0.]], [8., -6.], json!({"p0":[30,40],"p1":[0,0],"width":20})),+ (+ "sketch.slot.arc_three_point",+ vec![[-20., 0.], [0., 20.], [20., 0.]],+ [20., -4.],+ json!({"start":[-20,0],"through":[0,20],"end":[20,0],"width":8}),+ ),+ ];+ for (command, points, hover, params) in cases {+ let mut h = Harness::new();+ h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();+ let preview = preview_curve(&tool(command, &points), Vec2::new(hover[0], hover[1]), None, None, None)+ .unwrap_or_else(|| panic!("{command}: no slot outline before the width click"));+ let ctx = egui::Context::default();+ let proj = projection(2.0);+ let output = ctx.run_ui(egui::RawInput { screen_rect: Some(proj.rect), ..Default::default() }, |ui| {+ super::paint_preview_curve(preview.clone(), &Plane::XY, ui.painter(), &proj, egui::Stroke::new(1.5, egui::Color32::WHITE), 0);+ });+ assert_eq!(+ output.shapes.iter().filter(|shape| matches!(shape.shape, egui::Shape::Path(_))).count(),+ 4,+ "{command}: paint all four outline curves"+ );+ h.app.run(command, params).unwrap();+ let state = h.app.session.world_state();+ let committed = &state.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch;+ assert_eq!(preview.curves.len(), committed.curves.len(), "{command}");+ for index in 0..committed.curves.len() {+ let a = preview.exact_segs(index).unwrap_or_else(|| preview.segs(index));+ let b = committed.exact_segs(index).unwrap_or_else(|| committed.segs(index));+ assert_eq!(a.len(), b.len(), "{command}, curve {index}");+ assert_eq!(preview.curves[index].construction, committed.curves[index].construction);+ for (a, b) in a.iter().zip(&b) {+ for i in 0..=20 {+ assert!(a.point_at(f64::from(i) / 20.0).dist(b.point_at(f64::from(i) / 20.0)) < 1e-7, "{command}, curve {index}");+ }+ }+ }+ }+}++#[test]+fn typed_small_slot_width_preview_matches_the_final_click() {+ for (command, length) in [("sketch.slot.center_to_center", 40.0), ("sketch.slot.overall", 40.0), ("sketch.slot.overall", 0.0002)] {+ let mut h = Harness::new();+ h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();+ let mut t = tool(command, &[[0., 0.], [length, 0.]]);+ t.dims = crate::sketch_dims::boxes_for(command, 2);+ t.dims[0].value = "0.0002 / 2".into();+ t.dims[0].locked = true;+ t.hover = Some((Vec2::new(length * 0.5, 8.), None));+ crate::sketch_dims::validate(&h.app, &t).unwrap();++ // Zoom into the first cap: the accepted typed width is smaller than the pointer's+ // minimum width, and must still produce the same visible outline as the final click.+ let ctx = egui::Context::default();+ let proj = projection(2_000_000.0);+ let input = || egui::RawInput { screen_rect: Some(proj.rect), ..Default::default() };+ let output = ctx.run_ui(input(), |ui| super::preview(&h.app, &t, ui.painter(), &proj));+ let paths = |output: egui::FullOutput| {+ output+ .shapes+ .into_iter()+ .filter_map(|s| match s.shape {+ egui::Shape::Path(path) => Some(path.points),+ _ => None,+ })+ .collect::<Vec<_>>()+ };+ let preview = paths(output);+ assert!(h.app.session.world_state().sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch.curves.is_empty());++ let click = crate::sketch_dims::placed(&h.app, &t, t.hover.as_ref().unwrap());+ h.app.tool = Some(t);+ super::place(&mut h.app, click);+ let state = h.app.session.world_state();+ let committed = &state.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch;+ assert_eq!(committed.curves.len(), 4, "{command}: final click commits the typed width");+ let solidcraft_engine::geom::Seg2::Arc { radius, .. } = committed.segs(1)[0] else { panic!("missing slot cap") };+ assert!((radius - 0.00005).abs() < 1e-10, "{command}: the typed width determines the cap radius");+ let output = ctx.run_ui(input(), |ui| {+ super::paint_preview_curve(committed.clone(), &Plane::XY, ui.painter(), &proj, egui::Stroke::new(1.5, egui::Color32::WHITE), 0);+ });+ let expected = paths(output);+ assert!(!expected.is_empty(), "{command}: the zoomed cap must be visible");+ assert_eq!(preview.len(), expected.len(), "{command}: preview and committed paths");+ for (preview, expected) in preview.iter().zip(&expected) {+ assert_eq!(preview.len(), expected.len(), "{command}: sampled path vertices");+ for (preview, expected) in preview.iter().zip(expected) {+ assert!(preview.distance(*expected) < 0.1, "{command}: preview {preview:?}, committed {expected:?}");+ }+ }+ }+}++#[test]+fn slot_preview_rejects_invalid_extents() {+ let cases = [+ ("sketch.slot.center_to_center", vec![[0., 0.], [0., 0.]], [0., 8.]),+ ("sketch.slot.overall", vec![[0., 0.], [10., 0.]], [5., 5.]),+ ("sketch.slot.overall", vec![[0., 0.], [10., 0.]], [5., 8.]),+ ("sketch.slot.arc_center", vec![[0., 0.], [20., 0.], [0., 20.]], [0., 40.]),+ ("sketch.slot.arc_center", vec![[0., 0.], [0., 20.], [0., 0.]], [0., 24.]),+ ("sketch.slot.arc_three_point", vec![[0., 0.], [10., 0.], [20., 0.]], [20., 4.]),+ ];+ for (command, points, hover) in cases {+ assert!(preview_curve(&tool(command, &points), Vec2::new(hover[0], hover[1]), None, None, None).is_none(), "{command}");+ }+ let t = tool("sketch.slot.center_to_center", &[[0., 0.], [40., 0.]]);+ for hover in [Vec2::new(f64::NAN, 0.), Vec2::new(0., f64::INFINITY), Vec2::new(f64::MAX, f64::MAX)] {+ assert!(preview_curve(&t, hover, None, None, None).is_none());+ }+ for width in [0.0, -1.0, f64::NAN, f64::INFINITY, f64::MAX] {+ assert!(preview_curve(&t, Vec2::new(20., 8.), None, None, Some(width)).is_none());+ }+}diff --git a/crates/ui-egui/src/sketch_tools.rs b/crates/ui-egui/src/sketch_tools.rsindex f4edda24ff..5f05fb1204 100644--- a/crates/ui-egui/src/sketch_tools.rs+++ b/crates/ui-egui/src/sketch_tools.rs@@ -1033,7 +1033,7 @@ pub fn preview(app: &SolveApp, t: &Tool, painter: &egui::Painter, proj: &Proj) {}}if let Some((h, _)) = t.hover.as_ref()- && let Some(curve) = crate::tools::preview_curve(t, *h, None, crate::sketch_dims::locked_value(app, t, "Rho"))+ && let Some(curve) = crate::tools::preview_curve(t, *h, None, crate::sketch_dims::locked_value(app, t, "Rho"), None){crate::tools::paint_preview_curve(curve, &ss.plane, painter, proj, stroke, crate::sketch_palette::mode(app));}diff --git a/crates/ui-egui/src/tools.rs b/crates/ui-egui/src/tools.rsindex e34e2068e4..773e9d0741 100644--- a/crates/ui-egui/src/tools.rs+++ b/crates/ui-egui/src/tools.rs@@ -410,8 +410,10 @@ fn run_shape(app: &mut SolveApp, t: &Tool) -> Result<Vec<String>, String> {"sketch.polygon.edge" => json!({"p0": xy(&p[0]), "p1": xy(&p[1]), "sides": sides}),"sketch.slot.center_to_center" | "sketch.slot.overall" => {let dir = (p[1].0 - p[0].0).normalized().unwrap_or(Vec2::X);- let w = 2.0 * dir.cross(p[2].0 - p[0].0).abs();- json!({"p0": xy(&p[0]), "p1": xy(&p[1]), "width": w.max(1e-3)})+ // Seed the creator with the typed width too: an Overall slot places its cap+ // centres from this width before the driving dimension is applied.+ let width = crate::sketch_dims::locked_value(app, t, "Width").unwrap_or_else(|| (2.0 * dir.cross(p[2].0 - p[0].0).abs()).max(1e-3));+ json!({"p0": xy(&p[0]), "p1": xy(&p[1]), "width": width})}"sketch.point" => json!({"point": xy(&p[0])}),_ => return Err(format!("drawing {} is not supported", t.cmd)),@@ -572,9 +574,13 @@ pub(crate) fn paint_preview_curve(let line = matches!(curve.kind, solidcraft_engine::sketch::CurveKind::Line { .. });curve.centerline = mode == 2 && line;curve.infinite = mode == 3 && line;- curve.construction = mode != 0 && !curve.centerline;+ curve.construction |= mode != 0 && !curve.centerline;}- paint_curve(&sketch, 0, plane, painter, proj, stroke, &mut solidcraft_engine::render::SamplingBudget::new(4096, 65_536));+ let mut budget = solidcraft_engine::render::SamplingBudget::new(4096, 65_536);+ for index in 0..sketch.curves.len() {+ paint_curve(&sketch, index, plane, painter, proj, stroke, &mut budget);+ }+ crate::scenario::publish_count("tool_preview_curves", sketch.curves.len() as f64);}pub(crate) fn paint_sketch_path(points: &[solidcraft_engine::geom::Vec3], mode: u8, painter: &egui::Painter, proj: &Proj, stroke: Stroke) {@@ -610,7 +616,13 @@ pub(crate) fn paint_curve(/// Temporary analytic geometry uses the same exact span extraction as committed curves./// It never solves constraints or modifies the document.-pub(crate) fn preview_curve(t: &Tool, hover: Vec2, sweep: Option<f64>, rho: Option<f64>) -> Option<solidcraft_engine::sketch::Sketch> {+pub(crate) fn preview_curve(+ t: &Tool,+ hover: Vec2,+ sweep: Option<f64>,+ rho: Option<f64>,+ slot_width: Option<f64>,+) -> Option<solidcraft_engine::sketch::Sketch> {use solidcraft_engine::sketch::{CurveKind, Sketch};if !hover.is_finite() || t.pts.len() >= solidcraft_engine::sketch::MAX_SPLINE_POINTS || t.pts.iter().any(|p| !p.0.is_finite()) {return None;@@ -633,13 +645,7 @@ pub(crate) fn preview_curve(t: &Tool, hover: Vec2, sweep: Option<f64>, rho: Optisk.add_line(*m * 2.0 - hover, hover, None, None, None).ok()?;}("sketch.circle.three_point" | "sketch.arc.three_point", [a, b]) => {- let ab = *b - *a;- let ah = hover - *a;- let d = 2.0 * ab.cross(ah);- if !d.is_finite() || d.abs() < 1e-12 {- return None;- }- let centre = *a + Vec2::new(ah.y * ab.len2() - ab.y * ah.len2(), ab.x * ah.len2() - ah.x * ab.len2()) / d;+ let centre = preview_circumcentre(*a, *b, hover)?;if t.cmd == "sketch.circle.three_point" {sk.add_circle(centre, centre.dist(*a), None, None).ok()?;} else {@@ -664,6 +670,55 @@ pub(crate) fn preview_curve(t: &Tool, hover: Vec2, sweep: Option<f64>, rho: Opticurve.reversed = sweep < 0.0;}}+ ("sketch.slot.center_to_center" | "sketch.slot.overall" | "sketch.slot.center_point", [a, b]) => {+ let dir = (*b - *a).normalized()?;+ // Typed widths can be smaller than the final click's pointer minimum.+ let width = slot_width.unwrap_or_else(|| (2.0 * dir.cross(hover - *a).abs()).max(1e-3));+ if !width.is_finite() || width <= 1e-9 {+ return None;+ }+ let radius = width * 0.5;+ let (c0, c1) = match t.cmd {+ "sketch.slot.overall" if a.dist(*b) > width => (*a + dir * radius, *b - dir * radius),+ "sketch.slot.overall" => return None,+ "sketch.slot.center_point" => (*a * 2.0 - *b, *b),+ _ => (*a, *b),+ };+ let n = dir.perp() * radius;+ sk.add_line(c0 - n, c1 - n, None, None, None).ok()?;+ sk.add_arc(c1, c1 - n, c1 + n, [None; 3], None).ok()?;+ sk.add_line(c1 + n, c0 + n, None, None, None).ok()?;+ sk.add_arc(c0, c0 + n, c0 - n, [None; 3], None).ok()?;+ }+ ("sketch.slot.arc_center" | "sketch.slot.arc_three_point", [a, b, c]) => {+ let (centre, start, end, radius, width) = if t.cmd == "sketch.slot.arc_center" {+ (*a, *b, *c, a.dist(*b), (2.0 * (hover.dist(*a) - a.dist(*b)).abs()).max(1e-3))+ } else {+ let centre = preview_circumcentre(*a, *c, *b)?;+ let span = |p: Vec2| ((p - centre).angle() - (*a - centre).angle()).rem_euclid(std::f64::consts::TAU);+ let (start, end) = if span(*b) < span(*c) { (*a, *c) } else { (*c, *a) };+ (centre, start, end, centre.dist(*a), (2.0 * hover.dist(*c)).max(1e-3))+ };+ let t0 = (start - centre).angle();+ let sweep = ((end - centre).angle() - t0).rem_euclid(std::f64::consts::TAU);+ let half = width * 0.5;+ if !radius.is_finite()+ || !half.is_finite()+ || half >= radius+ || end.dist(centre) < 1e-9+ || !(sweep > 1e-6 && sweep < std::f64::consts::TAU - 1e-6)+ {+ return None;+ }+ let at = |angle: f64, r: f64| centre + Vec2::from_angle(angle) * r;+ let t1 = t0 + sweep;+ sk.add_arc(centre, at(t0, radius + half), at(t1, radius + half), [None; 3], None).ok()?;+ sk.add_arc(centre, at(t0, radius - half), at(t1, radius - half), [None; 3], None).ok()?;+ sk.add_arc(at(t1, radius), at(t1, radius + half), at(t1, radius - half), [None; 3], None).ok()?;+ sk.add_arc(at(t0, radius), at(t0, radius - half), at(t0, radius + half), [None; 3], None).ok()?;+ let guide = sk.add_arc(centre, at(t0, radius), at(t1, radius), [None; 3], None).ok()?;+ sk.curves.get_mut(guide)?.construction = true;+ }("sketch.ellipse", [c, m]) => {let u = (*m - *c).normalized()?;let d = hover - *c;@@ -712,6 +767,17 @@ pub(crate) fn preview_curve(t: &Tool, hover: Vec2, sweep: Option<f64>, rho: OptiSome(sk)}+fn preview_circumcentre(a: Vec2, b: Vec2, c: Vec2) -> Option<Vec2> {+ let ab = b - a;+ let ac = c - a;+ let d = 2.0 * ab.cross(ac);+ if !d.is_finite() || d.abs() < 1e-12 {+ return None;+ }+ let centre = a + Vec2::new(ac.y * ab.len2() - ab.y * ac.len2(), ab.x * ac.len2() - ac.x * ab.len2()) / d;+ centre.is_finite().then_some(centre)+}+/// The polygon's actual straight edges, in the same orientation as the eventual command./// Keep preview work bounded even while a side-count expression is being edited.pub(crate) fn polygon_outline(t: &Tool, hover: Vec2, sides: f64) -> Option<Vec<Vec2>> {@@ -779,7 +845,13 @@ pub fn preview(app: &SolveApp, t: &Tool, painter: &egui::Painter, proj: &Proj) {}}- if let Some(curve) = preview_curve(t, h, crate::sketch_dims::locked_value(app, t, "Sweep"), crate::sketch_dims::locked_value(app, t, "Rho")) {+ if let Some(curve) = preview_curve(+ t,+ h,+ crate::sketch_dims::locked_value(app, t, "Sweep"),+ crate::sketch_dims::locked_value(app, t, "Rho"),+ crate::sketch_dims::locked_value(app, t, "Width"),+ ) {paint_preview_curve(curve, &ss.plane, painter, proj, stroke, crate::sketch_palette::mode(app));return;}diff --git a/crates/ui-egui/tests/scenarios/slot_preview.json b/crates/ui-egui/tests/scenarios/slot_preview.jsonnew file mode 100644index 0000000000..5fc0921718--- /dev/null+++ b/crates/ui-egui/tests/scenarios/slot_preview.json@@ -0,0 +1,82 @@+[+ {"note":"#2535: show the complete slot outline while choosing its width, without adding document curves until the final click."},+ {"call":"engine.execute","params":{"command":"sketch.create","params":{"plane":"XY"}}},+ {"call":"ui.view","params":{"view":"top"}},+ {"start":"sketch.slot.center_to_center"},+ {"click":{"sketch":[0,0]}},+ {"click":{"sketch":[40,0]}},+ {"move":{"sketch":[20,8]}},+ {"expect":{"count":{"name":"tool_preview_curves","value":4},"sketch_curves":{"own":0},"errors":0}},+ {"text":"16"},+ {"key":"Tab"},+ {"move":{"sketch":[20,20]}},+ {"expect":{"count":{"name":"tool_preview_curves","value":4},"errors":0}},+ {"click":{"sketch":[20,20]}},+ {"expect":{"sketch_curves":{"own":4},"param":{"d1":16},"errors":0}},+ {"key":"Escape"},+ {"start":"sketch.slot.overall"},+ {"click":{"sketch":[0,-30]}},+ {"click":{"sketch":[40,-30]}},+ {"move":{"sketch":[20,-38]}},+ {"expect":{"count":{"name":"tool_preview_curves","value":4},"errors":0}},+ {"click":{"sketch":[20,-38]}},+ {"expect":{"sketch_curves":{"own":8},"errors":0}},+ {"key":"Escape"},+ {"start":"sketch.slot.center_point"},+ {"click":{"sketch":[0,30]}},+ {"click":{"sketch":[20,30]}},+ {"move":{"sketch":[10,38]}},+ {"expect":{"count":{"name":"tool_preview_curves","value":4},"errors":0}},+ {"click":{"sketch":[10,38]}},+ {"expect":{"sketch_curves":{"own":12},"errors":0}},+ {"key":"Escape"},+ {"call":"engine.execute","params":{"command":"sketch.create","params":{"plane":"XY"}}},+ {"call":"ui.view","params":{"view":"top"}},+ {"start":"sketch.slot.arc_center"},+ {"click":{"sketch":[0,0]}},+ {"click":{"sketch":[20,0]}},+ {"click":{"sketch":[0,20]}},+ {"move":{"sketch":[0,24]}},+ {"expect":{"count":{"name":"tool_preview_curves","value":5},"errors":0}},+ {"click":{"sketch":[0,24]}},+ {"expect":{"sketch_curves":{"own":5},"errors":0}},+ {"key":"Escape"},+ {"call":"engine.execute","params":{"command":"sketch.create","params":{"plane":"XY"}}},+ {"call":"ui.view","params":{"view":"top"}},+ {"start":"sketch.slot.arc_three_point"},+ {"click":{"sketch":[20,0]}},+ {"click":{"sketch":[0,20]}},+ {"click":{"sketch":[-20,0]}},+ {"move":{"sketch":[-20,4]}},+ {"expect":{"count":{"name":"tool_preview_curves","value":5},"errors":0}},+ {"click":{"sketch":[-20,4]}},+ {"expect":{"sketch_curves":{"own":5},"errors":0}},+ {"key":"Escape"},+ {"note":"Typed widths below the pointer minimum remain valid for both dimensioned slot tools."},+ {"call":"engine.execute","params":{"command":"sketch.create","params":{"plane":"XY"}}},+ {"call":"ui.view","params":{"view":"top"}},+ {"start":"sketch.slot.center_to_center"},+ {"click":{"sketch":[0,0]}},+ {"click":{"sketch":[40,0]}},+ {"move":{"sketch":[20,8]}},+ {"text":"0.0002 / 2"},+ {"key":"Tab"},+ {"move":{"sketch":[20,20]}},+ {"expect":{"count":{"name":"tool_preview_curves","value":4},"sketch_curves":{"own":0},"errors":0}},+ {"click":{"sketch":[20,20]}},+ {"expect":{"sketch_curves":{"own":4},"param":{"d2":0.0001},"errors":0}},+ {"key":"Escape"},+ {"call":"engine.execute","params":{"command":"sketch.create","params":{"plane":"XY"}}},+ {"call":"ui.view","params":{"view":"top"}},+ {"start":"sketch.slot.overall"},+ {"click":{"sketch":[0,0]}},+ {"click":{"sketch":[40,0]}},+ {"move":{"sketch":[20,8]}},+ {"text":"0.0001"},+ {"key":"Tab"},+ {"move":{"sketch":[20,20]}},+ {"expect":{"count":{"name":"tool_preview_curves","value":4},"sketch_curves":{"own":0},"errors":0}},+ {"click":{"sketch":[20,20]}},+ {"expect":{"sketch_curves":{"own":4},"param":{"d3":0.0001},"errors":0}},+ {"key":"Escape"}+]