SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
//! Dimension creation is an editable draft, accepted by the real focused value field.
use crate::scenario::Harness;
use serde_json::json;
use solidcraft_engine::geom::prelude::*;
fn line(end: [f64; 2]) -> Harness {
crate::dim_view::cancel();
let mut h = Harness::new();
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
h.app.run("sketch.line", json!({"points":[[0,0],end]})).unwrap();
h.call("ui.view", json!({"view":"top"}));
// Leave room around the measured shape while testing the draft itself. Separate Fit
// tests exercise measured dock occlusion without changing the picking projection.
h.app.cam.distance = 80.0;
h.app.cam.target = solidcore_record::Vec3::new(end[0] * 0.5, end[1] * 0.5, 0.0);
h.settle();
h
}
fn place(h: &mut Harness, picks: &[[f64; 2]], at: [f64; 2]) {
h.step(&json!({"start":"sketch.dimension"})).unwrap();
for p in picks {
h.step(&json!({"click":{"world":[p[0],p[1],0]}})).unwrap();
}
h.step(&json!({"click":{"world":[at[0],at[1],0]}})).unwrap();
assert!(crate::dim_view::editing(), "placement opens an editor");
assert_eq!(h.ctx.memory(|m| m.focused()), Some(egui::Id::unique("sc_dim_edit")));
}
fn type_value(h: &mut Harness, text: &str) {
h.step(&json!({"key":"A","cmd":true})).unwrap();
if text.is_empty() {
h.step(&json!({"key":"Backspace"})).unwrap();
} else {
h.step(&json!({"text":text})).unwrap();
}
}
#[test]
fn dimension_editor_names_and_reference_picks_drive_new_and_existing_dimensions() {
let mut h = line([20., 0.]);
let source =
h.app.run("sketch.dimension", json!({"entities":["l1"],"value":20,"text_at":[10,8]})).unwrap()["param"].as_str().unwrap().to_string();
h.app.run("sketch.line", json!({"points":[[0,-10],[12,-10]],"infer":false})).unwrap();
h.settle();
place(&mut h, &[[6., -10.]], [6., -16.]);
let target = h.app.session.doc.next_d_name();
assert!(h.widget(&format!("Dimension: {target}")).is_some(), "new dimension shows its actual parameter name");
// Let the preceding placement clicks expire before starting a distinct double-click.
h.frames(40);
h.step(&json!({"click":{"dimension":source},"double":true})).unwrap();
assert!(crate::dim_view::editing(), "reference click keeps the draft open");
h.step(&json!({"text":" / 2"})).unwrap();
h.step(&json!({"key":"Enter"})).unwrap();
assert!(!crate::dim_view::editing(), "{}", h.call("ui.inspect", json!({})));
assert_eq!(h.app.session.doc.param(&target).unwrap().expr, format!("{source} / 2"));
h.app.tool = None;
h.settle();
crate::dim_view::edit_param(&h.app, &target);
h.frames(5);
assert!(h.widget(&format!("Dimension: {target}")).is_some());
type_value(&mut h, "2 * ");
h.frames(40);
h.step(&json!({"click":{"dimension":source},"double":true})).unwrap();
h.step(&json!({"key":"Enter"})).unwrap();
assert_eq!(h.app.session.doc.param(&target).unwrap().expr, format!("2 * {source}"));
h.app.run("parameters.change", json!({"name":source,"expression":"15 mm"})).unwrap();
assert!((h.app.session.doc.eval(&target, solidcraft_engine::doc::expr::Kind::Length).unwrap() - 30.).abs() < 1e-6);
crate::dim_view::cancel();
}
/// Two dimensioned lines, editing `d2` with `typed` in its value field.
fn editing_d2(typed: &str) -> Harness {
let mut h = line([20., 0.]);
h.app.run("sketch.dimension", json!({"entities":["l1"],"value":20,"text_at":[10,8]})).unwrap();
h.app.run("sketch.line", json!({"points":[[0,-10],[12,-10]],"infer":false})).unwrap();
h.app.run("sketch.dimension", json!({"entities":["l2"],"value":12,"text_at":[6,-16]})).unwrap();
h.settle();
crate::dim_view::edit_param(&h.app, "d2");
h.frames(5);
type_value(&mut h, typed);
h
}
/// Click `d1`, check the editor stays focused, then apply and return d2's expression.
fn click_d1_and_apply(h: &mut Harness) -> String {
h.step(&json!({"click":{"dimension":"d1"}})).unwrap();
assert!(crate::dim_view::editing(), "a reference click keeps the editor open");
h.frames(2);
assert_eq!(h.ctx.memory(|m| m.focused()), Some(egui::Id::unique("sc_dim_edit")), "the value field keeps the keyboard");
h.step(&json!({"key":"Enter"})).unwrap();
assert!(!crate::dim_view::editing(), "{}", h.call("ui.inspect", json!({})));
let expr = h.app.session.doc.param("d2").unwrap().expr.clone();
crate::dim_view::cancel();
expr
}
#[test]
fn clicking_another_dimension_appends_its_name_to_the_typed_text() {
for (typed, expected) in [("2 * ", "2 * d1"), ("10 + ", "10 + d1")] {
let mut h = editing_d2(typed);
assert_eq!(click_d1_and_apply(&mut h), expected, "typed {typed:?}");
}
}
#[test]
fn clicking_another_dimension_replaces_a_lone_value() {
for typed in ["10", "10 mm", "-3.5"] {
let mut h = editing_d2(typed);
assert_eq!(click_d1_and_apply(&mut h), "d1", "typed {typed:?}");
}
// The cursor inside the number does not matter: the whole value goes.
let mut h = editing_d2("125");
h.step(&json!({"key":"Home"})).unwrap();
h.step(&json!({"key":"ArrowRight"})).unwrap();
assert_eq!(click_d1_and_apply(&mut h), "d1");
}
#[test]
fn clicking_another_dimension_lets_typing_continue_after_its_name() {
let mut h = editing_d2("2 * ");
h.step(&json!({"click":{"dimension":"d1"}})).unwrap();
h.frames(2);
h.step(&json!({"text":" + 1"})).unwrap();
h.step(&json!({"key":"Enter"})).unwrap();
assert_eq!(h.app.session.doc.param("d2").unwrap().expr, "2 * d1 + 1");
crate::dim_view::cancel();
}
#[test]
fn clicking_another_dimension_inserts_its_name_at_the_cursor() {
let mut h = editing_d2("( ) / 2");
h.step(&json!({"key":"Home"})).unwrap();
h.step(&json!({"key":"ArrowRight"})).unwrap();
h.step(&json!({"key":"ArrowRight"})).unwrap();
assert_eq!(click_d1_and_apply(&mut h), "( d1) / 2");
}
#[test]
fn clicking_another_dimension_replaces_the_selected_text() {
let mut h = editing_d2("5 + 7");
h.step(&json!({"key":"ArrowLeft","shift":true})).unwrap();
assert_eq!(click_d1_and_apply(&mut h), "5 + d1");
}
#[test]
fn double_clicking_another_dimension_inserts_its_name_once() {
let mut h = editing_d2("3 * ");
// Synthetic input feeds one pointer event per frame, so this is a click and, a frame
// later, a second click that egui reads as a double-click.
h.step(&json!({"click":{"dimension":"d1"},"double":true})).unwrap();
h.step(&json!({"key":"Enter"})).unwrap();
assert_eq!(h.app.session.doc.param("d2").unwrap().expr, "3 * d1");
crate::dim_view::cancel();
}
/// With the Dimension tool on, one click on an existing dimension edits its value, as a
/// double-click does without a tool. The tool stays on, and geometry still starts a new one.
#[test]
fn dimension_tool_click_on_an_existing_dimension_edits_its_value() {
let mut h = line([20., 0.]);
h.app.run("sketch.dimension", json!({"entities":["l1"],"value":20,"text_at":[10,8]})).unwrap();
let created = h.app.run("sketch.line", json!({"points":[[0,-10],[12,-10]],"infer":false})).unwrap();
let second = created["created"]["curves"][0].as_str().unwrap().to_string();
h.settle();
h.step(&json!({"start":"sketch.dimension"})).unwrap();
h.step(&json!({"click":{"dimension":"d1"}})).unwrap();
assert!(crate::dim_view::editing(), "a click on the dimension opens its value");
h.frames(5);
assert_eq!(h.ctx.memory(|m| m.focused()), Some(egui::Id::unique("sc_dim_edit")), "the value field takes the keyboard");
type_value(&mut h, "25");
h.step(&json!({"key":"Enter"})).unwrap();
assert!(!crate::dim_view::editing(), "{}", h.call("ui.inspect", json!({})));
assert!((h.app.session.doc.eval("d1", solidcraft_engine::doc::expr::Kind::Length).unwrap() - 25.).abs() < 1e-6);
assert_eq!(h.app.session.doc.next_d_name(), "d2", "no new dimension was made");
assert_eq!(h.app.tool.as_ref().map(|t| t.cmd), Some("sketch.dimension"), "the tool stays on");
// A click on geometry still picks it for a new dimension.
h.frames(40);
h.step(&json!({"click":{"world":[6,-10,0]}})).unwrap();
assert_eq!(h.app.tool.as_ref().map(|t| t.picks.clone()), Some(vec![second]));
crate::dim_view::cancel();
}
/// With dimensions off in the selection filter, the Dimension tool leaves them alone.
#[test]
fn dimension_tool_click_respects_the_selection_filter() {
let mut h = line([20., 0.]);
h.app.run("sketch.dimension", json!({"entities":["l1"],"value":20,"text_at":[10,8]})).unwrap();
h.app.ui.pick_off.push("dimensions".into());
h.settle();
h.step(&json!({"start":"sketch.dimension"})).unwrap();
h.step(&json!({"click":{"dimension":"d1"}})).unwrap();
assert!(!crate::dim_view::editing(), "a filtered-out dimension opened for editing");
crate::dim_view::cancel();
}
/// A line from the origin to `end` with Preferences › Sketch › Dimension values set to In a
/// window (#7246).
fn windowed(end: [f64; 2]) -> Harness {
let mut h = line(end);
h.call("ui.prefs", json!({"dimension_input": "window"}));
h
}
/// The value the open new dimension's window holds.
fn draft_value() -> String {
crate::dim_view::draft_preview().map(|(expr, _, _)| expr).unwrap_or_default()
}
/// In a window, the Dimension tool places the text first and the window opens on it. Its arrows,
/// Up/Down and the wheel over the field step the value while the sketch previews it, nothing
/// reaches the design before the check, the check adds the dimension in one undo step, and the
/// tool stays on for the next dimension.
#[test]
fn a_new_dimension_in_the_window_steps_previews_and_applies_once() {
let mut h = windowed([20., 0.]);
let original = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
h.step(&json!({"start":"sketch.dimension"})).unwrap();
h.step(&json!({"click":{"world":[10,0,0]}})).unwrap();
assert_eq!(crate::dim_view::live(), None, "no value follows the pointer before the text is placed");
assert!(!crate::dim_view::editing());
h.step(&json!({"click":{"world":[10,6,0]}})).unwrap();
h.frames(3);
assert!(crate::dim_view::editing(), "placing the text opens the window");
assert_eq!(h.ctx.memory(|m| m.focused()), Some(egui::Id::unique("sc_dim_edit")), "its field takes the keyboard");
let window = crate::scenario::rect_of("dimwin").expect("the window is shown");
let drawable = h.app.viewport.layout.as_ref().unwrap().drawable;
assert!(drawable.contains_rect(window), "the window {window:?} stays in the view {drawable:?}");
assert_eq!(draft_value(), "20 mm");
let arrow = crate::scenario::handle_at("dimwin:up");
for _ in 0..3 {
h.step(&json!({"click":{"handle":"dimwin:up"}})).unwrap();
}
h.frames(2);
assert_eq!(crate::scenario::handle_at("dimwin:up"), arrow, "the window stays put while the value moves the text");
let (value, dimension, _) = crate::dim_view::draft_preview().unwrap();
assert_eq!(value, "23 mm");
assert!((dimension.kind.value().unwrap() - 23.).abs() < 1e-6, "the sketch previews the stepped value");
assert!(crate::scenario::count_of("dimwin:preview_curves").unwrap_or(0.0) > 0.0, "what the value moves is drawn");
assert_eq!(h.app.session.doc.to_json(), original, "nothing reaches the design before OK");
assert_eq!(h.app.session.undo.len(), undo);
assert_eq!(h.ctx.memory(|m| m.focused()), Some(egui::Id::unique("sc_dim_edit")), "the arrows leave the keyboard with the field");
// The wheel over the field steps it instead of zooming the view.
let cam = h.app.cam;
let field = crate::scenario::rect_of("dimwin:value").unwrap();
h.call("ui.scroll", json!({"x": field.center().x, "y": field.center().y, "delta": -40.0}));
h.frames(2);
assert_eq!(draft_value(), "22 mm");
assert_eq!(h.app.cam, cam, "the view did not zoom");
h.step(&json!({"key":"ArrowUp"})).unwrap();
h.frames(2);
assert_eq!(draft_value(), "23 mm");
h.step(&json!({"click":{"handle":"dimwin:ok"}})).unwrap();
h.frames(2);
assert!(!crate::dim_view::editing(), "{}", h.call("ui.inspect", json!({})));
assert_eq!(h.app.session.undo.len(), undo + 1, "one undo step");
let state = h.app.session.world_state().unwrap();
let sk = &state.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch;
let dimension = sk.constraints.iter().find(|c| c.param.is_some()).expect("the dimension was added");
assert!((dimension.kind.value().unwrap() - 23.).abs() < 1e-6);
assert_eq!(h.app.tool.as_ref().map(|t| (t.cmd, t.picks.len())), Some(("sketch.dimension", 0)), "the tool stays on for the next one");
crate::dim_view::cancel();
}
/// The cross and Esc drop only the dimension in the window: nothing is added and the Dimension
/// tool stays on. Esc with no window open then puts the tool down, as before.
#[test]
fn the_window_cross_and_escape_drop_only_this_dimension() {
let mut h = windowed([20., 0.]);
let original = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
place(&mut h, &[[10., 0.]], [10., 6.]);
h.step(&json!({"click":{"handle":"dimwin:up"}})).unwrap();
h.step(&json!({"click":{"handle":"dimwin:cancel"}})).unwrap();
h.frames(2);
assert!(!crate::dim_view::editing());
assert_eq!(h.app.session.doc.to_json(), original);
assert_eq!(h.app.session.undo.len(), undo);
assert_eq!(h.app.tool.as_ref().map(|t| (t.cmd, t.picks.len())), Some(("sketch.dimension", 0)));
place(&mut h, &[[10., 0.]], [10., 6.]);
h.step(&json!({"key":"Escape"})).unwrap();
assert!(!crate::dim_view::editing());
assert_eq!(h.app.session.doc.to_json(), original);
assert_eq!(h.app.tool.as_ref().map(|t| t.cmd), Some("sketch.dimension"), "Esc in the window leaves the tool on");
h.frames(40);
h.step(&json!({"key":"Escape"})).unwrap();
assert!(h.app.tool.is_none(), "Esc with no window open ends the tool");
crate::dim_view::cancel();
}
/// Double-clicking an existing dimension opens the window too. Typing and stepping preview the
/// sketch without touching the design, a value OK would refuse says why under the field, an
/// expression is left as typed by the arrows, and Enter applies the value in one undo step.
#[test]
fn double_clicking_a_dimension_opens_the_window_with_a_live_preview() {
let mut h = windowed([20., 0.]);
h.app.run("parameters.add", json!({"name":"width","expression":"30 mm"})).unwrap();
h.app.run("sketch.dimension", json!({"entities":["l1"],"value":20,"text_at":[10,8]})).unwrap();
h.settle();
let before = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
h.frames(40);
h.step(&json!({"click":{"dimension":"d1"},"double":true})).unwrap();
h.frames(3);
assert!(crate::dim_view::editing() && crate::scenario::rect_of("dimwin").is_some(), "the window opens on the dimension");
type_value(&mut h, "26");
h.frames(2);
assert!(crate::scenario::count_of("dimwin:preview_curves").unwrap_or(0.0) > 0.0, "the sketch previews 26");
h.step(&json!({"key":"ArrowUp"})).unwrap();
h.frames(2);
assert!(h.widget("27").is_some(), "Up stepped the value: {}", h.call("ui.inspect", json!({})));
assert_eq!(h.app.session.doc.to_json(), before, "nothing reaches the design before OK");
type_value(&mut h, "no_such_name");
h.frames(2);
assert!(crate::scenario::rect_of("dialog:report:dimension_error").is_some(), "the refusal shows under the field");
assert_eq!(crate::scenario::count_of("dimwin:preview_curves"), Some(0.0), "a refused value previews nothing");
type_value(&mut h, "width - 4");
h.step(&json!({"click":{"handle":"dimwin:up"}})).unwrap();
h.frames(2);
assert!(h.widget("width - 4").is_some(), "an expression is left as typed");
type_value(&mut h, "27");
h.step(&json!({"key":"Enter"})).unwrap();
h.frames(2);
assert!(!crate::dim_view::editing());
assert!((h.app.session.doc.eval("d1", solidcraft_engine::doc::expr::Kind::Length).unwrap() - 27.).abs() < 1e-6);
assert_eq!(h.app.session.undo.len(), undo + 1, "one undo step");
crate::dim_view::cancel();
}
/// The arrows keep the unit and decimal mark a value is written in: a length steps by the length
/// step converted to that unit (a bare number is in the design's unit), an angle by the angle
/// step, and anything but a plain number is left alone.
#[test]
fn window_steps_keep_the_written_unit_and_decimal_mark() {
use crate::dim_view::window::stepped;
use solidcraft_engine::doc::expr::Kind::{Angle, Length};
assert_eq!(stepped("20 mm", 1.0, Length, "mm", 1.0, 1.0).as_deref(), Some("21 mm"));
assert_eq!(stepped("20", -1.0, Length, "mm", 0.5, 1.0).as_deref(), Some("19.5"));
assert_eq!(stepped("1 in", 1.0, Length, "mm", 2.54, 1.0).as_deref(), Some("1.1 in"));
assert_eq!(stepped("1", 1.0, Length, "in", 2.54, 1.0).as_deref(), Some("1.1"), "a bare length is in the design's unit");
assert_eq!(stepped("3\"", 10.0, Length, "mm", 2.54, 1.0).as_deref(), Some("4\""));
assert_eq!(stepped("2,5 cm", 1.0, Length, "mm", 1.0, 1.0).as_deref(), Some("2,6 cm"));
assert_eq!(stepped("45 deg", -1.0, Angle, "mm", 1.0, 5.0).as_deref(), Some("40 deg"));
assert_eq!(stepped("45", 0.1, Angle, "in", 1.0, 1.0).as_deref(), Some("45.1"), "a bare angle is in degrees");
assert_eq!(stepped("width / 2", 1.0, Length, "mm", 1.0, 1.0), None);
assert_eq!(stepped("20 deg", 1.0, Length, "mm", 1.0, 1.0), None, "a length does not step an angle");
}
/// Dimension values default to In the view with steps of 1 mm and 1°; the choice and the steps
/// save, out-of-range steps and unknown choices are refused, and the Sketch page's Restore
/// Defaults and Cancel treat them as the page's own.
#[test]
fn the_dimension_window_preferences_default_save_and_reset() {
use crate::prefs::{DimensionInput, Prefs, control};
let d = Prefs::default();
assert_eq!((d.dimension_input, d.dimension_step_mm, d.dimension_step_deg), (DimensionInput::View, 1.0, 1.0));
let old: Prefs = serde_json::from_value(json!({})).unwrap();
assert_eq!(old.dimension_input, DimensionInput::View, "saved preferences without it keep the box");
let read = crate::prefs::lenient(&json!({"dimension_input": "sideways", "dimension_step_mm": 2.0}));
assert_eq!((read.dimension_input, read.dimension_step_mm), (DimensionInput::View, 2.0), "an unknown choice costs only itself");
let mut app = crate::SolveApp::new(solidcraft_engine::Session::default(), Default::default());
for refused in [
json!({"dimension_input": "sideways"}),
json!({"dimension_step_mm": 0.0}),
json!({"dimension_step_mm": 5000.0}),
json!({"dimension_step_deg": 0.0}),
json!({"dimension_step_deg": 200.0}),
] {
assert!(control(&mut app, &refused).is_err(), "{refused}");
}
assert_eq!(app.preferences, Prefs::default(), "a refusal changes nothing");
control(&mut app, &json!({"open": "Sketch", "dimension_input": "window", "dimension_step_mm": 0.5, "dimension_step_deg": 15.0})).unwrap();
control(&mut app, &json!({"button": "apply"})).unwrap();
let mut other = crate::SolveApp::new(solidcraft_engine::Session::default(), Default::default());
other.load_prefs(&app.prefs());
assert_eq!(
(other.preferences.dimension_input, other.preferences.dimension_step_mm, other.preferences.dimension_step_deg),
(DimensionInput::Window, 0.5, 15.0)
);
control(&mut app, &json!({"button": "defaults"})).unwrap();
assert_eq!(
(app.preferences.dimension_input, app.preferences.dimension_step_mm, app.preferences.dimension_step_deg),
(DimensionInput::View, 1.0, 1.0)
);
control(&mut app, &json!({"button": "cancel"})).unwrap();
assert_eq!(
(app.preferences.dimension_input, app.preferences.dimension_step_mm, app.preferences.dimension_step_deg),
(DimensionInput::Window, 0.5, 15.0)
);
}
/// The Sketch page's Dimension values switch is a real control.
#[test]
fn the_sketch_page_switches_dimension_values_to_a_window() {
let mut h = Harness::new();
h.call("ui.prefs", json!({"open": "Sketch"}));
h.frames(4);
let handle = format!("dialog:{}:{}", crate::i18n::tr("prefs.dimension_values"), crate::i18n::tr("prefs.dimension_values_window"));
crate::prefs::reveal_preference(&mut h, &handle);
h.step(&json!({"click":{"handle": handle}})).unwrap();
h.frames(2);
assert_eq!(h.app.preferences.dimension_input, crate::prefs::DimensionInput::Window);
}
#[test]
fn dimension_parameters_use_typing_and_ctrl_space_completion() {
for (prefix, expected) in [("wid", "width"), ("", "width"), ("d", "d1")] {
let mut h = line([20., 0.]);
h.app.run("parameters.add", json!({"name":"width","expression":"25 mm"})).unwrap();
if prefix == "d" {
h.app.run("sketch.line", json!({"points":[[0,-10],[12,-10]],"infer":false})).unwrap();
h.app.run("sketch.dimension", json!({"entities":["l2"],"value":12,"text_at":[6,-16]})).unwrap();
h.settle();
}
place(&mut h, &[[10., 0.]], [10., 6.]);
let baseline = h.app.session.doc.to_json();
type_value(&mut h, prefix);
if prefix.is_empty() {
h.step(&json!({"key":"Space","cmd":true})).unwrap();
}
assert!(h.widget(expected).is_some(), "parameter completion is available for {prefix:?}: {}", h.call("ui.inspect", json!({})));
h.step(&json!({"key":"Tab"})).unwrap();
assert!(crate::dim_view::editing(), "accepting completion does not apply the dimension");
assert_eq!(h.app.session.doc.to_json(), baseline);
h.step(&json!({"key":"Enter"})).unwrap();
assert!(!crate::dim_view::editing());
assert_eq!(h.app.session.doc.params.iter().rev().find(|p| p.model).unwrap().expr, expected);
crate::dim_view::cancel();
}
}
#[test]
fn edge_and_endpoint_creation_commit_once_and_undo_restores_exact_design() {
for (end, picks, at) in [
([20., 0.], vec![[10., 0.]], [10., 5.]),
([20., 0.], vec![[0., 0.], [20., 0.]], [10., 5.]),
([0., 20.], vec![[0., 0.], [0., 20.]], [-5., 10.]),
([12., 16.], vec![[0., 0.], [12., 16.]], [-5., 12.]),
] {
let mut h = line(end);
let original = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
place(&mut h, &picks, at);
assert_eq!(h.app.session.doc.to_json(), original);
assert_eq!(h.app.session.undo.len(), undo);
type_value(&mut h, "30 mm");
h.step(&json!({"key":"Enter"})).unwrap();
assert!(!crate::dim_view::editing());
assert_eq!(h.app.session.undo.len(), undo + 1);
let state = h.app.session.world_state().unwrap();
let sk = &state.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch;
assert!(
(sk.point(sk.resolve_point("l1.start").unwrap()).unwrap().dist(sk.point(sk.resolve_point("l1.end").unwrap()).unwrap()) - 30.).abs()
< 1e-6
);
assert!(sk.constraints.iter().any(|c| c.param.is_some()));
let accepted = h.app.session.doc.to_json();
h.app.run("edit.undo", json!({})).unwrap();
assert_eq!(h.app.session.doc.to_json(), original);
h.app.run("edit.redo", json!({})).unwrap();
assert_eq!(h.app.session.doc.to_json(), accepted);
}
}
#[test]
fn escape_invalid_correction_and_seed_enter_do_not_create_partial_dimensions() {
let mut h = line([20., 0.]);
let original = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
place(&mut h, &[[10., 0.]], [10., 5.]);
h.step(&json!({"key":"Escape"})).unwrap();
assert!(!crate::dim_view::editing());
assert_eq!(h.app.session.doc.to_json(), original);
assert_eq!(h.app.session.undo.len(), undo);
place(&mut h, &[[0., 0.], [20., 0.]], [10., 5.]);
type_value(&mut h, "unknown_length");
h.step(&json!({"key":"Enter"})).unwrap();
assert!(crate::dim_view::editing());
assert_eq!(h.app.session.doc.to_json(), original);
assert_eq!(h.app.session.undo.len(), undo);
type_value(&mut h, "25 mm");
h.step(&json!({"key":"Enter"})).unwrap();
assert!(!crate::dim_view::editing());
assert_eq!(h.app.session.undo.len(), undo + 1);
h.app.run("edit.undo", json!({})).unwrap();
h.settle();
place(&mut h, &[[10., 0.]], [10., 5.]);
h.step(&json!({"key":"Enter"})).unwrap();
assert_eq!(h.app.session.undo.len(), undo + 1);
assert!(!crate::dim_view::editing());
}
#[test]
fn switching_documents_cancels_creation_and_existing_parameter_edit_is_separate() {
let mut h = line([20., 0.]);
let original = h.app.session.doc.to_json();
place(&mut h, &[[10., 0.]], [10., 5.]);
h.call("ui.documents", json!({"action":"new"}));
assert!(!crate::dim_view::editing());
h.call("ui.documents", json!({"action":"switch","index":0}));
assert_eq!(h.app.session.doc.to_json(), original);
place(&mut h, &[[10., 0.]], [10., 5.]);
h.step(&json!({"key":"Enter"})).unwrap();
let undo = h.app.session.undo.len();
crate::dim_view::edit_param(&h.app, "d1");
h.settle();
type_value(&mut h, "24 mm");
h.step(&json!({"key":"Enter"})).unwrap();
assert_eq!(h.app.session.undo.len(), undo + 1);
h.app.run("edit.undo", json!({})).unwrap();
assert!(h.app.session.doc.param("d1").unwrap().expr.starts_with("20"));
}
#[test]
fn rectangle_side_and_fixed_origin_line_dimensions_preserve_other_constraints() {
for edge in [false, true] {
let mut h = line([20., 0.]);
h.app.run("sketch.constraint.fix", json!({"entity":"l1.start"})).unwrap();
h.settle();
let original = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
let picks = if edge { vec![[10., 0.]] } else { vec![[0., 0.], [20., 0.]] };
place(&mut h, &picks, [10., 5.]);
type_value(&mut h, "30 mm");
h.step(&json!({"key":"Enter"})).unwrap();
let state = h.app.session.world_state().unwrap();
let sk = &state.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch;
assert!(sk.point(sk.resolve_point("l1.start").unwrap()).unwrap().len() < 1e-8, "fixed origin remains fixed");
assert!((sk.point(sk.resolve_point("l1.end").unwrap()).unwrap().x - 30.).abs() < 1e-6);
assert_eq!(h.app.session.undo.len(), undo + 1);
h.app.run("edit.undo", json!({})).unwrap();
assert_eq!(h.app.session.doc.to_json(), original);
}
for (picks, at) in
[(vec![[0., 0.], [0., 10.]], [-5., 5.]), (vec![[0., 5.]], [-5., 5.]), (vec![[20., 0.], [20., 10.]], [25., 5.]), (vec![[20., 5.]], [25., 5.])]
{
let mut h = Harness::new();
crate::dim_view::cancel();
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
h.app.run("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[20,10]})).unwrap();
h.call("ui.view", json!({"view":"top"}));
h.app.cam.distance = 80.;
h.app.cam.target = solidcore_record::Vec3::new(10., 5., 0.);
h.settle();
let baseline = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
place(&mut h, &picks, at);
type_value(&mut h, "12 mm");
h.step(&json!({"key":"Enter"})).unwrap();
let state = h.app.session.world_state().unwrap();
let solved = state.sketch(h.app.session.active_sketch.unwrap()).unwrap();
// The sketch's first dimension scales it (#1365): 20 × 10 becomes 24 × 12.
assert!((solved.profiles[0].area - 288.).abs() < 1e-5, "the first dimension scales the rectangle: {}", solved.profiles[0].area);
assert_eq!(h.app.session.undo.len(), undo + 1);
h.app.run("edit.undo", json!({})).unwrap();
assert_eq!(h.app.session.doc.to_json(), baseline);
}
}
/// With the Sketch preference off, the first dimension sizes only what it measures (#4109).
#[test]
fn the_first_dimension_scales_the_drawing_unless_the_preference_is_off() {
for (scales, side) in [true, false].into_iter().flat_map(|s| [2_f64, 30., 500.].map(|v| (s, v))) {
let mut h = Harness::new();
crate::dim_view::cancel();
assert!(h.app.preferences.first_dimension_scales, "on by default (#1365)");
h.app.preferences.first_dimension_scales = scales;
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
h.app.run("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[20,10]})).unwrap();
h.call("ui.view", json!({"view":"top"}));
h.app.cam.distance = 80.;
h.app.cam.target = solidcore_record::Vec3::new(10., 5., 0.);
h.settle();
place(&mut h, &[[10., 0.]], [10., -5.]);
type_value(&mut h, &format!("{side} mm"));
h.step(&json!({"key":"Enter"})).unwrap();
let state = h.app.session.world_state().unwrap();
let area = state.sketch(h.app.session.active_sketch.unwrap()).unwrap().profiles[0].area;
// On: 20 × 10 scales to side × side / 2. Off: only the side changes, side × 10.
let want: f64 = if scales { side * side / 2. } else { side * 10. };
assert!((area - want).abs() < 1e-6 * want.max(1.), "scales: {scales}, side {side}, area {area}");
}
}
#[test]
fn pending_second_nested_plane_uses_world_picks_but_one_local_dimension() {
use solidcore_record::Vec2;
crate::dim_view::cancel();
let mut h = Harness::new();
let parent = h.app.run("component.create", json!({"name":"Assembly"})).unwrap();
let parent_component = parent["component"].as_u64().unwrap();
let first = parent["occurrence"].as_u64().unwrap();
let child = h.app.run("component.create", json!({"name":"Part"})).unwrap();
let component = child["component"].as_u64().unwrap();
let leaf = child["occurrence"].as_u64().unwrap();
h.app.run("component.activate", json!({"component":0})).unwrap();
let second = h.app.run("occurrence.copy", json!({"component":parent_component})).unwrap()["occurrence"].as_u64().unwrap();
h.app.run("occurrence.move", json!({"occurrence":second,"translate":[20,30,40],"axis":[1,0,0],"angle":"35 deg","capture":true})).unwrap();
h.app.run("component.activate", json!({"component":component,"occurrence":leaf,"path":[second,leaf]})).unwrap();
h.app.run("browser.visibility", json!({"paths":[[first]],"visible":false})).unwrap();
let sid = h.app.run("sketch.create", json!({"plane":"XY"})).unwrap()["sketch"].as_u64().unwrap();
// The 2D producer uses sketch-local coordinates; pointer picks below use placed world coordinates.
h.app.run("sketch.line", json!({"points":[[0,0],[20,0]]})).unwrap();
h.app.run("occurrence.move", json!({"occurrence":second,"translate":[25,32,40],"axis":[1,0,0],"angle":"35 deg","capture":false})).unwrap();
h.call("ui.view", json!({"view":"top"}));
h.app.cam.distance = 90.;
let plane = h.app.session.world_state().unwrap().sketch(sid).unwrap().plane;
h.app.cam.target = plane.to_world(Vec2::new(10., 0.));
h.settle();
let baseline = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
let pending = h.app.session.pending_moves.clone();
h.step(&json!({"start":"sketch.dimension"})).unwrap();
for p in [Vec2::ZERO, Vec2::new(20., 0.), Vec2::new(10., 5.)] {
let w = plane.to_world(p);
h.step(&json!({"click":{"world":[w.x,w.y,w.z]}})).unwrap();
}
assert!(crate::dim_view::editing());
assert_eq!(h.app.session.doc.to_json(), baseline);
type_value(&mut h, "30 mm");
h.step(&json!({"key":"Enter"})).unwrap();
assert_eq!(h.app.session.undo.len(), undo + 1);
assert_eq!(h.app.session.active_occurrence_path, Some(vec![second, leaf]));
assert_eq!(h.app.session.pending_moves, pending);
let state = h.app.session.model.state();
let sk = &state.sketch(sid).unwrap().sketch;
assert!(
(sk.point(sk.resolve_point("l1.start").unwrap()).unwrap().dist(sk.point(sk.resolve_point("l1.end").unwrap()).unwrap()) - 30.).abs() < 1e-6
);
h.app.run("edit.undo", json!({})).unwrap();
assert_eq!(h.app.session.doc.to_json(), baseline);
assert_eq!(h.app.session.pending_moves, pending);
h.app.run("edit.redo", json!({})).unwrap();
assert_eq!(h.app.session.pending_moves, pending);
assert_eq!(h.app.session.active_occurrence_path, Some(vec![second, leaf]));
}
#[test]
fn invalid_zero_negative_failed_open_and_click_away_leave_no_dimension() {
let mut h = line([20., 0.]);
let baseline = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
for invalid in ["0 mm", "-2 mm"] {
place(&mut h, &[[10., 0.]], [10., 5.]);
type_value(&mut h, invalid);
h.step(&json!({"key":"Enter"})).unwrap();
assert!(crate::dim_view::editing());
assert_eq!(h.app.session.doc.to_json(), baseline);
assert_eq!(h.app.session.undo.len(), undo);
h.step(&json!({"key":"Escape"})).unwrap();
}
place(&mut h, &[[10., 0.]], [10., 5.]);
assert!(h.app.run("doc.open", json!({"path":"missing-dimension-draft-design.solidcraft"})).is_err());
assert!(crate::dim_view::editing(), "failed replacement must preserve the draft");
assert_eq!(h.app.session.doc.to_json(), baseline);
h.frames(8);
h.step(&json!({"click":{"world":[12,-10,0]}})).unwrap();
assert!(!crate::dim_view::editing());
assert_eq!(h.app.session.doc.to_json(), baseline);
assert_eq!(h.app.session.undo.len(), undo);
}
#[test]
fn dimension_to_fillet_virtual_sharp_keeps_the_arc_and_fixed_origin() {
crate::dim_view::cancel();
let mut h = Harness::new();
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
h.app.run("sketch.line", json!({"points":[[0,0],[0,20],[20,20]],"ids":["riser","top"]})).unwrap();
h.app.run("sketch.constraint.fix", json!({"entity":"riser.start"})).unwrap();
h.app.run("sketch.constraint.horizontal_vertical", json!({"line":"riser","mode":"vertical"})).unwrap();
h.app.run("sketch.constraint.horizontal_vertical", json!({"line":"top","mode":"horizontal"})).unwrap();
// An existing width requires the fillet's retained virtual sharp. Add an independent
// height through the visible corner while preserving that width and the fillet arc.
h.app.run("sketch.dimension", json!({"entities":["top"],"value":20})).unwrap();
let fillet = h.app.run("sketch.fillet", json!({"point":"riser.end","radius":5})).unwrap();
let corner = fillet["virtual_corners"][0].as_str().unwrap().to_string();
h.call("ui.view", json!({"view":"top"}));
h.app.cam.distance = 90.;
h.app.cam.target = solidcore_record::Vec3::new(5., 10., 0.);
h.settle();
let baseline = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
place(&mut h, &[[0., 0.], [0., 20.]], [-5., 10.]);
type_value(&mut h, "30 mm");
h.step(&json!({"key":"Enter"})).unwrap();
assert!(!crate::dim_view::editing());
assert_eq!(h.app.session.undo.len(), undo + 1);
let state = h.app.session.world_state().unwrap();
let solved = state.sketch(h.app.session.active_sketch.unwrap()).unwrap();
assert!(solved.report.ok());
let sk = &solved.sketch;
assert!((sk.point(sk.point_index(&corner).unwrap()).unwrap().y - 30.).abs() < 1e-6);
assert!(sk.point(sk.resolve_point("riser.start").unwrap()).unwrap().len() < 1e-8);
assert!(sk.curves.iter().any(|c| matches!(c.kind, solidcraft_engine::sketch::CurveKind::Arc { .. })), "the dimension retains the fillet arc");
h.app.run("edit.undo", json!({})).unwrap();
assert_eq!(h.app.session.doc.to_json(), baseline);
}
/// While a new dimension's value is typed, a committed dimension moves with the sketch drawn at
/// that value and is picked where it is drawn; the draft is no hit target, and Esc puts it back.
#[test]
fn a_committed_dimension_moves_with_the_typed_preview_and_is_picked_where_drawn() {
crate::dim_view::cancel();
let mut h = Harness::new();
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
h.app.run("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[20,10]})).unwrap();
let width = h.app.run("sketch.dimension", json!({"entities":["l3"],"value":20})).unwrap()["param"].as_str().unwrap().to_string();
h.call("ui.view", json!({"view":"top"}));
h.app.cam.distance = 80.;
h.app.cam.target = solidcore_record::Vec3::new(10., 5., 0.);
h.settle();
let at = crate::dim_view::text_at(&width).unwrap();
let drawn = crate::dim_view::drawn();
let baseline = h.app.session.doc.to_json();
place(&mut h, &[[0., 0.], [0., 10.]], [-5., 5.]);
type_value(&mut h, "12 mm");
h.settle();
// The sketch is drawn at the typed height, so the width on the top side is drawn, and
// picked, 2 mm higher; the draft itself is no hit target.
let [_, top] = h.at(&json!({"world":[10,12,0]})).unwrap();
let [_, was] = h.at(&json!({"world":[10,10,0]})).unwrap();
let moved = crate::dim_view::text_at(&width).unwrap() - at;
assert!(moved.x.abs() < 0.5 && (f64::from(moved.y) - (top - was)).abs() < 0.5, "the width follows its side: {moved:?}");
let ids = |d: Vec<(String, egui::Pos2)>| d.into_iter().map(|(id, _)| id).collect::<Vec<_>>();
assert_eq!(ids(crate::dim_view::drawn()), ids(drawn.clone()), "draft annotations must not become committed hit targets");
assert_eq!(h.app.session.doc.to_json(), baseline);
h.step(&json!({"key":"Escape"})).unwrap();
assert_eq!(crate::dim_view::drawn(), drawn);
}
#[test]
fn inch_dimension_entry_survives_unit_changes_undo_and_reopen() {
let mut h = line([25.4, 0.]);
h.app.run("document.units", json!({"units":"in"})).unwrap();
place(&mut h, &[[12.7, 0.]], [12.7, 8.]);
type_value(&mut h, "1.2345");
h.step(&json!({"key":"Enter"})).unwrap();
let sketch = h.app.session.active_sketch.unwrap();
h.settle();
crate::dim_view::edit_param(&h.app, "d1");
h.settle();
type_value(&mut h, "1.3456");
h.step(&json!({"key":"Enter"})).unwrap();
let edited = h.app.session.world_state().unwrap();
let edited = &edited.sketch(sketch).unwrap().sketch;
assert!(edited.constraints.iter().any(|c| c.kind.value().is_some_and(|v| (v - 1.3456 * 25.4).abs() < 1e-6)));
h.app.run("edit.undo", json!({})).unwrap();
let before = h.app.session.world_state().unwrap().sketch(sketch).unwrap().sketch.clone();
let c = before.constraints.iter().find(|c| c.param.is_some()).unwrap();
let p = h.app.session.doc.param(c.param.as_deref().unwrap()).unwrap();
assert_eq!(crate::dim_view::label(&c.kind, Some(&p.expr), false, "in", 2), "1.2345 in");
assert!((c.kind.value().unwrap() - 31.3563).abs() < 1e-6);
h.app.run("document.units", json!({"units":"mm"})).unwrap();
assert_eq!(h.app.session.world_state().unwrap().sketch(sketch).unwrap().sketch, before);
h.app.run("edit.undo", json!({})).unwrap();
assert_eq!(h.app.session.doc.units, "in");
let doc = solidcraft_engine::doc::Document::from_json(&h.app.session.doc.to_json()).unwrap();
let reopened = solidcraft_engine::Session::new(doc);
assert_eq!(reopened.doc.units, "in");
assert_eq!(reopened.world_state().unwrap().sketch(sketch).unwrap().sketch, before);
crate::dim_view::cancel();
}
/// Placing the dimension of two unaligned points across from them, on either side, gives the
/// distance between them; pulled past an end, up or down from it gives the horizontal distance
/// and sideways the vertical one (#257, #7295).
#[test]
fn placing_a_two_point_dimension_picks_horizontal_vertical_or_aligned() {
// What each placement fixes at 10 mm: the X span, the Y span, or the length.
let spans = |a: solidcore_record::Vec2, b: solidcore_record::Vec2| [(b.x - a.x).abs(), (b.y - a.y).abs(), a.dist(b)];
for (at, measured) in
[([6., 25.], 0), ([8., 26.], 0), ([-10., 1.], 1), ([22., 14.], 1), ([10., 4.], 2), ([-6., 22.], 2), ([2., 20.], 2), ([15., 4.], 2)]
{
let mut h = line([12., 16.]);
place(&mut h, &[[0., 0.], [12., 16.]], at);
type_value(&mut h, "10 mm");
h.step(&json!({"key":"Enter"})).unwrap();
assert!(!crate::dim_view::editing());
let state = h.app.session.world_state().unwrap();
let sk = &state.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch;
let a = sk.point(sk.resolve_point("l1.start").unwrap()).unwrap();
let b = sk.point(sk.resolve_point("l1.end").unwrap()).unwrap();
let spans = spans(a, b);
assert!((spans[measured] - 10.0).abs() < 1e-6, "placed at {at:?}: {a:?} {b:?}");
// The sketch's first dimension scales it (#1365): the other span keeps its proportion.
if measured < 2 {
let drawn = [12.0, 16.0];
let other = drawn[1 - measured] * 10.0 / drawn[measured];
assert!((spans[1 - measured] - other).abs() < 1e-6, "placed at {at:?}: {a:?} {b:?}");
}
}
}
/// A dimension that would over-constrain the sketch is placed as a driven (reference) one
/// instead of failing: added with no parameter or value editor, and removed again by one
/// undo (#320).
#[test]
fn an_over_constraining_dimension_is_placed_as_a_driven_one() {
let mut h = line([20., 0.]);
h.app.run("sketch.dimension", json!({"entities":["l1"],"value":"20 mm"})).unwrap();
h.settle();
let original = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
let params = h.app.session.doc.params.len();
h.step(&json!({"start":"sketch.dimension"})).unwrap();
h.step(&json!({"click":{"world":[10,0,0]}})).unwrap();
h.step(&json!({"move":{"world":[10,6,0]}})).unwrap();
h.settle();
assert_eq!(crate::dim_view::drawn().len(), 1, "the preview is not a selectable dimension");
h.step(&json!({"click":{"world":[10,6,0]}})).unwrap();
assert!(!crate::dim_view::editing(), "a driven dimension has no value to edit");
assert_eq!(h.app.session.undo.len(), undo + 1);
assert_eq!(h.app.session.doc.params.len(), params, "a driven dimension adds no parameter");
let state = h.app.session.world_state().unwrap();
let solved = state.sketch(h.app.session.active_sketch.unwrap()).unwrap();
assert!(solved.report.ok());
let dims: Vec<_> = solved.sketch.constraints.iter().filter(|c| c.kind.is_dimension()).collect();
assert_eq!(dims.len(), 2);
assert_eq!(dims.iter().filter(|c| c.driven && c.param.is_none()).count(), 1, "{dims:?}");
h.app.run("edit.undo", json!({})).unwrap();
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 = crate::open_meshing::session_world(&h.app.session);
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!(crate::open_meshing::session_world(&h.app.session).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.
fn sketch_with(setup: &[(&str, serde_json::Value)], centre: [f64; 2]) -> Harness {
crate::dim_view::cancel();
let mut h = Harness::new();
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
for (cmd, params) in setup {
h.app.run(cmd, params.clone()).unwrap();
}
h.call("ui.view", json!({"view":"top"}));
h.app.cam.distance = 80.0;
h.app.cam.target = solidcore_record::Vec3::new(centre[0], centre[1], 0.0);
h.settle();
h.step(&json!({"start":"sketch.dimension"})).unwrap();
h
}
/// Type as a keyboard does: each character is a key press with its text in the same frame,
/// so a letter that is also a tool shortcut reaches the shortcuts too.
fn keys(h: &mut Harness, text: &str) {
for ch in text.chars() {
let key = egui::Key::from_name(&ch.to_ascii_uppercase().to_string());
let modifiers = egui::Modifiers::default();
if let Some(key) = key {
h.app.synthetic.push(egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers });
}
h.app.synthetic.push(egui::Event::Text(ch.to_string()));
if let Some(key) = key {
h.app.synthetic.push(egui::Event::Key { key, physical_key: None, pressed: false, repeat: false, modifiers });
}
h.frames(1);
}
h.settle();
}
fn solved(h: &Harness) -> solidcraft_engine::sketch::Sketch {
let state = h.app.session.world_state().unwrap();
state.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch.clone()
}
/// The dimensions added since `before` (constraints with a parameter or a value).
fn added(h: &Harness, before: usize) -> Vec<solidcraft_engine::sketch::Constraint> {
solved(h).constraints.into_iter().filter(|c| c.kind.is_dimension()).skip(before).collect()
}
fn dimension_count(h: &Harness) -> usize {
solved(h).constraints.iter().filter(|c| c.kind.is_dimension()).count()
}
/// The value took the keyboard straight after the pick that determined the dimension.
fn assert_live(h: &Harness) {
assert!(crate::dim_view::editing(), "the pick opens the value at once");
assert_eq!(crate::dim_view::live(), Some(false));
assert_eq!(h.ctx.memory(|m| m.focused()), Some(egui::Id::unique("sc_dim_edit")));
}
#[test]
fn type_first_line_circle_arc_distance_and_angle_commit_one_undo_step_each() {
use solidcraft_engine::sketch::ConstraintKind as K;
let line = [("sketch.line", json!({"points":[[0,0],[20,0]],"infer":false}))];
let circle = [("sketch.circle.center", json!({"center":[10,0],"radius":5}))];
let arc = [("sketch.arc.center_point", json!({"center":[10,0],"start":[18,0],"sweep":90}))];
// Two lines joined at a fixed corner: the angle turns one about it.
let corner = [
("sketch.line", json!({"points":[[0,20],[0,0],[20,0]],"infer":false})),
("sketch.constraint.fix", json!({"entity":"l1.end"})),
("sketch.constraint.horizontal_vertical", json!({"line":"l2","mode":"horizontal"})),
];
let half = std::f64::consts::FRAC_1_SQRT_2 * 8.0;
type Check = fn(&K) -> bool;
let cases: [(&[(&str, serde_json::Value)], [f64; 2], Vec<[f64; 2]>, &str, Check); 5] = [
(&line, [10., 0.], vec![[10., 0.]], "25", |k| matches!(k, K::Length { value, .. } if (value - 25.).abs() < 1e-6)),
(&circle, [10., 0.], vec![[15., 0.]], "12", |k| matches!(k, K::Diameter { value, .. } if (value - 12.).abs() < 1e-6)),
(&arc, [10., 0.], vec![[10. + half, half]], "6", |k| matches!(k, K::Radius { value, .. } if (value - 6.).abs() < 1e-6)),
(&line, [10., 0.], vec![[0., 0.], [20., 0.]], "25", |k| k.value().is_some_and(|v| (v - 25.).abs() < 1e-6)),
(&corner, [8., 8.], vec![[12., 0.], [0., 12.]], "60", |k| k.is_angle() && k.value().is_some_and(|v| (v.to_degrees() - 60.).abs() < 1e-6)),
];
for (setup, centre, picks, typed, check) in cases {
let mut h = sketch_with(setup, centre);
let original = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
let dims = dimension_count(&h);
for p in &picks {
h.step(&json!({"click":{"world":[p[0],p[1],0]}})).unwrap();
}
assert_live(&h);
assert_eq!(h.app.session.doc.to_json(), original, "nothing changes until Enter");
// The text follows the pointer while typing: Enter places it there.
// (For the angle, inside the wedge both before and after it changes.)
let cursor = if check(&solidcraft_engine::sketch::ConstraintKind::Angle { a: 0, b: 1, value: 60f64.to_radians(), flip: false }) {
[10.4, 6.0]
} else {
[centre[0] + 3.0, centre[1] + 9.0]
};
h.step(&json!({"move":{"world":[cursor[0],cursor[1],0]}})).unwrap();
keys(&mut h, typed);
h.step(&json!({"key":"Enter"})).unwrap();
assert!(!crate::dim_view::editing(), "{picks:?}");
assert_eq!(h.app.session.undo.len(), undo + 1, "{picks:?}");
let new = added(&h, dims);
assert_eq!(new.len(), 1, "{picks:?}: {new:?}");
assert!(check(&new[0].kind), "{picks:?}: {:?}", new[0].kind);
h.settle();
let shown = crate::dim_view::text_at(&new[0].id).expect("the new dimension is drawn");
let [x, y] = h.at(&json!({"world":[cursor[0],cursor[1],0]})).unwrap();
assert!(shown.distance(egui::pos2(x as f32, y as f32)) < 40.0, "{picks:?}: text at {shown:?}, cursor at {x},{y}");
assert_eq!(h.app.tool.as_ref().map(|t| (t.cmd, t.picks.len())), Some(("sketch.dimension", 0)), "ready for the next dimension");
h.app.run("edit.undo", json!({})).unwrap();
assert_eq!(h.app.session.doc.to_json(), original);
}
crate::dim_view::cancel();
}
#[test]
fn type_first_without_moving_uses_the_default_place_and_expressions_work() {
let mut h = sketch_with(&[("sketch.line", json!({"points":[[0,0],[20,0]],"infer":false}))], [10., 0.]);
h.app.run("parameters.add", json!({"name":"width","expression":"15 mm"})).unwrap();
h.settle();
let dims = dimension_count(&h);
h.step(&json!({"click":{"world":[10,0,0]}})).unwrap();
assert_live(&h);
keys(&mut h, "2*width");
h.step(&json!({"key":"Enter"})).unwrap();
let new = added(&h, dims);
assert_eq!(new.len(), 1);
assert!(new[0].text.is_none(), "an unmoved pointer leaves the text in its default place: {:?}", new[0].text);
assert!((new[0].kind.value().unwrap() - 30.).abs() < 1e-6);
assert_eq!(h.app.session.doc.param(new[0].param.as_deref().unwrap()).unwrap().expr, "2*width");
crate::dim_view::cancel();
}
/// Letters typed into the value are not tool shortcuts (L Line, D Dimension, C Circle…).
#[test]
fn type_first_parameter_names_are_not_taken_by_shortcuts() {
for name in ["length", "depth", "clearance", "rim"] {
let mut h = sketch_with(&[("sketch.line", json!({"points":[[0,0],[20,0]],"infer":false}))], [10., 0.]);
h.app.run("parameters.add", json!({"name":name,"expression":"22 mm"})).unwrap();
h.settle();
let dims = dimension_count(&h);
h.step(&json!({"click":{"world":[10,0,0]}})).unwrap();
assert_live(&h);
keys(&mut h, name);
assert_eq!(h.app.tool.as_ref().map(|t| t.cmd), Some("sketch.dimension"), "{name}: a letter started another tool");
assert!(h.app.dialog.is_none(), "{name}");
h.step(&json!({"key":"Enter"})).unwrap();
let new = added(&h, dims);
assert_eq!(new.len(), 1, "{name}");
assert!((new[0].kind.value().unwrap() - 22.).abs() < 1e-6, "{name}");
assert_eq!(h.app.session.doc.param(new[0].param.as_deref().unwrap()).unwrap().expr, name);
crate::dim_view::cancel();
}
}
#[test]
fn type_first_escape_cancels_with_no_change() {
let mut h = sketch_with(&[("sketch.line", json!({"points":[[0,0],[20,0]],"infer":false}))], [10., 0.]);
let original = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
for typed in ["", "25"] {
h.step(&json!({"click":{"world":[10,0,0]}})).unwrap();
assert_live(&h);
keys(&mut h, typed);
h.step(&json!({"key":"Escape"})).unwrap();
assert!(!crate::dim_view::editing());
assert_eq!(h.app.session.doc.to_json(), original);
assert_eq!(h.app.session.undo.len(), undo);
assert_eq!(h.app.tool.as_ref().map(|t| (t.cmd, t.picks.len())), Some(("sketch.dimension", 0)), "Esc drops the picks too");
}
crate::dim_view::cancel();
}
/// The open sketch's lines as the next frame paints them (the viewport's sketch scene, rebuilt
/// only when its key changes, before the frame's dimensions are drawn; the harness has no GPU,
/// so the test does it): their bounds, [min x, min y, max x, max y].
fn drawn_extent(h: &mut Harness) -> [f32; 4] {
let rect = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0));
let proj = crate::viewport::projection(&h.app, rect);
crate::viewport::refresh_sketch_scene(&mut h.app, &proj);
let slot = h.app.viewport.sketch_slot.lock().unwrap();
let scene = slot.as_ref().expect("a sketch scene");
let ends = scene.overlay.as_chunks::<32>().0.iter().flat_map(|l| [&l[0..12], &l[12..24]]);
ends.map(|b| [0, 4].map(|i| b.get(i..i + 4).and_then(|x| x.try_into().ok()).map(f32::from_le_bytes)))
.filter_map(|[x, y]| Some([x?, y?]))
.fold([f32::MAX, f32::MAX, f32::MIN, f32::MIN], |m, [x, y]| [m[0].min(x), m[1].min(y), m[2].max(x), m[3].max(y)])
}
fn near(a: [f32; 4], b: [f32; 4]) -> bool {
a.iter().zip(b).all(|(a, b)| (a - b).abs() < 0.6)
}
fn bounds(sk: &solidcraft_engine::sketch::Sketch) -> [f32; 4] {
let (lo, hi) = sk.bounds().unwrap_or_default();
[lo.x, lo.y, hi.x, hi.y].map(|v| v as f32)
}
/// While a value is typed the sketch is drawn as the value leaves it, not only the dimension
/// (#11584), whatever the shape; Esc draws it as it is again.
#[test]
fn typing_a_value_draws_the_sketch_at_that_value_and_escape_restores_it() {
let fix = |entity: &str| ("sketch.constraint.fix", json!({"entity": entity}));
let rectangle = vec![("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,20]}))];
let circle = vec![("sketch.circle.center", json!({"center":[10,0],"radius":5})), fix("c1.center")];
let slot = vec![("sketch.slot.center_to_center", json!({"p0":[-20,0],"p1":[20,0],"width":20}))];
let arc = vec![("sketch.arc.center_point", json!({"center":[10,0],"start":[18,0],"sweep":90})), fix("a1.center")];
let spline = vec![
("sketch.spline.fit_point", json!({"points": [[-30, 0], [-10, 18], [10, 6], [30, 20]]})),
("sketch.line", json!({"points":[[30,20],[30,-10]],"infer":true})),
];
let mixed = vec![
("sketch.circle.center", json!({"center":[0,0],"radius":10})),
("sketch.circle.center", json!({"center":[40,0],"radius":10})),
("sketch.line", json!({"points":[[0,10],[40,10]],"infer":false})),
("sketch.constraint.tangent", json!({"a":"l1","b":"c1"})),
("sketch.constraint.tangent", json!({"a":"l1","b":"c2"})),
("sketch.constraint.equal", json!({"a":"c1","b":"c2"})),
fix("c1.center"),
fix("c2.center"),
];
let half = std::f64::consts::FRAC_1_SQRT_2 * 8.0;
let cases: [(&str, &[(&str, serde_json::Value)], [f64; 2], Vec<[f64; 2]>, &str); 6] = [
("rectangle side", &rectangle, [20., 10.], vec![[20., 0.]], "60"),
("circle diameter", &circle, [10., 0.], vec![[15., 0.]], "20"),
("slot side", &slot, [0., 0.], vec![[0., 10.]], "60"),
("arc radius", &arc, [10., 0.], vec![[10. + half, half]], "12"),
("spline end", &spline, [0., 5.], vec![[30., 5.]], "50"),
("tangent equal circles", &mixed, [20., 0.], vec![[-10., 0.]], "30"),
];
for (name, setup, centre, picks, typed) in cases {
let mut h = sketch_with(setup, centre);
// Far enough out that the grown shapes stay in view (the drawn lines stop at its edge).
h.app.cam.distance = 200.0;
h.settle();
let real = bounds(&solved(&h));
let before = drawn_extent(&mut h);
assert!(near(before, real), "{name}: drawn {before:?}, sketch {real:?}");
for p in &picks {
h.step(&json!({"click":{"world":[p[0],p[1],0]}})).unwrap();
}
assert_live(&h);
keys(&mut h, typed);
// What the frame after the last key paints, against the typed value's solve a frame later.
let shown = drawn_extent(&mut h);
h.frames(1);
let (_, _, preview) = crate::dim_view::draft_preview().expect("the draft is open");
let target = bounds(&preview);
assert!(!near(target, real), "{name}: the typed value changes the sketch: {target:?}");
assert!(near(shown, target), "{name}: the sketch follows the typed value: drawn {shown:?}, solved {target:?}");
assert!(near(bounds(&solved(&h)), real), "{name}: nothing changes until Enter");
// A value that does not solve (here half typed) keeps the last one that did.
keys(&mut h, "*");
assert_eq!(crate::dim_view::draft_preview().map(|(expr, _, _)| expr), Some(format!("{typed}*")));
let kept = drawn_extent(&mut h);
assert!(near(kept, target), "{name}: an unsolved value keeps the last drawn: {kept:?}");
h.step(&json!({"key":"Escape"})).unwrap();
assert!(!crate::dim_view::editing());
let after = drawn_extent(&mut h);
assert!(near(after, real), "{name}: Esc draws the sketch as it is: {after:?}");
crate::dim_view::cancel();
}
}
/// Each solve of a typed value redraws the sketch, also two between frames (a moved text and a
/// typed value in one frame), and a solve back to an earlier value: the scene is keyed on the
/// solve, not on where its result happens to be in memory.
#[test]
fn every_solve_of_a_typed_value_redraws_the_sketch() {
let mut h = sketch_with(&[("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,20]}))], [20., 10.]);
h.app.cam.distance = 300.0;
h.settle();
h.step(&json!({"click":{"world":[20,0,0]}})).unwrap();
assert_live(&h);
keys(&mut h, "60");
let sixty = drawn_extent(&mut h);
let mut solves = std::collections::BTreeSet::new();
for _ in 0..4 {
crate::dim_view::resolve(&h.app, "70");
crate::dim_view::resolve(&h.app, "80");
assert!(solves.insert(crate::dim_view::preview_solve(&h.app).expect("a preview")), "a new solve has a new number");
let (_, _, preview) = crate::dim_view::draft_preview().expect("the draft is open");
let drawn = drawn_extent(&mut h);
assert!(!near(drawn, sixty) && near(drawn, bounds(&preview)), "drawn {drawn:?}, solved {:?}", bounds(&preview));
crate::dim_view::resolve(&h.app, "60");
assert!(near(drawn_extent(&mut h), sixty));
}
crate::dim_view::cancel();
}
/// While a value is typed the sketch is drawn at it, so a profile under the pointer is not lit
/// where the design has it (over the resized one); it is again once the value is let go.
#[test]
fn a_typed_value_does_not_light_the_design_s_profile_under_the_pointer() {
let mut h = sketch_with(&[("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,20]}))], [20., 10.]);
h.step(&json!({"click":{"world":[20,0,0]}})).unwrap();
assert_live(&h);
keys(&mut h, "60");
let sketch = h.app.session.active_sketch.unwrap();
h.app.viewport.hover = Some(crate::viewport::Hit::Profile { sketch, index: 0 });
let key = crate::viewport::highlight_key(&h.app);
assert!(crate::viewport::build_highlight(&h.app).merged().trans.is_empty(), "no profile lit while the value is typed");
h.step(&json!({"key":"Escape"})).unwrap();
h.app.viewport.hover = Some(crate::viewport::Hit::Profile { sketch, index: 0 });
assert_ne!(crate::viewport::highlight_key(&h.app), key, "letting the value go lights it again");
assert!(!crate::viewport::build_highlight(&h.app).merged().trans.is_empty(), "lit as before");
crate::dim_view::cancel();
}
/// Until a value is typed the sketch is drawn as the design has it, so a picked dimension's
/// value box alone does not put the view in the typed preview: the profile under the pointer
/// stays lit. The first key does.
#[test]
fn a_dimension_only_picked_keeps_the_design_view_until_a_value_is_typed() {
let mut h = sketch_with(&[("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,20]}))], [20., 10.]);
h.step(&json!({"click":{"world":[20,0,0]}})).unwrap();
assert_live(&h);
assert!(crate::dim_view::preview_solve(&h.app).is_none(), "nothing typed yet: no preview");
let sketch = h.app.session.active_sketch.unwrap();
h.app.viewport.hover = Some(crate::viewport::Hit::Profile { sketch, index: 0 });
assert!(!crate::viewport::build_highlight(&h.app).merged().trans.is_empty(), "the profile is lit while only picked");
keys(&mut h, "6");
assert!(crate::dim_view::preview_solve(&h.app).is_some(), "a key starts the preview");
crate::dim_view::cancel();
}
/// A selected profile is not lit where the design has it while a value is typed either.
#[test]
fn a_typed_value_does_not_light_a_selected_design_profile() {
let mut h = sketch_with(&[("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,20]}))], [20., 10.]);
h.step(&json!({"click":{"world":[20,0,0]}})).unwrap();
assert_live(&h);
keys(&mut h, "60");
let sketch = h.app.session.active_sketch.unwrap();
h.app.session.selection = vec![solidcraft_engine::Sel::Profile { sketch, index: 0 }];
assert!(crate::dim_view::preview_solve(&h.app).is_some(), "the value is still typed");
assert!(crate::viewport::build_highlight(&h.app).merged().trans.is_empty(), "no profile lit while the value is typed");
crate::dim_view::cancel();
assert!(!crate::viewport::build_highlight(&h.app).merged().trans.is_empty(), "lit once the value is let go");
}
/// While a value is typed the sketch's curves are sampled before its profiles: a sketch whose
/// profiles would use up the sampling budget still has its curves drawn (its fills go first).
#[test]
fn a_typed_value_draws_the_curves_before_the_profiles_use_up_the_budget() {
let mut h = sketch_with(
&[("sketch.circle.center", json!({"center":[10,0],"radius":5})), ("sketch.constraint.fix", json!({"entity": "c1.center"}))],
[10., 0.],
);
h.step(&json!({"click":{"world":[15,0,0]}})).unwrap();
assert_live(&h);
keys(&mut h, "20");
let (_, _, preview) = crate::dim_view::draft_preview().expect("the draft is open");
let rect = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0));
let proj = crate::viewport::projection(&h.app, rect);
let plane = h.app.session.world_state().unwrap().sketch(h.app.session.active_sketch.unwrap()).unwrap().plane;
let mut all = solidcraft_engine::render::SamplingBudget::new(131_072, 1_048_576);
let need = crate::sketch_display::curve_with_budget(&preview, 0, &plane, &proj, h.app.viewport.pixels_per_point(), &mut all).vertex_count;
assert!(need > 4, "the circle takes some vertices: {need}");
crate::sketch_display::UNCACHED_VERTICES.with(|v| v.set(Some(need)));
let drawn = drawn_extent(&mut h);
crate::sketch_display::UNCACHED_VERTICES.with(|v| v.set(None));
assert!(near(drawn, bounds(&preview)), "the circle is drawn at the typed value: drawn {drawn:?}, solved {:?}", bounds(&preview));
crate::dim_view::cancel();
}
/// Is a sketch point drawn at `world` this frame (its filled square)?
fn point_drawn(h: &mut Harness, world: [f64; 2]) -> bool {
let [x, y] = h.at(&json!({"world":[world[0], world[1], 0]})).unwrap();
let at = egui::pos2(x as f32, y as f32);
h.shapes.iter().any(|s| matches!(&s.shape, egui::Shape::Rect(r) if r.rect.width() == 5.0 && r.rect.center().distance(at) < 0.5))
}
/// Is a sketch curve's hover highlight painted this frame?
fn hover_painted(h: &Harness) -> bool {
let col = egui::epaint::ColorMode::Solid(crate::theme::Tokens::get().hover_profile_edge);
h.shapes.iter().any(|s| matches!(&s.shape, egui::Shape::Path(p) if p.stroke.width == 3.0 && p.stroke.color == col))
}
/// While a value is typed, the sketch's points and constraint glyphs are drawn where the value
/// puts them as well as its curves, the next frame already (the value is solved when typed), and
/// no hover highlight traces a curve of the design; Esc puts everything back.
#[test]
fn typing_a_value_draws_points_and_glyphs_there_and_no_hover_of_the_design() {
let rectangle = [("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,20]}))];
let mut h = sketch_with(&rectangle, [30., 15.]);
h.app.cam.distance = 200.0;
h.settle();
let glyphs = crate::sketch_tools::glyph_positions();
assert!(!glyphs.is_empty());
assert!(point_drawn(&mut h, [40., 20.]));
h.step(&json!({"click":{"world":[20,0,0]}})).unwrap();
assert_live(&h);
keys(&mut h, "60");
// The frame after the last key, as the app draws it.
h.frames(1);
assert!(point_drawn(&mut h, [60., 30.]), "the corner is drawn where 60 puts it");
assert!(!point_drawn(&mut h, [40., 20.]), "no point where the design has it");
// The right side's glyph moves with its middle, from (40, 10) to (60, 15).
let [x0, y0] = h.at(&json!({"world":[40,10,0]})).unwrap();
let [x1, y1] = h.at(&json!({"world":[60,15,0]})).unwrap();
let shift = egui::vec2((x1 - x0) as f32, (y1 - y0) as f32);
let typed = crate::sketch_tools::glyph_positions();
let moved = |id: &String, at: egui::Pos2| glyphs.iter().any(|(was_id, was)| was_id == id && (at - *was - shift).length() < 1.5);
assert!(typed.iter().any(|(id, at)| moved(id, *at)), "a glyph follows the right side: {glyphs:?} -> {typed:?}, shift {shift:?}");
// Over where the design's right side is, nothing is drawn, so nothing lights up.
h.step(&json!({"move":{"world":[40,10,0]}})).unwrap();
h.frames(1);
assert!(!hover_painted(&h), "no hover highlight of the design's curve");
// One more key and one frame: the value is solved in the frame it is typed, so the next
// frame's sketch scene, built before the dimensions are drawn, is already at that value.
h.frame_with(vec![egui::Event::Text("5".into())]);
let (text, solved) = crate::dim_view::solved_for().expect("the draft is open");
assert_eq!((text.as_str(), solved.as_str()), ("605", "605"));
h.step(&json!({"key":"Escape"})).unwrap();
h.frames(1);
assert!(point_drawn(&mut h, [40., 20.]));
assert_eq!(crate::sketch_tools::glyph_positions(), glyphs);
crate::dim_view::cancel();
}
/// Place first still works: a click before typing puts the text there and keeps the value
/// (selected, so typing replaces it); Tab leaves the picks for a click to place, as before.
#[test]
fn type_first_keeps_the_place_first_flow() {
let mut h = sketch_with(&[("sketch.line", json!({"points":[[0,0],[20,0]],"infer":false}))], [10., 0.]);
let dims = dimension_count(&h);
h.step(&json!({"click":{"world":[10,0,0]}})).unwrap();
assert_live(&h);
h.step(&json!({"click":{"world":[10,-7,0]}})).unwrap();
assert!(crate::dim_view::editing());
assert_eq!(crate::dim_view::live(), None, "the text is pinned");
assert_eq!(h.ctx.memory(|m| m.focused()), Some(egui::Id::unique("sc_dim_edit")));
h.step(&json!({"move":{"world":[0,12,0]}})).unwrap();
keys(&mut h, "18");
h.step(&json!({"key":"Enter"})).unwrap();
let new = added(&h, dims);
assert_eq!(new.len(), 1);
assert!((new[0].kind.value().unwrap() - 18.).abs() < 1e-6);
h.settle();
let shown = crate::dim_view::text_at(&new[0].id).unwrap();
let [x, y] = h.at(&json!({"world":[10,-7,0]})).unwrap();
assert!(shown.distance(egui::pos2(x as f32, y as f32)) < 40.0, "the pinned place wins over the pointer: {shown:?} vs {x},{y}");
// Tab before typing hands the picks back to the place-first flow.
h.app.run("edit.undo", json!({})).unwrap();
h.settle();
h.step(&json!({"click":{"world":[10,0,0]}})).unwrap();
assert_live(&h);
h.frames(4);
h.step(&json!({"key":"Tab"})).unwrap();
h.settle();
assert!(!crate::dim_view::editing());
assert_eq!(h.app.tool.as_ref().map(|t| t.picks.len()), Some(1));
h.step(&json!({"click":{"world":[10,6,0]}})).unwrap();
assert!(crate::dim_view::editing());
assert_eq!(h.ctx.memory(|m| m.focused()), Some(egui::Id::unique("sc_dim_edit")));
keys(&mut h, "21");
h.step(&json!({"key":"Enter"})).unwrap();
let new = added(&h, dims);
assert!((new[0].kind.value().unwrap() - 21.).abs() < 1e-6);
crate::dim_view::cancel();
}
/// Put the value field's caret at `at` with nothing selected, as the field itself does when it
/// misses the keyboard for a frame (a WebView2 showed the caret before the value, #11204).
fn caret_without_the_person(h: &Harness, at: usize) {
let id = egui::Id::unique("sc_dim_edit");
let mut state = egui::TextEdit::load_state(&h.ctx, id).unwrap_or_default();
state.cursor.set_char_range(Some(egui::text::CCursorRange::one(egui::text::CCursor::new(at))));
state.store(&h.ctx, id);
}
/// A primary click at sketch point `at`, the button held down for `frames` frames.
fn held_click(h: &mut Harness, at: [f64; 2], frames: usize) {
h.step(&json!({"move":{"world":[at[0],at[1],0]}})).unwrap();
let [x, y] = h.at(&json!({"world":[at[0],at[1],0]})).unwrap();
let pos = egui::pos2(x as f32, y as f32);
let (button, modifiers) = (egui::PointerButton::Primary, egui::Modifiers::NONE);
h.app.synthetic.push(egui::Event::PointerButton { pos, button, pressed: true, modifiers });
h.frames(frames);
h.app.synthetic.push(egui::Event::PointerButton { pos, button, pressed: false, modifiers });
h.settle();
}
/// The value field's caret and selection end (characters).
fn caret(h: &Harness) -> Option<(usize, usize)> {
egui::TextEdit::load_state(&h.ctx, egui::Id::unique("sc_dim_edit"))
.and_then(|s| s.cursor.char_range())
.map(|r| (r.primary.index.0, r.secondary.index.0))
}
/// Until the person takes the proposed value over, the first digit they type replaces all of
/// it (#11204): however long the click that placed it was held, frames later, and whatever moved
/// the caret without them. Typed without Ctrl+A, as a person does.
#[test]
fn typed_digits_replace_the_proposed_value_whatever_moved_the_caret() {
for held in [1usize, 4, 12] {
let mut h = sketch_with(&[("sketch.line", json!({"points":[[0,0],[20,0]],"infer":false}))], [10., 0.]);
let dims = dimension_count(&h);
h.step(&json!({"click":{"world":[10,0,0]}})).unwrap();
assert_live(&h);
// A click held `held` frames: what a person's 60 to 150 ms click is at 60 Hz and beyond.
held_click(&mut h, [10., -7.], held);
assert_eq!(crate::dim_view::live(), None, "held {held}: the text is pinned");
h.frames(12);
caret_without_the_person(&h, 0);
h.frames(2);
assert_eq!(h.ctx.memory(|m| m.focused()), Some(egui::Id::unique("sc_dim_edit")), "held {held}");
keys(&mut h, "400");
assert_eq!(crate::dim_view::draft_preview().map(|d| d.0).as_deref(), Some("400"), "held {held}");
h.step(&json!({"key":"Enter"})).unwrap();
let new = added(&h, dims);
assert_eq!(new.len(), 1, "held {held}");
assert!((new[0].kind.value().unwrap() - 400.).abs() < 1e-6, "held {held}: {:?}", new[0].kind);
crate::dim_view::cancel();
}
}
/// A caret the person put somewhere stays there: Home then 1 writes in front of the value, and a
/// click into the field types where it landed (#11204).
#[test]
fn a_caret_the_person_moved_stays_where_they_put_it() {
let mut h = sketch_with(&[("sketch.line", json!({"points":[[0,0],[20,0]],"infer":false}))], [10., 0.]);
let dims = dimension_count(&h);
h.step(&json!({"click":{"world":[10,0,0]}})).unwrap();
assert_live(&h);
h.step(&json!({"click":{"world":[10,-7,0]}})).unwrap();
h.frames(4);
h.step(&json!({"key":"Home"})).unwrap();
h.frames(4);
assert_eq!(caret(&h), Some((0, 0)), "Home put the caret before the value");
keys(&mut h, "1");
h.frames(4);
assert_eq!(caret(&h), Some((1, 1)), "the caret stays after what was typed");
assert_eq!(crate::dim_view::draft_preview().map(|d| d.0).as_deref(), Some("120 mm"));
h.step(&json!({"key":"Enter"})).unwrap();
let new = added(&h, dims);
assert_eq!(new.len(), 1);
assert!((new[0].kind.value().unwrap() - 120.).abs() < 1e-6, "{:?}", new[0].kind);
crate::dim_view::cancel();
// A click into the field puts the caret where it landed: typing goes there.
let mut h = sketch_with(&[("sketch.line", json!({"points":[[0,0],[20,0]],"infer":false}))], [10., 0.]);
h.step(&json!({"click":{"world":[10,0,0]}})).unwrap();
h.step(&json!({"click":{"world":[10,-7,0]}})).unwrap();
h.frames(4);
let [x, y] = h.widget("20 mm").expect("the value field");
h.step(&json!({"click":[x, y]})).unwrap();
h.frames(4);
assert!(crate::dim_view::editing(), "a click into the field keeps the value open");
let placed = caret(&h);
assert!(placed.is_some_and(|(a, b)| a == b), "the click placed a caret: {placed:?}");
keys(&mut h, "4");
let expr = crate::dim_view::draft_preview().map(|d| d.0).unwrap_or_default();
assert!(expr.len() == "20 mm4".len() && expr.contains('4') && expr != "4", "typing went in at the click, not over the value: {expr:?}");
crate::dim_view::cancel();
}
/// Type-first, the text follows the pointer: moving it from across the picks (the distance
/// between them) to above or beside them switches to the horizontal or vertical distance and
/// back. Until something is typed the value follows the dimension, so the preview measures the
/// picked points where they are (it neither moves nor scales them) and Enter keeps them there.
#[test]
fn type_first_switching_between_aligned_horizontal_and_vertical_keeps_the_picked_points() {
use solidcraft_engine::sketch::ConstraintKind as K;
let end = [12., 16.];
let mid = [6., 8.];
// Across from the picks, above them, beside them.
let (across, above, beside) = ([-5., 12.], [6., 25.], [-10., 1.]);
type Kind = fn(&K) -> bool;
let aligned: Kind = |k| matches!(k, K::Distance { .. } | K::Length { .. });
let horizontal: Kind = |k| matches!(k, K::DistanceX { .. });
let vertical: Kind = |k| matches!(k, K::DistanceY { .. });
let picks: [Vec<[f64; 2]>; 2] = [vec![[0., 0.], end], vec![mid]];
for picks in picks {
for (commit_at, commit_kind, commit_value) in [(above, horizontal, 12.), (beside, vertical, 16.), (across, aligned, 20.)] {
let mut h = sketch_with(&[("sketch.line", json!({"points":[[0,0],end],"infer":false}))], mid);
let undo = h.app.session.undo.len();
for p in &picks {
h.step(&json!({"click":{"world":[p[0],p[1],0]}})).unwrap();
}
assert_live(&h);
for (at, kind, value) in [
(across, aligned, 20.),
(above, horizontal, 12.),
(across, aligned, 20.),
(beside, vertical, 16.),
(commit_at, commit_kind, commit_value),
] {
h.step(&json!({"move":{"world":[at[0],at[1],0]}})).unwrap();
h.settle();
let (expr, c, sk) = crate::dim_view::draft_preview().expect("the draft is open");
let ctx = format!("{picks:?} at {at:?}: {expr} {:?}", c.kind);
assert!(kind(&c.kind), "{ctx}");
assert!((c.kind.value().unwrap() - value).abs() < 1e-6, "{ctx}");
assert_eq!(expr, format!("{value} mm"), "{ctx}");
let a = sk.point(sk.resolve_point("l1.start").unwrap()).unwrap();
let b = sk.point(sk.resolve_point("l1.end").unwrap()).unwrap();
assert!(
a.dist(solidcore_record::Vec2::new(0., 0.)) < 1e-6 && b.dist(solidcore_record::Vec2::new(end[0], end[1])) < 1e-6,
"{ctx}: the preview moved the points to {a:?} {b:?}"
);
}
h.step(&json!({"key":"Enter"})).unwrap();
assert!(!crate::dim_view::editing());
assert_eq!(h.app.session.undo.len(), undo + 1);
let sk = solved(&h);
let a = sk.point(sk.resolve_point("l1.start").unwrap()).unwrap();
let b = sk.point(sk.resolve_point("l1.end").unwrap()).unwrap();
assert!(
a.dist(solidcore_record::Vec2::new(0., 0.)) < 1e-6 && b.dist(solidcore_record::Vec2::new(end[0], end[1])) < 1e-6,
"{picks:?} at {commit_at:?}: {a:?} {b:?}"
);
let new = added(&h, 0);
assert_eq!(new.len(), 1);
assert!(commit_kind(&new[0].kind), "{picks:?} at {commit_at:?}: {:?}", new[0].kind);
assert!((new[0].kind.value().unwrap() - commit_value).abs() < 1e-6, "{:?}", new[0].kind);
// The committed dimension's text is where the pointer left it, and its extension lines
// start at the picked points.
h.settle();
let shown = crate::dim_view::text_at(&new[0].id).expect("the new dimension is drawn");
let [x, y] = h.at(&json!({"world":[commit_at[0],commit_at[1],0]})).unwrap();
assert!(shown.distance(egui::pos2(x as f32, y as f32)) < 40.0, "{picks:?}: text at {shown:?}, cursor at {x},{y}");
crate::dim_view::cancel();
}
}
}
#[test]
fn midpoint_then_edge_creates_a_distance_in_one_undo_step() {
use solidcraft_engine::sketch::ConstraintKind;
let mut h = line([20., 0.]);
h.app.run("sketch.line", json!({"points":[[-10,-10],[-10,20]]})).unwrap();
h.app.run("sketch.constraint.fix", json!({"entity":"l2"})).unwrap();
h.settle();
let baseline = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
for accept in [false, true] {
place(&mut h, &[[10., 0.], [-10., -5.]], [0., -8.]);
let (_, c, sk) = crate::dim_view::draft_preview().unwrap();
let ConstraintKind::PointLineDistance { p, l, .. } = c.kind else { panic!("MID to edge must be a distance: {:?}", c.kind) };
assert_eq!(sk.curves[l].id, "l2");
assert!(sk.constraints.iter().any(|c| matches!(c.kind, ConstraintKind::Midpoint { p: q, l: 0 } if q == p)));
assert_eq!(h.app.session.doc.to_json(), baseline, "preview creates no persistent helper");
if !accept {
h.step(&json!({"key":"Escape"})).unwrap();
assert!(h.app.tool.as_ref().unwrap().point_picks.is_empty());
continue;
}
type_value(&mut h, "25 mm");
h.step(&json!({"key":"Enter"})).unwrap();
assert!(!crate::dim_view::editing());
assert_eq!(h.app.session.undo.len(), undo + 1);
let state = crate::open_meshing::session_world(&h.app.session);
let solved = state.sketch(h.app.session.active_sketch.unwrap()).unwrap();
assert!(solved.report.ok());
let sk = &solved.sketch;
let c = sk.constraints.iter().find(|c| c.param.is_some()).unwrap();
assert!(matches!(c.kind, ConstraintKind::PointLineDistance { .. }));
assert!((solidcraft_engine::sketch::measure_dimension(sk, &c.kind).unwrap() - 25.).abs() < 1e-6);
let accepted = h.app.session.doc.to_json();
h.app.run("edit.undo", json!({})).unwrap();
assert_eq!(h.app.session.doc.to_json(), baseline);
h.app.run("edit.redo", json!({})).unwrap();
assert_eq!(h.app.session.doc.to_json(), accepted);
}
crate::dim_view::cancel();
}
/// The short sketch edge overlaps a face's automatically projected boundary.
fn midpoint_face_sketch() -> Harness {
use solidcore_record::Vec3;
crate::dim_view::cancel();
let mut h = Harness::new();
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
h.app.run("sketch.rectangle.two_point", json!({"p0":[-10,-5],"p1":[10,15]})).unwrap();
h.app.finish_sketch();
h.app.run("solid.extrude", json!({"distance":10})).unwrap();
h.app.run("sketch.create", json!({"plane":{"face":[0,5,10]}})).unwrap();
let state = crate::open_meshing::session_world(&h.app.session);
let ss = state.sketch(h.app.session.active_sketch.unwrap()).unwrap();
let plane = ss.plane;
assert!(ss.sketch.curves.iter().any(|c| c.link.is_some()));
for ends in [[[-8., -5.], [2., -5.]], [[3., 2.], [7., 6.]]] {
let points: Vec<_> = ends
.into_iter()
.map(|p| {
let q = plane.to_local(Vec3::new(p[0], p[1], 10.));
[q.x, q.y]
})
.collect();
h.app.run("sketch.line", json!({"points":points,"infer":false})).unwrap();
}
h.call("ui.view", json!({"view":"top"}));
h.app.cam.distance = 90.;
h.app.cam.target = Vec3::new(0., 5., 10.);
h.settle();
h
}
#[test]
fn overlapping_sketch_midpoint_to_model_edge_dimensions_the_snapped_point() {
use solidcraft_engine::sketch::{ConstraintKind, Shape};
let mut h = midpoint_face_sketch();
let baseline = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
h.step(&json!({"start":"sketch.dimension"})).unwrap();
for p in [[-3., -5.], [10., 2.], [4., -10.]] {
h.step(&json!({"click":{"world":[p[0],p[1],10.]}})).unwrap();
}
let (_, c, sk) = crate::dim_view::draft_preview().expect("MID to projected model edge has a draft");
let ConstraintKind::PointLineDistance { p, l, .. } = c.kind else { panic!("expected point/edge distance: {:?}", c.kind) };
assert!(sk.curves[l].link.is_some());
let source = sk
.constraints
.iter()
.find_map(|c| match c.kind {
ConstraintKind::Midpoint { p: q, l } if p == q => Some(l),
_ => None,
})
.unwrap();
assert!(sk.curves[source].link.is_none(), "the short sketch edge won the overlapping pick");
let Shape::Line { a, b } = sk.shape(source).unwrap() else { panic!() };
assert!((a.dist(b) - 10.).abs() < 1e-6);
assert!((solidcraft_engine::sketch::measure_dimension(&sk, &c.kind).unwrap() - 13.).abs() < 1e-6);
assert_eq!(h.app.session.doc.to_json(), baseline);
type_value(&mut h, "12 mm");
h.step(&json!({"key":"Enter"})).unwrap();
assert!(!crate::dim_view::editing());
assert_eq!(h.app.session.undo.len(), undo + 1);
h.app.run("edit.undo", json!({})).unwrap();
assert_eq!(h.app.session.doc.to_json(), baseline);
crate::dim_view::cancel();
}
#[test]
fn midpoint_pairs_dimension_sketch_and_projected_model_edges() {
use solidcraft_engine::sketch::ConstraintKind;
for (first, second, projected) in [
([-3_f64, -5.], [5., 4.], [false, false]),
([-3., -5.], [10., 5.], [false, true]),
([10., 5.], [-3., -5.], [true, false]),
([0., -5.], [10., 5.], [true, true]),
] {
let mut h = midpoint_face_sketch();
let baseline = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
h.step(&json!({"start":"sketch.dimension"})).unwrap();
for p in [first, second] {
h.step(&json!({"click":{"world":[p[0],p[1],10.]}})).unwrap();
}
let at = [(first[0] + second[0]) * 0.5, (first[1] + second[1]) * 0.5];
assert_eq!(h.app.session.doc.to_json(), baseline);
h.step(&json!({"click":{"world":[at[0],at[1],10.]}})).unwrap();
if crate::dim_view::editing() {
h.step(&json!({"key":"Enter"})).unwrap();
}
let state = crate::open_meshing::session_world(&h.app.session);
let sk = &state.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch;
let c = sk.constraints.iter().rev().find(|c| c.kind.is_dimension()).expect("two MID picks commit a distance");
let ConstraintKind::Distance { p, q, .. } = c.kind else { panic!("expected midpoint distance for {projected:?}: {:?}", c.kind) };
for (point, expected) in [(p, projected[0]), (q, projected[1])] {
let l = sk
.constraints
.iter()
.find_map(|c| match c.kind {
ConstraintKind::Midpoint { p, l } if p == point => Some(l),
_ => None,
})
.expect("each pick remains a midpoint");
assert_eq!(sk.curves[l].link.is_some(), expected);
}
let measured = ((first[0] - second[0]).powi(2) + (first[1] - second[1]).powi(2)).sqrt();
assert!((solidcraft_engine::sketch::measure_dimension(sk, &c.kind).unwrap() - measured).abs() < 1e-6);
assert_eq!(h.app.session.undo.len(), undo + 1);
h.app.run("edit.undo", json!({})).unwrap();
assert_eq!(h.app.session.doc.to_json(), baseline);
crate::dim_view::cancel();
}
}
#[test]
fn midpoint_selection_keeps_line_circle_gap_dimensions_in_both_orders() {
use solidcraft_engine::sketch::ConstraintKind;
for reverse in [false, true] {
let mut h = line([20., 0.]);
h.app.run("sketch.circle.center", json!({"center":[10,10],"radius":3})).unwrap();
h.settle();
let baseline = h.app.session.doc.to_json();
let picks = if reverse { [[13., 10.], [10., 0.]] } else { [[10., 0.], [13., 10.]] };
place(&mut h, &picks, [25., 5.]);
let (_, c, sk) = crate::dim_view::draft_preview().expect("the edge-to-edge gap remains available");
assert!(matches!(c.kind, ConstraintKind::LineCircleDistance { value, .. } if (value - 7.).abs() < 1e-6));
assert!(!sk.constraints.iter().any(|c| matches!(c.kind, ConstraintKind::Midpoint { .. })));
h.step(&json!({"key":"Escape"})).unwrap();
assert_eq!(h.app.session.doc.to_json(), baseline);
crate::dim_view::cancel();
}
}
#[test]
fn midpoint_dimension_orientation_follows_the_pointer_before_placement() {
use solidcraft_engine::sketch::ConstraintKind;
for (first, second) in [([-3_f64, -5.], [5., 4.]), ([-3., -5.], [10., 5.]), ([10., 5.], [-3., -5.]), ([0., -5.], [10., 5.])] {
for (horizontal, held_y, reused) in
[(true, false, false), (false, false, false), (true, true, false), (false, true, false), (true, false, true), (false, false, true)]
{
if held_y && (first != [-3., -5.] || second != [10., 5.]) {
continue;
}
let mut h = midpoint_face_sketch();
if held_y {
let state = crate::open_meshing::session_world(&h.app.session);
let ss = state.sketch(h.app.session.active_sketch.unwrap()).unwrap();
let short = ss.sketch.curves.iter().find(|c| c.link.is_none()).unwrap().id.clone();
let bottom = ss
.sketch
.curves
.iter()
.enumerate()
.find_map(|(i, c)| {
c.link.as_ref()?;
let solidcraft_engine::sketch::Shape::Line { a, b } = ss.sketch.shape(i)? else {
return None;
};
((ss.plane.to_world(a).y + 5.).abs() < 1e-6 && (ss.plane.to_world(b).y + 5.).abs() < 1e-6).then(|| c.id.clone())
})
.unwrap();
for end in ["start", "end"] {
h.app.run("sketch.constraint.coincident", json!({"a":format!("{short}.{end}"),"b":bottom})).unwrap();
}
h.settle();
}
if reused {
let state = crate::open_meshing::session_world(&h.app.session);
let ss = state.sketch(h.app.session.active_sketch.unwrap()).unwrap();
let mid_ref = |point: [f64; 2]| {
ss.sketch
.curves
.iter()
.enumerate()
.find_map(|(i, c)| {
let solidcraft_engine::sketch::Shape::Line { a, b } = ss.sketch.shape(i)? else {
return None;
};
let at = ss.plane.to_world((a + b) * 0.5);
((at.x - point[0]).abs() < 1e-6 && (at.y - point[1]).abs() < 1e-6).then(|| format!("mid:{}", c.id))
})
.unwrap()
};
h.app.run("sketch.dimension", json!({"entities":[mid_ref(first),mid_ref(second)],"driven":true})).unwrap();
h.settle();
}
let baseline = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
h.step(&json!({"start":"sketch.dimension"})).unwrap();
for p in [first, second] {
h.step(&json!({"click":{"world":[p[0],p[1],10.]}})).unwrap();
}
assert!(!crate::dim_view::editing(), "choose the midpoint span's orientation before entering a value");
let above = [(first[0] + second[0]) * 0.5, first[1].max(second[1]) + 3.];
let beside = [first[0].max(second[0]) + 3., (first[1] + second[1]) * 0.5];
// Switch back and forth without accepting or changing the picked midpoints.
for is_x in [true, false, true, horizontal] {
let at = if is_x { above } else { beside };
h.step(&json!({"move":{"world":[at[0],at[1],10.]}})).unwrap();
h.settle();
let c = crate::dim_view::draft_preview()
.map(|(_, c, _)| c)
.or_else(|| crate::dim_view::placement_dimension_preview(&h.app))
.expect("a midpoint dimension previews before placement");
assert!(
if is_x { matches!(c.kind, ConstraintKind::DistanceX { .. }) } else { matches!(c.kind, ConstraintKind::DistanceY { .. }) },
"{first:?} to {second:?}, horizontal={is_x}: {:?}",
c.kind
);
let expected = if is_x { (first[0] - second[0]).abs() } else { (first[1] - second[1]).abs() };
assert!((c.kind.value().unwrap() - expected).abs() < 1e-6);
assert_eq!(h.app.session.doc.to_json(), baseline);
}
let at = if horizontal { above } else { beside };
h.step(&json!({"click":{"world":[at[0],at[1],10.]}})).unwrap();
if crate::dim_view::editing() {
h.step(&json!({"key":"Enter"})).unwrap();
}
let state = crate::open_meshing::session_world(&h.app.session);
let sk = &state.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch;
let c = sk.constraints.iter().rev().find(|c| c.kind.is_dimension()).unwrap();
assert!(if horizontal { matches!(c.kind, ConstraintKind::DistanceX { .. }) } else { matches!(c.kind, ConstraintKind::DistanceY { .. }) });
if held_y {
assert_eq!(c.driven, !horizontal, "the vertical span is fixed by the model edge");
}
assert_eq!(
sk.constraints.iter().filter(|c| matches!(c.kind, ConstraintKind::Midpoint { .. })).count(),
2,
"reuse the picked midpoint points"
);
assert_eq!(h.app.session.undo.len(), undo + 1);
h.app.run("edit.undo", json!({})).unwrap();
assert_eq!(h.app.session.doc.to_json(), baseline);
crate::dim_view::cancel();
}
}
}
/// A finished, extruded 20 x 10 rectangle whose dimensions are shown in the model view (Show
/// Dimensions): the width `d1` is driven by the user parameter `width`, the height `d2` is a
/// plain value. Returns the harness and the sketch id.
fn shown_dimensions() -> (Harness, u64) {
crate::dim_view::cancel();
let mut h = Harness::new();
h.app.run("parameters.add", json!({"name":"width","expression":"20 mm"})).unwrap();
let sketch = h.app.run("sketch.create", json!({"plane":"XY"})).unwrap()["sketch"].as_u64().unwrap();
h.app.run("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[20,10]})).unwrap();
h.app.run("sketch.dimension", json!({"entities":["l1"],"value":"width","text_at":[10,-4]})).unwrap();
h.app.run("sketch.dimension", json!({"entities":["l2"],"value":10,"text_at":[24,5]})).unwrap();
h.app.run("sketch.finish", json!({})).unwrap();
h.app.run("solid.extrude", json!({"sketch":sketch,"distance":5,"body_name":"Plate"})).unwrap();
crate::browser::set_sketch_visible(&mut h.app, sketch, true);
h.app.session.visibility.shown_dimensions.push(sketch);
h.call("ui.view", json!({"view":"top"}));
h.app.cam.distance = 80.0;
h.app.cam.target = solidcore_record::Vec3::new(10.0, 5.0, 0.0);
h.settle();
(h, sketch)
}
/// The model view's text of the dimension driven by `param` (screen).
fn model_text(h: &Harness, param: &str) -> [f32; 2] {
let sk = h
.app
.session
.world_state()
.unwrap()
.sketch(h.app.session.doc.features.iter().find(|f| f.name.starts_with("Sketch")).unwrap().id)
.unwrap()
.sketch
.clone();
let id = sk.constraints.iter().find(|c| c.param.as_deref() == Some(param)).unwrap().id.clone();
let (_, _, p) = crate::dim_view::model_drawn().into_iter().find(|(_, d, _)| *d == id).expect("the dimension is shown in the model view");
[p.x, p.y]
}
/// The extruded plate's width and depth (x, y), rounded to 0.001 mm.
fn plate_max(h: &Harness) -> [f64; 2] {
let b = h.app.session.world_state().unwrap().body("Plate").unwrap().mesh().bounds();
[((b.max.x - b.min.x) * 1000.0).round() / 1000.0, ((b.max.y - b.min.y) * 1000.0).round() / 1000.0]
}
#[test]
fn double_clicking_a_shown_dimension_edits_it_without_editing_the_sketch() {
let (mut h, _) = shown_dimensions();
let camera = (h.app.cam.target, h.app.cam.distance);
let undo = h.app.session.undo.len();
assert!((plate_max(&h)[1] - 10.0).abs() < 1e-6);
let at = model_text(&h, "d2");
h.step(&json!({"click":at,"double":true})).unwrap();
assert!(crate::dim_view::editing(), "the double-click opens the value");
assert_eq!(h.ctx.memory(|m| m.focused()), Some(egui::Id::unique("sc_dim_edit")));
assert_eq!(h.app.session.active_sketch, None, "the sketch is not edited");
type_value(&mut h, "14");
h.step(&json!({"key":"Enter"})).unwrap();
h.settle();
assert!(!crate::dim_view::editing());
assert_eq!(h.app.session.active_sketch, None);
assert_eq!((h.app.cam.target, h.app.cam.distance), camera, "the view stays put");
assert_eq!(h.app.session.undo.len(), undo + 1, "one undo step");
assert!((plate_max(&h)[1] - 14.0).abs() < 1e-6, "the extrude follows: {:?}", plate_max(&h));
h.app.run("edit.undo", json!({})).unwrap();
h.settle();
assert!((plate_max(&h)[1] - 10.0).abs() < 1e-6, "undo restores it");
}
#[test]
fn escape_cancels_a_shown_dimensions_value() {
let (mut h, _) = shown_dimensions();
let doc = h.app.session.doc.to_json();
let at = model_text(&h, "d2");
h.step(&json!({"click":at,"double":true})).unwrap();
assert!(crate::dim_view::editing());
type_value(&mut h, "30");
h.step(&json!({"key":"Escape"})).unwrap();
h.settle();
assert!(!crate::dim_view::editing());
assert_eq!(h.app.session.doc.to_json(), doc, "nothing changed");
assert!((plate_max(&h)[1] - 10.0).abs() < 1e-6);
}
#[test]
fn a_parameter_driven_shown_dimension_edits_its_own_expression() {
let (mut h, _) = shown_dimensions();
let at = model_text(&h, "d1");
h.step(&json!({"click":at,"double":true})).unwrap();
assert!(crate::dim_view::editing());
assert!(h.widget("width").is_some(), "the box shows the expression that drives it");
type_value(&mut h, "width + 5");
h.step(&json!({"key":"Enter"})).unwrap();
h.settle();
assert_eq!(h.app.session.doc.param("width").unwrap().expr, "20 mm", "the user parameter is left alone");
assert_eq!(h.app.session.doc.param("d1").unwrap().expr, "width + 5");
assert!((plate_max(&h)[0] - 25.0).abs() < 1e-6, "{:?}", plate_max(&h));
assert_eq!(h.app.session.active_sketch, None);
}
#[test]
fn a_driven_shown_dimension_is_read_only() {
let (mut h, sketch) = shown_dimensions();
h.app.run("sketch.edit", json!({"sketch":sketch})).unwrap();
h.app.run("sketch.dimension", json!({"entities":["l3"],"driven":true,"text_at":[10,14]})).unwrap();
h.app.run("sketch.finish", json!({})).unwrap();
h.settle();
let id = h.app.session.world_state().unwrap().sketch(sketch).unwrap().sketch.constraints.iter().find(|c| c.driven).unwrap().id.clone();
let (_, _, p) = crate::dim_view::model_drawn().into_iter().find(|(_, d, _)| *d == id).unwrap();
let doc = h.app.session.doc.to_json();
h.step(&json!({"click":[p.x, p.y],"double":true})).unwrap();
assert!(!crate::dim_view::editing());
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(), doc);
}
/// The value applies like any other change: the shell it breaks reports its error on the
/// timeline, and Undo brings back the value and the shell. The plate's 10 width taken to 3 leaves
/// no room inside two 2 thick walls. (A round wider than its face no longer breaks: a convex
/// round runs over the face's far edge, cut as if the face went on.)
#[test]
fn a_shown_dimension_that_breaks_a_later_feature_reports_it_and_undoes() {
let (mut h, _) = shown_dimensions();
h.app.run("solid.shell", json!({"faces":[[10,1,5]],"thickness":2,"name":"Hollow"})).unwrap();
h.settle();
let hollow = h.app.session.doc.features.iter().find(|f| f.name == "Hollow").unwrap().id;
let failed = |h: &Harness| h.app.session.model.result(hollow).is_some_and(|r| r.error.is_some());
assert!(!failed(&h));
let before = h.app.session.doc.to_json();
let at = model_text(&h, "d2");
h.step(&json!({"click":at,"double":true})).unwrap();
type_value(&mut h, "3");
h.step(&json!({"key":"Enter"})).unwrap();
h.settle();
assert_eq!(h.app.session.doc.param("d2").unwrap().expr, "3");
assert!(failed(&h), "the shell no longer has room and says so");
assert_eq!(h.app.session.active_sketch, None);
h.app.run("edit.undo", json!({})).unwrap();
h.settle();
assert_eq!(h.app.session.doc.to_json(), before);
assert!(!failed(&h), "undo brings the shell back");
}
/// Editing an existing dimension to `name = value` names its own parameter (#4071): `d1`
/// becomes `width`, set to the value, in one undo step, and opening it again shows `width`'s
/// value as its expression. No other parameter is made.
#[test]
fn editing_a_dimension_to_a_definition_names_its_parameter() {
let mut h = line([25., 0.]);
place(&mut h, &[[12.5, 0.]], [12.5, 8.]);
type_value(&mut h, "25");
h.step(&json!({"key":"Enter"})).unwrap();
h.settle();
let params = h.app.session.doc.params.len();
let undo = h.app.session.undo.len();
crate::dim_view::edit_param(&h.app, "d1");
h.settle();
type_value(&mut h, "width = 30");
h.step(&json!({"key":"Enter"})).unwrap();
let doc = &h.app.session.doc;
assert!(doc.param("d1").is_none(), "{:?}", h.app.status);
assert_eq!(doc.param("width").map(|p| p.expr.as_str()), Some("30"));
assert_eq!(doc.params.len(), params, "renamed, not added");
assert_eq!(h.app.session.undo.len(), undo + 1, "one undo step");
assert!(h.app.status.as_ref().is_some_and(|s| !s.2 && s.0.contains("`width`")), "{:?}", h.app.status);
let sk = doc.sketch(h.app.session.active_sketch.unwrap()).unwrap();
assert!(sk.constraints.iter().any(|c| c.param.as_deref() == Some("width") && c.kind.value().is_some_and(|v| (v - 30.0).abs() < 1e-6)));
}
/// The status line after a dimension is applied reads in the interface language (#8863): a
/// new parameter (`w = 40/2`), a plain value, a renamed parameter and a driven dimension, with
/// the parameter name kept as typed.
#[test]
fn the_status_after_a_dimension_is_in_the_interface_language() {
let pl = crate::i18n::Locale::for_language("pl");
let en = crate::i18n::Locale::for_language("en");
let status = |h: &Harness| h.app.status.as_ref().map(|s| (s.0.clone(), s.2));
let polish = |mut h: Harness| {
h.app.preferences.language = "pl".into();
h.frames(2);
h
};
// A new parameter.
let mut h = polish(line([25., 0.]));
place(&mut h, &[[12.5, 0.]], [12.5, 8.]);
type_value(&mut h, "w = 40/2");
h.step(&json!({"key":"Enter"})).unwrap();
assert!(h.app.session.doc.param("w").is_some(), "{:?}", h.app.status);
assert_eq!(status(&h), Some(("Wymiar zastosowany; zdefiniowano parametr `w`".to_string(), false)));
// A plain value, then the same dimension renamed to `width = 30`.
let mut h = polish(line([25., 0.]));
place(&mut h, &[[12.5, 0.]], [12.5, 8.]);
type_value(&mut h, "25");
h.step(&json!({"key":"Enter"})).unwrap();
assert_eq!(status(&h), Some((pl.text("sketch.dimension_applied").to_string(), false)));
h.settle();
crate::dim_view::edit_param(&h.app, "d1");
h.settle();
type_value(&mut h, "width = 30");
h.step(&json!({"key":"Enter"})).unwrap();
assert!(h.app.session.doc.param("width").is_some(), "{:?}", h.app.status);
assert_eq!(status(&h), Some((pl.format("sketch.dimension_applied_renamed", &[("name", "width")]), false)));
// A dimension the sketch already determines is added as a driven one.
let mut h = polish(line([20., 0.]));
h.app.run("sketch.dimension", json!({"entities":["l1"],"value":"20 mm"})).unwrap();
h.settle();
h.step(&json!({"start":"sketch.dimension"})).unwrap();
h.step(&json!({"click":{"world":[10,0,0]}})).unwrap();
h.step(&json!({"move":{"world":[10,6,0]}})).unwrap();
h.settle();
h.step(&json!({"click":{"world":[10,6,0]}})).unwrap();
assert!(!crate::dim_view::editing(), "a driven dimension has no value to edit");
assert_eq!(status(&h), Some((pl.text("sketch.dimension_added_driven").to_string(), false)));
for id in ["sketch.dimension_applied", "sketch.dimension_applied_defined", "sketch.dimension_applied_renamed", "sketch.dimension_added_driven"] {
assert_ne!(pl.text(id), en.text(id), "{id}: the Polish catalog translates it");
}
crate::dim_view::cancel();
}
/// A selected curve of the sketch is not lit where the design has it while a value is typed, as
/// a selected profile is not.
#[test]
fn a_typed_value_does_not_light_a_selected_design_curve() {
let mut h = sketch_with(&[("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,20]}))], [20., 10.]);
h.step(&json!({"click":{"world":[20,0,0]}})).unwrap();
assert_live(&h);
keys(&mut h, "60");
let sketch = h.app.session.active_sketch.unwrap();
let id = solved(&h).curves[0].id.clone();
for sel in [
solidcraft_engine::Sel::SketchCurve { id: id.clone(), sketch: None },
solidcraft_engine::Sel::SketchCurve { id: id.clone(), sketch: Some(sketch) },
solidcraft_engine::Sel::ExternalSketchCurve { sketch, id: id.clone() },
] {
h.app.session.selection = vec![sel.clone()];
assert!(crate::viewport::build_highlight(&h.app).overlay.is_empty(), "{sel:?}: no curve lit while the value is typed");
}
crate::dim_view::cancel();
assert!(!crate::viewport::build_highlight(&h.app).overlay.is_empty(), "lit once the value is let go");
}
/// The Dimension tool's "x, y" readout gives the design's coordinates: while a value is typed it
/// is not drawn, as the hover highlight is not.
#[test]
fn a_typed_value_hides_the_pointer_readout() {
let mut h = sketch_with(&[("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,20]}))], [20., 10.]);
h.step(&json!({"move":{"world":[10,5,0]}})).unwrap();
h.frames(1);
assert!(crate::scenario::rect_of("viewport:readout").is_some(), "the readout is drawn while only pointing");
h.step(&json!({"click":{"world":[20,0,0]}})).unwrap();
assert_live(&h);
keys(&mut h, "60");
h.step(&json!({"move":{"world":[12,6,0]}})).unwrap();
h.frames(1);
assert!(crate::scenario::rect_of("viewport:readout").is_none(), "no readout while the value is typed");
crate::dim_view::cancel();
}
/// A curvature comb's teeth are the design's: while a value is typed they are not drawn.
#[test]
fn a_typed_value_hides_the_curvature_combs() {
let mut h = sketch_with(&[("sketch.circle.center", json!({"center":[20,10],"radius":5}))], [20., 10.]);
let id = solved(&h).curves[0].id.clone();
h.app.run("inspect.curvature_comb", json!({"curves":[id]})).unwrap();
h.step(&json!({"start":"sketch.dimension"})).unwrap();
let teeth = egui::epaint::Stroke::new(1.0, crate::theme::Tokens::get().comb_teeth);
let comb_drawn = |h: &Harness| h.shapes.iter().any(|s| matches!(&s.shape, egui::Shape::LineSegment { stroke, .. } if *stroke == teeth));
h.frames(1);
assert!(comb_drawn(&h), "the comb is drawn");
h.step(&json!({"click":{"world":[25,10,0]}})).unwrap();
assert_live(&h);
keys(&mut h, "8");
h.frames(1);
assert!(!comb_drawn(&h), "no comb of the design while the value is typed");
crate::dim_view::cancel();
}
/// #3137: the Dimension tool takes the origin axis along the sketch's x or y as its second
/// pick: a circle's centre, or the circle itself, is then dimensioned from that axis.
#[test]
fn a_circle_centre_is_dimensioned_from_a_sketch_axis() {
for (picks, typed, centre) in [(vec![[30., 20.], [0., 3.]], "40 mm", [40., 20.]), (vec![[30., 20.], [3., 0.]], "12 mm", [30., 12.])] {
crate::dim_view::cancel();
let mut h = Harness::new();
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
h.app.run("sketch.circle.center", json!({"center":[30,20],"radius":5})).unwrap();
// Sized already, so the first dimension below measures instead of scaling the sketch (#1365).
h.app.run("sketch.dimension", json!({"entities":["c1"],"type":"radius","value":"5 mm"})).unwrap();
h.call("ui.view", json!({"view":"top"}));
h.app.cam.distance = 80.0;
h.app.cam.target = solidcore_record::Vec3::new(15., 10., 0.);
h.settle();
h.step(&json!({"start":"sketch.dimension"})).unwrap();
for p in &picks {
h.step(&json!({"move":{"world":[p[0],p[1],0]}})).unwrap();
h.step(&json!({"click":{"world":[p[0],p[1],0]}})).unwrap();
}
type_value(&mut h, typed);
h.step(&json!({"key":"Enter"})).unwrap();
let state = crate::open_meshing::session_world(&h.app.session);
let sk = &state.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch;
let o = sk.point(sk.resolve_point("c1.center").unwrap()).unwrap();
assert!((o.x - centre[0]).abs() < 1e-6 && (o.y - centre[1]).abs() < 1e-6, "{picks:?}: {o:?} {:?}", h.app.status);
}
}
/// #3320: after a line or a line's end, the X axis is the second pick: an angle from the axis,
/// and a distance from it. The line is picked off its midpoint, which is a point pick (#4872).
#[test]
fn a_line_is_dimensioned_against_the_sketch_x_axis() {
for (picks, typed) in [(vec![[5., 5.], [3., 0.]], "30 deg"), (vec![[20., 20.], [3., 0.]], "12 mm")] {
crate::dim_view::cancel();
let mut h = Harness::new();
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
h.app.run("sketch.line", json!({"points":[[0,0],[20,20]]})).unwrap();
// Sized already, so the first dimension below measures instead of scaling the sketch (#1365).
h.app.run("sketch.dimension", json!({"entities":["l1"],"type":"length","value":"28.284271247461902 mm"})).unwrap();
h.call("ui.view", json!({"view":"top"}));
h.app.cam.distance = 80.0;
h.app.cam.target = solidcore_record::Vec3::new(10., 10., 0.);
h.settle();
h.step(&json!({"start":"sketch.dimension"})).unwrap();
for p in &picks {
h.step(&json!({"move":{"world":[p[0],p[1],0]}})).unwrap();
h.step(&json!({"click":{"world":[p[0],p[1],0]}})).unwrap();
}
assert_eq!(h.app.tool.as_ref().unwrap().picks.last().map(String::as_str), Some("x"), "the axis is the second pick");
type_value(&mut h, typed);
h.step(&json!({"key":"Enter"})).unwrap();
let state = crate::open_meshing::session_world(&h.app.session);
let sk = &state.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch;
let (a, b) = (sk.point(sk.resolve_point("l1.start").unwrap()).unwrap(), sk.point(sk.resolve_point("l1.end").unwrap()).unwrap());
if typed.ends_with("deg") {
let angle = (b - a).angle().to_degrees();
assert!((angle - 30.0).abs() < 1e-6, "the line is at 30° to x: {angle}");
} else {
assert!((b.y - 12.0).abs() < 1e-6, "the end is 12 from x: {b:?}");
}
}
}