856f865cf98d
pdf_editable.rs
//! Experimental editable PDF import: a `craft-pdf` device turns painted paths into shape layers
//! and embedded-font text into text layers.
//!
//! Solid fills and strokes become [`ShapeLayer`]s in document pixels; embedded fonts whose glyphs
//! carry Unicode and a PostScript name become [`photocraft_doc::TextLayer`]s, with the font bytes
//! registered in the app's shared text engine. A page-sized axis-aligned clip that contains the
//! artboard is a no-op and is accepted. Images, other clipping paths, transparency groups,
//! patterns, soft masks, annotations and unsupported text mark the page unsupported, and the
//! caller falls back to the raster importer for that page with a warning. Nothing is ever half
//! imported.
//!
//! This is the app-owned `Device` route: Hayro's interpreter walks the page and reports each
//! paint with its real colour and geometry, so shape layers need no page raster underneath. That
//! is what makes moving or deleting a layer behave, and what avoids the black-path and
//! doubled-text failures of the old PDFium import.
use std::collections::hash_map::DefaultHasher;
use std::collections::{HashMap, HashSet};
use std::hash::{Hash, Hasher};
use std::panic::AssertUnwindSafe;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
use std::time::Duration;
use craft_pdf::interpret::color::Color as HayroColor;
use craft_pdf::interpret::font::{FontData, Glyph, OutlineFontData};
use craft_pdf::interpret::{
BlendMode, ClipPath, Context, Device, GlyphDrawMode, Image, InterpreterCache, InterpreterSettings, InterpreterWarning, Paint, PathDrawMode, SoftMask,
TransformExt, interpret_page,
};
use craft_pdf::syntax::page::Page;
use kurbo::{Affine as KurboAffine, BezPath, Cap, Join, PathEl};
use photocraft_color::{Color, ColorMode, PixelFormat, SampleType};
use photocraft_doc::text::{CharStyle, TextRun};
use photocraft_doc::vector::{FillRule, Knot, LineCap, LineJoin, Path, PathOp, ShapeLayer, ShapeStroke, StrokeAlign, Subpath};
use photocraft_doc::{Fill, Layer, LayerContent, TextLayer};
use photocraft_geom::{Affine, Point, Rect, TILE_SIZE};
use photocraft_raster::Interrupt;
/// Most layers one editable page may create; past it the page falls back to raster.
const MAX_LAYERS: usize = 20_000;
/// Most path knots one editable page may hold; past it the page falls back to raster.
const MAX_KNOTS: usize = 1_000_000;
/// Allocated tile bytes of all shape and text caches retained by one editable page.
const MAX_CACHE_BYTES: u64 = 256 << 20;
/// Bound text collection before building its layers and caches, including repeated overprinting.
const MAX_GLYPHS: usize = 100_000;
/// The strings in collected glyph records must also fit, not just their record count.
const MAX_GLYPH_BYTES: usize = 16 << 20;
/// Cap on fill/stroke glyph comparisons so hostile pages cannot make pairing quadratic forever.
const MAX_PAIR_CHECKS: usize = 1_000_000;
/// How often the watcher copies the interrupt into craft-pdf's cancellation flag. The Device's
/// callbacks are only reached per paint, so a page with one long path still needs this; 20 ms
/// keeps wakeups negligible while staying responsive.
const POLL: Duration = Duration::from_millis(20);
/// Largest gap (in em) inside one run before a space is inserted.
const WORD_GAP: f64 = 0.2;
/// Largest baseline offset (in em) for glyphs to share one line.
const LINE_TOLERANCE: f64 = 0.30;
/// Why an editable page could not be built.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum EditableError {
/// The caller cancelled the import.
Cancelled,
/// The page uses something this first step cannot represent; rasterise it instead.
Unsupported(&'static str),
}
/// Builds one page's shape layers in document coordinates inside `rect`.
///
/// `rect` is the page's artboard in document pixels; the page's displayed size comes from
/// `Page::render_dimensions()` (CropBox, rotation and UserUnit already applied), so a point maps
/// to `rect` by the per-axis scale `rect.size / render_dimensions`. Nothing here re-applies the
/// CropBox offset or rotation.
pub fn page(page: &Page<'_>, rect: Rect, ctl: &Interrupt) -> Result<Vec<Layer>, EditableError> {
ctl.check().map_err(|_| EditableError::Cancelled)?;
let (width_pt, height_pt) = page.render_dimensions();
if !width_pt.is_finite() || !height_pt.is_finite() || width_pt <= 0.0 || height_pt <= 0.0 {
return Err(EditableError::Unsupported("the page has no area"));
}
let sx = f64::from(rect.width()) / f64::from(width_pt);
let sy = f64::from(rect.height()) / f64::from(height_pt);
let doc = Affine::translate(f64::from(rect.x0), f64::from(rect.y0)).mul(&Affine { m: [sx, 0.0, 0.0, sy, 0.0, 0.0] });
let fmt = PixelFormat::new(ColorMode::Rgb, SampleType::U8, true);
let cancelled = Arc::new(AtomicBool::new(false));
let finished = Arc::new(AtomicBool::new(false));
let warned = Arc::new(AtomicU8::new(0));
let sink = Arc::clone(&warned);
let settings = InterpreterSettings {
cancelled: Some(Arc::clone(&cancelled)),
warning_sink: Arc::new(move |warning| {
let bit = match warning {
InterpreterWarning::ImageDecodeFailure => 1,
InterpreterWarning::UnsupportedFont => 2,
InterpreterWarning::ContentTruncated => 4,
};
sink.fetch_or(bit, Ordering::Relaxed);
}),
..InterpreterSettings::default()
};
let cache = InterpreterCache::new();
let mut device = PathDevice {
doc,
clip: rect,
fmt,
dpi: 72.0 * sx,
ctl: *ctl,
layers: Vec::new(),
glyphs: Vec::new(),
glyph_bytes: 0,
strokes: Vec::new(),
fonts: Vec::new(),
font_keys: HashMap::new(),
seen_fonts: HashSet::new(),
soft_mask: false,
clips: Vec::new(),
knots: 0,
cached: 0,
unsupported: None,
cancelled: false,
};
std::thread::scope(|scope| {
let flag = Arc::clone(&cancelled);
let done = Arc::clone(&finished);
let ctl = *ctl;
scope.spawn(move || {
while !done.load(Ordering::Relaxed) {
if ctl.cancelled() {
flag.store(true, Ordering::Relaxed);
}
std::thread::sleep(POLL);
}
});
// A hostile page must not take the process down. This only guards profiles that unwind;
// a `panic = "abort"` build aborts here just as the raster path would.
let result = std::panic::catch_unwind(AssertUnwindSafe(|| {
let bbox = kurbo::Rect::new(0.0, 0.0, f64::from(width_pt), f64::from(height_pt));
let mut context = Context::new(page.initial_transform(true).to_kurbo(), bbox, &cache, page.xref(), settings);
interpret_page(page, &mut context, &mut device);
}));
if result.is_err() {
device.unsupported = Some("the page could not be interpreted");
}
finished.store(true, Ordering::Relaxed);
});
if device.cancelled || ctl.cancelled() {
return Err(EditableError::Cancelled);
}
let warned = warned.load(Ordering::Relaxed);
if warned & 4 != 0 {
return Err(EditableError::Unsupported("the page content was truncated"));
}
if warned & 2 != 0 {
return Err(EditableError::Unsupported("a font could not be used"));
}
if warned & 1 != 0 {
return Err(EditableError::Unsupported("an image could not be decoded"));
}
if let Some(reason) = device.unsupported {
return Err(EditableError::Unsupported(reason));
}
pair_fake_bold(&mut device.glyphs, device.strokes, ctl)?;
let families = register_fonts(&device.fonts)?;
let texts = text_layers(&device.glyphs, &families, device.dpi, ctl)?;
if device.layers.len().saturating_add(texts.len()) > MAX_LAYERS {
return Err(EditableError::Unsupported("too many objects"));
}
let mut layers = merge_text_layers(device.layers, texts);
render_text_caches(&mut layers, device.dpi, device.fmt, ctl, &mut device.cached)?;
Ok(layers)
}
/// Removes stroked glyphs that duplicate a fill at the same place, marking that glyph fake bold.
fn pair_fake_bold(glyphs: &mut [GlyphRun], strokes: Vec<GlyphRun>, ctl: &Interrupt) -> Result<(), EditableError> {
// Index fills by the exact attributes a stroke must match, so each stroke only compares
// against candidates at its own paint order/font/text instead of the whole page.
let mut index: HashMap<(usize, u128, u64), Vec<usize>> = HashMap::new();
for (at, glyph) in glyphs.iter().enumerate() {
if at.is_multiple_of(256) && ctl.check().is_err() {
return Err(EditableError::Cancelled);
}
index.entry((glyph.order, glyph.font.key, text_hash(&glyph.text))).or_default().push(at);
}
let mut paired = vec![false; glyphs.len()];
let mut checks = 0usize;
for stroke in strokes {
let mut found = None;
if let Some(candidates) = index.get(&(stroke.order, stroke.font.key, text_hash(&stroke.text))) {
for &at in candidates {
if paired[at] {
continue;
}
if checks == MAX_PAIR_CHECKS {
return Err(EditableError::Unsupported("too much stroked text"));
}
if checks.is_multiple_of(256) && ctl.check().is_err() {
return Err(EditableError::Cancelled);
}
checks += 1;
let glyph = &glyphs[at];
let tolerance = 0.01 * glyph.size_px + 0.01;
if glyph.text == stroke.text
&& same_style(glyph, &stroke)
&& (glyph.origin.x - stroke.origin.x).abs() <= tolerance
&& (glyph.origin.y - stroke.origin.y).abs() <= tolerance
{
found = Some(at);
break;
}
}
}
let Some(at) = found else {
return Err(EditableError::Unsupported("stroked text"));
};
glyphs[at].fake_bold = true;
paired[at] = true;
}
Ok(())
}
/// A hash of a glyph string for the fake-bold index; equality is still checked on the string.
fn text_hash(text: &str) -> u64 {
let mut hasher = DefaultHasher::new();
text.hash(&mut hasher);
hasher.finish()
}
/// Builds one point-text layer per line and style run, with the layer index it must be inserted
/// at to preserve paint order relative to paths.
fn text_layers(
glyphs: &[GlyphRun],
families: &std::collections::HashMap<u128, String>,
dpi: f64,
ctl: &Interrupt,
) -> Result<Vec<(usize, Layer)>, EditableError> {
let mut out = Vec::new();
let mut i = 0;
while i < glyphs.len() {
ctl.check().map_err(|_| EditableError::Cancelled)?;
if out.len() >= MAX_LAYERS {
return Err(EditableError::Unsupported("too many text objects"));
}
let first = &glyphs[i];
let family = families.get(&first.font.key).cloned().unwrap_or_else(|| first.font.family.clone());
let (dx, dy) = (first.angle.cos(), first.angle.sin());
let (nx, ny) = (-dy, dx);
let baseline = first.origin.x * nx + first.origin.y * ny;
let start = i;
let mut text = String::new();
let mut positions = Vec::new();
let mut last = first;
while i < glyphs.len() {
let glyph = &glyphs[i];
if glyph.order != first.order || !same_style(glyph, first) {
break;
}
let line = glyph.origin.x * nx + glyph.origin.y * ny;
if (line - baseline).abs() > LINE_TOLERANCE * first.size_px {
break;
}
if i > start {
let along = (glyph.origin.x - first.origin.x) * dx + (glyph.origin.y - first.origin.y) * dy;
let prev = (last.origin.x - first.origin.x) * dx + (last.origin.y - first.origin.y) * dy;
let gap = along - (prev + last.advance);
if gap > 3.0 * first.size_px {
break;
}
if gap > WORD_GAP * first.size_px && !text.ends_with(' ') {
text.push(' ');
}
}
positions.push((text.len(), glyph.origin));
text.push_str(&glyph.text);
last = glyph;
i += 1;
}
if !text.is_empty() && has_ink(&text) {
let layer = text_layer(text, first, out.len(), &family);
if let LayerContent::Text(text) = &layer.content {
let shared = photocraft_text::shared();
let mut engine = shared.lock().unwrap_or_else(|error| error.into_inner());
let layout = engine.layout(text, dpi as f32);
// PDF spacing is already in the glyph origins. A word-gap heuristic cannot
// preserve TJ, character spacing, or explicitly positioned glyphs. Keep a run
// editable only if the actual text layout reproduces every recorded origin.
let clusters: std::collections::HashMap<_, _> = layout.clusters.iter().map(|c| (c.range.start, c)).collect();
for (offset, expected) in positions {
let cluster = clusters.get(&offset);
let actual =
cluster.and_then(|c| layout.lines.get(c.line).map(|line| text.transform.apply(Point::new(f64::from(c.x), f64::from(line.baseline)))));
if actual.is_none_or(|at| (at.x - expected.x).abs() > 0.5 || (at.y - expected.y).abs() > 0.5) {
return Err(EditableError::Unsupported("text positioning"));
}
}
}
out.push((first.order, layer));
}
if i == start {
i += 1;
}
}
Ok(out)
}
/// Whether `b` belongs to the same line and style run as `a`.
fn same_style(a: &GlyphRun, b: &GlyphRun) -> bool {
let weight = |glyph: &GlyphRun| if glyph.fake_bold { 700 } else { glyph.font.weight };
a.font.key == b.font.key
&& a.font.family == b.font.family
&& a.font.italic == b.font.italic
&& weight(a) == weight(b)
&& (a.size_pt - b.size_pt).abs() < 0.05
&& (a.angle - b.angle).abs() < 0.02
&& (a.color.c[0] - b.color.c[0]).abs() < 0.004
&& (a.color.c[1] - b.color.c[1]).abs() < 0.004
&& (a.color.c[2] - b.color.c[2]).abs() < 0.004
&& (a.color.alpha - b.color.alpha).abs() < 0.004
}
/// One line's point-text layer, with the family the shared engine registered.
fn text_layer(text: String, run: &GlyphRun, number: usize, family: &str) -> Layer {
let weight = if run.fake_bold { 700 } else { run.font.weight };
let font_style = match (weight >= 600, run.font.italic) {
(true, true) => "Bold Italic",
(true, false) => "Bold",
(false, true) => "Italic",
(false, false) => "Regular",
};
let style = CharStyle {
font_family: family.to_string(),
font_style: font_style.to_string(),
postscript_name: Some(run.font.postscript.clone()),
weight: u16::try_from(weight).unwrap_or(400),
italic: run.font.italic,
faux_bold: run.fake_bold,
// PDF positions already contain kerning; applying font kerning again moves glyphs.
kerning: photocraft_doc::text::Kerning::Off,
size_pt: run.size_pt as f32,
color: run.color,
..CharStyle::default()
};
let layer = TextLayer {
text: text.clone(),
font_family: family.to_string(),
size_pt: run.size_pt as f32,
color: run.color,
transform: Affine::translate(run.origin.x, run.origin.y).mul(&Affine::rotate(run.angle)),
runs: vec![TextRun { len: text.len(), style }],
..TextLayer::default()
};
Layer::new(format!("Text {}", number + 1), LayerContent::Text(layer))
}
/// Registers each embedded face with the shared engine under its content-keyed family and returns
/// the family each font key must use.
fn register_fonts(fonts: &[(u128, String, String, FontData)]) -> Result<std::collections::HashMap<u128, String>, EditableError> {
let shared = photocraft_text::shared();
let mut families = std::collections::HashMap::new();
for (key, postscript, derived, data) in fonts {
// Copy before taking the engine lock; parsing still happens under it, but the UI's
// layout is not blocked while the bytes are cloned.
let bytes = data.as_ref().as_ref().to_vec();
let mut engine = shared.lock().unwrap_or_else(|error| error.into_inner());
// Prefer an installed full family; a subset only holds the glyphs the page uses. The
// Device has the font program's PostScript name, not the PDF `/BaseFont`; a content-keyed
// alias keeps two documents' subsets of one name apart for the life of the shared engine,
// and the same face imported twice reuses its registration.
let family = if engine.has_family(derived) {
derived.clone()
} else {
let alias = font_alias(postscript, *key);
if engine.has_family(&alias) {
alias
} else {
let names = engine.register_font_data_as(bytes, &alias);
if names.is_empty() && !engine.has_family(&alias) {
return Err(EditableError::Unsupported("a font could not be registered"));
}
names.first().cloned().unwrap_or(alias)
}
};
families.insert(*key, family);
}
Ok(families)
}
/// Renders the text caches so the page is complete before the engine refreshes it.
fn render_text_caches(layers: &mut [Layer], dpi: f64, fmt: PixelFormat, ctl: &Interrupt, cached: &mut u64) -> Result<(), EditableError> {
let shared = photocraft_text::shared();
for layer in layers {
if ctl.check().is_err() {
return Err(EditableError::Cancelled);
}
if let LayerContent::Text(text) = &mut layer.content
&& has_ink(&text.text)
{
// Re-lock per layer so a text-heavy import does not hold the UI's engine for the
// whole cache-render loop.
let mut engine = shared.lock().unwrap_or_else(|error| error.into_inner());
let layout = engine.layout(text, dpi as f32);
let area = photocraft_text::render::ink_rect(&layout, &text.transform);
admit_cache(cached, area, fmt)?;
let rendered = photocraft_text::render::rasterize(&layout, &text.transform, fmt, text.antialias);
let rect = rendered.rect;
text.cache = Some(rendered.surface);
if rect.width() == 0 || rect.height() == 0 {
return Err(EditableError::Unsupported("a text cache could not be rendered"));
}
}
}
Ok(())
}
/// Reserves complete tiles before rendering: even one painted pixel allocates a whole tile.
fn admit_cache(cached: &mut u64, area: Rect, fmt: PixelFormat) -> Result<(), EditableError> {
let bytes = area.tile_count().saturating_mul(TILE_SIZE as u64).saturating_mul(TILE_SIZE as u64).saturating_mul(fmt.bytes_per_pixel() as u64);
let total = cached.saturating_add(bytes);
if total > MAX_CACHE_BYTES {
return Err(EditableError::Unsupported("page cache budget"));
}
*cached = total;
Ok(())
}
/// Puts text layers back at the path index where their glyphs were painted.
fn merge_text_layers(layers: Vec<Layer>, mut texts: Vec<(usize, Layer)>) -> Vec<Layer> {
texts.sort_by_key(|(order, _)| *order);
let mut out = Vec::with_capacity(layers.len() + texts.len());
let mut texts = texts.into_iter().peekable();
for (index, layer) in layers.into_iter().enumerate() {
while texts.peek().is_some_and(|(order, _)| *order <= index) {
if let Some((_, text)) = texts.next() {
out.push(text);
}
}
out.push(layer);
}
out.extend(texts.map(|(_, layer)| layer));
out
}
/// A content key for an embedded face, used to group its glyphs and to keep aliases unique.
fn font_content_key(data: &OutlineFontData) -> u128 {
let hash = blake3::hash(data.data.as_ref().as_ref());
let mut key = [0u8; 16];
key.copy_from_slice(&hash.as_bytes()[..16]);
u128::from_le_bytes(key)
}
/// Whether text has a visible character (not only spaces, controls or zero-width marks).
fn has_ink(text: &str) -> bool {
text.chars().any(|c| !c.is_whitespace() && !c.is_control() && !matches!(c, '\u{200B}'..='\u{200F}' | '\u{2060}' | '\u{FEFF}'))
}
/// The family alias an embedded face is registered under: its PostScript name plus a content
/// key, so subsets with the same name from different documents cannot replace each other.
fn font_alias(postscript: &str, key: u128) -> String {
format!("{postscript} {key:016x}")
}
/// Collects filled and stroked paths and glyph runs; anything else marks the page unsupported.
struct PathDevice<'a> {
/// Page points to document pixels: translation to the artboard plus the per-axis scale.
doc: Affine,
/// The page's artboard in document pixels; shape caches and strokes are clipped to it.
clip: Rect,
/// Document pixel format the shape caches are rendered in.
fmt: PixelFormat,
/// Document DPI, for text-layer caches.
dpi: f64,
ctl: Interrupt<'a>,
layers: Vec<Layer>,
/// Filled glyphs in content order.
glyphs: Vec<GlyphRun>,
glyph_bytes: usize,
/// Stroked glyphs, paired with a fill at the same place to recognise fake bold.
strokes: Vec<GlyphRun>,
/// Embedded fonts met on the page: cache key, PostScript name, derived family and bytes.
fonts: Vec<(u128, String, String, FontData)>,
/// Hayro's cheap font identity → our content hash, so bytes are hashed once per face.
font_keys: HashMap<u128, u128>,
/// Content keys of fonts already in [`Self::fonts`], so glyph callbacks do not scan it.
seen_fonts: HashSet<u128>,
/// Whether a soft mask is active; the first paint under one falls back the page.
soft_mask: bool,
/// One entry per clip pushed by the interpreter: `true` for an accepted no-op clip.
clips: Vec<bool>,
knots: usize,
/// Allocated tile bytes of caches retained so far.
cached: u64,
unsupported: Option<&'static str>,
cancelled: bool,
}
/// One drawn glyph with the style the text layer needs.
struct GlyphRun {
text: String,
/// Baseline origin in document pixels.
origin: Point,
size_pt: f64,
/// Em size in document pixels.
size_px: f64,
/// Baseline direction in radians (view space, y down).
angle: f64,
/// Advance in document pixels.
advance: f64,
font: FontInfo,
/// How many layers had been drawn when this glyph was painted; text runs split at a path
/// between glyphs so paint order is preserved.
order: usize,
color: Color,
/// Drawn both filled and stroked: word-processor fake bold.
fake_bold: bool,
}
/// The font style a run carries.
#[derive(Clone)]
struct FontInfo {
/// Hayro's font cache key, to group glyphs of one font.
key: u128,
family: String,
postscript: String,
weight: u32,
italic: bool,
}
impl PathDevice<'_> {
/// Stops collecting at the first thing this step cannot represent.
fn unsupported(&mut self, reason: &'static str) {
if self.unsupported.is_none() {
self.unsupported = Some(reason);
}
}
/// Whether `clip` is an axis-aligned rectangle that contains the whole artboard, so it
/// changes nothing in document space and can be ignored.
fn no_op_clip(&self, clip: &ClipPath) -> bool {
let Some((x0, y0, x1, y1)) = axis_aligned_rect(&clip.path) else { return false };
let a = self.doc.apply(Point::new(x0, y0));
let b = self.doc.apply(Point::new(x1, y1));
let (dx0, dx1) = (a.x.min(b.x), a.x.max(b.x));
let (dy0, dy1) = (a.y.min(b.y), a.y.max(b.y));
let board = self.clip;
dx0 <= f64::from(board.x0) + 0.5 && dy0 <= f64::from(board.y0) + 0.5 && dx1 >= f64::from(board.x1) - 0.5 && dy1 >= f64::from(board.y1) - 0.5
}
/// Adds one shape layer unless a page cap is reached. Renders its pixel cache within the
/// page's cache budget so the layer is visible before the engine refreshes it.
fn push_shape(&mut self, path: Path, fill: Option<Fill>, stroke: Option<ShapeStroke>) {
if self.ctl.check().is_err() {
self.cancelled = true;
return;
}
if path.is_empty() {
return;
}
if stroke.as_ref().is_some_and(|stroke| !stroke.dashes.is_empty()) && path.subpaths.iter().any(is_zero_length) {
// A dashed zero-length subpath cannot be reproduced as a single point.
self.unsupported("a dashed zero-length subpath");
return;
}
if self.layers.len() >= MAX_LAYERS {
self.unsupported("too many objects");
return;
}
let mut shape = ShapeLayer { path, fill, stroke, ..ShapeLayer::default() };
// Use the renderer's actual ink bounds, including miter tips, and reuse the compilation.
// Control-point bounds expanded by one stroke width can clip acute joins.
let compiled = photocraft_vector::CompiledShape::new(&shape, photocraft_vector::DEFAULT_TOLERANCE, self.clip);
let area = compiled.bounds().unwrap_or(Rect::EMPTY).intersect(&self.clip);
if area.width() > 0 && area.height() > 0 {
if let Err(EditableError::Unsupported(reason)) = admit_cache(&mut self.cached, area, self.fmt) {
self.unsupported(reason);
return;
}
shape.cache = Some(compiled.render(self.fmt, area));
}
self.layers.push(Layer::new(format!("Path {}", self.layers.len() + 1), LayerContent::Shape(shape)));
}
}
impl<'a> Device<'a> for PathDevice<'_> {
/// A soft mask changes compositing in ways a plain layer cannot express, but it only matters
/// if something is painted while it is active.
fn set_soft_mask(&mut self, mask: Option<SoftMask<'a>>) {
self.soft_mask = mask.is_some();
}
/// Only normal blending is editable.
fn set_blend_mode(&mut self, blend_mode: BlendMode) {
if blend_mode != BlendMode::Normal {
self.unsupported("blend modes");
}
}
/// Turns a filled/stroked path into a shape layer, rejecting paints and strokes it cannot keep.
fn draw_path(&mut self, path: &BezPath, transform: KurboAffine, paint: &Paint<'a>, draw_mode: &PathDrawMode) {
if self.unsupported.is_some() {
return;
}
if self.soft_mask {
self.unsupported("soft masks");
return;
}
if self.ctl.check().is_err() {
self.cancelled = true;
return;
}
let color = match paint {
Paint::Color(color) => to_color(color),
Paint::Pattern(_) => {
self.unsupported("patterns");
return;
}
};
let full = self.doc.mul(&knots_affine(&transform));
let Some(path) = to_path(path, &full, &mut self.knots) else {
self.unsupported("too many path points");
return;
};
match draw_mode {
PathDrawMode::Fill(rule) => {
let mut path = path;
path.fill_rule = match rule {
craft_pdf::interpret::FillRule::NonZero => FillRule::NonZero,
craft_pdf::interpret::FillRule::EvenOdd => FillRule::EvenOdd,
};
self.push_shape(path, Some(Fill::Solid(color)), None);
}
PathDrawMode::Stroke(stroke) => {
if !uniform_transform(&transform) {
self.unsupported("non-uniform stroke transform");
return;
}
let Some(stroke) = to_stroke(stroke, color, full.determinant().abs().sqrt()) else {
self.unsupported("stroke properties");
return;
};
self.push_shape(path, None, Some(stroke));
}
}
}
/// Accepts an axis-aligned clip that contains the artboard; other clips fall back.
fn push_clip_path(&mut self, clip_path: &ClipPath) {
if self.no_op_clip(clip_path) {
self.clips.push(true);
return;
}
self.clips.push(false);
self.unsupported("clipping paths");
}
/// Transparency groups are not represented by the layer model.
fn push_transparency_group(&mut self, _opacity: f32, mask: Option<SoftMask<'a>>, blend_mode: BlendMode) {
// A group needs its own blend/opacity/mask handling; until that exists the page is
// rasterised rather than flattened into the wrong stacking order.
let _ = (mask, blend_mode);
self.unsupported("transparency groups");
}
/// Records a filled glyph as text, or its stroke copy for fake-bold pairing.
fn draw_glyph(&mut self, glyph: &Glyph<'a>, transform: KurboAffine, glyph_transform: KurboAffine, paint: &Paint<'a>, draw_mode: &GlyphDrawMode) {
if self.unsupported.is_some() {
return;
}
if matches!(draw_mode, GlyphDrawMode::Invisible) {
return;
}
if self.soft_mask {
self.unsupported("soft masks");
return;
}
if self.ctl.check().is_err() {
self.cancelled = true;
return;
}
if matches!(draw_mode, GlyphDrawMode::Clip) {
self.unsupported("text used as a clipping path");
return;
}
if self.glyphs.len().saturating_add(self.strokes.len()) >= MAX_GLYPHS {
self.unsupported("too many glyphs");
return;
}
let text = match glyph.as_unicode() {
Some(craft_pdf::interpret::hayro_cmap::BfString::Char(c)) => c.to_string(),
Some(craft_pdf::interpret::hayro_cmap::BfString::String(s)) => s,
None => {
// No Unicode means the text layer could not be edited faithfully.
self.unsupported("text without a Unicode mapping");
return;
}
};
if text.is_empty() || text.chars().all(|c| c.is_control()) {
return;
}
let Glyph::Outline(outline) = glyph else {
self.unsupported("Type 3 text");
return;
};
let Some(data) = outline.font_data() else {
self.unsupported("text without an embedded font");
return;
};
if !data.embedded {
self.unsupported("text in a substituted font");
return;
}
let Some(postscript) = data.postscript_name.clone().filter(|name| !name.is_empty()) else {
self.unsupported("text without a font name");
return;
};
let color = match paint {
Paint::Color(color) => to_color(color),
Paint::Pattern(_) => {
self.unsupported("text with a pattern paint");
return;
}
};
let t = transform * glyph_transform;
let [a, b, c, d, e, f] = t.as_coeffs();
// A glyph space of 1000 units per em, so the determinant's square root is 1/1000 of the
// em size. Upright text has a positive a and a negative d (the view flips y).
let size_pt = (a * d - b * c).abs().sqrt() * 1000.0;
if !size_pt.is_finite() || size_pt <= 0.0 {
self.unsupported("text without a usable size");
return;
}
// Skewed, mirrored or sheared text cannot be a point text layer; leave the page to raster.
// After the view's y flip an upright or rotated run has a ≈ -d and b ≈ c.
let tolerance = 0.01 * (a * d - b * c).abs().sqrt();
if (a + d).abs() > tolerance || (b - c).abs() > tolerance {
self.unsupported("skewed or mirrored text");
return;
}
if let GlyphDrawMode::Stroke(stroke) = draw_mode {
// Only a thin, solid, same-colour outline can be approximated by faux bold.
// Colour equality is checked against the fill in pair_fake_bold.
if !stroke.line_width.is_finite()
|| stroke.line_width < 0.0
|| f64::from(stroke.line_width) * transform.determinant().abs().sqrt() > size_pt * 0.05
|| !stroke.dash_array.is_empty()
{
self.unsupported("stroked text geometry");
return;
}
}
let origin = self.doc.apply(Point::new(e, f));
let size_px = size_pt * self.doc.determinant().abs().sqrt();
let angle = b.atan2(a);
if !angle.is_finite() || !size_px.is_finite() || size_px <= 0.0 {
self.unsupported("text without a usable transform");
return;
}
let advance = f64::from(outline.advance_width().unwrap_or(500.0)) / 1000.0 * size_px;
let weight = font_weight(&data, &postscript);
let italic = data.is_italic || name_has(&postscript, &["italic", "oblique"]);
let identity = outline.font_cache_key();
let key = *self.font_keys.entry(identity).or_insert_with(|| font_content_key(&data));
let family = family_from_postscript(&postscript);
if self.seen_fonts.insert(key) {
self.fonts.push((key, postscript.clone(), family.clone(), data.data.clone()));
}
let bytes = std::mem::size_of::<GlyphRun>().saturating_add(text.len()).saturating_add(family.len()).saturating_add(postscript.len());
self.glyph_bytes = self.glyph_bytes.saturating_add(bytes);
if self.glyph_bytes > MAX_GLYPH_BYTES {
self.unsupported("glyph memory budget");
return;
}
let font = FontInfo { key, family, postscript, weight, italic };
let glyph = GlyphRun { text, origin, size_pt, size_px, angle, advance, font, color, fake_bold: false, order: self.layers.len() };
if matches!(draw_mode, GlyphDrawMode::Stroke(_)) {
self.strokes.push(glyph);
} else {
self.glyphs.push(glyph);
}
}
/// Images are not editable at this step.
fn draw_image(&mut self, _image: Image<'a, '_>, _transform: KurboAffine) {
self.unsupported("images");
}
/// Balances [`Self::push_clip_path`].
fn pop_clip_path(&mut self) {
let _ = self.clips.pop();
}
/// Balances [`Self::push_transparency_group`].
fn pop_transparency_group(&mut self) {}
/// Annotations are not part of the page's editable paint.
fn begin_annotations(&mut self) {
self.unsupported("annotations");
}
}
/// The weight a font is given to a text layer, from its metadata and name.
fn font_weight(data: &OutlineFontData, postscript: &str) -> u32 {
if name_has(postscript, &["bold", "semibold", "demibold", "extrabold", "ultrabold", "black", "heavy"]) {
return data.weight.unwrap_or(700).max(700);
}
data.weight.unwrap_or(400)
}
/// Whether `name` contains any of the lowercase style words.
fn name_has(name: &str, words: &[&str]) -> bool {
let lower = name.to_ascii_lowercase();
words.iter().any(|word| lower.contains(word))
}
/// A family name from a `/BaseFont`/PostScript name, per the rules PdfCraft and pdfcer use:
/// drop a six-letter subset tag, a trailing style suffix and `MT`/`PS`, then space camel case.
/// The raw name stays in `CharStyle::postscript_name`, because some systems match that spelling.
fn family_from_postscript(name: &str) -> String {
let mut s = name;
if s.len() > 7 && s.as_bytes()[6] == b'+' && s[..6].bytes().all(|b| b.is_ascii_uppercase()) {
s = &s[7..];
}
if let Some((head, tail)) = s.rsplit_once('-')
&& is_style_word(tail)
{
s = head;
}
loop {
if let Some(rest) = s.strip_suffix("PSMT") {
s = rest;
} else if let Some(rest) = s.strip_suffix("MT") {
s = rest;
} else if let Some(rest) = s.strip_suffix("PS") {
s = rest;
} else {
break;
}
}
let spaced = space_camel(s);
if spaced.is_empty() { name.to_string() } else { spaced }
}
/// Whether a suffix is a style word (after dropping `MT`/`PS` from it).
fn is_style_word(word: &str) -> bool {
let mut w = word;
loop {
if let Some(rest) = w.strip_suffix("MT") {
w = rest;
} else if let Some(rest) = w.strip_suffix("PS") {
w = rest;
} else {
break;
}
}
matches!(
w.to_ascii_lowercase().as_str(),
"bold"
| "italic"
| "oblique"
| "bolditalic"
| "boldoblique"
| "regular"
| "medium"
| "light"
| "black"
| "semibold"
| "demibold"
| "heavy"
| "thin"
| "book"
| "roman"
| "condensed"
| "narrow"
| "extended"
)
}
/// `TimesNewRoman` → `Times New Roman`; acronym runs and hyphens stay as they are.
fn space_camel(name: &str) -> String {
let chars: Vec<char> = name.chars().collect();
let mut out = String::with_capacity(name.len() + 4);
for (i, ch) in chars.iter().copied().enumerate() {
let prev = i.checked_sub(1).and_then(|j| chars.get(j)).copied();
let next = chars.get(i + 1).copied();
let boundary = ch.is_ascii_uppercase() && prev.is_some_and(|p| p.is_ascii_lowercase() || p.is_ascii_digit())
|| ch.is_ascii_uppercase() && prev.is_some_and(|p| p.is_ascii_uppercase()) && next.is_some_and(|n| n.is_ascii_lowercase());
if boundary && !out.is_empty() && !out.ends_with(' ') && !out.ends_with('-') {
out.push(' ');
}
out.push(ch);
}
out
}
/// The bounds of a path that is one axis-aligned rectangle, else `None`.
fn axis_aligned_rect(path: &BezPath) -> Option<(f64, f64, f64, f64)> {
let elements = path.elements();
if !(5..=6).contains(&elements.len()) {
return None;
}
let mut points = Vec::with_capacity(4);
for element in elements {
match *element {
PathEl::MoveTo(p) | PathEl::LineTo(p) => points.push((p.x, p.y)),
PathEl::ClosePath => {}
PathEl::QuadTo(..) | PathEl::CurveTo(..) => return None,
}
}
if points.len() != 4 {
// An explicitly closed rectangle uses four LineTo points plus the duplicate start.
if points.len() == 5 && (points[0].0 - points[4].0).abs() < 1.0e-6 && (points[0].1 - points[4].1).abs() < 1.0e-6 {
points.pop();
} else {
return None;
}
}
let x0 = points.iter().map(|p| p.0).fold(f64::INFINITY, f64::min);
let x1 = points.iter().map(|p| p.0).fold(f64::NEG_INFINITY, f64::max);
let y0 = points.iter().map(|p| p.1).fold(f64::INFINITY, f64::min);
let y1 = points.iter().map(|p| p.1).fold(f64::NEG_INFINITY, f64::max);
if !(x1 > x0 && y1 > y0) {
return None;
}
let on_edge = |v: f64, lo: f64, hi: f64| (v - lo).abs() < 1.0e-6 || (v - hi).abs() < 1.0e-6;
if points.iter().any(|(x, y)| !on_edge(*x, x0, x1) || !on_edge(*y, y0, y1)) {
return None;
}
// A bow-tie traversal also visits the four corners, so require its shoelace area to match
// the bounding box (a real rectangle covers it exactly).
let mut twice_area = 0.0;
for i in 0..4 {
let (ax, ay) = points[i];
let (bx, by) = points[(i + 1) % 4];
twice_area += ax * by - bx * ay;
}
let box_area = (x1 - x0) * (y1 - y0);
if (twice_area.abs() * 0.5 - box_area).abs() > box_area * 1.0e-3 {
return None;
}
Some((x0, y0, x1, y1))
}
/// Whether every knot of a subpath shares the first anchor (a zero-length subpath).
fn is_zero_length(subpath: &Subpath) -> bool {
subpath.knots.first().is_some_and(|first| subpath.knots.iter().all(|knot| knot.anchor.x == first.anchor.x && knot.anchor.y == first.anchor.y))
}
/// Whether a path transform keeps circles circular: both axes the same length and perpendicular.
fn uniform_transform(transform: &KurboAffine) -> bool {
let [a, b, c, d, _, _] = transform.as_coeffs();
let x = (a * a + b * b).sqrt();
let y = (c * c + d * d).sqrt();
if !x.is_finite() || !y.is_finite() || x <= 0.0 || y <= 0.0 {
return false;
}
let same = (x - y).abs() <= 0.01 * x.max(y);
let square = (a * c + b * d).abs() <= 0.01 * x * y;
same && square
}
/// A PDF colour as a straight-alpha PhotoCraft colour.
fn to_color(color: &HayroColor) -> Color {
let rgba = color.to_rgba();
// `AlphaColor` components are straight (not premultiplied), despite the raster path being
// premultiplied: `Color::to_rgba8` reads them as straight too.
let [r, g, b, a] = rgba.components();
Color::rgba(r.clamp(0.0, 1.0), g.clamp(0.0, 1.0), b.clamp(0.0, 1.0), a.clamp(0.0, 1.0))
}
/// A kurbo affine as PhotoCraft's affine (same `[a, b, c, d, e, f]` layout).
fn knots_affine(transform: &KurboAffine) -> Affine {
let [a, b, c, d, e, f] = transform.as_coeffs();
Affine { m: [a, b, c, d, e, f] }
}
/// A Hayro stroke as PhotoCraft's stroke: width in pixels, dashes in multiples of the width.
fn to_stroke(stroke: &craft_pdf::interpret::StrokeProps, color: Color, scale: f64) -> Option<ShapeStroke> {
if !stroke.line_width.is_finite() || stroke.line_width < 0.0 || !scale.is_finite() || scale <= 0.0 {
return None;
}
// A zero line width is the thinnest line the device can draw (ISO 32000-2 §8.4.3.2); the
// raster path draws it one document pixel wide, so do the same and use that as the dash base.
let width = if stroke.line_width > 0.0 { stroke.line_width * scale as f32 } else { 1.0 };
if !width.is_finite() || width <= 0.0 {
return None;
}
let mut dashes: Vec<f32> = stroke.dash_array.iter().map(|dash| dash * scale as f32 / width).collect();
// An odd PDF dash array repeats, so [3] means 3 on, 3 off rather than a single entry.
if dashes.len() % 2 == 1 {
let copy = dashes.clone();
dashes.extend(copy);
}
Some(ShapeStroke {
width,
paint: Fill::Solid(color),
opacity: 1.0,
align: StrokeAlign::Center,
cap: match stroke.line_cap {
Cap::Butt => LineCap::Butt,
Cap::Round => LineCap::Round,
Cap::Square => LineCap::Square,
},
join: match stroke.line_join {
Join::Miter => LineJoin::Miter,
Join::Round => LineJoin::Round,
Join::Bevel => LineJoin::Bevel,
},
miter_limit: stroke.miter_limit,
dashes,
dash_offset: stroke.dash_offset * scale as f32 / width,
})
}
/// Converts a kurbo path to PhotoCraft's cubic knot model. `None` once `knots` passes the cap.
fn to_path(bez: &BezPath, transform: &Affine, knots: &mut usize) -> Option<Path> {
let mut subpaths = Vec::new();
let mut current: Option<Subpath> = None;
let mut restarted = false;
let mut last = Point::new(0.0, 0.0);
for element in bez.elements() {
match *element {
PathEl::MoveTo(p) => {
if let Some(subpath) = current.take()
&& (!restarted || subpath.knots.len() > 1)
{
subpaths.push(subpath);
}
restarted = false;
current = Some(Subpath { closed: false, knots: vec![Knot::corner(p.x, p.y)], op: PathOp::Combine });
last = Point::new(p.x, p.y);
}
PathEl::LineTo(p) => {
if let Some(subpath) = current.as_mut() {
if let Some(knot) = subpath.knots.last_mut() {
knot.out_ctrl = knot.anchor;
}
subpath.knots.push(Knot::corner(p.x, p.y));
}
last = Point::new(p.x, p.y);
}
PathEl::QuadTo(control, p) => {
if let Some(subpath) = current.as_mut() {
let start = subpath.knots.last().map_or(last, |knot| knot.anchor);
if let Some(knot) = subpath.knots.last_mut() {
knot.out_ctrl = Point::new(start.x + 2.0 / 3.0 * (control.x - start.x), start.y + 2.0 / 3.0 * (control.y - start.y));
}
subpath.knots.push(Knot {
anchor: Point::new(p.x, p.y),
in_ctrl: Point::new(p.x + 2.0 / 3.0 * (control.x - p.x), p.y + 2.0 / 3.0 * (control.y - p.y)),
out_ctrl: Point::new(p.x, p.y),
smooth: false,
});
}
last = Point::new(p.x, p.y);
}
PathEl::CurveTo(c1, c2, p) => {
if let Some(subpath) = current.as_mut() {
if let Some(knot) = subpath.knots.last_mut() {
knot.out_ctrl = Point::new(c1.x, c1.y);
}
subpath.knots.push(Knot { anchor: Point::new(p.x, p.y), in_ctrl: Point::new(c2.x, c2.y), out_ctrl: Point::new(p.x, p.y), smooth: false });
}
last = Point::new(p.x, p.y);
}
PathEl::ClosePath => {
if let Some(mut subpath) = current.take() {
let restart = subpath.knots.first().map(|knot| knot.anchor);
subpath.closed = true;
if subpath.knots.len() > 1 {
let first = subpath.knots[0].anchor;
let last_anchor = subpath.knots.last().map_or(first, |knot| knot.anchor);
if (first.x - last_anchor.x).abs() < 1e-9 && (first.y - last_anchor.y).abs() < 1e-9 {
// A straight closing segment can merge into the first knot; a curve
// that returns to its start must keep both knots to preserve the loop.
let straight = subpath.knots.last().is_some_and(|knot| {
knot.in_ctrl.x == knot.anchor.x
&& knot.in_ctrl.y == knot.anchor.y
&& knot.out_ctrl.x == knot.anchor.x
&& knot.out_ctrl.y == knot.anchor.y
});
if straight && let Some(knot) = subpath.knots.pop() {
subpath.knots[0].in_ctrl = knot.in_ctrl;
}
} else {
subpath.knots[0].in_ctrl = first;
}
}
// A single-point closed subpath still paints a dot with a round cap.
if !restarted || subpath.knots.len() > 1 {
subpaths.push(subpath);
}
// A close starts a new subpath at the closed subpath's start point; a
// following line/curve continues from there (PDF 32000-1 §8.5.2.1).
if let Some(start) = restart {
current = Some(Subpath { closed: false, knots: vec![Knot::corner(start.x, start.y)], op: PathOp::Combine });
last = start;
restarted = true;
} else {
restarted = false;
}
}
}
}
}
if let Some(subpath) = current
&& (!restarted || subpath.knots.len() > 1)
{
subpaths.push(subpath);
}
*knots = knots.saturating_add(subpaths.iter().map(|subpath| subpath.knots.len()).sum::<usize>());
if *knots > MAX_KNOTS {
return None;
}
for subpath in &mut subpaths {
for knot in &mut subpath.knots {
*knot = knot.transform(transform);
}
}
Some(Path::new(subpaths))
}
#[cfg(test)]
mod tests {
use lopdf::{Document as PdfDocument, Object, Stream, dictionary};
use super::*;
use crate::{ImportOptions, IoError, import_with_options_and_interrupt};
/// The embedded test font.
const INTER: &[u8] = include_bytes!("../../../assets/fonts/Inter-Regular.ttf");
/// A one-page 200 x 100 pt PDF whose content stream is `content`.
fn pdf(content: &str) -> Vec<u8> {
pdf_with_resources(content, dictionary! {})
}
/// [`pdf`] with page resources (for example an ExtGState).
fn pdf_with_resources(content: &str, resources: lopdf::Dictionary) -> Vec<u8> {
let mut pdf = PdfDocument::with_version("1.5");
let pages_id = pdf.new_object_id();
let content_id = pdf.add_object(Stream::new(dictionary! {}, content.as_bytes().to_vec()));
let page_id = pdf.add_object(dictionary! {
"Type" => "Page",
"Parent" => pages_id,
"MediaBox" => Object::Array(vec![Object::Real(0.0), Object::Real(0.0), Object::Real(200.0), Object::Real(100.0)]),
"Contents" => content_id,
"Resources" => resources,
});
pdf.objects.insert(
pages_id,
Object::Dictionary(dictionary! {
"Type" => "Pages",
"Kids" => Object::Array(vec![Object::Reference(page_id)]),
"Count" => 1,
}),
);
let catalog = pdf.add_object(dictionary! { "Type" => "Catalog", "Pages" => pages_id });
pdf.trailer.set("Root", catalog);
let mut bytes = Vec::new();
pdf.save_to(&mut bytes).expect("writing the fixture");
bytes
}
/// A one-page 200 x 100 pt PDF whose content stream is `content` and whose page uses an
/// embedded TrueType font as `/F1`.
fn text_pdf(content: &str) -> Vec<u8> {
text_pdf_named(content, "Inter-Regular")
}
/// [`text_pdf`] with the font named `name` (the same Inter bytes, so tests can exercise the
/// name-based style rules).
fn text_pdf_named(content: &str, name: &str) -> Vec<u8> {
text_pdf_bytes(content, name, INTER)
}
/// [`text_pdf`] with the font named `name` and the given font bytes.
fn text_pdf_bytes(content: &str, name: &str, font_bytes: &[u8]) -> Vec<u8> {
let mut pdf = PdfDocument::with_version("1.5");
let pages_id = pdf.new_object_id();
let font_file = pdf.add_object(Stream::new(dictionary! { "Length1" => font_bytes.len() as i64 }, font_bytes.to_vec()));
let descriptor = pdf.add_object(dictionary! {
"Type" => "FontDescriptor",
"FontName" => Object::Name(name.as_bytes().to_vec()),
"Flags" => 32,
"FontBBox" => Object::Array(vec![Object::Integer(-100), Object::Integer(-200), Object::Integer(1000), Object::Integer(900)]),
"ItalicAngle" => 0,
"Ascent" => 900,
"Descent" => -200,
"CapHeight" => 700,
"StemV" => 80,
"FontFile2" => font_file,
});
let font = pdf.add_object(dictionary! {
"Type" => "Font",
"Subtype" => "TrueType",
"BaseFont" => Object::Name(name.as_bytes().to_vec()),
"FirstChar" => 32,
"LastChar" => 126,
"Widths" => Object::Array((32..=126u8).map(|c| {
let Ok(face) = ttf_parser::Face::parse(font_bytes, 0) else { return Object::Integer(600); };
let width = face.glyph_index(char::from(c)).and_then(|id| face.glyph_hor_advance(id)).unwrap_or(0);
Object::Real(f32::from(width) * 1000.0 / f32::from(face.units_per_em()))
}).collect()),
"FontDescriptor" => descriptor,
"Encoding" => "WinAnsiEncoding",
});
let content_id = pdf.add_object(Stream::new(dictionary! {}, content.as_bytes().to_vec()));
let page_id = pdf.add_object(dictionary! {
"Type" => "Page",
"Parent" => pages_id,
"MediaBox" => Object::Array(vec![Object::Real(0.0), Object::Real(0.0), Object::Real(200.0), Object::Real(100.0)]),
"Contents" => content_id,
"Resources" => dictionary! { "Font" => dictionary! { "F1" => font } },
});
pdf.objects.insert(
pages_id,
Object::Dictionary(dictionary! {
"Type" => "Pages",
"Kids" => Object::Array(vec![Object::Reference(page_id)]),
"Count" => 1,
}),
);
let catalog = pdf.add_object(dictionary! { "Type" => "Catalog", "Pages" => pages_id });
pdf.trailer.set("Root", catalog);
let mut bytes = Vec::new();
pdf.save_to(&mut bytes).expect("writing the text fixture");
bytes
}
/// The artboard group's children.
fn children(document: &photocraft_doc::Document) -> &[Layer] {
match &document.layers.first().expect("a page group").content {
LayerContent::Group(group) => &group.children,
_ => panic!("the page is not a group"),
}
}
/// The first text layer of `document`.
fn text_layer(document: &photocraft_doc::Document) -> &TextLayer {
children(document)
.iter()
.find_map(|layer| match &layer.content {
LayerContent::Text(text) => Some(text),
_ => None,
})
.expect("a text layer")
}
/// A solid fill or stroke colour.
fn solid(fill: &Fill) -> Color {
match fill {
Fill::Solid(color) => *color,
_ => panic!("not a solid paint"),
}
}
/// Path bounds in document pixels.
fn bounds(path: &Path) -> (f64, f64, f64, f64) {
let mut b = (f64::MAX, f64::MAX, f64::MIN, f64::MIN);
for knot in path.subpaths.iter().flat_map(|subpath| &subpath.knots) {
b.0 = b.0.min(knot.anchor.x);
b.1 = b.1.min(knot.anchor.y);
b.2 = b.2.max(knot.anchor.x);
b.3 = b.3.max(knot.anchor.y);
}
b
}
#[test]
fn painted_paths_become_shape_layers_with_their_colours_and_dashes() {
let bytes = pdf("1 0 0 rg 20 20 60 40 re f 0 0 1 RG 3 w [9 4] 0 d 100 30 m 180 30 l S");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("paths.pdf", &bytes, &options, &Interrupt::NONE).expect("an editable import");
let children = children(&imported.document);
assert_eq!(children.len(), 2, "one fill and one stroke layer");
let LayerContent::Shape(fill) = &children[0].content else { panic!("the first child is not a shape") };
assert_eq!(solid(fill.fill.as_ref().expect("a fill")), Color::rgb(1.0, 0.0, 0.0));
assert!(fill.stroke.is_none());
let (x0, y0, x1, y1) = bounds(&fill.path);
assert!((x0 - 20.0).abs() < 0.01 && (x1 - 80.0).abs() < 0.01, "x bounds {x0}..{x1}");
assert!((y0 - 40.0).abs() < 0.01 && (y1 - 80.0).abs() < 0.01, "PDF y up becomes document y down: {y0}..{y1}");
let LayerContent::Shape(stroke) = &children[1].content else { panic!("the second child is not a shape") };
assert!(stroke.fill.is_none());
let stroke = stroke.stroke.as_ref().expect("a stroke");
assert_eq!(solid(&stroke.paint), Color::rgb(0.0, 0.0, 1.0));
assert!((stroke.width - 3.0).abs() < 0.01, "stroke width {}", stroke.width);
assert_eq!(stroke.dashes.len(), 2);
assert!((stroke.dashes[0] - 3.0).abs() < 0.01 && (stroke.dashes[1] - 4.0 / 3.0).abs() < 0.01, "dashes {:?}", stroke.dashes);
}
#[test]
fn the_editable_composite_matches_the_raster_page() {
let bytes = pdf("1 0 0 rg 20 20 60 40 re f 0 0 1 RG 3 w [9 4] 0 d 100 30 m 180 30 l S");
let raster = import_with_options_and_interrupt("paths.pdf", &bytes, &ImportOptions { pdf_dpi: 72.0, ..ImportOptions::default() }, &Interrupt::NONE)
.expect("a raster import");
let editable = import_with_options_and_interrupt(
"paths.pdf",
&bytes,
&ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() },
&Interrupt::NONE,
)
.expect("an editable import");
let fmt = editable.document.pixel_format();
let a = photocraft_compose::flatten_to_surface(&editable.document, fmt, None);
let b = photocraft_compose::flatten_to_surface(&raster.document, fmt, None);
let rect = editable.document.bounds();
let av = a.read_region(rect);
let bv = b.read_region(rect);
assert_eq!(av.len(), bv.len());
let mut sum = 0.0f64;
let mut max = 0.0f32;
for (x, y) in av.iter().zip(&bv) {
let d = (x - y).abs();
sum += f64::from(d);
max = max.max(d);
}
let mean = sum / av.len() as f64;
assert!(mean < 0.01, "mean pixel difference {mean:.4} (max {max:.3})");
}
#[test]
fn text_falls_back_to_the_raster_page_with_a_warning() {
let bytes = pdf("BT /F1 24 Tf 10 50 Td (Hi) Tj ET");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("text.pdf", &bytes, &options, &Interrupt::NONE).expect("a fallback import");
assert!(
imported.warnings.iter().any(|warning| warning.contains("text without an embedded font") && warning.contains("rasterised")),
"{:?}",
imported.warnings
);
assert!(matches!(children(&imported.document).first().map(|layer| &layer.content), Some(LayerContent::Raster(_))));
}
#[test]
fn embedded_text_becomes_a_text_layer_with_its_style() {
let bytes = text_pdf("BT /F1 24 Tf 1 0 0 rg 20 50 Td (Hi) Tj ET");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("text.pdf", &bytes, &options, &Interrupt::NONE).expect("an editable text import");
let text = text_layer(&imported.document);
assert_eq!(text.text, "Hi");
assert!(text.font_family.starts_with("Inter"), "family {}", text.font_family);
assert!((f64::from(text.size_pt) - 24.0).abs() < 0.1, "size {}", text.size_pt);
assert_eq!(text.color, Color::rgb(1.0, 0.0, 0.0));
let origin = text.transform.apply(Point::new(0.0, 0.0));
assert!((origin.x - 20.0).abs() < 0.5 && (origin.y - 50.0).abs() < 0.5, "origin {origin:?}");
assert!(text.cache.is_some(), "the text cache is rendered on import");
let style = &text.runs[0].style;
assert_eq!(style.postscript_name.as_deref(), Some("Inter-Regular"));
assert_eq!(style.weight, 400);
assert!(!style.italic);
assert!(imported.warnings.iter().any(|warning| warning.contains("fonts embedded in the PDF")), "{:?}", imported.warnings);
}
#[test]
fn imported_text_relayouts_with_the_shared_engine() {
let bytes = text_pdf("BT /F1 24 Tf 1 0 0 rg 20 50 Td (Hi) Tj ET");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("text.pdf", &bytes, &options, &Interrupt::NONE).expect("an editable text import");
let mut text = text_layer(&imported.document).clone();
text.cache = None;
let shared = photocraft_text::shared();
let mut engine = shared.lock().unwrap_or_else(|error| error.into_inner());
assert!(engine.has_family(&text.font_family), "the app engine must know the imported family");
let rect = engine.render_layer(&mut text, 72.0, PixelFormat::new(ColorMode::Rgb, SampleType::U8, true));
assert!(rect.width() > 0 && rect.height() > 0, "the layer re-lays out");
assert!(text.cache.is_some());
}
#[test]
fn rotated_text_stays_editable() {
let bytes = text_pdf("BT /F1 24 Tf 0 1 -1 0 100 20 Tm (Hi) Tj ET");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("rotated.pdf", &bytes, &options, &Interrupt::NONE).expect("import");
assert!(!imported.warnings.iter().any(|warning| warning.contains("skewed or mirrored")), "{:?}", imported.warnings);
assert_eq!(text_layer(&imported.document).text, "Hi");
}
#[test]
fn font_aliases_include_the_content_key() {
assert_ne!(font_alias("Inter-Regular", 1), font_alias("Inter-Regular", 2));
assert!(font_alias("Inter-Regular", 0x12ab).contains("Inter-Regular"));
}
#[test]
fn two_documents_with_one_font_name_keep_distinct_aliases() {
// Rename the bundled Inter family to one that is not installed, so the embedded face
// takes the alias path; same PostScript name and family, different bytes (a trailing byte
// changes the content key), as two different subsets of one font would.
let mut base = INTER.to_vec();
for at in 0..base.len().saturating_sub(5) {
if &base[at..at + 5] == b"Inter" {
base[at..at + 5].copy_from_slice(b"Xntr");
}
}
let mut other = base.clone();
other.push(0);
let a = text_pdf_bytes("BT /F1 24 Tf 20 50 Td (Hi) Tj ET", "Xntr-Regular", &base);
let b = text_pdf_bytes("BT /F1 24 Tf 20 50 Td (Hi) Tj ET", "Xntr-Regular", &other);
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let first = import_with_options_and_interrupt("a.pdf", &a, &options, &Interrupt::NONE).expect("first import");
let second = import_with_options_and_interrupt("b.pdf", &b, &options, &Interrupt::NONE).expect("second import");
let fa = text_layer(&first.document).font_family.clone();
let fb = text_layer(&second.document).font_family.clone();
assert_ne!(fa, fb, "the two embedded faces must not share an alias");
let shared = photocraft_text::shared();
let mut engine = shared.lock().unwrap_or_else(|error| error.into_inner());
assert!(engine.has_family(&fa) && engine.has_family(&fb));
}
#[test]
fn mirrored_text_falls_back() {
let bytes = text_pdf("BT /F1 24 Tf -1 0 0 1 100 50 Tm (Hi) Tj ET");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("mirror.pdf", &bytes, &options, &Interrupt::NONE).expect("import");
assert!(
imported.warnings.iter().any(|warning| warning.contains("skewed or mirrored text") && warning.contains("rasterised")),
"{:?}",
imported.warnings
);
}
#[test]
fn font_names_set_bold_and_italic() {
for (name, weight, italic) in [("Inter-Bold", 700, false), ("Inter-Italic", 400, true), ("Inter-BoldItalic", 700, true)] {
let bytes = text_pdf_named("BT /F1 24 Tf 20 50 Td (Hi) Tj ET", name);
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("text.pdf", &bytes, &options, &Interrupt::NONE).expect("an editable text import");
let style = &text_layer(&imported.document).runs[0].style;
assert_eq!(style.weight, weight, "{name}");
assert_eq!(style.italic, italic, "{name}");
assert!(style.font_family.starts_with("Inter"), "{name}: {}", style.font_family);
}
}
#[test]
fn a_page_sized_clip_does_not_force_a_raster_page() {
let bytes = pdf("q 0 0 200 100 re W n 1 0 0 rg 20 20 60 40 re f Q");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("clip.pdf", &bytes, &options, &Interrupt::NONE).expect("import");
assert!(!imported.warnings.iter().any(|warning| warning.contains("clipping")), "{:?}", imported.warnings);
assert!(children(&imported.document).iter().any(|layer| matches!(layer.content, LayerContent::Shape(_))));
}
#[test]
fn a_zero_width_stroke_is_a_one_pixel_hairline() {
let bytes = pdf("0 0 1 RG 0 w 20 30 m 180 30 l S");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("hairline.pdf", &bytes, &options, &Interrupt::NONE).expect("import");
let LayerContent::Shape(shape) = &children(&imported.document)[0].content else { panic!("not a shape") };
let stroke = shape.stroke.as_ref().expect("a stroke");
assert!((stroke.width - 1.0).abs() < 0.01, "width {}", stroke.width);
}
#[test]
fn a_non_uniform_stroke_transform_falls_back() {
let bytes = pdf("q 2 0 0 1 0 0 cm 0 0 1 RG 4 w 20 30 m 80 30 l S Q");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("skew.pdf", &bytes, &options, &Interrupt::NONE).expect("import");
assert!(
imported.warnings.iter().any(|warning| warning.contains("non-uniform stroke transform") && warning.contains("rasterised")),
"{:?}",
imported.warnings
);
assert!(matches!(children(&imported.document).first().map(|layer| &layer.content), Some(LayerContent::Raster(_))));
}
#[test]
fn a_uniform_stroke_transform_scales_the_width() {
let bytes = pdf("q 2 0 0 2 0 0 cm 0 0 1 RG 4 w 20 30 m 80 30 l S Q");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("scaled.pdf", &bytes, &options, &Interrupt::NONE).expect("import");
let LayerContent::Shape(shape) = &children(&imported.document)[0].content else { panic!("not a shape") };
let stroke = shape.stroke.as_ref().expect("a stroke");
assert!((stroke.width - 8.0).abs() < 0.01, "width {}", stroke.width);
}
#[test]
fn extgstate_fill_and_stroke_opacity_reach_the_layers() {
let resources = dictionary! {
"ExtGState" => dictionary! {
"GS0" => dictionary! { "ca" => 0.5, "CA" => 0.5 },
},
};
let bytes = pdf_with_resources("/GS0 gs 0.2 0.4 0.6 rg 20 20 60 40 re f 0 0 1 RG 4 w 20 80 m 180 80 l S", resources);
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("opacity.pdf", &bytes, &options, &Interrupt::NONE).expect("import");
let layers = children(&imported.document);
let LayerContent::Shape(fill) = &layers[0].content else { panic!("not a shape") };
let fill = solid(fill.fill.as_ref().expect("a fill"));
assert!((fill.alpha - 0.5).abs() < 0.01);
assert!((fill.c[0] - 0.2).abs() < 0.01 && (fill.c[1] - 0.4).abs() < 0.01 && (fill.c[2] - 0.6).abs() < 0.01, "{fill:?}");
let LayerContent::Shape(stroke) = &layers[1].content else { panic!("not a shape") };
assert!((solid(&stroke.stroke.as_ref().expect("a stroke").paint).alpha - 0.5).abs() < 0.01);
}
#[test]
fn odd_and_zero_dash_arrays_are_normalised() {
let mut stroke = craft_pdf::interpret::StrokeProps {
line_width: 2.0,
line_cap: Cap::Butt,
line_join: Join::Miter,
miter_limit: 10.0,
dash_array: Default::default(),
dash_offset: 0.0,
};
stroke.dash_array.push(3.0);
let out = to_stroke(&stroke, Color::BLACK, 1.0).expect("a stroke");
assert_eq!(out.dashes, vec![1.5, 1.5], "an odd array repeats");
stroke.dash_array.clear();
stroke.dash_array.push(0.0);
stroke.dash_array.push(4.0);
let out = to_stroke(&stroke, Color::BLACK, 1.0).expect("a stroke");
assert_eq!(out.dashes, vec![0.0, 2.0], "zero-length dashes stay");
}
#[test]
fn fill_then_stroke_text_is_fake_bold_not_a_second_run() {
let bytes = text_pdf("BT /F1 24 Tf 2 Tr 1 0 0 rg 1 0 0 RG 20 50 Td (Hi) Tj ET");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("text.pdf", &bytes, &options, &Interrupt::NONE).expect("an editable text import");
let texts: Vec<_> = children(&imported.document)
.iter()
.filter_map(|layer| match &layer.content {
LayerContent::Text(text) => Some(text),
_ => None,
})
.collect();
assert_eq!(texts.len(), 1, "one run, not a duplicate stroke run");
assert_eq!(texts[0].text, "Hi");
assert_eq!(texts[0].runs[0].style.weight, 700);
assert_eq!(texts[0].color, Color::rgb(1.0, 0.0, 0.0));
}
#[test]
fn font_family_rules_follow_the_base_font() {
assert_eq!(family_from_postscript("ABCDEF+TimesNewRomanPSMT"), "Times New Roman");
assert_eq!(family_from_postscript("Arial-BoldMT"), "Arial");
assert_eq!(family_from_postscript("Helvetica-Oblique"), "Helvetica");
assert_eq!(family_from_postscript("MS-Gothic"), "MS-Gothic");
assert_eq!(family_from_postscript("SimSun"), "Sim Sun");
assert_eq!(family_from_postscript("Inter-Regular"), "Inter");
assert_eq!(family_from_postscript("Roboto-Black"), "Roboto");
}
#[test]
fn the_editable_text_composite_matches_the_raster_page() {
let bytes = text_pdf("BT /F1 24 Tf 1 0 0 rg 20 50 Td (Hi) Tj ET");
let raster = import_with_options_and_interrupt("text.pdf", &bytes, &ImportOptions { pdf_dpi: 72.0, ..ImportOptions::default() }, &Interrupt::NONE)
.expect("a raster import");
let editable = import_with_options_and_interrupt(
"text.pdf",
&bytes,
&ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() },
&Interrupt::NONE,
)
.expect("an editable import");
let fmt = editable.document.pixel_format();
let a = photocraft_compose::flatten_to_surface(&editable.document, fmt, None);
let b = photocraft_compose::flatten_to_surface(&raster.document, fmt, None);
let rect = editable.document.bounds();
let av = a.read_region(rect);
let bv = b.read_region(rect);
let mut sum = 0.0f64;
let mut max = 0.0f32;
for (x, y) in av.iter().zip(&bv) {
let d = (x - y).abs();
sum += f64::from(d);
max = max.max(d);
}
let mean = sum / av.len() as f64;
assert!(mean < 0.02, "mean pixel difference {mean:.4} (max {max:.3})");
// The cache must actually contain text: a blank layer can still pass a mean comparison.
let channels = fmt.channels();
let width = rect.width() as usize;
let mut red = 0;
for y in 30..60usize {
for x in 20..45usize {
let at = (y * width + x) * channels;
if av[at] > 0.4 && av[at + 1] < 0.4 && av[at + 2] < 0.4 {
red += 1;
}
}
}
assert!(red > 0, "the editable text cache is blank");
}
#[test]
fn text_keeps_paint_order_on_both_sides_of_a_path() {
let bytes = text_pdf("BT /F1 24 Tf 20 50 Td (A) Tj ET 0 0 1 rg 0 0 200 100 re f BT /F1 24 Tf 20 20 Td (B) Tj ET");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("order.pdf", &bytes, &options, &Interrupt::NONE).expect("import");
let layers = children(&imported.document);
assert_eq!(layers.len(), 3);
let text = |layer: &Layer| match &layer.content {
LayerContent::Text(text) => text.text.clone(),
_ => String::new(),
};
assert_eq!(text(&layers[0]), "A");
assert!(matches!(layers[1].content, LayerContent::Shape(_)), "the path stays between the runs");
assert_eq!(text(&layers[2]), "B");
}
#[test]
fn fake_bold_does_not_pair_across_a_path() {
let bytes = text_pdf("BT /F1 24 Tf 20 50 Td (Hi) Tj ET 0 0 1 rg 0 0 200 100 re f BT /F1 24 Tf 1 Tr 1 w 0 0 1 RG 20 50 Td (Hi) Tj ET");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("pair.pdf", &bytes, &options, &Interrupt::NONE).expect("import");
assert!(imported.warnings.iter().any(|warning| warning.contains("stroked text") && warning.contains("rasterised")), "{:?}", imported.warnings);
}
#[test]
fn a_curve_returning_to_its_start_keeps_both_knots() {
let mut bez = BezPath::new();
bez.move_to((0.0, 0.0));
bez.curve_to((10.0, 0.0), (10.0, 10.0), (0.0, 0.0));
bez.close_path();
let mut knots = 0;
let path = to_path(&bez, &Affine::IDENTITY, &mut knots).expect("a path");
assert_eq!(path.subpaths.len(), 1);
assert!(path.subpaths[0].knots.len() >= 2);
}
#[test]
fn an_explicitly_closed_rectangle_is_a_no_op_clip() {
let mut path = BezPath::new();
path.move_to((0.0, 0.0));
path.line_to((200.0, 0.0));
path.line_to((200.0, 100.0));
path.line_to((0.0, 100.0));
path.line_to((0.0, 0.0));
path.close_path();
assert_eq!(axis_aligned_rect(&path), Some((0.0, 0.0, 200.0, 100.0)));
}
#[test]
fn a_dashed_zero_length_line_falls_back() {
let bytes = pdf("[1 1] 0 d 10 10 m 20 20 l 30 30 m h S");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("dash.pdf", &bytes, &options, &Interrupt::NONE).expect("import");
assert!(
imported.warnings.iter().any(|warning| warning.contains("dashed zero-length subpath") && warning.contains("rasterised")),
"{:?}",
imported.warnings
);
}
#[test]
fn a_solid_zero_length_line_stays_editable() {
let bytes = pdf("10 10 m 20 20 l 30 30 m h S");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("solid.pdf", &bytes, &options, &Interrupt::NONE).expect("import");
let layers = children(&imported.document);
assert!(layers.iter().any(|layer| matches!(layer.content, LayerContent::Shape(_))), "{:?}", imported.warnings);
}
#[test]
fn a_closed_single_point_subpath_is_retained() {
let mut bez = BezPath::new();
bez.move_to((10.0, 10.0));
bez.close_path();
let mut knots = 0;
let path = to_path(&bez, &Affine::IDENTITY, &mut knots).expect("a path");
assert_eq!(path.subpaths.len(), 1);
assert_eq!(path.subpaths[0].knots.len(), 1);
assert!(path.subpaths[0].closed);
}
#[test]
fn a_bow_tie_path_is_not_a_no_op_clip() {
let mut path = BezPath::new();
path.move_to((0.0, 0.0));
path.line_to((10.0, 10.0));
path.line_to((10.0, 0.0));
path.line_to((0.0, 10.0));
path.close_path();
assert!(axis_aligned_rect(&path).is_none());
}
#[test]
fn a_line_after_close_starts_a_new_subpath() {
let mut bez = BezPath::new();
bez.move_to((0.0, 0.0));
bez.line_to((10.0, 0.0));
bez.line_to((10.0, 10.0));
bez.close_path();
bez.line_to((20.0, 0.0));
let mut knots = 0;
let path = to_path(&bez, &Affine::IDENTITY, &mut knots).expect("a path");
assert_eq!(path.subpaths.len(), 2);
assert_eq!(path.subpaths[1].knots[0].anchor, Point::new(0.0, 0.0));
assert_eq!(path.subpaths[1].knots.last().expect("a knot").anchor, Point::new(20.0, 0.0));
}
#[test]
fn cancelling_between_objects_stops_the_editable_page() {
let mut content = String::from("1 0 0 rg\n");
for i in 0..20 {
content.push_str(&format!("{} 20 20 20 re f\n", i * 8));
}
let bytes = pdf(&content);
let calls = std::sync::atomic::AtomicUsize::new(0);
let cancel = || calls.fetch_add(1, Ordering::SeqCst) >= 3;
let ctl = Interrupt::cancel_only(&cancel);
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
assert!(matches!(import_with_options_and_interrupt("objects.pdf", &bytes, &options, &ctl), Err(IoError::Cancelled)));
}
#[test]
fn a_cancelled_editable_import_returns_cancelled() {
let bytes = pdf("1 0 0 rg 20 20 60 40 re f");
let cancel = || true;
let ctl = Interrupt::cancel_only(&cancel);
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
assert!(matches!(import_with_options_and_interrupt("paths.pdf", &bytes, &options, &ctl), Err(IoError::Cancelled)));
}
#[test]
fn positioned_pdf_text_is_not_silently_reflowed() {
let bytes = text_pdf("BT /F1 24 Tf 20 50 Td [(H) -900 (i)] TJ ET");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("spacing.pdf", &bytes, &options, &Interrupt::NONE).unwrap();
assert!(children(&imported.document).iter().all(|l| matches!(l.content, LayerContent::Raster(_))), "unrepresentable spacing must rasterise");
assert!(imported.warnings.iter().any(|w| w.contains("rasterised")));
}
#[test]
fn colored_text_outlines_are_not_fake_bold() {
let bytes = text_pdf("BT /F1 24 Tf 1 0 0 rg 0 0 1 RG 1 w 2 Tr 20 50 Td (Hi) Tj ET");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("outline.pdf", &bytes, &options, &Interrupt::NONE).unwrap();
assert!(children(&imported.document).iter().all(|l| matches!(l.content, LayerContent::Raster(_))), "a blue outline cannot become red bold text");
}
#[test]
fn a_shape_cache_keeps_the_whole_miter() {
let bytes = pdf("10 w 10 M 40 20 m 50 70 l 60 20 l S");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("miter.pdf", &bytes, &options, &Interrupt::NONE).unwrap();
let layer = children(&imported.document).first().unwrap();
let LayerContent::Shape(shape) = &layer.content else { panic!("expected an editable stroke") };
let board = Rect::from_xywh(0, 0, 200, 100);
let expected = photocraft_vector::render_shape(shape, imported.document.pixel_format(), board);
assert!(shape.cache.as_ref().unwrap().read_region(board) == expected.read_region(board), "bounds must include the pointed join");
}
#[test]
fn cache_budget_charges_full_tiles_and_preserves_the_limit() {
let fmt = PixelFormat::new(ColorMode::Rgb, SampleType::U8, true);
let tile_bytes = TILE_SIZE as u64 * TILE_SIZE as u64 * fmt.bytes_per_pixel() as u64;
let mut used = MAX_CACHE_BYTES - tile_bytes;
admit_cache(&mut used, Rect::from_xywh(0, 0, 1, 1), fmt).unwrap();
assert_eq!(used, MAX_CACHE_BYTES);
assert_eq!(admit_cache(&mut used, Rect::from_xywh(0, 0, 1, 1), fmt), Err(EditableError::Unsupported("page cache budget")));
assert_eq!(used, MAX_CACHE_BYTES);
let mut used = 0;
admit_cache(&mut used, Rect::from_xywh(-1, -1, 2, 2), fmt).unwrap();
assert_eq!(used, 4 * tile_bytes, "a tiny rectangle may straddle four tiles");
}
#[test]
fn text_cache_respects_the_budget_already_used_by_shapes() {
let bytes = text_pdf("BT /F1 24 Tf 20 50 Td (Hi) Tj ET");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("text-budget.pdf", &bytes, &options, &Interrupt::NONE).unwrap();
let mut text = text_layer(&imported.document).clone();
text.cache = None;
let mut layers = vec![Layer::new("Text", LayerContent::Text(text))];
let mut cached = MAX_CACHE_BYTES;
assert_eq!(
render_text_caches(&mut layers, 72.0, imported.document.pixel_format(), &Interrupt::NONE, &mut cached),
Err(EditableError::Unsupported("page cache budget"))
);
let LayerContent::Text(text) = &layers[0].content else { panic!("text layer") };
assert!(text.cache.is_none(), "reject before allocating the text cache");
}
#[test]
fn multiple_text_caches_share_one_allowance() {
let bytes = text_pdf("BT /F1 24 Tf 20 50 Td (Hi) Tj ET");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("text-budget.pdf", &bytes, &options, &Interrupt::NONE).unwrap();
let mut text = text_layer(&imported.document).clone();
text.cache = None;
let fmt = imported.document.pixel_format();
let layout = photocraft_text::shared().lock().unwrap().layout(&text, 72.0);
let area = photocraft_text::render::ink_rect(&layout, &text.transform);
let mut one_cache = 0;
admit_cache(&mut one_cache, area, fmt).unwrap();
assert!(one_cache > 0);
let mut layers = vec![Layer::new("First", LayerContent::Text(text.clone())), Layer::new("Second", LayerContent::Text(text))];
let mut cached = MAX_CACHE_BYTES - one_cache;
assert_eq!(render_text_caches(&mut layers, 72.0, fmt, &Interrupt::NONE, &mut cached), Err(EditableError::Unsupported("page cache budget")));
assert_eq!(cached, MAX_CACHE_BYTES);
assert!(matches!(&layers[0].content, LayerContent::Text(t) if t.cache.is_some()));
assert!(matches!(&layers[1].content, LayerContent::Text(t) if t.cache.is_none()));
let mut cached = 0;
render_text_caches(&mut layers, 72.0, fmt, &Interrupt::NONE, &mut cached).unwrap();
assert_eq!(cached, one_cache * 2);
assert!(layers.iter().all(|l| matches!(&l.content, LayerContent::Text(t) if t.cache.is_some())));
}
#[test]
fn thick_text_outlines_are_not_fake_bold() {
let bytes = text_pdf("BT /F1 24 Tf 1 0 0 rg 1 0 0 RG 5 w 2 Tr 20 50 Td (Hi) Tj ET");
let options = ImportOptions { pdf_dpi: 72.0, pdf_editable: true, ..ImportOptions::default() };
let imported = import_with_options_and_interrupt("thick-outline.pdf", &bytes, &options, &Interrupt::NONE).unwrap();
assert!(children(&imported.document).iter().all(|l| matches!(l.content, LayerContent::Raster(_))));
}
}
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.