Files
vectorcraft/crates/engine/src/cmd/fileio/affinity/layout.rs
T
FredApps 31658546a8 fix(codecs): build the cutover against craft-libs d6cd7836d
- 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.
2026-11-15 18:05:45 +01:00

224 lines
9.4 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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(),
}
}