mirror of
https://github.com/storytold/designcraft.git
synced 2026-10-28 12:16:53 -06:00
Dylan M. TaylorandClaude Sonnet 5.5
c313c53497
Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
779 lines
32 KiB
Rust
779 lines
32 KiB
Rust
//! Composed text → pixels.
|
|
//!
|
|
//! Glyph outlines of a frame are transformed into frame space and batched per line and run style
|
|
//! once, then cached per (composed story allocation, frame id): a composed story is immutable, so
|
|
//! the cache entry stays valid for as long as the composition cache hands out the same `Arc`.
|
|
//! Each render only fills the lines that intersect the visible rectangle, and lines smaller than
|
|
//! the greeking threshold become grey bars without touching any outline.
|
|
|
|
use std::collections::HashMap;
|
|
use std::sync::{Arc, Weak};
|
|
|
|
use designcraft_compose::{ComposedStory, FrameText, Line, ShownOn};
|
|
use designcraft_doc::ItemId;
|
|
use designcraft_fonts::FontDb;
|
|
use designcraft_geom::{Affine, BezPath, Rect, Shape};
|
|
use vello_cpu::RenderContext;
|
|
use vello_cpu::kurbo;
|
|
use vello_cpu::peniko;
|
|
|
|
use crate::{Frame, Renderer, color_of, rect_overlaps, screen_color};
|
|
|
|
/// A text colour: solid, or a gradient swatch laid across the frame (InDesign spans a gradient on
|
|
/// text across its frame's box).
|
|
#[derive(Clone)]
|
|
enum TextPaint {
|
|
Solid(peniko::Color),
|
|
Gradient(designcraft_doc::Fill),
|
|
}
|
|
|
|
impl TextPaint {
|
|
fn of(doc: &designcraft_doc::Document, swatch: &str, tint: f32) -> Option<Self> {
|
|
if designcraft_color::swatch::resolve_gradient(&doc.swatches, swatch).is_some() {
|
|
return Some(TextPaint::Gradient(designcraft_doc::Fill { swatch: swatch.into(), tint, ..designcraft_doc::Fill::none() }));
|
|
}
|
|
doc.resolve_color(swatch, tint).map(|c| TextPaint::Solid(color_of(&c, 1.0)))
|
|
}
|
|
|
|
/// Make this the context's paint; a gradient runs across `area` (text space).
|
|
fn set(&self, ctx: &mut RenderContext, doc: &designcraft_doc::Document, area: Rect) {
|
|
match self {
|
|
TextPaint::Solid(c) => ctx.set_paint(*c),
|
|
TextPaint::Gradient(fill) => {
|
|
crate::set_fill_paint(ctx, doc, fill, area);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The box a gradient on a frame's text spans: the frame's, in text space (the union of its lines
|
|
/// when the frame is gone).
|
|
fn text_area(doc: &designcraft_doc::Document, ft: &FrameText) -> Rect {
|
|
if let Some(it) = doc.item(ft.frame) {
|
|
let local = doc.text_local(it);
|
|
if local.determinant().abs() > 1e-12 {
|
|
return local.inverse().transform_rect_bbox(it.inner_bounds());
|
|
}
|
|
}
|
|
ft.lines.iter().filter_map(line_box).reduce(|a, b| a.union(b)).unwrap_or(Rect::new(0.0, 0.0, 1.0, 1.0))
|
|
}
|
|
|
|
/// Cached outlines of one composed line.
|
|
pub(crate) struct LineGlyphs {
|
|
/// Frame-space bounds of everything drawn for the line (empty lines: `None`).
|
|
pub bounds: Option<Rect>,
|
|
/// Glyph outlines batched per run style.
|
|
pub runs: Vec<(u32, BezPath)>,
|
|
/// Bars below/above the glyph paint pass: colour swatch, tint, rectangle.
|
|
pub underlines: Vec<(String, f32, Rect)>,
|
|
pub strikes: Vec<(String, f32, Rect)>,
|
|
pub glyphs: usize,
|
|
}
|
|
|
|
pub(crate) struct FrameGlyphs {
|
|
pub lines: Vec<LineGlyphs>,
|
|
/// Path elements held (cache budget).
|
|
pub elements: usize,
|
|
}
|
|
|
|
struct Entry {
|
|
/// Pins only the allocation identity used by the key. The cached paths own their data;
|
|
/// old story layout buffers can drop once composition/render users release them. A Weak
|
|
/// still prevents this allocation address from being reused by another story.
|
|
_story: Weak<ComposedStory>,
|
|
glyphs: Arc<FrameGlyphs>,
|
|
stamp: u64,
|
|
}
|
|
|
|
/// Path cache keyed by (composed story address, frame id).
|
|
#[derive(Default)]
|
|
pub(crate) struct GlyphCache {
|
|
map: HashMap<(usize, ItemId), Entry>,
|
|
elements: usize,
|
|
clock: u64,
|
|
}
|
|
|
|
/// Roughly 56 bytes per element: ~110 MB of cached outlines.
|
|
const MAX_ELEMENTS: usize = 2_000_000;
|
|
|
|
impl GlyphCache {
|
|
pub fn tick(&mut self) {
|
|
self.clock += 1;
|
|
}
|
|
|
|
fn get(&mut self, cs: &Arc<ComposedStory>, ft: &FrameText) -> Arc<FrameGlyphs> {
|
|
let key = (Arc::as_ptr(cs) as usize, ft.frame);
|
|
let stamp = self.clock;
|
|
if let Some(e) = self.map.get_mut(&key) {
|
|
e.stamp = stamp;
|
|
return e.glyphs.clone();
|
|
}
|
|
let g = Arc::new(build(cs, ft));
|
|
self.elements += g.elements;
|
|
self.map.insert(key, Entry { _story: Arc::downgrade(cs), glyphs: g.clone(), stamp });
|
|
if self.elements > MAX_ELEMENTS {
|
|
self.evict();
|
|
}
|
|
g
|
|
}
|
|
|
|
/// Drop least recently used entries (never the ones used by the current render) until the
|
|
/// cache is at half its budget.
|
|
fn evict(&mut self) {
|
|
let mut stamps: Vec<(u64, usize, (usize, ItemId))> = self.map.iter().map(|(k, e)| (e.stamp, e.glyphs.elements, *k)).collect();
|
|
stamps.sort_unstable_by_key(|s| s.0);
|
|
for (stamp, n, k) in stamps {
|
|
if self.elements <= MAX_ELEMENTS / 2 || stamp >= self.clock {
|
|
break;
|
|
}
|
|
self.map.remove(&k);
|
|
self.elements -= n;
|
|
}
|
|
}
|
|
|
|
pub fn clear(&mut self) {
|
|
self.map.clear();
|
|
self.elements = 0;
|
|
}
|
|
|
|
pub fn len(&self) -> usize {
|
|
self.map.len()
|
|
}
|
|
}
|
|
|
|
fn transform_el(a: Affine, el: kurbo::PathEl) -> kurbo::PathEl {
|
|
use kurbo::PathEl::*;
|
|
match el {
|
|
MoveTo(p) => MoveTo(a * p),
|
|
LineTo(p) => LineTo(a * p),
|
|
QuadTo(p1, p2) => QuadTo(a * p1, a * p2),
|
|
CurveTo(p1, p2, p3) => CurveTo(a * p1, a * p2, a * p3),
|
|
ClosePath => ClosePath,
|
|
}
|
|
}
|
|
|
|
fn union(r: Option<Rect>, b: Rect) -> Option<Rect> {
|
|
Some(r.map_or(b, |r| r.union(b)))
|
|
}
|
|
|
|
/// Add a rule bar, joined onto the previous one when it continues the same stretch.
|
|
fn push_bar(bars: &mut Vec<(String, f32, Rect)>, color: &str, tint: f32, r: Rect) {
|
|
match bars.last_mut() {
|
|
Some((c, t, last))
|
|
if c.as_str() == color
|
|
&& *t == tint
|
|
&& (last.y0 - r.y0).abs() < 1e-6
|
|
&& (last.y1 - r.y1).abs() < 1e-6
|
|
&& (r.x0 - last.x1).abs() < 0.5 =>
|
|
{
|
|
last.x1 = last.x1.max(r.x1);
|
|
}
|
|
_ => bars.push((color.to_owned(), tint, r)),
|
|
}
|
|
}
|
|
|
|
fn build_line(db: &FontDb, cs: &ComposedStory, l: &Line, vertical: bool) -> LineGlyphs {
|
|
let mut runs: Vec<(u32, BezPath)> = Vec::new();
|
|
let mut underlines: Vec<(String, f32, Rect)> = Vec::new();
|
|
let mut strikes: Vec<(String, f32, Rect)> = Vec::new();
|
|
let mut glyphs = 0;
|
|
for g in &l.glyphs {
|
|
if !g.spans_rules() {
|
|
continue;
|
|
}
|
|
let style = &cs.styles[g.style as usize];
|
|
for (on, rule, bars) in [(style.underline, &style.underline_rule, &mut underlines), (style.strikethrough, &style.strike_rule, &mut strikes)] {
|
|
if on {
|
|
let r = rule.rect(g.x, g.x + g.adv, designcraft_compose::rule_baseline(style, l, g));
|
|
// One bar per stretch, as the PDF export draws them: a bar per glyph left
|
|
// anti-aliased seams between the letters.
|
|
push_bar(bars, &rule.color, rule.tint, r);
|
|
}
|
|
}
|
|
// A tab carries the rule across its width but draws nothing itself.
|
|
if !g.visible {
|
|
continue;
|
|
}
|
|
let outline = db.outline(&g.face, g.gid);
|
|
if outline.elements().is_empty() {
|
|
continue;
|
|
}
|
|
let skew = if style.skew != 0.0 { Affine::new([1.0, 0.0, -style.skew.to_radians().tan(), 1.0, 0.0, 0.0]) } else { Affine::IDENTITY };
|
|
let mut a = Affine::translate((g.x, l.baseline + g.y)) * skew * Affine::scale_non_uniform(g.sx, g.sy);
|
|
if let Some(shatai) = style.shatai_xf(g, l.baseline) {
|
|
a = shatai * a;
|
|
}
|
|
if vertical && let Some(turn) = g.vertical_xf(l.baseline) {
|
|
// Upright in vertical text.
|
|
a = turn * a;
|
|
}
|
|
let k = match runs.iter().position(|r| r.0 == g.style) {
|
|
Some(k) => k,
|
|
None => {
|
|
runs.push((g.style, BezPath::new()));
|
|
runs.len() - 1
|
|
}
|
|
};
|
|
let bp = &mut runs[k].1;
|
|
for el in outline.elements() {
|
|
bp.push(transform_el(a, *el));
|
|
}
|
|
glyphs += 1;
|
|
}
|
|
let mut bounds = None;
|
|
for (si, bp) in &runs {
|
|
let st = &cs.styles[*si as usize];
|
|
let sw = if st.stroke != designcraft_color::swatch::NONE { st.stroke_weight } else { 0.0 };
|
|
bounds = union(bounds, bp.bounding_box().inflate(sw, sw));
|
|
}
|
|
for (_, _, r) in underlines.iter().chain(&strikes) {
|
|
bounds = union(bounds, *r);
|
|
}
|
|
LineGlyphs { bounds, runs, underlines, strikes, glyphs }
|
|
}
|
|
|
|
fn build(cs: &ComposedStory, ft: &FrameText) -> FrameGlyphs {
|
|
let db = FontDb::global();
|
|
let lines: Vec<LineGlyphs> = ft.lines.iter().map(|l| build_line(db, cs, l, ft.vertical)).collect();
|
|
let elements = lines.iter().flat_map(|l| &l.runs).map(|(_, bp)| bp.elements().len()).sum();
|
|
FrameGlyphs { lines, elements }
|
|
}
|
|
|
|
/// Conservative frame-space box of a line from its metrics (no outlines needed).
|
|
fn line_box(l: &Line) -> Option<Rect> {
|
|
let first = l.glyphs.first()?;
|
|
let x0 = l.glyphs.iter().map(|g| g.x).fold(first.x, f64::min);
|
|
let x1 = l.glyphs.iter().map(|g| g.x + g.adv.max(0.0)).fold(l.end_x, f64::max);
|
|
let pad = l.ascent.max(1.0);
|
|
// A drop cap reaches down past its line.
|
|
let bottom = l.drop_cap.map_or(l.baseline + l.descent.max(0.0), |dc| dc.rect.y1.max(l.baseline + l.descent.max(0.0)));
|
|
Some(Rect::new(x0 - pad, l.baseline - l.ascent - pad, x1 + pad, bottom + pad))
|
|
}
|
|
|
|
impl Renderer {
|
|
pub(crate) fn draw_text(&mut self, ctx: &mut RenderContext, f: &Frame, cs: &Arc<ComposedStory>, ft: &FrameText, xf: Affine) {
|
|
let doc = f.doc;
|
|
let m = f.view * xf;
|
|
// Visible area in frame space.
|
|
if xf.determinant().abs() < 1e-12 {
|
|
return;
|
|
}
|
|
let vis = xf.inverse().transform_rect_bbox(f.visible);
|
|
// Decorations under text (shading) and rules.
|
|
for d in &ft.decos {
|
|
if !rect_overlaps(d.rect, vis) || d.nonprinting && f.opts.printing_only {
|
|
continue;
|
|
}
|
|
if let Some(c) = doc.resolve_color(&d.color, d.tint) {
|
|
ctx.set_transform(m);
|
|
ctx.set_paint(color_of(&c, 1.0));
|
|
match &d.path {
|
|
Some(p) => ctx.fill_path(p),
|
|
None => ctx.fill_rect(&d.rect),
|
|
}
|
|
}
|
|
}
|
|
if !ft.tables.is_empty() {
|
|
self.draw_tables(ctx, f, ft, xf);
|
|
}
|
|
// Text in fonts that aren't installed: pink behind the glyphs (screen only).
|
|
if f.opts.highlight_missing_fonts && cs.styles.iter().any(|s| s.missing_font) {
|
|
ctx.set_transform(m);
|
|
ctx.set_paint(screen_color([255, 166, 214], 255));
|
|
for l in &ft.lines {
|
|
for g in l.glyphs.iter().filter(|g| g.adv > 0.0 && cs.styles.get(g.style as usize).is_some_and(|s| s.missing_font)) {
|
|
ctx.fill_rect(&kurbo::Rect::new(g.x, l.baseline - l.ascent, g.x + g.adv, l.baseline + l.descent));
|
|
}
|
|
}
|
|
}
|
|
if f.opts.highlight_keeps && ft.lines.iter().any(|l| l.keep_violation) {
|
|
ctx.set_transform(m);
|
|
ctx.set_paint(screen_color([255, 236, 120], 255));
|
|
for l in ft.lines.iter().filter(|l| l.keep_violation) {
|
|
ctx.fill_rect(&kurbo::Rect::new(l.x0, l.baseline - l.ascent, l.x1, l.baseline + l.descent));
|
|
}
|
|
}
|
|
if f.opts.highlight_hj && ft.lines.iter().any(|l| l.hj > 0) {
|
|
ctx.set_transform(m);
|
|
for l in ft.lines.iter().filter(|l| l.hj > 0) {
|
|
let shade = [0u8, 0xF6, 0xEA, 0xD8][l.hj.min(3) as usize];
|
|
ctx.set_paint(screen_color([255, shade, [0u8, 0xB0, 0x70, 0x30][l.hj.min(3) as usize]], 255));
|
|
ctx.fill_rect(&kurbo::Rect::new(l.x0, l.baseline - l.ascent, l.end_x.max(l.x0 + 1.0), l.baseline + l.descent));
|
|
}
|
|
}
|
|
if f.opts.highlight_custom_tracking && cs.styles.iter().any(|s| s.custom_tracking) {
|
|
ctx.set_transform(m);
|
|
ctx.set_paint(screen_color([176, 236, 176], 255));
|
|
for l in &ft.lines {
|
|
for g in l.glyphs.iter().filter(|g| g.adv > 0.0 && cs.styles.get(g.style as usize).is_some_and(|s| s.custom_tracking)) {
|
|
ctx.fill_rect(&kurbo::Rect::new(g.x, l.baseline - l.ascent, g.x + g.adv, l.baseline + l.descent));
|
|
}
|
|
}
|
|
}
|
|
if f.opts.tag_markers && cs.styles.iter().any(|s| s.xml_tag.is_some()) {
|
|
ctx.set_transform(m);
|
|
let px = 1.0 / m.determinant().abs().sqrt().max(1e-9);
|
|
for l in &ft.lines {
|
|
let tag_of = |g: &designcraft_compose::PlacedGlyph| cs.styles.get(g.style as usize).and_then(|s| s.xml_tag.clone());
|
|
let gs: Vec<_> = l.glyphs.iter().filter(|g| g.len > 0).collect();
|
|
let mut i = 0;
|
|
while i < gs.len() {
|
|
let Some(tag) = tag_of(gs[i]) else {
|
|
i += 1;
|
|
continue;
|
|
};
|
|
let mut j = i + 1;
|
|
while j < gs.len() && tag_of(gs[j]).as_deref() == Some(tag.as_str()) {
|
|
j += 1;
|
|
}
|
|
let c = f.doc.xml.tags.iter().find(|t| t.name == tag).map_or([100, 100, 220], |t| t.color);
|
|
ctx.set_paint(screen_color([c[0], c[1], c[2]], 255));
|
|
let (x0, x1) = (gs[i].x, gs[j - 1].x + gs[j - 1].adv);
|
|
let (top, bot) = (l.baseline - l.ascent, l.baseline + l.descent);
|
|
let (w, t) = (2.5 * px, px.max(0.3));
|
|
// [ before the element, ] after it.
|
|
for (x, dir) in [(x0, 1.0), (x1, -1.0)] {
|
|
ctx.fill_rect(&kurbo::Rect::new(x - t / 2.0, top, x + t / 2.0, bot));
|
|
for y in [top, bot - t] {
|
|
let (a, b) = if dir > 0.0 { (x, x + w) } else { (x - w, x) };
|
|
ctx.fill_rect(&kurbo::Rect::new(a, y, b, y + t));
|
|
}
|
|
}
|
|
i = j;
|
|
}
|
|
}
|
|
}
|
|
if f.opts.change_markup && cs.styles.iter().any(|s| s.inserted) {
|
|
ctx.set_transform(m);
|
|
for l in &ft.lines {
|
|
for g in l.glyphs.iter().filter(|g| g.adv > 0.0 && cs.styles.get(g.style as usize).is_some_and(|s| s.inserted)) {
|
|
ctx.set_paint(screen_color([120, 190, 255], 110));
|
|
ctx.fill_rect(&kurbo::Rect::new(g.x, l.baseline - l.ascent, g.x + g.adv, l.baseline + l.descent));
|
|
}
|
|
}
|
|
}
|
|
if f.opts.note_indicators
|
|
&& let Some(st) = f.doc.story(cs.story).filter(|st| !st.editorial.is_empty())
|
|
{
|
|
// A small flag at each note anchor, in the notes' amber.
|
|
ctx.set_transform(m);
|
|
ctx.set_paint(screen_color([232, 160, 32], 255));
|
|
for l in &ft.lines {
|
|
for g in l.glyphs.iter().filter(|g| st.text.get(g.byte..).is_some_and(|t| t.starts_with(designcraft_doc::NOTE_MARK))) {
|
|
let h = l.ascent.max(4.0);
|
|
let mut p = BezPath::new();
|
|
p.move_to((g.x - h * 0.25, l.baseline - h));
|
|
p.line_to((g.x + h * 0.25, l.baseline - h));
|
|
p.line_to((g.x, l.baseline - h * 0.55));
|
|
p.close_path();
|
|
ctx.fill_path(&p);
|
|
ctx.fill_rect(&kurbo::Rect::new(g.x - h * 0.03, l.baseline - h * 0.6, g.x + h * 0.03, l.baseline + l.descent * 0.5));
|
|
}
|
|
}
|
|
}
|
|
if f.opts.condition_indicators && !f.doc.conditions.is_empty() && cs.styles.iter().any(|s| s.condition.is_some()) {
|
|
ctx.set_transform(m);
|
|
let px = 1.0 / m.determinant().abs().sqrt().max(1e-9);
|
|
for l in &ft.lines {
|
|
for g in l.glyphs.iter().filter(|g| g.visible && g.adv > 0.0) {
|
|
let Some(name) = cs.styles.get(g.style as usize).and_then(|s| s.condition.as_deref()) else { continue };
|
|
let Some(c) = f.doc.conditions.iter().find(|c| c.name == name) else { continue };
|
|
ctx.set_paint(screen_color([c.color[0], c.color[1], c.color[2]], 255));
|
|
let y = l.baseline + l.descent * 0.6;
|
|
ctx.fill_rect(&kurbo::Rect::new(g.x, y, g.x + g.adv, y + 2.0 * px));
|
|
}
|
|
}
|
|
}
|
|
let scale = m.determinant().abs().sqrt();
|
|
let greek_px = f.opts.greek_below_px;
|
|
let mut greek = BezPath::new();
|
|
let mut shown: Vec<usize> = Vec::new();
|
|
for (i, l) in ft.lines.iter().enumerate() {
|
|
let Some(b) = line_box(l) else { continue };
|
|
if !rect_overlaps(b, vis) {
|
|
continue;
|
|
}
|
|
if greek_px > 0.0 && l.ascent * scale < greek_px {
|
|
if let Some(a) = l.glyphs.first() {
|
|
let r = kurbo::Rect::new(a.x, l.baseline - l.ascent * 0.5, l.end_x, l.baseline);
|
|
if r.width() > 0.0 {
|
|
greek.extend(r.path_elements(0.1));
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
shown.push(i);
|
|
}
|
|
ctx.set_transform(m);
|
|
if !shown.is_empty() {
|
|
let fg = self.glyphs.get(cs, ft);
|
|
// Resolve each style's paints once per frame; gradients span the frame.
|
|
let area = text_area(doc, ft);
|
|
let mut fills: Vec<Option<Option<TextPaint>>> = vec![None; cs.styles.len()];
|
|
let mut fill_of = |si: u32| -> Option<TextPaint> {
|
|
fills[si as usize]
|
|
.get_or_insert_with(|| {
|
|
let st = &cs.styles[si as usize];
|
|
TextPaint::of(doc, &st.fill, st.fill_tint)
|
|
})
|
|
.clone()
|
|
};
|
|
shown.retain(|&i| fg.lines[i].bounds.is_some_and(|b| rect_overlaps(b, vis)));
|
|
// Paint all underlines before any glyphs: skewed runs and tightly spaced lines
|
|
// can overlap a later run's rule. A per-run paint pass would still cover ink.
|
|
for &i in &shown {
|
|
for (sw, tint, r) in &fg.lines[i].underlines {
|
|
if let Some(c) = doc.resolve_color(sw, *tint) {
|
|
ctx.set_paint(color_of(&c, 1.0));
|
|
ctx.fill_rect(r);
|
|
}
|
|
}
|
|
}
|
|
for &i in &shown {
|
|
let lg = &fg.lines[i];
|
|
self.stats.glyphs += lg.glyphs;
|
|
for (si, bp) in &lg.runs {
|
|
let st = &cs.styles[*si as usize];
|
|
let fill = fill_of(*si).map(|c| (c, crate::overprints(f, &st.fill, st.fill_tint, st.overprint_fill)));
|
|
let stroke = stroke_of(doc, st).map(|c| (c, crate::overprints(f, &st.stroke, st.stroke_tint, st.overprint_stroke)));
|
|
paint_glyphs(ctx, doc, area, bp, fill, stroke, st.stroke_weight, st.stroke_behind_fill);
|
|
}
|
|
}
|
|
for &i in &shown {
|
|
for (sw, tint, r) in &fg.lines[i].strikes {
|
|
if let Some(c) = doc.resolve_color(sw, *tint) {
|
|
ctx.set_paint(color_of(&c, 1.0));
|
|
ctx.fill_rect(r);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if !greek.elements().is_empty() {
|
|
ctx.set_paint(color_of(&designcraft_color::Color::gray(0.35), 0.5));
|
|
ctx.fill_path(&greek);
|
|
}
|
|
for n in &ft.notes {
|
|
if let Some(nft) = n.text.frames.first() {
|
|
self.draw_text(ctx, f, &n.text, nft, xf * Affine::translate(n.origin.to_vec2()));
|
|
}
|
|
}
|
|
// Anchored objects ride on their lines.
|
|
for o in &ft.objects {
|
|
self.draw_item(ctx, f, &o.object.item, xf * Affine::translate(o.origin.to_vec2()), ShownOn::Own);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Renderer {
|
|
/// Table fragments: cell fills, cell text, then cell edges and the border.
|
|
fn draw_tables(&mut self, ctx: &mut RenderContext, f: &Frame, ft: &FrameText, xf: Affine) {
|
|
let doc = f.doc;
|
|
for t in &ft.tables {
|
|
for c in &t.cells {
|
|
if let Some((sw, tint)) = &c.fill
|
|
&& let Some(col) = doc.resolve_color(sw, *tint)
|
|
{
|
|
ctx.set_transform(f.view * xf);
|
|
ctx.set_paint(color_of(&col, 1.0));
|
|
// Overlap neighbours by half a device pixel so adjacent fills show no seams.
|
|
let h = 0.5 * f.px;
|
|
ctx.fill_rect(&c.rect.inflate(h, h));
|
|
}
|
|
}
|
|
for c in &t.cells {
|
|
if let Some(g) = &c.graphic {
|
|
ctx.set_transform(f.view * xf);
|
|
ctx.push_clip_layer(&c.clip.to_path(0.1));
|
|
self.draw_graphic(ctx, f, g, xf * Affine::translate((c.clip.x0, c.clip.y0)));
|
|
ctx.set_transform(f.view * xf);
|
|
ctx.pop_layer();
|
|
} else if let Some(cft) = c.text.frames.first() {
|
|
self.draw_text(ctx, f, &c.text, cft, xf * Affine::translate(c.origin.to_vec2()));
|
|
}
|
|
}
|
|
ctx.set_transform(f.view * xf);
|
|
for s in &t.strokes {
|
|
let Some(col) = doc.resolve_color(&s.stroke.color, s.stroke.tint) else { continue };
|
|
let kind = doc.stroke_kind(&s.stroke.kind);
|
|
let line = kurbo::Line::new(s.a, s.b).to_path(0.1);
|
|
// Butt-ended fills close the table's corners the way square caps do.
|
|
let (ca, cb) = t.corner_capped(s);
|
|
let capped = kurbo::Line::new(ca, cb).to_path(0.1);
|
|
// Gap colour under dashes, dots and stripes: the whole edge, solid.
|
|
if !matches!(kind, designcraft_doc::StrokeType::Solid)
|
|
&& let Some(gap) = doc.resolve_color(&s.stroke.gap_color, s.stroke.gap_tint)
|
|
{
|
|
ctx.set_paint(color_of(&gap, 1.0));
|
|
ctx.set_stroke(kurbo::Stroke::new(s.stroke.weight).with_caps(kurbo::Cap::Butt));
|
|
ctx.stroke_path(&capped);
|
|
}
|
|
ctx.set_paint(color_of(&col, 1.0));
|
|
// Stripes, wavy and hash types are fills along the edge.
|
|
if let Some(o) = kind.outline(&capped, s.stroke.weight, 0.05 * f.px) {
|
|
ctx.fill_path(&o);
|
|
continue;
|
|
}
|
|
ctx.set_stroke(cell_stroke(&kind, s.stroke.weight, s.a.distance(s.b)));
|
|
ctx.stroke_path(&line);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A run's stroke colour, if it has one.
|
|
fn stroke_of(doc: &designcraft_doc::Document, st: &designcraft_compose::RunStyle) -> Option<TextPaint> {
|
|
if st.stroke == designcraft_color::swatch::NONE {
|
|
return None;
|
|
}
|
|
TextPaint::of(doc, &st.stroke, st.stroke_tint)
|
|
}
|
|
|
|
/// Run `paint` in a Multiply layer when `overprint` is set.
|
|
fn overprinting(ctx: &mut RenderContext, overprint: bool, paint: impl FnOnce(&mut RenderContext)) {
|
|
if overprint {
|
|
ctx.push_layer(None, Some(peniko::BlendMode::new(peniko::Mix::Multiply, peniko::Compose::SrcOver)), None, None, None);
|
|
}
|
|
paint(ctx);
|
|
if overprint {
|
|
ctx.pop_layer();
|
|
}
|
|
}
|
|
|
|
/// Paint glyph outlines: the fill, then the stroke over it, each multiplied when it overprints
|
|
/// (`(colour, overprint)`). With stroke behind fill a double-width stroke goes first and the fill
|
|
/// covers its inner half; with no fill to cover it, the glyph shapes are cut out of the stroke
|
|
/// instead.
|
|
#[allow(clippy::too_many_arguments)]
|
|
fn paint_glyphs(
|
|
ctx: &mut RenderContext,
|
|
doc: &designcraft_doc::Document,
|
|
area: Rect,
|
|
bp: &BezPath,
|
|
fill: Option<(TextPaint, bool)>,
|
|
stroke: Option<(TextPaint, bool)>,
|
|
weight: f64,
|
|
behind: bool,
|
|
) {
|
|
// A gradient paint runs across `area`; reset its transform after each use.
|
|
let paint_fill = |ctx: &mut RenderContext| {
|
|
let Some((c, overprint)) = &fill else { return };
|
|
overprinting(ctx, *overprint, |ctx| {
|
|
c.set(ctx, doc, area);
|
|
ctx.fill_path(bp);
|
|
ctx.reset_paint_transform();
|
|
});
|
|
};
|
|
let Some((sc, stroke_overprint)) = stroke else {
|
|
paint_fill(ctx);
|
|
return;
|
|
};
|
|
let paint_stroke = |ctx: &mut RenderContext, width: f64| {
|
|
overprinting(ctx, stroke_overprint, |ctx| {
|
|
sc.set(ctx, doc, area);
|
|
ctx.set_stroke(kurbo::Stroke::new(width));
|
|
ctx.stroke_path(bp);
|
|
ctx.reset_paint_transform();
|
|
});
|
|
};
|
|
if !behind {
|
|
paint_fill(ctx);
|
|
paint_stroke(ctx, weight);
|
|
return;
|
|
}
|
|
if fill.is_some() {
|
|
paint_stroke(ctx, weight * 2.0);
|
|
paint_fill(ctx);
|
|
} else {
|
|
overprinting(ctx, stroke_overprint, |ctx| {
|
|
ctx.push_layer(None, None, None, None, None);
|
|
sc.set(ctx, doc, area);
|
|
ctx.set_stroke(kurbo::Stroke::new(weight * 2.0));
|
|
ctx.stroke_path(bp);
|
|
ctx.push_layer(None, Some(peniko::BlendMode::new(peniko::Mix::Normal, peniko::Compose::DestOut)), None, None, None);
|
|
ctx.fill_path(bp);
|
|
ctx.pop_layer();
|
|
ctx.pop_layer();
|
|
ctx.reset_paint_transform();
|
|
});
|
|
}
|
|
}
|
|
|
|
/// Kurbo stroke for a table edge `length` points long of a resolved stroke type.
|
|
pub(crate) fn cell_stroke(kind: &designcraft_doc::StrokeType, weight: f64, length: f64) -> kurbo::Stroke {
|
|
use designcraft_doc::StrokeType;
|
|
let st = kurbo::Stroke::new(weight).with_caps(kurbo::Cap::Square);
|
|
match kind {
|
|
StrokeType::Dashed { pattern } if StrokeType::expandable_dashes(pattern, length) => {
|
|
st.with_caps(kurbo::Cap::Butt).with_dashes(0.0, pattern.iter().copied())
|
|
}
|
|
StrokeType::Dotted if StrokeType::expandable_dashes(&[0.0, weight * 2.0], length) => {
|
|
st.with_dashes(0.0, [0.0, weight * 2.0]).with_caps(kurbo::Cap::Round)
|
|
}
|
|
_ => st,
|
|
}
|
|
}
|
|
|
|
impl Renderer {
|
|
/// Type on a path: glyphs follow the frame's path.
|
|
#[allow(clippy::too_many_arguments)]
|
|
pub(crate) fn draw_path_text(
|
|
&mut self,
|
|
ctx: &mut RenderContext,
|
|
f: &Frame,
|
|
cs: &Arc<ComposedStory>,
|
|
ft: &FrameText,
|
|
xf: Affine,
|
|
path: &BezPath,
|
|
pt: &designcraft_doc::PathType,
|
|
) {
|
|
let doc = f.doc;
|
|
ctx.set_transform(f.view * xf);
|
|
// A gradient on type on a path spans the path's box.
|
|
let area = path.bounding_box();
|
|
for (si, bp) in designcraft_compose::path_glyphs(cs, ft, path, pt) {
|
|
let st = &cs.styles[si as usize];
|
|
let fill = TextPaint::of(doc, &st.fill, st.fill_tint).map(|c| (c, false));
|
|
paint_glyphs(ctx, doc, area, &bp, fill, stroke_of(doc, st).map(|c| (c, false)), st.stroke_weight, st.stroke_behind_fill);
|
|
self.stats.glyphs += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod cache_identity_tests {
|
|
use super::*;
|
|
|
|
fn composition() -> Arc<ComposedStory> {
|
|
Arc::new(ComposedStory { frames: vec![FrameText { frame: ItemId(1), ..Default::default() }], ..Default::default() })
|
|
}
|
|
|
|
fn rich_composition() -> (crate::Cache, Arc<ComposedStory>) {
|
|
let mut doc = designcraft_doc::Document::new(&Default::default());
|
|
for style in &mut doc.styles_mut().paragraph {
|
|
style.chars.underline = Some(true);
|
|
}
|
|
let layer = doc.default_layer();
|
|
let (_, sid) = doc
|
|
.add_text_frame(
|
|
designcraft_doc::SpreadRef::Doc(0),
|
|
Rect::new(36.0, 36.0, 300.0, 300.0),
|
|
layer,
|
|
"Visible decorated glyphs.",
|
|
designcraft_doc::ParaFormat::default(),
|
|
)
|
|
.unwrap();
|
|
let owner = crate::Cache::new();
|
|
let cs = owner.get(&doc, sid, None);
|
|
(owner, cs)
|
|
}
|
|
|
|
#[test]
|
|
fn cache_owns_weak_identity_and_reuses_live_glyphs() {
|
|
let cs = composition();
|
|
let mut cache = GlyphCache::default();
|
|
cache.tick();
|
|
let first = cache.get(&cs, &cs.frames[0]);
|
|
assert_eq!(Arc::strong_count(&cs), 1, "the glyph cache must not own the whole layout");
|
|
assert_eq!(Arc::weak_count(&cs), 1, "the glyph cache must still pin the allocation identity");
|
|
assert!(Arc::ptr_eq(&first, &cache.get(&cs, &cs.frames[0])));
|
|
assert_eq!(cache.len(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn make_mut_moves_to_a_new_cache_identity_without_reusing_old_paths() {
|
|
let mut cs = composition();
|
|
let old_address = Arc::as_ptr(&cs) as usize;
|
|
let mut cache = GlyphCache::default();
|
|
cache.tick();
|
|
let original_paths = cache.get(&cs, &cs.frames[0]);
|
|
Arc::make_mut(&mut cs).text_len = 5;
|
|
assert_ne!(Arc::as_ptr(&cs) as usize, old_address);
|
|
let new_paths = cache.get(&cs, &cs.frames[0]);
|
|
assert!(!Arc::ptr_eq(&original_paths, &new_paths));
|
|
assert_eq!(cache.len(), 2);
|
|
}
|
|
|
|
#[test]
|
|
fn in_flight_owner_keeps_layout_valid_then_releases_it_without_losing_outlines() {
|
|
let (origin, cs) = rich_composition();
|
|
let in_flight = cs.clone();
|
|
let lifetime = Arc::downgrade(&cs);
|
|
let mut cache = GlyphCache::default();
|
|
cache.tick();
|
|
let glyphs = cache.get(&cs, &cs.frames[0]);
|
|
assert!(glyphs.elements > 0);
|
|
let runs = glyphs.lines[0].runs.clone();
|
|
let underlines = glyphs.lines[0].underlines.clone();
|
|
assert!(!underlines.is_empty());
|
|
drop(cs);
|
|
origin.clear();
|
|
assert!(lifetime.upgrade().is_some());
|
|
assert!(!in_flight.styles.is_empty());
|
|
assert!(Arc::ptr_eq(&glyphs, &cache.get(&in_flight, &in_flight.frames[0])));
|
|
drop(in_flight);
|
|
assert!(lifetime.upgrade().is_none(), "only the real in-flight owner should keep the layout alive");
|
|
assert_eq!(glyphs.lines[0].runs, runs);
|
|
assert_eq!(glyphs.lines[0].underlines, underlines);
|
|
assert_eq!(cache.len(), 1, "no path eviction was needed");
|
|
}
|
|
|
|
#[test]
|
|
fn clearing_cache_releases_weak_identity_but_not_independently_owned_paths() {
|
|
let (origin, cs) = rich_composition();
|
|
let mut cache = GlyphCache::default();
|
|
cache.tick();
|
|
let glyphs = cache.get(&cs, &cs.frames[0]);
|
|
let runs = glyphs.lines[0].runs.clone();
|
|
assert!(glyphs.elements > 0);
|
|
assert_eq!(Arc::weak_count(&cs), 1);
|
|
cache.clear();
|
|
assert_eq!(Arc::weak_count(&cs), 0);
|
|
assert_eq!(cache.len(), 0);
|
|
origin.clear();
|
|
drop(cs);
|
|
assert_eq!(glyphs.lines[0].runs, runs);
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod rule_tests {
|
|
use super::*;
|
|
|
|
/// A tab is not drawn, but it is a character with an advance, and InDesign underlines it:
|
|
/// forms rule their fill-in lines with underlined tabs (`Name ⇥⇥⇥⇥, city ⇥⇥⇥⇥`). The bars
|
|
/// stopped at the last letter before each tab, so an imported form lost every writing line
|
|
/// (#1466).
|
|
#[test]
|
|
fn an_underline_runs_across_a_tab() {
|
|
let mut doc = designcraft_doc::Document::new(&Default::default());
|
|
for style in &mut doc.styles_mut().paragraph {
|
|
style.chars.underline = Some(true);
|
|
}
|
|
let layer = doc.default_layer();
|
|
let (_, sid) = doc
|
|
.add_text_frame(
|
|
designcraft_doc::SpreadRef::Doc(0),
|
|
Rect::new(36.0, 36.0, 400.0, 300.0),
|
|
layer,
|
|
"Name\tCity",
|
|
designcraft_doc::ParaFormat::default(),
|
|
)
|
|
.unwrap();
|
|
let owner = crate::Cache::new();
|
|
let cs = owner.get(&doc, sid, None);
|
|
let line = &cs.frames[0].lines[0];
|
|
let tab = line.glyphs.iter().find(|g| g.rendered_char == '\t').expect("the tab is placed on the line");
|
|
assert!(!tab.visible, "a tab draws nothing itself");
|
|
assert!(tab.adv > 1.0, "it advances to its stop: {}", tab.adv);
|
|
|
|
let mut cache = GlyphCache::default();
|
|
cache.tick();
|
|
let glyphs = cache.get(&cs, &cs.frames[0]);
|
|
let bars = &glyphs.lines[0].underlines;
|
|
assert_eq!(bars.len(), 1, "one bar across the line, not one before the tab and one after: {bars:?}");
|
|
let bar = bars[0].2;
|
|
assert!(bar.x0 <= tab.x + 0.5, "the bar starts at the text, not at the tab: {bar:?}");
|
|
assert!(bar.x1 >= tab.x + tab.adv - 0.5, "the bar covers the tab's width: {bar:?}, tab {} + {}", tab.x, tab.adv);
|
|
}
|
|
}
|