mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-19 08:52:45 +01:00
#8188: arrowheads from partly transparent, masked or ambiguous art keep the drawn look
Review follow-ups: - A symbol whose art is partly transparent or has an opacity mask makes no head: the head would come in opaque and whole. - When both placements give the drawn art's bounds (a line ending inside the bounds of its other segments) and the heads move 0.2 pt or more between them, the object keeps its drawn look. - A comment line inside a /SymbolArt entry is skipped.
This commit is contained in:
1 parent
007356257f
commit
75c0bbd5d4
6 files changed
+133
-11
No files matched your search
@@ -20,15 +20,16 @@ const MAX_DEPTH: usize = 16;
|
||||
|
||||
/// The head that symbol art `art` (in the document's symbol space) draws, named `name`. `None` when
|
||||
/// the art doesn't have exactly one sample of the line, its sample isn't 1 pt wide, it holds
|
||||
/// anything but paths, compound paths and groups (a clip group, say), has an effect, a brush or a
|
||||
/// group with fills or strokes of its own, paints no head, or is too detailed for one; or when the
|
||||
/// anything but paths, compound paths and groups (a clip group, say), has an effect, a brush, an
|
||||
/// opacity mask, partial opacity or a group with fills or strokes of its own, paints no head, or is
|
||||
/// too detailed for one; or when the
|
||||
/// line would stop past the head's tip or farther back than a head can reach
|
||||
/// ([`CustomArrowhead::MAX_UNITS`]).
|
||||
pub(super) fn head(name: &str, art: &Node) -> Option<CustomArrowhead> {
|
||||
let mut parts = Parts::default();
|
||||
match &art.kind {
|
||||
// The members of the symbol's group are its art's top level, where the sample is.
|
||||
NodeKind::Group { children, clip: false } if art.visible && !paints(art) && art.appearance.effects.is_empty() => {
|
||||
NodeKind::Group { children, clip: false } if art.visible && plain(art) && !paints(art) => {
|
||||
for c in children {
|
||||
parts.member(c, true, 1)?;
|
||||
}
|
||||
@@ -70,7 +71,7 @@ impl Parts {
|
||||
if !n.visible || n.opacity <= 0.0 {
|
||||
return Some(());
|
||||
}
|
||||
if !n.appearance.effects.is_empty() {
|
||||
if !plain(n) {
|
||||
return None;
|
||||
}
|
||||
match &n.kind {
|
||||
@@ -102,13 +103,13 @@ impl Parts {
|
||||
for item in &n.appearance.items {
|
||||
match item {
|
||||
AppearanceItem::Fill(f) if f.visible && f.opacity > 0.0 && !f.paint.is_none() => {
|
||||
if !f.effects.is_empty() {
|
||||
if !f.effects.is_empty() || f.opacity < 1.0 {
|
||||
return None;
|
||||
}
|
||||
filled = true;
|
||||
}
|
||||
AppearanceItem::Stroke(s) if s.visible && s.opacity > 0.0 && !s.paint.is_none() && s.width > 0.0 => {
|
||||
if !s.effects.is_empty() || s.brush.is_some() {
|
||||
if !s.effects.is_empty() || s.brush.is_some() || s.opacity < 1.0 {
|
||||
return None;
|
||||
}
|
||||
strokes.push(s);
|
||||
@@ -149,6 +150,12 @@ impl Parts {
|
||||
}
|
||||
}
|
||||
|
||||
/// Does `n` draw as its shapes alone: fully opaque, with no effects and no opacity mask applied?
|
||||
/// A head is one opaque shape, so partly transparent or masked art isn't read as one.
|
||||
fn plain(n: &Node) -> bool {
|
||||
n.opacity >= 1.0 && n.appearance.effects.is_empty() && n.extras().mask.as_ref().is_none_or(|m| m.disabled)
|
||||
}
|
||||
|
||||
/// Does `n` (a group) have fills or strokes of its own that paint?
|
||||
fn paints(n: &Node) -> bool {
|
||||
n.appearance.items.iter().any(|i| match i {
|
||||
@@ -172,3 +179,66 @@ fn sample_line(path: &PathData) -> Option<(f64, f64)> {
|
||||
}
|
||||
Some((y, sub.anchors.iter().map(|a| a.p.x).fold(f64::NEG_INFINITY, f64::max)))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::sync::Arc;
|
||||
|
||||
use vectorcraft_color::{Color, Paint};
|
||||
use vectorcraft_doc::{Appearance, Node, NodeId, OpacityMask};
|
||||
use vectorcraft_geom::{PathData, Point, SubPath};
|
||||
|
||||
use super::head;
|
||||
|
||||
fn path(id: u64, points: &[(f64, f64)], closed: bool, appearance: Appearance) -> Arc<Node> {
|
||||
let points: Vec<Point> = points.iter().map(|(x, y)| Point::new(*x, *y)).collect();
|
||||
Arc::new(Node::path(NodeId(id), PathData::single(SubPath::polyline(&points, closed)), appearance))
|
||||
}
|
||||
|
||||
/// A 1 pt sample of the line from x = −9 to 4 on y = 0.
|
||||
fn sample() -> Arc<Node> {
|
||||
path(1, &[(-9.0, 0.0), (4.0, 0.0)], false, Appearance::basic(Paint::None, Paint::solid(Color::BLACK), 1.0))
|
||||
}
|
||||
|
||||
/// A filled wedge from x = 2 back to its tip at x = 8, 3 either side.
|
||||
fn wedge() -> Arc<Node> {
|
||||
path(2, &[(2.0, -3.0), (8.0, 0.0), (2.0, 3.0)], true, Appearance::basic(Paint::solid(Color::BLACK), Paint::None, 1.0))
|
||||
}
|
||||
|
||||
fn art(members: Vec<Arc<Node>>) -> Node {
|
||||
Node::group(NodeId(10), members)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_wedge_and_its_sample_make_a_head() {
|
||||
let h = head("W", &art(vec![sample(), wedge()])).expect("a head");
|
||||
assert_eq!(h.stop(), 4.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn partly_transparent_or_masked_art_makes_no_head() {
|
||||
// The head would come in opaque and whole, with the bounds of the art.
|
||||
let half = |n: Arc<Node>| Arc::new(Node { opacity: 0.5, ..(*n).clone() });
|
||||
let mut faint_fill = (*wedge()).clone();
|
||||
let mut ap = (*faint_fill.appearance).clone();
|
||||
if let Some(f) = ap.fill_mut() {
|
||||
f.opacity = 0.5;
|
||||
}
|
||||
faint_fill.appearance = ap.into();
|
||||
let mut masked = (*wedge()).clone();
|
||||
masked.extras_mut().mask = Some(Box::new(OpacityMask { art: sample(), clip: true, invert: false, disabled: false, linked: true }));
|
||||
let cases = [
|
||||
("a head at half opacity", art(vec![sample(), half(wedge())])),
|
||||
("a fill at half opacity", art(vec![sample(), Arc::new(faint_fill)])),
|
||||
("a group at half opacity", art(vec![sample(), half(Arc::new(art(vec![wedge()])))])),
|
||||
("the art at half opacity", Node { opacity: 0.5, ..art(vec![sample(), wedge()]) }),
|
||||
("a head with an opacity mask", art(vec![sample(), Arc::new(masked.clone())])),
|
||||
];
|
||||
for (why, a) in cases {
|
||||
assert!(head("W", &a).is_none(), "{why}");
|
||||
}
|
||||
// A disabled mask isn't applied.
|
||||
masked.extras_mut().mask.as_mut().unwrap().disabled = true;
|
||||
assert!(head("W", &art(vec![sample(), Arc::new(masked)])).is_some());
|
||||
}
|
||||
}
|
||||
@@ -1406,7 +1406,8 @@ fn painted_bounds(object: &Node, appearance: &Appearance) -> Option<Rect> {
|
||||
/// the path, or past them by the line's length under each head (Extend), whichever gives the
|
||||
/// object the look's bounds within a quarter of the least distance a head moves between the two
|
||||
/// (at least 0.05 pt, at most 0.5 pt). `None`
|
||||
/// when neither does: the file draws the heads elsewhere (on other subpaths, say).
|
||||
/// when neither does (the file draws the heads elsewhere: on other subpaths, say), or when both do
|
||||
/// and the heads move 0.2 pt or more between them (the bounds can't tell which the file draws).
|
||||
fn heads_placed(object: &Node, look: &Node, mut appearance: Appearance, space: Affine) -> Option<Appearance> {
|
||||
let k = space.determinant().abs().sqrt();
|
||||
let k = if k.is_finite() && k > 0.0 { k } else { 1.0 };
|
||||
@@ -1427,6 +1428,7 @@ fn heads_placed(object: &Node, look: &Node, mut appearance: Appearance, space: A
|
||||
// Well under the distance between the placements, and under half a point: a look without
|
||||
// those heads, or with them elsewhere, is off by more.
|
||||
let tolerance = (shift / 4.0).clamp(0.05, 0.5);
|
||||
let mut fits = vec![];
|
||||
for align in [ArrowAlign::Tip, ArrowAlign::Extend] {
|
||||
for item in &mut appearance.items {
|
||||
if let AppearanceItem::Stroke(s) = item {
|
||||
@@ -1438,10 +1440,22 @@ fn heads_placed(object: &Node, look: &Node, mut appearance: Appearance, space: A
|
||||
let got = painted_bounds(object, &scaled)?;
|
||||
let off = [got.x0 - want.x0, got.y0 - want.y0, got.x1 - want.x1, got.y1 - want.y1].iter().fold(0.0f64, |m, d| m.max(d.abs()));
|
||||
if off <= tolerance {
|
||||
return Some(appearance);
|
||||
fits.push(align);
|
||||
}
|
||||
}
|
||||
None
|
||||
// Both fit when the bounds can't tell the placements apart (the end inside the bounds of the
|
||||
// line's other segments), unless the heads move so little that either draws alike.
|
||||
let align = match fits.as_slice() {
|
||||
[one] => *one,
|
||||
[first, _] if shift < 0.2 => *first,
|
||||
_ => return None,
|
||||
};
|
||||
for item in &mut appearance.items {
|
||||
if let AppearanceItem::Stroke(s) = item {
|
||||
s.arrow_align = align;
|
||||
}
|
||||
}
|
||||
Some(appearance)
|
||||
}
|
||||
|
||||
/// A graphic style's appearance from art style `st`, on no object: `None` when the style isn't one
|
||||
|
||||
@@ -1557,7 +1557,14 @@ fn symbol_entry(lex: &mut Lexer, operands: &mut Vec<V>, other_entry: &mut Option
|
||||
let symbol = operands.iter().rev().find_map(|v| names.text(v));
|
||||
(*other_entry, *operands) = (None, vec![]);
|
||||
let at = lex.offset();
|
||||
let (close, key) = (lex.next_token().map(|t| t.tok), lex.next_token().map(|t| t.tok));
|
||||
// A comment line is no part of the entry.
|
||||
let mut next = || loop {
|
||||
match lex.next_token().map(|t| t.tok) {
|
||||
Some(Tok::Comment(_)) => continue,
|
||||
tok => return tok,
|
||||
}
|
||||
};
|
||||
let (close, key) = (next(), next());
|
||||
// Anything else is read as it comes (a `/KnownStyle` starting the next style, say).
|
||||
let (Some(Tok::Word(b";")), Some(Tok::Str(key))) = (close, key) else {
|
||||
lex.seek(at);
|
||||
|
||||
@@ -1604,3 +1604,15 @@ fn a_symbol_entry_cut_short_leaves_the_next_style_read() {
|
||||
assert!(styles.contains_key("Cut") && styles.contains_key("Next"), "{:?}", styles.keys().collect::<Vec<_>>());
|
||||
assert!(matches!(styles["Next"].items.as_slice(), [StyleItem::Stroke { arrows: None, .. }]), "{:?}", styles["Next"].items);
|
||||
}
|
||||
|
||||
/// A comment line inside a `/SymbolArt` entry is skipped: the entry is still read.
|
||||
#[test]
|
||||
fn a_comment_inside_a_symbol_entry_is_skipped() {
|
||||
let text = "/KnownStyle :\n(Arrowed) /Name ,\n/ActiveStyle :\n/CompoundFilter :\n(Chain Style Filter) 0 0 /Filter ,\n1 /Visible ,\n\
|
||||
/BasicFilter :\n(Stroke Style Filter) 0 0 /Filter ,\n1 /Visible ,\n/Dictionary : /NotRecorded ,\n\
|
||||
/GObjRef : (W) /SymbolArt\n%a comment\n; (BSArrowEndSymbol) ,\n\
|
||||
/StrokeStyle : 0 R\n0 0 0 1 0 0 0 XA\n0 J 0 j 1 w 10 M []0 d\n0 XR\n1 0 Xd\n/Def ;\n (StrokeStyle) ,\n; /Dict ;\n /Part ,\n;\n";
|
||||
let styles = art_styles(text.as_bytes());
|
||||
let [StyleItem::Stroke { arrows: Some(arrows), .. }] = styles["Arrowed"].items.as_slice() else { panic!("{:?}", styles["Arrowed"].items) };
|
||||
assert_eq!(arrows.end, Some(("W".to_string(), 100.0)));
|
||||
}
|
||||
@@ -6427,6 +6427,25 @@ fn arrowheads_this_does_not_read_keep_the_drawn_look() {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn heads_whose_placement_the_drawn_bounds_leave_open_keep_the_drawn_look() {
|
||||
// The line bends back so its end, and a head on it either on the end or 4 past it, lie inside
|
||||
// the bounds of its earlier segments: those bounds can't tell the two placements apart.
|
||||
let path = "%_0 50 m\n%_0 0 L\n%_200 0 L\n%_200 100 L\n%_100 100 L\n%_100 50 L\n%_N\n";
|
||||
let look = "0 G\n2 w\n0 50 m\n0 0 l\n200 0 l\n200 100 l\n100 100 l\n100 54 l\nS\n0 g\n97 56 m\n100 50 l\n103 56 l\nf\n";
|
||||
let line = format!("0 Ae\nu\n{look}U\n{path}1 (Arrowed) XW\n");
|
||||
let file = format!(
|
||||
"{}{}{}",
|
||||
symbols(&symbol("Wedge", WEDGE_ART, 5)),
|
||||
styles_and_list(&[arrow_style("Arrowed", END_WEDGE, 2.0)], &["Arrowed"]),
|
||||
layer(&line)
|
||||
);
|
||||
let r = read_ok(&file);
|
||||
let a = art(&r.doc);
|
||||
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{:?} {a:#?}", r.warnings);
|
||||
assert!(!matches!(a[0].kind, NodeKind::Path { .. }), "the look, not the object");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_arrowhead_entry_without_heads_leaves_the_stroke_read() {
|
||||
// Only beside heads does an arrowhead entry this doesn't read keep the drawn look.
|
||||
|
||||
@@ -344,7 +344,7 @@ Stop opacity on translated artboards remains outside this regression coverage.
|
||||
|
||||
| Date | Change | Summary |
|
||||
|---|---|---|
|
||||
| 2026-11-16 | minor | `.ai` import: a stroke's arrowheads were left out, so lines came in without their heads (#8188). A Stroke Style filter's stroke dictionary names each end's head as a symbol of the file (`/GObjRef : (name) /SymbolArt ; (BSArrowBeginSymbol)` or `(BSArrowEndSymbol)`), with its scale in percent (`BSArrowEndScale`, and `BSArrowBeginScale` read the same way; 100 without one). As the files have it, such a symbol's art (y down, as symbols are read) points right along a straight, level sample of the line: an open stroked path with no fill, which ends where the line stops under the head. The rest of the art that paints is the head, its tip its rightmost point, at one symbol unit a head weight (the stroke's weight at the scale). The head comes in as a custom arrowhead with that outline and that stop (a custom head now carries an optional stop, else its line ends halfway along it, as before). Its placement is the one of the two (tip on the end of the path, or Extend, the tip past it by the line's length under the head) that gives the object its drawn art's bounds; the user's file has every tip on its path's end. A stroke keeps its drawn look when neither placement gives those bounds (heads on other subpaths, say), when its symbol isn't read whole or isn't read as a head (no sample or more than one, a sample that isn't 1 pt wide, as in art stored at a Large Canvas scale, art other than paths, compound paths and groups such as a clip group, a group with fills or strokes of its own, effects, brushes), when its dictionary holds another `BSArrow` entry beside heads, when a scale is outside 1–1000 %, or when the head's weight would be under the 0.25 pt least one VectorCraft draws; a graphic style with such a stroke isn't read rather than read without its heads, and one with heads takes them on the end of the path, so an object whose heads are read past its ends isn't linked to its listed style. Measured on a user's file of ten arrows (used locally, never committed): every line gets its heads, and drawn at 4× its pixels match the file's own page but for 3 of 9,825 inked ones (0.24.1: 1,232 differ). Tests `a_strokes_arrowhead_symbols_are_its_arrowheads`, `a_strokes_start_arrowhead_points_back_and_keeps_its_side`, `a_stroke_takes_both_heads_at_their_own_scales`, `heads_drawn_past_the_path_extend_it`, `arrowheads_this_does_not_read_keep_the_drawn_look`, `an_arrowhead_entry_without_heads_leaves_the_stroke_read` in `crates/eps/src/import/ai/tests.rs`, `a_symbol_entry_cut_short_leaves_the_next_style_read` in `crates/eps/src/import/ai/style/tests.rs`, fuzzed by `ai_arrowhead_strokes_never_panic`; scores unchanged |
|
||||
| 2026-11-16 | minor | `.ai` import: a stroke's arrowheads were left out, so lines came in without their heads (#8188). A Stroke Style filter's stroke dictionary names each end's head as a symbol of the file (`/GObjRef : (name) /SymbolArt ; (BSArrowBeginSymbol)` or `(BSArrowEndSymbol)`), with its scale in percent (`BSArrowEndScale`, and `BSArrowBeginScale` read the same way; 100 without one). As the files have it, such a symbol's art (y down, as symbols are read) points right along a straight, level sample of the line: an open stroked path with no fill, which ends where the line stops under the head. The rest of the art that paints is the head, its tip its rightmost point, at one symbol unit a head weight (the stroke's weight at the scale). The head comes in as a custom arrowhead with that outline and that stop (a custom head now carries an optional stop, else its line ends halfway along it, as before). Its placement is the one of the two (tip on the end of the path, or Extend, the tip past it by the line's length under the head) that gives the object its drawn art's bounds; the user's file has every tip on its path's end. A stroke keeps its drawn look when neither placement gives those bounds (heads on other subpaths, say) or both do while the heads move 0.2 pt or more between them (a line whose end lies inside the bounds of its other segments), when its symbol isn't read whole or isn't read as a head (no sample or more than one, a sample that isn't 1 pt wide, as in art stored at a Large Canvas scale, art other than paths, compound paths and groups such as a clip group, a group with fills or strokes of its own, effects, brushes, partial opacity or an opacity mask), when its dictionary holds another `BSArrow` entry beside heads, when a scale is outside 1–1000 %, or when the head's weight would be under the 0.25 pt least one VectorCraft draws; a graphic style with such a stroke isn't read rather than read without its heads, and one with heads takes them on the end of the path, so an object whose heads are read past its ends isn't linked to its listed style. Measured on a user's file of ten arrows (used locally, never committed): every line gets its heads, and drawn at 4× its pixels match the file's own page but for 3 of 9,825 inked ones (0.24.1: 1,232 differ). Tests `a_strokes_arrowhead_symbols_are_its_arrowheads`, `a_strokes_start_arrowhead_points_back_and_keeps_its_side`, `a_stroke_takes_both_heads_at_their_own_scales`, `heads_drawn_past_the_path_extend_it`, `arrowheads_this_does_not_read_keep_the_drawn_look`, `an_arrowhead_entry_without_heads_leaves_the_stroke_read` in `crates/eps/src/import/ai/tests.rs`, `heads_whose_placement_the_drawn_bounds_leave_open_keep_the_drawn_look` in it, `a_symbol_entry_cut_short_leaves_the_next_style_read` and `a_comment_inside_a_symbol_entry_is_skipped` in `crates/eps/src/import/ai/style/tests.rs`, `partly_transparent_or_masked_art_makes_no_head` in `crates/eps/src/import/ai/arrowhead.rs`, fuzzed by `ai_arrowhead_strokes_never_panic`; scores unchanged |
|
||||
| 2026-11-15 | minor | PDF import: stroked type (text rendering modes 1, 2, 5 and 6, and glyphs under `ActualText`) came in with butt caps, miter joins and a miter limit of 10 whatever the file stroked it with, while paths kept the graphics state's. The characters' stroke now takes the line cap (`J`), line join (`j`) and miter limit (`M`) of the graphics state, as a path's stroke does, and glyphs stroked with other ones start a run of their own, also a glyph filled and then stroked otherwise than the run its fill joined, so the glyphs before it keep their stroke (#7741). Test `imported_stroked_type_keeps_the_files_cap_join_and_miter_limit` in `crates/pdf/src/tests/textstroke.rs`. Scores and estimates unchanged. |
|
||||
| 2026-11-13 | minor | `.ai` and EPS import: layers that don't draw as the page, even with the drawn art of every live envelope put back, no longer put back the drawn art of every envelope of type. Each live envelope of type is weighed in the page check's own drawing of the pages it lies on, on the pixels that it and its drawn art ink there (the two drawn together on a layer of their own, without the rest of the layers; a pixel inks with an alpha above 8 of 255): it keeps its drawn art and its type, hidden, with the note, where the layers with it differ from the page in more of those pixels than its own check allows against its drawn art (10% of them, or 3% differing with all their neighbours, away from type), or where the envelopes of type that stay live, in the order they were read, would together differ there in more of a page than half of what the page check allows (a budget of the same size as the one their own checks share, kept apart from it). Art that differs elsewhere on the page no longer costs them their editable type; art that differs on their pixels still does. An envelope of type that a clip group or a clipping sublayer clips, an opacity mask masks, or a group with an appearance of its own, another envelope, a repeat or a blend holds keeps its drawn art as before, wherever it lies: drawn on its own it would be weighed elsewhere than it draws, and what holds it can draw it onto the page from off it. An envelope on no page stays live, as the page check doesn't see it, unless the page holds all the art that prints (an EPS's page that is its art's box, where art past the page is compared too): there one reaching past the page keeps its drawn art. Past 12 of them on the pages, all keep it. This holds where the editing data is trusted, where the objects that differ come in as the page's art (the placed files' other placement weighed on its own, as it draws them elsewhere under or over the envelopes; layers that draw as the page with only the envelopes the page holds put back are used as they are; where none of the objects that differ can then come in as the page's art, because an object holds type, the drawn art of every envelope of type is put back and that is tried again, as before), and for a `.ai` whose layers would open alone, which still opens alone: its envelopes of type are all settled again as they were with the page, in the same order and with the same checks, so each that opens live draws as it was weighed, and those the page held get their drawn art back. Where putting the drawn art of every live envelope back makes the layers draw as the page, it is still put back (#5065). In 224 users' files (used locally, never committed): envelopes of type that open live go from 174 to 186, in 8 files, none fewer in any file; no file changes between its layers and its PDF part; 7 renders change, by at most 0.7% of their pixels at 40 ppi (1 closer to the page, 1 alike, 5 further, by at most 0.7 of a percentage point, where VectorCraft's own envelope draws a little apart from the drawn art, within its check); the note for type in an envelope goes from 6 files. Of the 14 envelopes of type that had opened live and lost it to the page check, 2 keep their drawn art: one where the page draws something else where it is, and one in a file that comes in as its PDF part (#7141). Tests `build::candidate_tests::the_page_holds_back_only_envelopes_of_type_where_it_differs_from_them`, `envelopes_of_type_stay_live_within_half_of_what_the_page_check_allows`, `an_envelope_of_type_differing_in_more_of_its_pixels_than_its_check_allows_is_held_back`, `envelopes_of_type_the_layers_dont_draw_in_place_are_held_back`, `on_a_page_that_holds_all_the_art_an_envelope_of_type_past_it_is_held_back`, `objects_come_in_as_the_page_art_with_every_envelope_of_type_put_back_where_a_live_one_holds_a_difference`, `tests_native::layers_that_would_open_alone_keep_an_envelope_of_type_live_where_other_art_differs_from_the_page`, `layers_that_would_open_alone_keep_live_only_the_envelopes_of_type_the_page_doesnt_hold`, `trusted_layers_that_would_open_alone_open_alone_with_an_envelope_of_type_the_page_doesnt_hold_live`, `layers_with_objects_that_come_in_as_the_page_art_keep_an_envelope_of_type_that_draws_as_the_page_live`, `trusted_layers_keep_an_envelope_of_type_live_where_other_art_differs_from_the_page`, `trusted_layers_leave_an_envelope_of_type_the_page_draws_otherwise_its_drawn_art`, `build::candidate_tests::the_other_placement_of_placed_files_is_weighed_on_its_own`, `layers_that_draw_as_the_page_with_the_held_envelopes_of_type_put_back_are_used_so` |
|
||||
| 2026-11-13 | minor | PDF import: glyphs inside a marked-content span with an empty `ActualText` come in as outlines in their fill and stroke instead of being left out, adding no text (#6971; `empty_actual_text_keeps_the_glyphs_art` in `crates/pdf/src/tests/actual_text.rs`). Scores and estimates unchanged. |
|
||||
|
||||
Reference in new issue
Block a user