M4.83: overprinting fills and strokes overprint in PDF
Advanced > Overprint: Preserve (the default; document.exportPdf advanced.overprint) writes each overprinting fill and stroke (an object's own, a character's, a type object's) with a graphics state of /OP true /op true /OPM 1 (/OPM 0 in PDF/A); Discard writes none. White ones knock out when Document Setup's Discard White Overprint is on, as in print. Mask art never overprints. File > Print's composite PDF honours Print > Advanced > Overprints: Preserve the same way (separations keep multiplying plates). Each overprinting fill or stroke is drawn as a form marked to overprint (crates/pdf/src/forms.rs); after writing, its content starts by setting the overprinting graphics state, and the PDF/X self-check runs on the result. The engine's "overprint is not written to PDF yet" warning and print's "overprints print as knockouts in composite output" warning are gone. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
bflatastic
parent
0e4d3f6871
commit
a09cbe58c8
|
|
@ -140,7 +140,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
|
|||
| M1 | Selection, transform, layers, MCP | ✅ mostly done (transform reference point snaps to anchors/centres; rotated persistent bbox pending) | 4–6 |
|
||||
| M2 | Drawing tools + smart guides | ✅ mostly done (Flare, Reshape, Live Corners widget dragging landed; Shaper, Pen modifier nuances) | 15–20 |
|
||||
| M3 | Paint & appearance (swatches, color, gradient, stroke, appearance, transparency, styles) | ✅ done (M3.7–M3.98): swatches, groups, libraries, tints, Lab spots and Registration; Color Picker, Color panel, Color Guide, Color Themes, Edit Colors and Recolor Artwork; gradients that follow every transform, the annotator, linked stops, freeform gradients, focal points, gradients on strokes and Expand; stroke geometry, arrowheads, dashes fitted to corners, stroke on type, width profiles and the Width tool, Scale Strokes and preview bounds; Appearance targeting, container appearance, target circles, Expand Appearance; knockout, isolation, blend accuracy, CMYK blending, overprint, Attributes, masks and clipping, Flatten Transparency; graphic styles, links and libraries. Left: freeform and mixed spot/process gradients export as stops or process colours to SVG/PDF; flattener presets not yet used by PDF/print; confirm the Scale Strokes & Effects default | 4–8 |
|
||||
| M4 | Files (native, SVG, PDF, raster, Export for Screens, clipboard interop) | ✅ mostly done (M4.14–M4.98 on 2026-10-05): Save As/Save a Copy/Revert/templates, Data Recovery and background save, SVG import and export fidelity (units, text, symbols, filters, SVGZ, Preserve Editing, SVG Options), PDF import (colours, layers, masks, editable text, security) and export (presets, marks, bleed, ICC and output intent, raster effects, subset fonts, PDF/X-1a, X-3 and X-4, PDF layers), Place and Links, Package, EPS and DXF in and out, EMF/WMF, TIFF/BMP/Targa/PSD/GIF/PNG-8 export, Print and print presets, slices, Save for Web, Asset Export, clipboard flavours, File Info. Left: DWG (use DXF), PSD placement as layers, polish | 6–10 |
|
||||
| M4 | Files (native, SVG, PDF, raster, Export for Screens, clipboard interop) | ✅ mostly done (M4.14–M4.98 on 2026-10-05): Save As/Save a Copy/Revert/templates, Data Recovery and background save, SVG import and export fidelity (units, text, symbols, filters, SVGZ, Preserve Editing, SVG Options), PDF import (colours, layers, masks, editable text, security) and export (presets, marks, bleed, ICC and output intent, raster effects, subset fonts, PDF/X-1a, X-3 and X-4, PDF layers, overprint), Place and Links, Package, EPS and DXF in and out, EMF/WMF, TIFF/BMP/Targa/PSD/GIF/PNG-8 export, Print and print presets, slices, Save for Web, Asset Export, clipboard flavours, File Info. Left: DWG (use DXF), PSD placement as layers, polish | 6–10 |
|
||||
| M5 | Performance | 🟡 background render + caches + MT done; `vectorcraft-cli bench` and `vectorcraft-cli perf` (budget suite); file format v2 opens 3× faster (50k paths: 722 → 244 ms); raster effects (glows, shadows, blur, feather) no longer force the whole frame single-threaded (filtered offscreen per effect, verified equal to the single-threaded reference); effect-heavy demos need a clean-machine benchmark; dirty-region rendering, GPU backend spike pending | 15–25 |
|
||||
| M6 | Path operations (Pathfinder, Shape Builder, offset…) | ✅ mostly done (Boolean precision on almost-horizontal edges fixed and the property tests made deterministic; Shape Builder edge erase, large-offset bug open) | 3–6 |
|
||||
| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | 🟡 Character/Paragraph Styles, Area Type Options, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font, Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects, tab stops + Tabs panel done; tab leaders, spell check, vertical type pending | 45–60 |
|
||||
|
|
@ -187,7 +187,7 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale)
|
|||
| Guides, grids, smart guides, snapping, rulers | 3 | 75% | global/video rulers, smart-guide preference depth | 4–8 |
|
||||
| File formats | 6 | 85% | DWG (no open spec: DXF instead), PSD placement as layers, the remaining fidelity polish; EPS, DXF, EMF/WMF, TIFF, BMP, Targa, PSD export, SVGZ, PDF security, PDF/X, PDF layers and presets are done | 6–10 |
|
||||
| Export for Screens, Asset Export, slices, Save for Web | 3 | 85% | polish only (all four are done) | 2–4 |
|
||||
| Print, colour management, separations, flattener | 3 | 78% | flattener presets in PDF export, print preview fidelity, `/OP` in composite print (Print dialog, presets, PostScript, marks, separations, Print Tiling, print overprint/flattener/bitmap options and printer profile are done) | 2–4 |
|
||||
| Print, colour management, separations, flattener | 3 | 80% | flattener presets in PDF export, print preview fidelity (overprint in PDF and composite print, Print dialog, presets, PostScript, marks, separations, Print Tiling, print overprint/flattener/bitmap options and printer profile are done) | 1–3 |
|
||||
| Automation | 3 | 60% | Variables (data merge), scripting surface, batch | 8–12 |
|
||||
| UI chrome (panels, contextual Properties, workspaces, prefs) | 6 | 78% | Variables, SVG Interactivity, Properties per context, Consolidate All Windows (Links, Asset Export, CSS Properties, Attributes are done) | 15–25 |
|
||||
| Libraries, Links, Package | 2 | 50% | a local Libraries panel (no cloud by design); Links and Package are done | 5–8 |
|
||||
|
|
|
|||
|
|
@ -118,7 +118,7 @@ pub fn multiply_overprints(a: &mut Arc<Node>, discard_white: bool) {
|
|||
}
|
||||
|
||||
/// A solid paint of paper white (no ink in any colour model).
|
||||
fn is_white(p: &Paint) -> bool {
|
||||
pub fn is_white(p: &Paint) -> bool {
|
||||
let Paint::Solid { color, .. } = p else { return false };
|
||||
match *color {
|
||||
Color::Rgb { r, g, b } => r.min(g).min(b) >= 1.0,
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ use std::borrow::Cow;
|
|||
use serde::Deserialize;
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_doc::Document;
|
||||
use vectorcraft_pdf::{Overprint, PdfError, PdfOptions, PdfPreset, PdfSettings, Standard};
|
||||
use vectorcraft_pdf::{PdfError, PdfOptions, PdfPreset, PdfSettings, Standard};
|
||||
|
||||
use super::super::flatten::{FlattenOptions, flatten_document, see_through_images};
|
||||
use super::super::*;
|
||||
|
|
@ -91,7 +91,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
|||
"Export PDF",
|
||||
[],
|
||||
None,
|
||||
"{path?, preset?: \"VectorCraft Default\" (built-in or saved: pdf.preset.list), artboard? | artboards?: [i…] | range?: \"1-3, 5\" (1-based; default all, one page each), standard?: none|pdfA2b|pdfX1a (CMYK, grey and spot colours only: colours and images converted to output.destination or the CMYK output intent, untagged; transparency flattened with the High Resolution flattener preset; PDF 1.3)|pdfX3 (colours ICC-tagged; transparency flattened; PDF 1.3)|pdfX4 (transparency and layers kept; colours ICC-tagged; PDF 1.6 at most) (PDF/X: a /GTS_PDFX output intent, by default the CMYK profile in effect, embedded; TrimBox, Trapped, GTS_PDFXVersion, title and dates; fonts embedded or outlined), compatibility?: 1.4|1.5|1.6|1.7 (default)|2.0 (choosing a standard sets the latest it allows: 1.7 for pdfA2b, 1.6 for pdfX4, 1.4 for pdfX1a and pdfX3, written as PDF 1.3), preserveEditing? (on in VectorCraft Default: the native document as an embedded file, which document.open restores; choosing a standard turns it off, a standard refuses it), thumbnails?, fastWebView?, viewAfterSaving? (the app opens the written file), createLayers? (each top-level layer but template layers as a PDF layer, an optional content group: hidden layers off, non-printing ones /PrintState /OFF, locked ones locked; needs 1.5 or later; they reopen as layers; choosing pdfX1a or pdfX3 turns it off; they refuse it), includeNonPrinting? (keep layers whose Print option is off; left out by default unless createLayers), compression?: {color?, gray?: {downsample: none|average|subsample|bicubic, ppi: 300, abovePpi: 450, compression: none|zip|jpeg|jpeg2000|auto, quality: minimum|low|medium|high|maximum}, mono?: {downsample, ppi: 1200, abovePpi: 1800, compression: none|ccittG3|ccittG4|zip|runLength} (black-and-white images), compressText?: true} (images above abovePpi are resampled to ppi; auto keeps JPEGs JPEG, the others lossless; JPEG needs opaque images; none, jpeg2000, CCITT and runLength are written as ZIP with a warning), marks?: {trim, registration, colorBars, pageInfo, kind: roman|japanese, weight: 0.25 (trim marks and targets), offset: 6 (pt from the artboard, at least the bleed)} (printer's marks in [Registration], every plate: trim marks, registration targets mid-side, CMYK/spot/black-tint colour bars on top, page information (title, artboard, date UTC) below), bleed?: {useDocument (the document's bleed, document.setup), top, bottom, left, right} (pt; art in the bleed is kept). Each page: TrimBox = artboard, BleedBox = artboard + bleed, MediaBox = that + the marks' room (art clipped to the BleedBox), output?: {conversion: none (default)|destination (every colour into the destination profile's model, CMYK or RGB, also colours of that model in another profile)|preserveNumbers (only colours of the other model and Lab; those in the destination's model keep their numbers) (grey stays grey; images are converted too, printer's marks are not), destination: profile name (edit.colorSettings lists them; default: the document's profile for its colour mode), profiles: none (device colours)|all|destination|taggedSource (documents assigned a profile: edit.assignProfile) (ICC-based colours: CMYK with the destination or document CMYK profile, RGB as sRGB, grey with the sRGB tone curve; PDF/A always), outputIntent: profile name (embedded as the catalog's /GTS_PDFX output intent; a name that isn't a profile is only named, which pdfX1a and pdfX3 allow only with a registry and pdfX4 refuses; pdfX1a needs a CMYK one), outputCondition, outputConditionId (default: outputIntent), registry, trapped (/Trapped /True; /False when an output intent is written)} (PDF/A files keep their own output intent), advanced?: {fontSubsetPercent: 100 (below 100 is accepted with a warning: fonts are always embedded as subsets), outlineText: true (false: type as real, selectable and searchable text in embedded subset fonts with a ToUnicode map; fonts whose licence forbids embedding, or allows only whole fonts, stay outlines with a warning), overprint: preserve|discard}, security?: {openPassword, permissionsPassword, printing: none|low|high, changes: none|pages|forms|comments|any, copy, screenReader, plaintextMetadata}} → {path, bytes, warnings}; no path → {dataBase64, bytes, warnings}. The options apply over the preset (null keeps its value); options accepted but not applied yet come back as warnings; a standard with a PDF version it doesn't allow and a password with a standard are refused, and so is a PDF/X file that would still break its standard (transparency the flattener left, RGB in pdfX1a, a font not embedded). document.export {format: pdf} takes the same options",
|
||||
"{path?, preset?: \"VectorCraft Default\" (built-in or saved: pdf.preset.list), artboard? | artboards?: [i…] | range?: \"1-3, 5\" (1-based; default all, one page each), standard?: none|pdfA2b|pdfX1a (CMYK, grey and spot colours only: colours and images converted to output.destination or the CMYK output intent, untagged; transparency flattened with the High Resolution flattener preset; PDF 1.3)|pdfX3 (colours ICC-tagged; transparency flattened; PDF 1.3)|pdfX4 (transparency and layers kept; colours ICC-tagged; PDF 1.6 at most) (PDF/X: a /GTS_PDFX output intent, by default the CMYK profile in effect, embedded; TrimBox, Trapped, GTS_PDFXVersion, title and dates; fonts embedded or outlined), compatibility?: 1.4|1.5|1.6|1.7 (default)|2.0 (choosing a standard sets the latest it allows: 1.7 for pdfA2b, 1.6 for pdfX4, 1.4 for pdfX1a and pdfX3, written as PDF 1.3), preserveEditing? (on in VectorCraft Default: the native document as an embedded file, which document.open restores; choosing a standard turns it off, a standard refuses it), thumbnails?, fastWebView?, viewAfterSaving? (the app opens the written file), createLayers? (each top-level layer but template layers as a PDF layer, an optional content group: hidden layers off, non-printing ones /PrintState /OFF, locked ones locked; needs 1.5 or later; they reopen as layers; choosing pdfX1a or pdfX3 turns it off; they refuse it), includeNonPrinting? (keep layers whose Print option is off; left out by default unless createLayers), compression?: {color?, gray?: {downsample: none|average|subsample|bicubic, ppi: 300, abovePpi: 450, compression: none|zip|jpeg|jpeg2000|auto, quality: minimum|low|medium|high|maximum}, mono?: {downsample, ppi: 1200, abovePpi: 1800, compression: none|ccittG3|ccittG4|zip|runLength} (black-and-white images), compressText?: true} (images above abovePpi are resampled to ppi; auto keeps JPEGs JPEG, the others lossless; JPEG needs opaque images; none, jpeg2000, CCITT and runLength are written as ZIP with a warning), marks?: {trim, registration, colorBars, pageInfo, kind: roman|japanese, weight: 0.25 (trim marks and targets), offset: 6 (pt from the artboard, at least the bleed)} (printer's marks in [Registration], every plate: trim marks, registration targets mid-side, CMYK/spot/black-tint colour bars on top, page information (title, artboard, date UTC) below), bleed?: {useDocument (the document's bleed, document.setup), top, bottom, left, right} (pt; art in the bleed is kept). Each page: TrimBox = artboard, BleedBox = artboard + bleed, MediaBox = that + the marks' room (art clipped to the BleedBox), output?: {conversion: none (default)|destination (every colour into the destination profile's model, CMYK or RGB, also colours of that model in another profile)|preserveNumbers (only colours of the other model and Lab; those in the destination's model keep their numbers) (grey stays grey; images are converted too, printer's marks are not), destination: profile name (edit.colorSettings lists them; default: the document's profile for its colour mode), profiles: none (device colours)|all|destination|taggedSource (documents assigned a profile: edit.assignProfile) (ICC-based colours: CMYK with the destination or document CMYK profile, RGB as sRGB, grey with the sRGB tone curve; PDF/A always), outputIntent: profile name (embedded as the catalog's /GTS_PDFX output intent; a name that isn't a profile is only named, which pdfX1a and pdfX3 allow only with a registry and pdfX4 refuses; pdfX1a needs a CMYK one), outputCondition, outputConditionId (default: outputIntent), registry, trapped (/Trapped /True; /False when an output intent is written)} (PDF/A files keep their own output intent), advanced?: {fontSubsetPercent: 100 (below 100 is accepted with a warning: fonts are always embedded as subsets), outlineText: true (false: type as real, selectable and searchable text in embedded subset fonts with a ToUnicode map; fonts whose licence forbids embedding, or allows only whole fonts, stay outlines with a warning), overprint: preserve (overprinting fills and strokes set /OP /op true, /OPM 1; white ones knock out with document.setup discardWhiteOverprint)|discard (they knock out)}, security?: {openPassword, permissionsPassword, printing: none|low|high, changes: none|pages|forms|comments|any, copy, screenReader, plaintextMetadata}} → {path, bytes, warnings}; no path → {dataBase64, bytes, warnings}. The options apply over the preset (null keeps its value); options accepted but not applied yet come back as warnings; a standard with a PDF version it doesn't allow and a password with a standard are refused, and so is a PDF/X file that would still break its standard (transparency the flattener left, RGB in pdfX1a, a font not embedded). document.export {format: pdf} takes the same options",
|
||||
has_doc,
|
||||
export_pdf
|
||||
),
|
||||
|
|
@ -254,9 +254,6 @@ pub(super) fn encode_carrying(cmd: &str, doc: &Document, p: &Value, native: impl
|
|||
}
|
||||
let r = super::super::rasterfx::export_pdf_with_report(flat.as_ref().unwrap_or(doc), &opts).map_err(|e| pdf_error(cmd, e))?;
|
||||
warnings.extend(r.warnings);
|
||||
if opts.settings.advanced.overprint == Overprint::Preserve && doc.layers.iter().any(|l| l.has_overprint()) {
|
||||
warnings.push("overprinting objects are written without overprint: overprint is not written to PDF yet".into());
|
||||
}
|
||||
Ok((r.bytes, warnings))
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
//! `document.exportPdf {createLayers}` writes PDF layers that reopen as layers.
|
||||
//! `document.exportPdf {createLayers}` writes PDF layers that reopen as layers, and
|
||||
//! `advanced.overprint` keeps overprinting in the file or drops it.
|
||||
|
||||
use serde_json::{Value, json};
|
||||
|
||||
|
|
@ -43,3 +44,18 @@ fn export_pdf_create_layers_writes_layers_that_reopen_as_layers() {
|
|||
let v = s.execute("document.exportPdf", &json!({"createLayers": true, "compatibility": "1.4"})).unwrap();
|
||||
assert!(warnings(&v).iter().any(|w| w.contains("PDF 1.5")), "{:?}", warnings(&v));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn export_pdf_overprint_is_preserved_or_discarded() {
|
||||
let mut s = session();
|
||||
s.execute("select.all", &json!({})).unwrap();
|
||||
// The rectangles' strokes are black (their white fills would knock out: discardWhiteOverprint).
|
||||
s.execute("object.setOverprint", &json!({"stroke": true})).unwrap();
|
||||
let overprints = |s: &mut Session, p: Value| {
|
||||
let v = s.execute("document.exportPdf", &p).unwrap();
|
||||
assert!(warnings(&v).iter().all(|w| !w.contains("overprint")), "{:?}", warnings(&v));
|
||||
String::from_utf8_lossy(&b64(&v)).matches("/OP true/op true/OPM 1").count()
|
||||
};
|
||||
assert_eq!(overprints(&mut s, json!({"compression": {"compressText": false}})), 1);
|
||||
assert_eq!(overprints(&mut s, json!({"advanced": {"overprint": "discard"}})), 0);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
|||
"Print Setup",
|
||||
[],
|
||||
None,
|
||||
"{settings?: {copies: 1 (1–999), collate: true, reverse, artboards: all|range|ignore (all the art as one page), range: \"1-3, 5\" (1-based, with artboards: range), skipBlank (leave out artboards with no art that prints), media: letter|legal|tabloid|a3|a4|a5|b4|b5|custom, width, height (custom paper, 72–14400 pt), orientation: portrait|landscape|portraitFlipped|landscapeFlipped, autoRotate: true (turn the paper to each artboard; orientation ignored), transverse (the page a quarter turn on the paper), printLayers: visiblePrintable|visible|all (template layers never print), placement: {origin: topLeft|top|topRight|left|center|right|bottomLeft|bottom|bottomRight (the point of the printed area, the artboard with its bleed and marks, on the same point of the imageable area), x, y (pt, right and down)}, scaling: none|fit|custom|tileFull|tileImageable, scale: {width: 100, height: 100} (% with custom and tiling), overlap: 0 (pt between tiles), tileRange: \"\" (1-based tiles across then down; empty: all), margin: 0 (pt the device can't print around the paper: the imageable area is inside it), marks: {trim, registration, colorBars, pageInfo, kind: roman|japanese, weight: 0.25, offset: 6} (as document.exportPdf, at the paper's scale; page information adds the tile and the ink), bleed: {useDocument: true (the document's bleed, document.setup), top, bottom, left, right} (pt), output: {mode: composite|separations (one grey page per ink that prints), emulsion: up|down (down mirrors), image: positive|negative, spotsToProcess, inks: [{name: \"Cyan\"|…|a spot swatch, print: true, frequency (lpi, default 60), angle (default C 15, M 75, Y 0, K 45, spots 45)}]}, graphics: {autoFlatness: true, flatness: 1 (0.2–100), fonts: none|subset|complete}, color: {intent: perceptual|relativeColorimetric|saturation|absoluteColorimetric, preserveNumbers: true (CMYK colours keep their values), profile: \"\" (the printer profile, an RGB or CMYK one: composite PDF colours are converted to it with the intent, separations separate with a CMYK one; empty: as they are)}, advanced: {printAsBitmap (composite pages print as one image each, at the document's raster effects resolution), overprints: preserve|discard|simulate (composite output; simulate prints them as Overprint Preview shows them; separations always keep them), flattenerPreset: \"\" (a flattener preset, built-in or saved: transparency is flattened before printing; empty: it prints live; PostScript defaults to medium)}, tileOrigin: {placed: false, x, y} (where the Print Tiling tool put the pages: print.tiling.set)}} store the print settings with the document, over the ones it has (null keeps a value), as one undo step; no settings → {settings} (the current ones, defaults if never set up)",
|
||||
"{settings?: {copies: 1 (1–999), collate: true, reverse, artboards: all|range|ignore (all the art as one page), range: \"1-3, 5\" (1-based, with artboards: range), skipBlank (leave out artboards with no art that prints), media: letter|legal|tabloid|a3|a4|a5|b4|b5|custom, width, height (custom paper, 72–14400 pt), orientation: portrait|landscape|portraitFlipped|landscapeFlipped, autoRotate: true (turn the paper to each artboard; orientation ignored), transverse (the page a quarter turn on the paper), printLayers: visiblePrintable|visible|all (template layers never print), placement: {origin: topLeft|top|topRight|left|center|right|bottomLeft|bottom|bottomRight (the point of the printed area, the artboard with its bleed and marks, on the same point of the imageable area), x, y (pt, right and down)}, scaling: none|fit|custom|tileFull|tileImageable, scale: {width: 100, height: 100} (% with custom and tiling), overlap: 0 (pt between tiles), tileRange: \"\" (1-based tiles across then down; empty: all), margin: 0 (pt the device can't print around the paper: the imageable area is inside it), marks: {trim, registration, colorBars, pageInfo, kind: roman|japanese, weight: 0.25, offset: 6} (as document.exportPdf, at the paper's scale; page information adds the tile and the ink), bleed: {useDocument: true (the document's bleed, document.setup), top, bottom, left, right} (pt), output: {mode: composite|separations (one grey page per ink that prints), emulsion: up|down (down mirrors), image: positive|negative, spotsToProcess, inks: [{name: \"Cyan\"|…|a spot swatch, print: true, frequency (lpi, default 60), angle (default C 15, M 75, Y 0, K 45, spots 45)}]}, graphics: {autoFlatness: true, flatness: 1 (0.2–100), fonts: none|subset|complete}, color: {intent: perceptual|relativeColorimetric|saturation|absoluteColorimetric, preserveNumbers: true (CMYK colours keep their values), profile: \"\" (the printer profile, an RGB or CMYK one: composite PDF colours are converted to it with the intent, separations separate with a CMYK one; empty: as they are)}, advanced: {printAsBitmap (composite pages print as one image each, at the document's raster effects resolution), overprints: preserve|discard|simulate (composite output; preserve writes them to overprint (/OP), simulate prints them as Overprint Preview shows them; separations always keep them), flattenerPreset: \"\" (a flattener preset, built-in or saved: transparency is flattened before printing; empty: it prints live; PostScript defaults to medium)}, tileOrigin: {placed: false, x, y} (where the Print Tiling tool put the pages: print.tiling.set)}} store the print settings with the document, over the ones it has (null keeps a value), as one undo step; no settings → {settings} (the current ones, defaults if never set up)",
|
||||
has_doc,
|
||||
setup
|
||||
),
|
||||
|
|
|
|||
|
|
@ -77,6 +77,7 @@ pub fn export_with_report(doc: &Document, opts: &PdfOptions) -> Result<ExportRep
|
|||
if set.writes_layers() && doc.page_knockout {
|
||||
warnings.push("PDF layers can't be written with a knockout page group: every layer is plain page content".into());
|
||||
}
|
||||
ex.overprint = set.advanced.overprint == crate::Overprint::Preserve;
|
||||
// Marks and Bleeds: each page is its artboard (the trim box) grown by the bleed, and by the
|
||||
// printer's marks around that.
|
||||
let bleed = set.bleed_of(doc);
|
||||
|
|
@ -103,10 +104,10 @@ pub fn export_with_report(doc: &Document, opts: &PdfOptions) -> Result<ExportRep
|
|||
};
|
||||
w.page(&mut ex, &sheet).map_err(|_| PdfError::BadArtboard(i))?;
|
||||
}
|
||||
let layers = ex.layers;
|
||||
let (layers, overprinted) = (ex.layers, ex.overprinted);
|
||||
w.absorb(ex);
|
||||
let (bytes, more) = w.finish()?;
|
||||
let bytes = crate::forms::finish(bytes, doc, set, layers)?;
|
||||
let bytes = crate::forms::finish(bytes, doc, set, layers, overprinted)?;
|
||||
let bytes = if native.is_some() { crate::editing::seal(bytes)? } else { bytes };
|
||||
let bytes = crate::encrypt::protect(bytes, set)?;
|
||||
warnings.extend(more);
|
||||
|
|
@ -448,6 +449,10 @@ pub(crate) struct Exporter<'a> {
|
|||
pub layers: bool,
|
||||
/// A top-level layer's form is being drawn.
|
||||
in_layer: bool,
|
||||
/// Overprinting fills and strokes are drawn as forms marked to overprint.
|
||||
pub overprint: bool,
|
||||
/// An overprinting fill or stroke was drawn so.
|
||||
pub overprinted: bool,
|
||||
}
|
||||
|
||||
impl<'a> Exporter<'a> {
|
||||
|
|
@ -472,6 +477,8 @@ impl<'a> Exporter<'a> {
|
|||
fonts: HashMap::new(),
|
||||
layers: false,
|
||||
in_layer: false,
|
||||
overprint: false,
|
||||
overprinted: false,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -801,10 +808,12 @@ impl Exporter<'_> {
|
|||
if !m.clip || m.invert {
|
||||
cover(&mut ms, page, if m.clip { 0 } else { 255 }, 1.0);
|
||||
}
|
||||
// Mask art is a picture of its own: it takes no part in a knockout group around the object.
|
||||
// Mask art is a picture of its own: it takes no part in a knockout group around the object,
|
||||
// and has no inks to overprint.
|
||||
let knockout = std::mem::take(&mut self.knockout);
|
||||
let overprint = std::mem::take(&mut self.overprint);
|
||||
self.node(&mut ms, &m.art, page, true);
|
||||
self.knockout = knockout;
|
||||
(self.knockout, self.overprint) = (knockout, overprint);
|
||||
if m.invert {
|
||||
ms.push_blend_mode(krilla::blend::BlendMode::Difference);
|
||||
cover(&mut ms, page, 255, 1.0);
|
||||
|
|
@ -852,7 +861,9 @@ impl Exporter<'_> {
|
|||
let alpha = {
|
||||
let mut ab = ms.stream_builder();
|
||||
let mut als = ab.surface();
|
||||
let overprint = std::mem::take(&mut self.overprint);
|
||||
self.node(&mut als, &shape, page, false);
|
||||
self.overprint = overprint;
|
||||
als.finish();
|
||||
krilla::mask::Mask::new(ab.finish(), krilla::mask::MaskType::Alpha)
|
||||
};
|
||||
|
|
@ -985,27 +996,29 @@ impl Exporter<'_> {
|
|||
continue;
|
||||
}
|
||||
self.warn_raster(&fl.effects, || "fills".into());
|
||||
if self.area(s, &path, rule(r), &fl.paint, (fl.opacity, fl.blend), bounds, bounds) {
|
||||
continue;
|
||||
}
|
||||
let Some(paint) = self.paint(&fl.paint, bounds) else { continue };
|
||||
let bl = fl.blend != BlendMode::Normal;
|
||||
if bl {
|
||||
s.push_blend_mode(blend(fl.blend));
|
||||
}
|
||||
s.set_stroke(None);
|
||||
s.set_fill(Some(Fill { paint, opacity: norm(fl.opacity), rule: rule(r) }));
|
||||
s.draw_path(&path);
|
||||
if bl {
|
||||
s.pop();
|
||||
}
|
||||
self.overprinting(s, fl.overprint, &fl.paint, |ex, s| {
|
||||
if ex.area(s, &path, rule(r), &fl.paint, (fl.opacity, fl.blend), bounds, bounds) {
|
||||
return;
|
||||
}
|
||||
let Some(paint) = ex.paint(&fl.paint, bounds) else { return };
|
||||
let bl = fl.blend != BlendMode::Normal;
|
||||
if bl {
|
||||
s.push_blend_mode(blend(fl.blend));
|
||||
}
|
||||
s.set_stroke(None);
|
||||
s.set_fill(Some(Fill { paint, opacity: norm(fl.opacity), rule: rule(r) }));
|
||||
s.draw_path(&path);
|
||||
if bl {
|
||||
s.pop();
|
||||
}
|
||||
});
|
||||
}
|
||||
AppearanceItem::Stroke(st) => {
|
||||
if !st.visible || st.paint.is_none() || st.width <= 0.0 {
|
||||
continue;
|
||||
}
|
||||
self.warn_raster(&st.effects, || "strokes".into());
|
||||
self.stroke(s, bp, &path, r, st, page, bounds);
|
||||
self.overprinting(s, st.overprint, &st.paint, |ex, s| ex.stroke(s, bp, &path, r, st, page, bounds));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1013,6 +1026,19 @@ impl Exporter<'_> {
|
|||
s.set_stroke(None);
|
||||
}
|
||||
|
||||
/// Draw a fill or stroke of `paint` with `draw`: as a form marked to overprint when it
|
||||
/// `overprints`, paints and overprints are kept (but not a white one with Discard White
|
||||
/// Overprint).
|
||||
fn overprinting(&mut self, s: &mut Surface, overprints: bool, paint: &Paint, draw: impl FnOnce(&mut Self, &mut Surface)) {
|
||||
let white = || self.doc.setup.discard_white_overprint && vectorcraft_doc::overprint::is_white(paint);
|
||||
if overprints && self.overprint && !paint.is_none() && !white() {
|
||||
self.overprinted = true;
|
||||
crate::forms::form(s, Mark::Overprint, |s| draw(self, s));
|
||||
} else {
|
||||
draw(self, s);
|
||||
}
|
||||
}
|
||||
|
||||
/// Is `p` a paint PDF has no paint for, which [`Self::area`] draws as art: a pattern swatch or
|
||||
/// a freeform gradient?
|
||||
fn area_paint(&self, p: &Paint) -> bool {
|
||||
|
|
@ -1261,25 +1287,28 @@ impl Exporter<'_> {
|
|||
bp.extend(g.outline.iter());
|
||||
}
|
||||
let fill = &run.style.fill;
|
||||
// The outlines left to fill as paths: all of them, or those real text leaves.
|
||||
let outlines = match plain.as_deref().filter(|_| !fill.is_none() && !self.area_paint(fill)) {
|
||||
Some(text) => Cow::Owned(self.glyph_text(s, &layout, i, text, fill)),
|
||||
None => Cow::Borrowed(&bp),
|
||||
};
|
||||
let opaque = (1.0, BlendMode::Normal);
|
||||
if let Some(path) = to_path(&outlines)
|
||||
&& !self.area(s, &path, krilla::paint::FillRule::NonZero, fill, opaque, layout.bounds, outlines.bounding_box())
|
||||
&& let Some(paint) = self.paint(fill, layout.bounds)
|
||||
{
|
||||
s.set_stroke(None);
|
||||
s.set_fill(Some(Fill { paint, opacity: NormalizedF32::ONE, rule: krilla::paint::FillRule::NonZero }));
|
||||
s.draw_path(&path);
|
||||
}
|
||||
self.overprinting(s, run.style.overprint_fill, fill, |ex, s| {
|
||||
// The outlines left to fill as paths: all of them, or those real text leaves.
|
||||
let outlines = match plain.as_deref().filter(|_| !fill.is_none() && !ex.area_paint(fill)) {
|
||||
Some(text) => Cow::Owned(ex.glyph_text(s, &layout, i, text, fill)),
|
||||
None => Cow::Borrowed(&bp),
|
||||
};
|
||||
let opaque = (1.0, BlendMode::Normal);
|
||||
if let Some(path) = to_path(&outlines)
|
||||
&& !ex.area(s, &path, krilla::paint::FillRule::NonZero, fill, opaque, layout.bounds, outlines.bounding_box())
|
||||
&& let Some(paint) = ex.paint(fill, layout.bounds)
|
||||
{
|
||||
s.set_stroke(None);
|
||||
s.set_fill(Some(Fill { paint, opacity: NormalizedF32::ONE, rule: krilla::paint::FillRule::NonZero }));
|
||||
s.draw_path(&path);
|
||||
}
|
||||
});
|
||||
if run.style.has_stroke()
|
||||
&& let Some(path) = to_path(&bp)
|
||||
{
|
||||
// Character strokes are drawn in text space, with their cap, join and dashes.
|
||||
self.stroke(s, &bp, &path, FillRule::NonZero, &run.style.stroke_layer(), page, layout.bounds);
|
||||
let st = run.style.stroke_layer();
|
||||
self.overprinting(s, st.overprint, &st.paint, |ex, s| ex.stroke(s, &bp, &path, FillRule::NonZero, &st, page, layout.bounds));
|
||||
}
|
||||
}
|
||||
s.set_fill(None);
|
||||
|
|
@ -1296,16 +1325,18 @@ impl Exporter<'_> {
|
|||
fn text_items(&mut self, s: &mut Surface, items: &[AppearanceItem], bp: &BezPath, path: &Path, page: Rect, tb: Rect) {
|
||||
for item in items {
|
||||
match item {
|
||||
AppearanceItem::Fill(fl) if fl.visible => {
|
||||
if !self.area(s, path, krilla::paint::FillRule::NonZero, &fl.paint, (fl.opacity, fl.blend), tb, bp.bounding_box())
|
||||
&& let Some(paint) = self.paint(&fl.paint, tb)
|
||||
AppearanceItem::Fill(fl) if fl.visible => self.overprinting(s, fl.overprint, &fl.paint, |ex, s| {
|
||||
if !ex.area(s, path, krilla::paint::FillRule::NonZero, &fl.paint, (fl.opacity, fl.blend), tb, bp.bounding_box())
|
||||
&& let Some(paint) = ex.paint(&fl.paint, tb)
|
||||
{
|
||||
s.set_stroke(None);
|
||||
s.set_fill(Some(Fill { paint, opacity: norm(fl.opacity), rule: krilla::paint::FillRule::NonZero }));
|
||||
s.draw_path(path);
|
||||
}
|
||||
}),
|
||||
AppearanceItem::Stroke(st) if st.visible && st.width > 0.0 => {
|
||||
self.overprinting(s, st.overprint, &st.paint, |ex, s| ex.stroke(s, bp, path, FillRule::NonZero, st, page, tb))
|
||||
}
|
||||
AppearanceItem::Stroke(st) if st.visible && st.width > 0.0 => self.stroke(s, bp, path, FillRule::NonZero, st, page, tb),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,8 +1,9 @@
|
|||
//! What the PDF writer has no operators for — optional content (PDF layers) — drawn as form
|
||||
//! XObjects of their own (without a transparency group, so they draw as if in place), each
|
||||
//! starting with a mark: an empty clip whose first point says what the form is. Marked forms also
|
||||
//! stay apart (the writer shares identical forms). [`finish`] completes them in the written file:
|
||||
//! a layer's form is drawn as the layer's optional content (`/OC … BDC`).
|
||||
//! What the PDF writer has no operators for — optional content (PDF layers) and overprint — drawn
|
||||
//! as form XObjects of their own (without a transparency group, so they draw as if in place),
|
||||
//! each starting with a mark: an empty clip whose first point says what the form is. Marked
|
||||
//! forms also stay apart (the writer shares identical forms). [`finish`] completes them in the
|
||||
//! written file: a layer's form is drawn as the layer's optional content (`/OC … BDC`), and an
|
||||
//! overprinting form sets a graphics state that overprints first.
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::io::Read;
|
||||
|
|
@ -22,16 +23,21 @@ use crate::{PdfError, PdfSettings, Standard};
|
|||
pub(crate) enum Mark {
|
||||
/// The art of top-level layer `i` (`Document::layers`).
|
||||
Layer(usize),
|
||||
/// A fill or stroke that overprints.
|
||||
Overprint,
|
||||
}
|
||||
|
||||
/// The x coordinate of a layer mark's first point (its y is the layer index).
|
||||
const LAYER_X: i32 = -32000;
|
||||
/// The x coordinate of an overprint mark's first point.
|
||||
const OVERPRINT_X: i32 = -32001;
|
||||
|
||||
impl Mark {
|
||||
fn at(self) -> (f32, f32) {
|
||||
match self {
|
||||
// Exact in `f32` up to 2^24 layers.
|
||||
Self::Layer(i) => (LAYER_X as f32, i as f32),
|
||||
Self::Overprint => (OVERPRINT_X as f32, 0.0),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -59,13 +65,15 @@ pub(crate) fn form(s: &mut Surface, mark: Mark, draw: impl FnOnce(&mut Surface))
|
|||
|
||||
// ---------- finishing the written file ----------
|
||||
|
||||
/// The resource name of the overprinting graphics state.
|
||||
const OVERPRINT_GS: &str = "VCop";
|
||||
/// The prefix of the resource names of the layers' optional content groups (then the index).
|
||||
const LAYER_OC: &str = "VCoc";
|
||||
/// The most bytes of a form's content read to find its mark.
|
||||
const HEAD: u64 = 64;
|
||||
|
||||
fn bad(why: &str) -> PdfError {
|
||||
PdfError::Write(format!("can't write PDF layers: {why}"))
|
||||
PdfError::Write(format!("can't write PDF layers or overprint: {why}"))
|
||||
}
|
||||
|
||||
/// An object of the written file with a dictionary, and its stream's [`StreamSpans`].
|
||||
|
|
@ -113,6 +121,7 @@ impl Object<'_> {
|
|||
let (Some(b"q"), Some(x), Some(y), Some(b"m")) = (word(), word().and_then(int), word().and_then(int), word()) else { return None };
|
||||
match x {
|
||||
_ if x == i64::from(LAYER_X) => usize::try_from(y).ok().map(Mark::Layer),
|
||||
_ if x == i64::from(OVERPRINT_X) && y == 0 => Some(Mark::Overprint),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
|
@ -141,7 +150,8 @@ fn resources<'o>(objects: &'o HashMap<u32, Object<'_>>, o: &'o Object<'_>) -> Op
|
|||
}
|
||||
}
|
||||
|
||||
/// Add `entries` (`/VCoc0 12 0 R`) to the `category` (`Properties`) of resource dictionary `res`.
|
||||
/// Add `entries` (`/VCoc0 12 0 R`) to the `category` (`Properties`, `ExtGState`) of resource
|
||||
/// dictionary `res`.
|
||||
fn add_resources(patch: &mut Patch, res: &Obj<'_>, category: &str, entries: &str) -> Result<(), PdfError> {
|
||||
match (res.get(category.as_bytes()), res) {
|
||||
(Some(Obj::Dict { start, .. }), _) => patch.replace(start + 2, start + 2, entries.as_bytes().to_vec()),
|
||||
|
|
@ -191,16 +201,34 @@ fn mark_layers(content: &[u8], forms: &HashMap<&[u8], usize>) -> Option<(Vec<u8>
|
|||
/// Finish the marked forms of `pdf` (as [`crate::export`] writes `doc` with `set`): with
|
||||
/// `layers`, each top-level layer (but template layers) becomes an optional content group —
|
||||
/// named as the layer, off when it is hidden, not printed (`/PrintState /OFF`) when its Print
|
||||
/// option is off, locked when it is locked — and the uses of its forms its optional content.
|
||||
pub(crate) fn finish(pdf: Vec<u8>, doc: &Document, set: &PdfSettings, layers: bool) -> Result<Vec<u8>, PdfError> {
|
||||
if !layers {
|
||||
/// option is off, locked when it is locked — and the uses of its forms its optional content;
|
||||
/// with `overprint`, the overprinting forms get a graphics state that overprints (`/OP`, `/op`,
|
||||
/// `/OPM 1`; `/OPM 0` in PDF/A, which allows no other with ICC-based CMYK colours).
|
||||
pub(crate) fn finish(pdf: Vec<u8>, doc: &Document, set: &PdfSettings, layers: bool, overprint: bool) -> Result<Vec<u8>, PdfError> {
|
||||
if !layers && !overprint {
|
||||
return Ok(pdf);
|
||||
}
|
||||
let xref = Xref::read(&pdf).ok_or_else(|| bad("the written PDF has no cross-reference table"))?;
|
||||
let objects = objects(&pdf, &xref);
|
||||
let marks: HashMap<u32, Mark> = objects.iter().filter_map(|(n, o)| Some((*n, o.mark(&pdf)?))).collect();
|
||||
let mut patch = Patch::new(&xref);
|
||||
write_layers(&pdf, &xref, &objects, &marks, &mut patch, doc, set)?;
|
||||
if overprint {
|
||||
let opm = u8::from(set.standard != Standard::PdfA2b);
|
||||
let gs = patch.add_object(format!("<</Type/ExtGState/OP true/op true/OPM {opm}>>").into_bytes());
|
||||
for (n, _) in marks.iter().filter(|(_, m)| **m == Mark::Overprint) {
|
||||
let Some(o) = objects.get(n) else { continue };
|
||||
let (Some(content), Some(res)) = (o.data(&pdf, u64::MAX), resources(&objects, o)) else {
|
||||
return Err(bad("an overprinting form can't be read"));
|
||||
};
|
||||
let mut new = format!("/{OVERPRINT_GS} gs\n").into_bytes();
|
||||
new.extend_from_slice(&content);
|
||||
o.rewrite(&mut patch, &new)?;
|
||||
add_resources(&mut patch, res, "ExtGState", &format!("/{OVERPRINT_GS} {gs} 0 R"))?;
|
||||
}
|
||||
}
|
||||
if layers {
|
||||
write_layers(&pdf, &xref, &objects, &marks, &mut patch, doc, set)?;
|
||||
}
|
||||
let pdf = patch.apply(&pdf, &xref)?;
|
||||
// The file still is what its standard says.
|
||||
crate::pdfx::verify(&pdf, set.standard)?;
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
//! given an output intent as the Output settings say. Hidden objects,
|
||||
//! guides and template layers are skipped, and so are non-printing layers unless asked for.
|
||||
//! Top-level layers can be PDF layers (optional content groups with their visibility, print
|
||||
//! state and lock).
|
||||
//! state and lock), and overprinting fills and strokes overprint (Advanced).
|
||||
//! Each page is its artboard (the trim box) grown by the bleed (the bleed box) and by the
|
||||
//! printer's marks around it (the media box), drawn in Registration. [`PdfSettings`] is the Save PDF
|
||||
//! dialog's model (standard, compatibility, General, Compression, Marks and Bleeds, Output,
|
||||
|
|
|
|||
|
|
@ -230,11 +230,6 @@ impl<'a> Job<'a> {
|
|||
if !postscript && separations && set.output.inks.iter().any(|i| i.frequency.is_some() || i.angle.is_some()) {
|
||||
warnings.push("ink frequencies and angles are not written as halftone screens yet: the output device's screens apply".into());
|
||||
}
|
||||
if !separations && doc.layers.iter().any(|l| l.has_overprint()) {
|
||||
warnings.push(
|
||||
"overprinting fills and strokes print as knockouts in composite output (separations honour them; Simulate Overprints prints them as Overprint Preview shows them)".into(),
|
||||
);
|
||||
}
|
||||
if separations && set.advanced.print_as_bitmap {
|
||||
warnings.push("Print as Bitmap is for composite output: separations print the art as it is".into());
|
||||
}
|
||||
|
|
@ -411,16 +406,20 @@ pub fn print(doc: &Document, opts: &PrintOptions) -> Result<PrintReport, PdfErro
|
|||
ex.intent = opts.settings.color.intent;
|
||||
// The writer's colour output: the printer profile's conversion.
|
||||
ex.out = w.out.clone();
|
||||
// Composite output keeps overprints as the Advanced option says (plates multiply them).
|
||||
ex.overprint = !separations && pdf.advanced.overprint == Overprint::Preserve;
|
||||
}
|
||||
for &i in &plan.order {
|
||||
let Some(s) = plan.sheets.get(i) else { continue };
|
||||
let Some(ex) = exporters.get_mut(s.plate.unwrap_or(0)) else { continue };
|
||||
w.page(ex, &s.sheet())?;
|
||||
}
|
||||
let overprinted = exporters.iter().any(|ex| ex.overprinted);
|
||||
for ex in exporters {
|
||||
w.absorb(ex);
|
||||
}
|
||||
let (bytes, more) = w.finish()?;
|
||||
let bytes = crate::forms::finish(bytes, doc, &pdf, false, overprinted)?;
|
||||
let mut warnings = plan.warnings;
|
||||
for m in more {
|
||||
if !warnings.contains(&m) {
|
||||
|
|
|
|||
|
|
@ -1,11 +1,12 @@
|
|||
//! Save PDF › Create PDF layers: an optional content group per top-level layer, with its
|
||||
//! visibility, print state and lock.
|
||||
//! Save PDF › Create PDF layers (an optional content group per top-level layer, with its
|
||||
//! visibility, print state and lock) and Advanced › Overprint (a graphics state that overprints
|
||||
//! for the overprinting fills and strokes).
|
||||
|
||||
use hayro_syntax::object::{Array, Dict, Name, ObjectIdentifier};
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_color::{Color, Paint};
|
||||
use vectorcraft_doc::{Appearance, Document, LayerColor, Node, NodeKind};
|
||||
use vectorcraft_geom::{Rect, shapes};
|
||||
use vectorcraft_doc::{Appearance, CharStyle, Document, LayerColor, Node, NodeKind, TextObject};
|
||||
use vectorcraft_geom::{Point, Rect, shapes};
|
||||
|
||||
use crate::*;
|
||||
|
||||
|
|
@ -215,3 +216,78 @@ fn layered_art_imports_as_it_was_drawn() {
|
|||
assert_eq!(plain.len(), 3);
|
||||
assert_eq!(leaves(&import(&export(&d, json!({"createLayers": true})).bytes).unwrap()), plain, "the marks draw nothing");
|
||||
}
|
||||
|
||||
/// A rectangle whose fill overprints, one whose stroke does, a plain one and type whose
|
||||
/// characters' fill overprints, filled with `fill` (the overprinting rectangle).
|
||||
fn overprinting(fill: Color) -> Document {
|
||||
let mut d = Document::new(300.0, 100.0);
|
||||
let l = d.layers[0].id;
|
||||
let mut a = rect(&mut d, 10.0, fill);
|
||||
if let Some(f) = a.appearance.fill_mut() {
|
||||
f.overprint = true;
|
||||
}
|
||||
let mut b =
|
||||
Node::path(d.alloc_id(), shapes::rectangle(Rect::new(50.0, 10.0, 80.0, 40.0)), Appearance::basic(Paint::None, Paint::solid(BLUE), 2.0));
|
||||
if let Some(s) = b.appearance.stroke_mut() {
|
||||
s.overprint = true;
|
||||
}
|
||||
let c = rect(&mut d, 90.0, GREEN);
|
||||
let style = CharStyle { size: 24.0, fill: Paint::solid(Color::BLACK), overprint_fill: true, ..Default::default() };
|
||||
let t = Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(Point::new(130.0, 40.0), "Ink", style))));
|
||||
for (i, n) in [a, b, c, t].into_iter().enumerate() {
|
||||
d.insert(Some(l), i, n).unwrap();
|
||||
}
|
||||
d
|
||||
}
|
||||
|
||||
/// The uncompressed export of `d` with `v`: the overprinting graphics states it defines, and the
|
||||
/// forms that set one.
|
||||
fn overprints(d: &Document, v: Value) -> (usize, usize) {
|
||||
let mut v = v;
|
||||
v["compression"] = json!({"compressText": false});
|
||||
let r = export(d, v);
|
||||
assert!(r.warnings.iter().all(|w| !w.contains("overprint")), "{:?}", r.warnings);
|
||||
let text = String::from_utf8_lossy(&r.bytes).into_owned();
|
||||
(text.matches("/Type/ExtGState/OP true/op true/OPM 1").count(), text.matches("stream\n/VCop gs\n").count())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn overprint_preserve_writes_an_overprinting_graphics_state() {
|
||||
let d = overprinting(RED);
|
||||
assert_eq!(overprints(&d, json!({})), (1, 3), "the fill, the stroke and the characters' fill");
|
||||
assert_eq!(overprints(&d, json!({"advanced": {"overprint": "discard"}})), (0, 0));
|
||||
assert_eq!(overprints(&overprinting(RED), json!({"createLayers": true})), (1, 3), "with PDF layers too");
|
||||
// Nothing overprints: no graphics state.
|
||||
assert_eq!(overprints(&layered(), json!({})), (0, 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn white_overprint_is_discarded_as_the_document_setup_says() {
|
||||
let mut d = overprinting(Color::WHITE);
|
||||
assert!(d.setup.discard_white_overprint);
|
||||
assert_eq!(overprints(&d, json!({})).1, 2, "the white fill knocks out");
|
||||
d.setup.discard_white_overprint = false;
|
||||
assert_eq!(overprints(&d, json!({})).1, 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pdf_a_overprint_mode_is_0() {
|
||||
let r = export(&overprinting(RED), json!({"standard": "pdfA2b", "compression": {"compressText": false}}));
|
||||
let text = String::from_utf8_lossy(&r.bytes);
|
||||
assert!(text.contains("/OP true/op true/OPM 0") && !text.contains("/OPM 1"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn overprinting_art_imports_as_it_was_drawn() {
|
||||
let d = overprinting(RED);
|
||||
let plain = leaves(&import(&export(&d, json!({"advanced": {"overprint": "discard"}})).bytes).unwrap());
|
||||
for v in [json!({}), json!({"createLayers": true})] {
|
||||
assert_eq!(leaves(&import(&export(&d, v.clone()).bytes).unwrap()), plain, "{v}: the marks draw nothing");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pdf_x1a_keeps_overprint() {
|
||||
let r = export(&overprinting(RED), json!({"standard": "pdfX1a", "compatibility": "1.4", "compression": {"compressText": false}}));
|
||||
assert!(r.bytes.starts_with(b"%PDF-1.3") && String::from_utf8_lossy(&r.bytes).contains("/OP true/op true/OPM 1"));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -95,7 +95,8 @@ fn settings_saved_before_the_advanced_options_load_with_their_defaults() {
|
|||
fn discarded_and_simulated_overprints_write_no_overprint() {
|
||||
let d = overprinted();
|
||||
let preserve = job(&d, json!({}));
|
||||
assert!(preserve.warnings.iter().any(|w| w.contains("knockouts")), "{:?}", preserve.warnings);
|
||||
assert!(preserve.warnings.is_empty(), "{:?}", preserve.warnings);
|
||||
assert!(String::from_utf8_lossy(&preserve.bytes).contains("/OP true/op true/OPM 1"), "preserved overprints overprint in the file");
|
||||
assert!(overprints(&printed_document(&d, &settings(json!({})))), "preserved");
|
||||
for (how, multiplies) in [("discard", false), ("simulate", true)] {
|
||||
let set = json!({"advanced": {"overprints": how}});
|
||||
|
|
|
|||
|
|
@ -451,6 +451,9 @@ of knocking them out. `object.setOverprint {fill?, stroke?, item?, ids?}` sets i
|
|||
characters too; `item` aims at one appearance item) and `attributes.info {ids?}` reads it back (`null` where the
|
||||
objects differ). Overprint Preview (`view.overprintPreview`) and Separations Preview show it; rendering approximates
|
||||
it by multiplying. Older files that listed Overprint Black objects in the document get the flags on load.
|
||||
PDF export writes them with `advanced.overprint: "preserve"` (the default): each overprinting fill and stroke sets a
|
||||
graphics state with `/OP true /op true /OPM 1` (`/OPM 0` in PDF/A). With `discardWhiteOverprint` (`document.setup`, on by
|
||||
default) white ones knock out instead; `"discard"` writes none.
|
||||
|
||||
```json
|
||||
{"name":"run_command","arguments":{"command":"object.setOverprint","params":{"ids":[12],"stroke":true}}}
|
||||
|
|
@ -1303,7 +1306,7 @@ documents every field:
|
|||
with; without preserveNumbers CMYK colours are separated again).
|
||||
|
||||
Halftone screens and a fixed flatness are not written to the PDF (the output device's apply): the warnings say so,
|
||||
as they do for art larger than the imageable area and for overprints in composite output.
|
||||
as they do for art larger than the imageable area.
|
||||
|
||||
```json
|
||||
{"name":"run_command","arguments":{"command":"print.setup","params":{"settings":{"media":"a4","scaling":"fit","marks":{"trim":true}}}}}
|
||||
|
|
@ -1614,7 +1617,8 @@ the placement then shows as placed by the tool, with a Reset button; dragging th
|
|||
|
||||
The Print dialog's Advanced section and the printer profile are print settings too (`print.setup`, `print.preview`,
|
||||
`file.print`): `advanced: {printAsBitmap, overprints: preserve|discard|simulate, flattenerPreset}` and `color:
|
||||
{profile}`. In composite output, `discard` makes overprinting fills and strokes knock out and `simulate` prints them
|
||||
{profile}`. In composite output, `preserve` writes overprinting fills and strokes with an overprinting graphics state
|
||||
(`/OP`, as PDF export does), `discard` makes overprinting fills and strokes knock out and `simulate` prints them
|
||||
as Overprint Preview shows them (multiplied); either way the file has no overprint left. Separations always keep
|
||||
overprints. `flattenerPreset` (High Resolution, Medium Resolution, Low Resolution or a saved preset,
|
||||
`flattener.presets.list`) flattens transparency before printing, as Object → Flatten Transparency does; empty, a
|
||||
|
|
|
|||
Loading…
Reference in New Issue