a770fa5a5e5f
pdf_layers.rs
//! PDF export with layers, several sheets and hyperlinks (issue #560): drawing layers become
//! optional content groups, `layouts` plots several sheets into one file with page labels, and
//! linked entities get link annotations. The tests read the written file back.
use cadcraft_color::Color;
use cadcraft_doc::{Block, Common, Drawing, Entity, EntityKind, Handle, Insert, Layer, Line, Space, Viewport};
use cadcraft_geom::{Vec2, Vec3};
use cadcraft_io::pdf::{MAX_PAGES, pdf_sheets};
use cadcraft_io::{PdfOptions, plot};
use serde_json::json;
use crate::pdf_read::{self, Doc};
fn read(bytes: &[u8]) -> Doc {
pdf_read::read(bytes)
}
fn ocg_names(doc: &Doc) -> Vec<String> {
doc.ocgs.iter().map(|g| g.name.clone()).collect()
}
/// The `BDC` marks of a content: the property resource each one names.
fn marks(content: &str) -> Vec<String> {
pdf_read::ops(content).into_iter().filter(|o| o.op == "BDC").filter_map(|o| o.names.get(1).cloned()).collect()
}
fn add_line(d: &mut Drawing, space: &Space, layer: &str, a: (f64, f64), b: (f64, f64)) -> Handle {
let line = EntityKind::Line(Line { a: Vec3::new(a.0, a.1, 0.0), b: Vec3::new(b.0, b.1, 0.0) });
d.add(space, Common { layer: layer.into(), ..Default::default() }, line).unwrap()
}
/// Lines on layers "0", "Walls" (red), "Notes" (off) and "Hidden" (frozen), and a block
/// reference on "Doors" whose contents are on layer 0.
fn layered() -> Drawing {
let mut d = Drawing::new_metric();
d.layers.push(Layer { name: "Walls".into(), color: Color::Index(1), ..Layer::default() });
d.layers.push(Layer { name: "Notes".into(), on: false, ..Layer::default() });
d.layers.push(Layer { name: "Hidden".into(), frozen: true, ..Layer::default() });
d.layers.push(Layer { name: "Doors".into(), ..Layer::default() });
add_line(&mut d, &Space::Model, "0", (0.0, 0.0), (100.0, 0.0));
add_line(&mut d, &Space::Model, "Walls", (0.0, 10.0), (100.0, 10.0));
add_line(&mut d, &Space::Model, "Notes", (0.0, 20.0), (100.0, 20.0));
add_line(&mut d, &Space::Model, "Hidden", (0.0, 30.0), (100.0, 30.0));
let leaf = EntityKind::Line(Line { a: Vec3::new(0.0, 0.0, 0.0), b: Vec3::new(5.0, 5.0, 0.0) });
let mut blk = Block::new("DOOR");
blk.entities.push(Entity::new(Handle(0x900), leaf));
d.blocks.insert(blk.name.clone(), std::sync::Arc::new(blk));
let ins = Insert {
block: "DOOR".into(),
insert: Vec3::new(50.0, 40.0, 0.0),
scale: Vec3::new(1.0, 1.0, 1.0),
rotation: 0.0,
attribs: Vec::new(),
cols: 1,
rows: 1,
col_spacing: 0.0,
row_spacing: 0.0,
clip: None,
};
d.add(&Space::Model, Common { layer: "Doors".into(), ..Default::default() }, EntityKind::Insert(ins)).unwrap();
d
}
fn raw(extra: serde_json::Value) -> serde_json::Value {
let mut o = json!({"compress": false});
if let (Some(m), Some(e)) = (o.as_object_mut(), extra.as_object()) {
m.extend(e.clone());
}
o
}
#[test]
fn drawing_layers_become_pdf_layers() {
let d = layered();
let doc = read(&plot(&d, &Space::Model, &raw(json!({}))).unwrap());
// Plotted layers only, in drawing order of first use; block contents on layer 0 are on
// the block reference's layer. None starts hidden.
assert_eq!(ocg_names(&doc), ["0", "Walls", "Doors"]);
assert!(doc.ocgs.iter().all(|g| !g.off));
// One sheet: the viewer opens with its layer panel.
assert_eq!(doc.page_mode.as_deref(), Some("UseOC"));
// The page maps its marks to the groups, and the marked sections are balanced.
let page = &doc.pages[0];
let groups: Vec<&str> = page.properties.iter().map(|(_, g)| g.as_str()).collect();
for n in ["0", "Walls", "Doors"] {
assert!(groups.contains(&n), "{n} in {groups:?}");
}
let c = &page.content;
assert_eq!(pdf_read::count(c, "BDC"), pdf_read::count(c, "EMC"));
for m in marks(c) {
assert!(page.properties.iter().any(|(k, _)| *k == m), "mark {m} is a page property");
}
// The red wall line is on Walls.
let walls = page.properties.iter().find(|(_, g)| g == "Walls").map(|(k, _)| k.clone()).unwrap();
let ops = pdf_read::ops(c);
let at = ops.iter().position(|o| o.op == "BDC" && o.names.get(1) == Some(&walls)).unwrap();
let next = ops[at..].iter().find(|o| o.op == "RG").unwrap();
assert_eq!(next.nums, [1.0, 0.0, 0.0], "{c}");
// Marked content inside the clip's q/Q.
let first_bdc = ops.iter().position(|o| o.op == "BDC").unwrap();
let last_emc = ops.iter().rposition(|o| o.op == "EMC").unwrap();
let clip = ops.iter().position(|o| o.op == "W").unwrap();
let last_q = ops.iter().rposition(|o| o.op == "Q").unwrap();
assert!(clip < first_bdc && last_emc < last_q, "marked content inside the clip's q/Q");
}
#[test]
fn layers_that_are_off_are_included_hidden_on_request() {
let d = layered();
let doc = read(&plot(&d, &Space::Model, &raw(json!({"offLayers": true}))).unwrap());
let names = ocg_names(&doc);
assert!(names.contains(&"Notes".to_string()) && !names.contains(&"Hidden".to_string()), "{names:?}");
let off: Vec<&str> = doc.ocgs.iter().filter(|g| g.off).map(|g| g.name.as_str()).collect();
assert_eq!(off, ["Notes"]);
// Without layers, no optional content at all.
let flat = read(&plot(&d, &Space::Model, &raw(json!({"layers": false}))).unwrap());
assert!(flat.ocgs.is_empty() && flat.page_mode.is_none());
assert_eq!(pdf_read::count(flat.content(), "BDC"), 0);
}
#[test]
fn layers_that_are_off_are_plotted_only_on_request() {
let d = layered();
let strokes = |o: serde_json::Value| {
let doc = read(&plot(&d, &Space::Model, &raw(o)).unwrap());
pdf_read::drawn(doc.content()).iter().filter(|o| o.op == "m").count()
};
// By default Notes (off) and Hidden (frozen) aren't drawn: the four lines less those two,
// plus the door.
let plain = strokes(json!({}));
assert_eq!(plain, 3, "lines on 0 and Walls, and the door leaf");
// `offLayers` adds Notes (on a hidden PDF layer), never the frozen layer; it needs PDF layers.
assert_eq!(strokes(json!({"offLayers": true})), 4);
assert_eq!(strokes(json!({"layers": false, "offLayers": true})), plain);
}
#[test]
fn viewport_contents_keep_their_layers() {
let mut d = layered();
let paper = Space::Paper("Layout1".into());
let vp = Viewport {
center: Vec3::new(150.0, 100.0, 0.0),
width: 200.0,
height: 150.0,
view_center: Vec2::new(50.0, 20.0),
view_height: 80.0,
id: 2,
locked: false,
frozen_layers: vec!["Walls".into()],
layer_colors: Vec::new(),
clip: None,
on: true,
twist: 0.0,
};
d.add(&paper, Common { layer: "Viewports".into(), ..Default::default() }, EntityKind::Viewport(vp)).unwrap();
add_line(&mut d, &paper, "Title", (10.0, 10.0), (50.0, 10.0));
let names = ocg_names(&read(&plot(&d, &paper, &raw(json!({}))).unwrap()));
// The viewport's frozen layer is left out; the model layers seen through it are kept.
for n in ["Viewports", "0", "Doors", "Title"] {
assert!(names.contains(&n.to_string()), "{n} in {names:?}");
}
assert!(!names.contains(&"Walls".to_string()));
}
#[test]
fn several_sheets_in_one_file_with_page_labels() {
let mut d = layered();
add_line(&mut d, &Space::Paper("Layout1".into()), "Walls", (10.0, 10.0), (50.0, 10.0));
let doc = read(&plot(&d, &Space::Model, &raw(json!({"layouts": ["model", "LAYOUT1"]}))).unwrap());
// "all": model (it has objects), then every layout in tab order.
let all = read(&plot(&d, &Space::Model, &raw(json!({"layouts": "All"}))).unwrap());
assert_eq!(all.labels, ["Model", "Layout1", "Layout2"]);
assert_eq!(doc.pages.len(), 2);
assert_eq!(doc.labels, ["Model", "Layout1"]);
// Each page has its own sheet: model on A4 landscape, the layout on its page setup.
for p in &doc.pages {
assert!(pdf_read::ops(&p.content).iter().any(|o| o.op == "RG" && o.nums == [1.0, 0.0, 0.0]), "the red wall line: {}", p.content);
}
let size = |p: &pdf_read::Page| (p.media[2] - p.media[0], p.media[3] - p.media[1]);
assert!((size(&doc.pages[0]).0 - 841.89).abs() < 0.01 && (size(&doc.pages[0]).1 - 595.276).abs() < 0.01);
// The library call does the same.
let o = PdfOptions { compress: false, ..PdfOptions::default() };
let doc2 = read(&pdf_sheets(&d, &[Space::Paper("Layout1".into()), Space::Model], &o).unwrap());
assert_eq!(doc2.labels, ["Layout1", "Model"]);
// Title: the first page's label unless given.
assert_eq!(doc2.title.as_deref(), Some("Layout1"));
assert_eq!((doc2.creator.as_deref(), doc2.producer.as_deref()), (Some("CADCraft"), Some("CADCraft")));
}
#[test]
fn several_sheets_share_one_pdf_layer_per_drawing_layer() {
let mut d = layered();
add_line(&mut d, &Space::Paper("Layout1".into()), "Walls", (10.0, 10.0), (50.0, 10.0));
let doc = read(&plot(&d, &Space::Model, &raw(json!({"layouts": ["model", "LAYOUT1"]}))).unwrap());
assert_eq!(ocg_names(&doc).iter().filter(|n| *n == "Walls").count(), 1);
for p in &doc.pages {
assert!(p.properties.iter().any(|(_, g)| g == "Walls"));
}
// Several sheets: no layer panel forced open.
assert!(doc.page_mode.is_none());
}
#[test]
fn bad_sheet_lists_are_errors() {
let d = layered();
for o in [json!({"layouts": []}), json!({"layouts": ["Nope"]}), json!({"layouts": "Model"}), json!({"layouts": [1]})] {
assert!(plot(&d, &Space::Model, &o).is_err(), "{o}");
}
let many: Vec<&str> = vec!["Model"; MAX_PAGES + 1];
assert!(plot(&d, &Space::Model, &json!({ "layouts": many })).is_err());
assert!(pdf_sheets(&d, &[], &PdfOptions::default()).is_err());
}
#[test]
fn hyperlinks_become_link_annotations() {
let mut d = layered();
let h = add_line(&mut d, &Space::Model, "Walls", (0.0, 50.0), (100.0, 50.0));
let links = json!([
{"handle": h.hex(), "url": "https://example.com/a(1)"},
{"handle": h.0, "url": "javascript:alert(1)"},
{"handle": "FFFFFF", "url": "https://example.com/none"},
{"handle": h.hex(), "url": "https://example.com/ü"},
{"url": "https://example.com/no-handle"},
]);
let doc = read(&plot(&d, &Space::Model, &raw(json!({ "links": links }))).unwrap());
let annots = &doc.pages[0].links;
assert_eq!(annots.len(), 2);
assert_eq!(annots[0].uri, "https://example.com/a(1)");
assert_eq!(annots[1].uri, "https://example.com/%C3%BC");
// The rectangle is inside the A4 landscape sheet and wide like the line.
let v = annots[0].rect;
assert!(v[0] >= 0.0 && v[2] <= 841.9 && v[1] >= 0.0 && v[3] <= 595.3 && v[2] - v[0] > 100.0, "{v:?}");
}
fn unusual_names() -> Drawing {
let mut d = Drawing::new_metric();
for name in ["a(b)\\c", "Wände", "日本"] {
d.layers.push(Layer { name: name.into(), ..Layer::default() });
add_line(&mut d, &Space::Model, name, (0.0, 0.0), (10.0, 10.0));
}
d
}
#[test]
fn unusual_layer_names_are_kept() {
let doc = read(&plot(&unusual_names(), &Space::Model, &raw(json!({}))).unwrap());
assert_eq!(ocg_names(&doc), ["a(b)\\c", "Wände", "日本"]);
}
#[test]
fn unusual_titles_are_kept() {
let doc = read(&plot(&unusual_names(), &Space::Model, &raw(json!({"title": "Plan ü (1)\\"}))).unwrap());
assert_eq!(doc.title.as_deref(), Some("Plan ü (1)\\"));
}
#[test]
fn layers_past_the_cap_print_without_a_pdf_layer() {
// One more drawing layer than a file has PDF layers (4096).
let mut d = Drawing::new_metric();
for i in 0..4097 {
let name = format!("L{i}");
d.layers.push(Layer { name: name.clone(), ..Layer::default() });
add_line(&mut d, &Space::Model, &name, (0.0, f64::from(i)), (10.0, f64::from(i)));
}
let doc = read(&plot(&d, &Space::Model, &raw(json!({}))).unwrap());
assert_eq!(doc.ocgs.len(), 4096);
assert!(!ocg_names(&doc).contains(&"L4096".to_string()));
// Every line is still drawn; only the last is outside marked content.
let c = doc.content();
assert_eq!(pdf_read::drawn(c).iter().filter(|o| o.op == "m").count(), 4097);
assert_eq!((pdf_read::count(c, "BDC"), pdf_read::count(c, "EMC")), (4096, 4096));
}
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.