PdfCraft: An open-source PDF reader and editor written by scratch in pure Rust
use super::*;
use pdfcraft_render::{PageRenderer, RenderConfig, RenderRequest, RenderedPage, RequestKind};
fn numbers(values: &[f64]) -> Object {
Object::Array(values.iter().copied().map(Object::Real).collect())
}
// Contributor-original artwork uses a named color resource, without fonts or external assets.
fn widget_fixture(subtype: Option<Object>, matrix: Option<[f64; 6]>) -> (Document, ObjRef, ObjRef) {
let mut doc = fixture(1);
let page = pdfcraft_model::pages(&doc)[0].obj;
let mut colors = Dict::new();
colors.set(b"Ink".to_vec(), Object::name("DeviceRGB"));
let mut resources = Dict::new();
resources.set(b"ColorSpace".to_vec(), Object::Dict(colors));
let resources = doc.add(Object::Dict(resources));
let mut d = Dict::new();
d.set(b"BBox".to_vec(), numbers(&[0.0, 0.0, 20.0, 10.0]));
d.set(b"Resources".to_vec(), Object::Ref(resources));
d.set(b"PrivateKey".to_vec(), Object::name("PreserveMe"));
if let Some(subtype) = subtype {
d.set(b"Subtype".to_vec(), subtype);
}
if let Some(matrix) = matrix {
d.set(b"Matrix".to_vec(), numbers(&matrix));
}
let mut stream = Stream::flate(d, b"/Ink cs 0 1 0 scn 0 0 20 10 re f");
stream.dict.set(b"DecodeParms".to_vec(), Object::Dict(Dict::new()));
let ap = doc.add(Object::Stream(stream));
let mut widget = Dict::new();
widget.set(b"Subtype".to_vec(), Object::name("Widget"));
widget.set(b"FT".to_vec(), Object::name("Tx"));
widget.set(b"F".to_vec(), Object::Int(4));
widget.set(b"Rect".to_vec(), numbers(&[10.0, 20.0, 50.0, 40.0]));
let mut appearance = Dict::new();
appearance.set(b"N".to_vec(), Object::Ref(ap));
widget.set(b"AP".to_vec(), Object::Dict(appearance));
let widget = doc.add(Object::Dict(widget));
let contents = doc.add(Object::Stream(Stream::flate(Dict::new(), b"0 0 1 rg 0 0 8 8 re f")));
doc.update_dict(page, |d| {
d.set(b"MediaBox".to_vec(), numbers(&[0.0, 0.0, 100.0, 100.0]));
d.set(b"Annots".to_vec(), Object::Array(vec![Object::Ref(widget)]));
d.set(b"Contents".to_vec(), Object::Ref(contents));
d.set(b"Resources".to_vec(), Object::Dict(Dict::new()));
})
.unwrap();
(doc, ap, widget)
}
fn print_settings(content: Content) -> Settings {
Settings { pages: vec![0], paper: (100.0, 100.0), layout: Layout::Size(SizeMode::Actual), content, ..Settings::default() }
}
fn render(bytes: Vec<u8>) -> RenderedPage {
render_page(bytes, 0)
}
fn render_page(bytes: Vec<u8>, index: usize) -> RenderedPage {
let page = PageRenderer::new(Arc::new(bytes), RenderConfig::default()).render(RenderRequest {
page: index,
kind: RequestKind::Pixels,
tile: None,
scale: 1.0,
tag: 0,
preview: false,
});
assert_eq!(page.error, None);
assert!(page.warnings.is_empty(), "{:?}", page.warnings);
assert_eq!((page.width, page.height), (100, 100));
page
}
fn pixel(page: &RenderedPage, x: usize, y: usize) -> &[u8] {
let offset = (y * page.width as usize + x) * 4;
&page.rgba[offset..offset + 4]
}
fn saved(doc: &Document) -> Vec<u8> {
write_full(doc, &SaveOptions::default()).unwrap()
}
fn xobject(doc: &Document, owner: &Dict, name: &[u8]) -> ObjRef {
let resources = doc.resolve(owner.get(b"Resources").unwrap());
let objects = doc.resolve(resources.as_dict().unwrap().get(b"XObject").unwrap());
objects.as_dict().unwrap().get(name).unwrap().as_ref().unwrap()
}
/// Printing keeps occupied page resource names and distinct annotation appearances intact,
/// whether the page resources are direct or inherited from the page tree.
#[test]
fn annotation_appearances_do_not_replace_page_xobjects() {
for inherited in [false, true] {
let (mut doc, ap, widget) = widget_fixture(Some(Object::name("Form")), None);
let page = pdfcraft_model::pages(&doc)[0].obj;
let mut xobjects = Dict::new();
for (name, color) in [("PCPrA0", "1 0 0"), ("PCPrA1", "0 0 1"), ("PCPrA3", "1 0 0")] {
let dict = Dict::from_iter([
(b"Type".to_vec(), Object::name("XObject")),
(b"Subtype".to_vec(), Object::name("Form")),
(b"BBox".to_vec(), numbers(&[0.0, 0.0, 10.0, 10.0])),
]);
let form = doc.add(Object::Stream(Stream::flate(dict, format!("{color} rg 0 0 10 10 re f").as_bytes())));
xobjects.set(name.as_bytes().to_vec(), Object::Ref(form));
}
let xobjects = doc.add(Object::Dict(xobjects));
let resources = doc.add(Object::Dict(Dict::from_iter([(b"XObject".to_vec(), Object::Ref(xobjects))])));
let contents = doc.add(Object::Stream(Stream::flate(
Dict::new(),
b"q 1 0 0 1 60 20 cm /PCPrA0 Do Q\nq 1 0 0 1 70 20 cm /PCPrA1 Do Q\nq 1 0 0 1 80 20 cm /PCPrA3 Do Q",
)));
let second_ap = doc.add(Object::Stream(Stream::flate(doc.get(ap).as_dict().unwrap().clone(), b"/Ink cs 1 1 0 scn 0 0 20 10 re f")));
let mut second_widget = doc.get(widget).as_dict().unwrap().clone();
second_widget.set(b"Rect".to_vec(), numbers(&[10.0, 50.0, 50.0, 70.0]));
second_widget.set(b"AP".to_vec(), Object::Dict(Dict::from_iter([(b"N".to_vec(), Object::Ref(second_ap))])));
let second_widget = doc.add(Object::Dict(second_widget));
doc.update_dict(page, |d| {
d.set(b"Resources".to_vec(), Object::Ref(resources));
d.set(b"Contents".to_vec(), Object::Ref(contents));
d.set(b"Annots".to_vec(), Object::Array(vec![Object::Ref(widget), Object::Ref(second_widget)]));
})
.unwrap();
if inherited {
let parent = doc.get(page).as_dict().unwrap().reference(b"Parent").unwrap();
doc.update_dict(parent, |d| d.set(b"Resources".to_vec(), Object::Ref(resources))).unwrap();
doc.update_dict(page, |d| {
d.remove(b"Resources");
})
.unwrap();
}
let before = saved(&doc);
let source = render(before.clone());
for (x, color) in [(65, [255, 0, 0, 255]), (75, [0, 0, 255, 255]), (85, [255, 0, 0, 255])] {
assert_eq!(pixel(&source, x, 75), color, "source page artwork");
}
for (y, color) in [(40, [255, 255, 0, 255]), (70, [0, 255, 0, 255])] {
assert_eq!(pixel(&source, 30, y), color, "source widget appearance");
}
let printed = render(impose(&doc, &print_settings(Content::Document)).unwrap());
for (x, color) in [(65, [255, 0, 0, 255]), (75, [0, 0, 255, 255]), (85, [255, 0, 0, 255])] {
assert_eq!(pixel(&printed, x, 75), color, "printed page artwork, inherited={inherited}");
}
for (y, color) in [(40, [255, 255, 0, 255]), (70, [0, 255, 0, 255])] {
assert_eq!(pixel(&printed, 30, y), color, "printed widget appearance, inherited={inherited}");
}
assert_eq!(printed.rgba, source.rgba, "printing must retain page artwork and both appearances, inherited={inherited}");
assert_eq!(saved(&doc), before, "printing must leave the source resources unchanged");
}
}
#[test]
fn missing_subtype_appearance_survives_vector_print() {
let (control, _, _) = widget_fixture(Some(Object::name("Form")), None);
let control = render(impose(&control, &print_settings(Content::Document)).unwrap());
assert_eq!(pixel(&control, 30, 70), [0, 255, 0, 255], "valid Form control");
let (doc, ap, _) = widget_fixture(None, None);
let before = saved(&doc);
let state = doc.read_state();
let source_bytes = doc.bytes().clone();
let graph: Vec<_> = doc.scan_objects().collect();
let original = doc.get(ap);
let source = render(before.clone());
assert_eq!(pixel(&source, 30, 70), [0, 255, 0, 255], "source display");
let output = impose(&doc, &print_settings(Content::Document)).unwrap();
let reopened = Document::open(Arc::new(output.clone())).unwrap();
assert_eq!(pdfcraft_model::pages(&reopened).len(), 1);
let printed = render(output);
assert_eq!(pixel(&printed, 5, 5), [255, 255, 255, 255], "outside the appearance");
assert_eq!(pixel(&printed, 30, 70), [0, 255, 0, 255], "imposed missing-Subtype appearance");
assert_eq!(printed.rgba, control.rgba);
assert!(state.matches(&doc));
assert_eq!(doc.bytes(), &source_bytes);
assert_eq!(doc.scan_objects().collect::<Vec<_>>(), graph);
assert_eq!(doc.get(ap), original);
assert_eq!(saved(&doc), before);
let source = Document::open(Arc::new(before)).unwrap();
let page = &pdfcraft_model::pages(&source)[0];
let annots = source.resolve(page.dict.get(b"Annots").unwrap());
let widget = source.resolve(&annots.as_array().unwrap()[0]);
let selected = appearance(&source, widget.as_dict().unwrap()).unwrap();
let Object::Stream(stream) = &*source.get(selected) else { panic!("source AP stream") };
assert!(!stream.dict.contains(b"Subtype") && !stream.dict.contains(b"Type"));
assert_eq!(stream.decoded().unwrap(), b"/Ink cs 0 1 0 scn 0 0 20 10 re f");
assert_eq!(source.resolve(stream.dict.get(b"Resources").unwrap()), doc.resolve(original.as_dict().unwrap().get(b"Resources").unwrap()));
let sheet = &pdfcraft_model::pages(&reopened)[0];
let form = reopened.get(xobject(&reopened, &sheet.dict, b"P0"));
let promoted = reopened.get(xobject(&reopened, form.as_dict().unwrap(), b"PCPrA0"));
let Object::Stream(promoted) = &*promoted else { panic!("promoted AP stream") };
assert_eq!(promoted.dict.name(b"Subtype"), Some(b"Form".as_slice()));
let Object::Stream(original) = &*original else { panic!("original AP stream") };
assert_eq!(promoted.raw, original.raw);
let mut expected = original.dict.clone();
let mut actual = promoted.dict.clone();
actual.remove(b"Subtype");
actual.remove(b"Length");
expected.remove(b"Length");
let expected_resources = doc.resolve(expected.remove(b"Resources").as_ref().unwrap());
let actual_resources = reopened.resolve(actual.remove(b"Resources").as_ref().unwrap());
assert_eq!(actual_resources, expected_resources);
// The writer can spell integral Real values as integers. Compare their PDF values.
let mut actual_bytes = Vec::new();
let mut expected_bytes = Vec::new();
pdfcraft_cos::serialize(&Object::Dict(actual), &mut actual_bytes);
pdfcraft_cos::serialize(&Object::Dict(expected), &mut expected_bytes);
assert_eq!(actual_bytes, expected_bytes);
}
#[test]
fn promotion_preserves_streams_and_explicit_subtypes() {
for subtype in [None, Some(Object::name("Form")), Some(Object::name("Image")), Some(Object::Null), Some(Object::Int(7))] {
let (mut doc, ap, _) = widget_fixture(subtype.clone(), Some([2.0, 0.0, 0.0, 3.0, 5.0, 7.0]));
let original = doc.get(ap);
let pages = pdfcraft_model::pages(&doc);
let form = page_form(&mut doc, &pages, 0, Content::Document, &mut std::collections::HashMap::new()).unwrap();
assert_eq!(doc.get(ap), original, "original in the print clone");
let promoted = xobject(&doc, doc.get(form).as_dict().unwrap(), b"PCPrA0");
if subtype.is_some() {
assert_eq!(promoted, ap, "an explicit subtype keeps its object");
let printed = Document::open(Arc::new(impose(&doc, &print_settings(Content::Document)).unwrap())).unwrap();
let sheet = &pdfcraft_model::pages(&printed)[0];
let page_form = printed.get(xobject(&printed, &sheet.dict, b"P0"));
let printed_ap = printed.get(xobject(&printed, page_form.as_dict().unwrap(), b"PCPrA0"));
assert_eq!(printed_ap.as_dict().unwrap().get(b"Subtype"), subtype.as_ref(), "explicit subtype survives serialization");
} else {
assert_ne!(promoted, ap, "repair needs a separate object");
let Object::Stream(mut expected) = (*original).clone() else { panic!("AP stream") };
expected.dict.set(b"Subtype".to_vec(), Object::name("Form"));
assert_eq!(*doc.get(promoted), Object::Stream(expected), "only Subtype changes, including encoded data and resource refs");
}
}
}
#[test]
fn selected_shared_appearances_keep_placement_flags_and_content_modes() {
let mut default_images = Vec::new();
for matrix in [None, Some([2.0, 0.0, 0.0, 3.0, 5.0, 7.0])] {
let (mut doc, ap, widget) = widget_fixture(None, matrix);
// Optional Type does not replace the required Subtype.
doc.update_dict(ap, |d| d.set(b"Type".to_vec(), Object::name("XObject"))).unwrap();
let Object::Stream(mut off) = (*doc.get(ap)).clone() else { panic!("AP stream") };
off.raw = Stream::flate(off.dict.clone(), b"/Ink cs 1 0 0 scn 0 0 20 10 re f").raw;
let off = doc.add(Object::Stream(off));
let mut states = Dict::new();
states.set(b"On".to_vec(), Object::Ref(ap));
states.set(b"Off".to_vec(), Object::Ref(off));
let mut appearances = Dict::new();
appearances.set(b"N".to_vec(), Object::Dict(states));
doc.update_dict(widget, |d| {
d.set(b"AP".to_vec(), Object::Dict(appearances));
d.set(b"AS".to_vec(), Object::name("On"));
})
.unwrap();
let mut widgets = vec![Object::Ref(widget)];
for (rect, flags) in [([60.0, 20.0, 90.0, 40.0], 4), ([10.0, 60.0, 50.0, 80.0], 0), ([60.0, 60.0, 90.0, 80.0], 6)] {
let mut copy = doc.get(widget).as_dict().unwrap().clone();
copy.set(b"Rect".to_vec(), numbers(&rect));
copy.set(b"F".to_vec(), Object::Int(flags));
widgets.push(Object::Ref(doc.add(Object::Dict(copy))));
}
let page = pdfcraft_model::pages(&doc)[0].obj;
doc.update_dict(page, |d| d.set(b"Annots".to_vec(), Object::Array(widgets))).unwrap();
let before = saved(&doc);
for (mode, content) in
[Content::Document, Content::DocumentAndMarkups, Content::DocumentAndStamps, Content::FormFieldsOnly].into_iter().enumerate()
{
let output = impose(&doc, &print_settings(content)).unwrap();
let reopened = Document::open(Arc::new(output.clone())).unwrap();
assert_eq!(pdfcraft_model::pages(&reopened).len(), 1);
let sheet = &pdfcraft_model::pages(&reopened)[0];
let form = reopened.get(xobject(&reopened, &sheet.dict, b"P0"));
assert_eq!(
xobject(&reopened, form.as_dict().unwrap(), b"PCPrA0"),
xobject(&reopened, form.as_dict().unwrap(), b"PCPrA1"),
"selected shared appearance keeps one promotion"
);
let page = render(output);
for (x, y, expected) in
[(30, 70, [0, 255, 0, 255]), (75, 70, [0, 255, 0, 255]), (30, 30, [255, 255, 255, 255]), (75, 30, [255, 255, 255, 255])]
{
assert_eq!(pixel(&page, x, y), expected, "{matrix:?}, {content:?}, ({x},{y})");
}
let expected = if content == Content::FormFieldsOnly { [255, 255, 255, 255] } else { [0, 0, 255, 255] };
assert_eq!(pixel(&page, 4, 96), expected, "document artwork under {content:?}");
if matrix.is_none() {
default_images.push(page.rgba);
} else {
assert_eq!(page.rgba, default_images[mode], "Matrix must preserve the complete appearance extent under {content:?}");
}
}
assert_eq!(saved(&doc), before, "shared source graph stays unchanged");
}
}
#[test]
fn shared_promotions_span_pages_without_merging_distinct_sources() {
let mut doc = fixture(2);
// Contributor-original drawing and a bounded PDF comment expose repeated encoded payloads.
let mut payload = b"/Ink cs 0 1 0 scn 0 0 20 10 re f\n%".to_vec();
payload.extend(std::iter::repeat_n(b'x', 32 * 1024));
payload.push(b'\n');
let mut appearances = Vec::new();
for marker in ["Shared", "Distinct"] {
let mut colors = Dict::new();
colors.set(b"Ink".to_vec(), Object::name("DeviceRGB"));
let mut resources = Dict::new();
resources.set(b"ColorSpace".to_vec(), Object::Dict(colors));
resources.set(b"PrivateMarker".to_vec(), Object::name(marker));
let resources = doc.add(Object::Dict(resources));
let mut dict = Dict::new();
dict.set(b"BBox".to_vec(), numbers(&[0.0, 0.0, 20.0, 10.0]));
dict.set(b"Resources".to_vec(), Object::Ref(resources));
appearances.push(doc.add(Object::Stream(Stream::from_raw(dict, payload.clone()))));
}
let pages = pdfcraft_model::pages(&doc);
for (index, page) in pages.iter().enumerate() {
let mut widgets = Vec::new();
for (ap, rect) in [(appearances[0], [10.0, 20.0, 50.0, 40.0]), (appearances[0], [60.0, 20.0, 90.0, 40.0])]
.into_iter()
.chain((index == 1).then_some((appearances[1], [10.0, 60.0, 50.0, 80.0])))
{
let mut widget = Dict::new();
widget.set(b"Subtype".to_vec(), Object::name("Widget"));
widget.set(b"FT".to_vec(), Object::name("Tx"));
widget.set(b"F".to_vec(), Object::Int(4));
widget.set(b"Rect".to_vec(), numbers(&rect));
let mut appearance = Dict::new();
appearance.set(b"N".to_vec(), Object::Ref(ap));
widget.set(b"AP".to_vec(), Object::Dict(appearance));
widgets.push(Object::Ref(doc.add(Object::Dict(widget))));
}
doc.update_dict(page.obj, |dict| {
dict.set(b"MediaBox".to_vec(), numbers(&[0.0, 0.0, 100.0, 100.0]));
dict.set(b"Annots".to_vec(), Object::Array(widgets));
dict.remove(b"Contents");
dict.set(b"Resources".to_vec(), Object::Dict(Dict::new()));
})
.unwrap();
}
let before = saved(&doc);
let state = doc.read_state();
let source_bytes = doc.bytes().clone();
let graph: Vec<_> = doc.scan_objects().collect();
let originals: Vec<_> = appearances.iter().map(|ap| doc.get(*ap)).collect();
let settings = Settings { pages: vec![0, 1], ..print_settings(Content::Document) };
for _ in 0..2 {
let output = impose(&doc, &settings).unwrap();
let reopened = Document::open(Arc::new(output.clone())).unwrap();
let sheets = pdfcraft_model::pages(&reopened);
assert_eq!(sheets.len(), 2);
let mut shared = Vec::new();
let mut distinct = None;
for (index, sheet) in sheets.iter().enumerate() {
let form = reopened.get(xobject(&reopened, &sheet.dict, b"P0"));
let form = form.as_dict().unwrap();
shared.push(xobject(&reopened, form, b"PCPrA0"));
shared.push(xobject(&reopened, form, b"PCPrA1"));
if index == 1 {
distinct = Some(xobject(&reopened, form, b"PCPrA2"));
}
let rendered = render_page(output.clone(), index);
assert_eq!(pixel(&rendered, 30, 70), [0, 255, 0, 255]);
assert_eq!(pixel(&rendered, 75, 70), [0, 255, 0, 255]);
assert_eq!(pixel(&rendered, 30, 30), if index == 1 { [0, 255, 0, 255] } else { [255, 255, 255, 255] });
assert_eq!(pixel(&rendered, 75, 30), [255, 255, 255, 255]);
assert_eq!(pixel(&rendered, 5, 5), [255, 255, 255, 255]);
}
let copies = reopened
.scan_objects()
.filter(|(_, object)| matches!(&**object, Object::Stream(stream) if stream.raw.as_ref() == payload.as_slice()))
.count();
eprintln!(
"shared promotion output: bytes={}, payload_bytes={}, copies={copies}, shared={shared:?}, distinct={distinct:?}",
output.len(),
payload.len()
);
assert!(state.matches(&doc));
assert_eq!(doc.bytes(), &source_bytes);
assert_eq!(doc.scan_objects().collect::<Vec<_>>(), graph);
assert_eq!(saved(&doc), before);
for (ap, original) in appearances.iter().zip(&originals) {
assert_eq!(doc.get(*ap), *original);
}
assert_eq!(copies, 2, "one encoded payload per distinct source appearance");
assert!(shared.iter().all(|ap| *ap == shared[0]), "shared uses span both page forms");
let distinct = distinct.unwrap();
assert_ne!(shared[0], distinct, "identical bytes do not merge source references");
for (ap, marker) in [(shared[0], b"Shared".as_slice()), (distinct, b"Distinct".as_slice())] {
let object = reopened.get(ap);
let Object::Stream(stream) = &*object else { panic!("promoted appearance stream") };
assert_eq!(stream.raw.as_ref(), payload.as_slice());
assert_eq!(stream.dict.name(b"Subtype"), Some(b"Form".as_slice()));
let resources = reopened.resolve(stream.dict.get(b"Resources").unwrap());
assert_eq!(resources.as_dict().unwrap().name(b"PrivateMarker"), Some(marker));
}
}
}