a770fa5a5e5f
annotative.rs
//! Annotative scaling (#468): annotative objects keep their paper size at every annotation
//! scale, show only at scales they support unless ANNOALLVISIBLE is 1, and the scale list,
//! OBJECTSCALE, ANNOAUTOSCALE and ANNOUPDATE manage the scales.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{AnnoDraw, Drawing, Entity, EntityKind, Handle, Space, entity_bounds};
use serde_json::{Value, json};
fn setvar(s: &mut Session, name: &str, value: Value) {
s.execute("setvar", &json!({ "name": name, "value": value })).unwrap();
}
/// A session whose current text style is annotative, with one text 0.25 high on paper.
fn with_text() -> (Session, Handle) {
let mut s = Session::new();
s.execute("style", &json!({ "name": "Notes", "annotative": true, "current": true })).unwrap();
let r = s.execute("text", &json!({ "at": [0, 0], "text": "NOTE", "height": 0.25 })).unwrap();
let h = Handle::parse_hex(r["handle"].as_str().unwrap()).unwrap();
(s, h)
}
fn entity(s: &Session, h: Handle) -> Entity {
(**s.doc().unwrap().entity(h).unwrap()).clone()
}
fn scales(s: &Session, h: Handle) -> Vec<String> {
entity(s, h).common.anno_scales.iter().map(|x| x.name.clone()).collect()
}
fn height(d: &Drawing, h: Handle) -> f64 {
let e = d.entity(h).unwrap();
entity_bounds(d, e, 0).height()
}
/// Height of what the renderer draws for `h` in model space.
fn drawn_height(d: &Drawing, h: Handle) -> Option<f64> {
let list = cadcraft_engine::render::build(d, &Space::Model, &Default::default());
let mut b = cadcraft_engine::geom::Bounds2::EMPTY;
for p in list.prims.iter().filter(|p| p.handle == h) {
for q in list.points(p) {
b.add(*q);
}
}
(!b.is_empty()).then(|| b.height())
}
#[test]
fn text_of_an_annotative_style_supports_the_current_scale() {
let (s, h) = with_text();
assert_eq!(scales(&s, h), ["1:1"]);
let mut s = s;
let p = s.execute("properties", &json!({ "handles": [h.hex()] })).unwrap();
assert_eq!(p["objects"][0]["annotative"], json!(true), "{p}");
assert_eq!(p["objects"][0]["annotativeScales"], json!(["1:1"]), "{p}");
// A plain style makes plain text.
let mut s = Session::new();
let r = s.execute("text", &json!({ "at": [0, 0], "text": "X", "height": 0.25 })).unwrap();
let h = Handle::parse_hex(r["handle"].as_str().unwrap()).unwrap();
assert!(scales(&s, h).is_empty());
}
#[test]
fn annotative_text_draws_at_paper_height_times_the_scale() {
let (mut s, h) = with_text();
let at_1 = drawn_height(s.doc().unwrap(), h).unwrap();
setvar(&mut s, "CANNOSCALE", json!("1:50"));
s.execute("objectscale", &json!({ "handles": [h.hex()], "add": "1:50" })).unwrap();
assert_eq!(scales(&s, h), ["1:1", "1:50"]);
let at_50 = drawn_height(s.doc().unwrap(), h).unwrap();
assert!((at_50 / at_1 - 50.0).abs() < 1e-6, "{at_1} โ {at_50}");
// Bounds (zoom, selection) follow the drawn size; the stored height stays the paper height.
assert!((height(s.doc().unwrap(), h) / at_50 - 1.0).abs() < 0.5);
match entity(&s, h).kind {
EntityKind::Text(t) => assert_eq!(t.height, 0.25),
k => panic!("{k:?}"),
}
}
#[test]
fn unsupported_scale_hides_unless_annoallvisible() {
let (mut s, h) = with_text();
setvar(&mut s, "CANNOSCALE", json!("1:20"));
// ANNOALLVISIBLE 1 (the default): shown, at the object's own scale.
assert_eq!(s.doc().unwrap().anno_draw(&entity(&s, h)), AnnoDraw::Scaled(1.0));
assert!(drawn_height(s.doc().unwrap(), h).is_some());
s.execute("annovisible.current", &json!({})).unwrap();
assert_eq!(s.doc().unwrap().header.i64("ANNOALLVISIBLE", 1), 0);
assert_eq!(drawn_height(s.doc().unwrap(), h), None);
assert!(entity_bounds(s.doc().unwrap(), &entity(&s, h), 0).is_empty());
// Back at a supported scale it shows again.
setvar(&mut s, "CANNOSCALE", json!("1:1"));
assert!(drawn_height(s.doc().unwrap(), h).is_some());
s.execute("annovisible.toggle", &json!({})).unwrap();
assert_eq!(s.doc().unwrap().header.i64("ANNOALLVISIBLE", 0), 1);
}
#[test]
fn annoautoscale_adds_the_new_scale() {
let (mut s, h) = with_text();
setvar(&mut s, "ANNOAUTOSCALE", json!(4));
setvar(&mut s, "CANNOSCALE", json!("1:10"));
assert_eq!(scales(&s, h), ["1:1", "1:10"]);
let v = s.execute("getvar", &json!({ "name": "CANNOSCALEVALUE" })).unwrap();
assert!((v["value"].as_f64().unwrap() - 0.1).abs() < 1e-12, "{v}");
assert!(s.execute("setvar", &json!({ "name": "CANNOSCALEVALUE", "value": 1 })).is_err());
setvar(&mut s, "ANNOAUTOSCALE", json!(-4));
setvar(&mut s, "CANNOSCALE", json!("1:20"));
assert_eq!(scales(&s, h), ["1:1", "1:10"]);
// A scale that isn't in the list is refused.
assert!(s.execute("setvar", &json!({ "name": "CANNOSCALE", "value": "1:7" })).is_err());
assert!(s.execute("setvar", &json!({ "name": "CANNOSCALE", "value": 7 })).is_err());
}
#[test]
fn add_and_delete_current_scale_keep_one_scale() {
let (mut s, h) = with_text();
setvar(&mut s, "CANNOSCALE", json!("1:4"));
s.execute("aiobjectscaleadd", &json!({ "handles": [h.hex()] })).unwrap();
assert_eq!(scales(&s, h), ["1:1", "1:4"]);
s.execute("aiobjectscaleremove", &json!({ "handles": [h.hex()] })).unwrap();
assert_eq!(scales(&s, h), ["1:1"]);
// The last scale stays.
setvar(&mut s, "CANNOSCALE", json!("1:1"));
let r = s.execute("aiobjectscaleremove", &json!({ "handles": [h.hex()] })).unwrap();
assert_eq!(scales(&s, h), ["1:1"]);
assert!(r["message"].as_str().unwrap().contains("only scale"), "{r}");
assert!(s.execute("objectscale", &json!({ "handles": [h.hex()], "add": "no such" })).is_err());
}
#[test]
fn objectscale_at_the_command_line() {
let (mut s, h) = with_text();
// The pickfirst selection is used.
s.set_selection(vec![h]);
s.script("-OBJECTSCALE\nA\n1:2\nA\n1:8\nD\n1:1\n\n").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
assert_eq!(scales(&s, h), ["1:2", "1:8"]);
}
#[test]
fn scale_list_add_delete_reset() {
let (mut s, h) = with_text();
let r = s.execute("scalelistedit", &json!({ "add": { "name": "Site", "ratio": "1:250" } })).unwrap();
assert!(r["scales"].as_array().unwrap().iter().any(|x| x["name"] == "Site" && x["drawingUnits"] == 250.0), "{r}");
assert!(s.execute("scalelistedit", &json!({ "add": { "name": "site", "ratio": "1:3" } })).is_err());
assert!(s.execute("scalelistedit", &json!({ "add": { "name": "Bad", "ratio": "0:3" } })).is_err());
assert!(s.execute("scalelistedit", &json!({ "add": { "name": "Bad", "paperUnits": 1, "drawingUnits": -2 } })).is_err());
// In use by the text, or current: can't be deleted.
s.execute("objectscale", &json!({ "handles": [h.hex()], "add": "Site" })).unwrap();
assert!(s.execute("scalelistedit", &json!({ "delete": "Site" })).is_err());
assert!(s.execute("scalelistedit", &json!({ "delete": "1:1" })).is_err());
s.execute("scalelistedit", &json!({ "delete": "1:100" })).unwrap();
assert!(s.doc().unwrap().anno_scale("1:100").is_none());
// Reset brings the defaults back and keeps scales in use.
let r = s.execute("scalelistedit", &json!({ "reset": "metric" })).unwrap();
let names: Vec<&str> = r["scales"].as_array().unwrap().iter().filter_map(|x| x["name"].as_str()).collect();
assert!(names.contains(&"1:100") && names.contains(&"Site") && !names.iter().any(|n| n.contains('"')), "{names:?}");
let r = s.execute("scalelistedit", &json!({ "reset": "imperial" })).unwrap();
assert!(r["scales"].as_array().unwrap().iter().any(|x| x["name"] == "1/4\" = 1'-0\"" && x["drawingUnits"] == 12.0));
}
#[test]
fn scalelistedit_at_the_command_line() {
let mut s = Session::new();
s.script("-SCALELISTEDIT\nA\nDetail\n5:1\nD\n1:16\nE\n").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
let d = s.doc().unwrap();
let detail = d.anno_scale("detail").unwrap();
assert_eq!((detail.paper_units, detail.drawing_units), (5.0, 1.0));
assert!(d.anno_scale("1:16").is_none());
// Bad input is reported, not fatal.
s.script("-SCALELISTEDIT\nA\nOdd\nfoo\n1:3\nD\nnothing\n\n").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
assert_eq!(s.doc().unwrap().anno_scale("Odd").map(|x| x.drawing_units), Some(3.0));
s.script("-SCALELISTEDIT\nR\nY\nX\n\n").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
assert!(s.doc().unwrap().anno_scale("1:16").is_some(), "reset restores the defaults");
assert!(s.doc().unwrap().anno_scale("Odd").is_none(), "an unused scale goes");
}
#[test]
fn annotative_dimension_scales_its_text_and_arrows() {
let mut s = Session::new();
s.execute("dimstyle", &json!({ "name": "Anno", "annotative": true, "current": true })).unwrap();
let r = s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [100, 0], "at": [50, 20] })).unwrap();
let h = Handle::parse_hex(r["handle"].as_str().or_else(|| r["handles"][0].as_str()).unwrap()).unwrap();
assert_eq!(scales(&s, h), ["1:1"]);
let at_1 = drawn_height(s.doc().unwrap(), h).unwrap();
s.execute("scalelistedit", &json!({ "add": { "name": "1:3", "ratio": "1:3" } })).ok();
setvar(&mut s, "ANNOAUTOSCALE", json!(1));
setvar(&mut s, "CANNOSCALE", json!("1:4"));
let at_4 = drawn_height(s.doc().unwrap(), h).unwrap();
// The dimension stays 20 tall between its points and dimension line; the extension line
// offset and overshoot (DIMEXO, DIMEXE) are 4ร their paper size.
assert!(((at_4 - 20.0) / (at_1 - 20.0) - 4.0).abs() < 1e-6, "{at_1} โ {at_4}");
}
#[test]
fn annotative_multileader_and_hatch() {
let mut s = Session::new();
s.execute("mleaderstyle", &json!({ "name": "Anno", "annotative": true })).unwrap();
let r = s.execute("mleader", &json!({ "points": [[0, 0], [5, 5]], "text": "A" })).unwrap();
let ml = Handle::parse_hex(r["handle"].as_str().unwrap()).unwrap();
assert_eq!(scales(&s, ml), ["1:1"]);
setvar(&mut s, "HPANNOTATIVE", json!(1));
s.execute("rectang", &json!({ "p1": [20, 0], "p2": [30, 10] })).unwrap();
let r = s.execute("hatch", &json!({ "points": [[25, 5]], "pattern": "ANSI31" })).unwrap();
let hh = r["handle"].as_str().or_else(|| r["handles"][0].as_str()).and_then(Handle::parse_hex).unwrap();
assert_eq!(scales(&s, hh), ["1:1"]);
// At 1:2 the hatch pattern doubles: fewer, longer lines over the same area.
let count = |s: &Session| {
let d = s.doc().unwrap();
let list = cadcraft_engine::render::build(d, &Space::Model, &Default::default());
list.prims.iter().filter(|p| p.handle == hh).count()
};
let n1 = count(&s);
setvar(&mut s, "ANNOAUTOSCALE", json!(1));
setvar(&mut s, "CANNOSCALE", json!("1:2"));
let n2 = count(&s);
assert!(n2 < n1, "{n1} โ {n2}");
}
#[test]
fn explode_gives_plain_objects_at_the_current_scale() {
let (mut s, h) = with_text();
s.execute("objectscale", &json!({ "handles": [h.hex()], "add": "1:10" })).unwrap();
setvar(&mut s, "CANNOSCALE", json!("1:10"));
// Text doesn't explode; a block reference of an annotative block does.
s.execute("block", &json!({ "name": "TAG", "base": [0, 0], "handles": [h.hex()], "annotative": true })).unwrap();
let ins = s.doc().unwrap().model.last().unwrap().handle;
assert_eq!(scales(&s, ins), ["1:10"]);
s.execute("explode", &json!({ "handles": [ins.hex()] })).unwrap();
let d = s.doc().unwrap();
let t = d.model.iter().find(|e| matches!(e.kind, EntityKind::Text(_))).unwrap();
match &t.kind {
EntityKind::Text(t) => assert!((t.height - 2.5).abs() < 1e-9, "{}", t.height),
_ => unreachable!(),
}
}
#[test]
fn annoupdate_and_properties_follow_the_style() {
let mut s = Session::new();
s.execute("style", &json!({ "name": "Notes", "current": true })).unwrap();
let r = s.execute("text", &json!({ "at": [0, 0], "text": "N", "height": 0.25 })).unwrap();
let h = Handle::parse_hex(r["handle"].as_str().unwrap()).unwrap();
assert!(scales(&s, h).is_empty());
s.execute("style", &json!({ "name": "Notes", "annotative": true })).unwrap();
s.execute("annoupdate", &json!({ "handles": [h.hex()] })).unwrap();
assert_eq!(scales(&s, h), ["1:1"]);
s.execute("properties.set", &json!({ "handles": [h.hex()], "annotative": false })).unwrap();
assert!(scales(&s, h).is_empty());
s.execute("properties.set", &json!({ "handles": [h.hex()], "annotative": true })).unwrap();
assert_eq!(scales(&s, h), ["1:1"]);
let r = s.execute("annoreset", &json!({ "handles": [h.hex()] })).unwrap();
assert_eq!(r["objects"], 1);
// Lines can't be annotative.
let r = s.execute("line", &json!({ "points": [[0, 0], [1, 1]] })).unwrap();
let l = r["handles"][0].as_str().or_else(|| r["handle"].as_str()).and_then(Handle::parse_hex).unwrap();
s.execute("properties.set", &json!({ "handles": [l.hex()], "annotative": true })).unwrap();
assert!(scales(&s, l).is_empty());
}
#[test]
fn hostile_parameters_are_refused() {
let (mut s, h) = with_text();
for p in [
json!({ "handles": [h.hex()], "add": 5 }),
json!({ "handles": [h.hex()], "delete": [1, 2] }),
json!({ "handles": "x" }),
json!({ "handles": [] }),
] {
assert!(s.execute("objectscale", &p).is_err(), "{p}");
}
for p in [
json!({ "add": { "name": "", "ratio": "1:2" } }),
json!({ "add": { "name": "x", "ratio": "1:inf" } }),
json!({ "add": { "name": "x", "paperUnits": 1e308, "drawingUnits": 1e-308 } }),
json!({ "add": "1:2" }),
json!({ "reset": 3 }),
json!({ "delete": "missing" }),
] {
assert!(s.execute("scalelistedit", &p).is_err(), "{p}");
}
}
#[test]
fn annotative_mtext_columns_follow_the_scale() {
// #708: at 1:2, two columns 10 wide with a gutter of 1 and a height of 20 on paper draw 20
// wide, 2 apart and 40 tall: the box is 42 ร 40, not 41 ร 20.
let mut s = Session::new();
setvar(&mut s, "CANNOSCALE", json!("1:2"));
let r = s
.execute(
"mtext",
&json!({ "at": [0, 0], "height": 1, "width": 10, "text": "a\\Pb\\Pc", "columns": { "type": "static", "count": 2, "gutter": 1, "height": 20 } }),
)
.unwrap();
let h = Handle::parse_hex(r["handle"].as_str().unwrap()).unwrap();
s.execute("properties.set", &json!({ "handles": [h.hex()], "annotative": true })).unwrap();
assert_eq!(scales(&s, h), ["1:2"]);
let v = |s: &mut Session, name: &str| s.execute("getvar", &json!({ "name": name })).unwrap()["value"].clone();
assert_eq!(v(&mut s, "EXTMIN"), json!([0.0, -40.0, 0.0]));
assert_eq!(v(&mut s, "EXTMAX"), json!([42.0, 0.0, 0.0]));
// Dynamic columns with manual heights, and the text of a multileader, scale the same way.
let mut e = entity(&s, h);
if let EntityKind::MText(t) = &mut e.kind
&& let Some(c) = &mut t.columns
{
c.heights = vec![3.0, 5.0];
}
let mtext = match &e.kind {
EntityKind::MText(t) => t.clone(),
k => panic!("{k:?}"),
};
let ml = Entity {
kind: EntityKind::MLeader(cadcraft_engine::doc::MLeader {
leaders: Vec::new(),
landing: Default::default(),
dogleg: 1.0,
text: Some(mtext),
style: "Standard".into(),
arrow_size: 1.0,
spline: false,
block: None,
}),
..e.clone()
};
for e in [e, ml] {
let t = match cadcraft_engine::doc::anno_scaled(&e, 2.0).kind {
EntityKind::MText(t) => t,
EntityKind::MLeader(m) => m.text.unwrap(),
k => panic!("{k:?}"),
};
let c = t.columns.unwrap();
assert_eq!((t.height, t.width, c.count, c.gutter, c.height, c.heights), (2.0, 20.0, 2, 2.0, 40.0, vec![6.0, 10.0]));
}
}
No file is open. Choose one in the tree, or press Ctrl+O (โO on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.