phanoob
dd7790a43f
A sketch text gets an optional style: bold and italic faces (a slanted fallback for italic), left/center/right alignment, letter and line spacing, and a path curve of the same sketch for the baseline to follow (reverse takes the other side). Edit Text gets B/I toggles, alignment, spacing fields and a Path chip, all live. The style is saved only when not plain and is noted under format 18.
217 lines
11 KiB
Rust
217 lines
11 KiB
Rust
use super::*;
|
|
|
|
fn run(s: &mut Session, cmd: &str, params: Value) -> Value {
|
|
s.execute(cmd, ¶ms).unwrap()
|
|
}
|
|
|
|
fn setup() -> (Session, String, String) {
|
|
let mut s = Session::default();
|
|
run(&mut s, "sketch.create", json!({"plane":"XY"}));
|
|
let result = run(&mut s, "sketch.text", json!({"text":"II","at":[3,4],"height":10,"angle":15}));
|
|
(s, result["link"].as_str().unwrap().into(), result["curves"][0].as_str().unwrap().into())
|
|
}
|
|
|
|
#[test]
|
|
fn text_move_updates_the_source_once_preserves_ids_and_roundtrips() {
|
|
let (mut s, link, curve) = setup();
|
|
let before = s.doc.to_json();
|
|
let ids: Vec<_> = s.doc.sketch(1).unwrap().curves.iter().map(|c| c.id.clone()).collect();
|
|
let undo = s.undo.len();
|
|
run(&mut s, "sketch.move", json!({"entities":[curve,ids[1]],"translate":[10,-2],"center":[3,4],"angle":30}));
|
|
let sk = s.doc.sketch(1).unwrap();
|
|
assert_eq!(sk.curves.iter().map(|c| c.id.clone()).collect::<Vec<_>>(), ids);
|
|
let LinkSource::Text { at, angle, text, height, font, .. } = &sk.link(&link).unwrap().source else { panic!() };
|
|
assert!(at.dist(Vec2::new(13.0, 2.0)) < 1e-9);
|
|
assert!((*angle - 45_f64.to_radians()).abs() < 1e-12);
|
|
assert_eq!((text.as_str(), *height, font), ("II", 10.0, &None));
|
|
assert_eq!(s.undo.len(), undo + 1);
|
|
let moved = s.doc.to_json();
|
|
let reopened = solidcraft_doc::Document::from_json(&moved).unwrap();
|
|
assert_eq!(reopened.to_json(), moved);
|
|
run(&mut s, "edit.undo", json!({}));
|
|
assert_eq!(s.doc.to_json(), before);
|
|
run(&mut s, "edit.redo", json!({}));
|
|
assert_eq!(s.doc.to_json(), moved);
|
|
}
|
|
|
|
#[test]
|
|
fn text_copy_is_a_new_editable_source_and_original_is_unchanged() {
|
|
let (mut s, link, curve) = setup();
|
|
let original = s.doc.sketch(1).unwrap().link(&link).unwrap().source.clone();
|
|
let result = run(&mut s, "sketch.move", json!({"entities":[curve],"translate":[20,0],"copy":true}));
|
|
let copied_curve = result["curves"][0].as_str().unwrap();
|
|
let new_link = text_link(s.doc.sketch(1).unwrap(), copied_curve).unwrap().to_owned();
|
|
assert_ne!(new_link, link);
|
|
run(&mut s, "sketch.edit_text", json!({"link":new_link,"text":"O"}));
|
|
assert_eq!(s.doc.sketch(1).unwrap().link(&link).unwrap().source, original);
|
|
}
|
|
|
|
#[test]
|
|
fn text_drag_moves_all_letters_and_rebuilds_downstream_on_release() {
|
|
let (mut s, link, curve) = setup();
|
|
run(&mut s, "sketch.finish", json!({}));
|
|
run(&mut s, "solid.extrude", json!({"distance":3}));
|
|
run(&mut s, "sketch.edit", json!({"sketch":1}));
|
|
let sk = s.doc.sketch(1).unwrap();
|
|
let before = sk.link_points(&link).into_iter().map(|i| (i, sk.point(i).unwrap())).collect::<Vec<_>>();
|
|
for frame in 0..3 {
|
|
let result = run(&mut s, "sketch.drag", json!({"entity":curve,"from":[frame,0],"to":[frame+1,1],"live":true}));
|
|
assert_eq!(result["reached"], 1.0);
|
|
assert!(s.model.is_stale());
|
|
}
|
|
run(&mut s, "sketch.drag_end", json!({}));
|
|
assert!(!s.model.is_stale());
|
|
assert!(s.model.result(2).is_some_and(|r| r.error.is_none()));
|
|
let sk = s.doc.sketch(1).unwrap();
|
|
for (i, old) in before {
|
|
assert!(sk.point(i).unwrap().dist(old + Vec2::new(3.0, 3.0)) < 1e-8);
|
|
}
|
|
assert!(matches!(sk.link(&link).unwrap().source, LinkSource::Text { .. }));
|
|
}
|
|
|
|
#[test]
|
|
fn live_text_resize_follows_each_frame_and_rebuilds_downstream_on_release() {
|
|
let (mut s, link, _) = setup();
|
|
run(&mut s, "sketch.finish", json!({}));
|
|
run(&mut s, "solid.extrude", json!({"distance":3}));
|
|
run(&mut s, "sketch.edit", json!({"sketch":1}));
|
|
let curves = s.doc.sketch(1).unwrap().link_curves(&link).len();
|
|
for (frame, height) in [12.0, 16.0, 20.0].into_iter().enumerate() {
|
|
let at = Vec2::new(3.0 - frame as f64, 4.0);
|
|
run(&mut s, "sketch.edit_text", json!({"link":link,"at":[at.x,at.y],"height":height,"angle":-10,"live":true}));
|
|
assert!(s.model.is_stale(), "a live frame leaves the features after the sketch as they were");
|
|
let sk = s.doc.sketch(1).unwrap();
|
|
let LinkSource::Text { at: now, height: h, angle, text, .. } = &sk.link(&link).unwrap().source else { panic!() };
|
|
assert!(now.dist(at) < 1e-12);
|
|
assert_eq!((*h, text.as_str()), (height, "II"));
|
|
assert!((*angle + 10_f64.to_radians()).abs() < 1e-12);
|
|
// Same letters, same outlines: what references them keeps working.
|
|
assert_eq!(sk.link_curves(&link).len(), curves);
|
|
let shown = s.world_state();
|
|
assert!(shown.sketch(1).unwrap().profiles.len() >= 2, "the sketch shown follows the frame");
|
|
}
|
|
run(&mut s, "sketch.drag_end", json!({}));
|
|
assert!(!s.model.is_stale());
|
|
assert!(s.model.result(2).is_some_and(|r| r.error.is_none()));
|
|
}
|
|
|
|
#[test]
|
|
fn live_text_edit_rejects_bad_values_and_leaves_the_design_as_it_was() {
|
|
let (mut s, link, _) = setup();
|
|
let before = s.doc.to_json();
|
|
let undo = s.undo.len();
|
|
for params in [
|
|
json!({"link":link,"height":0,"live":true}),
|
|
json!({"link":link,"height":-3,"live":true}),
|
|
json!({"link":link,"height":2e5,"live":true}),
|
|
json!({"link":"no-such-link","height":5,"live":true}),
|
|
json!({"height":5,"live":true}),
|
|
] {
|
|
assert!(s.execute("sketch.edit_text", ¶ms).is_err(), "{params}");
|
|
assert_eq!(s.doc.to_json(), before);
|
|
assert_eq!(s.undo.len(), undo);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn text_move_in_a_rotated_component_preserves_font_and_local_coordinates() {
|
|
let mut s = Session::default();
|
|
let component = run(&mut s, "component.create", json!({"name":"Label"}));
|
|
run(&mut s, "occurrence.move", json!({"occurrence":component["occurrence"],"translate":[30,20,10],"axis":[0,0,1],"angle":90}));
|
|
let created = run(&mut s, "sketch.create", json!({"plane":"XY"}));
|
|
let sid = created["sketch"].as_u64().unwrap();
|
|
let result = run(&mut s, "sketch.text", json!({"text":"I","at":[0,0],"height":10,"font":solidcraft_sketch::DEFAULT_FONT_FAMILY}));
|
|
let link = result["link"].as_str().unwrap();
|
|
let before = s.world_state().sketch(sid).unwrap().plane;
|
|
run(&mut s, "sketch.move", json!({"entities":[result["curves"][0]],"translate":[5,2]}));
|
|
let sk = s.doc.sketch(sid).unwrap();
|
|
let LinkSource::Text { at, font, .. } = &sk.link(link).unwrap().source else { panic!() };
|
|
assert!(at.dist(Vec2::new(5.0, 2.0)) < 1e-9);
|
|
assert_eq!(font.as_deref(), Some(solidcraft_sketch::DEFAULT_FONT_FAMILY));
|
|
let state = s.world_state();
|
|
assert!(state.sketch(sid).unwrap().plane.to_world(*at).dist(before.to_world(Vec2::new(5.0, 2.0))) < 1e-9);
|
|
let reopened = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap());
|
|
assert_eq!(reopened.doc.sketch(sid).unwrap().link(link).unwrap().source, sk.link(link).unwrap().source);
|
|
}
|
|
|
|
#[test]
|
|
fn text_move_rejects_malformed_values_without_changing_history() {
|
|
let (mut s, _, curve) = setup();
|
|
let before = s.doc.to_json();
|
|
let undo = s.undo.len();
|
|
for params in [
|
|
json!({"entities":[curve],"translate":[1]}),
|
|
json!({"entities":[curve],"angle":"invalid"}),
|
|
json!({"entity":curve,"from":[0,0],"to":["invalid",2]}),
|
|
] {
|
|
let cmd = if params.get("entity").is_some() { "sketch.drag" } else { "sketch.move" };
|
|
assert!(s.execute(cmd, ¶ms).is_err());
|
|
assert_eq!(s.doc.to_json(), before);
|
|
assert_eq!(s.undo.len(), undo);
|
|
}
|
|
}
|
|
|
|
/// The box around the solved outlines of text `link` in sketch 1: (min, max).
|
|
fn text_box(s: &Session, link: &str) -> (Vec2, Vec2) {
|
|
let state = s.world_state();
|
|
let sk = &state.sketch(1).unwrap().sketch;
|
|
let pts: Vec<Vec2> = sk.link_curves(link).into_iter().flat_map(|ci| sk.polyline(ci)).collect();
|
|
let lo = pts.iter().fold(Vec2::new(f64::MAX, f64::MAX), |m, p| Vec2::new(m.x.min(p.x), m.y.min(p.y)));
|
|
let hi = pts.iter().fold(Vec2::new(f64::MIN, f64::MIN), |m, p| Vec2::new(m.x.max(p.x), m.y.max(p.y)));
|
|
(lo, hi)
|
|
}
|
|
|
|
#[test]
|
|
fn text_on_a_path_follows_its_curve_when_the_curve_moves() {
|
|
let mut s = Session::default();
|
|
run(&mut s, "sketch.create", json!({"plane":"XY"}));
|
|
// (Away from the origin, which would hold a line's end.)
|
|
let line = run(&mut s, "sketch.line", json!({"points":[[0,-30],[80,-30]]}))["curves"][0].as_str().unwrap().to_string();
|
|
let t = run(&mut s, "sketch.text", json!({"text":"HH","at":[5,5],"height":10,"angle":30,"path":line,"align":"center"}));
|
|
let link = t["link"].as_str().unwrap().to_string();
|
|
// Centred on the line's middle, standing on it; `at` and the angle do not place it.
|
|
let (lo, hi) = text_box(&s, &link);
|
|
assert!(((lo.x + hi.x) / 2.0 - 40.0).abs() < 0.05 && (lo.y + 30.0).abs() < 1e-6 && (hi.y + 20.0).abs() < 0.05, "{lo:?} {hi:?}");
|
|
// The line moves up 20 mm: the text with it.
|
|
run(&mut s, "sketch.move", json!({"entities":[line],"translate":[0,20]}));
|
|
let (lo, hi) = text_box(&s, &link);
|
|
assert!((lo.y + 10.0).abs() < 1e-6 && ((lo.x + hi.x) / 2.0 - 40.0).abs() < 0.05, "{lo:?} {hi:?}");
|
|
// It is moved with its curve, not on its own.
|
|
let outline = s.doc.sketch(1).unwrap().curves.iter().find(|c| c.link.as_deref() == Some(link.as_str())).unwrap().id.clone();
|
|
let e = s.execute("sketch.move", &json!({"entities":[outline],"translate":[5,0]})).unwrap_err().to_string();
|
|
assert!(e.contains("follows its curve"), "{e}");
|
|
// Off the path again: at `at`, turned by its angle.
|
|
run(&mut s, "sketch.edit_text", json!({"link":link,"path":"","align":"left"}));
|
|
let (lo, _) = text_box(&s, &link);
|
|
assert!(lo.x > 0.0 && lo.y > 4.0 && lo.y < 6.0, "{lo:?}");
|
|
// A design with styled text reads back the same.
|
|
let saved = s.doc.to_json();
|
|
assert_eq!(solidcraft_doc::Document::from_json(&saved).unwrap().to_json(), saved);
|
|
}
|
|
|
|
#[test]
|
|
fn text_style_parameters_are_checked() {
|
|
let (mut s, link, _) = setup();
|
|
for (params, error) in [
|
|
(json!({"link":link,"bold":true}), "no bold face"),
|
|
(json!({"link":link,"bold":"yes"}), "`bold` must be true or false"),
|
|
(json!({"link":link,"align":"justify"}), "`align` must be left, center or right"),
|
|
(json!({"link":link,"line_spacing":0}), "`line_spacing` must be a positive factor"),
|
|
(json!({"link":link,"letter_spacing":"wide"}), "`letter_spacing` must be a length"),
|
|
(json!({"link":link,"path":"no-such-curve"}), "not a curve of this sketch"),
|
|
] {
|
|
let before = s.doc.to_json();
|
|
let e = s.execute("sketch.edit_text", ¶ms).unwrap_err().to_string();
|
|
assert!(e.contains(error), "{params}: {e}");
|
|
assert_eq!(s.doc.to_json(), before);
|
|
}
|
|
run(&mut s, "sketch.edit_text", json!({"link":link,"italic":true,"align":"right","letter_spacing":1.5,"line_spacing":1.2}));
|
|
let LinkSource::Text { style, text, .. } = &s.doc.sketch(1).unwrap().link(&link).unwrap().source else { panic!() };
|
|
assert_eq!(text, "II");
|
|
assert!(style.italic && style.align == solidcraft_sketch::TextAlign::Right && style.letter_spacing == 1.5 && style.line_spacing == 1.2);
|
|
// Left out, a style stays.
|
|
run(&mut s, "sketch.edit_text", json!({"link":link,"text":"I"}));
|
|
let LinkSource::Text { style, .. } = &s.doc.sketch(1).unwrap().link(&link).unwrap().source else { panic!() };
|
|
assert!(style.italic && style.letter_spacing == 1.5);
|
|
}
|