mirror of
https://github.com/storytold/photocraft.git
synced 2026-11-21 17:37:14 +00:00
1798 lines
81 KiB
Rust
1798 lines
81 KiB
Rust
//! Shaping and layout of a text layer's model into positioned glyphs (text-space pixels, y down,
|
||
//! first baseline of point text at y = 0).
|
||
//!
|
||
//! Each paragraph is shaped and line-broken by parley (HarfRust shaping, Unicode bidi and line
|
||
//! breaking); paragraphs are then stacked with Photoshop's rules: baseline-to-baseline distance =
|
||
//! the largest leading on the line (auto leading = paragraph factor × size), space before/after,
|
||
//! indents, and point-text alignment around the anchor.
|
||
//!
|
||
//! **Vertical type** (tategaki) is laid out in the same *line space* and then turned 90° clockwise
|
||
//! into text space: a line becomes a column running top to bottom, and successive columns advance
|
||
//! right to left. Within a column, CJK characters stay upright (centred on the column, placed with
|
||
//! the font's vertical metrics: `VORG`, `vhea`/`vmtx`, else the ideographic em box) and use the
|
||
//! font's vertical alternates (`vert`) for punctuation, brackets and the long-vowel mark; other
|
||
//! text (Latin, digits) runs rotated 90° clockwise, Photoshop's default. Lines, clusters, carets
|
||
//! and hit tests stay in line space; [`TextLayout::to_text`] / [`TextLayout::to_line`] convert.
|
||
|
||
use std::borrow::Cow;
|
||
use std::ops::Range;
|
||
|
||
use parley::{
|
||
Alignment, AlignmentOptions, FontData, FontFamily, FontFeatures, FontStyle, FontVariations, FontWeight, IndentOptions, Layout, LayoutContext,
|
||
PositionedLayoutItem, StyleProperty,
|
||
};
|
||
use photocraft_doc::TextLayer;
|
||
use photocraft_doc::text::{Caps, CharStyle, FontBaseline, Kerning, Orientation, ParagraphStyle, TextAlign, TextDirection, TextShape};
|
||
use skrifa::raw::types::Tag;
|
||
|
||
use crate::fonts::FontDb;
|
||
|
||
/// Photoshop synthesizes small caps for faces without an OpenType `smcp` table. Keep the same
|
||
/// readable hierarchy for every font instead of silently rendering lowercase text unchanged.
|
||
const SYNTHETIC_SMALL_CAPS_SCALE: f32 = 0.7;
|
||
|
||
/// Photoshop's default superscript / subscript size and position (Type preferences, stored in a
|
||
/// PSD's text resources as `SuperscriptSize` .583, `SuperscriptPosition` .333 and their
|
||
/// `Subscript` twins): the run is drawn at 58.3% of its size and moved by 33.3% of its size.
|
||
const SCRIPT_SIZE: f32 = 0.583;
|
||
const SCRIPT_POSITION: f32 = 0.333;
|
||
|
||
/// The style a run is drawn with: superscript and subscript shrink it and shift its baseline.
|
||
fn drawn_style(s: &mut CharStyle) {
|
||
let dir = match s.baseline {
|
||
FontBaseline::Normal => return,
|
||
FontBaseline::Superscript => 1.0,
|
||
FontBaseline::Subscript => -1.0,
|
||
};
|
||
s.baseline_shift_pt += dir * SCRIPT_POSITION * s.size_pt;
|
||
s.size_pt *= SCRIPT_SIZE;
|
||
}
|
||
|
||
/// Photoshop's default tab stops: every half inch, measured from the anchor of point text or the
|
||
/// left edge of a paragraph box. PSD type carries no custom tab stops, so these are the only ones.
|
||
pub const DEFAULT_TAB_STOP_PT: f32 = 36.0;
|
||
|
||
/// The rendering path for a `SmallCaps` character style.
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||
enum SmallCapsMode {
|
||
None,
|
||
OpenType,
|
||
Synthetic,
|
||
}
|
||
|
||
/// Index of the run containing byte offset `off`, given each run's start offset (non-decreasing):
|
||
/// the last run starting at or before `off`, or 0 when none does. Binary search, so a layer with
|
||
/// many runs doesn't make per-character lookups quadratic.
|
||
fn run_index_at(run_starts: &[usize], off: usize) -> usize {
|
||
run_starts.partition_point(|&s| s <= off).saturating_sub(1)
|
||
}
|
||
|
||
/// Whether the style's selected face has an `smcp` feature (a font load and GSUB parse).
|
||
fn probe_smcp(fonts: &mut FontDb, style: &CharStyle) -> bool {
|
||
#[cfg(test)]
|
||
SMCP_PROBES.with(|c| c.set(c.get() + 1));
|
||
fonts.selected_face_has_feature(&style.font_family, style.weight, style.italic, Tag::new(b"smcp"))
|
||
}
|
||
|
||
#[cfg(test)]
|
||
thread_local! {
|
||
static SMCP_PROBES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
|
||
}
|
||
|
||
fn small_caps_mode(caps: Caps, face_has_smcp: bool) -> SmallCapsMode {
|
||
match caps {
|
||
Caps::SmallCaps if face_has_smcp => SmallCapsMode::OpenType,
|
||
Caps::SmallCaps => SmallCapsMode::Synthetic,
|
||
_ => SmallCapsMode::None,
|
||
}
|
||
}
|
||
|
||
/// Index of the character run whose style a glyph uses, plus the vertical-type class of its
|
||
/// characters ([`VClass`] as `u8`; always 0 in horizontal type).
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq)]
|
||
pub struct RunBrush(pub u32, pub u8);
|
||
|
||
/// How a character is set in vertical type (a simplification of Unicode's
|
||
/// `Vertical_Orientation`, UAX #50).
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||
pub enum VClass {
|
||
/// Rotated 90° clockwise (Latin, digits, most symbols).
|
||
Rotate = 0,
|
||
/// Upright (ideographs, kana, Hangul, full-width forms, CJK punctuation such as 、。),
|
||
/// using a vertical alternate when the font has one.
|
||
Upright = 1,
|
||
/// Upright through its vertical alternate (brackets, the long-vowel mark, dashes); rotated
|
||
/// when the font has none.
|
||
AlternateOrRotate = 2,
|
||
}
|
||
|
||
/// The vertical-type class of a character.
|
||
pub fn vertical_class(c: char) -> VClass {
|
||
let u = c as u32;
|
||
let alt = matches!(
|
||
u,
|
||
0x2014..=0x2016
|
||
| 0x2025
|
||
| 0x2026
|
||
| 0x2329
|
||
| 0x232A
|
||
| 0x3008..=0x3011
|
||
| 0x3014..=0x301F
|
||
| 0x3030
|
||
| 0x30A0
|
||
| 0x30FC
|
||
| 0xFE59..=0xFE5E
|
||
| 0xFF08
|
||
| 0xFF09
|
||
| 0xFF0D
|
||
| 0xFF1A..=0xFF1E
|
||
| 0xFF3B
|
||
| 0xFF3D
|
||
| 0xFF3F
|
||
| 0xFF5B..=0xFF60
|
||
| 0xFFE3
|
||
);
|
||
if alt {
|
||
return VClass::AlternateOrRotate;
|
||
}
|
||
// Half-width katakana and Hangul rotate like other half-width text.
|
||
if (0xFF61..=0xFFDC).contains(&u) {
|
||
return VClass::Rotate;
|
||
}
|
||
let upright = crate::cjk::classify(c).is_some()
|
||
|| matches!(u, 0xA7 | 0xA9 | 0xAE | 0xB1 | 0xBC..=0xBE | 0xD7 | 0xF7 | 0x2E80..=0x2EFF | 0xFE10..=0xFE1F | 0xFE30..=0xFE4F | 0x1F000..=0x1FAFF);
|
||
if upright { VClass::Upright } else { VClass::Rotate }
|
||
}
|
||
|
||
/// How a placed glyph's outline is oriented in text space.
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||
pub enum GlyphOrient {
|
||
/// Horizontal type: origin on the baseline, outline upright.
|
||
#[default]
|
||
Horizontal,
|
||
/// Vertical type, upright: the origin is the glyph's horizontal origin (left end of its
|
||
/// advance, on its baseline); baseline shift moves it right.
|
||
Upright,
|
||
/// Vertical type, rotated 90° clockwise about its origin (the baseline runs downwards).
|
||
Rotated,
|
||
}
|
||
|
||
/// A font instance used by some glyphs.
|
||
#[derive(Clone, Debug)]
|
||
pub struct GlyphFace {
|
||
pub font: FontData,
|
||
/// Normalised variation coordinates (F2Dot14 bits).
|
||
pub coords: Vec<i16>,
|
||
pub size_px: f32,
|
||
/// Synthetic bold requested by font matching (face lacks the weight).
|
||
pub embolden: bool,
|
||
/// Synthetic oblique angle in degrees (face lacks italics).
|
||
pub skew_deg: f32,
|
||
}
|
||
|
||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||
pub struct PlacedGlyph {
|
||
pub face: u32,
|
||
pub id: u32,
|
||
/// Pen position (text space px): x along the baseline, y = baseline (before baseline shift).
|
||
pub x: f32,
|
||
pub y: f32,
|
||
/// Character run index (into [`TextLayout::styles`]).
|
||
pub style: u32,
|
||
/// Orientation of the outline (vertical type).
|
||
pub orient: GlyphOrient,
|
||
}
|
||
|
||
/// Underline/strikethrough rectangle (text space px).
|
||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||
pub struct DecorationRect {
|
||
pub x0: f32,
|
||
pub y0: f32,
|
||
pub x1: f32,
|
||
pub y1: f32,
|
||
pub style: u32,
|
||
}
|
||
|
||
/// A line (a column in vertical type) in line space: `x` runs along the line and `baseline` is the
|
||
/// cross-line position. In vertical type `baseline` is the column's centre line and
|
||
/// `ascent`/`descent` are the column's half widths on either side.
|
||
#[derive(Clone, Debug, PartialEq)]
|
||
pub struct LineInfo {
|
||
/// Byte range in the layer text (without the paragraph break).
|
||
pub range: Range<usize>,
|
||
pub baseline: f32,
|
||
/// Visual extent along the baseline.
|
||
pub x0: f32,
|
||
pub x1: f32,
|
||
pub ascent: f32,
|
||
pub descent: f32,
|
||
pub paragraph: usize,
|
||
}
|
||
|
||
/// A grapheme cluster (caret stops, hit testing, selection), in line space.
|
||
#[derive(Clone, Debug, PartialEq)]
|
||
pub struct ClusterInfo {
|
||
pub range: Range<usize>,
|
||
pub x: f32,
|
||
pub advance: f32,
|
||
pub line: usize,
|
||
pub rtl: bool,
|
||
}
|
||
|
||
/// Result of laying out a text layer.
|
||
#[derive(Clone, Debug, Default)]
|
||
pub struct TextLayout {
|
||
pub faces: Vec<GlyphFace>,
|
||
pub glyphs: Vec<PlacedGlyph>,
|
||
pub decorations: Vec<DecorationRect>,
|
||
pub lines: Vec<LineInfo>,
|
||
pub clusters: Vec<ClusterInfo>,
|
||
/// Resolved character styles (one per run of the layer).
|
||
pub styles: Vec<CharStyle>,
|
||
/// Pixels per point used (dpi / 72).
|
||
pub px_per_pt: f32,
|
||
/// Vertical type: line space is turned 90° clockwise into text space.
|
||
pub vertical: bool,
|
||
}
|
||
|
||
impl TextLayout {
|
||
/// Line space → text space: the identity for horizontal type; for vertical type the line
|
||
/// direction points down and the cross-line direction (towards the next line) points left.
|
||
pub fn to_text(&self, x: f32, y: f32) -> (f32, f32) {
|
||
if self.vertical { (-y, x) } else { (x, y) }
|
||
}
|
||
|
||
/// Text space → line space (inverse of [`Self::to_text`]).
|
||
pub fn to_line(&self, x: f32, y: f32) -> (f32, f32) {
|
||
if self.vertical { (y, -x) } else { (x, y) }
|
||
}
|
||
|
||
/// Logical bounds (x0, y0, x1, y1) of all lines, text space.
|
||
pub fn bounds(&self) -> Option<[f32; 4]> {
|
||
let b = self.line_bounds()?;
|
||
Some(if self.vertical { [-b[3], b[0], -b[1], b[2]] } else { b })
|
||
}
|
||
|
||
/// Logical bounds of all lines in line space (equal to [`Self::bounds`] for horizontal type).
|
||
pub fn line_bounds(&self) -> Option<[f32; 4]> {
|
||
self.lines.iter().fold(None, |acc, l| {
|
||
let r = [l.x0, l.baseline - l.ascent, l.x1, l.baseline + l.descent];
|
||
Some(match acc {
|
||
None => r,
|
||
Some(a) => [a[0].min(r[0]), a[1].min(r[1]), a[2].max(r[2]), a[3].max(r[3])],
|
||
})
|
||
})
|
||
}
|
||
|
||
/// Byte offset of the caret nearest to a text-space point.
|
||
pub fn hit_test(&self, x: f32, y: f32) -> usize {
|
||
let (x, y) = self.to_line(x, y);
|
||
self.hit_test_line(x, y)
|
||
}
|
||
|
||
/// The visual line nearest to a line-space ordinate, including its ascent and descent.
|
||
/// Pointer hit testing uses this even where adjacent lines share a caret byte offset.
|
||
fn closest_line(&self, y: f32) -> Option<(usize, &LineInfo)> {
|
||
self.lines.iter().enumerate().min_by(|a, b| {
|
||
let d = |l: &LineInfo| {
|
||
if y < l.baseline - l.ascent {
|
||
l.baseline - l.ascent - y
|
||
} else if y > l.baseline + l.descent {
|
||
y - l.baseline - l.descent
|
||
} else {
|
||
0.0
|
||
}
|
||
};
|
||
d(a.1).total_cmp(&d(b.1))
|
||
})
|
||
}
|
||
|
||
/// Byte offset of the caret nearest to a line-space point.
|
||
pub fn hit_test_line(&self, x: f32, y: f32) -> usize {
|
||
let Some((li, _)) = self.closest_line(y) else {
|
||
return 0;
|
||
};
|
||
self.hit_test_x_on_line(li, x)
|
||
}
|
||
|
||
fn hit_test_x_on_line(&self, line_index: usize, x: f32) -> usize {
|
||
let Some(line) = self.lines.get(line_index) else { return 0 };
|
||
let mut best = (f32::MAX, line.range.end);
|
||
for c in self.clusters.iter().filter(|c| c.line == line_index) {
|
||
let mid = c.x + c.advance / 2.0;
|
||
let (before, after) = if c.rtl { (c.range.end, c.range.start) } else { (c.range.start, c.range.end) };
|
||
let (dist, off) = if x < mid { ((x - c.x).abs(), before) } else { ((x - c.x - c.advance).abs(), after) };
|
||
if dist < best.0 {
|
||
best = (dist, off);
|
||
}
|
||
}
|
||
best.1
|
||
}
|
||
|
||
/// The caret for a byte offset as a text-space segment (its two end points).
|
||
pub fn caret_segment(&self, offset: usize) -> [(f32, f32); 2] {
|
||
let (x, top, bottom) = self.caret(offset);
|
||
[self.to_text(x, top), self.to_text(x, bottom)]
|
||
}
|
||
|
||
/// Caret geometry for a byte offset: (x, top, bottom) in line space (the same as text space
|
||
/// for horizontal type; see [`Self::caret_segment`]).
|
||
pub fn caret(&self, offset: usize) -> (f32, f32, f32) {
|
||
for c in &self.clusters {
|
||
if c.range.start == offset
|
||
&& let Some(l) = self.lines.get(c.line)
|
||
{
|
||
let x = if c.rtl { c.x + c.advance } else { c.x };
|
||
return (x, l.baseline - l.ascent, l.baseline + l.descent);
|
||
}
|
||
}
|
||
// End of a line (or empty line): after the last cluster of the line containing it.
|
||
let li = self.lines.iter().position(|l| offset >= l.range.start && offset <= l.range.end).unwrap_or(self.lines.len().saturating_sub(1));
|
||
match self.lines.get(li) {
|
||
Some(l) => {
|
||
let x = self
|
||
.clusters
|
||
.iter()
|
||
.filter(|c| c.line == li && c.range.end == offset)
|
||
.map(|c| if c.rtl { c.x } else { c.x + c.advance })
|
||
.next()
|
||
.unwrap_or(l.x1);
|
||
(x, l.baseline - l.ascent, l.baseline + l.descent)
|
||
}
|
||
None => (0.0, 0.0, 0.0),
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Byte offset of character `index` (the text length when `index` is past the end).
|
||
pub fn byte_index(text: &str, index: usize) -> usize {
|
||
text.char_indices().nth(index).map_or(text.len(), |(b, _)| b)
|
||
}
|
||
|
||
/// Character index of byte `byte`, floored to a char boundary so a bad offset never panics.
|
||
pub fn char_index(text: &str, byte: usize) -> usize {
|
||
let mut byte = byte.min(text.len());
|
||
while byte > 0 && !text.is_char_boundary(byte) {
|
||
byte -= 1;
|
||
}
|
||
text[..byte].chars().count()
|
||
}
|
||
|
||
/// Line containing a byte offset. At a shared wrap boundary the caret belongs to
|
||
/// the following line, while an offset at the end of the text stays on the last.
|
||
pub fn line_index(layout: &TextLayout, byte: usize) -> usize {
|
||
layout.lines.iter().rposition(|ln| byte >= ln.range.start && byte <= ln.range.end).unwrap_or_else(|| layout.lines.len().saturating_sub(1))
|
||
}
|
||
|
||
/// Nearest caret to a text-space point: character index and the line it sits on.
|
||
pub fn hit_char(layout: &TextLayout, text: &str, x: f32, y: f32) -> (usize, usize) {
|
||
let byte = layout.hit_test(x, y);
|
||
// At a soft-wrap boundary either visual line can share this byte offset. The
|
||
// pointer's line, not the caret's preferred (following) line, is authoritative.
|
||
let (_, line_y) = layout.to_line(x, y);
|
||
let line = layout.closest_line(line_y).map_or_else(|| line_index(layout, byte), |(index, _)| index);
|
||
(char_index(text, byte), line)
|
||
}
|
||
|
||
/// Text-space point inside the laid-out line boxes, expanded by `slop` px on every side.
|
||
pub fn text_point_inside(layout: &TextLayout, x: f32, y: f32, slop: f32) -> bool {
|
||
let slop = if slop.is_finite() { slop.max(0.0) } else { 0.0 };
|
||
layout.bounds().is_some_and(|b| x >= b[0] - slop && x <= b[2] + slop && y >= b[1] - slop && y <= b[3] + slop)
|
||
}
|
||
|
||
/// Character index of the word boundary before (`forward` is false) or after `idx`.
|
||
///
|
||
/// A word is a run of alphanumeric characters, the rule the Type tool has always used.
|
||
pub fn word_boundary(text: &str, idx: usize, forward: bool) -> usize {
|
||
let chars: Vec<char> = text.chars().collect();
|
||
let mut i = idx.min(chars.len());
|
||
if forward {
|
||
while i < chars.len() && !chars[i].is_alphanumeric() {
|
||
i += 1;
|
||
}
|
||
while i < chars.len() && chars[i].is_alphanumeric() {
|
||
i += 1;
|
||
}
|
||
} else {
|
||
while i > 0 && !chars[i - 1].is_alphanumeric() {
|
||
i -= 1;
|
||
}
|
||
while i > 0 && chars[i - 1].is_alphanumeric() {
|
||
i -= 1;
|
||
}
|
||
}
|
||
i
|
||
}
|
||
|
||
/// Caret on the neighbouring line (`dir` < 0 previous, otherwise next), keeping `x`
|
||
/// (line space: the position along the line). Past the first or last line the caret
|
||
/// goes to the start or end of the text. Line space is the same for both orientations,
|
||
/// so a column of vertical type steps the same way a line of horizontal type does.
|
||
pub fn line_step(layout: &TextLayout, text: &str, idx: usize, x: f32, dir: i32) -> usize {
|
||
let n = text.chars().count();
|
||
let idx = idx.min(n);
|
||
if layout.lines.is_empty() {
|
||
return idx;
|
||
}
|
||
let current_line = line_index(layout, byte_index(text, idx));
|
||
let target_line = if dir < 0 {
|
||
let Some(target) = current_line.checked_sub(1) else { return 0 };
|
||
target
|
||
} else {
|
||
let Some(target) = current_line.checked_add(1).filter(|target| *target < layout.lines.len()) else { return n };
|
||
target
|
||
};
|
||
char_index(text, layout.hit_test_x_on_line(target_line, x))
|
||
}
|
||
|
||
/// Line start (`end` false) or end for the line containing `idx`, as a character index.
|
||
pub fn line_edge(layout: &TextLayout, text: &str, idx: usize, end: bool) -> usize {
|
||
let n = text.chars().count();
|
||
let idx = idx.min(n);
|
||
let byte = byte_index(text, idx);
|
||
let line = layout.lines.get(line_index(layout, byte));
|
||
line.map_or(idx, |ln| char_index(text, if end { ln.range.end } else { ln.range.start }))
|
||
}
|
||
|
||
const LRM: &str = "\u{200E}";
|
||
const RLM: &str = "\u{200F}";
|
||
/// A line break inside a paragraph (Shift+Return), stored as U+0003 in PSD type.
|
||
pub(crate) const FORCED_LINE_BREAK: char = '\u{3}';
|
||
|
||
pub(crate) struct Layouter {
|
||
lcx: LayoutContext<RunBrush>,
|
||
optical: crate::optical::Cache,
|
||
}
|
||
|
||
/// A cluster of a line in visual order, for kerning.
|
||
struct KernSlot {
|
||
/// Index of the run in the paragraph layout.
|
||
run: usize,
|
||
/// Byte offset in the paragraph text.
|
||
start: usize,
|
||
first: Option<u32>,
|
||
last: Option<u32>,
|
||
font: FontData,
|
||
coords: Vec<i16>,
|
||
size: f32,
|
||
rtl: bool,
|
||
blank: bool,
|
||
/// Advance along the line (px, horizontal scale included).
|
||
advance: f32,
|
||
/// What horizontal scale adds to the shaped advance (px; negative below 100%).
|
||
growth: f32,
|
||
/// A tab, shaped as a space; it advances to the next tab stop.
|
||
tab: bool,
|
||
/// Vertical type, upright glyph (its outline doesn't run along the column).
|
||
upright: bool,
|
||
}
|
||
|
||
impl Layouter {
|
||
pub fn new() -> Self {
|
||
Self { lcx: LayoutContext::new(), optical: crate::optical::Cache::default() }
|
||
}
|
||
|
||
pub fn layout(&mut self, fonts: &mut FontDb, t: &TextLayer, dpi: f32) -> TextLayout {
|
||
let k = if dpi.is_finite() && dpi > 0.0 { dpi / 72.0 } else { 1.0 };
|
||
let runs = t.char_runs();
|
||
let paras = t.paragraph_runs();
|
||
let vertical = t.orientation == Orientation::Vertical;
|
||
let mut out = TextLayout { px_per_pt: k, vertical, ..Default::default() };
|
||
// Resolve families (PostScript names from PSDs, unknown families).
|
||
for r in &runs {
|
||
let mut s = r.style.clone();
|
||
if let Some(ps) = s.postscript_name.clone()
|
||
&& !fonts.faces(&s.font_family).iter().any(|f| f.postscript_name.as_deref() == Some(&ps))
|
||
{
|
||
let f = fonts.resolve_postscript(&ps);
|
||
// An exact face match wins; a guessed family only fills a missing family.
|
||
if f.exact || (!fonts.has_family(&s.font_family) && fonts.has_family(&f.family)) {
|
||
s.font_family = f.family;
|
||
s.weight = f.weight;
|
||
s.italic = f.italic;
|
||
}
|
||
}
|
||
// Drawn with a fallback for now; a host that serves this family fetches it (`served`).
|
||
if !fonts.has_family(&s.font_family) {
|
||
crate::served::request(&s.font_family);
|
||
}
|
||
fonts.select_named_face(&mut s);
|
||
drawn_style(&mut s);
|
||
out.styles.push(s);
|
||
}
|
||
let run_starts: Vec<usize> = runs
|
||
.iter()
|
||
.scan(0, |a, r| {
|
||
let s = *a;
|
||
*a += r.len;
|
||
Some(s)
|
||
})
|
||
.collect();
|
||
let style_at = |off: usize| run_index_at(&run_starts, off);
|
||
let para_starts: Vec<usize> = paras
|
||
.iter()
|
||
.scan(0, |a, r| {
|
||
let s = *a;
|
||
*a += r.len;
|
||
Some(s)
|
||
})
|
||
.collect();
|
||
let para_style_at = |off: usize| ¶s[para_starts.iter().rposition(|&s| s <= off).unwrap_or(0)].style;
|
||
|
||
let text = &t.text;
|
||
let (box_rect, is_box) = match t.shape {
|
||
TextShape::Box { x, y, width, height } => ((x, y, width, height), true),
|
||
// Path text is laid out as one point-text line, then bent onto the path. Area text
|
||
// places its own lines (`area` below).
|
||
TextShape::Point | TextShape::Path { .. } | TextShape::Area { .. } => ((0.0, 0.0, 0.0, 0.0), false),
|
||
};
|
||
// Area type: the shape its lines wrap inside. A path that encloses nothing (only from a
|
||
// hostile file; `type.fillPath` refuses one) lays out as point text.
|
||
let area = match &t.shape {
|
||
TextShape::Area { path } => crate::area::AreaShape::new(path, vertical),
|
||
_ => None,
|
||
};
|
||
// Box and area text wrap, align within their lines and hide what doesn't fit.
|
||
let wraps = is_box || area.is_some();
|
||
let mut prev_baseline: Option<f32> = None;
|
||
let mut pending_space = 0.0f32;
|
||
let mut stop = false;
|
||
// Fixed for the whole layout, and the font probe only matters for styles that use small
|
||
// caps. A real `smcp` substitution must receive lowercase source text; only the fallback
|
||
// path uppercases it and scales it down.
|
||
let small_caps: Vec<SmallCapsMode> = out
|
||
.styles
|
||
.iter()
|
||
.map(|style| match style.caps {
|
||
Caps::SmallCaps => small_caps_mode(style.caps, probe_smcp(fonts, style)),
|
||
_ => SmallCapsMode::None,
|
||
})
|
||
.collect();
|
||
for (pi, prange) in split_paragraphs(text).into_iter().enumerate() {
|
||
if stop {
|
||
break;
|
||
}
|
||
let ps = para_style_at(prange.start).clone();
|
||
let content_end = strip_break(text, &prange);
|
||
let content = &text[prange.start..content_end];
|
||
let prefix = match ps.direction {
|
||
TextDirection::Auto => "",
|
||
TextDirection::Ltr => LRM,
|
||
TextDirection::Rtl => RLM,
|
||
};
|
||
let mut ptext = String::with_capacity(prefix.len() + content.len());
|
||
ptext.push_str(prefix);
|
||
// Ranges in `ptext` for lowercase characters rendered as synthetic small caps.
|
||
// They have the same UTF-8 length as their uppercase form, so the layer's byte-based
|
||
// run and caret offsets remain unchanged.
|
||
let mut synthetic_small_caps: Vec<(Range<usize>, f32)> = Vec::new();
|
||
// Offsets in `ptext` of the spaces standing in for tabs.
|
||
let mut tabs: Vec<usize> = Vec::new();
|
||
let tab_px = DEFAULT_TAB_STOP_PT * k;
|
||
for (i, ch) in content.char_indices() {
|
||
// A forced line break ends the line but not the paragraph. The line breaker knows
|
||
// it as a newline, which has the same length, so text offsets don't move.
|
||
if ch == FORCED_LINE_BREAK {
|
||
ptext.push('\n');
|
||
continue;
|
||
}
|
||
// Imported PSD text can contain literal tab controls. Font shaping may
|
||
// render those as .notdef boxes; a space preserves the one-byte source
|
||
// and style/caret offsets while supplying a real whitespace advance. The space
|
||
// is widened to its tab stop after line breaking (`tab_px` below).
|
||
if ch == '\t' {
|
||
tabs.push(ptext.len());
|
||
ptext.push(' ');
|
||
continue;
|
||
}
|
||
let style = &out.styles[style_at(prange.start + i)];
|
||
let caps = style.caps;
|
||
if caps == Caps::AllCaps || small_caps[style_at(prange.start + i)] == SmallCapsMode::Synthetic {
|
||
let up: String = ch.to_uppercase().collect();
|
||
if up.len() == ch.len_utf8() {
|
||
ptext.push_str(&up);
|
||
if caps == Caps::SmallCaps && ch.is_lowercase() {
|
||
let end = ptext.len();
|
||
synthetic_small_caps.push((end - up.len()..end, style.size_pt * k * SYNTHETIC_SMALL_CAPS_SCALE));
|
||
}
|
||
continue;
|
||
}
|
||
}
|
||
ptext.push(ch);
|
||
}
|
||
let first_style = &out.styles[style_at(prange.start)];
|
||
let first_px = first_style.size_pt * k;
|
||
// Scripts the loaded fonts may lack (Arabic, Japanese, …): a host serving a font for them
|
||
// fetches it (`served`); it joins the fallback stack once it arrives.
|
||
crate::served::request_for_text(&ptext);
|
||
let fallback: Vec<String> = fonts.fallback_stack().map(str::to_string).collect();
|
||
let si0 = style_at(prange.start);
|
||
let si_end = run_starts.partition_point(|&rs| rs < content_end).max(si0 + 1).min(out.styles.len());
|
||
// Shapes the paragraph, each tab widened by its letter spacing in `tab_spacing` (px).
|
||
let build = |lcx: &mut LayoutContext<RunBrush>, fcx: &mut parley::FontContext, tab_spacing: &[f32]| -> Layout<RunBrush> {
|
||
let mut b = lcx.ranged_builder(fcx, &ptext, 1.0, false);
|
||
// Paragraph-start style as the default (covers the direction mark and empty
|
||
// paragraphs), then every run piece intersecting this paragraph.
|
||
for p in style_props(&out.styles[si0], k, &fallback, si0 as u32, small_caps[si0]) {
|
||
b.push_default(p);
|
||
}
|
||
// Paragraph text breaks a word wider than the box at the box edge, as Photoshop
|
||
// does (#6694): parley's default only breaks at UAX #14 opportunities and lets the
|
||
// word run out of the box. Point text has no width to overflow.
|
||
if is_box {
|
||
b.push_default(StyleProperty::OverflowWrap(parley::style::OverflowWrap::BreakWord));
|
||
}
|
||
for (ri, st) in out.styles.iter().enumerate().take(si_end).skip(si0) {
|
||
let rs = run_starts[ri];
|
||
let (a, z) = (rs.max(prange.start), (rs + runs[ri].len).min(content_end));
|
||
if a >= z {
|
||
continue;
|
||
}
|
||
let range = (a - prange.start + prefix.len())..(z - prange.start + prefix.len());
|
||
for p in style_props(st, k, &fallback, ri as u32, small_caps[ri]) {
|
||
b.push(p, range.clone());
|
||
}
|
||
if vertical {
|
||
// Upright pieces get the vertical alternates and their class in the brush.
|
||
let piece = ptext.get(range.clone()).unwrap_or("");
|
||
let mut seg: Option<(usize, VClass)> = None;
|
||
let flush = |b: &mut parley::RangedBuilder<'_, RunBrush>, from: usize, to: usize, cls: VClass| {
|
||
if cls == VClass::Rotate || from >= to {
|
||
return;
|
||
}
|
||
let mut feats = feature_list(st, small_caps[ri]);
|
||
feats.push("\"vert\" 1".into());
|
||
let r = (range.start + from)..(range.start + to);
|
||
b.push(StyleProperty::FontFeatures(FontFeatures::Source(Cow::Owned(feats.join(", ")))), r.clone());
|
||
b.push(StyleProperty::Brush(RunBrush(ri as u32, cls as u8)), r);
|
||
};
|
||
for (i, ch) in piece.char_indices() {
|
||
let cls = vertical_class(ch);
|
||
match seg {
|
||
Some((_, c)) if c == cls => {}
|
||
Some((from, c)) => {
|
||
flush(&mut b, from, i, c);
|
||
seg = Some((i, cls));
|
||
}
|
||
None => seg = Some((i, cls)),
|
||
}
|
||
}
|
||
if let Some((from, c)) = seg {
|
||
flush(&mut b, from, piece.len(), c);
|
||
}
|
||
}
|
||
}
|
||
for (range, size) in &synthetic_small_caps {
|
||
b.push(StyleProperty::FontSize(*size), range.clone());
|
||
}
|
||
// Korean breaks lines at spaces, between words, as Photoshop sets it; Unicode's
|
||
// default rules break between any two Hangul syllables, mid-word (#5959).
|
||
for range in hangul_runs(&ptext) {
|
||
b.push(StyleProperty::WordBreak(parley::WordBreak::KeepAll), range);
|
||
}
|
||
for (&at, &spacing) in tabs.iter().zip(tab_spacing) {
|
||
b.push(StyleProperty::LetterSpacing(spacing), at..at + 1);
|
||
}
|
||
b.build(&ptext)
|
||
};
|
||
let indent_start = ps.start_indent_pt * k;
|
||
let indent_end = ps.end_indent_pt * k;
|
||
let first_indent = ps.first_line_indent_pt * k;
|
||
// Box extent along the lines: width, or height for vertical type (columns).
|
||
let (line_origin, line_len) = if vertical { (box_rect.1, box_rect.3) } else { (box_rect.0, box_rect.2) };
|
||
let avail = if is_box { Some((line_len - indent_start - indent_end).max(1.0)) } else { None };
|
||
// Horizontal scale is applied after shaping, so paragraph text breaks at the box
|
||
// (or area span) width divided by it (#5565). Mixed scales break at the largest, so
|
||
// no line overflows the box.
|
||
let break_scale = if wraps {
|
||
(si0..si_end)
|
||
.filter(|&ri| {
|
||
let rs = run_starts.get(ri).copied().unwrap_or(0);
|
||
let end = rs.saturating_add(runs.get(ri).map_or(0, |r| r.len));
|
||
ri == si0 || (rs.max(prange.start) < end.min(content_end))
|
||
})
|
||
.filter_map(|ri| out.styles.get(ri))
|
||
.map(effective_horizontal_scale)
|
||
.fold(0.0f32, f32::max)
|
||
} else {
|
||
1.0
|
||
};
|
||
let break_scale = if break_scale > 0.0 { break_scale } else { 1.0 };
|
||
// Area type: the first row goes no higher than one leading (plus paragraph spacing)
|
||
// below the previous paragraph's last line.
|
||
let space_before = if prev_baseline.is_some() { ps.space_before_pt * k } else { 0.0 };
|
||
let area_from = |m: LineMetrics| match (&area, prev_baseline) {
|
||
(Some(_), Some(b)) => b + m.leading + pending_space + space_before,
|
||
(Some(a), None) => a.bounds[1] + m.ascent,
|
||
(None, _) => 0.0,
|
||
};
|
||
// Line-breaking passes left for this paragraph's area type (see `break_area`).
|
||
let area_budget = std::cell::Cell::new(MAX_AREA_PASSES);
|
||
let break_lines = |layout: &mut Layout<RunBrush>| -> (Vec<Slot>, bool) {
|
||
if first_indent != 0.0 {
|
||
layout.set_text_indent(first_indent / break_scale, IndentOptions::default());
|
||
}
|
||
let Some(a) = &area else {
|
||
layout.break_all_lines(avail.map(|a| a / break_scale));
|
||
return (Vec::new(), false);
|
||
};
|
||
// Plan every row with the paragraph's real line metrics (its tallest font and
|
||
// largest leading, measured on the unwrapped paragraph), so no wrapped line comes
|
||
// out taller than the row it was planned in and no second plan is needed.
|
||
layout.break_all_lines(None);
|
||
let m = area_metrics(layout, &out.styles, &ps, k, first_style, vertical);
|
||
break_area(layout, a, area_from(m), m, (indent_start, indent_end), first_px, break_scale, &area_budget)
|
||
};
|
||
// Paragraph text: a tab is never wider than a space plus one tab interval, so breaking
|
||
// lines at that width keeps the expanded tabs inside the box, but can wrap early.
|
||
// Break again with the tab widths that layout gives until they agree; if they don't
|
||
// settle, keep the safe layout.
|
||
let wide = if wraps { tab_px } else { 0.0 };
|
||
let mut layout = build(&mut self.lcx, &mut fonts.fcx, &vec![wide; tabs.len()]);
|
||
let (mut area_slots, mut area_full) = break_lines(&mut layout);
|
||
if wraps && !tabs.is_empty() {
|
||
let first = tab_widths(&layout, &tabs, &out.styles, indent_start, first_indent, tab_px);
|
||
let mut want: Vec<f32> = first.iter().map(|t| t.width).collect();
|
||
for _ in 0..4 {
|
||
let spacing: Vec<f32> = first.iter().zip(&want).map(|(t, w)| w / t.scale - (t.advance - tab_px)).collect();
|
||
let mut next = build(&mut self.lcx, &mut fonts.fcx, &spacing);
|
||
let (next_slots, next_full) = break_lines(&mut next);
|
||
let got: Vec<f32> = tab_widths(&next, &tabs, &out.styles, indent_start, first_indent, tab_px).iter().map(|t| t.width).collect();
|
||
if got.iter().zip(&want).all(|(a, b)| (a - b).abs() < 0.01) {
|
||
layout = next;
|
||
area_slots = next_slots;
|
||
area_full = next_full;
|
||
break;
|
||
}
|
||
want = got;
|
||
}
|
||
}
|
||
let alignment = if wraps {
|
||
match ps.align {
|
||
TextAlign::Left => Alignment::Left,
|
||
TextAlign::Center => Alignment::Center,
|
||
TextAlign::Right => Alignment::Right,
|
||
_ => Alignment::Justify,
|
||
}
|
||
} else {
|
||
Alignment::Left
|
||
};
|
||
layout.align(alignment, AlignmentOptions { align_when_overflowing: !wraps });
|
||
|
||
// Stack lines.
|
||
if prev_baseline.is_some() {
|
||
pending_space += ps.space_before_pt * k;
|
||
}
|
||
let nlines = layout.len();
|
||
for (li, line) in layout.lines().enumerate() {
|
||
// Area type: the slot the breaker gave this line.
|
||
let slot = area_slots.get(li).copied();
|
||
if area.is_some() && slot.is_none() {
|
||
stop = true;
|
||
break;
|
||
}
|
||
let m = *line.metrics();
|
||
let LineMetrics { ascent, descent, leading } = line_metrics(&line, &out.styles, &ps, k, first_style, vertical);
|
||
let baseline = match (slot, prev_baseline) {
|
||
(Some(s), _) => s.baseline,
|
||
// The first column's right edge touches the box's right edge.
|
||
// (In vertical type the ascent is half the column width.)
|
||
(None, None) if is_box && vertical => -(box_rect.0 + box_rect.2) + ascent,
|
||
// Photoshop's "first baseline: ascent": the top of the tallest ascender
|
||
// (height of 'd') touches the box top, not the font's hhea ascent.
|
||
(None, None) if is_box => box_rect.1 + first_ascent(&line).unwrap_or(ascent),
|
||
(None, None) => 0.0,
|
||
(None, Some(b)) => b + leading + pending_space,
|
||
};
|
||
pending_space = 0.0;
|
||
// Photoshop keeps a horizontal line whose baseline is inside the box and lets
|
||
// its descenders hang below the bottom edge (#1317: three 35 pt lines in a
|
||
// 91.3 pt box, the last baseline at 88). Requiring the descent to fit dropped
|
||
// that line.
|
||
let overflow = if vertical { baseline + descent > -box_rect.0 + 0.5 } else { baseline > box_rect.1 + box_rect.3 + 0.5 };
|
||
if is_box && overflow {
|
||
stop = true;
|
||
break;
|
||
}
|
||
prev_baseline = Some(baseline);
|
||
let last_line = li + 1 == nlines;
|
||
let adv = m.advance - m.trailing_whitespace;
|
||
let map = |o: usize| (prange.start + o.saturating_sub(prefix.len())).min(content_end);
|
||
|
||
// Kerning after each cluster (px), per run in visual cluster order: manual
|
||
// kerning plus optical pair kerning. Applied after shaping (like horizontal
|
||
// scale) in line space, so it moves the following glyphs, carets and the line
|
||
// extent; in vertical type that is along the column. Optical kerning measures
|
||
// horizontal outlines, so it applies to rotated (Latin) glyphs only there.
|
||
let mut slots: Vec<KernSlot> = Vec::new();
|
||
let mut line_runs: Vec<usize> = Vec::new();
|
||
for item in line.items() {
|
||
let PositionedLayoutItem::GlyphRun(gr) = item else {
|
||
continue;
|
||
};
|
||
let run = gr.run();
|
||
if line_runs.contains(&run.index()) {
|
||
continue;
|
||
}
|
||
line_runs.push(run.index());
|
||
let hs = out.styles.get(gr.style().brush.0 as usize).map_or(1.0, |st| if st.horizontal_scale > 0.0 { st.horizontal_scale } else { 1.0 });
|
||
for c in run.visual_clusters() {
|
||
let mut gl = c.glyphs();
|
||
let first = gl.next().map(|g| g.id);
|
||
let last = gl.last().map(|g| g.id).or(first);
|
||
slots.push(KernSlot {
|
||
run: run.index(),
|
||
start: c.text_range().start,
|
||
first,
|
||
last,
|
||
font: run.font().clone(),
|
||
coords: run.normalized_coords().to_vec(),
|
||
size: run.font_size(),
|
||
rtl: c.is_rtl(),
|
||
blank: first.is_none() || c.is_space_or_nbsp() || c.text_range().end <= prefix.len(),
|
||
upright: vertical && c.first_style().brush.1 != VClass::Rotate as u8,
|
||
advance: c.advance() * hs,
|
||
growth: c.advance() * (hs - 1.0),
|
||
tab: tabs.binary_search(&c.text_range().start).is_ok(),
|
||
});
|
||
}
|
||
}
|
||
let mut kern_px: Vec<f32> = vec![0.0; slots.len()];
|
||
for j in 0..slots.len().saturating_sub(1) {
|
||
let (a, b) = (&slots[j], &slots[j + 1]);
|
||
if a.start < prefix.len() {
|
||
continue;
|
||
}
|
||
let st = &out.styles[style_at(map(a.start))];
|
||
let next = &out.styles[style_at(map(b.start))];
|
||
let mut units = if st.kern.is_finite() { st.kern } else { 0.0 };
|
||
// Optical pairs: both characters optical (a mode change splits shaping
|
||
// runs, which ends automatic kerning, as with Metrics).
|
||
if st.kerning == Kerning::Optical
|
||
&& next.kerning == Kerning::Optical
|
||
&& st.kern == 0.0
|
||
&& next.kern == 0.0
|
||
&& !a.rtl
|
||
&& !b.rtl
|
||
&& !a.blank
|
||
&& !b.blank
|
||
&& !a.upright
|
||
&& !b.upright
|
||
&& a.font.data.id() == b.font.data.id()
|
||
&& a.font.index == b.font.index
|
||
&& a.coords == b.coords
|
||
&& (a.size - b.size).abs() < 1e-3
|
||
&& let (Some(l), Some(r)) = (a.last, b.first)
|
||
{
|
||
let coords: Vec<skrifa::instance::NormalizedCoord> =
|
||
a.coords.iter().map(|&c| skrifa::instance::NormalizedCoord::from_bits(c)).collect();
|
||
if let Some(k) = self.optical.pair(a.font.data.id(), a.font.data.as_ref(), a.font.index, &coords, l, r) {
|
||
units += k + crate::optical::size_adjust(st.size_pt);
|
||
}
|
||
}
|
||
kern_px[j] = units / 1000.0 * a.size;
|
||
}
|
||
// Tabs: the "kerning" after a tab takes the pen to the next stop, measured from
|
||
// the anchor or the box edge as if the line were left-aligned (alignment then
|
||
// moves the whole line).
|
||
let mut pos = indent_start + if li == 0 { first_indent } else { 0.0 };
|
||
let mut trailing_tabs = 0.0f32;
|
||
let mut trailing_growth = 0.0f32;
|
||
for (j, s) in slots.iter().enumerate() {
|
||
// Trailing whitespace is outside the line's extent (`adv`).
|
||
let trailing = s.blank && slots[j + 1..].iter().all(|n| n.blank);
|
||
if trailing {
|
||
trailing_growth += s.growth;
|
||
}
|
||
if s.tab {
|
||
kern_px[j] = next_tab_stop(pos, tab_px) - pos - s.advance;
|
||
if slots[j + 1..].iter().all(|n| n.blank) {
|
||
trailing_tabs += kern_px[j];
|
||
}
|
||
}
|
||
pos += s.advance + kern_px.get(j).copied().unwrap_or(0.0);
|
||
}
|
||
let line_kern: f32 = kern_px.iter().sum::<f32>() - trailing_tabs;
|
||
// Per run on the line: (run index, glyph → slot, glyphs emitted, first slot whose
|
||
// kerning isn't applied yet).
|
||
let mut cursors: Vec<(usize, Vec<usize>, usize, usize)> = Vec::new();
|
||
for item in line.items() {
|
||
let PositionedLayoutItem::GlyphRun(gr) = item else {
|
||
continue;
|
||
};
|
||
let run = gr.run();
|
||
if cursors.iter().any(|c| c.0 == run.index()) {
|
||
continue;
|
||
}
|
||
let base = slots.iter().position(|s| s.run == run.index()).unwrap_or(0);
|
||
let mut g2s = Vec::new();
|
||
for (ci, c) in run.visual_clusters().enumerate() {
|
||
g2s.extend(c.glyphs().map(|_| base + ci));
|
||
}
|
||
cursors.push((run.index(), g2s, 0, base));
|
||
}
|
||
// Parley aligned box lines without the kerning.
|
||
let kern_align = if wraps {
|
||
match ps.align {
|
||
TextAlign::Center => line_kern / 2.0,
|
||
TextAlign::Right => line_kern,
|
||
_ => 0.0,
|
||
}
|
||
} else {
|
||
0.0
|
||
};
|
||
// Box and area lines start at their box or span edge; the line's own width
|
||
// (`line_avail`) takes the justify-last-line slack.
|
||
let line_avail = slot.map(|s| s.width).or(avail);
|
||
let dx = if wraps {
|
||
let origin = slot.map_or(line_origin, |s| s.x);
|
||
let base = origin + indent_start - kern_align;
|
||
let slack = line_avail.unwrap_or(0.0) - adv * break_scale - line_kern;
|
||
// Parley aligned the unscaled line in `avail / break_scale`: scale its
|
||
// indent and alignment offset back to the box.
|
||
let scaled_offset = m.offset * (break_scale - 1.0);
|
||
base + if last_line {
|
||
match ps.align {
|
||
TextAlign::JustifyCenter => slack * 0.5 - m.offset,
|
||
TextAlign::JustifyRight => slack - m.offset,
|
||
_ => scaled_offset,
|
||
}
|
||
} else {
|
||
scaled_offset
|
||
}
|
||
} else {
|
||
let target = match ps.align {
|
||
TextAlign::Center | TextAlign::JustifyCenter => -(adv + line_kern) / 2.0,
|
||
TextAlign::Right | TextAlign::JustifyRight => -(adv + line_kern),
|
||
_ => indent_start,
|
||
};
|
||
target - m.offset
|
||
};
|
||
let justify_all = wraps && last_line && ps.align == TextAlign::JustifyAll;
|
||
let line_index = out.lines.len();
|
||
let lr = line.text_range();
|
||
let g0 = out.glyphs.len();
|
||
let c0 = out.clusters.len();
|
||
let mut vinfo: Vec<VGlyph> = Vec::new();
|
||
let mut extra = 0.0f32; // horizontal-scale growth and kerning along the line
|
||
let mut seen_runs: Vec<usize> = Vec::new();
|
||
for item in line.items() {
|
||
let PositionedLayoutItem::GlyphRun(gr) = item else {
|
||
continue;
|
||
};
|
||
let run = gr.run();
|
||
let si = gr.style().brush.0;
|
||
let st = &out.styles[si as usize];
|
||
let hs = if st.horizontal_scale > 0.0 { st.horizontal_scale } else { 1.0 };
|
||
let synth = run.synthesis();
|
||
let face = out.faces.len() as u32;
|
||
out.faces.push(GlyphFace {
|
||
font: run.font().clone(),
|
||
coords: run.normalized_coords().to_vec(),
|
||
size_px: run.font_size(),
|
||
embolden: synthetic_bold(synth.embolden(), st.weight, run.font_attrs().weight.value()),
|
||
skew_deg: synth.skew().unwrap_or(0.0),
|
||
});
|
||
let run_x0 = dx + gr.offset() + extra;
|
||
if !seen_runs.contains(&run.index()) {
|
||
seen_runs.push(run.index());
|
||
let mut cx = run_x0;
|
||
let base = slots.iter().position(|s| s.run == run.index()).unwrap_or(0);
|
||
for (ci, c) in run.visual_clusters().enumerate() {
|
||
let a = c.advance() * hs + kern_px.get(base + ci).copied().unwrap_or(0.0);
|
||
let r = c.text_range();
|
||
if r.end > prefix.len() || prefix.is_empty() {
|
||
out.clusters.push(ClusterInfo { range: map(r.start)..map(r.end), x: cx, advance: a, line: line_index, rtl: c.is_rtl() });
|
||
}
|
||
cx += a;
|
||
}
|
||
}
|
||
let rm = run.metrics();
|
||
let vm = if vertical { Some(VMetrics::new(run.font(), run.normalized_coords(), run.font_size())) } else { None };
|
||
let class = gr.style().brush.1;
|
||
// Glyphs of the run's own characters (not substituted by `vert`).
|
||
let plain: Vec<u32> = match (&vm, class) {
|
||
(Some(v), 2) => ptext.get(run.text_range()).unwrap_or("").chars().filter_map(|c| v.cmap(c)).collect(),
|
||
_ => Vec::new(),
|
||
};
|
||
let mut pen = gr.offset();
|
||
let mut cursor = cursors.iter_mut().find(|c| c.0 == run.index());
|
||
for g in gr.glyphs() {
|
||
// Kerning of the clusters before this glyph's cluster.
|
||
if let Some(c) = cursor.as_deref_mut() {
|
||
if let Some(&slot) = c.1.get(c.2) {
|
||
while c.3 < slot {
|
||
extra += kern_px.get(c.3).copied().unwrap_or(0.0);
|
||
c.3 += 1;
|
||
}
|
||
}
|
||
c.2 += 1;
|
||
}
|
||
out.glyphs.push(PlacedGlyph {
|
||
face,
|
||
id: g.id,
|
||
x: dx + pen + g.x + extra,
|
||
y: baseline + g.y,
|
||
style: si,
|
||
orient: GlyphOrient::Horizontal,
|
||
});
|
||
if let Some(v) = &vm {
|
||
let upright = class == 1 || (class == 2 && !plain.contains(&g.id));
|
||
vinfo.push(VGlyph {
|
||
upright,
|
||
advance: g.advance * hs,
|
||
origin: if upright { v.origin(g.id) } else { 0.0 },
|
||
// Rotated text is centred on the column: its baseline sits
|
||
// (ascent − descent) / 2 from the centre line.
|
||
centre: (rm.ascent - rm.descent) * 0.5,
|
||
});
|
||
}
|
||
extra += g.advance * (hs - 1.0);
|
||
pen += g.advance;
|
||
}
|
||
// The run's last glyph: its remaining clusters' kerning follows it.
|
||
if let Some(c) = cursor
|
||
&& c.2 >= c.1.len()
|
||
{
|
||
let end = slots.iter().rposition(|s| s.run == c.0).map_or(c.3, |p| p + 1);
|
||
while c.3 < end {
|
||
extra += kern_px.get(c.3).copied().unwrap_or(0.0);
|
||
c.3 += 1;
|
||
}
|
||
}
|
||
let run_x1 = dx + gr.offset() + gr.advance() + extra;
|
||
let shift = st.baseline_shift_pt * k;
|
||
if vertical {
|
||
// Underline to the right of the column, strikethrough through its centre
|
||
// (stored directly in text space).
|
||
let half = run.font_size() * 0.5;
|
||
let mut push = |v0: f32, v1: f32| out.decorations.push(DecorationRect { x0: -v1, y0: run_x0, x1: -v0, y1: run_x1, style: si });
|
||
if gr.style().underline.is_some() {
|
||
let v1 = baseline - half;
|
||
push(v1 - rm.underline_size.max(1.0), v1);
|
||
}
|
||
if gr.style().strikethrough.is_some() {
|
||
let sz = rm.strikethrough_size.max(1.0);
|
||
push(baseline - sz * 0.5, baseline + sz * 0.5);
|
||
}
|
||
} else if gr.style().underline.is_some() {
|
||
let y0 = baseline - rm.underline_offset - shift;
|
||
out.decorations.push(DecorationRect { x0: run_x0, y0, x1: run_x1, y1: y0 + rm.underline_size.max(1.0), style: si });
|
||
}
|
||
if !vertical && gr.style().strikethrough.is_some() {
|
||
let y0 = baseline - rm.strikethrough_offset - shift;
|
||
out.decorations.push(DecorationRect { x0: run_x0, y0, x1: run_x1, y1: y0 + rm.strikethrough_size.max(1.0), style: si });
|
||
}
|
||
}
|
||
if vertical {
|
||
extra -= squeeze_punctuation(text, &mut out.clusters[c0..], &mut out.glyphs[g0..]);
|
||
}
|
||
if justify_all {
|
||
let slack = line_avail.unwrap_or(0.0) - (adv + extra);
|
||
let n = out.clusters.len() - c0;
|
||
if n > 1 && slack > 0.0 {
|
||
let step = slack / (n - 1) as f32;
|
||
let starts: Vec<f32> = out.clusters[c0..].iter().map(|c| c.x).collect();
|
||
for (i, c) in out.clusters[c0..].iter_mut().enumerate() {
|
||
c.x += step * i as f32;
|
||
}
|
||
for g in &mut out.glyphs[g0..] {
|
||
let i = starts.iter().rposition(|&s| s <= g.x + 1e-3).unwrap_or(0);
|
||
g.x += step * i as f32;
|
||
}
|
||
extra += slack;
|
||
}
|
||
}
|
||
if vertical {
|
||
// Line space → text space (90° clockwise); upright glyphs centred on the column.
|
||
for (g, v) in out.glyphs[g0..].iter_mut().zip(&vinfo) {
|
||
let (u, cross) = (g.x, g.y);
|
||
if v.upright {
|
||
g.x = -baseline - v.advance * 0.5;
|
||
g.y = u + v.origin;
|
||
g.orient = GlyphOrient::Upright;
|
||
} else {
|
||
g.x = -(cross + v.centre);
|
||
g.y = u;
|
||
g.orient = GlyphOrient::Rotated;
|
||
}
|
||
}
|
||
}
|
||
let x0 = dx + m.offset;
|
||
out.lines.push(LineInfo {
|
||
range: map(lr.start)..map(lr.end).min(content_end),
|
||
baseline,
|
||
x0,
|
||
x1: x0 + adv + extra - trailing_tabs - trailing_growth,
|
||
ascent,
|
||
descent,
|
||
paragraph: pi,
|
||
});
|
||
}
|
||
if area_full {
|
||
// The shape is full: later paragraphs are hidden too.
|
||
stop = true;
|
||
}
|
||
pending_space += ps.space_after_pt * k;
|
||
}
|
||
out
|
||
}
|
||
}
|
||
|
||
/// A style's horizontal scale; unset (zero or negative) is 100%.
|
||
fn effective_horizontal_scale(st: &CharStyle) -> f32 {
|
||
if st.horizontal_scale > 0.0 && st.horizontal_scale.is_finite() { st.horizontal_scale } else { 1.0 }
|
||
}
|
||
|
||
/// The first tab stop after `pos` (px from the anchor or box edge); stops are `interval` apart.
|
||
fn next_tab_stop(pos: f32, interval: f32) -> f32 {
|
||
if interval > 0.0 && pos.is_finite() { ((pos + 1e-3) / interval).floor() * interval + interval } else { pos }
|
||
}
|
||
|
||
/// Where one line of area type goes: its baseline, the left edge of its span, and the width
|
||
/// it may fill (the span less the paragraph's indents), plus the row and span it came from.
|
||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||
struct Slot {
|
||
baseline: f32,
|
||
x: f32,
|
||
width: f32,
|
||
row: usize,
|
||
span: usize,
|
||
}
|
||
|
||
/// A line's ascent, descent and leading (px); for area type, the largest over a paragraph.
|
||
#[derive(Clone, Copy, Debug)]
|
||
struct LineMetrics {
|
||
ascent: f32,
|
||
descent: f32,
|
||
leading: f32,
|
||
}
|
||
|
||
/// Most line-breaking passes area type makes for one paragraph, over all its plans (each span
|
||
/// left empty for a word that doesn't fit costs a pass). Past it, words overflow their spans.
|
||
const MAX_AREA_PASSES: usize = 32;
|
||
/// Most rows one area paragraph is planned on.
|
||
const MAX_AREA_ROWS: usize = 4096;
|
||
|
||
#[cfg(test)]
|
||
thread_local! {
|
||
/// Area line-breaking passes made on this thread, for tests.
|
||
pub(crate) static AREA_PASSES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
|
||
}
|
||
|
||
/// The rows an area paragraph's lines go on: baselines from `next` down, one leading apart,
|
||
/// each with its spans left to right. They don't depend on the text, so they are found once
|
||
/// (lazily) and shared by every pass.
|
||
struct AreaRows<'a> {
|
||
area: &'a crate::area::AreaShape,
|
||
m: LineMetrics,
|
||
min_width: f32,
|
||
/// Where the search for the next row starts.
|
||
next: f32,
|
||
rows: Vec<(f32, Vec<(f32, f32)>)>,
|
||
done: bool,
|
||
}
|
||
|
||
impl AreaRows<'_> {
|
||
/// Row `i`: its baseline and spans; `None` past the shape.
|
||
fn get(&mut self, i: usize) -> Option<&(f32, Vec<(f32, f32)>)> {
|
||
while self.rows.len() <= i && !self.done {
|
||
match self.area.next_row(self.next, self.m.ascent, self.m.descent, self.min_width) {
|
||
Some((b, spans)) if self.rows.len() < MAX_AREA_ROWS => {
|
||
self.next = b + self.m.leading;
|
||
self.rows.push((b, spans));
|
||
}
|
||
_ => self.done = true,
|
||
}
|
||
}
|
||
self.rows.get(i)
|
||
}
|
||
|
||
/// The first span, from span `span` of row `row` on, that leaves at least `width` once
|
||
/// `inset` (the paragraph's indents) is taken off: its row and span.
|
||
fn first_fit(&mut self, row: usize, span: usize, width: f32, inset: f32) -> Option<(usize, usize)> {
|
||
let (mut r, mut first) = (row, span);
|
||
while let Some((_, spans)) = self.get(r) {
|
||
if let Some(j) = spans.iter().skip(first).position(|&(x0, x1)| x1 - x0 - inset + 0.5 >= width) {
|
||
return Some((r, first + j));
|
||
}
|
||
r += 1;
|
||
first = 0;
|
||
}
|
||
None
|
||
}
|
||
}
|
||
|
||
/// A line wider than the span it fell in, that a later span can hold: the line's index in the
|
||
/// paragraph, where its text starts, and its width.
|
||
#[derive(Clone, Copy, Debug)]
|
||
struct Need {
|
||
line: usize,
|
||
start: usize,
|
||
width: f32,
|
||
}
|
||
|
||
/// Breaks one paragraph of area type a line at a time, each line as wide as the next span the
|
||
/// shape leaves (rows from `from` down, spans left to right). Returns each line's slot and
|
||
/// whether text was left over because the shape ran out (hidden, like box overflow).
|
||
///
|
||
/// A span too narrow for the word that would start it (the narrow top of an ellipse) is left
|
||
/// empty and the word goes to the first later span that holds it, as Photoshop does. A word no
|
||
/// later span holds but another span of the shape would means the shape is full: it and the rest are
|
||
/// hidden. Only a word no span holds overflows its span. Parley doesn't report a line's
|
||
/// trailing whitespace while breaking, so overflowing lines are found after a pass and the
|
||
/// paragraph broken again; `budget` (shared by the paragraph's calls) bounds the passes.
|
||
///
|
||
/// Horizontal scale applies after shaping, so each line breaks at its span width divided by
|
||
/// `scale`; widths compared with spans are the scaled ones.
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn break_area(
|
||
layout: &mut Layout<RunBrush>,
|
||
area: &crate::area::AreaShape,
|
||
from: f32,
|
||
m: LineMetrics,
|
||
indents: (f32, f32),
|
||
min_width: f32,
|
||
scale: f32,
|
||
budget: &std::cell::Cell<usize>,
|
||
) -> (Vec<Slot>, bool) {
|
||
let inset = indents.0 + indents.1;
|
||
let mut rows = AreaRows { area, m, min_width, next: from, rows: Vec::new(), done: false };
|
||
// Every row of the shape from its top, whatever paragraph came before (found lazily).
|
||
let mut shape_rows = AreaRows { area, m, min_width, next: area.bounds[1], rows: Vec::new(), done: false };
|
||
let mut needs: Vec<Need> = Vec::new();
|
||
loop {
|
||
let (slots, overflow) = break_area_pass(layout, &mut rows, inset, scale, &needs);
|
||
budget.set(budget.get().saturating_sub(1));
|
||
// Each line's text start and scaled width without its trailing whitespace.
|
||
let lines: Vec<(usize, f32)> = layout
|
||
.lines()
|
||
.map(|l| {
|
||
let lm = l.metrics();
|
||
(l.text_range().start, (lm.advance - lm.trailing_whitespace) * scale)
|
||
})
|
||
.collect();
|
||
// A line still wider than its span that some span of the shape would hold: the shape ran
|
||
// out of room for it (the narrow bottom of a full bubble). It and the rest are hidden, as
|
||
// overflow; only a word no span holds overflows its span.
|
||
let mut ran_out = |slots: Vec<Slot>, overflow: bool| match lines
|
||
.iter()
|
||
.zip(&slots)
|
||
.position(|(&(_, width), s)| width > s.width + 0.5 && shape_rows.first_fit(0, 0, width, inset).is_some())
|
||
{
|
||
Some(li) => (slots.into_iter().take(li).collect(), true),
|
||
None => (slots, overflow),
|
||
};
|
||
if budget.get() == 0 {
|
||
return ran_out(slots, overflow);
|
||
}
|
||
// A line that now starts elsewhere (an earlier line changed) no longer needs its span.
|
||
let kept = needs.len();
|
||
needs.retain(|n| lines.get(n.line).is_some_and(|l| l.0 == n.start));
|
||
if needs.len() != kept {
|
||
continue;
|
||
}
|
||
let mut new = None;
|
||
for (li, (&(start, width), s)) in lines.iter().zip(&slots).enumerate() {
|
||
if width > s.width + 0.5 && !needs.iter().any(|n| n.line == li) && rows.first_fit(s.row, s.span + 1, width, inset).is_some() {
|
||
new = Some(Need { line: li, start, width });
|
||
break;
|
||
}
|
||
}
|
||
if let Some(n) = new {
|
||
needs.push(n);
|
||
continue;
|
||
}
|
||
return ran_out(slots, overflow);
|
||
}
|
||
}
|
||
|
||
/// One pass of [`break_area`]: each line in the next span, skipping spans too narrow for a
|
||
/// line in `needs` when a later span holds it.
|
||
fn break_area_pass(layout: &mut Layout<RunBrush>, rows: &mut AreaRows<'_>, inset: f32, scale: f32, needs: &[Need]) -> (Vec<Slot>, bool) {
|
||
#[cfg(test)]
|
||
AREA_PASSES.with(|c| c.set(c.get() + 1));
|
||
let mut slots: Vec<Slot> = Vec::new();
|
||
let mut br = layout.break_lines();
|
||
// Per-line widths below are never wider than this, as parley requires.
|
||
br.state_mut().set_layout_max_advance(f32::INFINITY);
|
||
let (mut row, mut span) = (0, 0);
|
||
let mut overflow = false;
|
||
while !br.is_done() {
|
||
let Some((baseline, spans)) = rows.get(row) else {
|
||
overflow = true;
|
||
break;
|
||
};
|
||
let baseline = *baseline;
|
||
let Some(&(x0, x1)) = spans.get(span) else {
|
||
row += 1;
|
||
span = 0;
|
||
continue;
|
||
};
|
||
let width = (x1 - x0 - inset).max(1.0);
|
||
// A line known to be too wide here moves on to the first span that holds it.
|
||
if let Some(w) = needs.iter().find(|n| n.line == slots.len()).map(|n| n.width)
|
||
&& w > width + 0.5
|
||
&& let Some((r, j)) = rows.first_fit(row, span + 1, w, inset)
|
||
{
|
||
(row, span) = (r, j);
|
||
continue;
|
||
}
|
||
br.state_mut().set_line_max_advance(width / scale);
|
||
if br.break_next().is_none() {
|
||
break;
|
||
}
|
||
// Parley aligns each line within the width it was broken at.
|
||
br.set_prior_line_width(width / scale);
|
||
slots.push(Slot { baseline, x: x0, width, row, span });
|
||
span += 1;
|
||
}
|
||
br.finish();
|
||
(slots, overflow)
|
||
}
|
||
|
||
/// One laid-out line's ascent, descent and leading, as the line loop stacks it. `fallback` is
|
||
/// the paragraph's first style, used for a line with no glyph runs.
|
||
fn line_metrics(line: &parley::Line<'_, RunBrush>, styles: &[CharStyle], ps: &ParagraphStyle, k: f32, fallback: &CharStyle, vertical: bool) -> LineMetrics {
|
||
let first_px = fallback.size_pt * k;
|
||
let m = line.metrics();
|
||
// Largest leading among the glyph runs, and half the largest em (a vertical column's half width).
|
||
let mut leading = 0.0f32;
|
||
let mut half = 0.0f32;
|
||
for item in line.items() {
|
||
if let PositionedLayoutItem::GlyphRun(gr) = item {
|
||
let px = gr.run().font_size();
|
||
half = half.max(px * 0.5);
|
||
let lp = styles.get(gr.style().brush.0 as usize).and_then(|st| st.leading_pt);
|
||
leading = leading.max(lp.map_or(ps.auto_leading * px, |l| l * k));
|
||
}
|
||
}
|
||
if leading == 0.0 {
|
||
leading = fallback.leading_pt.map_or(ps.auto_leading * first_px, |l| l * k);
|
||
}
|
||
let (ascent, descent) = if vertical {
|
||
let h = if half > 0.0 { half } else { first_px * 0.5 };
|
||
(h, h)
|
||
} else if m.ascent > 0.0 || m.descent > 0.0 {
|
||
(m.ascent, m.descent)
|
||
} else {
|
||
(first_px * 0.8, first_px * 0.2)
|
||
};
|
||
LineMetrics { ascent, descent, leading }
|
||
}
|
||
|
||
/// Largest ascent, descent and leading over the lines of a broken paragraph, by
|
||
/// [`line_metrics`], so an area paragraph's rows are planned with the metrics it is stacked with.
|
||
fn area_metrics(layout: &Layout<RunBrush>, styles: &[CharStyle], ps: &ParagraphStyle, k: f32, fallback: &CharStyle, vertical: bool) -> LineMetrics {
|
||
layout.lines().map(|line| line_metrics(&line, styles, ps, k, fallback, vertical)).fold(LineMetrics { ascent: 0.0, descent: 0.0, leading: 0.0 }, |a, b| {
|
||
LineMetrics { ascent: a.ascent.max(b.ascent), descent: a.descent.max(b.descent), leading: a.leading.max(b.leading) }
|
||
})
|
||
}
|
||
|
||
/// A tab as line breaking saw it: its shaped advance (before horizontal scale), the horizontal
|
||
/// scale, and the width that takes it to its tab stop on its line.
|
||
struct TabWidth {
|
||
advance: f32,
|
||
scale: f32,
|
||
width: f32,
|
||
}
|
||
|
||
/// The width of each tab (offsets `tabs` in the paragraph text) on the broken lines of `layout`,
|
||
/// before kerning and alignment.
|
||
fn tab_widths(layout: &Layout<RunBrush>, tabs: &[usize], styles: &[CharStyle], indent: f32, first_indent: f32, interval: f32) -> Vec<TabWidth> {
|
||
let mut out: Vec<TabWidth> = tabs.iter().map(|_| TabWidth { advance: interval, scale: 1.0, width: interval }).collect();
|
||
for (li, line) in layout.lines().enumerate() {
|
||
let mut pos = indent + if li == 0 { first_indent } else { 0.0 };
|
||
let mut seen: Vec<usize> = Vec::new();
|
||
for item in line.items() {
|
||
let PositionedLayoutItem::GlyphRun(gr) = item else {
|
||
continue;
|
||
};
|
||
let run = gr.run();
|
||
if seen.contains(&run.index()) {
|
||
continue;
|
||
}
|
||
seen.push(run.index());
|
||
let scale = styles.get(gr.style().brush.0 as usize).map_or(1.0, |st| if st.horizontal_scale > 0.0 { st.horizontal_scale } else { 1.0 });
|
||
for c in run.visual_clusters() {
|
||
let advance = c.advance();
|
||
match tabs.binary_search(&c.text_range().start).ok().and_then(|i| out.get_mut(i)) {
|
||
Some(t) => {
|
||
let stop = next_tab_stop(pos, interval);
|
||
*t = TabWidth { advance, scale, width: stop - pos };
|
||
pos = stop;
|
||
}
|
||
None => pos += advance * scale,
|
||
}
|
||
}
|
||
}
|
||
}
|
||
out
|
||
}
|
||
|
||
/// Byte ranges of paragraphs (each including its `\r`, `\n` or `\r\n` terminator). Text ending
|
||
/// with a break yields a final empty paragraph, like Photoshop's trailing empty line.
|
||
pub fn split_paragraphs(text: &str) -> Vec<Range<usize>> {
|
||
let b = text.as_bytes();
|
||
let mut v = Vec::new();
|
||
let mut start = 0;
|
||
let mut i = 0;
|
||
while i < b.len() {
|
||
match b[i] {
|
||
b'\r' => {
|
||
let end = if b.get(i + 1) == Some(&b'\n') { i + 2 } else { i + 1 };
|
||
v.push(start..end);
|
||
start = end;
|
||
i = end;
|
||
}
|
||
b'\n' => {
|
||
v.push(start..i + 1);
|
||
start = i + 1;
|
||
i += 1;
|
||
}
|
||
_ => i += 1,
|
||
}
|
||
}
|
||
v.push(start..b.len());
|
||
v
|
||
}
|
||
|
||
fn strip_break(text: &str, r: &Range<usize>) -> usize {
|
||
let s = &text[r.clone()];
|
||
r.start + s.trim_end_matches(['\r', '\n']).len()
|
||
}
|
||
|
||
fn quote(s: &str) -> String {
|
||
format!("\"{}\"", s.replace(['\\', '"'], ""))
|
||
}
|
||
|
||
/// Placement data of one vertical-type glyph (before mapping to text space).
|
||
struct VGlyph {
|
||
upright: bool,
|
||
/// Advance along the column (px).
|
||
advance: f32,
|
||
/// Upright: distance from the top of the glyph's cell down to its baseline (px).
|
||
origin: f32,
|
||
/// Rotated: distance from the column centre line to the glyph's baseline (px).
|
||
centre: f32,
|
||
}
|
||
|
||
/// Vertical metrics of a font instance: `VORG`, `vhea`/`vmtx`, else the ideographic em box.
|
||
struct VMetrics<'a> {
|
||
font: Option<skrifa::FontRef<'a>>,
|
||
coords: Vec<skrifa::instance::NormalizedCoord>,
|
||
/// px per font unit.
|
||
scale: f32,
|
||
/// Em-box fallback origin (px below the cell top).
|
||
em_origin: f32,
|
||
}
|
||
|
||
impl<'a> VMetrics<'a> {
|
||
fn new(fd: &'a FontData, coords: &[i16], size: f32) -> Self {
|
||
use skrifa::MetadataProvider;
|
||
let font = skrifa::FontRef::from_index(fd.data.as_ref(), fd.index).ok();
|
||
let coords: Vec<skrifa::instance::NormalizedCoord> = coords.iter().map(|&c| skrifa::instance::NormalizedCoord::from_bits(c)).collect();
|
||
let (scale, em_origin) = match &font {
|
||
Some(f) => {
|
||
let m = f.metrics(skrifa::instance::Size::unscaled(), skrifa::instance::LocationRef::new(&coords));
|
||
let upem = f32::from(m.units_per_em).max(1.0);
|
||
let (asc, desc) = (m.ascent, -m.descent);
|
||
// Ideographic em box: the em centred on the font's ascent/descent span.
|
||
let r = if asc + desc > 0.0 && asc.is_finite() && desc.is_finite() { (asc / (asc + desc)).clamp(0.0, 1.0) } else { 0.88 };
|
||
(size / upem, size * r)
|
||
}
|
||
None => (0.0, size * 0.88),
|
||
};
|
||
Self { font, coords, scale, em_origin }
|
||
}
|
||
|
||
fn cmap(&self, c: char) -> Option<u32> {
|
||
use skrifa::MetadataProvider;
|
||
self.font.as_ref()?.charmap().map(c).map(|g| g.to_u32())
|
||
}
|
||
|
||
/// Distance from the top of an upright glyph's cell to its baseline (px).
|
||
fn origin(&self, gid: u32) -> f32 {
|
||
self.vertical_origin(gid).filter(|v| v.is_finite()).unwrap_or(self.em_origin)
|
||
}
|
||
|
||
fn vertical_origin(&self, gid: u32) -> Option<f32> {
|
||
use skrifa::MetadataProvider;
|
||
use skrifa::raw::TableProvider;
|
||
let f = self.font.as_ref()?;
|
||
let g = skrifa::GlyphId::new(gid);
|
||
if let Ok(vorg) = f.vorg() {
|
||
return Some(f32::from(vorg.vertical_origin_y(g)) * self.scale);
|
||
}
|
||
let tsb = f.vmtx().ok()?.side_bearing(g)?;
|
||
// Top of the outline (font units), from the outline itself (glyf and CFF alike).
|
||
let outline = f.outline_glyphs().get(g)?;
|
||
let mut pen = YMax(None);
|
||
let settings = skrifa::outline::DrawSettings::unhinted(skrifa::instance::Size::unscaled(), skrifa::instance::LocationRef::new(&self.coords));
|
||
outline.draw(settings, &mut pen).ok()?;
|
||
Some((pen.0? + f32::from(tsb)) * self.scale)
|
||
}
|
||
}
|
||
|
||
/// Outline pen recording the largest y.
|
||
struct YMax(Option<f32>);
|
||
|
||
impl YMax {
|
||
fn add(&mut self, y: f32) {
|
||
self.0 = Some(self.0.map_or(y, |m| m.max(y)));
|
||
}
|
||
}
|
||
|
||
impl skrifa::outline::OutlinePen for YMax {
|
||
fn move_to(&mut self, _x: f32, y: f32) {
|
||
self.add(y);
|
||
}
|
||
fn line_to(&mut self, _x: f32, y: f32) {
|
||
self.add(y);
|
||
}
|
||
fn quad_to(&mut self, _cx0: f32, cy0: f32, _x: f32, y: f32) {
|
||
self.add(cy0);
|
||
self.add(y);
|
||
}
|
||
fn curve_to(&mut self, _cx0: f32, cy0: f32, _cx1: f32, cy1: f32, _x: f32, y: f32) {
|
||
self.add(cy0);
|
||
self.add(cy1);
|
||
self.add(y);
|
||
}
|
||
fn close(&mut self) {}
|
||
}
|
||
|
||
/// OpenType feature settings of a character style (CSS `font-feature-settings` items).
|
||
fn feature_list(st: &CharStyle, small_caps: SmallCapsMode) -> Vec<String> {
|
||
let mut feats: Vec<String> = Vec::new();
|
||
// Optical and manual kerning replace the font's kerning table; a character with a manual
|
||
// kern is manually kerned whatever its mode (as in Photoshop).
|
||
if st.kerning != Kerning::Metrics || st.kern != 0.0 {
|
||
feats.push("\"kern\" 0".into());
|
||
}
|
||
if !st.ligatures {
|
||
feats.push("\"liga\" 0".into());
|
||
feats.push("\"clig\" 0".into());
|
||
}
|
||
if st.discretionary_ligatures {
|
||
feats.push("\"dlig\" 1".into());
|
||
}
|
||
if small_caps == SmallCapsMode::OpenType {
|
||
feats.push("\"smcp\" 1".into());
|
||
}
|
||
for f in &st.features {
|
||
if f.tag.len() == 4 && f.tag.is_ascii() {
|
||
feats.push(format!("\"{}\" {}", f.tag, f.value));
|
||
}
|
||
}
|
||
feats
|
||
}
|
||
|
||
/// The font variations for a run: the explicit axis values, plus `opsz` at the type size when the
|
||
/// style doesn't set it (as CSS `font-optical-sizing: auto`). A font without an `opsz` axis
|
||
/// ignores it.
|
||
fn variation_list(st: &CharStyle) -> Vec<String> {
|
||
let mut vars: Vec<String> =
|
||
st.variations.iter().filter(|v| v.axis.len() == 4 && v.axis.is_ascii() && v.value.is_finite()).map(|v| format!("\"{}\" {}", v.axis, v.value)).collect();
|
||
if st.size_pt.is_finite() && !st.variations.iter().any(|v| v.axis == "opsz") {
|
||
vars.push(format!("\"opsz\" {}", st.size_pt.max(0.01)));
|
||
}
|
||
vars
|
||
}
|
||
|
||
fn style_props(st: &CharStyle, k: f32, fallback: &[String], idx: u32, small_caps: SmallCapsMode) -> Vec<StyleProperty<'static, RunBrush>> {
|
||
let px = (st.size_pt * k).max(0.01);
|
||
let mut fam: Vec<String> = Vec::new();
|
||
if !st.font_family.is_empty() {
|
||
fam.push(quote(&st.font_family));
|
||
}
|
||
// Serif runs fall back to a Mincho face for Japanese (craft-fonts), others to a Gothic one.
|
||
if crate::craft_fonts::is_serif_family(&st.font_family) {
|
||
fam.extend(crate::craft_fonts::mincho_first(fallback).iter().map(|f| quote(f)));
|
||
} else {
|
||
fam.extend(fallback.iter().map(|f| quote(f)));
|
||
}
|
||
fam.push("sans-serif".into());
|
||
let feats = feature_list(st, small_caps);
|
||
let vars = variation_list(st);
|
||
vec![
|
||
StyleProperty::FontFamily(FontFamily::Source(Cow::Owned(fam.join(", ")))),
|
||
StyleProperty::FontSize(px),
|
||
StyleProperty::FontWeight(FontWeight::new(st.weight.clamp(1, 1000) as f32)),
|
||
StyleProperty::FontStyle(if st.italic { FontStyle::Italic } else { FontStyle::Normal }),
|
||
StyleProperty::FontFeatures(FontFeatures::Source(Cow::Owned(feats.join(", ")))),
|
||
StyleProperty::FontVariations(FontVariations::Source(Cow::Owned(vars.join(", ")))),
|
||
StyleProperty::LetterSpacing(st.tracking / 1000.0 * px),
|
||
StyleProperty::Underline(st.underline),
|
||
StyleProperty::Strikethrough(st.strikethrough),
|
||
StyleProperty::Brush(RunBrush(idx, 0)),
|
||
StyleProperty::Locale(st.language.as_deref().and_then(|l| parley::fontique::Language::parse(l).ok())),
|
||
]
|
||
}
|
||
|
||
/// Closing CJK punctuation: its full-width cell has blank space after the mark.
|
||
fn is_closing(c: char) -> bool {
|
||
matches!(c, '、' | '。' | ',' | '.' | '」' | '』' | ')' | '〕' | '】' | '〉' | '》' | '〙' | '〗' | ']' | '}')
|
||
}
|
||
|
||
/// Opening CJK brackets: blank space before the mark.
|
||
fn is_opening(c: char) -> bool {
|
||
matches!(c, '「' | '『' | '(' | '〔' | '【' | '〈' | '《' | '〘' | '〖' | '[' | '{')
|
||
}
|
||
|
||
/// Basic Japanese punctuation squeeze (JIS X 4051 style) for one line in line space: between a
|
||
/// closing mark and a following opening or closing mark, the closing mark's trailing half-em
|
||
/// blank is removed; between two opening brackets, the second one's leading half-em. Clusters and
|
||
/// glyphs from the squeezed point on move back. Returns the total length removed.
|
||
pub(crate) fn squeeze_punctuation(text: &str, clusters: &mut [ClusterInfo], glyphs: &mut [PlacedGlyph]) -> f32 {
|
||
let first = |c: &ClusterInfo| text.get(c.range.clone()).and_then(|s| s.chars().next());
|
||
let last = |c: &ClusterInfo| text.get(c.range.clone()).and_then(|s| s.chars().next_back());
|
||
// Shift to apply from each cluster on.
|
||
let mut shifts = vec![0.0f32; clusters.len()];
|
||
let mut total = 0.0f32;
|
||
for i in 1..clusters.len() {
|
||
let (Some(prev), Some(cur)) = (clusters.get(i - 1), clusters.get(i)) else { continue };
|
||
if prev.rtl || cur.rtl {
|
||
continue;
|
||
}
|
||
let (Some(a), Some(b)) = (last(prev), first(cur)) else { continue };
|
||
let cut = if is_closing(a) && (is_opening(b) || is_closing(b)) {
|
||
prev.advance * 0.5
|
||
} else if is_opening(a) && is_opening(b) {
|
||
cur.advance * 0.5
|
||
} else {
|
||
0.0
|
||
};
|
||
if cut.is_finite() && cut > 0.0 {
|
||
total += cut;
|
||
}
|
||
if let Some(s) = shifts.get_mut(i) {
|
||
*s = total;
|
||
}
|
||
}
|
||
if total <= 0.0 {
|
||
return 0.0;
|
||
}
|
||
let starts: Vec<f32> = clusters.iter().map(|c| c.x).collect();
|
||
for (c, s) in clusters.iter_mut().zip(&shifts) {
|
||
c.x -= s;
|
||
}
|
||
for g in glyphs.iter_mut() {
|
||
let i = starts.iter().rposition(|&s| s <= g.x + 1e-3).unwrap_or(0);
|
||
g.x -= shifts.get(i).copied().unwrap_or(0.0);
|
||
}
|
||
total
|
||
}
|
||
|
||
/// Whether to embolden a face synthetically. Font matching (fontique) asks for it whenever the
|
||
/// requested weight is above the face's, so Regular (400) from a family with only W3 (300) and W6
|
||
/// (600), like Hiragino Mincho ProN, came out as a smeared bold W3. Like Photoshop and CSS, only
|
||
/// a bold request (≥ 600) on a face that isn't bold (≤ 500) is emboldened; anything else uses the
|
||
/// nearest face as it is (Faux Bold stays a separate, explicit style).
|
||
pub(crate) fn synthetic_bold(matcher_says: bool, requested: u16, face_weight: f32) -> bool {
|
||
matcher_says && requested >= 600 && face_weight <= 500.0
|
||
}
|
||
|
||
/// Height of the lowercase ascender ('d') of the tallest run on the line.
|
||
fn first_ascent(line: &parley::Line<'_, RunBrush>) -> Option<f32> {
|
||
use skrifa::MetadataProvider;
|
||
let mut best: Option<f32> = None;
|
||
for run in line.runs() {
|
||
let fd = run.font();
|
||
let Ok(font) = skrifa::FontRef::from_index(fd.data.as_ref(), fd.index) else {
|
||
continue;
|
||
};
|
||
let coords: Vec<skrifa::instance::NormalizedCoord> = run.normalized_coords().iter().map(|&c| skrifa::instance::NormalizedCoord::from_bits(c)).collect();
|
||
let loc = skrifa::instance::LocationRef::new(&coords);
|
||
let size = skrifa::instance::Size::new(run.font_size());
|
||
let h = font.charmap().map('d').and_then(|g| font.glyph_metrics(size, loc).bounds(g)).map(|b| b.y_max).or_else(|| {
|
||
let m = font.metrics(size, loc);
|
||
m.cap_height.or(Some(m.ascent * 0.75))
|
||
});
|
||
if let Some(h) = h {
|
||
best = Some(best.map_or(h, |b: f32| b.max(h)));
|
||
}
|
||
}
|
||
best
|
||
}
|
||
|
||
/// Hangul (syllables and jamo).
|
||
fn is_hangul(c: char) -> bool {
|
||
matches!(c, '\u{1100}'..='\u{11FF}' | '\u{3130}'..='\u{318F}' | '\u{A960}'..='\u{A97F}' | '\u{AC00}'..='\u{D7AF}' | '\u{D7B0}'..='\u{D7FF}')
|
||
}
|
||
|
||
/// The byte ranges of `text` made of Hangul, each as long as it runs.
|
||
pub(crate) fn hangul_runs(text: &str) -> Vec<std::ops::Range<usize>> {
|
||
let mut runs: Vec<std::ops::Range<usize>> = Vec::new();
|
||
for (i, c) in text.char_indices().filter(|&(_, c)| is_hangul(c)) {
|
||
match runs.last_mut() {
|
||
Some(r) if r.end == i => r.end = i + c.len_utf8(),
|
||
_ => runs.push(i..i + c.len_utf8()),
|
||
}
|
||
}
|
||
runs
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::{SmallCapsMode, feature_list, small_caps_mode, variation_list};
|
||
use photocraft_doc::TextLayer;
|
||
use photocraft_doc::text::{Caps, CharStyle, FontVariation, TextRun};
|
||
|
||
/// Reference: the lookup the layout used before it became a binary search.
|
||
fn run_index_reference(starts: &[usize], off: usize) -> usize {
|
||
starts.iter().rposition(|&s| s <= off).unwrap_or(0)
|
||
}
|
||
|
||
#[test]
|
||
fn run_lookup_matches_the_linear_reference() {
|
||
// Deterministic pseudo-random run layouts with empty runs, equal adjacent styles and
|
||
// offsets past the end.
|
||
let mut seed = 0x2545_f491_4f6c_dd1d_u64;
|
||
let mut next = move |m: u64| {
|
||
seed ^= seed << 13;
|
||
seed ^= seed >> 7;
|
||
seed ^= seed << 17;
|
||
(seed % m) as usize
|
||
};
|
||
for _ in 0..300 {
|
||
let n = next(12);
|
||
let mut acc = 0;
|
||
let starts: Vec<usize> = (0..n)
|
||
.map(|_| {
|
||
let s = acc;
|
||
acc += next(4); // 0 = empty run
|
||
s
|
||
})
|
||
.collect();
|
||
for off in 0..acc + 4 {
|
||
assert_eq!(super::run_index_at(&starts, off), run_index_reference(&starts, off), "{starts:?} @ {off}");
|
||
}
|
||
}
|
||
assert_eq!(super::run_index_at(&[], 5), 0);
|
||
}
|
||
|
||
/// Many runs and paragraphs: the font is probed once per small-caps style per layout, not
|
||
/// once per style per paragraph, and styles that don't use small caps are never probed.
|
||
#[test]
|
||
fn small_caps_probe_runs_once_per_small_caps_style() {
|
||
let plain = CharStyle { font_family: "Inter".into(), ..Default::default() };
|
||
let small = CharStyle { caps: Caps::SmallCaps, ..plain.clone() };
|
||
let text: String = "a\n".repeat(300);
|
||
let runs = |small_every: usize| -> Vec<TextRun> {
|
||
(0..text.len()).map(|i| TextRun { len: 1, style: if small_every > 0 && i % small_every == 0 { small.clone() } else { plain.clone() } }).collect()
|
||
};
|
||
let mut engine = crate::TextEngine::new();
|
||
let mut probes = |small_every: usize| {
|
||
super::SMCP_PROBES.with(|c| c.set(0));
|
||
let layer = TextLayer { text: text.clone(), runs: runs(small_every), ..Default::default() };
|
||
let _ = engine.layout(&layer, 72.0);
|
||
super::SMCP_PROBES.with(|c| c.get())
|
||
};
|
||
assert_eq!(probes(0), 0);
|
||
let styles = text.len().div_ceil(2); // every other index is a small-caps run
|
||
assert_eq!(probes(2), styles);
|
||
}
|
||
|
||
/// A variable font's optical size follows the type size unless the style sets `opsz` (#2985).
|
||
#[test]
|
||
fn optical_size_follows_the_type_size_unless_set() {
|
||
let style = CharStyle { size_pt: 36.0, variations: vec![FontVariation { axis: "wght".into(), value: 650.0 }], ..Default::default() };
|
||
assert_eq!(variation_list(&style), ["\"wght\" 650", "\"opsz\" 36"]);
|
||
let set = CharStyle { size_pt: 36.0, variations: vec![FontVariation { axis: "opsz".into(), value: 12.0 }], ..Default::default() };
|
||
assert_eq!(variation_list(&set), ["\"opsz\" 12"]);
|
||
}
|
||
|
||
#[test]
|
||
fn uses_real_small_caps_only_when_the_selected_face_supports_smcp() {
|
||
let style = CharStyle { caps: Caps::SmallCaps, ..Default::default() };
|
||
let real = small_caps_mode(style.caps, true);
|
||
let synthetic = small_caps_mode(style.caps, false);
|
||
|
||
assert_eq!(real, SmallCapsMode::OpenType);
|
||
assert!(feature_list(&style, real).iter().any(|feature| feature == "\"smcp\" 1"));
|
||
assert_eq!(synthetic, SmallCapsMode::Synthetic);
|
||
assert!(!feature_list(&style, synthetic).iter().any(|feature| feature == "\"smcp\" 1"));
|
||
}
|
||
}
|