mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-19 17:05:55 +01:00
Merge pull request #3715 from storytold/land/3356
G11 #722: keep imported PDF text boxes in place
This commit is contained in:
11 files changed
+1162
-137
No files matched your search
@@ -154,3 +154,8 @@ display_name = "Don Omondi"
|
||||
|
||||
[people.alpha-rock]
|
||||
display_name = "Aditya Sisodiya"
|
||||
|
||||
[people.Ronfo2013]
|
||||
real_name = "Angelo Bernardini"
|
||||
display_name = "Angelo Bernardini"
|
||||
sync_github_name = false
|
||||
@@ -1628,7 +1628,7 @@ impl<'p> Builder<'p> {
|
||||
return n.clone();
|
||||
}
|
||||
let data = o.font_data();
|
||||
let name = self.fonts.get(&key).map(|(n, _)| n.clone()).or_else(|| data.as_ref().and_then(|d| d.postscript_name.clone()));
|
||||
let name = self.fonts.get(&key).map(|f| f.name.clone()).or_else(|| data.as_ref().and_then(|d| d.postscript_name.clone()));
|
||||
let (weight, italic) = data.as_ref().map_or((None, false), |d| (d.weight, d.is_italic));
|
||||
// A subset's six-letter tag.
|
||||
let ps = name.as_deref().map(|n| match n.split_once('+') {
|
||||
@@ -1710,13 +1710,12 @@ impl<'p> Builder<'p> {
|
||||
return false;
|
||||
}
|
||||
let width = o.advance_width().filter(|w| w.is_finite());
|
||||
// Set vertically (WMode 1): no horizontal advance; its em box is a full em wide.
|
||||
// Set vertically (WMode 1): no horizontal advance.
|
||||
let upright = width.is_some_and(|w| w.abs() <= 1.0);
|
||||
let top = m * kurbo::Point::new(f64::from(width.filter(|w| *w > 1.0).unwrap_or(1000.0)) * 0.5, 880.0);
|
||||
let mut info = self.font_name(key, o);
|
||||
// A font the file doesn't carry is drawn with a stand-in: its glyphs can't tell which
|
||||
// style of the installed family it is, so the name decides.
|
||||
let embedded = self.fonts.get(&key).is_none_or(|(_, e)| *e);
|
||||
let embedded = self.fonts.get(&key).is_none_or(|f| f.embedded);
|
||||
if let Some(face) = &info.face
|
||||
&& embedded
|
||||
{
|
||||
@@ -1772,8 +1771,17 @@ impl<'p> Builder<'p> {
|
||||
stroke,
|
||||
};
|
||||
let advance = width.map_or(at.size * 0.5, |w| w as f64 / 1000.0 * at.size * at.h_scale / 100.0);
|
||||
let place = |line: &mut TextLine| {
|
||||
if upright { line.push_upright(&look, at, opacity, Upright { top }, &text) } else { line.push(&look, at, opacity, advance, &text) }
|
||||
// A glyph set vertically is drawn from its origin, which the file puts the position
|
||||
// vector's vx (from the font's `W2`, else half its width from `W` or `DW`) to the left of
|
||||
// the column's centre (ISO 32000-1 §9.7.4.3); vertical type centres each glyph on the
|
||||
// column. Half an em only for a full-width glyph (#722).
|
||||
let top = upright.then(|| {
|
||||
let vx = self.fonts.get(&key).and_then(|f| f.vertical.as_ref()).map_or(500.0, |v| v.centre(glyph));
|
||||
m * kurbo::Point::new(vx, 880.0)
|
||||
});
|
||||
let place = |line: &mut TextLine| match top {
|
||||
Some(top) => line.push_upright(&look, at, opacity, Upright { top }, &text),
|
||||
None => line.push(&look, at, opacity, advance, &text),
|
||||
};
|
||||
self.flush_glyphs();
|
||||
// A stroke over the glyph just filled (fill and stroke rendering).
|
||||
|
||||
@@ -14,10 +14,10 @@ use std::sync::Arc;
|
||||
|
||||
use kurbo::{Point, Rect, Shape};
|
||||
use vectorcraft_color::BlendMode;
|
||||
use vectorcraft_doc::{AppearanceItem, Justify, Node, NodeId, NodeKind, TextKind, TextObject, TextRun};
|
||||
use vectorcraft_doc::{AppearanceItem, CharStyle, Justify, Node, NodeId, NodeKind, TextKind, TextObject, TextRun};
|
||||
use vectorcraft_geom::shapes;
|
||||
|
||||
use crate::import_text::LineFacts;
|
||||
use crate::import_text::{LineFacts, median};
|
||||
|
||||
/// Rebuild the type among `nodes` (and in their groups) from what its lines tell (`lines`).
|
||||
pub(crate) fn rebuild(nodes: &mut Vec<Arc<Node>>, lines: &HashMap<NodeId, LineFacts>) {
|
||||
@@ -148,79 +148,108 @@ fn block(nodes: &[Arc<Node>], lines: &HashMap<NodeId, LineFacts>) -> (usize, Opt
|
||||
(count, (space > -size * 0.01).then_some(Block { leading, space: space.max(0.0), ys }))
|
||||
}
|
||||
|
||||
/// How far a line's characters' tracking may stray (thousandths of an em) and still be one
|
||||
/// value: placing each glyph where the file put it (#722) tracks characters a little apart where
|
||||
/// the file's widths are rounded, or it moved a glyph a hair (`TJ`).
|
||||
const EVEN_TRACKING: f64 = 10.0;
|
||||
|
||||
/// A line's spacing: the tracking after its letters, and how much more its spaces take (word
|
||||
/// spacing, `Tw`; `None` when it has none). `None` when its letters are tracked apart (set by
|
||||
/// hand), or its spaces more than `slack` apart.
|
||||
fn line_spacing(t: &TextObject, slack: f64) -> Option<(f64, Option<f64>)> {
|
||||
// The tracking of the runs with characters that are spaces (`true`) or that aren't.
|
||||
let tracking = |space: bool| -> Vec<f64> {
|
||||
t.runs.iter().filter(|r| r.text.chars().any(|c| c.is_whitespace() == space)).map(|r| r.style.tracking).collect()
|
||||
};
|
||||
let letters = tracking(false);
|
||||
let one = median(letters.clone())?;
|
||||
letters.iter().all(|x| (x - one).abs() <= EVEN_TRACKING).then_some(())?;
|
||||
let spaces = tracking(true);
|
||||
let word = match median(spaces.clone()) {
|
||||
Some(s) => {
|
||||
spaces.iter().all(|x| (x - s).abs() <= slack).then_some(())?;
|
||||
Some(s - one)
|
||||
}
|
||||
None => None,
|
||||
};
|
||||
Some((one, word))
|
||||
}
|
||||
|
||||
/// The one word spacing (thousandths of an em past the letters' tracking) of lines spaced
|
||||
/// `words` (`None`: no spaces): 0 for lines without.
|
||||
fn one_word_spacing(words: &[Option<f64>]) -> Option<f64> {
|
||||
let w: Vec<f64> = words.iter().flatten().copied().collect();
|
||||
let Some(one) = median(w.clone()) else { return Some(0.0) };
|
||||
w.iter().all(|x| (x - one).abs() <= EVEN_TRACKING).then_some(if one.abs() <= EVEN_TRACKING { 0.0 } else { one })
|
||||
}
|
||||
|
||||
/// Lines `nodes` of block `b` as one area type object, aligned left or justified, when laying it
|
||||
/// out breaks its lines where the file does.
|
||||
fn area_type(nodes: &[Arc<Node>], lines: &HashMap<NodeId, LineFacts>, b: &Block) -> Option<TextObject> {
|
||||
let texts: Vec<(&TextObject, &LineFacts)> = nodes.iter().map(|n| line(n, lines)).collect::<Option<_>>()?;
|
||||
let (first, _) = texts.first()?;
|
||||
let size = first.first_style().size;
|
||||
// A line's tracking: one for all its runs, or (`spaces` false) one for its runs other than
|
||||
// lone spaces.
|
||||
let shared = |t: &TextObject, spaces: bool| {
|
||||
let mut all = t.runs.iter().filter(|r| spaces || r.text != " ").map(|r| r.style.tracking);
|
||||
let one = all.next()?;
|
||||
all.all(|x| x == one).then_some(one)
|
||||
};
|
||||
// As justified type, a wrapped line's tracking leaves out its spaces when each space is a run
|
||||
// of its own, tracked within a fiftieth of an em of the line's first space.
|
||||
let spread = |t: &TextObject| {
|
||||
let tracking = shared(t, false)?;
|
||||
let mut spaces = t.runs.iter().filter(|r| r.text == " ").map(|r| r.style.tracking);
|
||||
let alike =
|
||||
spaces.next().is_some_and(|s| spaces.all(|x| (x - s).abs() <= 20.0)) && !t.runs.iter().any(|r| r.text != " " && r.text.contains(' '));
|
||||
(alike || shared(t, true).is_some()).then_some(tracking)
|
||||
};
|
||||
let trackings: Option<Vec<f64>> = texts.iter().map(|(t, _)| shared(t, true)).collect();
|
||||
let justified: Option<Vec<f64>> = texts.iter().map(|(t, f)| if f.wraps { spread(t) } else { shared(t, true) }).collect();
|
||||
let median = |mut v: Vec<f64>| {
|
||||
v.sort_by(f64::total_cmp);
|
||||
v.get(v.len() / 2).copied()
|
||||
};
|
||||
// Each line's tracking and word spacing. A justified line spaces its words out (word spacing,
|
||||
// `Tw`), which justification does again (#722); word spacing the same on every line is the
|
||||
// type's own.
|
||||
// A wrapped line's spaces may each be tracked apart, within a fiftieth of an em of each other.
|
||||
let spacings: Vec<(f64, Option<f64>)> =
|
||||
texts.iter().map(|(t, f)| line_spacing(t, if f.wraps { 20.0 } else { EVEN_TRACKING })).collect::<Option<_>>()?;
|
||||
let trackings: Vec<f64> = spacings.iter().map(|(t, _)| *t).collect();
|
||||
let words: Vec<Option<f64>> = spacings.iter().map(|(_, w)| *w).collect();
|
||||
let wrapped: Vec<f64> = texts.iter().filter(|(_, f)| f.wraps).map(|(_, f)| f.length).collect();
|
||||
let longest = |v: &[f64]| v.iter().copied().fold(0.0, f64::max);
|
||||
let mut tries = vec![];
|
||||
// Wrapped lines all as long: justified (a paragraph's last line aligned left), tracked as the
|
||||
// lines that end paragraphs are (the others are spaced out).
|
||||
// Wrapped lines all as long: justified (a paragraph's last line aligned left), tracked and
|
||||
// word spaced as the lines that end paragraphs are (the others are spaced out).
|
||||
let full = longest(&wrapped);
|
||||
let ends: Vec<usize> = texts.iter().enumerate().filter(|(_, (_, f))| !f.wraps).map(|(i, _)| i).collect();
|
||||
let end_words: Vec<Option<f64>> = ends.iter().filter_map(|i| words.get(*i).copied()).collect();
|
||||
if wrapped.len() >= 2
|
||||
&& wrapped.iter().all(|l| (full - l).abs() <= size * 0.02)
|
||||
&& let Some(justified) = justified
|
||||
&& let Some(word) = one_word_spacing(&end_words)
|
||||
{
|
||||
let ends: Vec<f64> = texts.iter().zip(&justified).filter(|((_, f), _)| !f.wraps).map(|(_, t)| *t).collect();
|
||||
let tracking = median(ends).or_else(|| justified.iter().copied().reduce(f64::min))?;
|
||||
tries.push((Justify::JustifyLeft, full, tracking));
|
||||
let tracking =
|
||||
median(ends.iter().filter_map(|i| trackings.get(*i).copied()).collect()).or_else(|| trackings.iter().copied().reduce(f64::min))?;
|
||||
tries.push((Justify::JustifyLeft, full, tracking, word));
|
||||
}
|
||||
let all: Vec<f64> = texts.iter().map(|(_, f)| f.length).collect();
|
||||
if let Some(trackings) = trackings {
|
||||
tries.push((Justify::Left, longest(&all) + size * 0.02, median(trackings)?));
|
||||
// Every line spaced alike: aligned left.
|
||||
if let Some(word) = one_word_spacing(&words) {
|
||||
let all: Vec<f64> = texts.iter().map(|(_, f)| f.length).collect();
|
||||
tries.push((Justify::Left, longest(&all) + size * 0.02, median(trackings)?, word));
|
||||
}
|
||||
tries.into_iter().find_map(|(justify, width, tracking)| laid_out(&texts, b, justify, width, tracking))
|
||||
tries.into_iter().find_map(|(justify, width, tracking, word)| laid_out(&texts, b, justify, width, tracking, word))
|
||||
}
|
||||
|
||||
/// The area type of lines `texts` (block `b`): `width` wide, aligned `justify`, its characters
|
||||
/// tracked `tracking`; `None` when it doesn't lay out as the lines did.
|
||||
fn laid_out(texts: &[(&TextObject, &LineFacts)], b: &Block, justify: Justify, width: f64, tracking: f64) -> Option<TextObject> {
|
||||
/// tracked `tracking` and its spaces `word` more; `None` when it doesn't lay out as the lines did.
|
||||
fn laid_out(texts: &[(&TextObject, &LineFacts)], b: &Block, justify: Justify, width: f64, tracking: f64, word: f64) -> Option<TextObject> {
|
||||
let (first, _) = texts.first()?;
|
||||
let size = first.first_style().size;
|
||||
// Leading as set, unless it is Auto's (120% of the size).
|
||||
let explicit =
|
||||
(b.leading - size * 1.2).abs() > size * 1e-3 || texts.iter().any(|(t, _)| t.runs.iter().any(|r| (r.style.size - size).abs() > 1e-9));
|
||||
let mut runs: Vec<TextRun> = vec![];
|
||||
let mut push = |text: &str, style: CharStyle| match runs.last_mut() {
|
||||
Some(last) if last.style == style => last.text.push_str(text),
|
||||
_ => runs.push(TextRun { text: text.to_string(), style, inline: None }),
|
||||
};
|
||||
for (k, (t, f)) in texts.iter().enumerate() {
|
||||
let mut style = CharStyle::default();
|
||||
for r in &t.runs {
|
||||
let mut style = r.style.clone();
|
||||
style.tracking = tracking;
|
||||
style = r.style.clone();
|
||||
style.tracking = if r.text.trim().is_empty() { tracking + word } else { tracking };
|
||||
style.leading = explicit.then_some((b.leading * 1000.0).round() / 1000.0);
|
||||
match runs.last_mut() {
|
||||
Some(last) if last.style == style => last.text.push_str(&r.text),
|
||||
_ => runs.push(TextRun { text: r.text.clone(), style, inline: None }),
|
||||
}
|
||||
push(&r.text, style.clone());
|
||||
}
|
||||
// A wrapped line's space, or the end of a paragraph.
|
||||
if k + 1 < texts.len()
|
||||
&& let Some(last) = runs.last_mut()
|
||||
{
|
||||
last.text.push(if f.wraps { ' ' } else { '\n' });
|
||||
if k + 1 < texts.len() {
|
||||
if f.wraps {
|
||||
style.tracking = tracking + word;
|
||||
push(" ", style);
|
||||
} else {
|
||||
push("\n", style);
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut t = (*first).clone();
|
||||
|
||||
@@ -20,7 +20,7 @@ use craft_pdf::interpret::CacheKey;
|
||||
use craft_pdf::syntax::Pdf;
|
||||
use craft_pdf::syntax::content::TypedIter;
|
||||
use craft_pdf::syntax::content::ops::TypedInstruction;
|
||||
use craft_pdf::syntax::object::{Array, Dict, FromBytes, MaybeRef, Name, Object, ObjectIdentifier, dict_or_stream};
|
||||
use craft_pdf::syntax::object::{Array, Dict, FromBytes, MaybeRef, Name, Object, ObjectIdentifier, Stream, dict_or_stream};
|
||||
use craft_pdf::syntax::page::{Page, Resources};
|
||||
|
||||
use crate::PdfError;
|
||||
@@ -617,7 +617,10 @@ impl Walker<'_, '_> {
|
||||
if let Some(f) = res.fonts.get::<Dict<'_>>(key.as_ref())
|
||||
&& let Some(name) = f.get::<Name<'_>>(b"BaseFont")
|
||||
{
|
||||
self.fonts.entry(f.cache_key()).or_insert_with(|| (String::from_utf8_lossy(name.as_ref()).into_owned(), embeds_glyphs(&f)));
|
||||
self.fonts.entry(f.cache_key()).or_insert_with(|| {
|
||||
let embedded = embeds_glyphs(&f);
|
||||
FontNote { name: String::from_utf8_lossy(name.as_ref()).into_owned(), embedded, vertical: vertical_metrics(&f, embedded) }
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -841,9 +844,153 @@ impl Walker<'_, '_> {
|
||||
}
|
||||
}
|
||||
|
||||
/// The fonts of a document by cache key: base font name, and whether the file carries the glyphs
|
||||
/// ([`embeds_glyphs`]).
|
||||
pub(crate) type FontNames = HashMap<u128, (String, bool)>;
|
||||
/// The fonts of a document by cache key.
|
||||
pub(crate) type FontNames = HashMap<u128, FontNote>;
|
||||
|
||||
/// What a document says of one of its fonts.
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct FontNote {
|
||||
/// Its base (PostScript) font name.
|
||||
pub name: String,
|
||||
/// The file carries its glyphs ([`embeds_glyphs`]).
|
||||
pub embedded: bool,
|
||||
/// A composite font written vertically: its descendant's metrics.
|
||||
pub vertical: Option<Vertical>,
|
||||
}
|
||||
|
||||
/// The most CIDs a vertical font's widths are read for (the most a CID-keyed font has).
|
||||
const MAX_CIDS: u32 = 65_536;
|
||||
|
||||
/// A vertical composite font's metrics (ISO 32000-1 §9.7.4.3), in glyph space (1000 units an em):
|
||||
/// where each glyph's position vector puts the column's centre.
|
||||
#[derive(Debug, Default)]
|
||||
pub(crate) struct Vertical {
|
||||
/// The default width (`DW`, w0).
|
||||
default: f64,
|
||||
/// Widths by CID (`W`).
|
||||
widths: HashMap<u32, f64>,
|
||||
/// The position vector's x by CID (`W2`'s vx).
|
||||
vx: HashMap<u32, f64>,
|
||||
/// The CID of each glyph: `None` when they can't be told (a CID-keyed CFF font's charset
|
||||
/// decides, or a font the file doesn't carry is drawn with a stand-in's glyphs).
|
||||
cids: Option<Cids>,
|
||||
}
|
||||
|
||||
/// How glyph ids map back to CIDs.
|
||||
#[derive(Debug)]
|
||||
enum Cids {
|
||||
/// The same (`CIDToGIDMap` `/Identity`, or none).
|
||||
Identity,
|
||||
/// The first CID of each glyph a `CIDToGIDMap` stream maps.
|
||||
Map(HashMap<u32, u32>),
|
||||
}
|
||||
|
||||
impl Vertical {
|
||||
/// How far right of glyph `gid`'s origin (glyph space) the column's centre is: the position
|
||||
/// vector's vx from `W2`, else half the glyph's width (w0 from `W`, or `DW`).
|
||||
pub fn centre(&self, gid: u32) -> f64 {
|
||||
let cid = match &self.cids {
|
||||
Some(Cids::Identity) => Some(gid),
|
||||
Some(Cids::Map(m)) => m.get(&gid).copied(),
|
||||
None => None,
|
||||
};
|
||||
let w0 = |cid: Option<u32>| cid.and_then(|c| self.widths.get(&c)).copied().unwrap_or(self.default) * 0.5;
|
||||
cid.and_then(|c| self.vx.get(&c)).copied().unwrap_or_else(|| w0(cid))
|
||||
}
|
||||
}
|
||||
|
||||
/// The vertical metrics of font `f` when it is a composite font written vertically (its CMap's
|
||||
/// writing mode is 1), from its descendant CIDFont. `embedded`: the file carries its glyphs.
|
||||
pub(crate) fn vertical_metrics(f: &Dict<'_>, embedded: bool) -> Option<Vertical> {
|
||||
if f.get::<Name<'_>>(b"Subtype")?.as_ref() != b"Type0" {
|
||||
return None;
|
||||
}
|
||||
let vertical = match f.get::<Name<'_>>(b"Encoding") {
|
||||
Some(n) => n.as_ref().ends_with(b"-V"),
|
||||
None => f.get::<Stream<'_>>(b"Encoding").is_some_and(|s| s.dict().get::<i32>(b"WMode") == Some(1)),
|
||||
};
|
||||
if !vertical {
|
||||
return None;
|
||||
}
|
||||
let d = f.get::<Array<'_>>(b"DescendantFonts").and_then(|a| a.iter::<Dict<'_>>().next())?;
|
||||
let finite = |v: f64| v.is_finite() && v.abs() < 1e5;
|
||||
let default = d.get::<f64>(b"DW").filter(|w| finite(*w)).unwrap_or(1000.0);
|
||||
let mut widths = HashMap::new();
|
||||
if let Some(w) = d.get::<Array<'_>>(b"W") {
|
||||
cid_ranges(&w, 1, |cid, v| {
|
||||
if let [w0] = v {
|
||||
widths.insert(cid, *w0);
|
||||
}
|
||||
});
|
||||
}
|
||||
let mut vx = HashMap::new();
|
||||
if let Some(w2) = d.get::<Array<'_>>(b"W2") {
|
||||
cid_ranges(&w2, 3, |cid, v| {
|
||||
if let [_, x, _] = v {
|
||||
vx.insert(cid, *x);
|
||||
}
|
||||
});
|
||||
}
|
||||
widths.retain(|_, w| finite(*w));
|
||||
vx.retain(|_, x| finite(*x));
|
||||
let true_type = d.get::<Name<'_>>(b"Subtype").is_some_and(|s| s.as_ref() == b"CIDFontType2");
|
||||
let cids = if !embedded || !true_type {
|
||||
None
|
||||
} else if let Some(s) = d.get::<Stream<'_>>(b"CIDToGIDMap") {
|
||||
// Two bytes a CID, the glyph it maps to.
|
||||
let data = s.decoded().ok()?;
|
||||
let mut m = HashMap::new();
|
||||
for (cid, g) in (0..MAX_CIDS).zip(data.as_chunks::<2>().0) {
|
||||
m.entry(u32::from(u16::from_be_bytes(*g))).or_insert(cid);
|
||||
}
|
||||
Some(Cids::Map(m))
|
||||
} else {
|
||||
Some(Cids::Identity)
|
||||
};
|
||||
Some(Vertical { default, widths, vx, cids })
|
||||
}
|
||||
|
||||
/// Each CID a `W` or `W2` array (`per` numbers a CID) gives values for, and its values: `c [v…]`
|
||||
/// gives CIDs from c on their values in turn, `c_first c_last v…` the same values to each of the
|
||||
/// range. At most [`MAX_CIDS`] CIDs are read.
|
||||
fn cid_ranges(a: &Array<'_>, per: usize, mut each: impl FnMut(u32, &[f64])) {
|
||||
let mut it = a.flex_iter();
|
||||
let mut read = 0;
|
||||
loop {
|
||||
if let Some((first, list)) = it.next::<(u32, Array<'_>)>() {
|
||||
let values: Vec<f64> = list.iter::<f64>().collect();
|
||||
for (cid, v) in (first..=u32::MAX).zip(values.chunks_exact(per)) {
|
||||
read += 1;
|
||||
if read > MAX_CIDS {
|
||||
return;
|
||||
}
|
||||
each(cid, v);
|
||||
}
|
||||
} else if per == 1
|
||||
&& let Some((first, last, w)) = it.next::<(u32, u32, f64)>()
|
||||
{
|
||||
for cid in first..=last.min(first.saturating_add(MAX_CIDS)) {
|
||||
read += 1;
|
||||
if read > MAX_CIDS {
|
||||
return;
|
||||
}
|
||||
each(cid, &[w]);
|
||||
}
|
||||
} else if per == 3
|
||||
&& let Some((first, last, w, x, y)) = it.next::<(u32, u32, f64, f64, f64)>()
|
||||
{
|
||||
for cid in first..=last.min(first.saturating_add(MAX_CIDS)) {
|
||||
read += 1;
|
||||
if read > MAX_CIDS {
|
||||
return;
|
||||
}
|
||||
each(cid, &[w, x, y]);
|
||||
}
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether font `f` carries its own glyphs: a font program in its descriptor (a composite font's in
|
||||
/// its descendant's), or a Type 3 font's glyph procedures. A font that doesn't is drawn with a
|
||||
|
||||
+296
-74
@@ -1,6 +1,8 @@
|
||||
//! Text as editable point type: glyphs drawn one after another on the same baseline make one
|
||||
//! point text object of their Unicode text, a run per font, size and paint (a gap wider than a
|
||||
//! fifth of the smaller size beside it reads as a space). Fonts are named from the file's base font name (its
|
||||
//! fifth of the smaller size beside it reads as a space; a glyph the file raised or lowered off the
|
||||
//! baseline, text rise, is baseline shift). Each glyph stays where the file drew it: the kerning
|
||||
//! and tracking the type takes put it there (#722). Fonts are named from the file's base font name (its
|
||||
//! subset prefix dropped, the family matched against the fonts available); a font that isn't
|
||||
//! available keeps its name, and the text shows in the fallback font until it is.
|
||||
//!
|
||||
@@ -161,7 +163,13 @@ pub(crate) struct TextLine {
|
||||
last_size: f64,
|
||||
/// Each glyph's baseline origin, then where the last one ends.
|
||||
baseline: Vec<Point>,
|
||||
runs: Vec<(Look, String)>,
|
||||
/// Runs of glyphs drawn alike: their look, how far the file raised them off the line's
|
||||
/// baseline (points, up; text rise, `Ts`), their text.
|
||||
runs: Vec<(Look, f64, String)>,
|
||||
/// Where the file put each character of the runs' text, in order: the first character of each
|
||||
/// glyph has its glyph's [`Slot`]; a space read from a gap and the other characters of a
|
||||
/// glyph of several have none.
|
||||
slots: Vec<Option<Slot>>,
|
||||
/// The first glyph was set vertically ([`Upright`]).
|
||||
upright: Option<Upright>,
|
||||
/// The glyphs make a column (vertical type), each below the last.
|
||||
@@ -179,13 +187,19 @@ pub(crate) struct TextLine {
|
||||
/// A space the file drew after a glyph that isn't one, until the next glyph comes: its byte
|
||||
/// offset, and the gap before it plus its advance (points).
|
||||
drawn_space: Option<(usize, f64)>,
|
||||
/// Each glyph's advance in the file's font (points), with [`Self::baseline`].
|
||||
advances: Vec<f64>,
|
||||
/// The strokes of its glyphs' outlines drawn between them, one per glyph with ink so far
|
||||
/// (written right after the line).
|
||||
pub held: Vec<Node>,
|
||||
}
|
||||
|
||||
/// Where the file put a glyph: the glyph's index in the line, and its advance in the file's font
|
||||
/// (points) when it shows one character (`None` for a ligature's several).
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
struct Slot {
|
||||
glyph: usize,
|
||||
advance: Option<f64>,
|
||||
}
|
||||
|
||||
/// What a finished line of type tells beyond its text object (see [`crate::import_lines`]).
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub(crate) struct LineFacts {
|
||||
@@ -213,13 +227,13 @@ impl TextLine {
|
||||
last_size: at.size,
|
||||
baseline: vec![],
|
||||
runs: vec![],
|
||||
slots: vec![],
|
||||
upright: None,
|
||||
column: false,
|
||||
ink: vec![],
|
||||
gaps: vec![],
|
||||
drawn_spaces: vec![],
|
||||
drawn_space: None,
|
||||
advances: vec![],
|
||||
held: vec![],
|
||||
}
|
||||
}
|
||||
@@ -235,8 +249,8 @@ impl TextLine {
|
||||
pub fn push_upright(&mut self, look: &Look, at: Placement, opacity: f32, upright: Upright, text: &str) -> bool {
|
||||
let down = -self.at.up();
|
||||
let size = self.at.size.max(at.size);
|
||||
let Some((last, run)) = self.runs.last_mut() else {
|
||||
self.runs.push((look.clone(), text.to_string()));
|
||||
let Some((last, _, run)) = self.runs.last_mut() else {
|
||||
self.runs.push((look.clone(), 0.0, text.to_string()));
|
||||
(self.upright, self.next, self.last) = (Some(upright), at.origin + down * at.size, at.origin);
|
||||
return true;
|
||||
};
|
||||
@@ -264,7 +278,7 @@ impl TextLine {
|
||||
if last.takes(look) {
|
||||
run.push_str(text);
|
||||
} else {
|
||||
self.runs.push((look.clone(), text.to_string()));
|
||||
self.runs.push((look.clone(), 0.0, text.to_string()));
|
||||
}
|
||||
self.next = at.origin + down * at.size;
|
||||
self.last = at.origin;
|
||||
@@ -278,17 +292,33 @@ impl TextLine {
|
||||
if self.column || self.upright.is_some() {
|
||||
return false;
|
||||
}
|
||||
let bytes: usize = self.runs.iter().map(|(_, t)| t.len()).sum();
|
||||
if let Some((last, run)) = self.runs.last_mut() {
|
||||
let bytes: usize = self.runs.iter().map(|(_, _, t)| t.len()).sum();
|
||||
let glyph = self.baseline.len();
|
||||
let curved = self.curved();
|
||||
let mut shift = 0.0;
|
||||
if let Some((last, last_shift, run)) = self.runs.last_mut() {
|
||||
let size = self.at.size.max(at.size);
|
||||
let gap = (at.origin - self.next).dot(self.last_dir);
|
||||
// How far the glyph sits above the line's baseline. The file raises a superscript or
|
||||
// lowers a subscript (text rise, `Ts`) with the glyphs turned exactly as the rest of
|
||||
// the line (`level`): it stays on the line, shifted off its baseline. Up to half an em
|
||||
// when it follows on from the glyph before (no wider gap than a space reads from):
|
||||
// further apart, it is type of its own (the next cell of a table's row, its baseline a
|
||||
// little higher).
|
||||
let above = (at.origin - self.at.origin).dot(self.at.up());
|
||||
let level = at.dir.dot(self.at.dir) > 1.0 - 1e-9 && !curved;
|
||||
let on_line = opacity == self.opacity
|
||||
&& at.dir.dot(self.at.dir) > 0.9995
|
||||
&& (at.slant - self.at.slant).abs() < 1e-3
|
||||
&& (at.origin - self.at.origin).dot(self.at.up()).abs() < size * 0.15
|
||||
&& (above.abs() < size * 0.15 || (level && above.abs() < size * 0.5 && gap <= size * 0.2))
|
||||
// Proportional widths close CJK marks up by up to half an em.
|
||||
&& gap > -size * 0.6
|
||||
&& gap < size * 3.0;
|
||||
// Within a hair of the baseline (rounding in the file) is on it; a glyph turned a
|
||||
// little (type on a path) sits on the curve, not shifted off it.
|
||||
if on_line && level && above.abs() > size * 0.01 {
|
||||
shift = above;
|
||||
}
|
||||
// Or on a curve: turned a little from the glyph before it, and starting about where
|
||||
// that one ends.
|
||||
let on_curve = !on_line
|
||||
@@ -312,14 +342,17 @@ impl TextLine {
|
||||
self.drawn_spaces.push((b, before + gap));
|
||||
}
|
||||
}
|
||||
if last.takes(look) {
|
||||
if last.takes(look) && (*last_shift - shift).abs() < 1e-3 {
|
||||
run.push_str(text);
|
||||
} else {
|
||||
self.runs.push((look.clone(), text.to_string()));
|
||||
self.runs.push((look.clone(), shift, text.to_string()));
|
||||
}
|
||||
} else {
|
||||
self.runs.push((look.clone(), text.to_string()));
|
||||
self.runs.push((look.clone(), 0.0, text.to_string()));
|
||||
}
|
||||
let one = text.chars().count() == 1;
|
||||
self.slots.push(Some(Slot { glyph, advance: one.then_some(advance) }));
|
||||
self.slots.extend(text.chars().skip(1).map(|_| None));
|
||||
self.next = at.origin + at.dir * advance;
|
||||
if !text.trim().is_empty() {
|
||||
self.visible = self.next;
|
||||
@@ -328,7 +361,6 @@ impl TextLine {
|
||||
self.last_dir = at.dir;
|
||||
self.last_size = at.size;
|
||||
self.baseline.push(at.origin);
|
||||
self.advances.push(advance);
|
||||
true
|
||||
}
|
||||
|
||||
@@ -365,7 +397,7 @@ impl TextLine {
|
||||
/// and stroke rendering), which `overprint`s or not: the run is stroked. `false`: it isn't
|
||||
/// that glyph.
|
||||
pub fn stroke_last(&mut self, font: u128, at: Placement, stroke: (Paint, f64), overprint: bool) -> bool {
|
||||
let Some((look, _)) = self.runs.last_mut().filter(|(l, _)| l.font == font && (at.origin - self.last).hypot() < self.at.size * 1e-3) else {
|
||||
let Some((look, ..)) = self.runs.last_mut().filter(|(l, ..)| l.font == font && (at.origin - self.last).hypot() < self.at.size * 1e-3) else {
|
||||
return false;
|
||||
};
|
||||
(look.stroke, look.overprint_stroke) = (Some(stroke), overprint);
|
||||
@@ -377,15 +409,46 @@ impl TextLine {
|
||||
let mut facts = LineFacts { ink: std::mem::take(&mut self.ink), ..LineFacts::default() };
|
||||
// Turned along a curve: type on a path through the glyphs.
|
||||
let path = if self.curved() { self.baseline_path() } else { None };
|
||||
facts.wraps = path.is_none() && self.upright.is_none() && self.runs.last().is_some_and(|(_, t)| t.ends_with(' '));
|
||||
if let Some((_, last)) = self.runs.last_mut() {
|
||||
facts.wraps = path.is_none() && self.upright.is_none() && self.runs.last().is_some_and(|(.., t)| t.ends_with(' '));
|
||||
if let Some((.., last)) = self.runs.last_mut() {
|
||||
last.truncate(last.trim_end().len());
|
||||
}
|
||||
self.runs.retain(|(_, t)| !t.is_empty());
|
||||
if self.runs.iter().all(|(_, t)| t.trim().is_empty()) {
|
||||
self.runs.retain(|(.., t)| !t.is_empty());
|
||||
if self.runs.iter().all(|(.., t)| t.trim().is_empty()) {
|
||||
return None;
|
||||
}
|
||||
let mut runs = self.runs.into_iter().map(|(look, text)| TextRun { text, style: look.style(), inline: None });
|
||||
// The spaces trimmed off the end have no place either.
|
||||
let chars: usize = self.runs.iter().map(|(.., t)| t.chars().count()).sum();
|
||||
self.slots.truncate(chars);
|
||||
// The baseline most of the characters sit on is the line's: the others are shifted off it
|
||||
// (a line starting with a raised footnote mark keeps the baseline of its text).
|
||||
let mut on: Vec<(f64, usize)> = vec![];
|
||||
for (_, shift, text) in &self.runs {
|
||||
let n = text.chars().count();
|
||||
match on.iter_mut().find(|(s, _)| (s - shift).abs() < 1e-3) {
|
||||
Some((_, count)) => *count += n,
|
||||
None => on.push((*shift, n)),
|
||||
}
|
||||
}
|
||||
// A tie keeps the first glyph's ("m²" sits on the m's baseline).
|
||||
let base = on.iter().fold(None::<(f64, usize)>, |best, &(s, n)| if best.is_none_or(|(_, b)| n > b) { Some((s, n)) } else { best });
|
||||
let base = base.map_or(0.0, |(s, _)| s);
|
||||
if path.is_some() {
|
||||
// Type on a path sits on its curve: no glyph is shifted off it.
|
||||
for (_, shift, _) in &mut self.runs {
|
||||
*shift = 0.0;
|
||||
}
|
||||
} else if base != 0.0 {
|
||||
// Up the slant the type leans by (a sheared text matrix), as the file raises it.
|
||||
self.at.origin += (self.at.up() + self.at.dir * self.at.slant) * base;
|
||||
for (_, shift, _) in &mut self.runs {
|
||||
*shift -= base;
|
||||
}
|
||||
}
|
||||
let mut runs = self.runs.into_iter().map(|(look, shift, text)| {
|
||||
let style = CharStyle { baseline_shift: round(shift), ..look.style() };
|
||||
TextRun { text, style, inline: None }
|
||||
});
|
||||
let first = runs.next()?;
|
||||
let mut t = TextObject::point(Point::ORIGIN, &first.text, first.style);
|
||||
t.runs.extend(runs);
|
||||
@@ -409,15 +472,21 @@ impl TextLine {
|
||||
// After the earlier spaces, at the end of the run before it (the run it follows).
|
||||
let at = gap.at + spaces.len();
|
||||
let mut offset = 0;
|
||||
let Some(run) = t.runs.iter_mut().find(|run| {
|
||||
let Some(i) = t.runs.iter().position(|run| {
|
||||
offset += run.text.len();
|
||||
at <= offset
|
||||
}) else {
|
||||
break;
|
||||
};
|
||||
// The characters before it, in the runs before and in its own.
|
||||
let earlier: usize = t.runs.iter().take(i).map(|r| r.text.chars().count()).sum();
|
||||
let Some(run) = t.runs.get_mut(i) else { break };
|
||||
let at = at - (offset - run.text.len());
|
||||
if !run.text.is_char_boundary(at) {
|
||||
continue;
|
||||
let Some(head) = run.text.get(..at) else { continue };
|
||||
// A space read from a gap has no slot of its own.
|
||||
let char_at = earlier + head.chars().count();
|
||||
if char_at <= self.slots.len() {
|
||||
self.slots.insert(char_at, None);
|
||||
}
|
||||
run.text.insert(at, ' ');
|
||||
spaces.push((gap.at, gap.width, gap.on_line));
|
||||
@@ -433,19 +502,20 @@ impl TextLine {
|
||||
// The glyphs' tops lean along the baseline (+x), up being -y in the type's own space.
|
||||
t.xf = Affine::translate(self.at.origin.to_vec2()) * Affine::rotate(angle) * Affine::skew(-self.at.slant, 0.0);
|
||||
let db = vectorcraft_text::FontDb::global();
|
||||
// Glyphs spaced each their own way (character tightening, optical kerning) keep their
|
||||
// place: each character its own tracking.
|
||||
let own = (self.upright.is_none() && t.para.direction.is_none())
|
||||
.then(|| own_spacing(&t, &self.baseline, &self.advances, path.as_ref(), self.at.dir, self.at.size))
|
||||
.flatten();
|
||||
if let Some(own) = &own {
|
||||
t.runs = tracked_each(std::mem::take(&mut t.runs), own, self.at.size);
|
||||
}
|
||||
// Each glyph where the file put it (#722): the kerning (the font's, or none) and tracking
|
||||
// (one value for the line, or each character its own) that place them there.
|
||||
let placed = (self.upright.is_none() && t.para.direction.is_none())
|
||||
.then(|| place_each(&t, &self.slots, &self.baseline, path.as_ref(), self.at, self.at.size))
|
||||
.flatten()
|
||||
.map(|(runs, laid)| {
|
||||
t.runs = runs;
|
||||
laid.bounds
|
||||
});
|
||||
if let Some(path) = path {
|
||||
// Evenly spaced type keeps its length along the path: the path runs through the
|
||||
// glyphs' origins, one curve each, to the end of the last glyph, and tracking makes up
|
||||
// the difference from the advances.
|
||||
if own.is_none() {
|
||||
if placed.is_none() {
|
||||
let length: f64 = path.segments().take(self.baseline.len()).map(|seg| kurbo::ParamCurveArclen::arclen(&seg, 1e-3)).sum();
|
||||
let laid = vectorcraft_text::layout(db, &t);
|
||||
let natural: f64 = laid.glyphs.iter().map(|g| g.advance).sum();
|
||||
@@ -479,12 +549,17 @@ impl TextLine {
|
||||
if !t.vertical {
|
||||
facts.length = length;
|
||||
}
|
||||
// Placed glyph by glyph: laid out so already.
|
||||
if let Some(bounds) = placed {
|
||||
t.cached_bounds = Some(bounds);
|
||||
return Some((t, self.opacity, facts));
|
||||
}
|
||||
let laid = vectorcraft_text::layout(db, &t);
|
||||
let natural: f64 = laid.glyphs.iter().map(|g| g.advance).sum();
|
||||
let chars: usize = t.runs.iter().map(|r| r.text.chars().count()).sum();
|
||||
let size = self.at.size;
|
||||
let mut bounds = laid.bounds;
|
||||
if own.is_none() && chars > 1 && length.is_finite() && (length - natural).abs() > size * 0.01 {
|
||||
if chars > 1 && length.is_finite() && (length - natural).abs() > size * 0.01 {
|
||||
// The spaces read from gaps or drawn between glyphs keep their own place only in text
|
||||
// left in the file's order.
|
||||
let total: usize = t.runs.iter().map(|r| r.text.len()).sum();
|
||||
@@ -499,59 +574,206 @@ impl TextLine {
|
||||
}
|
||||
}
|
||||
|
||||
/// The space each glyph of `t` (laid out untracked) leaves after its advance to put the next one
|
||||
/// where the file did (points; the last glyph's is the one before it), when that varies by more
|
||||
/// than a fiftieth of an em: one tracking value can't place them. Glyph origins are `baseline`,
|
||||
/// measured along `path` (type on a path: one curve per glyph) or along `dir`. None when the
|
||||
/// glyphs can't be matched to the characters one to one (spaces, ligatures), or when the font
|
||||
/// laid out isn't the file's (its advances differ from `advances`): spacing measured against a
|
||||
/// stand-in's widths would keep the stand-in's differences once the font is installed.
|
||||
fn own_spacing(t: &TextObject, baseline: &[Point], advances: &[f64], path: Option<&BezPath>, dir: Vec2, size: f64) -> Option<Vec<f64>> {
|
||||
let text: String = t.runs.iter().map(|r| r.text.as_str()).collect();
|
||||
let chars = text.chars().count();
|
||||
if chars < 3 || text.contains(' ') || baseline.len() != chars || advances.len() != chars {
|
||||
return None;
|
||||
/// Where along the line (points) layout `laid` puts each character at a byte offset of `chars`
|
||||
/// (in order), and its advance: `None` for one inside another's cluster. Text in the file's order
|
||||
/// (left to right).
|
||||
fn pens(laid: &TextLayout, chars: &[usize]) -> Vec<Option<(f64, f64)>> {
|
||||
let mut at = vec![None; chars.len()];
|
||||
let mut pen = 0.0;
|
||||
for g in &laid.glyphs {
|
||||
if let Some(slot) = chars.binary_search(&g.byte).ok().and_then(|i| at.get_mut(i)) {
|
||||
slot.get_or_insert((pen, g.advance));
|
||||
}
|
||||
pen += g.advance;
|
||||
}
|
||||
let laid = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);
|
||||
let advs: Vec<f64> = laid.glyphs.iter().map(|g| g.advance).collect();
|
||||
if advs.len() != chars || advs.iter().zip(advances).any(|(a, b)| (a - b).abs() > size * 0.01) {
|
||||
return None;
|
||||
}
|
||||
let dist: Vec<f64> = match path {
|
||||
Some(bp) => bp.segments().take(chars - 1).map(|seg| kurbo::ParamCurveArclen::arclen(&seg, 1e-3)).collect(),
|
||||
None => baseline.windows(2).map(|w| (w[1] - w[0]).dot(dir)).collect(),
|
||||
};
|
||||
if dist.len() != chars - 1 {
|
||||
return None;
|
||||
}
|
||||
let mut extra: Vec<f64> = dist.iter().zip(&advs).map(|(d, a)| d - a).collect();
|
||||
let mean = extra.iter().sum::<f64>() / extra.len() as f64;
|
||||
if extra.iter().all(|e| (e - mean).abs() <= size * 0.02) {
|
||||
return None;
|
||||
}
|
||||
extra.push(*extra.last()?);
|
||||
Some(extra)
|
||||
at
|
||||
}
|
||||
|
||||
/// `runs` with each character's tracking from `own` (points, one per character), characters with
|
||||
/// the same tracking kept in one run.
|
||||
fn tracked_each(runs: Vec<TextRun>, own: &[f64], size: f64) -> Vec<TextRun> {
|
||||
let em = |pts: f64| (pts / size * 1000.0).clamp(-1000.0, 1000.0).round();
|
||||
let mut out: Vec<TextRun> = vec![];
|
||||
/// `t`'s runs with kerning `kern` and each character's tracking from `own` (points, one per
|
||||
/// character, in thousandths of each run's em), characters alike kept in one run.
|
||||
fn restyled(t: &TextObject, kern: Option<f64>, own: &[f64]) -> Vec<TextRun> {
|
||||
let mut out: Vec<TextRun> = Vec::with_capacity(t.runs.len());
|
||||
// The run of `t` the last character came from.
|
||||
let mut from = None;
|
||||
let mut k = 0;
|
||||
for r in runs {
|
||||
for (i, r) in t.runs.iter().enumerate() {
|
||||
let size = r.style.size.max(1e-3);
|
||||
for c in r.text.chars() {
|
||||
let style = CharStyle { tracking: own.get(k).map_or(0.0, |e| em(*e)), ..r.style.clone() };
|
||||
let tracking = own.get(k).map_or(0.0, |e| (e / size * 1000.0).clamp(-1000.0, 10000.0));
|
||||
k += 1;
|
||||
// Hundredths of a thousandth of an em: no drift along a line, no noise in the panels.
|
||||
let tracking = (tracking * 100.0).round() / 100.0;
|
||||
match out.last_mut() {
|
||||
Some(last) if last.style == style && last.inline == r.inline => last.text.push(c),
|
||||
_ => out.push(TextRun { text: c.to_string(), style, inline: r.inline.clone() }),
|
||||
Some(last) if from == Some(i) && last.style.tracking == tracking => last.text.push(c),
|
||||
last => {
|
||||
let style = CharStyle { tracking, kerning: kern, ..r.style.clone() };
|
||||
match last {
|
||||
Some(last) if last.style == style && last.inline == r.inline => last.text.push(c),
|
||||
_ => out.push(TextRun { text: c.to_string(), style, inline: r.inline.clone() }),
|
||||
}
|
||||
}
|
||||
}
|
||||
from = Some(i);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The runs of `t` that put its glyphs where the file did (#722), and their layout: with the
|
||||
/// font's kerning or none, whichever the file's spacing follows, and tracking that is the same
|
||||
/// after every character when the file spaced them evenly, else each character's own (word
|
||||
/// spacing, `TJ` adjustments, character tightening, spaces read from gaps).
|
||||
///
|
||||
/// The file put the glyph of each character with a [`Slot`] at `baseline` (one origin per glyph),
|
||||
/// measured along `path` (type on a path: one curve per glyph) or along `line`'s baseline from its
|
||||
/// origin, where a character shifted off it by its baseline shift draws that shift times `line`'s
|
||||
/// slant further along (the type's skew leans it so, as the file's text rise did). `None` when the
|
||||
/// font laid out isn't the file's (its advances differ from the file's): spacing measured against
|
||||
/// a stand-in's widths would keep the stand-in's differences once the font is installed; or when
|
||||
/// the glyphs can't be placed so (the layout joins characters the file drew apart).
|
||||
fn place_each(
|
||||
t: &TextObject,
|
||||
slots: &[Option<Slot>],
|
||||
baseline: &[Point],
|
||||
path: Option<&BezPath>,
|
||||
line: Placement,
|
||||
size: f64,
|
||||
) -> Option<(Vec<TextRun>, TextLayout)> {
|
||||
let chars: Vec<usize> = t
|
||||
.runs
|
||||
.iter()
|
||||
.scan(0, |off, r| {
|
||||
let base = *off;
|
||||
*off += r.text.len();
|
||||
Some(r.text.char_indices().map(move |(i, _)| base + i).collect::<Vec<_>>())
|
||||
})
|
||||
.flatten()
|
||||
.collect();
|
||||
if chars.len() < 2 || chars.len() != slots.len() || t.runs.iter().any(|r| r.inline.is_some()) {
|
||||
return None;
|
||||
}
|
||||
// How far along the line the file put each glyph.
|
||||
let along: Vec<f64> = match path {
|
||||
Some(bp) => std::iter::once(0.0)
|
||||
.chain(bp.segments().scan(0.0, |d, seg| {
|
||||
*d += kurbo::ParamCurveArclen::arclen(&seg, 1e-3);
|
||||
Some(*d)
|
||||
}))
|
||||
.take(baseline.len())
|
||||
.collect(),
|
||||
None => baseline.iter().map(|p| (*p - line.origin).dot(line.dir)).collect(),
|
||||
};
|
||||
// Each character's baseline shift, which the type's slant draws `slant` times as far along.
|
||||
let shifts: Vec<f64> = t.runs.iter().flat_map(|r| r.text.chars().map(move |_| r.style.baseline_shift)).collect();
|
||||
let slant = if path.is_some() { 0.0 } else { line.slant };
|
||||
// Each character's target: where the file put it, if it put it anywhere.
|
||||
let target: Vec<Option<(f64, Option<f64>)>> =
|
||||
slots.iter().zip(&shifts).map(|(s, shift)| s.and_then(|s| Some((*along.get(s.glyph)? - slant * shift, s.advance)))).collect();
|
||||
if target.first().is_none_or(Option::is_none) || target.iter().flatten().any(|(d, _)| !d.is_finite()) {
|
||||
return None;
|
||||
}
|
||||
let db = vectorcraft_text::FontDb::global();
|
||||
// The spacing each character takes after it, laid out with `pens`: whatever puts the next one
|
||||
// the file placed where it did. Characters between two the file placed (a space read from a
|
||||
// gap, the rest of a ligature) take the line's spacing, the last of them the rest.
|
||||
let spacing = |pens: &[Option<(f64, f64)>]| -> Option<Vec<f64>> {
|
||||
// How far each character the file placed is from where the layout puts it.
|
||||
let placed: Vec<(usize, f64)> =
|
||||
target.iter().zip(pens).enumerate().filter_map(|(i, (t, p))| Some((i, t.as_ref()?.0 - p.as_ref()?.0))).collect();
|
||||
let steps: Vec<f64> = placed.windows(2).filter(|w| w[1].0 == w[0].0 + 1).map(|w| w[1].1 - w[0].1).collect();
|
||||
let line = median(steps).unwrap_or(0.0);
|
||||
let mut own = vec![line; chars.len()];
|
||||
for w in placed.windows(2) {
|
||||
let ((a, da), (b, db)) = (w[0], w[1]);
|
||||
*own.get_mut(b.checked_sub(1)?)? = db - da - line * (b - a - 1) as f64;
|
||||
}
|
||||
// After the last character the file placed, spacing changes nothing: the line's.
|
||||
let last = placed.last()?.0;
|
||||
let tail = if last > 0 { own.get(last - 1).copied().unwrap_or(line) } else { line };
|
||||
for e in own.get_mut(last..).into_iter().flatten() {
|
||||
*e = tail;
|
||||
}
|
||||
Some(own)
|
||||
};
|
||||
// Evenly spaced: one tracking value for the line. (A file rounds its widths to thousandths of
|
||||
// an em: a hair either way is even.)
|
||||
let even = |own: &[f64]| {
|
||||
let line = median(own.to_vec())?;
|
||||
own.iter().all(|e| (e - line).abs() <= size * 0.002).then(|| vec![line; own.len()])
|
||||
};
|
||||
let changes = |own: &[f64]| own.windows(2).filter(|w| (w[1] - w[0]).abs() > size * 1e-4).count();
|
||||
// The type as it is: untracked, with the font's kerning.
|
||||
let auto = vectorcraft_text::layout(db, t);
|
||||
// Each glyph's own advance (the font's, unkerned) tells whether the layout's font is the
|
||||
// file's, whether the font kerned any of the line's pairs, and where the glyphs go unkerned
|
||||
// (the same glyphs, each on its own advance: no layout needed to tell).
|
||||
let mut faces: Vec<std::sync::Arc<vectorcraft_text::FontFace>> = vec![];
|
||||
let mut unkerned_pens = vec![None; chars.len()];
|
||||
let mut pen = 0.0;
|
||||
let mut kerned_any = false;
|
||||
for g in &auto.glyphs {
|
||||
let face = match faces.iter().find(|f| f.id() == g.font_id) {
|
||||
Some(f) => f.clone(),
|
||||
None => {
|
||||
let f = db.face_by_id(g.font_id)?;
|
||||
faces.push(f.clone());
|
||||
f
|
||||
}
|
||||
};
|
||||
let style = &t.runs.get(g.run)?.style;
|
||||
let own = face.advance(g.gid) * style.size / face.units_per_em().max(1e-9) * style.h_scale / 100.0;
|
||||
kerned_any |= (own - g.advance).abs() > size * 1e-6;
|
||||
if let Some(slot) = chars.binary_search(&g.byte).ok().and_then(|i| unkerned_pens.get_mut(i)) {
|
||||
slot.get_or_insert((pen, own));
|
||||
}
|
||||
pen += own;
|
||||
}
|
||||
let same_font = unkerned_pens.iter().zip(&target).all(|(n, t)| match t {
|
||||
Some((_, Some(adv))) => n.is_some_and(|(_, a): (f64, f64)| (a - adv).abs() <= size * 0.01),
|
||||
_ => true,
|
||||
});
|
||||
if !same_font {
|
||||
return None;
|
||||
}
|
||||
// The font's kerning when the file followed it (or there is none to follow), else none.
|
||||
let kerned = spacing(&pens(&auto, &chars))?;
|
||||
let (kern, own) = match even(&kerned) {
|
||||
Some(own) => (None, own),
|
||||
// Without kerning the line lays out the same.
|
||||
None if !kerned_any => (None, kerned),
|
||||
None => {
|
||||
let unkerned = spacing(&unkerned_pens)?;
|
||||
match even(&unkerned) {
|
||||
Some(own) => (Some(0.0), own),
|
||||
None if changes(&unkerned) < changes(&kerned) => (Some(0.0), unkerned),
|
||||
None => (None, kerned),
|
||||
}
|
||||
}
|
||||
};
|
||||
let runs = restyled(t, kern, &own);
|
||||
// As the type is: laid out so already.
|
||||
if kern.is_none() && runs.iter().all(|r| r.style.tracking == 0.0) {
|
||||
return Some((runs, auto));
|
||||
}
|
||||
// Laid out so, are they where the file put them? (A ligature the layout forms where the file
|
||||
// drew two glyphs moves those after it.)
|
||||
let mut probe = t.clone();
|
||||
probe.runs = runs;
|
||||
let check = vectorcraft_text::layout(db, &probe);
|
||||
let got = pens(&check, &chars);
|
||||
let ok = got.iter().zip(&target).all(|(g, t)| match t {
|
||||
Some((d, _)) => g.is_some_and(|(p, _)| (p - d).abs() <= size * 0.02),
|
||||
None => true,
|
||||
});
|
||||
ok.then_some((probe.runs, check))
|
||||
}
|
||||
|
||||
/// The middle value of `v` (the upper one of an even count).
|
||||
pub(crate) fn median(mut v: Vec<f64>) -> Option<f64> {
|
||||
v.sort_by(f64::total_cmp);
|
||||
v.get(v.len() / 2).copied()
|
||||
}
|
||||
|
||||
/// The tracking (thousandths of an em) that sets a line of `chars` characters, laid out untracked
|
||||
/// as `laid`, `extra` points longer, as the file set it: the same after every character, except
|
||||
/// the spaces read from gaps or drawn between glyphs (`gaps`: byte offset, gap in points) where
|
||||
|
||||
@@ -307,6 +307,8 @@ mod tests_stroke;
|
||||
#[cfg(test)]
|
||||
mod tests_strokeout;
|
||||
#[cfg(test)]
|
||||
mod tests_text_placement;
|
||||
#[cfg(test)]
|
||||
mod tests_textstroke;
|
||||
#[cfg(test)]
|
||||
mod tests_webview;
|
||||
|
||||
@@ -384,7 +384,8 @@ fn fonts_are_noted_past_font_resources_the_reader_cannot_parse() {
|
||||
let mut fonts = crate::import_scan::FontNames::new();
|
||||
let mut ocgs = crate::import_scan::Ocgs::read(&pdf);
|
||||
crate::import_scan::scan_page(&pdf.pages()[0], &mut ocgs, false, &mut fonts, pdf.decode_limits().max_decoded_stream()).unwrap();
|
||||
assert_eq!(fonts.into_values().collect::<Vec<_>>(), [("Helvetica".to_string(), false)], "{junk}");
|
||||
let noted: Vec<_> = fonts.into_values().map(|f| (f.name, f.embedded)).collect();
|
||||
assert_eq!(noted, [("Helvetica".to_string(), false)], "{junk}");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,599 @@
|
||||
//! #722: type from a PDF lands where the file draws it. Each file here is written from scratch
|
||||
//! from the PDF specification (ISO 32000-1 §9, "Text": the text state, text-positioning and
|
||||
//! text-showing operators, Type 0, Type 3 and TrueType fonts, vertical writing), with Source Sans 3
|
||||
//! from this repo's assets embedded as its font program. What the file draws (its glyphs opened as
|
||||
//! outlines) and what the type it opens as draws must match contour by contour.
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
use kurbo::{BezPath, PathEl, Point, Rect, Shape};
|
||||
use vectorcraft_doc::{Document, NodeKind, TextKind, TextObject};
|
||||
use vectorcraft_testkit::pdf::{PdfPage, first_extra, pdf_with};
|
||||
use vectorcraft_text::{FontDb, FontFace};
|
||||
|
||||
use crate::tests_import_fidelity::stream;
|
||||
use crate::*;
|
||||
|
||||
const SOURCE_SANS: &[u8] = include_bytes!("../../../assets/fonts/SourceSans3-Regular.ttf");
|
||||
|
||||
fn sans() -> Arc<FontFace> {
|
||||
FontDb::global().find_postscript("SourceSans3-Regular").expect("Source Sans 3 is built in")
|
||||
}
|
||||
|
||||
/// Source Sans 3's advance of `c`, in thousandths of an em (as a PDF's widths give it).
|
||||
fn width(c: char) -> f64 {
|
||||
let face = sans();
|
||||
(face.advance(face.glyph_for(c)) * 1000.0 / face.units_per_em()).round()
|
||||
}
|
||||
|
||||
/// The font program of Source Sans 3 Regular as a stream (ASCII hex).
|
||||
fn font_file() -> String {
|
||||
let hex: String = SOURCE_SANS.iter().map(|b| format!("{b:02X}")).collect::<String>() + ">";
|
||||
stream(&format!("/Length1 {} /Filter /ASCIIHexDecode", SOURCE_SANS.len()), &hex)
|
||||
}
|
||||
|
||||
/// A font descriptor for the font program in object `file`.
|
||||
fn descriptor(file: usize) -> String {
|
||||
format!(
|
||||
"<< /Type /FontDescriptor /FontName /SourceSans3-Regular /Flags 32 /FontBBox [-500 -300 1500 1000] /ItalicAngle 0 /Ascent 1024 /Descent -400 /CapHeight 660 /StemV 80 /FontFile2 {file} 0 R >>"
|
||||
)
|
||||
}
|
||||
|
||||
/// A simple TrueType font (WinAnsi, Source Sans 3's widths) described by object `desc`.
|
||||
fn simple(desc: usize) -> String {
|
||||
let widths: Vec<String> = (32u8..=126).map(|c| width(c as char).to_string()).collect();
|
||||
format!(
|
||||
"<< /Type /Font /Subtype /TrueType /BaseFont /SourceSans3-Regular /FirstChar 32 /LastChar 126 /Widths [{}] /FontDescriptor {desc} 0 R /Encoding /WinAnsiEncoding >>",
|
||||
widths.join(" ")
|
||||
)
|
||||
}
|
||||
|
||||
/// The characters the Type 0 fonts map: printable ASCII, and symbols that stand upright in
|
||||
/// vertical type and are narrower than an em.
|
||||
fn cid_chars() -> impl Iterator<Item = char> {
|
||||
(32u8..=126).map(char::from).chain("§±×".chars())
|
||||
}
|
||||
|
||||
/// `text` as a string of Source Sans 3's glyph ids, two bytes each (Identity-H or Identity-V,
|
||||
/// CIDToGIDMap Identity).
|
||||
fn gids(text: &str) -> String {
|
||||
let face = sans();
|
||||
let hex: String = text.chars().map(|c| format!("{:04X}", face.glyph_for(c))).collect();
|
||||
format!("<{hex}>")
|
||||
}
|
||||
|
||||
/// A ToUnicode map of Source Sans 3's glyph ids for [`cid_chars`].
|
||||
fn to_unicode() -> String {
|
||||
let face = sans();
|
||||
let rows: Vec<String> = cid_chars().map(|c| format!("<{:04X}> <{:04X}>", face.glyph_for(c), c as u32)).collect();
|
||||
let data = format!(
|
||||
"/CIDInit /ProcSet findresource begin 12 dict begin begincmap /CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def /CMapName /Test-UCS def /CMapType 2 def 1 begincodespacerange <0000> <FFFF> endcodespacerange {} beginbfchar\n{}\nendbfchar endcmap CMapName currentdict /CMap defineresource pop end end",
|
||||
rows.len(),
|
||||
rows.join("\n")
|
||||
);
|
||||
stream("", &data)
|
||||
}
|
||||
|
||||
/// A CID-keyed TrueType font (the descendant of the Type 0 fonts) of Source Sans 3 with its
|
||||
/// widths (/W), described by object `desc`.
|
||||
fn cid_font(desc: usize) -> String {
|
||||
let face = sans();
|
||||
let w: Vec<String> = cid_chars().map(|c| format!("{} [{}]", face.glyph_for(c), width(c))).collect();
|
||||
format!(
|
||||
"<< /Type /Font /Subtype /CIDFontType2 /BaseFont /SourceSans3-Regular /CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >> /FontDescriptor {desc} 0 R /CIDToGIDMap /Identity /DW 1000 /W [{}] >>",
|
||||
w.join(" ")
|
||||
)
|
||||
}
|
||||
|
||||
/// [`cid_font`] with vertical metrics (/W2: each glyph's position vector half its width across,
|
||||
/// 880 up) and no /W (every width the default, an em).
|
||||
fn cid_font_w2(desc: usize) -> String {
|
||||
let face = sans();
|
||||
let w2: Vec<String> = cid_chars().map(|c| format!("{} [-1000 {} 880]", face.glyph_for(c), width(c) / 2.0)).collect();
|
||||
format!(
|
||||
"<< /Type /Font /Subtype /CIDFontType2 /BaseFont /SourceSans3-Regular /CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >> /FontDescriptor {desc} 0 R /CIDToGIDMap /Identity /DW 1000 /DW2 [880 -1000] /W2 [{}] >>",
|
||||
w2.join(" ")
|
||||
)
|
||||
}
|
||||
|
||||
/// A Type 3 font (object `first`, its glyph procedures the two after it) whose glyph space is
|
||||
/// 1/`upm` of text space (FontMatrix [1/upm 0 0 1/upm 0 0]): `a` is half an em wide and draws a box
|
||||
/// 0.4 em wide, `b` an em wide with a box of 0.9 em; both boxes are 0.7 em tall on the baseline.
|
||||
fn type3(first: usize, upm: f64) -> Vec<String> {
|
||||
let s = 1.0 / upm;
|
||||
let (h, w) = (upm * 0.5, upm);
|
||||
let a = stream("", &format!("{h} 0 d0 0 0 {} {} re f", h * 0.8, upm * 0.7));
|
||||
let b = stream("", &format!("{w} 0 d0 0 0 {} {} re f", w * 0.9, upm * 0.7));
|
||||
let font = format!(
|
||||
"<< /Type /Font /Subtype /Type3 /FontBBox [0 0 {w} {w}] /FontMatrix [{s} 0 0 {s} 0 0] /CharProcs << /a {} 0 R /b {} 0 R >> /Encoding << /Type /Encoding /Differences [97 /a /b] >> /FirstChar 97 /LastChar 98 /Widths [{h} {w}] /Resources << >> >>",
|
||||
first + 1,
|
||||
first + 2
|
||||
);
|
||||
vec![font, a, b]
|
||||
}
|
||||
|
||||
/// A 300 × 200 pt page drawing `content`, plus `entries` in the page dictionary, with fonts:
|
||||
/// - `/F1`: Source Sans 3, embedded, a simple TrueType font;
|
||||
/// - `/F4`: Source Sans 3 as a Type 0 font, Identity-H (two-byte glyph ids, see [`gids`]);
|
||||
/// - `/F5`: the same, Identity-V (vertical writing);
|
||||
/// - `/F6`: the same with vertical metrics (/W2) and no widths (/W), Identity-V;
|
||||
/// - `/T3`, `/T30`: Type 3 fonts of 1000 and of 100 units an em;
|
||||
/// - `/HV`: Helvetica, not embedded.
|
||||
fn page(content: &str, entries: &str) -> Vec<u8> {
|
||||
sized_page(300.0, 200.0, content, entries)
|
||||
}
|
||||
|
||||
/// [`page`], `w` × `h` pt.
|
||||
fn sized_page(w: f64, h: f64, content: &str, entries: &str) -> Vec<u8> {
|
||||
let n = first_extra(1);
|
||||
let type0 = |enc: &str, cid: usize| {
|
||||
format!(
|
||||
"<< /Type /Font /Subtype /Type0 /BaseFont /SourceSans3-Regular /Encoding /{enc} /DescendantFonts [{cid} 0 R] /ToUnicode {} 0 R >>",
|
||||
n + 4
|
||||
)
|
||||
};
|
||||
let mut objs = vec![
|
||||
font_file(), // n
|
||||
descriptor(n), // n + 1
|
||||
simple(n + 1), // n + 2: F1
|
||||
cid_font(n + 1), // n + 3
|
||||
to_unicode(), // n + 4
|
||||
type0("Identity-H", n + 3), // n + 5: F4
|
||||
type0("Identity-V", n + 3), // n + 6: F5
|
||||
cid_font_w2(n + 1), // n + 7
|
||||
type0("Identity-V", n + 7), // n + 8: F6
|
||||
];
|
||||
let t3 = n + objs.len();
|
||||
objs.extend(type3(t3, 1000.0));
|
||||
objs.extend(type3(t3 + 3, 100.0));
|
||||
let refs: Vec<&str> = objs.iter().map(String::as_str).collect();
|
||||
let resources = format!(
|
||||
"/Font << /F1 {} 0 R /F4 {} 0 R /F5 {} 0 R /F6 {} 0 R /T3 {t3} 0 R /T30 {} 0 R /HV << /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >> >>",
|
||||
n + 2,
|
||||
n + 5,
|
||||
n + 6,
|
||||
n + 8,
|
||||
t3 + 3
|
||||
);
|
||||
pdf_with(&[PdfPage { resources, entries: entries.into(), ..PdfPage::new(w, h, content) }], &refs, None)
|
||||
}
|
||||
|
||||
fn open_as(bytes: &[u8], text_as: TextAs) -> Document {
|
||||
import_with_report(bytes, &ImportOptions { text_as, ..Default::default() }).unwrap().document
|
||||
}
|
||||
|
||||
fn texts(d: &Document) -> Vec<TextObject> {
|
||||
let mut v = vec![];
|
||||
d.walk(|n| {
|
||||
if let NodeKind::Text(t) = &n.kind {
|
||||
v.push((**t).clone());
|
||||
}
|
||||
});
|
||||
v
|
||||
}
|
||||
|
||||
fn plain(d: &Document) -> Vec<String> {
|
||||
texts(d).iter().map(TextObject::plain_text).collect()
|
||||
}
|
||||
|
||||
/// The largest difference between two boxes' edges.
|
||||
fn off(a: Rect, b: Rect) -> f64 {
|
||||
[a.x0 - b.x0, a.y0 - b.y0, a.x1 - b.x1, a.y1 - b.y1].iter().fold(0.0f64, |m, v| m.max(v.abs()))
|
||||
}
|
||||
|
||||
/// The bounds of each contour of `bp` (each subpath).
|
||||
fn contours_of(bp: &BezPath, out: &mut Vec<Rect>) {
|
||||
let mut cur = BezPath::new();
|
||||
for el in bp.elements() {
|
||||
if matches!(el, PathEl::MoveTo(_)) && cur.elements().len() > 1 {
|
||||
out.push(std::mem::take(&mut cur).bounding_box());
|
||||
}
|
||||
if matches!(el, PathEl::MoveTo(_)) {
|
||||
cur = BezPath::new();
|
||||
}
|
||||
cur.push(*el);
|
||||
}
|
||||
if cur.elements().len() > 1 {
|
||||
out.push(cur.bounding_box());
|
||||
}
|
||||
}
|
||||
|
||||
/// The contours `d` draws: its paths' and its type's glyphs', in document space.
|
||||
fn contours(d: &Document) -> Vec<Rect> {
|
||||
let mut out = vec![];
|
||||
d.walk(|n| match &n.kind {
|
||||
NodeKind::Path { path, .. } => contours_of(&path.to_bezpath(), &mut out),
|
||||
NodeKind::Text(t) => {
|
||||
for g in vectorcraft_text::layout(FontDb::global(), t).glyphs {
|
||||
contours_of(&(t.xf * g.outline), &mut out);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
});
|
||||
out
|
||||
}
|
||||
|
||||
/// How far (points) the glyphs of the type `bytes` opens as are from where the file draws them:
|
||||
/// the furthest any contour the file draws is from the nearest one the type draws, or the other
|
||||
/// way round.
|
||||
fn displacement(bytes: &[u8]) -> f64 {
|
||||
let drawn = contours(&open_as(bytes, TextAs::Outlines));
|
||||
let typed = contours(&open_as(bytes, TextAs::Text));
|
||||
assert!(!drawn.is_empty() && !typed.is_empty(), "the file draws glyphs");
|
||||
let worst = |a: &[Rect], b: &[Rect]| a.iter().map(|r| b.iter().map(|s| off(*r, *s)).fold(f64::INFINITY, f64::min)).fold(0.0, f64::max);
|
||||
worst(&drawn, &typed).max(worst(&typed, &drawn))
|
||||
}
|
||||
|
||||
/// The type `content` opens as lands where the file draws it, as `want` (its objects' text).
|
||||
#[track_caller]
|
||||
fn lands(content: &str, entries: &str, want: &[&str]) {
|
||||
let bytes = page(content, entries);
|
||||
assert_eq!(plain(&open_as(&bytes, TextAs::Text)), want, "{content}");
|
||||
let d = displacement(&bytes);
|
||||
assert!(d < 0.02, "{content}: glyphs {d:.3} pt from where the file draws them");
|
||||
}
|
||||
|
||||
/// Three lines wrapped in a frame (each wrapped line ends in a space).
|
||||
const PARAGRAPH: &str = "(The quick brown fox ) Tj T* (jumps over the lazy ) Tj T* (dog and runs away.) Tj";
|
||||
const PARAGRAPH_TEXT: &str = "The quick brown fox jumps over the lazy dog and runs away.";
|
||||
|
||||
/// The text-positioning operators and the text matrix under any CTM: lines start where the file
|
||||
/// starts them, the glyphs of each where it draws them.
|
||||
#[test]
|
||||
fn text_positioning_and_the_ctm_put_type_where_the_file_draws_it() {
|
||||
let lines = ["Line one", "Line two", "Line three"];
|
||||
for (content, entries, want) in [
|
||||
("BT /F1 24 Tf 20 50 Td (Hello World) Tj ET", "", &["Hello World"][..]),
|
||||
("BT /F1 1 Tf 24 0 0 24 20 50 Tm (Hello World) Tj ET", "", &["Hello World"]),
|
||||
("q 2 0 0 2 10 10 cm BT /F1 12 Tf 10 20 Td (Hello World) Tj ET Q", "", &["Hello World"]),
|
||||
// A y-down CTM with a text matrix that turns the type upright again.
|
||||
("q 1 0 0 -1 0 200 cm BT /F1 12 Tf 1 0 0 -1 20 50 Tm (Hello World) Tj ET Q", "", &["Hello World"]),
|
||||
("BT /F1 12 Tf 14 TL 20 150 Td (Line one) Tj T* (Line two) Tj T* (Line three) Tj ET", "", &lines),
|
||||
("BT /F1 12 Tf 20 150 Td (Line one) Tj 0 -16 TD (Line two) Tj T* (Line three) Tj ET", "", &lines),
|
||||
// ' moves to the next line; " also sets word and character spacing.
|
||||
("BT /F1 12 Tf 14 TL 20 150 Td (Line one) Tj (Line two) ' 2 1 (Line three) \" ET", "", &lines),
|
||||
("BT /F1 18 Tf 0.866 0.5 -0.5 0.866 40 40 Tm (Turned line) Tj ET", "", &["Turned line"]),
|
||||
("BT /F1 1 Tf 30 0 0 15 20 50 Tm (Squashed) Tj ET", "", &["Squashed"]),
|
||||
("q 1 0 0 0.5 0 0 cm BT /F1 20 Tf 20 100 Td (Squashed) Tj ET Q", "", &["Squashed"]),
|
||||
("BT /F1 24 Tf 60 80 Td (Cropped) Tj ET", "/CropBox [40 30 260 180]", &["Cropped"]),
|
||||
("BT /F1 24 Tf 20 50 Td (Turned page) Tj ET", "/Rotate 90", &["Turned page"]),
|
||||
] {
|
||||
lands(content, entries, want);
|
||||
}
|
||||
}
|
||||
|
||||
/// Horizontal scaling, character and word spacing, and `TJ`'s adjustments: each glyph keeps the
|
||||
/// place the file gave it (they used to be evened out over the line, and laid out with the font's
|
||||
/// kerning where the file had none, so the glyphs between the ends slid).
|
||||
#[test]
|
||||
fn spacing_and_scaling_keep_each_glyph_where_the_file_put_it() {
|
||||
for (content, want) in [
|
||||
("BT /F1 20 Tf 50 Tz 20 50 Td (Narrow type) Tj ET", "Narrow type"),
|
||||
("BT /F1 20 Tf 150 Tz 20 50 Td (Wide type) Tj ET", "Wide type"),
|
||||
("BT /F1 16 Tf 2 Tc 20 50 Td (Spaced out) Tj ET", "Spaced out"),
|
||||
("BT /F1 16 Tf -0.8 Tc 20 50 Td (Tight type here) Tj ET", "Tight type here"),
|
||||
("BT /F1 16 Tf 6 Tw 20 50 Td (Word space here) Tj ET", "Word space here"),
|
||||
("BT /F1 16 Tf 1.5 Tc 80 Tz 20 50 Td (Spaced and narrow) Tj ET", "Spaced and narrow"),
|
||||
("BT /F1 16 Tf 20 50 Td [(A) 120 (V) -80 (A) 300 (Tower)] TJ ET", "AVATower"),
|
||||
("BT /F1 16 Tf 20 50 Td (AVATAR WAVE) Tj ET", "AVATAR WAVE"),
|
||||
] {
|
||||
lands(content, "", &[want]);
|
||||
}
|
||||
// Two-byte codes of a Type 0 font alike (word spacing applies only to single-byte code 32,
|
||||
// ISO 32000-1 §9.3.3: none here).
|
||||
for content in ["BT /F4 24 Tf 70 Tz 3 Ts 20 50 Td <> Tj ET", "BT /F4 24 Tf 9 Tw 2 Tc 20 50 Td <> Tj ET"] {
|
||||
lands(&content.replace("<>", &gids("Hello World")), "", &["Hello World"]);
|
||||
}
|
||||
}
|
||||
|
||||
/// Word spacing stays on the spaces, as tracking of their own; evenly spaced letters keep one
|
||||
/// tracking value for the line, and a file that didn't kern opens with kerning off.
|
||||
#[test]
|
||||
fn word_spacing_is_tracking_on_the_spaces_and_unkerned_type_opens_unkerned() {
|
||||
let d = open_as(&page("BT /F1 16 Tf 6 Tw 20 50 Td (Word space here) Tj ET", ""), TextAs::Text);
|
||||
let t = texts(&d);
|
||||
let letters: Vec<f64> = t[0].runs.iter().filter(|r| r.text != " ").map(|r| r.style.tracking).collect();
|
||||
let spaces: Vec<f64> = t[0].runs.iter().filter(|r| r.text == " ").map(|r| r.style.tracking).collect();
|
||||
assert_eq!(spaces.len(), 2, "{:?}", t[0].runs);
|
||||
for s in &spaces {
|
||||
assert!((s - 375.0).abs() < 0.5, "6 pt at 16 pt is 375/1000 em: {spaces:?}");
|
||||
}
|
||||
assert!(letters.iter().all(|l| l.abs() < 0.5), "the letters as the font spaces them: {letters:?}");
|
||||
// "AV", "VA", "WA" kern in Source Sans 3; this file set them on their widths alone.
|
||||
let d = open_as(&page("BT /F1 16 Tf 20 50 Td (AVATAR WAVE) Tj ET", ""), TextAs::Text);
|
||||
let t = texts(&d);
|
||||
assert_eq!(t[0].runs.len(), 1, "{:?}", t[0].runs);
|
||||
assert_eq!(t[0].runs[0].style.kerning, Some(0.0), "kerning off, as the file set it");
|
||||
assert!(t[0].runs[0].style.tracking.abs() < 0.5);
|
||||
}
|
||||
|
||||
/// Type the font's kerning spaced (as editors write it) keeps the font's kerning.
|
||||
#[test]
|
||||
fn kerned_type_keeps_the_fonts_kerning() {
|
||||
let bytes = crate::tests_live_text::text_pdf(&[(20.0, 50.0, 24.0, "AVATAR WAVE")], false);
|
||||
let d = open_as(&bytes, TextAs::Text);
|
||||
let t = texts(&d);
|
||||
assert_eq!(t.len(), 1);
|
||||
assert!(t[0].runs.iter().all(|r| r.style.kerning.is_none()), "{:?}", t[0].runs);
|
||||
assert!(displacement(&bytes) < 0.02);
|
||||
}
|
||||
|
||||
/// Text rise (`Ts`): a superscript or subscript stays in its line as baseline shift (it used to be
|
||||
/// pulled onto the baseline within 0.15 em of it, or split off as an object of its own), and a line
|
||||
/// that starts raised keeps the baseline of the rest of its text.
|
||||
#[test]
|
||||
fn raised_and_lowered_characters_stay_in_their_line_shifted_off_its_baseline() {
|
||||
for (content, want) in [
|
||||
("BT /F1 12 Tf 20 50 Td 5 Ts (Raised line) Tj ET", "Raised line"),
|
||||
("BT /F1 12 Tf 20 50 Td (E = mc) Tj 5 Ts (2) Tj 0 Ts ( here) Tj ET", "E = mc2 here"),
|
||||
("BT /F1 12 Tf 20 50 Td (H) Tj -3 Ts (2) Tj 0 Ts (O water) Tj ET", "H2O water"),
|
||||
("BT /F1 12 Tf 20 50 Td (H) Tj 1.5 Ts (2) Tj 0 Ts (O water) Tj ET", "H2O water"),
|
||||
("BT /F1 12 Tf 20 50 Td (CO) Tj -1.2 Ts /F1 8 Tf (2) Tj 0 Ts /F1 12 Tf ( gas) Tj ET", "CO2 gas"),
|
||||
("BT /F1 12 Tf 20 50 Td 1.5 Ts (1) Tj 0 Ts (Footnote text) Tj ET", "1Footnote text"),
|
||||
] {
|
||||
lands(content, "", &[want]);
|
||||
}
|
||||
// Under a sheared text matrix (slanted type) text rise moves a glyph along the slant, as the
|
||||
// type's slant draws its baseline shift: the shifted glyphs land where the file draws them.
|
||||
for (content, want) in [
|
||||
("BT /F1 12 Tf 1 0 0.2 1 20 50 Tm (E = mc) Tj 5 Ts (2) Tj ET", "E = mc2"),
|
||||
("BT /F1 12 Tf 1 0 0.2 1 20 50 Tm (E = mc) Tj 5 Ts (2) Tj 0 Ts ( here) Tj ET", "E = mc2 here"),
|
||||
("BT /F1 12 Tf 1 0 -0.3 1 20 50 Tm (H) Tj -3 Ts (2) Tj 0 Ts (O water) Tj ET", "H2O water"),
|
||||
("BT /F1 12 Tf 1 0 0.2 1 20 50 Tm 1.5 Ts (1) Tj 0 Ts (Footnote text) Tj ET", "1Footnote text"),
|
||||
("BT /F1 12 Tf 1 0 0.2 1 20 50 Tm 4 Ts (Raised) Tj ET", "Raised"),
|
||||
] {
|
||||
lands(content, "", &[want]);
|
||||
}
|
||||
let t = texts(&open_as(&page("BT /F1 12 Tf 20 50 Td 1.5 Ts (1) Tj 0 Ts (Footnote text) Tj ET", ""), TextAs::Text));
|
||||
let origin = t[0].xf * Point::ZERO;
|
||||
assert!((origin.y - 150.0).abs() < 1e-6, "on the text's baseline, not the mark's: {origin:?}");
|
||||
assert_eq!(t[0].runs[0].text, "1");
|
||||
assert!((t[0].runs[0].style.baseline_shift - 1.5).abs() < 1e-6, "{:?}", t[0].runs[0].style.baseline_shift);
|
||||
assert!(t[0].runs[1..].iter().all(|r| r.style.baseline_shift == 0.0));
|
||||
}
|
||||
|
||||
/// Lines wrapped in a frame (area type, as an editor writes it: each line placed with `T*` or `Td`)
|
||||
/// come back as one area type object whose glyphs are where the lines' were: aligned left, or
|
||||
/// justified with word spacing (`Tw`) on each wrapped line.
|
||||
#[test]
|
||||
fn text_boxes_open_where_their_lines_were() {
|
||||
for content in [
|
||||
format!("BT /F1 12 Tf 14 TL 20 150 Td {PARAGRAPH} ET"),
|
||||
format!("BT /F1 12 Tf 14 TL 4 Ts 80 Tz 20 150 Td {PARAGRAPH} ET"),
|
||||
format!("q 1.5 0 0 1.5 5 5 cm BT /F1 8 Tf 10 TL 10 90 Td {PARAGRAPH} ET Q"),
|
||||
format!("BT /F1 12 Tf 14 TL 0.866 0.5 -0.5 0.866 40 40 Tm {PARAGRAPH} ET"),
|
||||
] {
|
||||
let t = texts(&open_as(&page(&content, ""), TextAs::Text));
|
||||
assert_eq!(t.len(), 1, "{content}: one text box");
|
||||
assert!(matches!(t[0].kind, TextKind::Area { .. }), "{content}");
|
||||
lands(&content, "", &[PARAGRAPH_TEXT]);
|
||||
}
|
||||
// Justified: every wrapped line spaced out to the frame's width with word spacing.
|
||||
let lines = ["The quick brown fox ", "jumps over the lazy ", "dog and runs away."];
|
||||
let (size, frame) = (12.0, 110.0);
|
||||
let mut content = format!("BT /F1 {size} Tf 20 170 Td ");
|
||||
for (i, l) in lines.iter().enumerate() {
|
||||
let natural = l.trim_end().chars().map(width).sum::<f64>() * size / 1000.0;
|
||||
let spaces = l.trim_end().matches(' ').count() as f64;
|
||||
let tw = if i + 1 < lines.len() { (frame - natural) / spaces } else { 0.0 };
|
||||
if i > 0 {
|
||||
content += "0 -14.4 Td ";
|
||||
}
|
||||
content += &format!("{tw:.4} Tw ({l}) Tj ");
|
||||
}
|
||||
content += "ET";
|
||||
let t = texts(&open_as(&page(&content, ""), TextAs::Text));
|
||||
assert_eq!(t.len(), 1, "one text box: {:?}", t.iter().map(TextObject::plain_text).collect::<Vec<_>>());
|
||||
assert_eq!(t[0].para.justify, vectorcraft_doc::Justify::JustifyLeft);
|
||||
lands(&content, "", &[PARAGRAPH_TEXT]);
|
||||
}
|
||||
|
||||
/// Vertical writing (Identity-V): the file puts each glyph's origin half its width (/W) left of
|
||||
/// the column (ISO 32000-1 §9.7.4.3); glyphs narrower than an em stay centred on it.
|
||||
#[test]
|
||||
fn vertical_glyphs_narrower_than_an_em_stay_on_their_column() {
|
||||
lands(&format!("BT /F5 24 Tf 150 180 Td {} Tj ET", gids("§±×")), "", &["§±×"]);
|
||||
}
|
||||
|
||||
/// Type 3 glyphs (drawn by their procedures, kept as outlines) are scaled by the font's matrix:
|
||||
/// the same boxes at 1000 and at 100 units an em.
|
||||
#[test]
|
||||
fn type3_glyphs_follow_the_font_matrix() {
|
||||
for font in ["T3", "T30"] {
|
||||
let d = open_as(&page(&format!("BT /{font} 20 Tf 20 50 Td (ab) Tj ET"), ""), TextAs::Text);
|
||||
assert!(texts(&d).is_empty(), "Type 3 text keeps its outlines");
|
||||
let mut boxes = contours(&d);
|
||||
boxes.sort_by(|a, b| a.x0.total_cmp(&b.x0));
|
||||
// `a` at x 20 (0.4 em = 8 pt wide), `b` after its half-em advance; 0.7 em = 14 pt tall,
|
||||
// standing on the baseline at y 150 (200 - 50).
|
||||
let want = [Rect::new(20.0, 136.0, 28.0, 150.0), Rect::new(30.0, 136.0, 48.0, 150.0)];
|
||||
assert_eq!(boxes.len(), 2, "{font}: {boxes:?}");
|
||||
for (b, w) in boxes.iter().zip(want) {
|
||||
assert!(off(*b, w) < 1e-3, "{font}: {b:?} vs {w:?}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A font that isn't embedded or installed is set in a stand-in: the line still starts where
|
||||
/// the file starts it, on its baseline, and is as long as the file's.
|
||||
#[test]
|
||||
fn type_in_a_stand_in_font_still_starts_where_the_file_starts_it() {
|
||||
let t = texts(&open_as(&page("BT /HV 12 Tf 6 Tw 20 50 Td 5 Ts (Raised word line) Tj ET", ""), TextAs::Text));
|
||||
assert_eq!(t.len(), 1);
|
||||
assert_eq!(t[0].plain_text(), "Raised word line");
|
||||
let origin = t[0].xf * Point::ZERO;
|
||||
assert!((origin.x - 20.0).abs() < 1e-6 && (origin.y - 145.0).abs() < 1e-6, "{origin:?}");
|
||||
}
|
||||
|
||||
/// Type on a gentle arc: each glyph turned a little from the one before, the first few within a
|
||||
/// hair of the first's direction. They sit on the curve; none is shifted off it as well (which
|
||||
/// moved them off the curve by the shift twice over).
|
||||
#[test]
|
||||
fn type_on_a_gentle_arc_sits_on_its_curve_unshifted() {
|
||||
let text = "Gentle arc of type here";
|
||||
let (size, r) = (12.0, 450.0);
|
||||
let (cx, cy) = (150.0, -300.0);
|
||||
let mut phi = 100f64.to_radians();
|
||||
let mut content = format!("BT /F1 {size} Tf ");
|
||||
for c in text.chars() {
|
||||
let a = phi - std::f64::consts::FRAC_PI_2;
|
||||
let (x, y) = (cx + r * phi.cos(), cy + r * phi.sin());
|
||||
let esc = if c == ' ' { " ".to_string() } else { c.to_string() };
|
||||
content += &format!("{:.6} {:.6} {:.6} {:.6} {x:.4} {y:.4} Tm ({esc}) Tj ", a.cos(), a.sin(), -a.sin(), a.cos());
|
||||
phi -= width(c) * size / 1000.0 / r;
|
||||
}
|
||||
content += "ET";
|
||||
let t = texts(&open_as(&page(&content, ""), TextAs::Text));
|
||||
assert_eq!(t.len(), 1, "{:?}", t.iter().map(TextObject::plain_text).collect::<Vec<_>>());
|
||||
assert_eq!(t[0].plain_text(), text);
|
||||
assert!(matches!(t[0].kind, TextKind::OnPath { .. }), "type on a path");
|
||||
assert!(t[0].runs.iter().all(|r| r.style.baseline_shift == 0.0), "{:?}", t[0].runs);
|
||||
let d = displacement(&page(&content, ""));
|
||||
assert!(d < 0.05, "glyphs {d:.3} pt off the curve");
|
||||
}
|
||||
|
||||
/// A line with as many raised characters as level ones keeps the baseline of its first glyph:
|
||||
/// "m²" sits on the m's baseline, the 2 shifted up.
|
||||
#[test]
|
||||
fn a_tie_keeps_the_first_glyphs_baseline() {
|
||||
let content = "BT /F1 12 Tf 20 50 Td (m) Tj 5 Ts (2) Tj ET";
|
||||
lands(content, "", &["m2"]);
|
||||
let t = texts(&open_as(&page(content, ""), TextAs::Text));
|
||||
let origin = t[0].xf * Point::ZERO;
|
||||
assert!((origin.y - 150.0).abs() < 1e-6, "on the m's baseline: {origin:?}");
|
||||
assert_eq!(t[0].runs.len(), 2, "{:?}", t[0].runs);
|
||||
assert_eq!(t[0].runs[0].style.baseline_shift, 0.0);
|
||||
assert!((t[0].runs[1].style.baseline_shift - 5.0).abs() < 1e-6, "{:?}", t[0].runs[1].style);
|
||||
}
|
||||
|
||||
/// The cells of a table's row whose baselines differ a little (a third of an em) stay objects of
|
||||
/// their own: only a character that follows on from the one before is raised in its line.
|
||||
#[test]
|
||||
fn table_cells_a_little_apart_stay_apart() {
|
||||
for content in [
|
||||
"BT /F1 12 Tf 20 50 Td (Cell one) Tj 60 3.6 Td (Cell two) Tj ET",
|
||||
"BT /F1 12 Tf 20 50 Td (Cell one) Tj 60 -3.6 Td (Cell two) Tj ET",
|
||||
"BT /F1 12 Tf 20 50 Td (Cell one) Tj 3.6 Ts 60 0 Td (Cell two) Tj ET",
|
||||
] {
|
||||
lands(content, "", &["Cell one", "Cell two"]);
|
||||
}
|
||||
}
|
||||
|
||||
/// Vertical writing with the font's own vertical metrics (/W2): each glyph's position vector puts
|
||||
/// the column's centre where the font says (ISO 32000-1 §9.7.4.3), not half the default width.
|
||||
#[test]
|
||||
fn vertical_type_takes_the_fonts_position_vectors() {
|
||||
lands(&format!("BT /F6 24 Tf 150 180 Td {} Tj ET", gids("§±×")), "", &["§±×"]);
|
||||
}
|
||||
|
||||
/// A vertical font's metrics as the file gives them: /W2 first, then half the width from /W, then
|
||||
/// half /DW; glyphs mapped back to their CIDs through a /CIDToGIDMap stream; a CFF font's glyphs
|
||||
/// (whose charset maps them) take /DW's.
|
||||
#[test]
|
||||
fn vertical_font_metrics_are_read_from_w2_w_and_dw() {
|
||||
use craft_pdf::syntax::Pdf;
|
||||
use craft_pdf::syntax::object::{Dict, ObjectIdentifier};
|
||||
let n = first_extra(1);
|
||||
// CID → glyph: 10 → 5, 20 → 6, 30 → 7, 31 → 9, 40 → 8 (others 0).
|
||||
let mut map = [0u16; 41];
|
||||
for (cid, gid) in [(10, 5), (20, 6), (30, 7), (31, 9), (40, 8)] {
|
||||
map[cid] = gid;
|
||||
}
|
||||
let hex: String = map.iter().map(|g| format!("{g:04X}")).collect::<String>() + ">";
|
||||
let descendant = |subtype: &str, gid_map: &str| {
|
||||
format!(
|
||||
"<< /Type /Font /Subtype /{subtype} /BaseFont /Test /DW 900 /W [10 20 600 30 [400 500]] /W2 [10 [-1000 222 880] 40 41 -1000 333 880] {gid_map} >>"
|
||||
)
|
||||
};
|
||||
let type0 = |enc: &str, d: usize| format!("<< /Type /Font /Subtype /Type0 /BaseFont /Test /Encoding /{enc} /DescendantFonts [{d} 0 R] >>");
|
||||
let objs = [
|
||||
stream("/Filter /ASCIIHexDecode", &hex), // n
|
||||
descendant("CIDFontType2", &format!("/CIDToGIDMap {n} 0 R")), // n + 1
|
||||
type0("Identity-V", n + 1), // n + 2
|
||||
descendant("CIDFontType2", ""), // n + 3
|
||||
type0("Identity-V", n + 3), // n + 4
|
||||
descendant("CIDFontType0", ""), // n + 5
|
||||
type0("Identity-V", n + 5), // n + 6
|
||||
type0("Identity-H", n + 3), // n + 7
|
||||
];
|
||||
let refs: Vec<&str> = objs.iter().map(String::as_str).collect();
|
||||
let bytes = pdf_with(&[PdfPage::new(100.0, 100.0, "")], &refs, None);
|
||||
let pdf = Pdf::new(Arc::new(bytes)).unwrap();
|
||||
let font = |k: usize| pdf.xref().get::<Dict<'_>>(ObjectIdentifier::new((n + k) as i32, 0)).unwrap();
|
||||
let mapped = crate::import_scan::vertical_metrics(&font(2), true).expect("vertical");
|
||||
for (gid, want) in [(5, 222.0), (6, 300.0), (7, 200.0), (9, 250.0), (8, 333.0), (100, 450.0)] {
|
||||
assert_eq!(mapped.centre(gid), want, "glyph {gid}");
|
||||
}
|
||||
// CIDToGIDMap /Identity: glyph ids are CIDs.
|
||||
let identity = crate::import_scan::vertical_metrics(&font(4), true).expect("vertical");
|
||||
for (gid, want) in [(10, 222.0), (15, 300.0), (31, 250.0), (41, 333.0), (42, 450.0)] {
|
||||
assert_eq!(identity.centre(gid), want, "glyph {gid}");
|
||||
}
|
||||
// A font the file doesn't carry, or a CFF one: its glyphs can't be told by CID.
|
||||
let stand_in = crate::import_scan::vertical_metrics(&font(4), false).expect("vertical");
|
||||
let cff = crate::import_scan::vertical_metrics(&font(6), true).expect("vertical");
|
||||
assert_eq!((stand_in.centre(10), cff.centre(10)), (450.0, 450.0));
|
||||
assert!(crate::import_scan::vertical_metrics(&font(7), true).is_none(), "horizontal");
|
||||
}
|
||||
|
||||
/// Area type whose lines the file spaced a hair unevenly (`TJ` adjustments of a few thousandths
|
||||
/// of an em) still comes back as one text box.
|
||||
#[test]
|
||||
fn text_boxes_with_a_hair_of_uneven_spacing_still_open_as_one() {
|
||||
let content =
|
||||
"BT /F1 12 Tf 14 TL 20 150 Td [(The qu) -4 (ick brown fox )] TJ T* [(jumps o) 5 (ver the) -3 ( lazy )] TJ T* (dog and runs away.) Tj ET";
|
||||
let t = texts(&open_as(&page(content, ""), TextAs::Text));
|
||||
assert_eq!(t.len(), 1, "one text box: {:?}", t.iter().map(TextObject::plain_text).collect::<Vec<_>>());
|
||||
assert!(matches!(t[0].kind, TextKind::Area { .. }));
|
||||
assert_eq!(t[0].plain_text(), PARAGRAPH_TEXT);
|
||||
assert!(displacement(&page(content, "")) < 0.1);
|
||||
}
|
||||
|
||||
/// Word spacing the same on every line of a text box, its last line too, is the type's: it comes
|
||||
/// back as one text box, aligned left, its spaces tracked apart.
|
||||
#[test]
|
||||
fn text_boxes_word_spaced_throughout_open_as_one() {
|
||||
let content = format!("BT /F1 12 Tf 14 TL 2 Tw 20 150 Td {PARAGRAPH} ET");
|
||||
let t = texts(&open_as(&page(&content, ""), TextAs::Text));
|
||||
assert_eq!(t.len(), 1, "one text box: {:?}", t.iter().map(TextObject::plain_text).collect::<Vec<_>>());
|
||||
assert!(matches!(t[0].kind, TextKind::Area { .. }));
|
||||
assert_eq!(t[0].para.justify, vectorcraft_doc::Justify::Left);
|
||||
let spaces: Vec<f64> = t[0].runs.iter().filter(|r| r.text.trim().is_empty()).map(|r| r.style.tracking).collect();
|
||||
assert!(!spaces.is_empty() && spaces.iter().all(|s| (s - 2.0 / 12.0 * 1000.0).abs() < 1.0), "{:?}", t[0].runs);
|
||||
lands(&content, "", &[PARAGRAPH_TEXT]);
|
||||
}
|
||||
|
||||
/// A text-heavy page: `columns` columns of `rows` lines of 10 pt type, alternately plain lines and
|
||||
/// paragraphs wrapped in a frame (left aligned, and justified with word spacing).
|
||||
fn text_heavy(columns: usize, rows: usize) -> Vec<u8> {
|
||||
const WORDS: [&str; 12] = ["Gather", "the", "quick", "brown", "fox", "over", "lazy", "dogs", "while", "AVATAR", "waves", "kerning"];
|
||||
let mut content = String::new();
|
||||
for c in 0..columns {
|
||||
let x = 20.0 + c as f64 * 200.0;
|
||||
content += &format!("BT /F1 10 Tf 12 TL {x} {} Td ", 40.0 + rows as f64 * 12.0);
|
||||
for r in 0..rows {
|
||||
let words: Vec<&str> = (0..6).map(|k| WORDS[(c * 7 + r * 5 + k) % WORDS.len()]).collect();
|
||||
let wrapped = c % 2 == 1 && r % 6 != 5;
|
||||
let tw = if c % 4 == 3 && wrapped { 1.5 } else { 0.0 };
|
||||
content += &format!("{tw} Tw ({}{}) Tj T* ", words.join(" "), if wrapped { " " } else { "" });
|
||||
}
|
||||
content += "ET ";
|
||||
}
|
||||
sized_page(40.0 + columns as f64 * 200.0, 80.0 + rows as f64 * 12.0, &content, "")
|
||||
}
|
||||
|
||||
/// How long a text-heavy file takes to open as type (run by hand: `-- --ignored --nocapture`).
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn perf_text_heavy_open() {
|
||||
let bytes = text_heavy(20, 200);
|
||||
for _ in 0..2 {
|
||||
let start = std::time::Instant::now();
|
||||
let d = open_as(&bytes, TextAs::Text);
|
||||
let took = start.elapsed();
|
||||
let n = texts(&d).len();
|
||||
let start = std::time::Instant::now();
|
||||
let _ = open_as(&bytes, TextAs::Outlines);
|
||||
println!("4000 lines: {n} text objects in {took:?} (as outlines: {:?})", start.elapsed());
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
# File format parity
|
||||
|
||||
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-21 · **Change:** minor (PDF/X-1a and PDF/X-3 flattening keeps a CMYK document's inks where it rasterizes, #2160; EPS and `.ai` editing data: type keeps stacked art styles as a live appearance; point type frames without a matrix read; `editingData: "always"` for EPS; PDF invisible text, as a scanned page's recognized text is, opens as type with no fill or stroke and is written back as invisible text, #2675; DXF circular cubic paths export as native CIRCLE/ARC where stroke semantics permit (R13–2018 for weighted strokes; R12 weighted strokes remain POLYLINE) (#1299); non-circular curves stay SPLINE; scores and hours unchanged; an Illustrator 3 file without layers, as image editors export their paths, opens with its art on one layer, storytold/photocraft#6036; EPS editing data: legacy mesh corners, vector opacity masks and compound member paint retained; raster page comparison filters minification without relaxing limits; scores and hours unchanged; batch exporting, #1935; legacy `.ai` runs as PostScript with a prolog of its own, #868; legacy `.ai` of version 7 saved, with type as text, hidden objects and an artboard picker, and its type read, #868; PDF.R1: shared PDF reader with windowed content scanning and explicit incomplete-content errors; scores and estimates unchanged; PDF.W1: guarded shared PDF writer; output behavior, scores and estimates unchanged; later 2026-10-14 merges: SVG `:not()` selectors, #1557, stacked selectors, #1703, linked files, #1870; DXF VPORT, #1789; nesting caps, #1852; hostile PDF, `.ai`, EPS, Affinity and native data, #1862, #1863, #1871–#1873; failed saves, #1685, #1693, #1694; type in symbols after reopening, #1738; scores unchanged; verified PngSuite downloads, #1729; EPS stitched shadings, #1653; oversized images in WMF/EMF refused from the header, #1776; PDF name trees with shared nodes, #1781; native size limits for files read from memory, #1783; private temporary files on Unix, #1778; ruzstd 0.9.1, #1807; scores unchanged; SVG import: CSS transforms and the `font` shorthand, #1565, percentage lengths in symbols, #1596, Inkscape flowed text and pages, #1568, #1601, filter warnings, #1598; type on a path from PDF and `.ai`, #1585, #1586; ICC tag alignment in JPEG, TIFF and PSD, #1584; saves to folders that refuse the temporary file, #1620 in part; scores unchanged; TIFF is available in Export for Screens and Asset Export with shared format settings; scores and hours unchanged; compact native saves for documents with a lot of path data, #1492; PDF and EPS paste as vector art, #1499; `.ai` gradient stops listed upwards, #1530; SVG text on basic shapes, #1527; PDF soft masks drawn as images, #1551; Type 42 fonts in EPS, #1553; clips that only seem to cover the page, #1542; images too large to decode are reported, #1540; a `.ai` page's art past its artboard no longer lies over the page before it when read as its PDF part; grayscale TIFFs with an alpha channel or extra channels place and open, #1466 in part; a faded or masked fill keeps its stroke apart on PDF and `.ai` import, #1434; SVG knockout groups without masks, #1435; Affinity import: a text frame too short for its first line is made taller, #1423; `.ai` editing data: a compound path takes its last path's paint and keeps paths grouped inside it, #1410; a `.ai` whose PDF part is only text opens from it, #1387; PDF and `.ai` import keep overprint, #1388; `.ai` editing data: gradients with middle stops, #1390; type of objects with an appearance, hidden layers and later artboards, #1391; area type in a frame too short for the fallback font, #1392; `.ai` editing data: placed (linked) files read, #1264; gradient-filled shapes import as paths, #1304; white constant alpha soft masks, #1286 in part; DXF control-point SPLINE closure read, #1299 follow-up; `.ai` and PDF trim and bleed boxes as artboard and bleed, #1266; `.ai` gradient matrices, meshes and artboard names from the editing data; `.ai` art styles, clipping fills and compound looks from the editing data; `editingData: "always"` opens a `.ai` from its editing data; a `.ai` whose PDF part is only text opens from it, #1387; PDF and `.ai` import keep overprint, #1388; `.ai` editing data: gradients with middle stops, #1390; type of objects with an appearance, hidden layers and later artboards, #1391; area type in a frame too short for the fallback font, #1392; `.ai` editing data: placed (linked) files read, #1264; gradient-filled shapes import as paths, #1304; white constant alpha soft masks, #1286 in part; DXF control-point SPLINE closure read, #1299 follow-up; `.ai` and PDF trim and bleed boxes as artboard and bleed, #1266; `.ai` gradient matrices, meshes and artboard names from the editing data; `.ai` art styles, clipping fills and compound looks from the editing data; a `.ai` whose PDF part is only text opens from it, #1387; PDF and `.ai` import keep overprint, #1388; `.ai` editing data: gradients with middLine truncated
|
||||
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-21 · **Change:** minor (PDF text opens where the file draws it, #722; PDF/X-1a and PDF/X-3 flattening keeps a CMYK document's inks where it rasterizes, #2160; EPS and `.ai` editing data: type keeps stacked art styles as a live appearance; point type frames without a matrix read; `editingData: "always"` for EPS; PDF invisible text, as a scanned page's recognized text is, opens as type with no fill or stroke and is written back as invisible text, #2675; DXF circular cubic paths export as native CIRCLE/ARC where stroke semantics permit (R13–2018 for weighted strokes; R12 weighted strokes remain POLYLINE) (#1299); non-circular curves stay SPLINE; scores and hours unchanged; an Illustrator 3 file without layers, as image editors export their paths, opens with its art on one layer, storytold/photocraft#6036; EPS editing data: legacy mesh corners, vector opacity masks and compound member paint retained; raster page comparison filters minification without relaxing limits; scores and hours unchanged; batch exporting, #1935; legacy `.ai` runs as PostScript with a prolog of its own, #868; legacy `.ai` of version 7 saved, with type as text, hidden objects and an artboard picker, and its type read, #868; PDF.R1: shared PDF reader with windowed content scanning and explicit incomplete-content errors; scores and estimates unchanged; PDF.W1: guarded shared PDF writer; output behavior, scores and estimates unchanged; later 2026-10-14 merges: SVG `:not()` selectors, #1557, stacked selectors, #1703, linked files, #1870; DXF VPORT, #1789; nesting caps, #1852; hostile PDF, `.ai`, EPS, Affinity and native data, #1862, #1863, #1871–#1873; failed saves, #1685, #1693, #1694; type in symbols after reopening, #1738; scores unchanged; verified PngSuite downloads, #1729; EPS stitched shadings, #1653; oversized images in WMF/EMF refused from the header, #1776; PDF name trees with shared nodes, #1781; native size limits for files read from memory, #1783; private temporary files on Unix, #1778; ruzstd 0.9.1, #1807; scores unchanged; SVG import: CSS transforms and the `font` shorthand, #1565, percentage lengths in symbols, #1596, Inkscape flowed text and pages, #1568, #1601, filter warnings, #1598; type on a path from PDF and `.ai`, #1585, #1586; ICC tag alignment in JPEG, TIFF and PSD, #1584; saves to folders that refuse the temporary file, #1620 in part; scores unchanged; TIFF is available in Export for Screens and Asset Export with shared format settings; scores and hours unchanged; compact native saves for documents with a lot of path data, #1492; PDF and EPS paste as vector art, #1499; `.ai` gradient stops listed upwards, #1530; SVG text on basic shapes, #1527; PDF soft masks drawn as images, #1551; Type 42 fonts in EPS, #1553; clips that only seem to cover the page, #1542; images too large to decode are reported, #1540; a `.ai` page's art past its artboard no longer lies over the page before it when read as its PDF part; grayscale TIFFs with an alpha channel or extra channels place and open, #1466 in part; a faded or masked fill keeps its stroke apart on PDF and `.ai` import, #1434; SVG knockout groups without masks, #1435; Affinity import: a text frame too short for its first line is made taller, #1423; `.ai` editing data: a compound path takes its last path's paint and keeps paths grouped inside it, #1410; a `.ai` whose PDF part is only text opens from it, #1387; PDF and `.ai` import keep overprint, #1388; `.ai` editing data: gradients with middle stops, #1390; type of objects with an appearance, hidden layers and later artboards, #1391; area type in a frame too short for the fallback font, #1392; `.ai` editing data: placed (linked) files read, #1264; gradient-filled shapes import as paths, #1304; white constant alpha soft masks, #1286 in part; DXF control-point SPLINE closure read, #1299 follow-up; `.ai` and PDF trim and bleed boxes as artboard and bleed, #1266; `.ai` gradient matrices, meshes and artboard names from the editing data; `.ai` art styles, clipping fills and compound looks from the editing data; `editingData: "always"` opens a `.ai` from its editing data; a `.ai` whose PDF part is only text opens from it, #1387; PDF and `.ai` import keep overprint, #1388; `.ai` editing data: gradients with middle stops, #1390; type of objects with an appearance, hidden layers and later artboards, #1391; area type in a frame too short for the fallback font, #1392; `.ai` editing data: placed (linked) files read, #1264; gradient-filled shapes import as paths, #1304; white constant alpha soft masks, #1286 in part; DXF control-point SPLINE closure read, #1299 follow-up; `.ai` and PDF trim and bleed boxes as artboard and bleed, #1266; `.ai` gradient matrices, meshes and artboard names from the editing data; `.ai` art styles, clipping fills and compound looks from the editing data; a `.ai` whose PDF part is only text opens from it, #1387; PDF and `.ai` import keep overprint, Line truncated
|
||||
|
||||
Every format Illustrator opens, places, saves or exports, against VectorCraft's format table (`FORMATS`,
|
||||
`OPEN_EXTS`, `PLACE_EXTS` in `crates/engine/src/cmd/fileio/mod.rs`). Illustrator's list comes from its public
|
||||
@@ -93,7 +93,7 @@ the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPri
|
||||
| VectorCraft `.vectorcraft` / `.vctemplate` | — | yes | yes | lossless JSON, versioned, save down to v1; property-tested round trips (`format/tests/prop_format.rs`); documents with a lot of path data are written as compact JSON, about a fifth of the size (#1492); a save falls back to a plain fsync and to writing elsewhere and copying in when the folder refuses the usual steps (#1625, #1649, part of #1620; not confirmed on a real network share); the size limits on embedded data also apply to files read from memory (#1783), and saving over a private file on Unix leaves no readable temporary copy beside it (#1778) |
|
||||
| Illustrator template `.ait` | open, save | yes | PDF-compatible only, from Save as Template (`.vctemplate` stays its default) | New from Template opens a saved `.ait` untitled with its layers and art (`tests_pdfedit.rs`) |
|
||||
| Illustrator `.ai` | open, save | yes (PDF-compatible + editing-data structure, File Info) | PDF-compatible, or legacy version 7 (layers and groups) | see above; no real-file corpus |
|
||||
| PDF | open, place, save | yes (layers, masks, editable text, security, overprint, File Info from the XMP packet and the document information dictionary; Crop To › Trim takes the bleed box as the document's bleed) | yes (presets, PDF/X-1a/3/4, layers, marks and bleed, ICC, fast web view, 1.3+) | fuzzed import; shared guarded writer and windowed reader ([pdf-backend.md](pdf-backend.md)), metadata, incomplete-content and dependency-source regressions; PDF text placement issues in some files (#722); alpha soft masks drawn as images import with the mask (#1551); a clip only counts as covering the page when its shape does (#1542); a PDF another app copied pastes as editable vector art (#1499); letter-spaced type on a path keeps its length and its glyph-by-glyph stroke comes in as one text object (#1586, #1585); a crafted name tree with shared nodes no longer takes exponential time on open (#1781); invisible text (rendering mode 3: a scanned page's recognized text) opens as type with no fill or stroke and saves back as invisible, searchable text (#2675); PDF/X-1a and X-3 flattening in a CMYK document keeps CMYK inks where it rasterizes (#2160) |
|
||||
| PDF | open, place, save | yes (layers, masks, editable text, security, overprint, File Info from the XMP packet and the document information dictionary; Crop To › Trim takes the bleed box as the document's bleed) | yes (presets, PDF/X-1a/3/4, layers, marks and bleed, ICC, fast web view, 1.3+) | fuzzed import; shared guarded writer and windowed reader ([pdf-backend.md](pdf-backend.md)), metadata, incomplete-content and dependency-source regressions; PDF text opens where the file draws it, glyph by glyph (#722: kerning or none, spacing per character, text rise as baseline shift, vertical writing, justified text boxes); alpha soft masks drawn as images import with the mask (#1551); a clip only counts as covering the page when its shape does (#1542); a PDF another app copied pastes as editable vector art (#1499); letter-spaced type on a path keeps its length and its glyph-by-glyph stroke comes in as one text object (#1586, #1585); a crafted name tree with shared nodes no longer takes exponential time on open (#1781); invisible text (rendering mode 3: a scanned page's recognized text) opens as type with no fill or stroke and saves back as invisible, searchable text (#2675); PDF/X-1a and X-3 flattening in a CMYK document keeps CMYK inks where it rasterizes (#2160) |
|
||||
| EPS | open, place, save | yes (own PostScript L3 interpreter, Illustrator EPS editing data structure) | yes (L2/L3, TIFF previews) | CID-keyed CJK type not read; #505; images encoded with `CCITTFaxDecode` (ITU-T T.4 Group 3 and T.6 Group 4, with `K`, `Columns`, `Rows`, `EndOfBlock`, `EndOfLine`, `EncodedByteAlign` and `BlackIs1`) draw, and damaged data keeps the rows decoded before its first damaged row; Type 42 (TrueType) fonts set type at its size (#1553); a clip only counts as covering the page when its shape does (#1542); an EPS another app copied pastes as editable vector art (`clipboard.importEps`, #1499); a stitched shading keeps its hard colour changes on import (#1654); CMYK images, CMYK JPEGs included, keep their ink amounts on import, as from PDF, and the pixels a `MaskColor` or `ImageType 3` mask hides become a grayscale opacity mask; ruzstd 0.9.1 for compressed editing data (#1807, RUSTSEC-2026-0344) |
|
||||
| PostScript `.ps` | open, place | yes (the EPS reader reads its first page; `.epsf` files open and place as EPS) | via Print to PostScript | `tests_epsimport.rs` |
|
||||
| SVG / SVGZ | open, place, save | yes | yes (SVG Options, Preserve Editing, symbols, filters, rich text) | strongest format; tests in `crates/svg/tests`; text on a path follows basic shapes as their SVG 2 equivalent paths (#1527); CSS transforms and the `font` shorthand (#1565), percentage lengths in symbols (#1596), Inkscape flowed text as area type (#1568) and Inkscape pages as artboards (#1601) import; an unsupported filter is named in its warning (#1598); an artboard exported on its own (Export As with Use Artboards, Export for Screens, Asset Export) has the artboard's name as `<title>`, Save the document's (#3544) |
|
||||
@@ -135,6 +135,7 @@ the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPri
|
||||
| 2026-10-21 | minor | EPS and `.ai` editing data: type with an art style of several fills or strokes, effects on a fill (Offset Path, Transform with copies, Drop Shadow, Gaussian Blur, Bas Relief), pattern and gradient fills, per-fill blend modes and a Warp comes in as type with that live appearance instead of its drawn look (outlines), the style read as a tree of filters; other objects keep the rule for plain styles. Point type whose frame has no matrix (written so by newer files) is read; such stories were left out. Where a styled object's drawn look lay, the page isn't held to look like VectorCraft's drawing of the style. `editingData: "always"` also opens an Illustrator EPS from its editing data. Own-fixture tests; a user's file used locally only; scores and hours unchanged |
|
||||
| 2026-10-18 | minor | PDF import: invisible text (rendering mode 3, which carries a scanned page's recognized text) opens as type with no fill or stroke instead of being dropped without a word; when it can't be type (text opened as outlines, Type 3 fonts) it is left out with a warning. PDF export writes characters with no fill or stroke as invisible text in rendering mode 3, so a scanned PDF opened and saved keeps its searchable text, in PDF/X-1a and PDF/A too (#2675); own-fixture tests; scores and hours unchanged |
|
||||
| 2026-10-18 | minor | DXF circular cubic paths export as native CIRCLE/ARC where stroke semantics permit (R13–2018 for weighted strokes; R12 weighted strokes remain POLYLINE); R12 stroked circles/arcs retain their POLYLINE width, and ClosePath geometry with an implicit closing chord is not promoted to CIRCLE (#1299); scores and hours unchanged |
|
||||
| 2026-10-17 | minor | PDF import: text opens where the file draws it (#722): the font's kerning or none as the file followed it, word and character spacing and `TJ` adjustments kept per character as tracking, text rise as baseline shift in its line, vertical glyphs narrower than an em centred on their column, justified text boxes back as area type; fixtures written from ISO 32000-1 §9; scores unchanged |
|
||||
| 2026-10-17 | minor | PDF Place and clipboard paste preserve live text; explicit outlines remain supported on Place. Synthetic regressions; scores and hours unchanged. |
|
||||
| 2026-10-16 | minor | An Illustrator 3 file without prolog or layers (an image editor's exported paths) opens with its art on one layer instead of being refused (storytold/photocraft#6036); scores unchanged |
|
||||
| 2026-10-16 | minor | EPS editing data: legacy mesh corners, vector opacity masks and compound member paint retained; raster page comparison filters minification without relaxing limits; scores and hours unchanged. Synthetic EPS/parser/minification regressions; user EPS/SVG/JPG kept local. |
|
||||
|
||||
+11
-2
@@ -1,6 +1,6 @@
|
||||
# Gaps
|
||||
|
||||
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (G2: the Effect Gallery shipped (#2883): Effect › Effect Gallery… browses the Artistic, Brush Strokes, Distort, Sketch, Stylize and Texture filters, edits each filter's settings, builds an ordered stack (add, reorder, hide, remove) with a live canvas preview, and OK applies it as separate appearance effects in one undo step; remaining: filter thumbnails and a preview area inside the dialog; G2 estimate 4–6 → 1–2 h; Raster effects 82% → 85% (power-user view 49% → 52%), estimated, a modest move because the named missing dialog landed without thumbnails or an in-dialog preview; previously: G4: colour emoji fonts with bitmap glyphs (`sbix`: Apple Color Emoji; `CBDT`: Noto Color Emoji) draw on the canvas and export: PDF Type 3 glyphs or images, SVG images with outlined text, EPS and legacy `.ai` images, Create Outlines images; COLR and OpenType SVG fonts remain; estimate unchanged; G13: gradient Dither (Illustrator 30.0): a Dither box in the Gradient panel (`paint.editGradient`/`paint.setFill` `dither`, saved in the native file) draws a linear or radial gradient fill with seeded fine noise that hides banding, on the canvas and in raster exports; SVG and PDF exports write the fill as an image at the Document Raster Effects resolution, as the public documentation describes dither; fills only, as documented; score and hours unchanged; G2: Effect › Sketch › Conté Crayon (Foreground Level, Background Level, Texture, Scaling, Relief, Light Direction, Invert; a black crayon in the dark areas and a white one in the light areas on textured mid-grey paper; ranges and defaults unverified VectorCraft choices); measured Photoshop-style filters 57/57, the Effect Gallery remains (4–6 h); Affinity import AF.5: master pages, tables, paragraph formats, shadows, glows, outlines, overlays and embedded documents; Recolor Artwork Edit chips scroll within the available screen height (#3416); small palettes retain their tab height; scores and estimates unchanged; Blend panel Type and Ramp control step easing with a separate color Shift (#2539); Blend Options retains spacing and orientation; polynomial curves are original approximations; Shape Builder Gap Detection shares Live Paint’s spatial gap finder and temporary merge bridges (#2526); Custom is capped at 72 pt in the existing options dialog; filter plug-ins read and set effect records and stroke joins, caps and miter limits, G17; 3D: original Standard, Diffuse, Top Left and Right lighting presets; command access, effective-setting recognition and preview/history; scores and estimates unchanged; G1: one selected clip group's Properties panel has Edit Clipping Path and Edit Contents at its top; the selection tools take a clipping path on its outline, over the art it clips; Polygon and Star exact-size placement remembers the chosen count for later drags and dialog openings; Cancel preserves the previous count; Live trace result bounds and selection highlights exclude the retained bitmap except in source-image views; live-effect plug-ins given their object's fills and strokes and the item they sit on, G17; plug-in parameters: labels, units, groups, help and conditions in their dialogs, text and number-list parameters, up to 256 of them, G17; exporter plug-ins: plug-in file formats in Export As and document.export, G17; G2: Effect › Artistic › Smudge Stick, Sponge and Watercolor; Sketch › Bas Relief, Charcoal, Photocopy and Stamp, #2533; Photoshop filters 45/57, 12 remaining (8–14 h); on-canvas Mirror Repeat axis, #2877; G12: Background Export progress dialog with Cancel, #2564; status-readout sample widths cached by language, document unit and pixels per point; status messages and readouts use stable responsive allocations sized for localized labels and ordinary coordinates; cached canvas dimensions match the renderer limit before cache-key creation, view construction and worker submission; cached canvas reprojection preserves scale during resize, rotation and DPI changes; on-canvas Mirror Repeat axis, #2877; G12: Background Export progress dialog with Cancel, #2564; 3D lighting: one to ten colored lights, smooth colored Inflate, legacy white-light appearance preserved; surface batching and restored seam minimum; scores and estimates unchanged; Blend spine Anchor Point conversions, selection/stacking priority and Shift regression coverage (#2544); scores and hours unchanged; transparency grid visibility saved in native documents, #1968; G6: MCP cancellation, progress notifications and busy answers during long exports, #2165, #2171, #2172; EPS editing data: legacy mesh corners, vector opacity masks and compound member paint retained; raster page comparison filters minification without relaxing limits; scores and hours unchanged; correction: quick Image Trace presets leave the panel as it was, the Image Trace button opens it; batch exporting, #1935; G2: Effect › Sketch Line truncated
|
||||
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (G11: PDF text opens where the file draws it, #722; G2: the Effect Gallery shipped (#2883): Effect › Effect Gallery… browses the Artistic, Brush Strokes, Distort, Sketch, Stylize and Texture filters, edits each filter's settings, builds an ordered stack (add, reorder, hide, remove) with a live canvas preview, and OK applies it as separate appearance effects in one undo step; remaining: filter thumbnails and a preview area inside the dialog; G2 estimate 4–6 → 1–2 h; Raster effects 82% → 85% (power-user view 49% → 52%), estimated, a modest move because the named missing dialog landed without thumbnails or an in-dialog preview; previously: G4: colour emoji fonts with bitmap glyphs (`sbix`: Apple Color Emoji; `CBDT`: Noto Color Emoji) draw on the canvas and export: PDF Type 3 glyphs or images, SVG images with outlined text, EPS and legacy `.ai` images, Create Outlines images; COLR and OpenType SVG fonts remain; estimate unchanged; G13: gradient Dither (Illustrator 30.0): a Dither box in the Gradient panel (`paint.editGradient`/`paint.setFill` `dither`, saved in the native file) draws a linear or radial gradient fill with seeded fine noise that hides banding, on the canvas and in raster exports; SVG and PDF exports write the fill as an image at the Document Raster Effects resolution, as the public documentation describes dither; fills only, as documented; score and hours unchanged; G2: Effect › Sketch › Conté Crayon (Foreground Level, Background Level, Texture, Scaling, Relief, Light Direction, Invert; a black crayon in the dark areas and a white one in the light areas on textured mid-grey paper; ranges and defaults unverified VectorCraft choices); measured Photoshop-style filters 57/57, the Effect Gallery remains (4–6 h); Affinity import AF.5: master pages, tables, paragraph formats, shadows, glows, outlines, overlays and embedded documents; Recolor Artwork Edit chips scroll within the available screen height (#3416); small palettes retain their tab height; scores and estimates unchanged; Blend panel Type and Ramp control step easing with a separate color Shift (#2539); Blend Options retains spacing and orientation; polynomial curves are original approximations; Shape Builder Gap Detection shares Live Paint’s spatial gap finder and temporary merge bridges (#2526); Custom is capped at 72 pt in the existing options dialog; filter plug-ins read and set effect records and stroke joins, caps and miter limits, G17; 3D: original Standard, Diffuse, Top Left and Right lighting presets; command access, effective-setting recognition and preview/history; scores and estimates unchanged; G1: one selected clip group's Properties panel has Edit Clipping Path and Edit Contents at its top; the selection tools take a clipping path on its outline, over the art it clips; Polygon and Star exact-size placement remembers the chosen count for later drags and dialog openings; Cancel preserves the previous count; Live trace result bounds and selection highlights exclude the retained bitmap except in source-image views; live-effect plug-ins given their object's fills and strokes and the item they sit on, G17; plug-in parameters: labels, units, groups, help and conditions in their dialogs, text and number-list parameters, up to 256 of them, G17; exporter plug-ins: plug-in file formats in Export As and document.export, G17; G2: Effect › Artistic › Smudge Stick, Sponge and Watercolor; Sketch › Bas Relief, Charcoal, Photocopy and Stamp, #2533; Photoshop filters 45/57, 12 remaining (8–14 h); on-canvas Mirror Repeat axis, #2877; G12: Background Export progress dialog with Cancel, #2564; status-readout sample widths cached by language, document unit and pixels per point; status messages and readouts use stable responsive allocations sized for localized labels and ordinary coordinates; cached canvas dimensions match the renderer limit before cache-key creation, view construction and worker submission; cached canvas reprojection preserves scale during resize, rotation and DPI changes; on-canvas Mirror Repeat axis, #2877; G12: Background Export progress dialog with Cancel, #2564; 3D lighting: one to ten colored lights, smooth colored Inflate, legacy white-light appearance preserved; surface batching and restored seam minimum; scores and estimates unchanged; Blend spine Anchor Point conversions, selection/stacking priority and Shift regression coverage (#2544); scores and hours unchanged; transparency grid visibility saved in native documents, #1968; G6: MCP cancellation, progress notifications and busy answers during long exports, #2165, #2171, #2172; EPS editing data: legacy mesh corners, vector opacity masks and compound member paint retained; raster page comparison filters minification without relaxing limits; scores and hours unchanged; correction: quick Image Trace presets leave the panel as it was, the Image Trace button opens Line truncated
|
||||
|
||||
## Feature submission evidence
|
||||
|
||||
@@ -235,8 +235,16 @@ from G14 and the budget run of G15: **~170–270 h** one agent, ~50–80 h wall
|
||||
- **Done (#1910):** Transform Each's Reflect X flips left-right and Reflect Y flips top-bottom (aligned with
|
||||
Effect › Distort › Transform). Properties flip buttons keep the reference app's Properties names (Flip Along Horizontal / Vertical
|
||||
Axis).
|
||||
- **Done (#722):** PDF text opens where the file draws it. Each line used to come in as point type laid out by the
|
||||
font's metrics (its kerning, one even tracking, every glyph on one baseline, a vertical glyph's column an em wide),
|
||||
so glyphs slid wherever the file spaced them otherwise. Now a line takes the font's kerning or none, whichever the
|
||||
file followed, and tracking that puts every glyph where the file drew it (word and character spacing and `TJ`
|
||||
adjustments per character); text rise (`Ts`) stays in the line as baseline shift; a vertical glyph is centred on
|
||||
its column by the font's own metrics (`/W2`, else half its `/W` or `/DW`, ISO 32000-1 §9.7.4.3); justified text
|
||||
boxes come back as justified area type. Fixtures written from ISO 32000-1 §9 (`tests_text_placement`). A font
|
||||
that is neither embedded nor installed still draws in a stand-in with the old fit.
|
||||
- **Missing:** Shape Builder misses planar regions and targets whole shapes (#937); Transform effect dialog's invisible checkboxes and missing options (#885);
|
||||
PDF text boxes moving on open (#722); SVG units reverting to points (#864); bezier drag preview freezing (#834).
|
||||
SVG units reverting to points (#864); bezier drag preview freezing (#834).
|
||||
- **Impact:** wrong output in everyday work.
|
||||
- **Estimate:** 8–15 h.
|
||||
|
||||
@@ -505,6 +513,7 @@ separate. Scores and hours unchanged. [Behavior and command details](development
|
||||
| 2026-10-18 | minor | Mirror Repeat shows its axis when selected (#2877): drag the line or center handle to move it, drag an end handle to rotate it (Shift: 45°), Escape cancels and each drag is one undo step. Engine and headless canvas gesture regressions passed; native move, rotation and Escape screenshots reviewed. Formatting, Clippy, WASM and repository checks passed; the undo label reuses translated Repeat Options. (#2877) Scores and hours unchanged. |
|
||||
| 2026-10-18 | minor | Bounding-box handles take priority where a selected Mirror Repeat axis crosses them; a Top-handle regression confirms scaling of the default repeat. Center and end handles retain their move and rotation behavior. G1 scope and estimate unchanged. |
|
||||
| 2026-10-19 | minor | G13: blend easing (#1124): Ease In / Ease Out and separate Color Ease In / Out in Blend Options, saved with the blend; on-canvas handles and easing in the Blend panel remain. Estimate unchanged |
|
||||
| 2026-10-17 | minor | G11: #722 fixed (PDF text slid on open where the file spaced its glyphs other than the font's metrics: kerning, word and character spacing, `TJ` adjustments, text rise, narrow vertical glyphs; justified text boxes stayed lines); estimate unchanged |
|
||||
| 2026-10-19 | minor | G13: tangent and perpendicular snapping for lines drawn from an anchor (Pen, Curvature, Line Segment, with Smart Guides on), View › Snapping with every snap option, and the `view.snapping` command (#2530); estimate unchanged |
|
||||
| 2026-10-17 | minor | Blend spine Anchor Point conversions, selection/stacking priority and Shift regression coverage (#2544); scores and hours unchanged. Windows native canvas checks and screenshots reviewed in PR #2643. |
|
||||
| 2026-10-17 | minor | G12: Background Export progress dialog with Cancel and Continue in Background (#2564); no entry closed, estimates unchanged |
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Parity with Adobe Illustrator
|
||||
|
||||
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (G2: the Effect Gallery shipped (#2883): Effect › Effect Gallery… browses the Artistic, Brush Strokes, Distort, Sketch, Stylize and Texture filters, edits each filter's settings, builds an ordered stack (add, reorder, hide, remove) with a live canvas preview, and OK applies it as separate appearance effects in one undo step; remaining: filter thumbnails and a preview area inside the dialog; G2 estimate 4–6 → 1–2 h; Raster effects 82% → 85% (power-user view 49% → 52%), estimated, a modest move because the named missing dialog landed without thumbnails or an in-dialog preview; previously: colour emoji fonts with bitmap glyphs (`sbix`: Apple Color Emoji; `CBDT`: Noto Color Emoji) draw on the canvas and export: PDF Type 3 glyphs or images, SVG images with outlined text, EPS and legacy `.ai` images, Create Outlines images, see [type-parity.md](type-parity.md); scores unchanged; imported PDF type keeps a word space between two sizes (#3623); G13: gradient Dither (Illustrator 30.0): a Dither box in the Gradient panel (`paint.editGradient`/`paint.setFill` `dither`, saved in the native file) draws a linear or radial gradient fill with seeded fine noise that hides banding, on the canvas and in raster exports; SVG and PDF exports write the fill as an image at the Document Raster Effects resolution, as the public documentation describes dither; fills only, as documented; score and hours unchanged; #3546: `--automation-read-root` and `--automation-write-root` may each be given more than once (`vectorcraft-cli mcp` and the desktop app); a path inside any root of its kind is allowed, every confinement check unchanged. Scores and estimates unchanged; #3147: `vectorcraft-cli run --commands FILE` (or `-`) reads the steps from a JSON file or standard input (an array or JSON Lines, at most 64 MiB and 100,000 steps), among `--cmd` and `--export` in order; errors name the step. Scores and estimates unchanged; G2: Effect › Sketch › Conté Crayon (Foreground Level, Background Level, Texture, Scaling, Relief, Light Direction, Invert; a black crayon in the dark areas and a white one in the light areas on textured mid-grey paper; ranges and defaults unverified VectorCraft choices); measured Photoshop-style filters 57/57, the Effect Gallery remains (4–6 h); Affinity import AF.5: master pages, tables, paragraph formats, shadows, glows, outlines, overlays and embedded documents; Recolor Artwork Edit chips scroll within the available screen height (#3416); small palettes retain their tab height; scores and estimates unchanged; #3515: recent-font groups in font pickers; PDF/X-1a and PDF/X-3 flattening keeps a CMYK document's inks where it rasterizes, #2160; Blend panel Type and Ramp control step easing with a separate color Shift (#2539); Blend Options retains spacing and orientation; polynomial curves are original approximation; UI chrome: panels dock into any dock group or the icon column by dragging (UI.6), workspaces keep their layout changes (UI.7), dock groups collapse to their tabs by a double-click (UI.8); scores and hours unchanged; Shape Builder Gap Detection shares Live Paint’s spatial gap finder and temporary merge bridges (#2526); Custom is capped at 72 pt in the existing options dialog; Recolor model selection is available through the engine and MCP only (#2520); the dialog retains its existing controls; filter plug-ins read and set effect records and stroke joins, caps and miter limits, G17; the Print dialog's Media list has the Japanese papers: JIS B4 257 × 364 mm, JIS B5 182 × 257 mm and JIS B6 beside the ISO B4/B5, which keep their ISO 216 sizes, and はがき, 往復はがき, 封筒 長形3号/長形4号/角形2号/角形3号 and 四六判; a paper is named by its JSON id or its dialog label, any case and spacing; imported PDF type that is letter-spaced keeps its word spaces and no others; Fractional Widths: Character panel menu, per type object, on by default; System Layout remains a panel stub; scores unchanged; G4: manual Tate-chu-yoko; G4: No Break; scores unchanged; the selection tools take a clipping path on its outline, G1; Polygon and Star exact-size placement remembers the chosen count for later drags and dialog openings; Cancel preserves the previous count; Live trace result bounds and selection highlights exclude the retained bitmap except in source-image views; CSS swatch libraries retain fractional gradient stop positions; scores and hours unchanged; live-effect plug-ins given their object's fills and strokes and the item they sit on, G17; plug-in parameters: labels, units, groups, help and conditions in their dialogs, text and number-list parameters, up to 256 of them, G17; exporter plug-ins: plug-in file formats in Export As and document.export, G17; G2: Effect › Artistic › Smudge Stick, Sponge and Watercolor; Sketch › Bas Relief, Charcoal, Photocopy and Stamp, #2533; Photoshop filters 45/5Line truncated
|
||||
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (File formats: PDF text opens where the file draws it, #722, score unchanged; G2: the Effect Gallery shipped (#2883): Effect › Effect Gallery… browses the Artistic, Brush Strokes, Distort, Sketch, Stylize and Texture filters, edits each filter's settings, builds an ordered stack (add, reorder, hide, remove) with a live canvas preview, and OK applies it as separate appearance effects in one undo step; remaining: filter thumbnails and a preview area inside the dialog; G2 estimate 4–6 → 1–2 h; Raster effects 82% → 85% (power-user view 49% → 52%), estimated, a modest move because the named missing dialog landed without thumbnails or an in-dialog preview; previously: colour emoji fonts with bitmap glyphs (`sbix`: Apple Color Emoji; `CBDT`: Noto Color Emoji) draw on the canvas and export: PDF Type 3 glyphs or images, SVG images with outlined text, EPS and legacy `.ai` images, Create Outlines images, see [type-parity.md](type-parity.md); scores unchanged; imported PDF type keeps a word space between two sizes (#3623); G13: gradient Dither (Illustrator 30.0): a Dither box in the Gradient panel (`paint.editGradient`/`paint.setFill` `dither`, saved in the native file) draws a linear or radial gradient fill with seeded fine noise that hides banding, on the canvas and in raster exports; SVG and PDF exports write the fill as an image at the Document Raster Effects resolution, as the public documentation describes dither; fills only, as documented; score and hours unchanged; #3546: `--automation-read-root` and `--automation-write-root` may each be given more than once (`vectorcraft-cli mcp` and the desktop app); a path inside any root of its kind is allowed, every confinement check unchanged. Scores and estimates unchanged; #3147: `vectorcraft-cli run --commands FILE` (or `-`) reads the steps from a JSON file or standard input (an array or JSON Lines, at most 64 MiB and 100,000 steps), among `--cmd` and `--export` in order; errors name the step. Scores and estimates unchanged; G2: Effect › Sketch › Conté Crayon (Foreground Level, Background Level, Texture, Scaling, Relief, Light Direction, Invert; a black crayon in the dark areas and a white one in the light areas on textured mid-grey paper; ranges and defaults unverified VectorCraft choices); measured Photoshop-style filters 57/57, the Effect Gallery remains (4–6 h); Affinity import AF.5: master pages, tables, paragraph formats, shadows, glows, outlines, overlays and embedded documents; Recolor Artwork Edit chips scroll within the available screen height (#3416); small palettes retain their tab height; scores and estimates unchanged; #3515: recent-font groups in font pickers; PDF/X-1a and PDF/X-3 flattening keeps a CMYK document's inks where it rasterizes, #2160; Blend panel Type and Ramp control step easing with a separate color Shift (#2539); Blend Options retains spacing and orientation; polynomial curves are original approximation; UI chrome: panels dock into any dock group or the icon column by dragging (UI.6), workspaces keep their layout changes (UI.7), dock groups collapse to their tabs by a double-click (UI.8); scores and hours unchanged; Shape Builder Gap Detection shares Live Paint’s spatial gap finder and temporary merge bridges (#2526); Custom is capped at 72 pt in the existing options dialog; Recolor model selection is available through the engine and MCP only (#2520); the dialog retains its existing controls; filter plug-ins read and set effect records and stroke joins, caps and miter limits, G17; the Print dialog's Media list has the Japanese papers: JIS B4 257 × 364 mm, JIS B5 182 × 257 mm and JIS B6 beside the ISO B4/B5, which keep their ISO 216 sizes, and はがき, 往復はがき, 封筒 長形3号/長形4号/角形2号/角形3号 and 四六判; a paper is named by its JSON id or its dialog label, any case and spacing; imported PDF type that is letter-spaced keeps its word spaces and no others; Fractional Widths: Character panel menu, per type object, on by default; System Layout remains a panel stub; scores unchanged; G4: manual Tate-chu-yoko; G4: No Break; scores unchanged; the selection tools take a clipping path on its outline, G1; Polygon and Star exact-size placement remembers the chosen count for later drags and dialog openings; Cancel preserves the previous count; Live trace result bounds and selection highlights exclude the retained bitmap except in source-image views; CSS swatch libraries retain fractional gradient stop positions; scores and hours unchanged; live-effect plug-ins given their object's fills and strokes and the item they sit on, G17; plug-in parameters: labels, units, groups, help and conditions in their dialogs, text and number-list parameters, up to 256 of them, G17; exporter plug-ins: plug-in file formats in Export As and document.export, G17; G2: Effect › Artistic › Smudge Stick, Sponge and Watercolor; SketchLine truncated
|
||||
|
||||
## Feature submission evidence
|
||||
|
||||
@@ -840,6 +840,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
|
||||
SVG export (live text), legacy `.ai` saves (text objects), DXF export (`TEXT` entities) and the CSS Properties panel write area type that Shrink Text to Fit scales down at the size it draws at, and scale its tracking, kerning, leading and baseline shifts the same way where the format holds them.
|
||||
A PDF saved with Illustrator's editing data opens through it as a PDF-compatible `.ai` does, with its layers and groups and with art reaching past its page unclipped; such a PDF holds the data in `AIPDFPrivateData` streams (part of #868). A shape a PDF or `.ai` paints with a gradient (a clip path round a shading) opens as one path filled with the gradient, not a clip group round a rectangle, so Shape Builder, Live Paint and Pathfinder work on its outline (#1304).
|
||||
In a `.ai` opened from its editing data, a text object on a layer that shows and doesn't print stays on that layer, made from the file's text document, even where the page doesn't draw it (`crates/eps/src/import/tests_native.rs`). Such a `.ai` opens without the PDF part's warnings that text was kept as outlines when no outlined glyphs come in, and a warning counts the text objects that hold the page's type next to glyphs the page has only as outlines, which don't come in (`crates/engine/src/cmd/fileio/tests_aiimport.rs`). Where the art of a `.ai` or EPS opened from its editing data differs a little from the file's page, the warning gives the share of the page that differs away from type. When that share is 0.2% or less, the warning names the type and gives the share of the page that differs where the type is (`crates/eps/src/import/tests_native.rs`).
|
||||
PDF text opens with every glyph where the file draws it (#722): the font's kerning or none, whichever the file followed, word and character spacing, `TJ` adjustments and horizontal scaling kept per character as tracking, text rise as baseline shift within its line, vertical glyphs narrower than an em centred on their column (`/W2`, `/W`, `/DW`), justified text boxes with word spacing back as justified area type (`tests_text_placement`, fixtures written from ISO 32000-1 §9).
|
||||
A `.ai` or PDF whose editing data holds a variable library opens with a warning that its variables and data sets weren't read, with how many of each it has, whether its layers are read or it comes in as its PDF part (`crates/engine/src/cmd/fileio/tests_aiimport.rs`).
|
||||
A PDF page whose `UserUnit` (PDF 1.6) is above 1 opens at its size in points, its numbers times the `UserUnit` (one above 75,000 counts as 75,000), and `document.pdfInfo` gives its size and boxes in points too. A `.ai` whose editing data has its artboards in the units of such a page opens from that data at the page's size, with its layers, and when the layers can't be read its pages still take the artboard layout of the data, scaled the same way (part of #1482).
|
||||
When the editing data of a `.ai` or EPS is for a page of another size than the file's, the warning that its layers weren't read gives both sizes in points, and the scale of the editing data's page to the file's page (1:10 for a tenth of its size) when their sides are in proportion (#2034; `crates/eps/src/import/tests_native.rs`).
|
||||
@@ -1066,6 +1067,7 @@ applies to fills). Tests: `color::gradient::tests` (perceptual midpoint, expansi
|
||||
| 2026-10-18 | minor | Mirror Repeat shows its axis when selected (#2877): drag the line or center handle to move it, drag an end handle to rotate it (Shift: 45°), Escape cancels and each drag is one undo step. Engine and headless canvas gesture regressions passed; native move, rotation and Escape screenshots reviewed. Formatting, Clippy, WASM and repository checks passed; the undo label reuses translated Repeat Options. (#2877) Scores and hours unchanged. |
|
||||
| 2026-10-18 | minor | Bounding-box handles take priority where a selected Mirror Repeat axis crosses them: the Top handle scales the repeat, while the center still moves it and the ends still rotate it. Headless canvas regression confirms vertical scaling without width change; scores and hours unchanged. |
|
||||
| 2026-10-19 | minor | Blends: ease in/out and separate colour easing in Blend Options (#1124); on-canvas handles and easing in the Blend panel remain. Symbols, blends, envelopes score unchanged (estimated) |
|
||||
| 2026-10-17 | minor | File formats: PDF text opens where the file draws it (#722: glyphs slid where the file's spacing differed from the font's metrics: kerning, word and character spacing, `TJ` adjustments, text rise, narrow vertical glyphs; justified text boxes stayed lines); score 75% and hours unchanged (estimated) |
|
||||
| 2026-10-19 | minor | Guides, grids, smart guides, snapping: tangent and perpendicular snapping for lines drawn from an anchor (Pen, Curvature, Line Segment) and View › Snapping with every snap option, #2530; both only in part, so score and hours unchanged (estimated) |
|
||||
| 2026-10-17 | minor | Blend spine Anchor Point conversions, selection/stacking priority and Shift regression coverage (#2544); scores and hours unchanged. Windows native canvas checks and screenshots reviewed in PR #2643. |
|
||||
| 2026-10-17 | minor | Evidence: Artboard Options has X and Y beside a reference point locator, counted from the ruler origin (#1876); scores unchanged |
|
||||
|
||||
Reference in new issue
Block a user