Files
makeCAD/crates/ui-egui/src/pattern_arrow_tests.rs
T
Logan Night 1720c56840 Drag arrows: pattern spacing and sketch offset go negative past their start (#5497) (#5508)
* claim: #5497

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Sketch pattern: a spacing arrow dragged past zero gives a negative spacing (#5497)

The drag arrow floored an unsigned value at a small positive number, and the
rectangular sketch pattern's two spacing arrows were unsigned, although the
command takes a negative spacing and typing one works. Both arrows are signed
now, like the Extrude, Move and offset ones.

The test drags each arrow back past its start: without the change the first
one stops at 0.001.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Drag arrows: the solid pattern spacing and one-sided sketch offset go negative too (#5497)

The solid rectangular pattern's Spacing arrow and the sketch Offset distance
arrow were unsigned, so a drag back past the start stopped at a small positive
value, although both commands take a negative value and typing one works. Both
are signed now. A symmetric offset uses only the distance's size, so its arrow
still stops at the curve.

Tests: the solid pattern arrow dragged 10 mm back gives Spacing -10 and the
copies on the negative side (without the change: 0.001); the offset arrow
dragged across its circle gives -1 mm and the same circle as typing -1 mm
(without the change: 0.001), and a symmetric offset stays positive.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-26 20:03:03 +00:00

182 lines
9.2 KiB
Rust

//! A rectangular pattern's second direction has its own drag arrow for Spacing 2 (#2462), as
//! the first direction's arrow sets Spacing.
use crate::dialogs::Kind;
use crate::scenario::{Harness, handle_at};
use crate::sketch_modify_ui::Mod;
use serde_json::json;
fn spacings(h: &Harness) -> (String, String) {
match h.app.dialog.as_ref().map(|d| &d.kind) {
Some(Kind::PatternRect { spacing, spacing2, .. }) | Some(Kind::SketchModify(Mod::PatternRect { spacing, spacing2, .. })) => {
(spacing.clone(), spacing2.clone())
}
other => panic!("no rectangular pattern window: {other:?}"),
}
}
#[test]
fn a_sketch_pattern_drags_its_second_spacing_square_to_the_first() {
let mut h = Harness::new();
h.run(&json!([
{"start": "sketch.create"},
{"click": {"plane": "XY"}},
{"start": "sketch.circle.center"},
{"click": {"sketch": [0, 0]}},
{"click": {"sketch": [5, 0]}},
{"key": "Escape"},
{"start": "sketch.pattern.rectangular"},
{"click": {"sketch": [5, 0]}}
]))
.unwrap();
// Keep both arrows in the exposed viewport beside the left dialog. The full-bleed
// projection otherwise puts Spacing 2 under the dialog's top edge.
h.call("ui.camera", json!({"target":[-30,0,0]}));
h.settle();
let (Some(a1), Some(a2)) = (handle_at("arrow"), handle_at("arrow2")) else {
panic!("both arrows: {:?} {:?}", handle_at("arrow"), handle_at("arrow2"));
};
// Looking down on XY, the first direction (sketch x) points right and the second (square to
// it) up the screen: the arrows share their base, so each lies along its own axis.
assert!(a1.x > a2.x + 10.0 && (a2.y - a1.y).abs() > 10.0, "arrow {a1:?}, arrow2 {a2:?}");
assert!(!crate::shell::covered(&h.app, a1));
assert!(!crate::shell::covered(&h.app, a2));
let (spacing, spacing2) = spacings(&h);
// Dragging the second arrow further out sets Spacing 2 only.
h.call("ui.drag", json!({"x0": a2.x, "y0": a2.y, "x1": a2.x, "y1": a2.y - 60.0, "steps": 6}));
h.settle();
let (after, after2) = spacings(&h);
assert_eq!(after, spacing);
assert_ne!(after2, spacing2);
let grown = h.app.session.doc.eval(&after2, solidcraft_engine::doc::expr::Kind::Length).unwrap();
let was = h.app.session.doc.eval(&spacing2, solidcraft_engine::doc::expr::Kind::Length).unwrap();
assert!(grown > was, "Spacing 2 {spacing2} -> {after2}");
}
#[test]
fn a_solid_pattern_shows_the_second_arrow_once_it_has_a_second_direction() {
let mut h = Harness::new();
h.run(&json!([
{"call": "engine.execute", "params": {"command": "solid.box", "params": {"length": 10, "width": 10, "height": 10}}},
{"call": "ui.view", "params": {"view": "iso"}},
{"start": "solid.pattern.rectangular"},
{"click": {"world": [5, 5, 10]}},
{"call": "ui.dialogInput", "params": {"index": 1}},
{"click": {"axis": "X"}}
]))
.unwrap();
h.settle();
assert!(handle_at("arrow").is_some());
assert!(handle_at("arrow2").is_none(), "no second direction yet, so no second arrow");
h.run(&json!([
{"call": "ui.dialogInput", "params": {"index": 2}},
{"click": {"axis": "Y"}}
]))
.unwrap();
h.settle();
let Some(a2) = handle_at("arrow2") else { panic!("no second arrow with a second direction") };
let (spacing, spacing2) = spacings(&h);
let toward = h.call("ui.worldToScreen", json!({"points": [[5, 60, 5]]}))["result"][0].clone();
let (tx, ty) = (toward[0].as_f64().unwrap() as f32, toward[1].as_f64().unwrap() as f32);
// Drag it along +Y (towards a point far out on Y): Spacing 2 changes, Spacing doesn't.
let (dx, dy) = (tx - a2.x, ty - a2.y);
let len = (dx * dx + dy * dy).sqrt().max(1.0);
h.call("ui.drag", json!({"x0": a2.x, "y0": a2.y, "x1": a2.x + dx / len * 60.0, "y1": a2.y + dy / len * 60.0, "steps": 6}));
h.settle();
let (after, after2) = spacings(&h);
assert_eq!(after, spacing);
assert_ne!(after2, spacing2);
}
#[test]
fn a_pattern_of_features_puts_its_arrow_on_the_patterned_feature() {
let mut h = Harness::new();
h.run(&json!([
{"call": "engine.execute", "params": {"command": "solid.box", "params": {"corner": [0, 0, 0], "length": 60, "width": 20, "height": 5, "name": "Plate"}}},
{"call": "engine.execute", "params": {"command": "solid.box", "params": {"corner": [8, 6, 5], "length": 8, "width": 8, "height": 6, "operation": "join", "name": "Boss"}}},
{"call": "engine.execute", "params": {"command": "solid.pattern.rectangular", "params": {"features": ["Boss"], "dir1": [1, 0, 0], "count1": 2, "spacing1": 20, "name": "Pattern"}}},
{"call": "ui.view", "params": {"view": "iso"}},
{"call": "ui.editFeature", "params": {"feature": "Pattern"}}
]))
.unwrap();
h.settle();
let d = h.app.dialog.as_ref().expect("the pattern dialog");
assert!(matches!(d.inputs.first().and_then(|i| i.items.first()), Some(solidcraft_engine::Sel::Feature { .. })), "{:?}", d.inputs);
// The arrow starts at the middle of the boss and points along X, the pattern's direction.
let (base, dir) = crate::canvas::anchor(&h.app, d).expect("the pattern has an anchor");
assert!(base.dist(solidcraft_engine::geom::Vec3::new(12.0, 10.0, 8.0)) < 1e-6, "{base:?}");
assert!(dir.is_some_and(|v| v.dist(solidcraft_engine::geom::Vec3::new(1.0, 0.0, 0.0)) < 1e-9), "{dir:?}");
let Some(tip) = handle_at("arrow") else { panic!("no arrow on a pattern of features") };
let from = h.call("ui.worldToScreen", json!({"points": [[12, 10, 8], [32, 10, 8]]}))["result"].clone();
let at = |i: usize| egui::pos2(from[i][0].as_f64().unwrap() as f32, from[i][1].as_f64().unwrap() as f32);
let (b, x) = (at(0), at(1));
// The tip lies off the base, on the screen line of the boss's +X direction.
let (ux, uy) = (x.x - b.x, x.y - b.y);
let (vx, vy) = (tip.x - b.x, tip.y - b.y);
assert!(vx * ux + vy * uy > 0.0, "tip {tip:?} base {b:?}");
assert!((vx * uy - vy * ux).abs() / (ux * ux + uy * uy).sqrt() < 3.0, "tip {tip:?} off the X line through {b:?}");
}
#[test]
fn inch_pattern_arrows_follow_bare_primary_and_secondary_distances() {
let mut h = Harness::new();
h.app.run("solid.box", json!({"length":10,"width":10,"height":10})).unwrap();
h.app.run("document.units", json!({"units":"in"})).unwrap();
h.run(&json!([
{"call":"ui.view","params":{"view":"iso"}},
{"start":"solid.pattern.rectangular"},
{"click":{"world":[5,5,10]}},
{"call":"ui.dialogInput","params":{"index":1}}, {"click":{"axis":"X"}},
{"call":"ui.dialogInput","params":{"index":2}}, {"click":{"axis":"Y"}}
]))
.unwrap();
if let Kind::PatternRect { spacing, spacing2, .. } = &mut h.app.dialog.as_mut().unwrap().kind {
*spacing = "0.5".into();
*spacing2 = "0.25".into();
}
h.settle();
let bare = (handle_at("arrow").unwrap(), handle_at("arrow2").unwrap());
if let Kind::PatternRect { spacing, spacing2, .. } = &mut h.app.dialog.as_mut().unwrap().kind {
*spacing = "12.7 mm".into();
*spacing2 = "6.35 mm".into();
}
h.settle();
let explicit = (handle_at("arrow").unwrap(), handle_at("arrow2").unwrap());
assert!(bare.0.distance(explicit.0) < 0.01, "primary: {bare:?} vs {explicit:?}");
assert!(bare.1.distance(explicit.1) < 0.01, "secondary: {bare:?} vs {explicit:?}");
}
/// Dragging a solid pattern's Spacing arrow back past its start gives a negative spacing, as
/// typing one does (#5497): the arrow was floored at one snap step.
#[test]
fn a_solid_pattern_spacing_arrow_dragged_past_zero_goes_negative() {
let mut h = Harness::new();
h.run(&json!([
{"call": "engine.execute", "params": {"command": "solid.box", "params": {"length": 10, "width": 10, "height": 10}}},
{"call": "ui.view", "params": {"view": "iso"}},
{"start": "solid.pattern.rectangular"},
{"click": {"world": [5, 5, 10]}},
{"call": "ui.dialogInput", "params": {"index": 1}},
{"click": {"axis": "X"}}
]))
.unwrap();
// Keep the arrow's tip clear of its value box, which the iso view pushes onto it at the
// viewport's edge.
h.call("ui.camera", json!({"target": [15, 5, 5]}));
h.settle();
let (at, dir) = crate::canvas::anchor(&h.app, h.app.dialog.as_ref().unwrap()).expect("an anchor");
let to = at - dir.expect("a direction") * 10.0;
h.step(&json!({"drag": [{"handle": "arrow"}, {"world": [to.x, to.y, to.z]}], "ctrl": true})).unwrap();
let (spacing, _) = spacings(&h);
let v = h.app.session.doc.eval(&spacing, solidcraft_engine::doc::expr::Kind::Length).unwrap();
assert!((v + 10.0).abs() < 0.5, "dragging 10 mm back from the start gave Spacing {spacing}");
// Applied, the copies sit on the negative side, as a typed negative spacing puts them.
h.step(&json!({"widget": "OK"})).unwrap();
assert!(h.app.dialog.is_none(), "{:?}", h.app.status);
let st = h.app.session.world_state();
for (copy, k) in [("Body1 (2)", 1.0), ("Body1 (3)", 2.0)] {
let x = st.body(copy).unwrap_or_else(|| panic!("no {copy}: {:?}", h.app.status)).mesh().bounds().center().x;
assert!((x - (5.0 + k * v)).abs() < 1e-6, "{copy} centred at x = {x} for Spacing {spacing}");
}
}