mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-16 22:34:43 +00:00
Type on an open path can now start before the path's start: its start is stored below 0, the span runs from there, and the characters whose middle falls before the path's start are not drawn, as SVG 2 lays out text on a path (https://www.w3.org/TR/SVG2/text.html#TextLayoutPath). The text keeps every character, and the start bracket stays at the path's start. Past the path's end, text that does not fit is overflow, as for other type on a path. Type that starts on the path draws every glyph as before. - SVG import keeps a <textPath> start before an open path's start (text-anchor end or middle, or a negative startOffset) instead of starting the text at the path's start, which drew every character. - SVG export writes it as a negative startOffset. - PDF export writes only the characters drawn on the path. - The legacy .ai and .ai editing data writers write the type from the path's start with the type attributes warning. - type.pathOptions takes a start below 0 for type on an open path; on a closed path it is the path's start, as before. A flip starts the type at its start bracket. Dragging the center bracket slides it from where it starts, and no further before the path. - A click at the path's start places the caret by the first drawn character, and the caret in the hidden characters stands at the path's start. The highlight of substituted fonts and glyphs leaves them out. - Release Type on a Path keeps the first drawn glyph where it was drawn, with the hidden characters before it. - The Touch Type tool shows no box for a hidden character, and text.touchType returns an error for one. A character with a drawn glyph is changed by that glyph. Docs: docs/mcp.md, docs/target-app-parity.md.
385 lines
16 KiB
Rust
385 lines
16 KiB
Rust
use super::driver::layout;
|
|
use super::{Affine, CharStyle, Ctx, EPS, Point, PositionedGlyph, RubyAlign, RubyPosition, Shape, TextKind, TextObject};
|
|
|
|
/// Ruby (furigana): lays each reading out over its base text in line space, grows the line's
|
|
/// ascent/descent so the ruby fits, and moves the lines after it on in the block direction.
|
|
///
|
|
/// Positions are measured from the line's baseline. Vertical type uses the same geometry — ruby
|
|
/// "above" the baseline is right of the column once the lines are turned — with each reading
|
|
/// character set upright along the column (a quarter turn that the final vertical turn undoes).
|
|
/// A reading over a line break is split between the lines, by the base characters' share of it.
|
|
/// A reading wider than its base hangs over the neighbours (`overhang`), or is squeezed to the
|
|
/// base's width. Type on a path is left out (it has no above/below).
|
|
pub(super) fn ruby_layout(cx: &mut Ctx<'_>, t: &TextObject) {
|
|
let line_count = cx.out.lines.len();
|
|
if line_count == 0 || cx.out.glyphs.is_empty() {
|
|
return;
|
|
}
|
|
let base_baselines = cx.out.lines.iter().map(|line| line.baseline).collect::<Vec<_>>();
|
|
let old_ascent = cx.out.lines.iter().map(|line| line.ascent).collect::<Vec<_>>();
|
|
let old_descent = cx.out.lines.iter().map(|line| line.descent).collect::<Vec<_>>();
|
|
let pieces = ruby_pieces(cx, t);
|
|
// Phase A: shape each reading, place it relative to the (unshifted) baseline, and note how
|
|
// far above/below the baseline its ink reaches.
|
|
let placed = place_ruby_pieces(cx, &pieces, &base_baselines, &old_descent);
|
|
if !placed.is_empty() {
|
|
grow_ruby_lines(cx, t, placed, &old_ascent, &old_descent);
|
|
}
|
|
}
|
|
|
|
// One piece of base text on one line, with the part of the reading that belongs to it.
|
|
struct RubyPiece {
|
|
line: usize,
|
|
x0: f64,
|
|
x1: f64,
|
|
run: usize,
|
|
byte: usize,
|
|
reading: String,
|
|
style: CharStyle,
|
|
position: RubyPosition,
|
|
align: RubyAlign,
|
|
base_size: f64,
|
|
overhang: bool,
|
|
}
|
|
|
|
struct PlacedRuby {
|
|
line: usize,
|
|
glyphs: Vec<PositionedGlyph>,
|
|
ascent: f64,
|
|
descent: f64,
|
|
}
|
|
|
|
fn ruby_pieces(cx: &Ctx<'_>, t: &TextObject) -> Vec<RubyPiece> {
|
|
use std::collections::BTreeMap;
|
|
|
|
let text_len = cx.text.len();
|
|
// The glyphs by their byte, to find a span's without a scan of them all for each span.
|
|
let byte_of = |i: usize| cx.out.glyphs.get(i).map_or(0, |g| g.byte);
|
|
let mut by_byte: Vec<usize> = (0..cx.out.glyphs.len()).collect();
|
|
by_byte.sort_by_key(|&i| byte_of(i));
|
|
let longest = cx.out.glyphs.iter().map(|g| g.len.max(1)).max().unwrap_or(1);
|
|
let mut pieces = Vec::new();
|
|
for span in &t.ruby {
|
|
let (start, end) = (span.start.min(text_len), span.end.min(text_len));
|
|
if start >= end || span.text.trim().is_empty() {
|
|
continue;
|
|
}
|
|
// The base glyphs of the span, by line; a glyph's cluster is its byte range (`len`, or
|
|
// one byte for generated glyphs). A list marker is not part of the base.
|
|
let mut by_line: BTreeMap<usize, Vec<usize>> = BTreeMap::new();
|
|
let hi = by_byte.partition_point(|&i| byte_of(i) < end);
|
|
let lo = by_byte.partition_point(|&i| byte_of(i).saturating_add(longest) <= start).min(hi);
|
|
let mut hits: Vec<usize> = by_byte.get(lo..hi).unwrap_or_default().to_vec();
|
|
// In glyph order, as the scan found them.
|
|
hits.sort_unstable();
|
|
for i in hits {
|
|
let Some(glyph) = cx.out.glyphs.get(i) else { continue };
|
|
let glyph_end = glyph.byte.saturating_add(glyph.len.max(1));
|
|
if glyph.byte < end && glyph_end > start && cx.out.marker_of(i).is_none() {
|
|
by_line.entry(glyph.line).or_default().push(i);
|
|
}
|
|
}
|
|
let total: usize = by_line.values().map(Vec::len).sum();
|
|
if total == 0 {
|
|
continue;
|
|
}
|
|
collect_ruby_pieces_for_span(cx, span, start, total, &by_line, &mut pieces);
|
|
}
|
|
pieces
|
|
}
|
|
|
|
fn collect_ruby_pieces_for_span(
|
|
cx: &Ctx<'_>,
|
|
span: &vectorcraft_doc::text::RubySpan,
|
|
start: usize,
|
|
total: usize,
|
|
by_line: &std::collections::BTreeMap<usize, Vec<usize>>,
|
|
pieces: &mut Vec<RubyPiece>,
|
|
) {
|
|
let reading: Vec<char> = span.text.trim().chars().collect();
|
|
let ratio = span.safe_size_percent() / 100.0;
|
|
// Split the reading by each line's share of the base glyphs: cumulative fractions keep
|
|
// every character once and in order.
|
|
let mut taken = 0;
|
|
let mut done = 0;
|
|
for (&line, glyph_indices) in by_line {
|
|
done += glyph_indices.len();
|
|
let upto = if reading.is_empty() { 0 } else { (reading.len() * done / total).min(reading.len()) };
|
|
let part: String = reading.get(taken.min(reading.len())..upto.min(reading.len())).unwrap_or_default().iter().collect();
|
|
taken = upto;
|
|
if part.is_empty() {
|
|
continue;
|
|
}
|
|
if let Some(piece) = ruby_piece_for_line(cx, line, start, &part, ratio, glyph_indices, span) {
|
|
pieces.push(piece);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn ruby_piece_for_line(
|
|
cx: &Ctx<'_>,
|
|
line: usize,
|
|
start: usize,
|
|
reading: &str,
|
|
ratio: f64,
|
|
glyph_indices: &[usize],
|
|
span: &vectorcraft_doc::text::RubySpan,
|
|
) -> Option<RubyPiece> {
|
|
let mut x0 = f64::INFINITY;
|
|
let mut x1 = f64::NEG_INFINITY;
|
|
// The size the base is drawn at (where the reading goes), and the size the text sets it in (what
|
|
// the reading is scaled from: a composite font's part scales the reading itself).
|
|
let mut base_size: f64 = 0.0;
|
|
let mut set_size: f64 = 0.0;
|
|
let mut run = 0;
|
|
let mut byte = start;
|
|
for (index, &glyph_index) in glyph_indices.iter().enumerate() {
|
|
let Some(glyph) = cx.out.glyphs.get(glyph_index) else { continue };
|
|
x0 = x0.min(glyph.origin.x);
|
|
x1 = x1.max(glyph.origin.x + glyph.advance);
|
|
base_size = base_size.max(cx.style_at(glyph.byte).size);
|
|
set_size = set_size.max(cx.set_style_at(glyph.byte).size);
|
|
if index == 0 {
|
|
run = glyph.run;
|
|
byte = glyph.byte;
|
|
}
|
|
}
|
|
if !(x0.is_finite() && x1.is_finite()) || base_size <= 0.0 {
|
|
return None;
|
|
}
|
|
// The base's style as the text sets it: a reading in a composite font is set in its parts.
|
|
let mut style = cx.set_style_at(byte).clone();
|
|
style.size = set_size * ratio;
|
|
style.leading = None;
|
|
style.baseline_shift = 0.0;
|
|
style.tracking = 0.0;
|
|
style.kerning = None;
|
|
Some(RubyPiece {
|
|
line,
|
|
x0,
|
|
x1,
|
|
run,
|
|
byte,
|
|
reading: reading.to_string(),
|
|
style,
|
|
position: span.position,
|
|
align: span.align,
|
|
base_size,
|
|
overhang: span.overhang,
|
|
})
|
|
}
|
|
|
|
fn place_ruby_pieces(cx: &Ctx<'_>, pieces: &[RubyPiece], baselines: &[f64], old_descent: &[f64]) -> Vec<PlacedRuby> {
|
|
pieces.iter().filter_map(|piece| place_ruby_piece(cx, piece, baselines, old_descent)).collect()
|
|
}
|
|
|
|
fn place_ruby_piece(cx: &Ctx<'_>, piece: &RubyPiece, baselines: &[f64], old_descent: &[f64]) -> Option<PlacedRuby> {
|
|
let baseline = baselines.get(piece.line).copied()?;
|
|
let mini = TextObject::point(Point::ZERO, &piece.reading, piece.style.clone());
|
|
let layout = layout(cx.db, &mini);
|
|
let first_line = layout.lines.first()?;
|
|
let base_width = (piece.x1 - piece.x0).max(0.0);
|
|
let ruby_y = ruby_baseline(piece, baseline, first_line.ascent, first_line.descent, old_descent);
|
|
let glyphs = if cx.vertical {
|
|
place_vertical_ruby(piece, &layout.glyphs, first_line.ascent, first_line.descent, base_width, ruby_y)
|
|
} else {
|
|
place_horizontal_ruby(piece, &layout.glyphs, first_line, base_width, ruby_y)
|
|
};
|
|
let (ascent, descent) = ruby_ink_extents(&glyphs, baseline);
|
|
(!glyphs.is_empty()).then_some(PlacedRuby { line: piece.line, glyphs, ascent, descent })
|
|
}
|
|
|
|
fn ruby_baseline(piece: &RubyPiece, baseline: f64, reading_ascent: f64, reading_descent: f64, old_descent: &[f64]) -> f64 {
|
|
// Above: the reading's bottom sits on the base's em box top. Below: its top sits on the
|
|
// base's em box bottom (the line's descent below the baseline).
|
|
if piece.position == RubyPosition::Above {
|
|
baseline - piece.base_size - reading_descent
|
|
} else {
|
|
baseline + old_descent.get(piece.line).copied().unwrap_or(0.0) + reading_ascent
|
|
}
|
|
}
|
|
|
|
fn ruby_destination(piece: &RubyPiece, base_width: f64, reading_width: f64) -> f64 {
|
|
match piece.align {
|
|
RubyAlign::Center => piece.x0 + (base_width - reading_width) * 0.5,
|
|
RubyAlign::Start => piece.x0,
|
|
RubyAlign::End => piece.x1 - reading_width,
|
|
}
|
|
}
|
|
|
|
fn place_vertical_ruby(piece: &RubyPiece, reading: &[PositionedGlyph], asc: f64, desc: f64, base_width: f64, ruby_y: f64) -> Vec<PositionedGlyph> {
|
|
// Each reading character in its own cell along the column, upright once the lines turn.
|
|
let cell = (asc + desc).max(piece.style.size * 0.5);
|
|
let clusters = ruby_clusters(reading);
|
|
let (ruby_width, squeeze) = ruby_width(clusters.len() as f64 * cell, base_width, piece.overhang);
|
|
let x = ruby_destination(piece, base_width, ruby_width);
|
|
let mut glyphs = Vec::new();
|
|
for (index, cluster) in clusters.iter().enumerate() {
|
|
let anchor = Point::new(x + (index as f64 + 0.5) * cell, ruby_y);
|
|
let centre = ruby_cluster_center(cluster, anchor);
|
|
let transform = squeeze_transform(
|
|
Affine::rotate_about(-std::f64::consts::FRAC_PI_2, anchor) * Affine::translate((anchor.x - centre.x, anchor.y - centre.y)),
|
|
x,
|
|
squeeze,
|
|
);
|
|
for glyph in cluster {
|
|
glyphs.push(ruby_glyph(glyph, transform, piece.run, piece.byte, piece.line));
|
|
}
|
|
}
|
|
glyphs
|
|
}
|
|
|
|
fn ruby_clusters(glyphs: &[PositionedGlyph]) -> Vec<Vec<&PositionedGlyph>> {
|
|
let mut clusters: Vec<Vec<&PositionedGlyph>> = Vec::new();
|
|
for glyph in glyphs {
|
|
match clusters.last_mut() {
|
|
Some(cluster) if cluster.last().is_some_and(|previous| previous.byte == glyph.byte && previous.len == glyph.len) => cluster.push(glyph),
|
|
_ => clusters.push(vec![glyph]),
|
|
}
|
|
}
|
|
clusters
|
|
}
|
|
|
|
fn ruby_cluster_center(cluster: &[&PositionedGlyph], anchor: Point) -> Point {
|
|
let bounds = cluster
|
|
.iter()
|
|
.filter(|glyph| !glyph.outline.elements().is_empty())
|
|
.map(|glyph| glyph.outline.bounding_box())
|
|
.reduce(|left, right| left.union(right));
|
|
bounds.map_or(anchor, |bounds| Point::new((bounds.x0 + bounds.x1) * 0.5, (bounds.y0 + bounds.y1) * 0.5))
|
|
}
|
|
|
|
fn place_horizontal_ruby(
|
|
piece: &RubyPiece,
|
|
reading: &[PositionedGlyph],
|
|
line: &super::LineInfo,
|
|
base_width: f64,
|
|
ruby_y: f64,
|
|
) -> Vec<PositionedGlyph> {
|
|
// The reading set along the line: the line's extent, centred or aligned to the base.
|
|
let reading_width = (line.x1 - line.x0).max(0.0);
|
|
let (ruby_width, squeeze) = ruby_width(reading_width, base_width, piece.overhang);
|
|
let x = ruby_destination(piece, base_width, ruby_width);
|
|
let transform = squeeze_transform(Affine::translate((x - line.x0, ruby_y - line.baseline)), x, squeeze);
|
|
reading.iter().map(|glyph| ruby_glyph(glyph, transform, piece.run, piece.byte, piece.line)).collect()
|
|
}
|
|
|
|
fn ruby_width(reading_width: f64, base_width: f64, overhang: bool) -> (f64, f64) {
|
|
if !overhang && reading_width > base_width + EPS && reading_width > EPS { (base_width, base_width / reading_width) } else { (reading_width, 1.0) }
|
|
}
|
|
|
|
fn squeeze_transform(transform: Affine, x: f64, squeeze: f64) -> Affine {
|
|
if squeeze == 1.0 {
|
|
transform
|
|
} else {
|
|
Affine::translate((x, 0.0)) * Affine::scale_non_uniform(squeeze, 1.0) * Affine::translate((-x, 0.0)) * transform
|
|
}
|
|
}
|
|
|
|
fn ruby_ink_extents(glyphs: &[PositionedGlyph], baseline: f64) -> (f64, f64) {
|
|
// How far the reading reaches above and below the base line's baseline (its ink).
|
|
let mut ascent: f64 = 0.0;
|
|
let mut descent: f64 = 0.0;
|
|
for glyph in glyphs.iter().filter(|glyph| !glyph.outline.elements().is_empty()) {
|
|
let bounds = glyph.outline.bounding_box();
|
|
ascent = ascent.max(baseline - bounds.y0);
|
|
descent = descent.max(bounds.y1 - baseline);
|
|
}
|
|
(ascent, descent)
|
|
}
|
|
|
|
fn grow_ruby_lines(cx: &mut Ctx<'_>, t: &TextObject, placed: Vec<PlacedRuby>, old_ascent: &[f64], old_descent: &[f64]) {
|
|
let line_count = cx.out.lines.len();
|
|
// Phase B: grow each line's box to fit its ruby, then move the lines on after it by what they
|
|
// need in the block direction (the first line too for area type, so the ruby stays inside the
|
|
// frame; point type's first baseline is its anchor and stays).
|
|
let mut growth = vec![0.0_f64; line_count];
|
|
for ruby in &placed {
|
|
if let (Some(asc), Some(desc), Some(slot)) = (old_ascent.get(ruby.line), old_descent.get(ruby.line), growth.get_mut(ruby.line)) {
|
|
let grown = (asc.max(ruby.ascent) + desc.max(ruby.descent)) - (asc + desc);
|
|
*slot = slot.max(grown.max(0.0));
|
|
}
|
|
}
|
|
// A line's ruby grows above it: the line moves on in the block direction by its own growth,
|
|
// so the line before it keeps its room (for area type the first line moves too, keeping the
|
|
// ruby inside the frame; point type's first baseline is its anchor and stays).
|
|
let area = matches!(t.kind, TextKind::Area { .. });
|
|
let mut shift = vec![0.0_f64; line_count];
|
|
let mut cumulative = 0.0;
|
|
for (index, amount) in growth.iter().copied().enumerate() {
|
|
if area || index > 0 {
|
|
cumulative += amount;
|
|
shift[index] = cumulative;
|
|
}
|
|
}
|
|
// Grow the lines' boxes to fit their ruby, then move them on in the block direction.
|
|
for ruby in &placed {
|
|
if let Some(line) = cx.out.lines.get_mut(ruby.line) {
|
|
line.ascent = line.ascent.max(ruby.ascent);
|
|
line.descent = line.descent.max(ruby.descent);
|
|
}
|
|
}
|
|
for (index, line) in cx.out.lines.iter_mut().enumerate() {
|
|
line.baseline += shift.get(index).copied().unwrap_or(0.0);
|
|
}
|
|
shift_base_glyphs(cx, &shift);
|
|
append_ruby_glyphs(cx, placed, &shift);
|
|
}
|
|
|
|
fn shift_base_glyphs(cx: &mut Ctx<'_>, shift: &[f64]) {
|
|
for glyph in &mut cx.out.glyphs {
|
|
let amount = shift.get(glyph.line).copied().unwrap_or(0.0);
|
|
if amount != 0.0 {
|
|
glyph.origin.y += amount;
|
|
glyph.outline.apply_affine(Affine::translate((0.0, amount)));
|
|
glyph.xf = Affine::translate((0.0, amount)) * glyph.xf;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn append_ruby_glyphs(cx: &mut Ctx<'_>, placed: Vec<PlacedRuby>, shift: &[f64]) {
|
|
for ruby in placed {
|
|
let amount = shift.get(ruby.line).copied().unwrap_or(0.0);
|
|
for mut glyph in ruby.glyphs {
|
|
if amount != 0.0 {
|
|
glyph.origin.y += amount;
|
|
glyph.outline.apply_affine(Affine::translate((0.0, amount)));
|
|
}
|
|
glyph.line = ruby.line;
|
|
cx.out.ruby.push(glyph);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A ruby glyph from one of a reading's laid-out glyphs, moved by `m` into the base text's line
|
|
/// space. It is not a character of the text: `len` 0, the base text's `run` for fill and stroke.
|
|
fn ruby_glyph(g: &PositionedGlyph, m: Affine, run: usize, byte: usize, line: usize) -> PositionedGlyph {
|
|
PositionedGlyph {
|
|
outline: m * g.outline.clone(),
|
|
run,
|
|
byte,
|
|
origin: m * g.origin,
|
|
advance: 0.0,
|
|
len: 0,
|
|
angle: 0.0,
|
|
line,
|
|
font_id: g.font_id,
|
|
gid: g.gid,
|
|
xf: Affine::IDENTITY,
|
|
rtl: false,
|
|
scale: 1.0,
|
|
// Ruby draws outlines only.
|
|
image: None,
|
|
colour: None,
|
|
bend: None,
|
|
unturned: Affine::IDENTITY,
|
|
pivot: m * g.origin,
|
|
carets: Vec::new(),
|
|
width: 0.0,
|
|
width_start: 0.0,
|
|
warichu: None,
|
|
warichu_line: 0.0,
|
|
off_path: false,
|
|
}
|
|
}
|