SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
use egui::{Event, Key, Modifiers, MouseWheelUnit, TouchPhase, pos2, vec2};
use serde_json::json;
use super::*;
use crate::SolveApp;
use crate::scenario::Harness;
#[test]
fn plain_numbers_step_in_the_unit_they_are_written_in() {
for (text, tenths, want) in [
("20 mm", 10, "21 mm"),
("20mm", -10, "19mm"),
("20", 100, "30"),
("2.5", 1, "2.6"),
("2", 1, "2.1"),
("2.25 mm", 10, "3.25 mm"),
("0.5 mm", -10, "-0.5 mm"),
("-0.5", 10, "0.5"),
("-1", 10, "0"),
("-0.1", 1, "0.0"),
(" 45 deg ", 10, " 46 deg "),
("90°", -100, "80°"),
("1 in", 1, "1.1 in"),
("12 µm", 10, "13 µm"),
("+5", 10, "6"),
(".5", 10, "1.5"),
("4", 30, "7"),
("2,5 mm", 10, "3,5 mm"),
("2,5", 1, "2,6"),
("-0,5", 5, "0,0"),
("20\"", 10, "21\""),
("3 ′", -10, "2 ′"),
("12 inch", 100, "22 inch"),
] {
assert_eq!(stepped(text, tenths).as_deref(), Some(want), "{text:?} by {tenths} tenths");
}
}
#[test]
fn anything_but_a_plain_number_is_left_as_typed() {
for text in [
"",
" ",
"width",
"width / 2",
"20 mm + 1",
"2 * 3",
"1e3",
"1,5,3",
"2,",
",5",
"2 1/8\"",
"20 widths",
"mm",
"-",
".",
"1.2.3",
"20 mm mm",
"inf",
"NaN",
] {
assert_eq!(stepped(text, 10), None, "{text:?}");
}
// Hostile input stays a string: no panic, nothing infinite.
assert_eq!(stepped(&"9".repeat(400), 10), None);
assert!(stepped("1", i64::MAX).is_some());
assert!(stepped("1", i64::MIN).is_some());
}
/// One focused value field (a dialog's, through `params_dialog::complete`) in a scroll area taller
/// than the window, with value stepping on (`Field::new`) or off as by default (`Field::off`).
struct Field {
on: bool,
ctx: egui::Context,
app: SolveApp,
text: String,
id: egui::Id,
changed: bool,
rect: egui::Rect,
scroll: egui::Id,
}
impl Field {
fn new(text: &str) -> Self {
Self::with(text, true)
}
fn off(text: &str) -> Self {
Self::with(text, false)
}
fn with(text: &str, on: bool) -> Self {
let ctx = egui::Context::default();
let mut app = SolveApp::new(solidcraft_engine::Session::default(), Default::default());
crate::params_dialog::publish(&mut app, &ctx);
let id = egui::Id::unique("value_step_test_field");
let mut f = Self { on, ctx, app, text: text.into(), id, changed: false, rect: egui::Rect::NOTHING, scroll: egui::Id::NULL };
f.ctx.memory_mut(|m| m.request_focus(id));
f.frame(Vec::new());
f.frame(Vec::new());
f
}
fn frame(&mut self, events: Vec<Event>) {
let mut out = self.ctx.run_ui(
egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(400.0, 300.0))), events, ..Default::default() },
|ui| {
crate::expression_complete::begin_frame(ui.ctx());
set_enabled(ui.ctx(), self.on);
crate::params_dialog::publish(&mut self.app, ui.ctx());
self.scroll = egui::ScrollArea::vertical()
.max_height(200.0)
.show(ui, |ui| {
let r = ui.add(egui::TextEdit::singleline(&mut self.text).id(self.id));
self.changed = crate::params_dialog::complete(ui, &r, &mut self.text);
self.rect = r.rect;
ui.add_space(1000.0);
})
.id;
},
);
out.textures_delta.clear();
}
fn key(&mut self, key: Key, modifiers: Modifiers) {
self.frame(vec![Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers }]);
}
fn wheel(&mut self, at: egui::Pos2, unit: MouseWheelUnit, dy: f32) {
let wheel = Event::MouseWheel {
source: egui::MouseWheelSource::Unknown,
unit,
delta: vec2(0.0, dy),
modifiers: Modifiers::NONE,
phase: TouchPhase::Move,
};
self.frame(vec![Event::PointerMoved(at), wheel]);
}
fn selection(&self) -> (usize, usize) {
let r = egui::TextEdit::load_state(&self.ctx, self.id).unwrap().cursor.char_range().unwrap();
let (a, b) = (r.primary.index.0, r.secondary.index.0);
(a.min(b), a.max(b))
}
fn scrolled(&self) -> f32 {
egui::scroll_area::State::load(&self.ctx, self.scroll).map_or(0.0, |s| s.clamped_offset().y)
}
}
#[test]
fn arrows_step_a_focused_field_and_select_the_new_value() {
let mut f = Field::new("20 mm");
f.key(Key::ArrowUp, Modifiers::NONE);
assert_eq!(f.text, "21 mm");
assert!(f.changed, "callers see the change");
assert_eq!(f.selection(), (0, 5), "typing replaces the stepped value");
f.key(Key::ArrowDown, Modifiers::NONE);
f.key(Key::ArrowDown, Modifiers::NONE);
assert_eq!(f.text, "19 mm");
f.key(Key::ArrowUp, Modifiers::SHIFT);
assert_eq!(f.text, "29 mm", "Shift: ten");
f.key(Key::ArrowDown, Modifiers::ALT);
assert_eq!(f.text, "28.9 mm", "Alt: a tenth");
f.key(Key::ArrowUp, Modifiers::COMMAND);
assert_eq!(f.text, "28.9 mm", "Ctrl/Cmd keep the text cursor's Up");
assert!(!f.changed);
}
#[test]
fn arrows_move_the_cursor_in_an_expression_and_leave_unfocused_fields_alone() {
let mut f = Field::new("width / 2");
f.key(Key::ArrowUp, Modifiers::NONE);
assert_eq!(f.text, "width / 2");
assert_eq!(f.selection(), (0, 0), "Up moved the text cursor home, as in any text box");
let mut f = Field::new("20 mm");
f.ctx.memory_mut(|m| m.surrender_focus(f.id));
f.frame(Vec::new());
f.key(Key::ArrowUp, Modifiers::NONE);
assert_eq!(f.text, "20 mm");
}
#[test]
fn an_open_completion_list_keeps_the_arrows() {
// A plain number's unit is a whole name, so the list only opens when asked for (Ctrl+Space).
let mut f = Field::new("20 mm");
f.key(Key::Space, Modifiers::CTRL);
f.key(Key::ArrowDown, Modifiers::NONE);
assert_eq!(f.text, "20 mm", "the arrows go to the list while it shows");
f.key(Key::Escape, Modifiers::NONE);
f.ctx.memory_mut(|m| m.request_focus(f.id));
f.frame(Vec::new());
f.key(Key::ArrowDown, Modifiers::NONE);
assert_eq!(f.text, "19 mm", "with the list dismissed they step");
}
#[test]
fn the_wheel_over_a_focused_field_steps_it_instead_of_scrolling() {
let mut f = Field::new("20 mm");
let over = f.rect.center();
f.wheel(over, MouseWheelUnit::Line, 1.0);
assert_eq!(f.text, "21 mm", "a notch up steps up");
f.wheel(over, MouseWheelUnit::Line, -2.0);
assert_eq!(f.text, "19 mm");
// A trackpad's points add up to a notch (a line's worth) before the value moves.
let speed = f.ctx.options(|o| o.input_options.line_scroll_speed);
for _ in 0..3 {
f.wheel(over, MouseWheelUnit::Point, speed / 4.0);
}
assert_eq!(f.text, "19 mm");
f.wheel(over, MouseWheelUnit::Point, speed / 4.0);
assert_eq!(f.text, "20 mm");
for _ in 0..30 {
f.frame(vec![Event::PointerMoved(over)]);
}
assert_eq!(f.scrolled(), 0.0, "the panel under the field did not scroll");
// Off the field the wheel scrolls as before and leaves the value.
f.wheel(pos2(over.x, over.y + 120.0), MouseWheelUnit::Line, -3.0);
for _ in 0..30 {
f.frame(Vec::new());
}
assert_eq!(f.text, "20 mm");
assert!(f.scrolled() > 0.0, "the panel scrolls off the field");
}
/// An edge Flange dialog open on a 100 x 60 base flange, its Height box (10 mm) beside the edge,
/// with value stepping `on` or off.
fn edge_flange(on: bool) -> Harness {
let mut h = Harness::new();
h.app.preferences.step_values = on;
h.app.run("sketch.create", json!({"plane": "XY", "name": "Base"})).unwrap();
h.app.run("sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [100, 60]})).unwrap();
h.app.run("sketch.finish", json!({})).unwrap();
let sk = h.app.session.doc.features[0].id;
h.app.session.selection = vec![solidcraft_engine::Sel::Profile { sketch: sk, index: 0 }];
h.app.start("sheet.flange");
let d = h.app.dialog.take().unwrap();
for (id, p) in crate::dialogs::apply_commands(&h.app, &d).unwrap() {
h.app.run(&id, p).unwrap();
}
let edge = crate::dialogs::edge_sel(&h.app.session, solidcore_record::Vec3::new(50.0, 0.0, 2.5)).unwrap();
h.app.session.selection = vec![edge];
h.step(&json!({"start": "sheet.flange"})).unwrap();
h.frames(6);
assert_eq!(flange(&h), (1, "10 mm".into(), String::new()), "an edge flange, 10 mm high");
h
}
/// The open Flange dialog's type, height and bend radius.
fn flange(h: &Harness) -> (usize, String, String) {
match &h.app.dialog.as_ref().unwrap().kind {
crate::dialogs::Kind::Sheet(crate::dialogs_sheet::Sm::Flange { ty, height, radius, .. }) => (*ty, height.clone(), radius.clone()),
_ => panic!("flange dialog"),
}
}
/// #2320 as reported: in an edge Flange, the Height box beside the edge and the Bend Radius row
/// both take Up/Down and the wheel, and OK makes the stepped flange.
#[test]
fn flange_height_and_bend_radius_step_with_arrows_and_wheel() {
let mut h = edge_flange(true);
// The box sits at the arrow's tip, so it moves as the height does.
let at = |h: &Harness| h.ctx.read_response(egui::Id::unique("sc_canvas_value")).expect("the Height box beside the edge").rect.center();
let height = at(&h);
h.step(&json!({"click": [height.x, height.y]})).unwrap();
h.step(&json!({"key": "ArrowUp"})).unwrap();
h.frames(2);
assert_eq!(flange(&h).1, "11 mm");
h.step(&json!({"key": "ArrowUp", "shift": true})).unwrap();
h.frames(2);
assert_eq!(flange(&h).1, "21 mm");
// Close in, then notch after notch at one spot: the box stays under the pointer while its arrow
// shrinks, so every notch steps it and none reaches the camera.
h.call("ui.camera", json!({"target": [50, 0, 15], "distance": 40}));
h.frames(4);
let rect = h.ctx.read_response(egui::Id::unique("sc_canvas_value")).unwrap().rect;
let tip = h.at(&json!({"handle": "arrow"})).unwrap()[1];
let cam = h.app.cam;
for _ in 0..4 {
h.call("ui.scroll", json!({"x": rect.center().x, "y": rect.center().y, "delta": -40.0}));
h.frames(2);
}
assert_eq!(flange(&h).1, "17 mm", "four notches down");
assert_eq!(h.app.cam, cam, "the view did not zoom");
let moved = (h.at(&json!({"handle": "arrow"})).unwrap()[1] - tip).abs();
assert!(moved > f64::from(rect.height()), "the tip moved {moved}, further than the box is tall");
// The Bend Radius row (under Advanced) is found by its label, empty ("from the rule") does not
// step, a number does.
h.step(&json!({"click": {"handle": "dialog:section:Advanced"}})).unwrap();
h.frames(2);
h.step(&json!({"click": {"handle": "dialog:Bend Radius"}})).unwrap();
h.step(&json!({"key": "ArrowUp"})).unwrap();
h.frames(2);
assert_eq!(flange(&h).2, "");
h.step(&json!({"text": "2 mm"})).unwrap();
h.step(&json!({"key": "ArrowUp"})).unwrap();
h.frames(2);
assert_eq!(flange(&h).2, "3 mm");
h.step(&json!({"widget": "OK"})).unwrap();
h.frames(2);
let f = h.app.session.doc.features.last().unwrap();
let solidcraft_engine::doc::FeatureKind::SheetFlange { height, radius, .. } = &f.kind else { panic!("flange feature: {:?}", f.kind) };
assert_eq!((height.as_str(), radius.as_deref()), ("17 mm", Some("3 mm")));
}
/// The Parameters window's expression boxes step too; Enter applies the stepped expression.
#[test]
fn parameter_expressions_step_and_apply() {
let mut h = Harness::new();
h.app.preferences.step_values = true;
h.app.run("parameters.add", json!({"name": "width", "expression": "10 mm"})).unwrap();
h.step(&json!({"start": "parameters.change"})).unwrap();
h.frames(4);
h.step(&json!({"click": {"handle": "param:width"}})).unwrap();
h.frames(2);
h.step(&json!({"key": "ArrowUp"})).unwrap();
h.step(&json!({"key": "ArrowUp"})).unwrap();
h.frames(2);
assert_eq!(h.app.params.as_ref().unwrap().editing.get("width").map(String::as_str), Some("12 mm"));
h.step(&json!({"key": "Enter"})).unwrap();
h.frames(2);
assert_eq!(h.app.session.doc.param("width").map(|p| p.expr.as_str()), Some("12 mm"));
}
/// Off, as by default, value fields behave as before: Up moves the text cursor home, the wheel
/// scrolls the panel under the field, and the box beside the geometry follows its arrow.
#[test]
fn off_by_default_the_keys_and_the_wheel_do_what_they_did() {
assert!(!crate::prefs::Prefs::default().step_values);
assert!(!serde_json::from_value::<crate::prefs::Prefs>(json!({})).unwrap().step_values, "saved preferences without it");
let mut f = Field::off("20 mm");
f.key(Key::ArrowUp, Modifiers::NONE);
assert_eq!((f.text.as_str(), f.selection()), ("20 mm", (0, 0)), "Up moved the cursor home");
let over = f.rect.center();
f.wheel(over, MouseWheelUnit::Line, -3.0);
for _ in 0..30 {
f.frame(vec![Event::PointerMoved(over)]);
}
assert_eq!(f.text, "20 mm");
assert!(f.scrolled() > 0.0, "the wheel scrolled the panel");
let mut h = edge_flange(false);
let at = h.ctx.read_response(egui::Id::unique("sc_canvas_value")).unwrap().rect.center();
h.step(&json!({"click": [at.x, at.y]})).unwrap();
h.step(&json!({"key": "ArrowUp"})).unwrap();
h.call("ui.scroll", json!({"x": at.x, "y": at.y, "delta": 40.0}));
h.frames(2);
assert_eq!(flange(&h).1, "10 mm", "neither Up nor the wheel stepped the Height box");
// Typed with the pointer over the box, the box follows the arrow's tip as before.
h.step(&json!({"key": "A", "cmd": true})).unwrap();
h.step(&json!({"text": "40 mm"})).unwrap();
h.frames(3);
assert_eq!(flange(&h).1, "40 mm");
let moved = h.ctx.read_response(egui::Id::unique("sc_canvas_value")).unwrap().rect.center();
assert!((moved.y - at.y).abs() > 5.0, "the box moved with the arrow ({at:?} -> {moved:?})");
}
/// The preference is on Preferences › Design, and the control channel sets it.
#[test]
fn the_preference_is_on_the_design_page() {
let mut h = Harness::new();
crate::prefs::set(&mut h.app, &json!({"step_values": true})).unwrap();
assert!(h.app.preferences.step_values);
crate::prefs::set(&mut h.app, &json!({"step_values": false})).unwrap();
h.call("ui.prefs", json!({"open": "Design"}));
h.frames(3);
// The row can be below the page's fold: scroll the page to it, as a user would, a little at a
// time so the page's length doesn't matter.
for _ in 0..40 {
let window = h.ctx.memory(|m| m.area_rect(egui::Id::unique("sc_prefs"))).unwrap();
let row = crate::scenario::handle_at("prefs:step_values").expect("the Design page shows the row");
if window.shrink(60.0).contains(row) {
break;
}
let delta = if row.y > window.center().y { -60.0 } else { 60.0 };
h.call("ui.scroll", json!({"x": window.center().x, "y": window.center().y, "delta": delta}));
h.frames(10);
}
h.step(&json!({"click": {"handle": "prefs:step_values"}})).unwrap();
h.frames(2);
assert!(h.app.preferences.step_values, "the Design page's checkbox turns it on");
}