mirror of
https://github.com/storytold/photocraft.git
synced 2026-11-15 22:52:35 +00:00
* Add path text placement ranges and drag gestures * Preview path placement and track bounded canvas damage * Preserve legacy path anchors and show overflow markers * Match path marker hit targets and directional cursors * Fix path placement lint failures * Cover path text body movement and position locks * Keep open path text movable at range endpoints * Target the type path after attaching text * Fix path text range rendering and placement lifecycle * Map vertical path text and preserve drag branch continuity * Cover path placement lifecycle and preview damage regressions * Preserve closest branch projection and fix CI regressions * Normalize path endpoints and bind gestures to their viewport * Simplify viewport ownership guards for Clippy * Document path placement invariants and regression cases * Fix path placement ownership, validation and geometry caching * Correct path placement regression fixtures * Ignore transient path geometry cache in UI state equality * fix: allow path text flips with stale placement ranges * fix: retain path text handles after shortening curves * test: account for layer translation in path placement drags * fix: mark path text range with x and o markers on the path The beginning marker is an x and the end a small circle, both on the path, with a plus in the circle while the range hides glyphs. The cursor's triangle points right over the beginning, left over the end, and both ways over the text body, which moves the whole range. Direct Selection leaves an anchor or handle under a marker to path editing; Path Selection always takes the marker. * fix: resolve coincident path text markers by lap or drag direction The x and o markers coincide on a closed path's full lap and on an empty or end-clamped open range. A full lap now moves the whole text; otherwise the first motion picks the beginning (backward) or the end (forward). Marker fixtures press on the path, where the markers now sit. * fix: let either end of a full-lap path text range be dragged Text attached to a closed path fills one lap, so its x and o markers coincide and every press moved the whole text, leaving no way to shorten the range. As the text begins just ahead of that point and ends just behind it, a press ahead along the path now grabs the beginning and one behind grabs the end; the point itself still moves the whole text. * test: check full-lap marker drags do not flip the text * fix: read and write the path text range in PSD Type on a path keeps its range in the Txt2 frame as /2 /6 [start end], in curve-segment units with -1 for the default. Three reference-editor files in ag-psd's test set fix the mapping: text-path ends a third into the first segment and draws only "so" of "some text", and text-path-26/27 move the start on an open path. Import reads both ends (and the flipped flag) into the layer's start and end. Export writes an open path whole with its start and end in the range, instead of cutting the path at the start, and a closed path's limited end as a range from its start. Path text in a document that never came from a PSD now gets a Txt2 block, so its path is saved at all, and the warning that the end limit is lost is gone. * fix: let both selection tools grab a path text marker on an anchor Direct Selection gave an anchor under a marker the click, so an open path's default markers (on its end anchors) and a closed path's coincident full-lap markers (on its first anchor) could not be moved with that tool. In the reference editor either selection tool drags a marker wherever the pointer shows the text bar with a triangle, so the marker now wins for both tools. The Direct Selection tests for reshaping a type path (#9114) drag its last anchor, where the default end marker sits; they now end the range short of it. To reshape at an anchor under a marker, drag the marker off it or select the anchor with a marquee and nudge it. * fix: keep explicit and empty path text ranges through PSD An explicit end at the path's end stays explicit, so centered and right type keeps its alignment within the span. A closed range whose ends meet reads as empty, not as a full lap. * ci: re-run checks after a download outage * ci: re-run checks after a download outage * fix: preserve legacy path text anchors through PSD * ci: re-run checks against current main --------- Co-authored-by: FredApps <153173854+FredApps@users.noreply.github.com>
498 lines
20 KiB
Rust
498 lines
20 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. Roman
|
||
//! letters stand upright one per em unless the run sets `rotate_roman`. 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::{FontData, FontFamily, FontFeatures, FontStyle, FontVariations, FontWeight, Layout, LayoutContext, PositionedLayoutItem, StyleProperty};
|
||
use photocraft_doc::TextLayer;
|
||
use photocraft_doc::text::{Caps, CharStyle, FontBaseline, Kerning, Orientation, ParagraphStyle, TextShape};
|
||
use skrifa::raw::types::Tag;
|
||
|
||
use crate::fonts::FontDb;
|
||
|
||
mod area;
|
||
mod lines;
|
||
mod navigate;
|
||
mod paragraphs;
|
||
mod shaping;
|
||
mod style;
|
||
mod vertical;
|
||
|
||
#[cfg(test)]
|
||
pub(crate) use area::AREA_PASSES;
|
||
pub use navigate::{byte_index, char_index, hit_char, line_edge, line_index, line_step, text_point_inside, word_boundary};
|
||
use paragraphs::next_tab_stop;
|
||
pub use paragraphs::{DEFAULT_TAB_STOP_PT, split_paragraphs};
|
||
use shaping::{Para, resolve_run_styles, running_starts, small_caps_modes};
|
||
use style::SmallCapsMode;
|
||
#[cfg(test)]
|
||
use style::{SMCP_PROBES, feature_list, small_caps_mode, variation_list};
|
||
#[cfg(test)]
|
||
pub(crate) use style::{hangul_runs, squeeze_punctuation, synthetic_bold};
|
||
pub use vertical::{VClass, vertical_class};
|
||
|
||
/// 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)
|
||
}
|
||
|
||
/// 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 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,
|
||
/// Optional line-space glyph center before rotation into text space.
|
||
pub line_center: Option<f32>,
|
||
}
|
||
|
||
/// 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>,
|
||
/// Layer-text byte range represented by each glyph, in the same order as `glyphs`.
|
||
pub glyph_ranges: Vec<Range<usize>>,
|
||
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])],
|
||
})
|
||
})
|
||
}
|
||
|
||
/// Whether boxed text doesn't all fit its shape: a box's layout drops the lines that
|
||
/// overflow (`layout` breaks out of the line loop), so any character the laid-out lines
|
||
/// don't cover — the last line's range ends short of the whole text — points at dropped
|
||
/// content. Text that fits completely covers its end: paragraph breaks are inside their
|
||
/// lines, and a trailing empty paragraph that fits gains its own (empty) line. Empty text
|
||
/// has nothing to drop. Callers gate this on the shape being a box; point text has no box
|
||
/// to overflow.
|
||
pub fn overflows(&self, text: &str) -> bool {
|
||
!text.is_empty() && self.lines.last().is_none_or(|ln| ln.range.end < text.len())
|
||
}
|
||
|
||
/// 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),
|
||
}
|
||
}
|
||
}
|
||
|
||
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,
|
||
}
|
||
|
||
impl Layouter {
|
||
pub fn new() -> Self {
|
||
Self { lcx: LayoutContext::new(), optical: crate::optical::Cache::default() }
|
||
}
|
||
|
||
/// Lays out text runs into positioned glyphs, shaped lines, and decoration rectangles at target DPI.
|
||
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() };
|
||
let styles = resolve_run_styles(fonts, &runs);
|
||
let run_starts = running_starts(runs.iter().map(|r| r.len));
|
||
let para_starts = running_starts(paras.iter().map(|r| r.len));
|
||
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,
|
||
};
|
||
let small_caps = small_caps_modes(fonts, &styles);
|
||
let env = Env {
|
||
text: &t.text,
|
||
runs: &runs,
|
||
styles: &styles,
|
||
run_starts: &run_starts,
|
||
small_caps: &small_caps,
|
||
k,
|
||
vertical,
|
||
is_box,
|
||
// Box and area text wrap, align within their lines and hide what doesn't fit.
|
||
wraps: is_box || area.is_some(),
|
||
box_rect,
|
||
path_range: crate::warp::path_range_length(&t.shape).map(|n| n.min(f32::MAX as f64) as f32),
|
||
area,
|
||
};
|
||
let mut flow = Flow::default();
|
||
for (pi, prange) in split_paragraphs(&t.text).into_iter().enumerate() {
|
||
if flow.stop {
|
||
break;
|
||
}
|
||
let ps = paras[run_index_at(¶_starts, prange.start)].style.clone();
|
||
self.layout_paragraph(fonts, &mut out, &mut flow, Para::new(&env, fonts, pi, prange, ps));
|
||
}
|
||
out.styles = styles;
|
||
out
|
||
}
|
||
|
||
/// Breaks one paragraph and stacks its lines below the previous paragraph's.
|
||
fn layout_paragraph(&mut self, fonts: &mut FontDb, out: &mut TextLayout, flow: &mut Flow, para: Para<'_>) {
|
||
let env = para.env;
|
||
let (mut layout, area_slots, area_full) = para.break_paragraph(&mut self.lcx, &mut fonts.fcx, flow);
|
||
layout.align(para.alignment(), para.align_options());
|
||
if flow.prev_baseline.is_some() {
|
||
flow.pending_space += para.ps.space_before_pt * env.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 env.area.is_some() && slot.is_none() {
|
||
flow.stop = true;
|
||
break;
|
||
}
|
||
let Some(frame) = para.frame_line(&line, li, nlines, slot, flow) else {
|
||
flow.stop = true;
|
||
break;
|
||
};
|
||
para.place_line(&mut self.optical, out, &line, &frame);
|
||
}
|
||
if area_full {
|
||
// The shape is full: later paragraphs are hidden too.
|
||
flow.stop = true;
|
||
}
|
||
flow.pending_space += para.ps.space_after_pt * env.k;
|
||
}
|
||
}
|
||
|
||
/// What a layout run shares between its paragraphs.
|
||
struct Env<'a> {
|
||
text: &'a str,
|
||
runs: &'a [photocraft_doc::text::TextRun],
|
||
styles: &'a [CharStyle],
|
||
/// Start offset of each run.
|
||
run_starts: &'a [usize],
|
||
small_caps: &'a [SmallCapsMode],
|
||
k: f32,
|
||
vertical: bool,
|
||
is_box: bool,
|
||
/// Box and area text wrap, align within their lines and hide what doesn't fit.
|
||
wraps: bool,
|
||
box_rect: (f32, f32, f32, f32),
|
||
/// Available explicit path span in text-space pixels, capped by the curve's capacity.
|
||
/// `None` keeps legacy alignment around the start anchor (an alignment span of zero).
|
||
path_range: Option<f32>,
|
||
area: Option<crate::area::AreaShape>,
|
||
}
|
||
|
||
impl Env<'_> {
|
||
/// Index of the run (and style) containing byte offset `off`.
|
||
fn style_at(&self, off: usize) -> usize {
|
||
run_index_at(self.run_starts, off)
|
||
}
|
||
}
|
||
|
||
/// Where the previous paragraph left off.
|
||
#[derive(Default)]
|
||
struct Flow {
|
||
prev_baseline: Option<f32>,
|
||
pending_space: f32,
|
||
stop: bool,
|
||
}
|
||
|
||
/// 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,
|
||
}
|
||
|
||
#[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"));
|
||
}
|
||
}
|