mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-17 08:26:28 +00:00
- Test files whose image→craft-image-codecs rewrites didn't compile against main's newer tests go back to main's versions (engine fileio/tests.rs, tests_tiffbmp.rs, tests/menucmds.rs, eps tests.rs); they still use the image crate, which keeps its format features. - craft_jxl::encode, craft_image_codecs::encode and Image::icc at d6cd7836d. - jp2read and pdf export pass DecodeOptions, not Limits. - EPS DCTDecode: grey JPEGs no longer use the image after moving it, and keep main's one-channel output. - svg keeps its direct usvg dependency for main's image href code; pdf keeps jpeg-encoder for CMYK JPEGs. - clippy -D warnings and rustfmt clean.
224 lines
9.4 KiB
Rust
224 lines
9.4 KiB
Rust
use super::nodes::MAX_DEPTH;
|
||
use super::{AfAlign, CharStyle, Justify, Kind, Rect, TextKind, TextObject, VerticalAlign, af, shapes};
|
||
|
||
/// The master page instances among `nodes` (also inside layers and groups): (master, first page,
|
||
/// first master page, page count).
|
||
pub(super) fn master_instances(nodes: &[af::Node]) -> Vec<(usize, usize, usize, usize)> {
|
||
fn visit(n: &af::Node, depth: usize, out: &mut Vec<(usize, usize, usize, usize)>) {
|
||
if depth > MAX_DEPTH || !n.visible {
|
||
return;
|
||
}
|
||
match n.kind {
|
||
Kind::MasterInstance { master, page, master_page, count } => out.push((master, page, master_page, count)),
|
||
Kind::Layer | Kind::Group => n.children.iter().for_each(|c| visit(c, depth + 1, out)),
|
||
_ => {}
|
||
}
|
||
}
|
||
let mut out = Vec::new();
|
||
nodes.iter().for_each(|n| visit(n, 0, &mut out));
|
||
out
|
||
}
|
||
|
||
/// Which master page instance each of `pages` pages shows: (master, first page, first master
|
||
/// page) of the first instance in `instances` that covers it. Each page is settled once (the
|
||
/// next page still open is found by a path-halving jump), so this is about linear in pages and
|
||
/// instances however much their ranges overlap.
|
||
pub(super) fn page_masters(instances: &[(usize, usize, usize, usize)], pages: usize) -> Vec<Option<(usize, usize, usize)>> {
|
||
fn open_from(next: &mut [usize], mut i: usize) -> usize {
|
||
while let Some(&n) = next.get(i) {
|
||
if n == i {
|
||
break;
|
||
}
|
||
let skip = next.get(n).copied().unwrap_or(n);
|
||
if let Some(slot) = next.get_mut(i) {
|
||
*slot = skip;
|
||
}
|
||
i = n;
|
||
}
|
||
i
|
||
}
|
||
let mut owner = vec![None; pages];
|
||
// `next[p]` leads towards the first page from `p` on with no master yet (`pages`: none).
|
||
let mut next: Vec<usize> = (0..=pages).collect();
|
||
for &(master, first, master_page, count) in instances {
|
||
let end = first.saturating_add(count).min(pages);
|
||
let mut p = open_from(&mut next, first.min(pages));
|
||
while p < end {
|
||
if let Some(o) = owner.get_mut(p) {
|
||
*o = Some((master, first, master_page));
|
||
}
|
||
if let Some(n) = next.get_mut(p) {
|
||
*n = p + 1;
|
||
}
|
||
p = open_from(&mut next, p + 1);
|
||
}
|
||
}
|
||
owner
|
||
}
|
||
|
||
/// Master names: A, B … Z, then A1, B1 ….
|
||
pub(super) fn master_prefix(index: usize) -> String {
|
||
let letter = char::from(b'A' + (index % 26) as u8);
|
||
match index / 26 {
|
||
0 => letter.to_string(),
|
||
n => format!("{letter}{n}"),
|
||
}
|
||
}
|
||
|
||
/// A table cell's text `w` × `h` at the origin, placed as Affinity places it. Affinity aligns the
|
||
/// block from the first line's capitals' tops to the last baseline in the cell, and draws it even
|
||
/// where it doesn't fit (centred cells measured on a document's thumbnail: two lines in a cell
|
||
/// shorter than them reach out of it at both ends). VectorCraft aligns the block down to the last
|
||
/// line's descenders and keeps lines inside the frame: the frame moves by what this returns (down
|
||
/// the cell) and grows where the lines need more room.
|
||
pub(super) fn place_cell(obj: &mut TextObject, w: f64, h: f64) -> f64 {
|
||
let share = match obj.area.vertical_align {
|
||
VerticalAlign::Center => 0.5,
|
||
VerticalAlign::Bottom => 1.0,
|
||
_ => 0.0,
|
||
};
|
||
let mut tall = obj.clone();
|
||
tall.area.vertical_align = VerticalAlign::Top;
|
||
tall.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(0.0, 0.0, w, h * 4.0 + 10_000.0)) };
|
||
let lines = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &tall).lines;
|
||
let Some(last) = lines.iter().rfind(|l| l.region == 0) else { return 0.0 };
|
||
let (baseline, descent) = (last.baseline, last.descent);
|
||
if !(baseline.is_finite() && descent.is_finite() && h.is_finite()) {
|
||
return 0.0;
|
||
}
|
||
// (A little more than the lines need, for the rounding of the layout.)
|
||
let frame = h.max(baseline + descent + 0.05);
|
||
obj.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(0.0, 0.0, w, frame)) };
|
||
// Where Affinity has the block's top, less where VectorCraft puts it in the frame.
|
||
(h - baseline) * share - (frame - baseline - descent) * share
|
||
}
|
||
|
||
/// Area type `w` × `h` at the origin whose lines don't all fit. Affinity shows each line whose
|
||
/// baseline is inside the frame, its descenders hanging out of it; VectorCraft's area type leaves
|
||
/// such a line out. The frame is made taller, from its top, by what those lines need. Whether it was.
|
||
pub(super) fn fit_lines(obj: &mut TextObject, w: f64, h: f64) -> bool {
|
||
let db = vectorcraft_text::FontDb::global();
|
||
if !(w > 0.0 && h > 0.0 && h.is_finite()) {
|
||
return false;
|
||
}
|
||
let first = vectorcraft_text::layout(db, obj);
|
||
if !first.overflow {
|
||
return false;
|
||
}
|
||
// Where the lines go in a frame with room for all of them.
|
||
let mut tall = obj.clone();
|
||
tall.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(0.0, 0.0, w, h * 4.0 + 10_000.0)) };
|
||
let need = vectorcraft_text::layout(db, &tall)
|
||
.lines
|
||
.iter()
|
||
.filter(|l| l.region == 0 && l.baseline <= h + 1e-6)
|
||
.map(|l| l.baseline + l.descent)
|
||
.filter(|b| b.is_finite())
|
||
.fold(0.0, f64::max);
|
||
if need <= h {
|
||
return false;
|
||
}
|
||
let before = first.lines.len();
|
||
// (A little more than they need, for the rounding of the layout.)
|
||
let short = std::mem::replace(&mut obj.kind, TextKind::Area { frame: shapes::rectangle(Rect::new(0.0, 0.0, w, need + 0.05)) });
|
||
// Something else keeps the lines out: as the source has it.
|
||
if vectorcraft_text::layout(db, obj).lines.len() <= before {
|
||
obj.kind = short;
|
||
return false;
|
||
}
|
||
true
|
||
}
|
||
|
||
/// RGBA pixels as a PNG file.
|
||
pub(super) fn png(width: u32, height: u32, rgba: Vec<u8>) -> Option<Vec<u8>> {
|
||
let raw =
|
||
craft_image_codecs::Image::from_raw(width, height, craft_image_codecs::ChannelLayout::Rgba, craft_image_codecs::SampleType::U8, rgba).ok()?;
|
||
craft_image_codecs::encode(&raw, craft_image_codecs::Format::Png, &craft_image_codecs::EncodeOptions::default()).ok()
|
||
}
|
||
|
||
/// Where a line of `w` starts in a span from 0 to `room` (as a share of `room - w`).
|
||
fn share(j: Justify) -> f64 {
|
||
match j {
|
||
Justify::Center | Justify::JustifyCenter => 0.5,
|
||
Justify::Right | Justify::JustifyRight => 1.0,
|
||
_ => 0.0,
|
||
}
|
||
}
|
||
|
||
/// Artistic text whose paragraphs are aligned differently. Affinity aligns each line within the
|
||
/// width of the longest, and places that block at the anchor by the text's own alignment (its
|
||
/// first paragraph's); VectorCraft's point type aligns each line on the anchor. Indents move the
|
||
/// lines to where Affinity has them and keep their alignment: a centred line centres between its
|
||
/// indents and a right-aligned one ends at its right indent, whatever its width.
|
||
pub(super) fn align_lines(obj: &mut TextObject) {
|
||
let block = share(obj.para.justify);
|
||
if obj.paras.iter().all(|p| share(p.justify) == block) {
|
||
return;
|
||
}
|
||
let lines = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), obj).lines;
|
||
// Each line as wide as VectorCraft aligns it: without the tracking after its last character.
|
||
let w = lines.iter().map(|l| l.x1 - l.trailing - l.x0).filter(|w| w.is_finite()).fold(0.0, f64::max);
|
||
if !(w > 0.0 && w < 1e6) {
|
||
return;
|
||
}
|
||
// The block's left edge, from the anchor.
|
||
let left = -w * block;
|
||
for p in &mut obj.paras {
|
||
let at = share(p.justify);
|
||
let shift = left + w * at;
|
||
// A left-aligned line starts at its left indent, a right-aligned one ends at minus its right
|
||
// indent, and a centred one centres on half their difference.
|
||
if at < 0.25 {
|
||
p.left_indent += shift;
|
||
} else if at > 0.75 {
|
||
p.right_indent -= shift;
|
||
} else {
|
||
p.left_indent += shift;
|
||
p.right_indent -= shift;
|
||
}
|
||
}
|
||
if let Some(first) = obj.paras.first() {
|
||
obj.para = first.clone();
|
||
}
|
||
}
|
||
|
||
pub(super) fn justify(a: AfAlign) -> Justify {
|
||
match a {
|
||
AfAlign::Left => Justify::Left,
|
||
AfAlign::Center => Justify::Center,
|
||
AfAlign::Right => Justify::Right,
|
||
AfAlign::Justify => Justify::JustifyLeft,
|
||
}
|
||
}
|
||
|
||
/// A font's line gap in em, as VectorCraft will set it (the installed face, or the fallback for
|
||
/// a missing one); 0 when no font is loaded.
|
||
pub(super) fn line_gap(family: &str, style: &str) -> f64 {
|
||
let defaults = CharStyle::default();
|
||
let family = if family.is_empty() { defaults.font_family.as_str() } else { family };
|
||
let style = if style.is_empty() { defaults.font_style.as_str() } else { style };
|
||
let Some(face) = vectorcraft_text::FontDb::global().face(family, style) else { return 0.0 };
|
||
let upem = face.units_per_em();
|
||
let gap = if upem > 0.0 { face.line_gap() / upem } else { 0.0 };
|
||
if gap.is_finite() { gap.clamp(0.0, 2.0) } else { 0.0 }
|
||
}
|
||
|
||
pub(super) fn font_style(weight: i64, italic: bool) -> String {
|
||
let w = match weight {
|
||
..=150 => "Thin",
|
||
151..=250 => "ExtraLight",
|
||
251..=325 => "Light",
|
||
326..=450 => "Regular",
|
||
451..=550 => "Medium",
|
||
551..=650 => "SemiBold",
|
||
651..=750 => "Bold",
|
||
751..=850 => "ExtraBold",
|
||
_ => "Black",
|
||
};
|
||
match (w, italic) {
|
||
("Regular", true) => "Italic".into(),
|
||
(w, true) => format!("{w} Italic"),
|
||
(w, false) => w.into(),
|
||
}
|
||
}
|