VectorCraft: An open-source, vector art tool written by scratch in pure Rust
refactor(eps): move legacy_ai.rs items to legacy_ai/{encoding,prolog,writer}.rs
aiongg722ecade76ab
diff --git a/crates/eps/src/legacy_ai.rs b/crates/eps/src/legacy_ai.rsindex fde4cb505..fc7d6e9d9 100644--- a/crates/eps/src/legacy_ai.rs+++ b/crates/eps/src/legacy_ai.rs@@ -72,6 +72,17 @@ use vectorcraft_geom::{Affine, AnchorKind, BezPath, FillRule, PathData, Point, Ruse crate::{latin, ps};+mod encoding;+mod prolog;+mod writer;++#[cfg(test)]+use encoding::writable;+use encoding::{gradient_def, latin_string};+pub(crate) use prolog::PROCSET;+use prolog::{PROLOG, PS_HEADER, fonts};+use writer::Writer;+/// How deep symbols and live objects may nest in one another (deeper art is left out). Groups and/// layers need no limit of their own: a document is never deeper than/// [`vectorcraft_doc::MAX_DEPTH`].@@ -226,1254 +237,5 @@ pub fn export_legacy_ai(doc: &Document, o: &LegacyAiOptions) -> Result<LegacyAiOOk(LegacyAiOutput { bytes: s.into_bytes(), warnings: w.warnings })}-/// The setup's fonts (§3.1, §3.3): `%%IncludeFont` for each, the encoding strings are in (`TE`),-/// and each font re-encoded to it as `_name` (`TZ`; a TrueType font takes the encoding as its own,-/// not the standard one, as the specification says of fonts that aren't Type 1).-fn fonts(s: &mut String, fonts: &[(String, bool)]) {- if fonts.is_empty() {- return;- }- for (name, _) in fonts {- let _ = writeln!(s, "%%IncludeFont: {name}");- }- let te = latin::te();- s.push_str(&te);- // The encoding pairs, without `[` and `TE`.- let pairs = te.trim_start_matches('[').trim_end().trim_end_matches("TE").trim_end();- for (name, truetype) in fonts {- let _ = writeln!(s, "%AI3_BeginEncoding: _{name} {name}");- if *truetype {- let _ = writeln!(s, "[{pairs}\n/_{name}/{name} 0 0 0 TZ\n%AI3_EndEncoding TrueType");- } else {- let _ = writeln!(s, "[/_{name}/{name} 0 0 1 TZ\n%AI3_EndEncoding AdobeType");- }- }-}--/// The prolog's procedure set, as `%%DocumentSuppliedResources` names it: a file that has it is-/// read from its program when its layers are asked for ([`crate::import_with`]).-pub(crate) const PROCSET: &str = "VectorCraft_Legacy 1 0";--/// The prolog: a procedure set of this writer's own (`VectorCraft_Legacy 1 0`), in a dictionary-/// (`VCLegacy`) the setup begins and the trailer ends (§1.2: the prolog holds definitions only,-/// the setup activates them, the trailer deactivates them). It gives each operator the script-/// uses its meaning in PostScript, so that the file prints and previews as a PostScript program,-/// written from the PostScript Language Reference and this format's specification (no other-/// application's procedure set): paths and their painting with the fill and stroke colours,-/// compound paths painted as one path, clipping groups, guides that don't print, layers that are-/// hidden or don't print marking nothing, and images drawn from the samples on the comment lines-/// that follow `XI`. Gradients fill with the colour set before them (the writer sets the first-/// stop's), and type marks nothing: apps that read the format draw both. The page trailer's-/// `annotatepage` (§3, Script Setup: `gsave annotatepage grestore showpage`) marks nothing.-const PROLOG: &str = "%%BeginResource: procset VectorCraft_Legacy 1 0-/VCLegacy 96 dict def-VCLegacy begin-/bd {bind def} bind def-% State: the fill and stroke colours (procedures that set them), their overprints, the fill rule,-% a clip to make at the next painting operator, a compound path being built, a guide being-% drawn, whether the layer prints, and what the compound path is painted with.-/_fc {0 setgray} def /_sc {0 setgray} def-/_fo false def /_so false def /_eo false def /_w false def /_cp false def /_g false def-/_on true def /_rf false def /_rs false def-% Painting: a fill and a stroke that keep the path; the path painted as _rf and _rs say (after-% the clip W asked for), then ended.-/_fill {gsave _fc _fo setoverprint _eo {eofill} {fill} ifelse grestore} bd-/_stroke {gsave _sc _so setoverprint stroke grestore} bd-/_draw {_w {_eo {eoclip} {clip} ifelse /_w false def} if- _on _g not and {_rf {_fill} if _rs {_stroke} if} if newpath} bd-% close? fill? stroke? _r: paints now, or at the end of the compound path being built.-/_r {/_rs exch def /_rf exch def {closepath} if _cp not {_draw} if} bd-% Path construction (section 5.3.2) and painting (5.3.3).-/m {moveto} bd /l {lineto} bd /L {lineto} bd /c {curveto} bd /C {curveto} bd-/N {false false false _r} bd /n {true false false _r} bd-/F {false true false _r} bd /f {true true false _r} bd-/S {false false true _r} bd /s {true false true _r} bd-/B {false true true _r} bd /b {true true true _r} bd-/XR {1 eq /_eo exch def} bd-% Compound paths (5.3.5): one path, painted at its end.-/*u {/_cp true def} bd /*U {/_cp false def _draw} bd-% Groups, clipping groups and masks (5.6), locking (5.1), guides (6.1).-/u {} bd /U {} bd /q {gsave} bd /Q {grestore} bd-/H {} bd /h {closepath} bd /W {/_w true def} bd-/A {pop} bd-/* {pop _g {newpath /_g false def} {/_g true def} ifelse} bd-% Colours (5.4): fill and stroke colours, overprints; a custom colour as its CMYK equivalent at-% its tint (tint 0 is the full colour).-/g {/setgray load 2 array astore cvx /_fc exch def} bd-/G {/setgray load 2 array astore cvx /_sc exch def} bd-/k {/setcmykcolor load 5 array astore cvx /_fc exch def} bd-/K {/setcmykcolor load 5 array astore cvx /_sc exch def} bd-/Xa {/setrgbcolor load 4 array astore cvx /_fc exch def} bd-/XA {/setrgbcolor load 4 array astore cvx /_sc exch def} bd-/_tint {1 exch sub /_t exch def pop 4 {_t mul 4 1 roll} repeat} bd-/x {_tint k} bd /X {_tint K} bd-/O {1 eq /_fo exch def} bd /R {1 eq /_so exch def} bd-/w {setlinewidth} bd /J {setlinecap} bd /j {setlinejoin} bd /M {setmiterlimit} bd /d {setdash} bd-% Gradients (3.5): definitions are skipped; an instance fills with the colour set before it-% (the writer sets its first stop's), and BB strokes the path as its flag says.-/Bn {pop} bd /Bd {pop pop pop} bd /BD {cleartomark} bd-/Bb {gsave} bd /Bg {12 {pop} repeat} bd /Bh {pop pop pop pop} bd-/BB {grestore _cp {0 gt {/_rs true def} if}- {dup 2 eq {closepath} if 0 gt _on and {_stroke} if newpath} ifelse} bd-% Layers (9): a layer that is hidden or doesn't print marks nothing.-/Lb {6 {pop} repeat exch pop exch pop 1 eq exch 1 eq and /_on exch def} bd-/Ln {pop} bd /LB {/_on true def} bd-% Images (8): the samples, in hex on the comment lines that follow XI, read a line at a time.-/_l 256 string def /_s 128 string def-/_row {{currentfile _l readline not {exit} if dup length 1 gt {exit} if pop} loop- dup length 1 gt {dup length 1 sub 1 exch getinterval /ASCIIHexDecode filter _s readstring pop} {pop ()} ifelse} bd-/XI {pop pop pop pop /_ic exch def /_ib exch def /_ih exch def /_iw exch def pop pop pop pop- [1 0 0 -1 0 0] exch matrix concatmatrix- _on {gsave concat _iw _ih _ib [1 0 0 1 0 0] /_row load false _ic 1 eq {1} {_ic} ifelse colorimage grestore} {pop} ifelse} bd-% Type (15) is set by the app that reads the file: its operators take their operands and mark-% nothing; encodings (3.3) are skipped.-/TE {cleartomark} bd /TZ {cleartomark} bd-/To {pop} bd /Tp {7 {pop} repeat} bd /TP {} bd /TO {} bd-/Tr {pop} bd /Tf {pop pop pop pop} bd /Ts {pop} bd /Tz {pop pop} bd /Tt {pop} bd /TA {pop} bd-/Tl {pop pop} bd /Ta {pop} bd /Ti {pop pop pop} bd /Tx {pop} bd-% The page trailer (3): annotatepage marks nothing.-/annotatepage {} bd-end-%%EndResource-";--/// The first line of a PostScript file (the DSC version comment).-const PS_HEADER: &str = "%!PS-Adobe-3.0"; // brand-ok: the PostScript header comment--/// A gradient definition: `%AI5_BeginGradient: (name)`, `(name) type stops Bd`, `[`, the stops-/// (`colorSpec colorStyle midPoint rampPoint %_Bs`, each with its midpoint to the next stop), `BD`,-/// `%AI5_EndGradient`. A linear gradient's stops are listed from the last to the first (§1.4.3). A-/// radial gradient's stops are listed from the first to the last, as in §3.5.2's radial-/// definition (10, then 100).-fn gradient_def(s: &mut String, w: &Writer, name: &str, g: &Gradient) {- let name = latin_string(name);- let radial = g.kind == GradientKind::Radial;- let kind = if radial { 1 } else { 0 };- let _ = writeln!(s, "%AI5_BeginGradient: {name}\n{name} {kind} {} Bd\n[", g.stops.len());- let mut stops: Vec<_> = g.stops.iter().collect();- if !radial {- stops.reverse();- }- for stop in stops {- let paint = Paint::Solid { color: stop.color, swatch: stop.swatch.clone(), tint: stop.tint };- match w.ink(&paint) {- Ink::Gray(v) => {- ps::push_num(s, f64::from(v));- s.push_str(" 0 ");- }- Ink::Cmyk(c) => {- ps::push_nums(s, &c.map(f64::from));- s.push_str("1 ");- }- Ink::Rgb(c, rgb) => {- ps::push_nums(s, &c.map(f64::from));- ps::push_nums(s, &rgb.map(f64::from));- s.push_str("2 ");- }- Ink::Spot { cmyk, name, tint } => {- ps::push_nums(s, &cmyk.map(f64::from));- let _ = write!(s, "{} ", latin_string(w.spot_name(&name)));- ps::push_num(s, f64::from(1.0 - tint));- s.push_str(" 3 ");- }- }- ps::push_nums(s, &[f64::from(stop.midpoint) * 100.0, f64::from(stop.offset) * 100.0]);- s.push_str("%_Bs\n");- }- s.push_str("BD\n%AI5_EndGradient\n");-}--/// A colour as the format writes it.-#[derive(Clone, Debug, PartialEq)]-enum Ink {- /// Lightness (1 is white).- Gray(f32),- Cmyk([f32; 4]),- /// RGB, with its CMYK equivalent.- Rgb([f32; 4], [f32; 3]),- /// A spot colour's full CMYK equivalent, name and tint (1: full).- Spot {- cmyk: [f32; 4],- name: String,- tint: f32,- },-}--fn unit(v: f32) -> f32 {- if v.is_finite() { v.clamp(0.0, 1.0) } else { 0.0 }-}--/// Can `a` be drawn through (a finite, non-flat map)?-fn invertible(a: Affine) -> bool {- let det = a.determinant();- det.is_finite() && det.abs() > 1e-12-}--/// Name `name` as a PostScript string of its characters' Windows-1252 codes (a character outside-/// Windows-1252 is left out: [`Writer::latin_name`] replaces them first).-fn latin_string(name: &str) -> String {- let bytes: Vec<u8> = name.chars().filter_map(latin::encode).collect();- ps::bytes(&bytes)-}--struct Writer<'a> {- doc: &'a Document,- /// The document → art space.- to_art: Affine,- cms: Arc<Cms>,- body: String,- /// Gradient definitions, by the name objects use.- gradients: Vec<(String, Gradient)>,- /// Spot colors used: the name written and full CMYK equivalent.- spots: Vec<(String, [f32; 4])>,- /// The name each spot color (by its swatch's name) is written with ([`Self::spot`]).- spot_names: Vec<(String, String)>,- warnings: Vec<String>,- /// The lock state the last `A` set.- locked: bool,- /// Symbols and live objects being written inside one another.- nest: u32,- /// What to do with hidden objects.- hidden: HiddenObjects,- /// Type as outlines.- outline_text: bool,- /// The layer being written's hidden objects for its hidden layer, and whether each is locked.- hidden_art: Vec<(Node, bool)>,- /// Writing a layer that is hidden (or the hidden layer of one's hidden objects): hidden objects- /// are written where they are.- in_hidden: bool,- /// The fonts type is set in: PostScript name, and whether it's TrueType.- fonts: Vec<(String, bool)>,-}--impl<'a> Writer<'a> {- fn new(doc: &'a Document, to_art: Affine, o: &LegacyAiOptions) -> Self {- Self {- doc,- to_art,- cms: vectorcraft_color::cms::active(),- body: String::new(),- gradients: vec![],- spots: vec![],- spot_names: vec![],- warnings: vec![],- locked: false,- nest: 0,- hidden: o.hidden,- outline_text: o.outline_text,- hidden_art: vec![],- in_hidden: false,- fonts: vec![],- }- }-- fn warn(&mut self, w: &str) {- if !self.warnings.iter().any(|x| x == w) {- self.warnings.push(w.to_string());- }- }-- fn line(&mut self, s: &str) {- self.body.push_str(s);- self.body.push('\n');- }-- // ---------- layers and objects ------------ /// `name` with each character outside Windows-1252 (the encoding type and names are written- /// in) replaced by `?`; adds the warning `warning` when it replaces one.- fn latin_name(&mut self, name: &str, warning: &str) -> String {- let mut lost = false;- let kept = name- .chars()- .map(|c| {- if latin::encode(c).is_some() {- c- } else {- lost = true;- '?'- }- })- .collect();- if lost {- self.warn(warning);- }- kept- }-- /// A layer's name as a PostScript string in Windows-1252, like the type; a character outside it- /// is written as `?`, with a warning.- fn layer_name(&mut self, name: &str) -> String {- latin_string(&self.latin_name(name, LAYER_NAME))- }-- /// Note spot color `name` (its swatch's name), of full CMYK equivalent `cmyk`, as a custom- /// color of the document, and give the name it is written with. Its characters outside- /// Windows-1252 are written as `?` (with a warning), and it is numbered when another spot color- /// is already written with that name; the name is the same each time.- fn spot(&mut self, name: &str, cmyk: [f32; 4]) -> String {- let written = match self.spot_names.iter().find(|(n, _)| n == name) {- Some((_, w)) => w.clone(),- None => {- let base = self.latin_name(name, TITLE_AND_COLOR_NAMES);- let mut written = base.clone();- let mut i = 1;- while self.spot_names.iter().any(|(_, w)| *w == written) {- i += 1;- written = format!("{base} {i}");- }- self.spot_names.push((name.to_string(), written.clone()));- written- }- };- if !self.spots.iter().any(|(n, _)| *n == written) {- self.spots.push((written.clone(), cmyk));- }- written- }-- /// The name spot color `name` (its swatch's name) is written with, once [`Self::spot`] has- /// noted it.- fn spot_name<'n>(&'n self, name: &'n str) -> &'n str {- self.spot_names.iter().find(|(n, _)| n == name).map_or(name, |(_, w)| w.as_str())- }-- /// A top-level layer. False when it isn't a layer.- fn layer(&mut self, n: &Node) -> bool {- let NodeKind::Layer { color, template, printable, children, clip, preview, dim_images } = &n.kind else { return false };- let [r, g, b] = match color {- LayerColor::Preset(i) => LAYER_COLORS.get(usize::from(*i)).map_or([79, 128, 255], |c| c.1),- LayerColor::Custom(rgb) => *rgb,- };- let index = match color {- LayerColor::Preset(i) if usize::from(*i) < LAYER_COLORS.len() => i64::from(*i),- _ => -1,- };- let flag = |b: bool| u8::from(b);- let name = self.layer_name(n.name.as_deref().unwrap_or("Layer"));- // A template layer doesn't print and shows dimmed.- let _ = writeln!(- self.body,- "%AI5_BeginLayer\n{} {} {} {} {} 0 {index} {r} {g} {b} Lb\n{} Ln",- flag(n.visible),- flag(*preview),- flag(!n.locked),- flag(*printable && !*template),- flag(dim_images.is_some() || *template),- name,- );- self.locked = false;- self.line("0 A");- self.in_hidden = !n.visible;- self.contents(children, *clip, false);- self.in_hidden = false;- self.line("LB\n%AI5_EndLayer--");- true- }-- /// The hidden layer of top-level layer `n`'s hidden objects, just above it (named after it,- /// with its colour, lock and printing). False when it has none.- fn hidden_layer(&mut self, n: &Node) -> bool {- if self.hidden_art.is_empty() {- return false;- }- let art = std::mem::take(&mut self.hidden_art);- let NodeKind::Layer { color, template, printable, .. } = &n.kind else { return false };- let [r, g, b] = match color {- LayerColor::Preset(i) => LAYER_COLORS.get(usize::from(*i)).map_or([79, 128, 255], |c| c.1),- LayerColor::Custom(rgb) => *rgb,- };- let index = match color {- LayerColor::Preset(i) if usize::from(*i) < LAYER_COLORS.len() => i64::from(*i),- _ => -1,- };- let name = format!("{} (hidden)", n.name.as_deref().unwrap_or("Layer"));- let name = self.layer_name(&name);- let _ = writeln!(- self.body,- "%AI5_BeginLayer\n0 1 {} {} {} 0 {index} {r} {g} {b} Lb\n{} Ln",- u8::from(!n.locked),- u8::from(*printable && !*template),- u8::from(*template),- name,- );- self.locked = false;- self.line("0 A");- self.in_hidden = true;- for (node, locked) in &art {- self.node(node, *locked);- }- self.in_hidden = false;- self.line("LB\n%AI5_EndLayer--");- true- }-- /// A container's members, the first clipping the others when `clip`; `locked`: the container is.- fn contents(&mut self, children: &[Arc<Node>], clip: bool, locked: bool) {- if clip {- self.clip_group(children, locked);- } else {- for c in children {- self.node(c, locked);- }- }- }-- /// Set the lock state of the objects that follow.- fn lock(&mut self, locked: bool) {- if locked != self.locked {- self.locked = locked;- self.line(if locked { "1 A" } else { "0 A" });- }- }-- /// One object (inside a container locked when `locked`).- fn node(&mut self, n: &Node, locked: bool) {- if !n.visible && !self.in_hidden {- match self.hidden {- HiddenObjects::Omit => {- self.warn(HIDDEN);- return;- }- HiddenObjects::Layer => {- self.warn(HIDDEN_LAYER);- self.hidden_art.push((n.clone(), locked || n.locked));- return;- }- HiddenObjects::Visible => self.warn(HIDDEN_SHOWN),- }- }- if n.opacity < 1.0 || n.blend != BlendMode::Normal || n.extras().mask.as_ref().is_some_and(|m| !m.disabled) {- self.warn(TRANSPARENCY);- }- if n.name.as_deref().is_some_and(|s| !s.is_empty()) && !n.is_layer() {- self.warn(NAMES);- }- let locked = locked || n.locked;- match &n.kind {- NodeKind::Layer { children, clip, .. } => {- self.warn(SUBLAYERS);- self.group(children, *clip, locked);- }- NodeKind::Group { children, clip } => self.group(children, *clip, locked),- NodeKind::Path { path, rule, guide, .. } => {- self.lock(locked);- if *guide {- self.guide(path);- } else {- self.shape(n, path, *rule);- }- }- NodeKind::Compound { children, rule } => {- self.lock(locked);- let mut subpaths = vec![];- for p in children.iter().filter_map(|c| c.path_data()) {- subpaths.extend(p.subpaths.iter().cloned());- }- self.shape(n, &PathData::new(subpaths), *rule);- }- NodeKind::Text(t) => {- self.lock(locked);- self.text(t);- }- NodeKind::Image(im) => {- self.lock(locked);- self.image(self.doc.image_blob(im), im.width, im.height, im.xf);- }- NodeKind::SymbolInstance { symbol, xf } => {- self.warn(LIVE);- if let Some(sym) = self.doc.symbols.iter().find(|s| &s.name == symbol)- && self.nest < MAX_NEST- {- let mut art = (*sym.art).clone();- art.transform(*xf, false);- art.visible = true;- self.nest += 1;- self.node(&art, locked);- self.nest -= 1;- }- }- NodeKind::Blend { .. }- | NodeKind::Envelope { .. }- | NodeKind::Mesh(_)- | NodeKind::Repeat(_)- | NodeKind::PlacedDocument(_)- | NodeKind::Intertwine { .. } => {- self.warn(LIVE);- if self.nest < MAX_NEST {- let g = vectorcraft_effects::expand_live_deep(Some(self.doc), n);- self.nest += 1;- if let Some(children) = g.children() {- self.group(children, false, locked);- }- self.nest -= 1;- }- }- }- }-- /// A group (`u` … `U`), or a clipping group (`q` … `Q`).- fn group(&mut self, children: &[Arc<Node>], clip: bool, locked: bool) {- if children.is_empty() {- return;- }- self.lock(locked);- if clip {- self.clip_group(children, locked);- } else {- self.line("u");- self.contents(children, false, locked);- self.lock(locked);- self.line("U");- }- }-- /// A clipping group: its first member's outline clips the others (`h W n`). That member's fills- /// paint behind the art, inside the clip, and its strokes over it, outside.- fn clip_group(&mut self, children: &[Arc<Node>], locked: bool) {- let Some((clip, rest)) = children.split_first() else { return };- // Nothing to clip by hides the clipped art.- let Some((outline, rule)) = vectorcraft_effects::clip_outline(clip) else { return };- let paint = clip.clip_paint();- self.lock(locked);- self.line("q");- let path = PathData::from_bezpath(&outline);- self.fill_rule(rule);- let several = path.subpaths.len() > 1;- if several {- self.line("*u");- }- for sp in path.subpaths.iter().filter(|sp| !sp.anchors.is_empty()) {- self.mask(sp);- }- if several {- self.line("*U");- }- if let Some(fill) = &paint.fill {- self.node(fill, locked);- }- for c in rest {- self.node(c, locked);- }- self.lock(locked);- self.line("Q");- if let Some(stroke) = &paint.stroke {- self.node(stroke, locked);- }- }-- // ---------- paths ------------ /// A clipping path (§5.6.2): its points, `h` (closed) or `H`, `W`, then painted with nothing.- fn mask(&mut self, sp: &SubPath) {- self.subpath(sp);- self.line(if sp.closed { "h\nW\nn" } else { "H\nW\nN" });- }-- /// A guide (§6): `(N) *`, its path, `(N) *`.- fn guide(&mut self, path: &PathData) {- for sp in path.subpaths.iter().filter(|sp| !sp.anchors.is_empty()) {- self.line("(N) *");- self.subpath(sp);- self.line("(N) *");- }- }-- /// A path's fills and strokes: one object with one fill and a plain stroke over it where it- /// can be, else a group of an object for each (in paint order).- fn shape(&mut self, n: &Node, path: &PathData, rule: FillRule) {- if path.is_empty() {- return;- }- let items: Vec<&AppearanceItem> = n- .appearance- .items- .iter()- .filter(|i| match i {- AppearanceItem::Fill(f) => f.visible && !f.paint.is_none(),- AppearanceItem::Stroke(s) => s.visible && !s.paint.is_none() && s.width > 0.0 && s.width.is_finite(),- })- .collect();- for i in &items {- if i.opacity() < 1.0 || i.blend() != BlendMode::Normal {- self.warn(TRANSPARENCY);- }- }- match items.as_slice() {- [] => self.path_object(path, rule, None, None),- [AppearanceItem::Fill(f)] if direct_fill(&f.paint) => self.path_object(path, rule, Some(f), None),- [AppearanceItem::Stroke(s)] if direct_stroke(s) => self.path_object(path, rule, None, Some(s)),- [AppearanceItem::Fill(f), AppearanceItem::Stroke(s)] if direct_fill(&f.paint) && direct_stroke(s) => {- self.path_object(path, rule, Some(f), Some(s))- }- [one] => self.item(path, rule, one),- items => {- self.line("u");- for i in items {- self.item(path, rule, i);- }- self.line("U");- }- }- }-- /// One fill or stroke of a path as an object of its own.- fn item(&mut self, path: &PathData, rule: FillRule, item: &AppearanceItem) {- match item {- AppearanceItem::Fill(f) => self.fill_object(path, rule, f),- AppearanceItem::Stroke(s) if direct_stroke(s) => self.path_object(path, rule, None, Some(s)),- AppearanceItem::Stroke(s) => {- self.warn(STROKES);- let outline = stroke::outline_region(path, rule, s);- let fill = FillLayer { overprint: s.overprint, ..FillLayer::new(s.paint.clone()) };- self.fill_object(&outline, FillRule::NonZero, &fill);- }- }- }-- /// A fill as an object of its own: patterns as their tiles clipped to the path.- fn fill_object(&mut self, path: &PathData, rule: FillRule, f: &FillLayer) {- if direct_fill(&f.paint) {- return self.path_object(path, rule, Some(f), None);- }- let Paint::Pattern { pattern, xf } = &f.paint else {- // A freeform gradient: its average colour.- self.warn(FREEFORM);- let color = match &f.paint {- Paint::Gradient(g) => average(&g.gradient),- _ => Color::gray(0.5),- };- let flat = FillLayer { paint: Paint::solid(color), ..f.clone() };- return self.path_object(path, rule, Some(&flat), None);- };- self.warn(PATTERNS);- let doc = self.doc;- let Some(def) = doc.pattern(pattern) else {- let flat = FillLayer { paint: Paint::solid(Color::gray(0.5)), ..f.clone() };- return self.path_object(path, rule, Some(&flat), None);- };- let area = path.to_bezpath().bounding_box();- let tiles = def.instances_in(*xf, area);- self.line("q");- self.fill_rule(rule);- let several = path.subpaths.len() > 1;- if several {- self.line("*u");- }- for sp in path.subpaths.iter().filter(|sp| !sp.anchors.is_empty()) {- self.mask(sp);- }- if several {- self.line("*U");- }- let locked = self.locked;- for t in &tiles {- self.node(t, locked);- }- self.lock(locked);- self.line("Q");- }-- /// A path object painted with `fill` (a colour or a linear or radial gradient) and `stroke`- /// (a plain line of a colour) over it; several subpaths make a compound path.- fn path_object(&mut self, path: &PathData, rule: FillRule, fill: Option<&FillLayer>, stroke: Option<&StrokeLayer>) {- let subpaths: Vec<&SubPath> = path.subpaths.iter().filter(|sp| !sp.anchors.is_empty()).collect();- if subpaths.is_empty() {- return;- }- let gradient = match fill.map(|f| &f.paint) {- Some(Paint::Gradient(g)) => Some(self.gradient(g, path.to_bezpath().bounding_box())),- _ => None,- };- if let Some(f) = fill {- let paint = match &f.paint {- // The colour under the gradient: its first stop's.- Paint::Gradient(g) => g.gradient.stops.first().map_or(Paint::None, |s| Paint::solid(s.color)),- p => p.clone(),- };- self.color(&paint, false);- self.line(if f.overprint { "1 O" } else { "0 O" });- }- if let Some(s) = stroke {- self.color(&s.paint, true);- self.line(if s.overprint { "1 R" } else { "0 R" });- self.line_style(s);- }- self.fill_rule(rule);- let op = match (fill.is_some(), stroke.is_some()) {- (true, true) => 'b',- (true, false) => 'f',- (false, true) => 's',- (false, false) => 'n',- };- let several = subpaths.len() > 1;- if several {- self.line("*u");- }- for sp in subpaths {- self.subpath(sp);- if let Some(g) = &gradient {- // The gradient fills between `Bb` and `BB`, whose flag strokes the path too (§3.5.3).- self.body.push_str(g);- self.line(if sp.closed { "f" } else { "F" });- self.line(match (stroke.is_some(), sp.closed) {- (false, _) => "0 BB",- (true, false) => "1 BB",- (true, true) => "2 BB",- });- } else {- self.line(&if sp.closed { op.to_string() } else { op.to_ascii_uppercase().to_string() });- }- }- if several {- self.line("*U");- }- }-- /// `rule` as `XR` (1: even-odd).- fn fill_rule(&mut self, rule: FillRule) {- self.line(if rule == FillRule::EvenOdd { "1 XR" } else { "0 XR" });- }-- /// One subpath's points, in art space: `m`, then a line or curve to each point (lower case: the- /// point is smooth, upper case: a corner, §5.3.2), and for a closed one the segment back to the- /// start, which says whether the start is smooth or a corner (as the specification's examples- /// close paths: the start point again, then the painting operator).- fn subpath(&mut self, sp: &SubPath) {- let Some(first) = sp.anchors.first() else { return };- let xf = self.to_art;- let s = &mut self.body;- let pt = |s: &mut String, p: Point| {- let p = xf * p;- ps::push_nums(s, &[p.x, p.y]);- };- pt(s, first.p);- s.push_str("m\n");- let segment = |s: &mut String, a: &vectorcraft_geom::Anchor, b: &vectorcraft_geom::Anchor| {- let straight = a.h_out == a.p && b.h_in == b.p;- let smooth = b.kind == AnchorKind::Smooth;- if straight {- pt(s, b.p);- s.push_str(if smooth { "l\n" } else { "L\n" });- } else {- pt(s, a.h_out);- pt(s, b.h_in);- pt(s, b.p);- s.push_str(if smooth { "c\n" } else { "C\n" });- }- };- for pair in sp.anchors.windows(2) {- if let [a, b] = pair {- segment(s, a, b);- }- }- if sp.closed- && sp.anchors.len() > 1- && let Some(last) = sp.anchors.last()- {- segment(s, last, first);- }- }-- /// The stroke's width, cap, join, miter limit and dashes: `w J j M d`.- fn line_style(&mut self, st: &StrokeLayer) {- let cap = match st.cap {- LineCap::Butt => 0,- LineCap::Round => 1,- LineCap::Square => 2,- };- let join = match st.join {- LineJoin::Miter => 0,- LineJoin::Round => 1,- LineJoin::Bevel => 2,- };- let s = &mut self.body;- ps::push_num(s, st.width);- let _ = write!(s, " w {cap} J {join} j ");- ps::push_num(s, if st.miter_limit.is_finite() { st.miter_limit.max(1.0) } else { 10.0 });- s.push_str(" M [");- let dash = st.dash.as_ref().filter(|d| d.is_dashed());- if let Some(d) = dash {- ps::push_nums(s, &d.pattern);- s.pop();- }- s.push_str("] ");- ps::push_num(s, dash.map_or(0.0, |d| d.offset));- s.push_str(" d\n");- }-- // ---------- colour ------------ /// How `p` (a solid paint) is written.- fn ink(&self, p: &Paint) -> Ink {- let Paint::Solid { color, swatch, tint } = p else { return Ink::Gray(0.0) };- let doc = self.doc;- let intent = self.cms.settings().intent;- if let Some(name) = swatch- && let Some(sw) = doc.swatch(name).filter(|s| s.spot)- && let Some(full) = sw.paint.color()- {- let full = doc.linked_color(full, true);- return Ink::Spot { cmyk: self.cms.to_cmyk(&full, intent).map(unit), name: name.clone(), tint: unit(*tint) };- }- match *color {- // Grey is ink coverage; the format's grey is lightness.- Color::Gray { k } => Ink::Gray(unit(1.0 - k)),- Color::Cmyk { c, m, y, k } => Ink::Cmyk([c, m, y, k].map(unit)),- Color::Rgb { r, g, b } => Ink::Rgb(self.cms.to_cmyk(color, intent).map(unit), [r, g, b].map(unit)),- Color::Lab { .. } => {- let rgb = color.to_rgb().map(unit);- Ink::Rgb(self.cms.to_cmyk(color, intent).map(unit), rgb)- }- }- }-- /// Set the fill (or with `stroke`, the stroke) colour to solid paint `p`.- fn color(&mut self, p: &Paint, stroke: bool) {- let ink = match self.ink(p) {- Ink::Spot { cmyk, name, tint } => Ink::Spot { name: self.spot(&name, cmyk), cmyk, tint },- ink => ink,- };- let op = |fill: &'static str, line: &'static str| if stroke { line } else { fill };- let s = &mut self.body;- match ink {- Ink::Gray(v) => {- ps::push_num(s, f64::from(v));- let _ = writeln!(s, " {}", op("g", "G"));- }- Ink::Cmyk(c) => {- ps::push_nums(s, &c.map(f64::from));- let _ = writeln!(s, "{}", op("k", "K"));- }- Ink::Rgb(_, rgb) => {- ps::push_nums(s, &rgb.map(f64::from));- let _ = writeln!(s, "{}", op("Xa", "XA"));- }- Ink::Spot { cmyk, name, tint } => {- ps::push_nums(s, &cmyk.map(f64::from));- let _ = write!(s, "{} ", latin_string(&name));- // The format's tint is how much lighter than the full colour (0: full).- ps::push_num(s, f64::from(1.0 - tint));- let _ = writeln!(s, " {}", op("x", "X"));- }- }- }-- // ---------- gradients ------------ /// The definition gradient `g` uses (defined once for each distinct gradient), and its- /// instance on a path of bounds `bounds`: `Bb`, a radial's highlight `x y angle fraction Bh`- /// (its distance a fraction of the radius, at most 1, §3.5.5; `0 0 0 0 Bh` at the center,- /// §3.5.6), `1 (name) x y angle length 1 0 0 1 0 0 Bg`.- fn gradient(&mut self, g: &GradientPaint, bounds: Rect) -> String {- let name = self.define(&g.gradient, g.swatch.as_deref());- for stop in &g.gradient.stops {- if stop.opacity < 1.0 {- self.warn(TRANSPARENCY);- }- if let Some(sw) = &stop.swatch {- // Spot colours in stops are custom colours too.- let p = Paint::Solid { color: stop.color, swatch: Some(sw.clone()), tint: stop.tint };- if let Ink::Spot { cmyk, name, .. } = self.ink(&p) {- self.spot(&name, cmyk);- }- }- }- let geom = g.resolve(bounds);- let (start, end) = (self.to_art * geom.start, self.to_art * geom.end);- let d = end - start;- let (angle, length) = (d.y.atan2(d.x).to_degrees(), d.hypot());- // The matrix is relative to the origin of a canvas whose size the specification doesn't- // give (§3.5.4), so it stays the identity: an elliptical radial is written circular.- if g.gradient.kind == GradientKind::Radial && (geom.aspect - 1.0).abs() > 1e-6 {- self.warn(ELLIPTICAL);- }- let mut s = String::from("Bb\n");- if g.gradient.kind == GradientKind::Radial {- // Every radial instance has a highlight (§3.5.5), `0 0 0 0 Bh` at the center (§3.5.6).- // It lies within the gradient's circle: one past the radius is written on it.- let off: Vec2 = geom.focal.map_or(Vec2::ZERO, |f| self.to_art * f - start);- let fraction = if off.hypot() > 1e-9 && length > 1e-9 { off.hypot() / length } else { 0.0 };- let (off, angle) = if fraction > 0.0 { (off / fraction.max(1.0), off.y.atan2(off.x).to_degrees()) } else { (Vec2::ZERO, 0.0) };- ps::push_nums(&mut s, &[off.x, off.y, angle, fraction.min(1.0)]);- s.push_str("Bh\n");- }- s.push_str("1 ");- s.push_str(&latin_string(&name));- s.push(' ');- ps::push_nums(&mut s, &[start.x, start.y, angle, length]);- s.push_str("1 0 0 1 0 0 Bg\n");- s- }-- /// The name of the definition of `g` (its swatch's name when it has one, with each character- /// outside Windows-1252 written as `?` and a warning), defined the first time.- fn define(&mut self, g: &Gradient, swatch: Option<&str>) -> String {- if let Some((name, _)) = self.gradients.iter().find(|(_, d)| d == g) {- return name.clone();- }- let taken = |n: &str, defs: &[(String, Gradient)]| defs.iter().any(|(m, _)| m == n);- let base = self.latin_name(swatch.filter(|s| !s.is_empty()).unwrap_or("Gradient"), TITLE_AND_COLOR_NAMES);- let mut name = base.clone();- let mut i = 1;- while taken(&name, &self.gradients) {- i += 1;- name = format!("{base} {i}");- }- self.gradients.push((name.clone(), g.clone()));- name- }-- // ---------- type ------------ /// Type: a text object when the format can hold it as text, else its outlines.- fn text(&mut self, t: &TextObject) {- if !invertible(t.xf) {- return;- }- if !self.outline_text {- if writable(t) {- return self.text_object(t);- }- self.warn(TYPE);- }- self.outlines(t);- }-- /// A text object (§15): `type To`, the text path (`a b c d tx ty startPt Tp`, an area's frame- /// or the path type runs along, `TP`), then each run's style and characters, `TO`. The matrix- /// takes text space (y up, the first baseline's start for point type) to art space; the frame- /// and path are in art space, as the specification's examples have them (§15.5).- fn text_object(&mut self, t: &TextObject) {- if lost_attributes(t) {- self.warn(TYPE_ATTRIBUTES);- }- // Area type that Shrink Text to Fit scales down is written in the styles it draws in.- let fitted = matches!((&t.kind, t.area.fit), (TextKind::Area { .. }, vectorcraft_doc::AreaFit::ShrinkText { .. }))- .then(|| vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t).fit_scale)- .filter(|f| *f != 1.0)- .map(|f| vectorcraft_text::scaled(t, f));- let t = fitted.as_ref().unwrap_or(t);- let m = self.to_art * t.xf * Affine::new([1.0, 0.0, 0.0, -1.0, 0.0, 0.0]);- let (kind, path, start) = match &t.kind {- TextKind::Point => (0, None, 0.0),- TextKind::Area { frame } => (1, frame.subpaths.iter().find(|sp| !sp.anchors.is_empty()).cloned(), 0.0),- TextKind::OnPath { path, .. } => {- let sp = path.subpaths.iter().find(|sp| !sp.anchors.is_empty()).cloned();- let fraction = t.kind.path_span().map_or(0.0, |(s, _)| s);- let start = sp- .as_ref()- .map_or(0.0, |sp| segment_point(&PathData::new(vec![sp.clone()]).transformed(self.to_art * t.xf).to_bezpath(), fraction));- (2, sp, start)- }- };- let _ = writeln!(self.body, "{kind} To");- let [a, b, c, d, e, f] = m.as_coeffs();- ps::push_nums(&mut self.body, &[a, b, c, d, e, f, start]);- self.line("Tp");- if let Some(sp) = path {- let placed = SubPath::new(sp.anchors.iter().map(|a| a.transform(t.xf)).collect(), sp.closed);- self.subpath(&placed);- self.line(if sp.closed { "n" } else { "N" });- }- self.line("TP");- let mut para = 0usize;- let mut para_start = true;- for run in &t.runs {- let text = if run.style.all_caps { run.text.to_uppercase() } else { run.text.clone() };- let mut pieces = text.split('\n').peekable();- while let Some(piece) = pieces.next() {- let ends_paragraph = pieces.peek().is_some();- if piece.is_empty() && !ends_paragraph {- continue;- }- if para_start {- self.paragraph(t.para_at(para));- para_start = false;- }- self.char_style(&run.style, t.para_at(para));- let mut bytes: Vec<u8> = piece.chars().filter_map(latin::encode).collect();- if ends_paragraph {- bytes.push(b'\r');- para += 1;- para_start = true;- }- self.body.push_str(&ps::bytes(&bytes));- self.line(" Tx");- }- }- self.line("TO");- }-- /// A paragraph's attributes: alignment `Ta` and indents `Ti` (first line's, left, right).- fn paragraph(&mut self, p: &ParaStyle) {- let align = match p.justify {- Justify::Auto if p.direction == Some(ParaDirection::RightToLeft) => 2,- Justify::Auto | Justify::Left => 0,- Justify::Center => 1,- Justify::Right => 2,- Justify::JustifyLeft | Justify::JustifyCenter | Justify::JustifyRight => 3,- Justify::JustifyAll => 4,- };- let _ = writeln!(self.body, "{align} Ta");- ps::push_nums(&mut self.body, &[p.first_line_indent, p.left_indent, p.right_indent]);- self.line("Ti");- }-- /// A run's character attributes and paint style: `Tr`, its fill and stroke, `Tf`, `Ts`, `Tz`,- /// `Tt`, `TA`, and the leading with the space before its paragraph, `Tl`.- fn char_style(&mut self, st: &CharStyle, p: &ParaStyle) {- let fill = !st.fill.is_none();- let stroke = st.has_stroke();- let render = match (fill, stroke) {- (true, false) => 0,- (false, true) => 1,- (true, true) => 2,- (false, false) => 3,- };- let _ = writeln!(self.body, "{render} Tr");- if fill {- self.color(&st.fill, false);- self.line(if st.overprint_fill { "1 O" } else { "0 O" });- }- if stroke {- self.color(&st.stroke, true);- self.line(if st.overprint_stroke { "1 R" } else { "0 R" });- self.line_style(&st.stroke_layer());- }- let (name, truetype, ascent, descent) = font_of(st);- if !self.fonts.iter().any(|(n, _)| *n == name) {- self.fonts.push((name.clone(), truetype));- }- let size = finite(st.size, 12.0);- let _ = write!(self.body, "/_{name} ");- ps::push_nums(&mut self.body, &[size, ascent * size, descent * size]);- self.line("Tf");- ps::push_num(&mut self.body, finite(st.baseline_shift, 0.0));- self.line(" Ts");- ps::push_nums(&mut self.body, &[finite(st.h_scale, 100.0), finite(st.v_scale, 100.0)]);- self.line("Tz");- ps::push_num(&mut self.body, finite(st.tracking, 0.0));- self.line(" Tt");- self.line(if st.kerning.is_none() { "1 TA" } else { "0 TA" });- ps::push_nums(&mut self.body, &[finite(st.effective_leading(), size * 1.2), finite(p.space_before, 0.0)]);- self.line("Tl");- }-- /// Type as its glyphs' outlines: a group of a compound path for each run, with the run's fill- /// and stroke.- fn outlines(&mut self, t: &TextObject) {- let layout = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);- let scale = t.xf.determinant().abs().sqrt();- self.line("u");- for (i, run) in t.runs.iter().enumerate() {- let mut bp = BezPath::new();- // Ruby (furigana) glyphs in their base text's run's paint, as the canvas draws them.- for g in layout.glyphs.iter().chain(&layout.ruby).filter(|g| g.run == i) {- bp.extend(g.outline.iter());- }- if bp.elements().is_empty() {- continue;- }- bp.apply_affine(t.xf);- let path = PathData::from_bezpath(&bp);- let fill =- (!run.style.fill.is_none()).then(|| FillLayer { overprint: run.style.overprint_fill, ..FillLayer::new(run.style.fill.clone()) });- let stroke = run.style.has_stroke().then(|| {- let mut s = run.style.stroke_layer();- s.width *= scale;- s- });- let items: Vec<AppearanceItem> = fill.map(AppearanceItem::Fill).into_iter().chain(stroke.map(AppearanceItem::Stroke)).collect();- let mut n = Node::path(vectorcraft_doc::NodeId(0), path.clone(), vectorcraft_doc::Appearance::default());- n.appearance = vectorcraft_doc::Appearance { items, ..vectorcraft_doc::Appearance::default() }.into();- self.shape(&n, &path, FillRule::NonZero);- }- // Colour bitmap glyphs (emoji): their images, which the runs' paint doesn't paint.- for g in &layout.glyphs {- if let Some((image, to_text)) = g.placed_image() {- self.image(Some(&image.blob), image.width, image.height, t.xf * to_text);- }- // COLR glyphs: their layers, as art.- if let Some(art) = g.placed_colour(t.xf) {- self.node(&art, false);- }- }- self.line("U");- }-- // ---------- images ------------ /// An image (§8): `%AI5_File:`, `%AI5_BeginRaster`, its matrix (an art-space matrix applied to- /// the pixels with their rows running downwards, `(u, -v)`) as `[ a b c d tx ty ]` and its- /// operands with `XI`, its RGB samples in hex on comment lines of [`HEX_LINE`] digits,- /// `%AI5_EndRaster`, then `F`. §8.4's examples have no `F`; without it, an app reading the file- /// can leave out an image in a clipping group and the art after it. No path is open there, so- /// the `F` paints nothing. `blob` holds the pixels, placed as a grid of `width` × `height`- /// by `xf`.- fn image(&mut self, blob: Option<&ImageBlob>, width: u32, height: u32, xf: Affine) {- let flip = Affine::new([1.0, 0.0, 0.0, -1.0, 0.0, 0.0]);- let m = self.to_art * xf * flip;- if !invertible(m) {- return;- }- if blob.is_some_and(|b| b.bytes.is_empty()) {- self.warn(LARGE_IMAGE);- return;- }- let Some(img) = blob.and_then(|b| image::load_from_memory(&b.bytes).ok()) else {- self.warn(UNDECODED);- return;- };- let (w, h) = (img.width(), img.height());- if w == 0 || h == 0 || u64::from(w) * u64::from(h) > MAX_IMAGE_PIXELS {- self.warn(LARGE_IMAGE);- return;- }- // The object places the image's own pixel grid (its width × height) wherever the file's is.- let fit = Affine::scale_non_uniform(f64::from(width.max(1)) / f64::from(w), f64::from(height.max(1)) / f64::from(h));- let m = self.to_art * xf * fit * flip;- let rgba = img.to_rgba8();- let mut hex = String::with_capacity(rgba.len() / 4 * 7);- hex.push('%');- let mut on_line = 0;- let mut see_through = false;- for px in rgba.pixels() {- let [r, g, b, a] = px.0;- if a < 255 {- see_through = true;- }- // Over white.- let over = |c: u8| ((u32::from(c) * u32::from(a) + 255 * (255 - u32::from(a)) + 127) / 255) as u8;- for c in [over(r), over(g), over(b)] {- let _ = write!(hex, "{c:02X}");- on_line += 2;- if on_line >= HEX_LINE {- hex.push_str("\n%");- on_line = 0;- }- }- }- if hex.ends_with('%') {- hex.pop();- } else {- hex.push('\n');- }- if see_through {- self.warn(IMAGE_ALPHA);- }- let [a, b, c, d, e, f] = m.as_coeffs();- let s = &mut self.body;- s.push_str("%AI5_File:\n%AI5_BeginRaster\n[ ");- ps::push_nums(s, &[a, b, c, d, e, f]);- let _ = writeln!(s, "] 0 0 {w} {h} {w} {h} 8 3 0 0 0 0 XI");- s.push_str(&hex);- s.push_str("%AI5_EndRaster\nF\n");- }-}--/// Can type `t` be written as text: horizontal, without ruby (which a text object can't hold), its-/// runs plain characters (no inline graphics) that 8-bit text can hold, filled and stroked with-/// colours?-fn writable(t: &TextObject) -> bool {- let solid = |p: &Paint| matches!(p, Paint::Solid { .. } | Paint::None);- !t.vertical- && t.ruby.is_empty()- && t.runs.iter().any(|r| !r.text.is_empty())- && t.runs.iter().all(|r| {- r.inline.is_none()- && solid(&r.style.fill)- && solid(&r.style.stroke)- && (if r.style.all_caps { r.text.to_uppercase() } else { r.text.clone() }).chars().all(|c| latin::encode(c).is_some())- })-}--/// Has type `t` attributes a legacy `.ai` text object can't hold (lost when it's written as text)?-fn lost_attributes(t: &TextObject) -> bool {- let run_lost = |s: &CharStyle| {- s.underline- || s.strikethrough- || s.small_caps.is_some()- || s.position != CharPosition::Normal- || s.rotation != 0.0- || !s.features.is_empty()- || !s.font_axes.is_empty()- };- let para_lost = |p: &ParaStyle| p.space_after != 0.0 || !p.tabs.is_empty() || p.list.is_some();- t.runs.iter().any(|r| run_lost(&r.style))- || t.paragraph_styles().iter().any(para_lost)- || (matches!(t.kind, TextKind::Area { .. }) && t.area != AreaOptions::default())- || (matches!(t.kind, TextKind::OnPath { .. }) && (t.path_effect != PathEffect::default() || t.path_spacing != 0.0))-}--/// The font type in style `st` is set in: its PostScript name, whether it's TrueType, and its-/// ascent and descent (ems). A font that isn't installed is named after its family and style.-fn font_of(st: &CharStyle) -> (String, bool, f64, f64) {- let db = vectorcraft_text::FontDb::global();- match db.face_version(&st.font_family, &st.font_style, st.font_version.as_deref()) {- Some(face) => {- let (ascent, descent) = face.vertical_metrics();- let em = face.units_per_em().max(1.0);- let name = face.postscript_name();- (name, face.is_truetype(), ascent / em, descent / em)- }- None => {- let squeeze = |s: &str| -> String { s.chars().filter(|c| c.is_ascii_alphanumeric()).collect() };- let style = squeeze(&st.font_style);- let name =- if style.is_empty() || style == "Regular" { squeeze(&st.font_family) } else { format!("{}-{style}", squeeze(&st.font_family)) };- (if name.is_empty() { "Helvetica".into() } else { name }, false, 0.75, 0.25)- }- }-}--/// `v`, or `default` when it isn't finite.-fn finite(v: f64, default: f64) -> f64 {- if v.is_finite() { v } else { default }-}--/// Where a fraction of `path`'s length is, as the start of type on a path gives it (§15.5.2): the-/// index of the segment it's on, plus how far along that segment (its curve parameter).-fn segment_point(path: &BezPath, fraction: f64) -> f64 {- use kurbo::ParamCurveArclen;- const ACCURACY: f64 = 1e-3;- let segments: Vec<kurbo::PathSeg> = path.segments().collect();- let lengths: Vec<f64> = segments.iter().map(|s| s.arclen(ACCURACY)).collect();- let total: f64 = lengths.iter().sum();- if !(total.is_finite() && total > 0.0) {- return 0.0;- }- let mut left = fraction.clamp(0.0, 1.0) * total;- for (i, (seg, len)) in segments.iter().zip(&lengths).enumerate() {- if left <= *len || i + 1 == segments.len() {- let t = if *len > 0.0 { seg.inv_arclen(left.min(*len), ACCURACY) } else { 0.0 };- return i as f64 + t.clamp(0.0, 0.9999);- }- left -= len;- }- 0.0-}--/// Can `p` paint a path object's fill directly (a colour or a linear or radial gradient)?-fn direct_fill(p: &Paint) -> bool {- match p {- Paint::Solid { .. } => true,- Paint::Gradient(g) => g.gradient.kind != GradientKind::Freeform && !g.gradient.stops.is_empty(),- _ => false,- }-}--/// Can stroke `s` be written as the stroke of a path object (a plain line of a colour)?-fn direct_stroke(s: &StrokeLayer) -> bool {- matches!(s.paint, Paint::Solid { .. }) && stroke::is_plain(s)-}--/// The average colour of a gradient's stops (in RGB).-fn average(g: &Gradient) -> Color {- let n = g.stops.len().max(1) as f32;- let sum = g.stops.iter().map(|s| s.color.to_rgb()).fold([0.0f32; 3], |a, c| [a[0] + c[0], a[1] + c[1], a[2] + c[2]]);- Color::rgb(unit(sum[0] / n), unit(sum[1] / n), unit(sum[2] / n))-}-#[cfg(test)]mod tests;diff --git a/crates/eps/src/legacy_ai/encoding.rs b/crates/eps/src/legacy_ai/encoding.rsnew file mode 100644index 000000000..b67296e72--- /dev/null+++ b/crates/eps/src/legacy_ai/encoding.rs@@ -0,0 +1,181 @@+use super::writer::Writer;+use super::*;++/// A gradient definition: `%AI5_BeginGradient: (name)`, `(name) type stops Bd`, `[`, the stops+/// (`colorSpec colorStyle midPoint rampPoint %_Bs`, each with its midpoint to the next stop), `BD`,+/// `%AI5_EndGradient`. A linear gradient's stops are listed from the last to the first (§1.4.3). A+/// radial gradient's stops are listed from the first to the last, as in §3.5.2's radial+/// definition (10, then 100).+pub(super) fn gradient_def(s: &mut String, w: &Writer, name: &str, g: &Gradient) {+ let name = latin_string(name);+ let radial = g.kind == GradientKind::Radial;+ let kind = if radial { 1 } else { 0 };+ let _ = writeln!(s, "%AI5_BeginGradient: {name}\n{name} {kind} {} Bd\n[", g.stops.len());+ let mut stops: Vec<_> = g.stops.iter().collect();+ if !radial {+ stops.reverse();+ }+ for stop in stops {+ let paint = Paint::Solid { color: stop.color, swatch: stop.swatch.clone(), tint: stop.tint };+ match w.ink(&paint) {+ Ink::Gray(v) => {+ ps::push_num(s, f64::from(v));+ s.push_str(" 0 ");+ }+ Ink::Cmyk(c) => {+ ps::push_nums(s, &c.map(f64::from));+ s.push_str("1 ");+ }+ Ink::Rgb(c, rgb) => {+ ps::push_nums(s, &c.map(f64::from));+ ps::push_nums(s, &rgb.map(f64::from));+ s.push_str("2 ");+ }+ Ink::Spot { cmyk, name, tint } => {+ ps::push_nums(s, &cmyk.map(f64::from));+ let _ = write!(s, "{} ", latin_string(w.spot_name(&name)));+ ps::push_num(s, f64::from(1.0 - tint));+ s.push_str(" 3 ");+ }+ }+ ps::push_nums(s, &[f64::from(stop.midpoint) * 100.0, f64::from(stop.offset) * 100.0]);+ s.push_str("%_Bs\n");+ }+ s.push_str("BD\n%AI5_EndGradient\n");+}++/// A colour as the format writes it.+#[derive(Clone, Debug, PartialEq)]+pub(super) enum Ink {+ /// Lightness (1 is white).+ Gray(f32),+ Cmyk([f32; 4]),+ /// RGB, with its CMYK equivalent.+ Rgb([f32; 4], [f32; 3]),+ /// A spot colour's full CMYK equivalent, name and tint (1: full).+ Spot {+ cmyk: [f32; 4],+ name: String,+ tint: f32,+ },+}++pub(super) fn unit(v: f32) -> f32 {+ if v.is_finite() { v.clamp(0.0, 1.0) } else { 0.0 }+}++/// Can `a` be drawn through (a finite, non-flat map)?+pub(super) fn invertible(a: Affine) -> bool {+ let det = a.determinant();+ det.is_finite() && det.abs() > 1e-12+}++/// Name `name` as a PostScript string of its characters' Windows-1252 codes (a character outside+/// Windows-1252 is left out: [`Writer::latin_name`] replaces them first).+pub(super) fn latin_string(name: &str) -> String {+ let bytes: Vec<u8> = name.chars().filter_map(latin::encode).collect();+ ps::bytes(&bytes)+}++/// Can type `t` be written as text: horizontal, without ruby (which a text object can't hold), its+/// runs plain characters (no inline graphics) that 8-bit text can hold, filled and stroked with+/// colours?+pub(super) fn writable(t: &TextObject) -> bool {+ let solid = |p: &Paint| matches!(p, Paint::Solid { .. } | Paint::None);+ !t.vertical+ && t.ruby.is_empty()+ && t.runs.iter().any(|r| !r.text.is_empty())+ && t.runs.iter().all(|r| {+ r.inline.is_none()+ && solid(&r.style.fill)+ && solid(&r.style.stroke)+ && (if r.style.all_caps { r.text.to_uppercase() } else { r.text.clone() }).chars().all(|c| latin::encode(c).is_some())+ })+}++/// Has type `t` attributes a legacy `.ai` text object can't hold (lost when it's written as text)?+pub(super) fn lost_attributes(t: &TextObject) -> bool {+ let run_lost = |s: &CharStyle| {+ s.underline+ || s.strikethrough+ || s.small_caps.is_some()+ || s.position != CharPosition::Normal+ || s.rotation != 0.0+ || !s.features.is_empty()+ || !s.font_axes.is_empty()+ };+ let para_lost = |p: &ParaStyle| p.space_after != 0.0 || !p.tabs.is_empty() || p.list.is_some();+ t.runs.iter().any(|r| run_lost(&r.style))+ || t.paragraph_styles().iter().any(para_lost)+ || (matches!(t.kind, TextKind::Area { .. }) && t.area != AreaOptions::default())+ || (matches!(t.kind, TextKind::OnPath { .. }) && (t.path_effect != PathEffect::default() || t.path_spacing != 0.0))+}++/// The font type in style `st` is set in: its PostScript name, whether it's TrueType, and its+/// ascent and descent (ems). A font that isn't installed is named after its family and style.+pub(super) fn font_of(st: &CharStyle) -> (String, bool, f64, f64) {+ let db = vectorcraft_text::FontDb::global();+ match db.face_version(&st.font_family, &st.font_style, st.font_version.as_deref()) {+ Some(face) => {+ let (ascent, descent) = face.vertical_metrics();+ let em = face.units_per_em().max(1.0);+ let name = face.postscript_name();+ (name, face.is_truetype(), ascent / em, descent / em)+ }+ None => {+ let squeeze = |s: &str| -> String { s.chars().filter(|c| c.is_ascii_alphanumeric()).collect() };+ let style = squeeze(&st.font_style);+ let name =+ if style.is_empty() || style == "Regular" { squeeze(&st.font_family) } else { format!("{}-{style}", squeeze(&st.font_family)) };+ (if name.is_empty() { "Helvetica".into() } else { name }, false, 0.75, 0.25)+ }+ }+}++/// `v`, or `default` when it isn't finite.+pub(super) fn finite(v: f64, default: f64) -> f64 {+ if v.is_finite() { v } else { default }+}++/// Where a fraction of `path`'s length is, as the start of type on a path gives it (§15.5.2): the+/// index of the segment it's on, plus how far along that segment (its curve parameter).+pub(super) fn segment_point(path: &BezPath, fraction: f64) -> f64 {+ use kurbo::ParamCurveArclen;+ const ACCURACY: f64 = 1e-3;+ let segments: Vec<kurbo::PathSeg> = path.segments().collect();+ let lengths: Vec<f64> = segments.iter().map(|s| s.arclen(ACCURACY)).collect();+ let total: f64 = lengths.iter().sum();+ if !(total.is_finite() && total > 0.0) {+ return 0.0;+ }+ let mut left = fraction.clamp(0.0, 1.0) * total;+ for (i, (seg, len)) in segments.iter().zip(&lengths).enumerate() {+ if left <= *len || i + 1 == segments.len() {+ let t = if *len > 0.0 { seg.inv_arclen(left.min(*len), ACCURACY) } else { 0.0 };+ return i as f64 + t.clamp(0.0, 0.9999);+ }+ left -= len;+ }+ 0.0+}++/// Can `p` paint a path object's fill directly (a colour or a linear or radial gradient)?+pub(super) fn direct_fill(p: &Paint) -> bool {+ match p {+ Paint::Solid { .. } => true,+ Paint::Gradient(g) => g.gradient.kind != GradientKind::Freeform && !g.gradient.stops.is_empty(),+ _ => false,+ }+}++/// Can stroke `s` be written as the stroke of a path object (a plain line of a colour)?+pub(super) fn direct_stroke(s: &StrokeLayer) -> bool {+ matches!(s.paint, Paint::Solid { .. }) && stroke::is_plain(s)+}++/// The average colour of a gradient's stops (in RGB).+pub(super) fn average(g: &Gradient) -> Color {+ let n = g.stops.len().max(1) as f32;+ let sum = g.stops.iter().map(|s| s.color.to_rgb()).fold([0.0f32; 3], |a, c| [a[0] + c[0], a[1] + c[1], a[2] + c[2]]);+ Color::rgb(unit(sum[0] / n), unit(sum[1] / n), unit(sum[2] / n))+}diff --git a/crates/eps/src/legacy_ai/prolog.rs b/crates/eps/src/legacy_ai/prolog.rsnew file mode 100644index 000000000..eb10f1440--- /dev/null+++ b/crates/eps/src/legacy_ai/prolog.rs@@ -0,0 +1,115 @@+use super::*;++/// The setup's fonts (§3.1, §3.3): `%%IncludeFont` for each, the encoding strings are in (`TE`),+/// and each font re-encoded to it as `_name` (`TZ`; a TrueType font takes the encoding as its own,+/// not the standard one, as the specification says of fonts that aren't Type 1).+pub(super) fn fonts(s: &mut String, fonts: &[(String, bool)]) {+ if fonts.is_empty() {+ return;+ }+ for (name, _) in fonts {+ let _ = writeln!(s, "%%IncludeFont: {name}");+ }+ let te = latin::te();+ s.push_str(&te);+ // The encoding pairs, without `[` and `TE`.+ let pairs = te.trim_start_matches('[').trim_end().trim_end_matches("TE").trim_end();+ for (name, truetype) in fonts {+ let _ = writeln!(s, "%AI3_BeginEncoding: _{name} {name}");+ if *truetype {+ let _ = writeln!(s, "[{pairs}\n/_{name}/{name} 0 0 0 TZ\n%AI3_EndEncoding TrueType");+ } else {+ let _ = writeln!(s, "[/_{name}/{name} 0 0 1 TZ\n%AI3_EndEncoding AdobeType");+ }+ }+}++/// The prolog's procedure set, as `%%DocumentSuppliedResources` names it: a file that has it is+/// read from its program when its layers are asked for ([`crate::import_with`]).+pub(crate) const PROCSET: &str = "VectorCraft_Legacy 1 0";++/// The prolog: a procedure set of this writer's own (`VectorCraft_Legacy 1 0`), in a dictionary+/// (`VCLegacy`) the setup begins and the trailer ends (§1.2: the prolog holds definitions only,+/// the setup activates them, the trailer deactivates them). It gives each operator the script+/// uses its meaning in PostScript, so that the file prints and previews as a PostScript program,+/// written from the PostScript Language Reference and this format's specification (no other+/// application's procedure set): paths and their painting with the fill and stroke colours,+/// compound paths painted as one path, clipping groups, guides that don't print, layers that are+/// hidden or don't print marking nothing, and images drawn from the samples on the comment lines+/// that follow `XI`. Gradients fill with the colour set before them (the writer sets the first+/// stop's), and type marks nothing: apps that read the format draw both. The page trailer's+/// `annotatepage` (§3, Script Setup: `gsave annotatepage grestore showpage`) marks nothing.+pub(super) const PROLOG: &str = "%%BeginResource: procset VectorCraft_Legacy 1 0+/VCLegacy 96 dict def+VCLegacy begin+/bd {bind def} bind def+% State: the fill and stroke colours (procedures that set them), their overprints, the fill rule,+% a clip to make at the next painting operator, a compound path being built, a guide being+% drawn, whether the layer prints, and what the compound path is painted with.+/_fc {0 setgray} def /_sc {0 setgray} def+/_fo false def /_so false def /_eo false def /_w false def /_cp false def /_g false def+/_on true def /_rf false def /_rs false def+% Painting: a fill and a stroke that keep the path; the path painted as _rf and _rs say (after+% the clip W asked for), then ended.+/_fill {gsave _fc _fo setoverprint _eo {eofill} {fill} ifelse grestore} bd+/_stroke {gsave _sc _so setoverprint stroke grestore} bd+/_draw {_w {_eo {eoclip} {clip} ifelse /_w false def} if+ _on _g not and {_rf {_fill} if _rs {_stroke} if} if newpath} bd+% close? fill? stroke? _r: paints now, or at the end of the compound path being built.+/_r {/_rs exch def /_rf exch def {closepath} if _cp not {_draw} if} bd+% Path construction (section 5.3.2) and painting (5.3.3).+/m {moveto} bd /l {lineto} bd /L {lineto} bd /c {curveto} bd /C {curveto} bd+/N {false false false _r} bd /n {true false false _r} bd+/F {false true false _r} bd /f {true true false _r} bd+/S {false false true _r} bd /s {true false true _r} bd+/B {false true true _r} bd /b {true true true _r} bd+/XR {1 eq /_eo exch def} bd+% Compound paths (5.3.5): one path, painted at its end.+/*u {/_cp true def} bd /*U {/_cp false def _draw} bd+% Groups, clipping groups and masks (5.6), locking (5.1), guides (6.1).+/u {} bd /U {} bd /q {gsave} bd /Q {grestore} bd+/H {} bd /h {closepath} bd /W {/_w true def} bd+/A {pop} bd+/* {pop _g {newpath /_g false def} {/_g true def} ifelse} bd+% Colours (5.4): fill and stroke colours, overprints; a custom colour as its CMYK equivalent at+% its tint (tint 0 is the full colour).+/g {/setgray load 2 array astore cvx /_fc exch def} bd+/G {/setgray load 2 array astore cvx /_sc exch def} bd+/k {/setcmykcolor load 5 array astore cvx /_fc exch def} bd+/K {/setcmykcolor load 5 array astore cvx /_sc exch def} bd+/Xa {/setrgbcolor load 4 array astore cvx /_fc exch def} bd+/XA {/setrgbcolor load 4 array astore cvx /_sc exch def} bd+/_tint {1 exch sub /_t exch def pop 4 {_t mul 4 1 roll} repeat} bd+/x {_tint k} bd /X {_tint K} bd+/O {1 eq /_fo exch def} bd /R {1 eq /_so exch def} bd+/w {setlinewidth} bd /J {setlinecap} bd /j {setlinejoin} bd /M {setmiterlimit} bd /d {setdash} bd+% Gradients (3.5): definitions are skipped; an instance fills with the colour set before it+% (the writer sets its first stop's), and BB strokes the path as its flag says.+/Bn {pop} bd /Bd {pop pop pop} bd /BD {cleartomark} bd+/Bb {gsave} bd /Bg {12 {pop} repeat} bd /Bh {pop pop pop pop} bd+/BB {grestore _cp {0 gt {/_rs true def} if}+ {dup 2 eq {closepath} if 0 gt _on and {_stroke} if newpath} ifelse} bd+% Layers (9): a layer that is hidden or doesn't print marks nothing.+/Lb {6 {pop} repeat exch pop exch pop 1 eq exch 1 eq and /_on exch def} bd+/Ln {pop} bd /LB {/_on true def} bd+% Images (8): the samples, in hex on the comment lines that follow XI, read a line at a time.+/_l 256 string def /_s 128 string def+/_row {{currentfile _l readline not {exit} if dup length 1 gt {exit} if pop} loop+ dup length 1 gt {dup length 1 sub 1 exch getinterval /ASCIIHexDecode filter _s readstring pop} {pop ()} ifelse} bd+/XI {pop pop pop pop /_ic exch def /_ib exch def /_ih exch def /_iw exch def pop pop pop pop+ [1 0 0 -1 0 0] exch matrix concatmatrix+ _on {gsave concat _iw _ih _ib [1 0 0 1 0 0] /_row load false _ic 1 eq {1} {_ic} ifelse colorimage grestore} {pop} ifelse} bd+% Type (15) is set by the app that reads the file: its operators take their operands and mark+% nothing; encodings (3.3) are skipped.+/TE {cleartomark} bd /TZ {cleartomark} bd+/To {pop} bd /Tp {7 {pop} repeat} bd /TP {} bd /TO {} bd+/Tr {pop} bd /Tf {pop pop pop pop} bd /Ts {pop} bd /Tz {pop pop} bd /Tt {pop} bd /TA {pop} bd+/Tl {pop pop} bd /Ta {pop} bd /Ti {pop pop pop} bd /Tx {pop} bd+% The page trailer (3): annotatepage marks nothing.+/annotatepage {} bd+end+%%EndResource+";++/// The first line of a PostScript file (the DSC version comment).+pub(super) const PS_HEADER: &str = "%!PS-Adobe-3.0"; // brand-ok: the PostScript header commentdiff --git a/crates/eps/src/legacy_ai/writer.rs b/crates/eps/src/legacy_ai/writer.rsnew file mode 100644index 000000000..31caf715f--- /dev/null+++ b/crates/eps/src/legacy_ai/writer.rs@@ -0,0 +1,960 @@+use super::encoding::{+ Ink, average, direct_fill, direct_stroke, finite, font_of, invertible, latin_string, lost_attributes, segment_point, unit, writable,+};+use super::*;++pub(super) struct Writer<'a> {+ doc: &'a Document,+ /// The document → art space.+ to_art: Affine,+ cms: Arc<Cms>,+ pub(super) body: String,+ /// Gradient definitions, by the name objects use.+ pub(super) gradients: Vec<(String, Gradient)>,+ /// Spot colors used: the name written and full CMYK equivalent.+ pub(super) spots: Vec<(String, [f32; 4])>,+ /// The name each spot color (by its swatch's name) is written with ([`Self::spot`]).+ spot_names: Vec<(String, String)>,+ pub(super) warnings: Vec<String>,+ /// The lock state the last `A` set.+ locked: bool,+ /// Symbols and live objects being written inside one another.+ nest: u32,+ /// What to do with hidden objects.+ hidden: HiddenObjects,+ /// Type as outlines.+ outline_text: bool,+ /// The layer being written's hidden objects for its hidden layer, and whether each is locked.+ hidden_art: Vec<(Node, bool)>,+ /// Writing a layer that is hidden (or the hidden layer of one's hidden objects): hidden objects+ /// are written where they are.+ in_hidden: bool,+ /// The fonts type is set in: PostScript name, and whether it's TrueType.+ pub(super) fonts: Vec<(String, bool)>,+}++impl<'a> Writer<'a> {+ pub(super) fn new(doc: &'a Document, to_art: Affine, o: &LegacyAiOptions) -> Self {+ Self {+ doc,+ to_art,+ cms: vectorcraft_color::cms::active(),+ body: String::new(),+ gradients: vec![],+ spots: vec![],+ spot_names: vec![],+ warnings: vec![],+ locked: false,+ nest: 0,+ hidden: o.hidden,+ outline_text: o.outline_text,+ hidden_art: vec![],+ in_hidden: false,+ fonts: vec![],+ }+ }++ fn warn(&mut self, w: &str) {+ if !self.warnings.iter().any(|x| x == w) {+ self.warnings.push(w.to_string());+ }+ }++ fn line(&mut self, s: &str) {+ self.body.push_str(s);+ self.body.push('\n');+ }++ // ---------- layers and objects ----------++ /// `name` with each character outside Windows-1252 (the encoding type and names are written+ /// in) replaced by `?`; adds the warning `warning` when it replaces one.+ pub(super) fn latin_name(&mut self, name: &str, warning: &str) -> String {+ let mut lost = false;+ let kept = name+ .chars()+ .map(|c| {+ if latin::encode(c).is_some() {+ c+ } else {+ lost = true;+ '?'+ }+ })+ .collect();+ if lost {+ self.warn(warning);+ }+ kept+ }++ /// A layer's name as a PostScript string in Windows-1252, like the type; a character outside it+ /// is written as `?`, with a warning.+ fn layer_name(&mut self, name: &str) -> String {+ latin_string(&self.latin_name(name, LAYER_NAME))+ }++ /// Note spot color `name` (its swatch's name), of full CMYK equivalent `cmyk`, as a custom+ /// color of the document, and give the name it is written with. Its characters outside+ /// Windows-1252 are written as `?` (with a warning), and it is numbered when another spot color+ /// is already written with that name; the name is the same each time.+ fn spot(&mut self, name: &str, cmyk: [f32; 4]) -> String {+ let written = match self.spot_names.iter().find(|(n, _)| n == name) {+ Some((_, w)) => w.clone(),+ None => {+ let base = self.latin_name(name, TITLE_AND_COLOR_NAMES);+ let mut written = base.clone();+ let mut i = 1;+ while self.spot_names.iter().any(|(_, w)| *w == written) {+ i += 1;+ written = format!("{base} {i}");+ }+ self.spot_names.push((name.to_string(), written.clone()));+ written+ }+ };+ if !self.spots.iter().any(|(n, _)| *n == written) {+ self.spots.push((written.clone(), cmyk));+ }+ written+ }++ /// The name spot color `name` (its swatch's name) is written with, once [`Self::spot`] has+ /// noted it.+ pub(super) fn spot_name<'n>(&'n self, name: &'n str) -> &'n str {+ self.spot_names.iter().find(|(n, _)| n == name).map_or(name, |(_, w)| w.as_str())+ }++ /// A top-level layer. False when it isn't a layer.+ pub(super) fn layer(&mut self, n: &Node) -> bool {+ let NodeKind::Layer { color, template, printable, children, clip, preview, dim_images } = &n.kind else { return false };+ let [r, g, b] = match color {+ LayerColor::Preset(i) => LAYER_COLORS.get(usize::from(*i)).map_or([79, 128, 255], |c| c.1),+ LayerColor::Custom(rgb) => *rgb,+ };+ let index = match color {+ LayerColor::Preset(i) if usize::from(*i) < LAYER_COLORS.len() => i64::from(*i),+ _ => -1,+ };+ let flag = |b: bool| u8::from(b);+ let name = self.layer_name(n.name.as_deref().unwrap_or("Layer"));+ // A template layer doesn't print and shows dimmed.+ let _ = writeln!(+ self.body,+ "%AI5_BeginLayer\n{} {} {} {} {} 0 {index} {r} {g} {b} Lb\n{} Ln",+ flag(n.visible),+ flag(*preview),+ flag(!n.locked),+ flag(*printable && !*template),+ flag(dim_images.is_some() || *template),+ name,+ );+ self.locked = false;+ self.line("0 A");+ self.in_hidden = !n.visible;+ self.contents(children, *clip, false);+ self.in_hidden = false;+ self.line("LB\n%AI5_EndLayer--");+ true+ }++ /// The hidden layer of top-level layer `n`'s hidden objects, just above it (named after it,+ /// with its colour, lock and printing). False when it has none.+ pub(super) fn hidden_layer(&mut self, n: &Node) -> bool {+ if self.hidden_art.is_empty() {+ return false;+ }+ let art = std::mem::take(&mut self.hidden_art);+ let NodeKind::Layer { color, template, printable, .. } = &n.kind else { return false };+ let [r, g, b] = match color {+ LayerColor::Preset(i) => LAYER_COLORS.get(usize::from(*i)).map_or([79, 128, 255], |c| c.1),+ LayerColor::Custom(rgb) => *rgb,+ };+ let index = match color {+ LayerColor::Preset(i) if usize::from(*i) < LAYER_COLORS.len() => i64::from(*i),+ _ => -1,+ };+ let name = format!("{} (hidden)", n.name.as_deref().unwrap_or("Layer"));+ let name = self.layer_name(&name);+ let _ = writeln!(+ self.body,+ "%AI5_BeginLayer\n0 1 {} {} {} 0 {index} {r} {g} {b} Lb\n{} Ln",+ u8::from(!n.locked),+ u8::from(*printable && !*template),+ u8::from(*template),+ name,+ );+ self.locked = false;+ self.line("0 A");+ self.in_hidden = true;+ for (node, locked) in &art {+ self.node(node, *locked);+ }+ self.in_hidden = false;+ self.line("LB\n%AI5_EndLayer--");+ true+ }++ /// A container's members, the first clipping the others when `clip`; `locked`: the container is.+ fn contents(&mut self, children: &[Arc<Node>], clip: bool, locked: bool) {+ if clip {+ self.clip_group(children, locked);+ } else {+ for c in children {+ self.node(c, locked);+ }+ }+ }++ /// Set the lock state of the objects that follow.+ fn lock(&mut self, locked: bool) {+ if locked != self.locked {+ self.locked = locked;+ self.line(if locked { "1 A" } else { "0 A" });+ }+ }++ /// One object (inside a container locked when `locked`).+ fn node(&mut self, n: &Node, locked: bool) {+ if !n.visible && !self.in_hidden {+ match self.hidden {+ HiddenObjects::Omit => {+ self.warn(HIDDEN);+ return;+ }+ HiddenObjects::Layer => {+ self.warn(HIDDEN_LAYER);+ self.hidden_art.push((n.clone(), locked || n.locked));+ return;+ }+ HiddenObjects::Visible => self.warn(HIDDEN_SHOWN),+ }+ }+ if n.opacity < 1.0 || n.blend != BlendMode::Normal || n.extras().mask.as_ref().is_some_and(|m| !m.disabled) {+ self.warn(TRANSPARENCY);+ }+ if n.name.as_deref().is_some_and(|s| !s.is_empty()) && !n.is_layer() {+ self.warn(NAMES);+ }+ let locked = locked || n.locked;+ match &n.kind {+ NodeKind::Layer { children, clip, .. } => {+ self.warn(SUBLAYERS);+ self.group(children, *clip, locked);+ }+ NodeKind::Group { children, clip } => self.group(children, *clip, locked),+ NodeKind::Path { path, rule, guide, .. } => {+ self.lock(locked);+ if *guide {+ self.guide(path);+ } else {+ self.shape(n, path, *rule);+ }+ }+ NodeKind::Compound { children, rule } => {+ self.lock(locked);+ let mut subpaths = vec![];+ for p in children.iter().filter_map(|c| c.path_data()) {+ subpaths.extend(p.subpaths.iter().cloned());+ }+ self.shape(n, &PathData::new(subpaths), *rule);+ }+ NodeKind::Text(t) => {+ self.lock(locked);+ self.text(t);+ }+ NodeKind::Image(im) => {+ self.lock(locked);+ self.image(self.doc.image_blob(im), im.width, im.height, im.xf);+ }+ NodeKind::SymbolInstance { symbol, xf } => {+ self.warn(LIVE);+ if let Some(sym) = self.doc.symbols.iter().find(|s| &s.name == symbol)+ && self.nest < MAX_NEST+ {+ let mut art = (*sym.art).clone();+ art.transform(*xf, false);+ art.visible = true;+ self.nest += 1;+ self.node(&art, locked);+ self.nest -= 1;+ }+ }+ NodeKind::Blend { .. }+ | NodeKind::Envelope { .. }+ | NodeKind::Mesh(_)+ | NodeKind::Repeat(_)+ | NodeKind::PlacedDocument(_)+ | NodeKind::Intertwine { .. } => {+ self.warn(LIVE);+ if self.nest < MAX_NEST {+ let g = vectorcraft_effects::expand_live_deep(Some(self.doc), n);+ self.nest += 1;+ if let Some(children) = g.children() {+ self.group(children, false, locked);+ }+ self.nest -= 1;+ }+ }+ }+ }++ /// A group (`u` … `U`), or a clipping group (`q` … `Q`).+ fn group(&mut self, children: &[Arc<Node>], clip: bool, locked: bool) {+ if children.is_empty() {+ return;+ }+ self.lock(locked);+ if clip {+ self.clip_group(children, locked);+ } else {+ self.line("u");+ self.contents(children, false, locked);+ self.lock(locked);+ self.line("U");+ }+ }++ /// A clipping group: its first member's outline clips the others (`h W n`). That member's fills+ /// paint behind the art, inside the clip, and its strokes over it, outside.+ fn clip_group(&mut self, children: &[Arc<Node>], locked: bool) {+ let Some((clip, rest)) = children.split_first() else { return };+ // Nothing to clip by hides the clipped art.+ let Some((outline, rule)) = vectorcraft_effects::clip_outline(clip) else { return };+ let paint = clip.clip_paint();+ self.lock(locked);+ self.line("q");+ let path = PathData::from_bezpath(&outline);+ self.fill_rule(rule);+ let several = path.subpaths.len() > 1;+ if several {+ self.line("*u");+ }+ for sp in path.subpaths.iter().filter(|sp| !sp.anchors.is_empty()) {+ self.mask(sp);+ }+ if several {+ self.line("*U");+ }+ if let Some(fill) = &paint.fill {+ self.node(fill, locked);+ }+ for c in rest {+ self.node(c, locked);+ }+ self.lock(locked);+ self.line("Q");+ if let Some(stroke) = &paint.stroke {+ self.node(stroke, locked);+ }+ }++ // ---------- paths ----------++ /// A clipping path (§5.6.2): its points, `h` (closed) or `H`, `W`, then painted with nothing.+ fn mask(&mut self, sp: &SubPath) {+ self.subpath(sp);+ self.line(if sp.closed { "h\nW\nn" } else { "H\nW\nN" });+ }++ /// A guide (§6): `(N) *`, its path, `(N) *`.+ fn guide(&mut self, path: &PathData) {+ for sp in path.subpaths.iter().filter(|sp| !sp.anchors.is_empty()) {+ self.line("(N) *");+ self.subpath(sp);+ self.line("(N) *");+ }+ }++ /// A path's fills and strokes: one object with one fill and a plain stroke over it where it+ /// can be, else a group of an object for each (in paint order).+ fn shape(&mut self, n: &Node, path: &PathData, rule: FillRule) {+ if path.is_empty() {+ return;+ }+ let items: Vec<&AppearanceItem> = n+ .appearance+ .items+ .iter()+ .filter(|i| match i {+ AppearanceItem::Fill(f) => f.visible && !f.paint.is_none(),+ AppearanceItem::Stroke(s) => s.visible && !s.paint.is_none() && s.width > 0.0 && s.width.is_finite(),+ })+ .collect();+ for i in &items {+ if i.opacity() < 1.0 || i.blend() != BlendMode::Normal {+ self.warn(TRANSPARENCY);+ }+ }+ match items.as_slice() {+ [] => self.path_object(path, rule, None, None),+ [AppearanceItem::Fill(f)] if direct_fill(&f.paint) => self.path_object(path, rule, Some(f), None),+ [AppearanceItem::Stroke(s)] if direct_stroke(s) => self.path_object(path, rule, None, Some(s)),+ [AppearanceItem::Fill(f), AppearanceItem::Stroke(s)] if direct_fill(&f.paint) && direct_stroke(s) => {+ self.path_object(path, rule, Some(f), Some(s))+ }+ [one] => self.item(path, rule, one),+ items => {+ self.line("u");+ for i in items {+ self.item(path, rule, i);+ }+ self.line("U");+ }+ }+ }++ /// One fill or stroke of a path as an object of its own.+ fn item(&mut self, path: &PathData, rule: FillRule, item: &AppearanceItem) {+ match item {+ AppearanceItem::Fill(f) => self.fill_object(path, rule, f),+ AppearanceItem::Stroke(s) if direct_stroke(s) => self.path_object(path, rule, None, Some(s)),+ AppearanceItem::Stroke(s) => {+ self.warn(STROKES);+ let outline = stroke::outline_region(path, rule, s);+ let fill = FillLayer { overprint: s.overprint, ..FillLayer::new(s.paint.clone()) };+ self.fill_object(&outline, FillRule::NonZero, &fill);+ }+ }+ }++ /// A fill as an object of its own: patterns as their tiles clipped to the path.+ fn fill_object(&mut self, path: &PathData, rule: FillRule, f: &FillLayer) {+ if direct_fill(&f.paint) {+ return self.path_object(path, rule, Some(f), None);+ }+ let Paint::Pattern { pattern, xf } = &f.paint else {+ // A freeform gradient: its average colour.+ self.warn(FREEFORM);+ let color = match &f.paint {+ Paint::Gradient(g) => average(&g.gradient),+ _ => Color::gray(0.5),+ };+ let flat = FillLayer { paint: Paint::solid(color), ..f.clone() };+ return self.path_object(path, rule, Some(&flat), None);+ };+ self.warn(PATTERNS);+ let doc = self.doc;+ let Some(def) = doc.pattern(pattern) else {+ let flat = FillLayer { paint: Paint::solid(Color::gray(0.5)), ..f.clone() };+ return self.path_object(path, rule, Some(&flat), None);+ };+ let area = path.to_bezpath().bounding_box();+ let tiles = def.instances_in(*xf, area);+ self.line("q");+ self.fill_rule(rule);+ let several = path.subpaths.len() > 1;+ if several {+ self.line("*u");+ }+ for sp in path.subpaths.iter().filter(|sp| !sp.anchors.is_empty()) {+ self.mask(sp);+ }+ if several {+ self.line("*U");+ }+ let locked = self.locked;+ for t in &tiles {+ self.node(t, locked);+ }+ self.lock(locked);+ self.line("Q");+ }++ /// A path object painted with `fill` (a colour or a linear or radial gradient) and `stroke`+ /// (a plain line of a colour) over it; several subpaths make a compound path.+ fn path_object(&mut self, path: &PathData, rule: FillRule, fill: Option<&FillLayer>, stroke: Option<&StrokeLayer>) {+ let subpaths: Vec<&SubPath> = path.subpaths.iter().filter(|sp| !sp.anchors.is_empty()).collect();+ if subpaths.is_empty() {+ return;+ }+ let gradient = match fill.map(|f| &f.paint) {+ Some(Paint::Gradient(g)) => Some(self.gradient(g, path.to_bezpath().bounding_box())),+ _ => None,+ };+ if let Some(f) = fill {+ let paint = match &f.paint {+ // The colour under the gradient: its first stop's.+ Paint::Gradient(g) => g.gradient.stops.first().map_or(Paint::None, |s| Paint::solid(s.color)),+ p => p.clone(),+ };+ self.color(&paint, false);+ self.line(if f.overprint { "1 O" } else { "0 O" });+ }+ if let Some(s) = stroke {+ self.color(&s.paint, true);+ self.line(if s.overprint { "1 R" } else { "0 R" });+ self.line_style(s);+ }+ self.fill_rule(rule);+ let op = match (fill.is_some(), stroke.is_some()) {+ (true, true) => 'b',+ (true, false) => 'f',+ (false, true) => 's',+ (false, false) => 'n',+ };+ let several = subpaths.len() > 1;+ if several {+ self.line("*u");+ }+ for sp in subpaths {+ self.subpath(sp);+ if let Some(g) = &gradient {+ // The gradient fills between `Bb` and `BB`, whose flag strokes the path too (§3.5.3).+ self.body.push_str(g);+ self.line(if sp.closed { "f" } else { "F" });+ self.line(match (stroke.is_some(), sp.closed) {+ (false, _) => "0 BB",+ (true, false) => "1 BB",+ (true, true) => "2 BB",+ });+ } else {+ self.line(&if sp.closed { op.to_string() } else { op.to_ascii_uppercase().to_string() });+ }+ }+ if several {+ self.line("*U");+ }+ }++ /// `rule` as `XR` (1: even-odd).+ fn fill_rule(&mut self, rule: FillRule) {+ self.line(if rule == FillRule::EvenOdd { "1 XR" } else { "0 XR" });+ }++ /// One subpath's points, in art space: `m`, then a line or curve to each point (lower case: the+ /// point is smooth, upper case: a corner, §5.3.2), and for a closed one the segment back to the+ /// start, which says whether the start is smooth or a corner (as the specification's examples+ /// close paths: the start point again, then the painting operator).+ fn subpath(&mut self, sp: &SubPath) {+ let Some(first) = sp.anchors.first() else { return };+ let xf = self.to_art;+ let s = &mut self.body;+ let pt = |s: &mut String, p: Point| {+ let p = xf * p;+ ps::push_nums(s, &[p.x, p.y]);+ };+ pt(s, first.p);+ s.push_str("m\n");+ let segment = |s: &mut String, a: &vectorcraft_geom::Anchor, b: &vectorcraft_geom::Anchor| {+ let straight = a.h_out == a.p && b.h_in == b.p;+ let smooth = b.kind == AnchorKind::Smooth;+ if straight {+ pt(s, b.p);+ s.push_str(if smooth { "l\n" } else { "L\n" });+ } else {+ pt(s, a.h_out);+ pt(s, b.h_in);+ pt(s, b.p);+ s.push_str(if smooth { "c\n" } else { "C\n" });+ }+ };+ for pair in sp.anchors.windows(2) {+ if let [a, b] = pair {+ segment(s, a, b);+ }+ }+ if sp.closed+ && sp.anchors.len() > 1+ && let Some(last) = sp.anchors.last()+ {+ segment(s, last, first);+ }+ }++ /// The stroke's width, cap, join, miter limit and dashes: `w J j M d`.+ fn line_style(&mut self, st: &StrokeLayer) {+ let cap = match st.cap {+ LineCap::Butt => 0,+ LineCap::Round => 1,+ LineCap::Square => 2,+ };+ let join = match st.join {+ LineJoin::Miter => 0,+ LineJoin::Round => 1,+ LineJoin::Bevel => 2,+ };+ let s = &mut self.body;+ ps::push_num(s, st.width);+ let _ = write!(s, " w {cap} J {join} j ");+ ps::push_num(s, if st.miter_limit.is_finite() { st.miter_limit.max(1.0) } else { 10.0 });+ s.push_str(" M [");+ let dash = st.dash.as_ref().filter(|d| d.is_dashed());+ if let Some(d) = dash {+ ps::push_nums(s, &d.pattern);+ s.pop();+ }+ s.push_str("] ");+ ps::push_num(s, dash.map_or(0.0, |d| d.offset));+ s.push_str(" d\n");+ }++ // ---------- colour ----------++ /// How `p` (a solid paint) is written.+ pub(super) fn ink(&self, p: &Paint) -> Ink {+ let Paint::Solid { color, swatch, tint } = p else { return Ink::Gray(0.0) };+ let doc = self.doc;+ let intent = self.cms.settings().intent;+ if let Some(name) = swatch+ && let Some(sw) = doc.swatch(name).filter(|s| s.spot)+ && let Some(full) = sw.paint.color()+ {+ let full = doc.linked_color(full, true);+ return Ink::Spot { cmyk: self.cms.to_cmyk(&full, intent).map(unit), name: name.clone(), tint: unit(*tint) };+ }+ match *color {+ // Grey is ink coverage; the format's grey is lightness.+ Color::Gray { k } => Ink::Gray(unit(1.0 - k)),+ Color::Cmyk { c, m, y, k } => Ink::Cmyk([c, m, y, k].map(unit)),+ Color::Rgb { r, g, b } => Ink::Rgb(self.cms.to_cmyk(color, intent).map(unit), [r, g, b].map(unit)),+ Color::Lab { .. } => {+ let rgb = color.to_rgb().map(unit);+ Ink::Rgb(self.cms.to_cmyk(color, intent).map(unit), rgb)+ }+ }+ }++ /// Set the fill (or with `stroke`, the stroke) colour to solid paint `p`.+ fn color(&mut self, p: &Paint, stroke: bool) {+ let ink = match self.ink(p) {+ Ink::Spot { cmyk, name, tint } => Ink::Spot { name: self.spot(&name, cmyk), cmyk, tint },+ ink => ink,+ };+ let op = |fill: &'static str, line: &'static str| if stroke { line } else { fill };+ let s = &mut self.body;+ match ink {+ Ink::Gray(v) => {+ ps::push_num(s, f64::from(v));+ let _ = writeln!(s, " {}", op("g", "G"));+ }+ Ink::Cmyk(c) => {+ ps::push_nums(s, &c.map(f64::from));+ let _ = writeln!(s, "{}", op("k", "K"));+ }+ Ink::Rgb(_, rgb) => {+ ps::push_nums(s, &rgb.map(f64::from));+ let _ = writeln!(s, "{}", op("Xa", "XA"));+ }+ Ink::Spot { cmyk, name, tint } => {+ ps::push_nums(s, &cmyk.map(f64::from));+ let _ = write!(s, "{} ", latin_string(&name));+ // The format's tint is how much lighter than the full colour (0: full).+ ps::push_num(s, f64::from(1.0 - tint));+ let _ = writeln!(s, " {}", op("x", "X"));+ }+ }+ }++ // ---------- gradients ----------++ /// The definition gradient `g` uses (defined once for each distinct gradient), and its+ /// instance on a path of bounds `bounds`: `Bb`, a radial's highlight `x y angle fraction Bh`+ /// (its distance a fraction of the radius, at most 1, §3.5.5; `0 0 0 0 Bh` at the center,+ /// §3.5.6), `1 (name) x y angle length 1 0 0 1 0 0 Bg`.+ fn gradient(&mut self, g: &GradientPaint, bounds: Rect) -> String {+ let name = self.define(&g.gradient, g.swatch.as_deref());+ for stop in &g.gradient.stops {+ if stop.opacity < 1.0 {+ self.warn(TRANSPARENCY);+ }+ if let Some(sw) = &stop.swatch {+ // Spot colours in stops are custom colours too.+ let p = Paint::Solid { color: stop.color, swatch: Some(sw.clone()), tint: stop.tint };+ if let Ink::Spot { cmyk, name, .. } = self.ink(&p) {+ self.spot(&name, cmyk);+ }+ }+ }+ let geom = g.resolve(bounds);+ let (start, end) = (self.to_art * geom.start, self.to_art * geom.end);+ let d = end - start;+ let (angle, length) = (d.y.atan2(d.x).to_degrees(), d.hypot());+ // The matrix is relative to the origin of a canvas whose size the specification doesn't+ // give (§3.5.4), so it stays the identity: an elliptical radial is written circular.+ if g.gradient.kind == GradientKind::Radial && (geom.aspect - 1.0).abs() > 1e-6 {+ self.warn(ELLIPTICAL);+ }+ let mut s = String::from("Bb\n");+ if g.gradient.kind == GradientKind::Radial {+ // Every radial instance has a highlight (§3.5.5), `0 0 0 0 Bh` at the center (§3.5.6).+ // It lies within the gradient's circle: one past the radius is written on it.+ let off: Vec2 = geom.focal.map_or(Vec2::ZERO, |f| self.to_art * f - start);+ let fraction = if off.hypot() > 1e-9 && length > 1e-9 { off.hypot() / length } else { 0.0 };+ let (off, angle) = if fraction > 0.0 { (off / fraction.max(1.0), off.y.atan2(off.x).to_degrees()) } else { (Vec2::ZERO, 0.0) };+ ps::push_nums(&mut s, &[off.x, off.y, angle, fraction.min(1.0)]);+ s.push_str("Bh\n");+ }+ s.push_str("1 ");+ s.push_str(&latin_string(&name));+ s.push(' ');+ ps::push_nums(&mut s, &[start.x, start.y, angle, length]);+ s.push_str("1 0 0 1 0 0 Bg\n");+ s+ }++ /// The name of the definition of `g` (its swatch's name when it has one, with each character+ /// outside Windows-1252 written as `?` and a warning), defined the first time.+ fn define(&mut self, g: &Gradient, swatch: Option<&str>) -> String {+ if let Some((name, _)) = self.gradients.iter().find(|(_, d)| d == g) {+ return name.clone();+ }+ let taken = |n: &str, defs: &[(String, Gradient)]| defs.iter().any(|(m, _)| m == n);+ let base = self.latin_name(swatch.filter(|s| !s.is_empty()).unwrap_or("Gradient"), TITLE_AND_COLOR_NAMES);+ let mut name = base.clone();+ let mut i = 1;+ while taken(&name, &self.gradients) {+ i += 1;+ name = format!("{base} {i}");+ }+ self.gradients.push((name.clone(), g.clone()));+ name+ }++ // ---------- type ----------++ /// Type: a text object when the format can hold it as text, else its outlines.+ fn text(&mut self, t: &TextObject) {+ if !invertible(t.xf) {+ return;+ }+ if !self.outline_text {+ if writable(t) {+ return self.text_object(t);+ }+ self.warn(TYPE);+ }+ self.outlines(t);+ }++ /// A text object (§15): `type To`, the text path (`a b c d tx ty startPt Tp`, an area's frame+ /// or the path type runs along, `TP`), then each run's style and characters, `TO`. The matrix+ /// takes text space (y up, the first baseline's start for point type) to art space; the frame+ /// and path are in art space, as the specification's examples have them (§15.5).+ fn text_object(&mut self, t: &TextObject) {+ if lost_attributes(t) {+ self.warn(TYPE_ATTRIBUTES);+ }+ // Area type that Shrink Text to Fit scales down is written in the styles it draws in.+ let fitted = matches!((&t.kind, t.area.fit), (TextKind::Area { .. }, vectorcraft_doc::AreaFit::ShrinkText { .. }))+ .then(|| vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t).fit_scale)+ .filter(|f| *f != 1.0)+ .map(|f| vectorcraft_text::scaled(t, f));+ let t = fitted.as_ref().unwrap_or(t);+ let m = self.to_art * t.xf * Affine::new([1.0, 0.0, 0.0, -1.0, 0.0, 0.0]);+ let (kind, path, start) = match &t.kind {+ TextKind::Point => (0, None, 0.0),+ TextKind::Area { frame } => (1, frame.subpaths.iter().find(|sp| !sp.anchors.is_empty()).cloned(), 0.0),+ TextKind::OnPath { path, .. } => {+ let sp = path.subpaths.iter().find(|sp| !sp.anchors.is_empty()).cloned();+ let fraction = t.kind.path_span().map_or(0.0, |(s, _)| s);+ let start = sp+ .as_ref()+ .map_or(0.0, |sp| segment_point(&PathData::new(vec![sp.clone()]).transformed(self.to_art * t.xf).to_bezpath(), fraction));+ (2, sp, start)+ }+ };+ let _ = writeln!(self.body, "{kind} To");+ let [a, b, c, d, e, f] = m.as_coeffs();+ ps::push_nums(&mut self.body, &[a, b, c, d, e, f, start]);+ self.line("Tp");+ if let Some(sp) = path {+ let placed = SubPath::new(sp.anchors.iter().map(|a| a.transform(t.xf)).collect(), sp.closed);+ self.subpath(&placed);+ self.line(if sp.closed { "n" } else { "N" });+ }+ self.line("TP");+ let mut para = 0usize;+ let mut para_start = true;+ for run in &t.runs {+ let text = if run.style.all_caps { run.text.to_uppercase() } else { run.text.clone() };+ let mut pieces = text.split('\n').peekable();+ while let Some(piece) = pieces.next() {+ let ends_paragraph = pieces.peek().is_some();+ if piece.is_empty() && !ends_paragraph {+ continue;+ }+ if para_start {+ self.paragraph(t.para_at(para));+ para_start = false;+ }+ self.char_style(&run.style, t.para_at(para));+ let mut bytes: Vec<u8> = piece.chars().filter_map(latin::encode).collect();+ if ends_paragraph {+ bytes.push(b'\r');+ para += 1;+ para_start = true;+ }+ self.body.push_str(&ps::bytes(&bytes));+ self.line(" Tx");+ }+ }+ self.line("TO");+ }++ /// A paragraph's attributes: alignment `Ta` and indents `Ti` (first line's, left, right).+ fn paragraph(&mut self, p: &ParaStyle) {+ let align = match p.justify {+ Justify::Auto if p.direction == Some(ParaDirection::RightToLeft) => 2,+ Justify::Auto | Justify::Left => 0,+ Justify::Center => 1,+ Justify::Right => 2,+ Justify::JustifyLeft | Justify::JustifyCenter | Justify::JustifyRight => 3,+ Justify::JustifyAll => 4,+ };+ let _ = writeln!(self.body, "{align} Ta");+ ps::push_nums(&mut self.body, &[p.first_line_indent, p.left_indent, p.right_indent]);+ self.line("Ti");+ }++ /// A run's character attributes and paint style: `Tr`, its fill and stroke, `Tf`, `Ts`, `Tz`,+ /// `Tt`, `TA`, and the leading with the space before its paragraph, `Tl`.+ fn char_style(&mut self, st: &CharStyle, p: &ParaStyle) {+ let fill = !st.fill.is_none();+ let stroke = st.has_stroke();+ let render = match (fill, stroke) {+ (true, false) => 0,+ (false, true) => 1,+ (true, true) => 2,+ (false, false) => 3,+ };+ let _ = writeln!(self.body, "{render} Tr");+ if fill {+ self.color(&st.fill, false);+ self.line(if st.overprint_fill { "1 O" } else { "0 O" });+ }+ if stroke {+ self.color(&st.stroke, true);+ self.line(if st.overprint_stroke { "1 R" } else { "0 R" });+ self.line_style(&st.stroke_layer());+ }+ let (name, truetype, ascent, descent) = font_of(st);+ if !self.fonts.iter().any(|(n, _)| *n == name) {+ self.fonts.push((name.clone(), truetype));+ }+ let size = finite(st.size, 12.0);+ let _ = write!(self.body, "/_{name} ");+ ps::push_nums(&mut self.body, &[size, ascent * size, descent * size]);+ self.line("Tf");+ ps::push_num(&mut self.body, finite(st.baseline_shift, 0.0));+ self.line(" Ts");+ ps::push_nums(&mut self.body, &[finite(st.h_scale, 100.0), finite(st.v_scale, 100.0)]);+ self.line("Tz");+ ps::push_num(&mut self.body, finite(st.tracking, 0.0));+ self.line(" Tt");+ self.line(if st.kerning.is_none() { "1 TA" } else { "0 TA" });+ ps::push_nums(&mut self.body, &[finite(st.effective_leading(), size * 1.2), finite(p.space_before, 0.0)]);+ self.line("Tl");+ }++ /// Type as its glyphs' outlines: a group of a compound path for each run, with the run's fill+ /// and stroke.+ fn outlines(&mut self, t: &TextObject) {+ let layout = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);+ let scale = t.xf.determinant().abs().sqrt();+ self.line("u");+ for (i, run) in t.runs.iter().enumerate() {+ let mut bp = BezPath::new();+ // Ruby (furigana) glyphs in their base text's run's paint, as the canvas draws them.+ for g in layout.glyphs.iter().chain(&layout.ruby).filter(|g| g.run == i) {+ bp.extend(g.outline.iter());+ }+ if bp.elements().is_empty() {+ continue;+ }+ bp.apply_affine(t.xf);+ let path = PathData::from_bezpath(&bp);+ let fill =+ (!run.style.fill.is_none()).then(|| FillLayer { overprint: run.style.overprint_fill, ..FillLayer::new(run.style.fill.clone()) });+ let stroke = run.style.has_stroke().then(|| {+ let mut s = run.style.stroke_layer();+ s.width *= scale;+ s+ });+ let items: Vec<AppearanceItem> = fill.map(AppearanceItem::Fill).into_iter().chain(stroke.map(AppearanceItem::Stroke)).collect();+ let mut n = Node::path(vectorcraft_doc::NodeId(0), path.clone(), vectorcraft_doc::Appearance::default());+ n.appearance = vectorcraft_doc::Appearance { items, ..vectorcraft_doc::Appearance::default() }.into();+ self.shape(&n, &path, FillRule::NonZero);+ }+ // Colour bitmap glyphs (emoji): their images, which the runs' paint doesn't paint.+ for g in &layout.glyphs {+ if let Some((image, to_text)) = g.placed_image() {+ self.image(Some(&image.blob), image.width, image.height, t.xf * to_text);+ }+ // COLR glyphs: their layers, as art.+ if let Some(art) = g.placed_colour(t.xf) {+ self.node(&art, false);+ }+ }+ self.line("U");+ }++ // ---------- images ----------++ /// An image (§8): `%AI5_File:`, `%AI5_BeginRaster`, its matrix (an art-space matrix applied to+ /// the pixels with their rows running downwards, `(u, -v)`) as `[ a b c d tx ty ]` and its+ /// operands with `XI`, its RGB samples in hex on comment lines of [`HEX_LINE`] digits,+ /// `%AI5_EndRaster`, then `F`. §8.4's examples have no `F`; without it, an app reading the file+ /// can leave out an image in a clipping group and the art after it. No path is open there, so+ /// the `F` paints nothing. `blob` holds the pixels, placed as a grid of `width` × `height`+ /// by `xf`.+ fn image(&mut self, blob: Option<&ImageBlob>, width: u32, height: u32, xf: Affine) {+ let flip = Affine::new([1.0, 0.0, 0.0, -1.0, 0.0, 0.0]);+ let m = self.to_art * xf * flip;+ if !invertible(m) {+ return;+ }+ if blob.is_some_and(|b| b.bytes.is_empty()) {+ self.warn(LARGE_IMAGE);+ return;+ }+ let Some(img) = blob.and_then(|b| image::load_from_memory(&b.bytes).ok()) else {+ self.warn(UNDECODED);+ return;+ };+ let (w, h) = (img.width(), img.height());+ if w == 0 || h == 0 || u64::from(w) * u64::from(h) > MAX_IMAGE_PIXELS {+ self.warn(LARGE_IMAGE);+ return;+ }+ // The object places the image's own pixel grid (its width × height) wherever the file's is.+ let fit = Affine::scale_non_uniform(f64::from(width.max(1)) / f64::from(w), f64::from(height.max(1)) / f64::from(h));+ let m = self.to_art * xf * fit * flip;+ let rgba = img.to_rgba8();+ let mut hex = String::with_capacity(rgba.len() / 4 * 7);+ hex.push('%');+ let mut on_line = 0;+ let mut see_through = false;+ for px in rgba.pixels() {+ let [r, g, b, a] = px.0;+ if a < 255 {+ see_through = true;+ }+ // Over white.+ let over = |c: u8| ((u32::from(c) * u32::from(a) + 255 * (255 - u32::from(a)) + 127) / 255) as u8;+ for c in [over(r), over(g), over(b)] {+ let _ = write!(hex, "{c:02X}");+ on_line += 2;+ if on_line >= HEX_LINE {+ hex.push_str("\n%");+ on_line = 0;+ }+ }+ }+ if hex.ends_with('%') {+ hex.pop();+ } else {+ hex.push('\n');+ }+ if see_through {+ self.warn(IMAGE_ALPHA);+ }+ let [a, b, c, d, e, f] = m.as_coeffs();+ let s = &mut self.body;+ s.push_str("%AI5_File:\n%AI5_BeginRaster\n[ ");+ ps::push_nums(s, &[a, b, c, d, e, f]);+ let _ = writeln!(s, "] 0 0 {w} {h} {w} {h} 8 3 0 0 0 0 XI");+ s.push_str(&hex);+ s.push_str("%AI5_EndRaster\nF\n");+ }+}