VectorCraft: An open-source, vector art tool written by scratch in pure Rust
refactor(svg): move export.rs items to export/{nodes,output,paint,text}.rs
aiongg7e5276017494
diff --git a/crates/svg/src/export.rs b/crates/svg/src/export.rsindex c393f98f3..9b64f97dd 100644--- a/crates/svg/src/export.rs+++ b/crates/svg/src/export.rs@@ -21,6 +21,17 @@ use crate::{use crate::css::{self, Props, blend_css, css_string, font_descriptor};+mod nodes;+mod output;+mod paint;+mod text;++use nodes::SymbolDef;+pub(crate) use nodes::{MASK_FLAGS, Reuse};+pub(crate) use output::sanitize_id;+use output::{entity_value, latin1_refs, valid_xml_value, xml_attr_escape, xml_text};+use text::FontUse;+pub(crate) fn export(doc: &Document, opts: &ExportOptions, native: Option<&[u8]>) -> Output {// Live geometry effects (Roughen, Warp, Offset Path, Effect → Pathfinder…) export as their result.let baked = vectorcraft_effects::bake_document(doc);@@ -182,118 +193,6 @@ fn write(doc: &Document, opts: &ExportOptions, native: Option<&[u8]>, id_prefix:Output { svg: out, linked: w.linked, warnings: w.warnings, encoding }}-/// XML 1.0 literal attribute whitespace is normalized to spaces; references retain the value.-fn xml_attr_escape(s: &str) -> String {- xml_escape(s).replace('\t', "	").replace('\n', " ").replace('\r', " ")-}--/// Escape type for XML content. Characters XML 1.0 does not allow are dropped, except the line-/// and page breaks (U+000B, U+000C) other apps paste, which become spaces.-fn xml_text(s: &str) -> String {- let s: String = s- .chars()- .filter_map(|c| match c {- '\u{b}' | '\u{c}' => Some(' '),- c if valid_xml_value(c.encode_utf8(&mut [0; 4])) => Some(c),- _ => None,- })- .collect();- xml_escape(&s)-}--fn valid_xml_value(s: &str) -> bool {- s.chars().all(|c| matches!(c, '\t' | '\n' | '\r' | '\u{20}'..='\u{d7ff}' | '\u{e000}'..='\u{fffd}' | '\u{10000}'..='\u{10ffff}'))-}--/// An XML name without a colon (an NCName): a letter or `_`, then [`xml_name_char`]s.-fn xml_ncname(s: &str) -> bool {- let mut chars = s.chars();- chars.next().is_some_and(|c| c.is_alphabetic() || c == '_') && chars.all(xml_name_char)-}--/// Namespace-free XML 1.0 NameChar. The fixed `data-` prefix supplies NameStartChar.-fn xml_name_char(c: char) -> bool {- matches!(c,- 'A'..='Z' | 'a'..='z' | '0'..='9' | '_' | '-' | '.' | '\u{b7}' |- '\u{c0}'..='\u{d6}' | '\u{d8}'..='\u{f6}' | '\u{f8}'..='\u{2ff}' |- '\u{300}'..='\u{37d}' | '\u{37f}'..='\u{1fff}' | '\u{200c}'..='\u{200d}' |- '\u{203f}'..='\u{2040}' | '\u{2070}'..='\u{218f}' | '\u{2c00}'..='\u{2fef}' |- '\u{3001}'..='\u{d7ff}' | '\u{f900}'..='\u{fdcf}' | '\u{fdf0}'..='\u{fffd}' |- '\u{10000}'..='\u{effff}'- )-}--/// Write every character of `s` beyond ISO 8859-1 as a character reference. Called only when-/// names fit Latin-1, so references occur in values, text or style sheets.-fn latin1_refs(s: &mut String) {- if s.chars().all(|c| u32::from(c) < 0x100) {- return;- }- let mut o = String::with_capacity(s.len() + 64);- for c in s.chars() {- if u32::from(c) < 0x100 {- o.push(c);- } else {- let _ = write!(o, "&#x{:X};", u32::from(c));- }- }- *s = o;-}--/// `chars` (sorted) as a CSS `unicode-range` (`U+41-5A,U+61`).-fn unicode_range(chars: &BTreeSet<char>) -> String {- let mut runs: Vec<(u32, u32)> = Vec::new();- for c in chars.iter().map(|c| u32::from(*c)) {- match runs.last_mut() {- Some((_, end)) if c == *end + 1 => *end = c,- _ => runs.push((c, c)),- }- }- let one = |(a, b): (u32, u32)| if a == b { format!("U+{a:X}") } else { format!("U+{a:X}-{b:X}") };- runs.into_iter().map(one).collect::<Vec<_>>().join(",")-}--/// A CSS declaration block as the literal value of an `<!ENTITY>`: quotes, `%` and markup-/// characters become references that still read as themselves inside the `style` attribute.-fn entity_value(decl: &str) -> String {- let mut o = String::with_capacity(decl.len());- for c in decl.chars() {- match c {- '"' => o.push_str("""),- '%' => o.push_str("%"),- // Doubly escaped: the entity's replacement text is parsed again where it is used.- '&' => o.push_str("&#38;"),- '<' => o.push_str("&#60;"),- _ => o.push(c),- }- }- o-}--/// Image `b` as SVG viewers show it: PNG, JPEG, GIF, WebP and SVG as they are, other formats (a-/// CMYK TIFF) as PNG.-fn web_image(b: &ImageBlob) -> std::borrow::Cow<'_, ImageBlob> {- use std::borrow::Cow;- if matches!(b.mime.as_str(), "image/png" | "image/jpeg" | "image/jpg" | "image/gif" | "image/webp" | "image/svg+xml") {- return Cow::Borrowed(b);- }- let png = image::load_from_memory(&b.bytes).ok().and_then(|img| {- let mut out = Vec::new();- img.write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png).ok()?;- Some(out)- });- png.map_or(Cow::Borrowed(b), |png| Cow::Owned(ImageBlob::png(png)))-}--/// The usual file extension of an image MIME type.-fn image_ext(mime: &str) -> &str {- match mime {- "image/jpeg" => "jpg",- "image/svg+xml" => "svg",- m => m.strip_prefix("image/").filter(|e| !e.is_empty() && e.chars().all(|c| c.is_ascii_alphanumeric())).unwrap_or("bin"),- }-}-struct Writer<'a> {doc: &'a Document,opts: &'a ExportOptions,@@ -352,2297 +251,3 @@ struct Writer<'a> {/// ([`Writer::foreign_attrs`]): declared on the root.foreign_ns: BTreeMap<String, String>,}--/// The characters type uses from one face, under one `@font-face` description: the family the-/// type names and the weight, italic and width its style asks for.-struct FontUse {- family: String,- weight: u16,- italic: bool,- /// The `font-stretch` percentage ([`css::font_stretch`]), as bits; `None` for the normal width.- stretch: Option<u64>,- face: Arc<FontFace>,- chars: BTreeSet<char>,-}--/// A symbol's `<symbol>` def and the instance transforms that can `<use>` it.-struct SymbolDef {- /// The def's id, once written.- id: Option<String>,- reuse: Reuse,-}--/// Which instance transforms paint a symbol's art exactly as the def under that transform (the-/// canvas transforms the art's geometry alone: stroke weights, effects, patterns and unlinked-/// masks stay put).-#[derive(Clone, Copy)]-pub(crate) struct Reuse {- /// Translations (no pattern paints or unlinked masks).- moves: bool,- /// Rotations and reflections (nor effects or brushes).- turns: bool,- /// Any other transform (nor strokes or live objects).- scales: bool,-}--/// How one stroke is written.-enum StrokePlan {- /// Its brush art (document space).- Brush(Vec<Node>),- Written(Written),-}--/// How deep symbols may sit in one another's art (deeper instances are left out).-const MAX_SYMBOL_NEST: u32 = 8;--impl Reuse {- const NONE: Self = Self { moves: false, turns: false, scales: false };-- /// What a def of symbol art `art` stands for.- pub(crate) fn of(doc: &Document, art: &Node) -> Self {- let mut r = Self { moves: true, turns: true, scales: true };- r.scan(doc, art, 0);- r- }-- /// Narrow down to what `n` (inside symbols nested `depth` deep) allows.- fn scan(&mut self, doc: &Document, n: &Node, depth: u32) {- let pattern = |p: &Paint| matches!(p, Paint::Pattern { .. });- let text_patterns = matches!(&n.kind, NodeKind::Text(t) if t.runs.iter().any(|r| pattern(&r.style.fill) || pattern(&r.style.stroke)));- let unlinked_mask = n.extras().mask.as_ref().is_some_and(|m| !m.linked);- if depth > MAX_SYMBOL_NEST || text_patterns || unlinked_mask || vectorcraft_doc::pattern::uses_pattern(n, None) {- *self = Self::NONE;- return;- }- let effects = |fx: &[vectorcraft_doc::Effect]| fx.iter().any(|e| e.visible);- if effects(&n.appearance.effects) || n.appearance.items.iter().any(|i| effects(i.effects())) {- (self.turns, self.scales) = (false, false);- }- for i in &n.appearance.items {- if let AppearanceItem::Stroke(s) = i- && s.visible- && !s.paint.is_none()- && s.width > 0.0- {- // Stroke weights don't scale; brushes can orient their art to the page.- self.scales = false;- self.turns &= s.brush.is_none();- }- }- match &n.kind {- NodeKind::Blend { .. }- | NodeKind::Envelope { .. }- | NodeKind::Mesh(_)- | NodeKind::Repeat(_)- | NodeKind::PlacedDocument(_)- | NodeKind::Intertwine { .. } => (self.turns, self.scales) = (false, false),- NodeKind::SymbolInstance { symbol, .. } => {- if let Some(s) = doc.symbols.iter().find(|s| s.name == *symbol) {- self.scan(doc, &s.art, depth + 1);- }- }- _ => {}- }- if let Some(m) = &n.extras().mask {- self.scan(doc, &m.art, depth);- }- for c in n.children().into_iter().flatten() {- self.scan(doc, c, depth);- }- }-- /// Can the def stand for an instance with transform `xf`?- pub(crate) fn allows(self, xf: Affine) -> bool {- const EPS: f64 = 1e-9;- let [a, b, c, d, _, _] = xf.as_coeffs();- if (a - 1.0).abs() < EPS && b.abs() < EPS && c.abs() < EPS && (d - 1.0).abs() < EPS {- return self.moves;- }- let rigid = (a * a + b * b - 1.0).abs() < EPS && (c * c + d * d - 1.0).abs() < EPS && (a * c + b * d).abs() < EPS;- if rigid { self.turns } else { self.scales }- }-}--/// Art about to be written moved by `m.inverse()` (a symbol instance's): map what the canvas-/// leaves on the page by `m` first, so it stays there. That is every pattern paint's placement-/// and the art of unlinked opacity masks.-fn pin_to_page(n: &mut Node, m: Affine) {- vectorcraft_doc::pattern::transform_pattern_paints(n, m);- if let Some(mask) = n.extras_if_any().and_then(|e| e.mask.as_deref_mut()) {- let linked = mask.linked;- let art = std::sync::Arc::make_mut(&mut mask.art);- if !linked {- art.transform(m, false);- }- pin_to_page(art, m);- }- for c in n.children_mut().into_iter().flatten() {- pin_to_page(std::sync::Arc::make_mut(c), m);- }-}--/// The Dublin Core terms File Info writes to `<metadata>`: the format, title, author (creator),-/// description, each keyword (subject), copyright notice and URL (rights) and created date, the-/// empty ones left out.-fn dublin_core(doc: &Document) -> Vec<(&'static str, String)> {- let info = &doc.metadata;- let mut terms = vec![("format", "image/svg+xml".to_string())];- let created = info.created.map(vectorcraft_doc::metadata::iso8601).unwrap_or_default();- let fields = [("title", doc.title.as_str()), ("creator", info.author.as_str()), ("description", info.description.as_str())];- let rights = [("rights", info.copyright_notice.as_str()), ("rights", info.copyright_url.as_str()), ("date", created.as_str())];- let keywords = info.keywords.iter().map(|k| ("subject", k.as_str()));- terms.extend(fields.into_iter().chain(keywords).chain(rights).filter(|(_, v)| !v.trim().is_empty()).map(|(k, v)| (k, v.to_string())));- terms-}--/// What SVG Tiny 1.2 does without masks.-const TINY_MASKS: &str = "SVG Tiny 1.2 has no masks: opacity masks are left out and knockout groups written as plain groups";-/// A region covering any artwork (mask and filter extents).-const BIG: &str = "x=\"-100000\" y=\"-100000\" width=\"200000\" height=\"200000\"";-/// Attributes of every `<mask>`: user-space units, and luminance taken from the sRGB values (as the-/// canvas and PDF take it) rather than from linearised ones.-const MASK: &str = "maskUnits=\"userSpaceOnUse\" color-interpolation=\"sRGB\"";-/// Attribute of an exported opacity mask listing its options that differ from the defaults-/// (clipping, not inverted): `noclip`, `invert`.-pub(crate) const MASK_FLAGS: &str = "data-vectorcraft-mask";--/// Turn an object name into a valid, readable XML id.-pub(crate) fn sanitize_id(name: &str) -> String {- let mut s: String = name.trim().chars().map(|c| if c.is_alphanumeric() || c == '-' || c == '_' || c == '.' { c } else { '_' }).collect();- if s.is_empty() || !s.starts_with(|c: char| c.is_alphabetic() || c == '_') {- s.insert(0, '_');- }- s-}--impl Writer<'_> {- /// Writing the SVG Tiny 1.2 profile?- fn tiny(&self) -> bool {- self.opts.profile == Profile::Tiny12- }- fn num(&self, v: f64) -> String {- fmt_num(v, self.opts.decimals)- }- fn indent(&self, depth: usize) -> String {- if self.opts.minify { String::new() } else { " ".repeat(depth) }- }- fn line(&mut self, s: &str) {- let ind = self.indent(self.depth);- self.body.push_str(&ind);- self.body.push_str(s);- if !self.opts.minify {- self.body.push('\n');- }- }- fn def(&mut self, depth: usize, s: &str) {- let ind = self.indent(depth + 1);- self.defs.push_str(&ind);- self.defs.push_str(s);- if !self.opts.minify {- self.defs.push('\n');- }- }- /// The `href` of image `im`: its file with [`ImageMode::Link`] (or when its pixels are- /// missing), else its bytes. `None` when it has neither.- fn image_href(&mut self, im: &vectorcraft_doc::ImageObject) -> Option<String> {- let (doc, link) = (self.doc, self.opts.images == ImageMode::Link);- match (im.link.as_ref().filter(|_| link), doc.image_blob(im)) {- (Some(l), _) => Some(l.path.clone()),- (None, Some(b)) if !b.bytes.is_empty() => Some(self.blob_href(&web_image(b))),- _ => im.link.as_ref().map(|l| l.path.clone()),- }- }-- /// Images drawn more than once in `art` (the pieces of a distorted image) go into the defs- /// once; each piece then draws them with `<use>`.- fn share_images(&mut self, art: &Node) {- // Each image's count and its first piece, which shows what they all show.- let mut seen: HashMap<(String, u32, u32), (usize, vectorcraft_doc::ImageObject)> = HashMap::new();- art.walk(&mut |c| {- if let NodeKind::Image(im) = &c.kind {- seen.entry((im.key.clone(), im.width, im.height)).or_insert_with(|| (0, (**im).clone())).0 += 1;- }- });- let mut repeated: Vec<_> = seen.into_iter().filter(|(k, (n, _))| *n > 1 && !self.shared_images.contains_key(k)).collect();- repeated.sort_by(|a, b| a.0.cmp(&b.0));- for ((key, width, height), (_, im)) in repeated {- let Some(href) = self.image_href(&im) else { continue };- let id = self.fresh_id("image");- self.def(- 0,- &format!(- "<image id=\"{id}\" width=\"{width}\" height=\"{height}\" preserveAspectRatio=\"none\" xlink:href=\"{}\"/>",- xml_escape(&href)- ),- );- self.shared_images.insert((key, width, height), id);- }- }-- fn fresh_id(&mut self, prefix: &str) -> String {- let mut i = 1;- loop {- let id = format!("{}{prefix}-{i}", self.id_prefix);- if self.used_ids.insert(id.clone()) {- return id;- }- i += 1;- }- }- /// `base` (with the unique prefix) if free, else `base-2`, `base-3`…- fn unique_id(&mut self, base: &str) -> String {- let base = format!("{}{base}", self.id_prefix);- if self.used_ids.insert(base.clone()) {- return base;- }- let next = self.next_suffix.entry(base.clone()).or_insert(2);- loop {- let cand = format!("{base}-{next}");- *next += 1;- if self.used_ids.insert(cand.clone()) {- return cand;- }- }- }-- /// Reserve ids for every named object up front so generated def ids never collide with them.- fn assign_name_ids(&mut self) {- if self.opts.object_ids == ObjectIds::Minimal {- return;- }- let mut named: Vec<(NodeId, String)> = Vec::new();- self.doc.walk(|n| {- if let Some(name) = &n.name {- named.push((n.id, sanitize_id(name)));- }- });- for (id, base) in named {- let cand = self.unique_id(&base);- self.names.insert(id, cand);- }- }- /// ` id="…"` for a named object, plus ` data-name="…"` with the name itself when the id had to- /// differ from it (spaces, punctuation, duplicates, the unique prefix).- /// The id of `n`'s element (with its name when the id isn't it), then the object's own data- /// as `data-*` attributes. Sublayers also retain their import marker.- fn id_attr(&mut self, n: &Node) -> String {- if self.anonymous {- return String::new();- }- let mut out = self.names.get(&n.id).map_or_else(String::new, |id| format!(" id=\"{}\"", xml_escape(id)));- if let (Some(id), Some(name)) = (self.names.get(&n.id), n.name.as_deref())- && name != id- {- if valid_xml_value(name) {- out.push_str(&format!(" data-name=\"{}\"", xml_attr_escape(name)));- } else {- self.warn("Object names containing invalid XML characters were left out of SVG name attributes");- }- }- // Preserve sublayer identity independently of object data attributes.- if !out.is_empty() && n.is_layer() && self.layer_nest > 1 {- out.push_str(&format!(" {}=\"sublayer\"", crate::import::SUBLAYER));- }- let mut keys = HashSet::new();- for (k, v) in n.extras().attrs.as_deref().map_or(&[][..], |a| a.data.as_slice()) {- // Ours (`name`, `vc-…`) are written by the export itself.- if k == "name" || k.starts_with("vc-") {- continue;- }- if k.is_empty() || !k.chars().all(xml_name_char) || !valid_xml_value(v) {- self.warn("Data attributes with invalid XML names or characters were left out of SVG");- continue;- }- // Native data is an ordered list. Keep the first valid value of each key.- if !keys.insert(k.as_str()) {- self.warn("Repeated data attribute keys were written only once in SVG");- continue;- }- self.non_latin1_names |= k.chars().any(|c| u32::from(c) > 0xff);- out.push_str(&format!(" data-{k}=\"{}\"", xml_attr_escape(v)));- }- self.foreign_attrs(n, &mut out);- self.event_attrs(n, &mut out);- out- }- /// `n`'s attributes in other applications' namespaces (`plotter:pen="2"`), added to `out`.- /// Each namespace is declared once, on the root, under the prefix the file gave it unless the- /// export uses that prefix itself or for another namespace ([`Writer::foreign_prefix`]).- fn foreign_attrs(&mut self, n: &Node, out: &mut String) {- let attrs = n.extras().attrs.as_deref().map_or(&[][..], |a| a.foreign.as_slice());- let mut seen = HashSet::new();- for a in attrs {- if !xml_ncname(&a.prefix) || !xml_ncname(&a.name) || a.ns.is_empty() || !valid_xml_value(&a.ns) || !valid_xml_value(&a.value) {- self.warn("Attributes of other applications with invalid XML names or characters were left out of SVG");- continue;- }- // Native data is a list: one attribute per namespace and name.- if !seen.insert((a.ns.as_str(), a.name.as_str())) {- self.warn("Repeated attributes of other applications were written only once in SVG");- continue;- }- let prefix = self.foreign_prefix(&a.ns, &a.prefix);- self.non_latin1_names |= prefix.chars().chain(a.name.chars()).any(|c| u32::from(c) > 0xff);- out.push_str(&format!(" {prefix}:{}=\"{}\"", a.name, xml_attr_escape(&a.value)));- }- }- /// The prefix namespace `ns` is written under: `wanted` (the file's), else `wanted2`,- /// `wanted3`… when the export's own prefixes or another namespace already have it. XML keeps- /// prefixes starting with `xml` for itself: those become `ns`, `ns2`…- fn foreign_prefix(&mut self, ns: &str, wanted: &str) -> String {- if let Some(p) = self.foreign_ns.get(ns) {- return p.clone();- }- const OURS: [&str; 5] = ["svg", "xlink", "rdf", "dc", "vectorcraft"];- let base = if wanted.to_ascii_lowercase().starts_with("xml") { "ns" } else { wanted };- let taken = |p: &str| OURS.contains(&p) || self.foreign_ns.values().any(|q| q == p);- let mut prefix = base.to_string();- let mut k = 2;- while taken(&prefix) {- prefix = format!("{base}{k}");- k += 1;- }- self.foreign_ns.insert(ns.to_string(), prefix.clone());- prefix- }- /// Window › SVG Interactivity: `n`'s events as event attributes (`onclick="…"`), added to- /// `out`. The SVG Tiny 1.2 profile leaves them out with a warning.- fn event_attrs(&mut self, n: &Node, out: &mut String) {- let events = n.extras().attrs.as_deref().map_or(&[][..], |a| a.events.as_slice());- if events.is_empty() {- return;- }- if self.tiny() {- self.warn("SVG Tiny 1.2 has no event attributes: SVG Interactivity events were left out");- return;- }- let mut seen = HashSet::new();- for (event, script) in events {- // Native data can name anything: only the panel's events are written, once each.- if !SVG_EVENTS.contains(&event.as_str()) || !valid_xml_value(script) {- self.warn("SVG Interactivity events with unknown names or invalid XML characters were left out of SVG");- continue;- }- if !seen.insert(event.as_str()) {- self.warn("Repeated SVG Interactivity events were written only once in SVG");- continue;- }- out.push_str(&format!(" {event}=\"{}\"", xml_attr_escape(script)));- }- }- fn matrix(&self, m: Affine) -> String {- let c = m.as_coeffs();- format!("matrix({} {} {} {} {} {})", self.num(c[0]), self.num(c[1]), self.num(c[2]), self.num(c[3]), self.num(c[4]), self.num(c[5]))- }-- /// Style properties as attributes, an inline style, or a CSS class, per the styling option.- fn attrs(&mut self, props: &Props) -> String {- if props.is_empty() {- return String::new();- }- // SVG Tiny has presentation attributes alone.- let styling = if self.tiny() { Styling::PresentationAttributes } else { self.opts.styling };- match styling {- Styling::PresentationAttributes => {- // CSS-only properties go in a style attribute (SVG Tiny has none: left out).- let (style, attrs): (Vec<_>, Vec<_>) = props.iter().partition(|(k, _)| {- matches!(*k, "mix-blend-mode" | "isolation" | "font-feature-settings" | "font-variation-settings" | "font-kerning")- });- let mut s: String = attrs.iter().map(|(k, v)| format!(" {k}=\"{}\"", xml_escape(v))).collect();- if !style.is_empty() {- if self.tiny() {- self.warn("SVG Tiny 1.2 has no style sheets: blend modes, isolation, font features and font variation settings are left out");- } else {- s.push_str(&format!(" style=\"{}\"", xml_escape(&css::declarations(style))));- }- }- s- }- Styling::InlineStyle => format!(" style=\"{}\"", xml_escape(&css::declarations(props))),- Styling::StyleEntities => format!(" style=\"&st{};\"", self.class(css::declarations(props))),- Styling::InternalCss => {- let i = self.class(css::declarations(props));- format!(" class=\"{}cls-{i}\"", self.id_prefix)- }- }- }-- /// The 1-based number of a distinct declaration block (a CSS class or a style entity).- fn class(&mut self, decl: String) -> usize {- if let Some(&i) = self.class_ids.get(decl.as_str()) {- return i;- }- let i = self.classes.len() + 1;- self.class_ids.insert(decl.clone(), i);- self.classes.push(decl);- i- }-- /// `<metadata>`: the Dublin Core terms of File Info ([`ExportOptions::metadata`]) and the- /// native document ([`ExportOptions::preserve_editing`]) with the [`body_hash`] of the markup- /// around this element.- fn metadata(&self, out: &mut String, native: Option<(&[u8], String)>) {- if !self.opts.metadata && native.is_none() {- return;- }- let nl = if self.opts.minify { "" } else { "\n" };- let mut line = |depth: usize, s: &str| {- out.push_str(&self.indent(depth));- out.push_str(s);- out.push_str(nl);- };- line(1, "<metadata>");- if self.opts.metadata {- line(2, "<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">");- line(3, "<rdf:Description rdf:about=\"\">");- for (term, value) in dublin_core(self.doc) {- line(4, &format!("<dc:{term}>{}</dc:{term}>", xml_escape(&value)));- }- line(3, "</rdf:Description>");- line(2, "</rdf:RDF>");- }- if let Some((bytes, hash)) = native {- line(- 2,- &format!(- "<vectorcraft:document xmlns:vectorcraft=\"{EDITING_NS}\" hash=\"{hash}\"><![CDATA[{}]]></vectorcraft:document>",- base64_encode(bytes)- ),- );- }- line(1, "</metadata>");- }-- fn path_d(&self, p: &PathData, m: Affine) -> String {- let mut s = String::new();- // Each point as "x y", appended in place (no string per number or per point).- let dec = self.opts.decimals;- let pt = |s: &mut String, p: Point| {- let p = m * p;- crate::push_num(s, p.x, dec);- s.push(' ');- crate::push_num(s, p.y, dec);- };- for sp in &p.subpaths {- let n = sp.anchors.len();- if n == 0 {- continue;- }- if !s.is_empty() {- s.push(' ');- }- s.push('M');- pt(&mut s, sp.anchors[0].p);- for i in 0..sp.segment_count() {- let (a, b) = (&sp.anchors[i], &sp.anchors[(i + 1) % n]);- if sp.segment_is_line(i) {- if sp.closed && i == n - 1 {- break;- }- s.push_str(" L");- pt(&mut s, b.p);- } else {- s.push_str(" C");- pt(&mut s, a.h_out);- s.push(' ');- pt(&mut s, b.h_in);- s.push(' ');- pt(&mut s, b.p);- }- }- if sp.closed {- s.push_str(" Z");- }- }- s- }-- /// A fill or stroke value. Gradients resolve unset geometry against `bounds` (the space- /// [`Self::xf`] maps into user space, as the renderer does).- fn paint(&mut self, p: &Paint, bounds: Option<Rect>) -> String {- match p {- Paint::None => "none".into(),- Paint::Pattern { pattern, xf } => match self.pattern_def(pattern, *xf) {- Some(id) => format!("url(#{id})"),- None => "none".into(),- },- Paint::Solid { color, .. } => color.to_hex(),- Paint::Gradient(g) => format!("url(#{})", self.gradient_def(g, bounds.unwrap_or(Rect::new(0.0, 0.0, 1.0, 1.0)))),- }- }-- /// A `<pattern>` def for pattern `name` placed by `xf`: one period (super-tile) of the tiling,- /// with every instance that reaches into it.- fn pattern_def(&mut self, name: &str, xf: Affine) -> Option<String> {- let doc = self.doc;- let def = doc.pattern(name)?;- let m = self.xf * xf;- let key = format!("{name}|{:?}", m.as_coeffs());- if let Some(id) = self.patterns.get(&key) {- return Some(id.clone());- }- if self.pattern_nest > 4 {- return None;- }- let id = self.fresh_id("pattern");- self.patterns.insert(key, id.clone());- let (pw, ph) = def.period();- let (saved_body, saved_xf, saved_depth) = (std::mem::take(&mut self.body), self.xf, self.depth);- self.depth = 3;- self.pattern_nest += 1;- for o in def.offsets_covering(Rect::new(0.0, 0.0, pw, ph)) {- self.xf = def.instance_xf(o);- for a in &def.art {- self.node(a);- }- }- self.pattern_nest -= 1;- let content = std::mem::replace(&mut self.body, saved_body);- self.xf = saved_xf;- self.depth = saved_depth;- let head = format!(- "<pattern id=\"{id}\" patternUnits=\"userSpaceOnUse\" width=\"{}\" height=\"{}\" patternTransform=\"{}\">",- self.num(pw),- self.num(ph),- self.matrix(m)- );- self.def(1, &head);- self.defs.push_str(&content);- self.def(1, "</pattern>");- Some(id)- }-- /// The id of a `<linearGradient>`/`<radialGradient>` def for `g` resolved against `bounds`.- /// Identical gradients share one def; a gradient from a swatch takes the swatch's name as its- /// id. A midpoint other than halfway is written as an extra stop marked `data-vc-midpoint`- /// (what import turns back into a midpoint).- fn gradient_def(&mut self, g: &GradientPaint, bounds: Rect) -> String {- if g.gradient.kind == GradientKind::Freeform {- // Object fills and strokes are images (see `raster_paint`); characters' paints aren't.- self.warn("freeform gradients on characters are written as linear gradients");- }- let mut geom = g.resolve(bounds);- geom.transform(self.xf, g.gradient.kind);- let (s, e) = (geom.start, geom.end);- // An off-centre focal point: `fx`/`fy`, in the gradient's own (unsquashed) space.- let focal = |w: &Self, f: Point| format!(" fx=\"{}\" fy=\"{}\"", w.num(f.x), w.num(f.y));- let (tag, prefix, attrs) = match g.gradient.kind {- GradientKind::Radial => {- let r = self.num((e - s).hypot());- let attrs = if (geom.aspect - 1.0).abs() < 1e-9 {- let f = geom.focal.map(|f| focal(self, f)).unwrap_or_default();- format!(" cx=\"{}\" cy=\"{}\" r=\"{r}\"{f}", self.num(s.x), self.num(s.y))- } else {- let v = e - s;- let m = Affine::translate(s.to_vec2()) * Affine::rotate(v.y.atan2(v.x)) * Affine::scale_non_uniform(1.0, geom.aspect);- let f = geom.focal.map(|f| focal(self, m.inverse() * f)).unwrap_or_default();- format!(" cx=\"0\" cy=\"0\" r=\"{r}\"{f} gradientTransform=\"{}\"", self.matrix(m))- };- ("radialGradient", "radial-gradient", attrs)- }- GradientKind::Linear | GradientKind::Freeform => (- "linearGradient",- "linear-gradient",- format!(" x1=\"{}\" y1=\"{}\" x2=\"{}\" y2=\"{}\"", self.num(s.x), self.num(s.y), self.num(e.x), self.num(e.y)),- ),- };- let stops: Vec<String> = g- .gradient- .expanded()- .map(|(offset, c, o, mid)| {- let op = if o < 1.0 { format!(" stop-opacity=\"{}\"", fmt_num(o as f64, 3)) } else { String::new() };- let mid = mid.map(|m| format!(" data-vc-midpoint=\"{}\"", fmt_num(m as f64, 4))).unwrap_or_default();- format!("<stop offset=\"{}\" stop-color=\"{}\"{op}{mid}/>", fmt_num(offset as f64, 4), c.to_hex())- })- .collect();- let key = format!("{tag}{attrs}{}", stops.concat());- if let Some(id) = self.gradients.get(&key) {- return id.clone();- }- let id = match &g.swatch {- Some(name) => self.unique_id(&sanitize_id(name)),- None => self.fresh_id(prefix),- };- self.gradients.insert(key, id.clone());- self.def(1, &format!("<{tag} id=\"{id}\"{attrs} gradientUnits=\"userSpaceOnUse\">"));- for stop in &stops {- self.def(2, stop);- }- self.def(1, &format!("</{tag}>"));- id- }-- fn fill_props(&mut self, f: &FillLayer, rule: FillRule, bounds: Option<Rect>, p: &mut Props) {- let paint = self.paint(&f.paint, bounds);- p.push(("fill", paint));- if f.opacity < 1.0 {- p.push(("fill-opacity", fmt_num(f.opacity as f64, 3)));- }- if rule == FillRule::EvenOdd {- p.push(("fill-rule", "evenodd".into()));- }- }-- fn stroke_props(&mut self, s: &StrokeLayer, width: f64, bounds: Option<Rect>, p: &mut Props) {- let paint = self.paint(&s.paint, bounds);- p.push(("stroke", paint));- if s.opacity < 1.0 {- p.push(("stroke-opacity", fmt_num(s.opacity as f64, 3)));- }- if (width - 1.0).abs() > 1e-9 {- p.push(("stroke-width", self.num(width)));- }- match s.cap {- LineCap::Butt => {}- LineCap::Round => p.push(("stroke-linecap", "round".into())),- LineCap::Square => p.push(("stroke-linecap", "square".into())),- }- match s.join {- LineJoin::Miter => {- if (s.miter_limit - 4.0).abs() > 1e-9 {- p.push(("stroke-miterlimit", self.num(s.miter_limit)));- }- }- LineJoin::Round => p.push(("stroke-linejoin", "round".into())),- LineJoin::Bevel => p.push(("stroke-linejoin", "bevel".into())),- }- if let Some(d) = &s.dash- && d.is_dashed()- {- p.push(("stroke-dasharray", d.pattern.iter().map(|v| self.num(*v)).collect::<Vec<_>>().join(" ")));- if d.offset != 0.0 {- p.push(("stroke-dashoffset", self.num(d.offset)));- }- }- }-- /// How stroke `st` is written (`bp`: the shape in document space, built on first use from- /// `paths`): its brush art, or a plain stroke or filled outlines matching the canvas.- fn stroke_plan(&mut self, st: &StrokeLayer, bp: &mut Option<BezPath>, paths: &[&PathData]) -> StrokePlan {- if stroke::is_plain(st) {- return StrokePlan::Written(stroke::for_writer(&BezPath::new(), st));- }- let bp = bp.get_or_insert_with(|| doc_path(paths));- let doc = self.doc;- let brushes = self.brushes.get_or_insert_with(|| vectorcraft_brush::library(doc));- match st.brush.as_deref().and_then(|name| brushes.iter().find(|b| b.name == name)) {- Some(b) => StrokePlan::Brush(vectorcraft_brush::stroke_pieces(doc, b, bp, st)),- None => StrokePlan::Written(stroke::for_writer(bp, st)),- }- }-- /// The `clip-path` (inside) or `mask` (outside) attribute that keeps an aligned stroke on its- /// side of the shape `d`; `reach` (document space) is what the stroke covers.- fn side_attr(&mut self, side: Option<StrokeAlign>, d: &str, rule: FillRule, reach: Rect) -> String {- match side {- None | Some(StrokeAlign::Center) => String::new(),- Some(StrokeAlign::Inside) => {- let cid = self.fresh_id("clip-path");- let r = if rule == FillRule::EvenOdd { " clip-rule=\"evenodd\"" } else { "" };- self.def(1, &format!("<clipPath id=\"{cid}\">"));- self.def(2, &format!("<path d=\"{d}\"{r}/>"));- self.def(1, "</clipPath>");- format!(" clip-path=\"url(#{cid})\"")- }- Some(StrokeAlign::Outside) if self.tiny() => {- // No masks: clipped by everything around the shape instead.- let cid = self.fresh_id("clip-path");- let b = self.xf.transform_rect_bbox(reach).inflate(1.0, 1.0);- let (x0, y0, x1, y1) = (self.num(b.x0), self.num(b.y0), self.num(b.x1), self.num(b.y1));- self.def(1, &format!("<clipPath id=\"{cid}\">"));- self.def(2, &format!("<path d=\"M{x0} {y0} H{x1} V{y1} H{x0} Z {d}\" clip-rule=\"evenodd\"/>"));- self.def(1, "</clipPath>");- format!(" clip-path=\"url(#{cid})\"")- }- Some(StrokeAlign::Outside) => {- let mid = self.fresh_id("mask");- let b = self.xf.transform_rect_bbox(reach).inflate(1.0, 1.0);- let (x, y, w, h) = (self.num(b.x0), self.num(b.y0), self.num(b.width()), self.num(b.height()));- let fr = if rule == FillRule::EvenOdd { " fill-rule=\"evenodd\"" } else { "" };- self.def(1, &format!("<mask id=\"{mid}\" {MASK} x=\"{x}\" y=\"{y}\" width=\"{w}\" height=\"{h}\">"));- self.def(2, &format!("<rect x=\"{x}\" y=\"{y}\" width=\"{w}\" height=\"{h}\" fill=\"#fff\"/>"));- self.def(2, &format!("<path d=\"{d}\" fill=\"#000\"{fr}/>"));- self.def(1, "</mask>");- format!(" mask=\"url(#{mid})\"")- }- }- }-- /// Paint a shape (`d`) with a node's appearance stack. `paths` is the same shape in document- /// space, for strokes that aren't plain (it may be empty when all are).- fn shape(&mut self, n: &Node, d: &str, paths: &[&PathData], rule: FillRule, bounds: Option<Rect>) {- let id = self.id_attr(n);- 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,- })- .collect();- let mut bp = None;- let plans: Vec<Option<StrokePlan>> = items- .iter()- .map(|i| match i {- AppearanceItem::Stroke(s) => Some(self.stroke_plan(s, &mut bp, paths)),- AppearanceItem::Fill(_) => None,- })- .collect();- let fills = items.iter().filter(|i| matches!(i, AppearanceItem::Fill(_))).count();- let strokes = items.len() - fills;- // A stroke's paint box is the bounds grown by half its weight, as on the canvas.- let paint_bounds = |s: &StrokeLayer| bounds.map(|b| s.paint_bounds(b));- let simple = fills <= 1- && strokes <= 1- && !items.iter().any(|i| has_raster(i.effects()))- && items.iter().all(|i| i.blend() == BlendMode::Normal)- && !items.iter().any(|i| pixel_gradient(i.paint(), matches!(i, AppearanceItem::Fill(_))).is_some())- && plans.iter().flatten().all(|p| matches!(p, StrokePlan::Written(Written { shape: WrittenShape::Stroke { .. }, side: None })));- if simple {- let mut p = Props::new();- match items.iter().find_map(|i| if let AppearanceItem::Fill(f) = i { Some(f) } else { None }) {- Some(f) => self.fill_props(f, rule, bounds, &mut p),- None => {- p.push(("fill", "none".into()));- if rule == FillRule::EvenOdd {- p.push(("fill-rule", "evenodd".into()));- }- }- }- if let Some(s) = items.iter().find_map(|i| if let AppearanceItem::Stroke(s) = i { Some(s) } else { None }) {- self.stroke_props(s, s.width, paint_bounds(s), &mut p);- if matches!(items.first(), Some(AppearanceItem::Stroke(_))) && fills == 1 {- p.push(("paint-order", "stroke".into()));- }- }- p.extend(css::transparency(n));- let a = self.attrs(&p);- self.line(&format!("<path{id} d=\"{d}\"{a}/>"));- return;- }- let a = self.attrs(&css::transparency(n));- self.line(&format!("<g{id}{a}>"));- self.depth += 1;- for (it, plan) in items.into_iter().zip(plans) {- // The item's own raster effects filter that item alone.- let filters = self.open_filters(n, it.effects());- let mut p = Props::new();- match (it, plan) {- (AppearanceItem::Fill(f), _) => {- let blend = (f.blend != BlendMode::Normal).then(|| ("mix-blend-mode", blend_css(f.blend).to_string()));- if let (Some(g), Some(b)) = (pixel_gradient(&f.paint, true), bounds) {- p.extend((f.opacity < 1.0).then(|| ("opacity", fmt_num(f.opacity as f64, 3))));- p.extend(blend);- self.raster_paint(g, b, &[d.to_string()], rule, &p, "", true);- } else {- self.fill_props(f, rule, bounds, &mut p);- p.extend(blend);- let a = self.attrs(&p);- self.line(&format!("<path d=\"{d}\"{a}/>"));- }- }- (AppearanceItem::Stroke(s), Some(StrokePlan::Brush(art))) => {- // The brush art takes the stroke's opacity and blend mode as a group.- if s.opacity < 1.0 {- p.push(("opacity", fmt_num(s.opacity as f64, 3)));- }- if s.blend != BlendMode::Normal {- p.push(("mix-blend-mode", blend_css(s.blend).into()));- }- let a = self.attrs(&p);- self.line(&format!("<g{a}>"));- self.depth += 1;- for piece in &art {- self.node(piece);- }- self.depth -= 1;- self.line("</g>");- }- (AppearanceItem::Stroke(s), Some(StrokePlan::Written(w))) => {- let side = self.side_attr(w.side, d, rule, w.reach(s, bounds.unwrap_or_default()));- let blend = (s.blend != BlendMode::Normal).then(|| ("mix-blend-mode", blend_css(s.blend).to_string()));- let opacity = (s.opacity < 1.0).then(|| ("opacity", fmt_num(s.opacity as f64, 3)));- match (&w.shape, pixel_gradient(&s.paint, false).zip(paint_bounds(s))) {- (WrittenShape::Stroke { width }, Some((g, b))) => {- // The stroke's outline clips the gradient's image.- let bp = bp.get_or_insert_with(|| doc_path(paths));- let outline = stroke::line_outline(bp, s, *width, OUTLINE_TOLERANCE);- let clip = self.path_d(&PathData::from_bezpath(&outline), self.xf);- p.extend(opacity);- p.extend(blend);- self.raster_paint(g, b, &[clip], FillRule::NonZero, &p, &side, false);- }- (WrittenShape::Fill(outlines), Some((g, b))) if s.path_gradient().is_none() => {- let clip: Vec<String> = outlines.iter().map(|o| self.path_d(&PathData::from_bezpath(o), self.xf)).collect();- p.extend(opacity);- p.extend(blend);- self.raster_paint(g, b, &clip, FillRule::NonZero, &p, &side, false);- }- (WrittenShape::Stroke { width }, _) => {- p.push(("fill", "none".into()));- self.stroke_props(s, *width, paint_bounds(s), &mut p);- p.extend(blend);- let a = self.attrs(&p);- self.line(&format!("<path d=\"{d}\"{a}{side}/>"));- }- (WrittenShape::Fill(outlines), _) if s.path_gradient().is_some() => {- // A gradient along or across the stroke: slices clipped to its outlines.- if let Some(ws) = bp.as_ref().and_then(|bp| stroke::written_slices(bp, rule, s, outlines)) {- p.extend(opacity);- p.extend(blend);- self.sliced(&ws, &p, &side);- }- }- (WrittenShape::Fill(outlines), _) => {- let paint = self.paint(&s.paint, paint_bounds(s));- let ds: Vec<String> = outlines.iter().map(|o| self.path_d(&PathData::from_bezpath(o), self.xf)).collect();- let opacity = (s.opacity < 1.0).then(|| fmt_num(s.opacity as f64, 3));- if let [one] = &ds[..] {- p.push(("fill", paint));- p.extend(opacity.map(|o| ("fill-opacity", o)));- p.extend(blend);- let a = self.attrs(&p);- self.line(&format!("<path d=\"{one}\"{a}{side}/>"));- } else if !ds.is_empty() {- // The line and its arrowheads overlap: one group takes the opacity.- p.extend(opacity.map(|o| ("opacity", o)));- p.extend(blend);- let a = self.attrs(&p);- self.line(&format!("<g{a}{side}>"));- self.depth += 1;- let fill = self.attrs(&vec![("fill", paint)]);- for one in &ds {- self.line(&format!("<path d=\"{one}\"{fill}/>"));- }- self.depth -= 1;- self.line("</g>");- }- }- }- }- (AppearanceItem::Stroke(_), None) => {}- }- self.close_filters(filters);- }- self.depth -= 1;- self.line("</g>");- }-- /// A stroke whose gradient runs along or across it ([`stroke::written_slices`]): a group (with- /// `props` and the `side` attribute) of its slices, clipped to its outlines.- fn sliced(&mut self, ws: &stroke::WrittenSlices, props: &Props, side: &str) {- self.warn("gradients along or across strokes are written as slices of linear gradients");- let cid = self.fresh_id("clip-path");- let clip = self.path_d(&PathData::from_bezpath(&ws.clip), self.xf);- self.def(1, &format!("<clipPath id=\"{cid}\">"));- self.def(2, &format!("<path d=\"{clip}\"/>"));- self.def(1, "</clipPath>");- let a = self.attrs(props);- self.line(&format!("<g{a}{side}>"));- self.depth += 1;- self.line(&format!("<g clip-path=\"url(#{cid})\">"));- self.depth += 1;- for (shape, paint) in &ws.slices {- let fill = self.paint(paint, None);- let fill = self.attrs(&vec![("fill", fill)]);- let d = self.path_d(&PathData::from_bezpath(shape), self.xf);- self.line(&format!("<path d=\"{d}\"{fill}/>"));- }- self.depth -= 1;- self.line("</g>");- self.depth -= 1;- self.line("</g>");- }-- fn warn(&mut self, w: &str) {- if !self.warnings.iter().any(|x| x == w) {- self.warnings.push(w.to_string());- }- }-- /// An object with an opacity mask: `<g mask="url(#…)">` around the unmasked object. The mask- /// art goes in `<defs>`; no-clip adds a white backdrop and invert a colour-inverting filter.- fn masked(&mut self, n: &Node, m: &vectorcraft_doc::OpacityMask) {- if self.tiny() {- self.warn(TINY_MASKS);- let mut bare = n.clone();- bare.extras_mut().mask = None;- return self.node_body(&bare);- }- let mid = self.fresh_id("mask");- // Mask art is a picture of its own: it takes no part in a knockout group around the object.- let knockout = std::mem::take(&mut self.knockout);- let art = self.detached(2, |w| w.node(&m.art));- self.knockout = knockout;- let inv = m.invert.then(|| {- let fid = self.fresh_id("invert");- self.def(1, &format!("<filter id=\"{fid}\" filterUnits=\"userSpaceOnUse\" color-interpolation-filters=\"sRGB\" {BIG}>"));- self.def(2, "<feColorMatrix type=\"matrix\" values=\"-1 0 0 0 1 0 -1 0 0 1 0 0 -1 0 1 0 0 0 1 0\"/>");- self.def(1, "</filter>");- fid- });- // The mask's options, so import restores them (and its art without backdrop and filter).- let flags: Vec<&str> = [(!m.clip).then_some("noclip"), m.invert.then_some("invert")].into_iter().flatten().collect();- let data = if flags.is_empty() { String::new() } else { format!(" {MASK_FLAGS}=\"{}\"", flags.join(" ")) };- self.def(1, &format!("<mask id=\"{mid}\" {MASK} {BIG}{data}>"));- if let Some(fid) = &inv {- self.def(1, &format!("<g filter=\"url(#{fid})\">"));- }- if !m.clip || m.invert {- let c = if m.clip { "black" } else { "white" };- self.def(1, &format!("<rect {BIG} fill=\"{c}\"/>"));- }- self.defs.push_str(&art);- if inv.is_some() {- self.def(1, "</g>");- }- self.def(1, "</mask>");- self.line(&format!("<g mask=\"url(#{mid})\">"));- self.depth += 1;- let mut bare = n.clone();- bare.extras_mut().mask = None;- self.node_body(&bare);- self.depth -= 1;- self.line("</g>");- }-- /// What `write` writes to the body, taken out of it (written at `depth`, for `<defs>`).- fn detached(&mut self, depth: usize, write: impl FnOnce(&mut Self)) -> String {- let (body, saved) = (std::mem::take(&mut self.body), self.depth);- self.depth = depth;- write(self);- self.depth = saved;- std::mem::replace(&mut self.body, body)- }-- /// Props of a group (or layer): a knockout group is isolated, a hidden one not displayed.- fn group_props(&self, n: &Node) -> Props {- let mut p = css::transparency(n);- if !n.isolate && n.knocks_out(self.knockout) {- p.push(("isolation", "isolate".into()));- }- p- }-- /// The children of group `n`, as the elements of a knockout group when it is one.- fn group_children(&mut self, n: &Node, children: &[std::sync::Arc<Node>]) {- let knockout = n.knocks_out(self.knockout);- let enclosing = std::mem::replace(&mut self.knockout, knockout);- self.children(children);- self.knockout = enclosing;- }-- /// Children of the group being written. SVG has no knockout groups: in one, each element is- /// drawn through a mask of where the elements above it don't paint (the same look for Normal- /// blending). The masks nest, so element i sits inside the masks of elements i+1…n.- fn children(&mut self, children: &[std::sync::Arc<Node>]) {- if self.knockout && self.tiny() {- self.warn(TINY_MASKS);- }- if !self.knockout || self.tiny() {- for c in children {- self.node(c);- }- return;- }- let elements = Node::knockout_elements(children);- // Where every element over another covers it fully, drawing them in order knocks out as- // much: the masks would only add seams along the shapes' antialiased edges.- if elements.iter().skip(1).all(|c| paints_opaque(c)) {- for c in elements {- self.node(c);- }- return;- }- let Some((first, rest)) = elements.split_first() else { return };- for c in rest.iter().rev() {- let mid = self.knockout_mask(c);- self.line(&format!("<g mask=\"url(#{mid})\">"));- self.depth += 1;- }- self.node(first);- for c in rest {- self.depth -= 1;- self.line("</g>");- self.node(c);- }- }-- /// A mask that is 1 − the knockout shape of `c`: white, then `c` painted black (at full object- /// opacity without its own mask, unless those define its shape). Returns the mask id.- fn knockout_mask(&mut self, c: &Node) -> String {- let filter = match &self.knockout_filter {- Some(f) => f.clone(),- None => {- let f = self.fresh_id("knockout-shape");- self.def(1, &format!("<filter id=\"{f}\" filterUnits=\"userSpaceOnUse\" {BIG}>"));- self.def(2, "<feColorMatrix type=\"matrix\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0\"/>");- self.def(1, "</filter>");- self.knockout_filter = Some(f.clone());- f- }- };- let shape = if c.knockout_shape {- c.clone()- } else {- let mut s = c.clone().with_mask(None);- s.opacity = 1.0;- s- };- let anonymous = std::mem::replace(&mut self.anonymous, true);- let art = self.detached(3, |w| w.node(&shape));- self.anonymous = anonymous;- let mid = self.fresh_id("knockout");- self.def(1, &format!("<mask id=\"{mid}\" {MASK} {BIG}>"));- self.def(2, &format!("<rect {BIG} fill=\"white\"/>"));- self.def(2, &format!("<g filter=\"url(#{filter})\">"));- self.defs.push_str(&art);- self.def(2, "</g>");- self.def(1, "</mask>");- mid- }-- /// An object, inside `<a>` when it links to a URL (Attributes panel).- fn node(&mut self, n: &Node) {- let layer = usize::from(n.is_layer());- self.layer_nest += layer;- match n.url().filter(|_| n.visible && !self.anonymous) {- Some(url) => {- self.line(&format!("<a xlink:href=\"{}\">", xml_escape(url)));- self.depth += 1;- self.node_body(n);- self.depth -= 1;- self.line("</a>");- }- None => self.node_body(n),- }- self.layer_nest -= layer;- }-- fn node_body(&mut self, n: &Node) {- // Hidden layers and objects are left out, unless the options keep them (hidden). Template- // layers never print.- if !(n.visible || self.opts.hidden_layers) {- return;- }- if has_raster(&n.appearance.effects) {- return self.filtered(n);- }- if let Some(m) = n.extras().mask.as_deref()- && !m.disabled- {- return self.masked(n, m);- }- match &n.kind {- NodeKind::Layer { template: true, .. } => {}- NodeKind::Layer { children, clip: false, .. } | NodeKind::Group { children, clip: false } => {- let id = self.id_attr(n);- let a = self.attrs(&self.group_props(n));- self.line(&format!("<g{id}{a}>"));- self.depth += 1;- self.group_children(n, children);- self.depth -= 1;- self.line("</g>");- }- NodeKind::Group { children, clip: true } | NodeKind::Layer { children, clip: true, .. } => {- let Some((clip, rest)) = children.split_first() else { return };- let cid = self.fresh_id("clip-path");- self.def(1, &format!("<clipPath id=\"{cid}\">"));- // The region every output clips to; with nothing to clip by, an empty clip path- // hides the clipped art.- if let Some((bp, rule)) = vectorcraft_effects::clip_outline(clip) {- let d = self.path_d(&PathData::from_bezpath(&bp), self.xf);- let r = if rule == FillRule::EvenOdd { " clip-rule=\"evenodd\"" } else { "" };- self.def(2, &format!("<path d=\"{d}\"{r}/>"));- }- self.def(1, "</clipPath>");- let id = self.id_attr(n);- let a = self.attrs(&self.group_props(n));- // The clipping path's fill paints behind the clipped art and its stroke over it,- // outside the clip (the group then wraps both).- let paint = clip.clip_paint();- if paint.stroke.is_some() {- self.line(&format!("<g{id}{a}>"));- self.depth += 1;- self.line(&format!("<g clip-path=\"url(#{cid})\">"));- } else {- self.line(&format!("<g{id} clip-path=\"url(#{cid})\"{a}>"));- }- self.depth += 1;- if let Some(fill) = &paint.fill {- self.node(fill);- }- self.group_children(n, rest);- self.depth -= 1;- self.line("</g>");- if let Some(stroke) = &paint.stroke {- // One element keeps the clipping path's id.- let anonymous = self.anonymous;- self.anonymous |= paint.fill.is_some();- self.node(stroke);- self.anonymous = anonymous;- self.depth -= 1;- self.line("</g>");- }- }- NodeKind::Path { guide: true, .. } => {}- NodeKind::Path { path, rule, .. } => {- if path.is_empty() {- return;- }- let d = self.path_d(path, self.xf);- self.shape(n, &d, &[path], *rule, n.geometric_bounds());- }- NodeKind::Compound { children, rule } => {- let paths: Vec<&PathData> = children.iter().filter(|c| c.visible).filter_map(|c| c.path_data()).filter(|p| !p.is_empty()).collect();- if paths.is_empty() {- return;- }- let d: Vec<String> = paths.iter().map(|p| self.path_d(p, self.xf)).collect();- self.shape(n, &d.join(" "), &paths, *rule, n.geometric_bounds());- }- NodeKind::Text(t) => self.text_node(n, t),- NodeKind::Image(im) => {- let id = self.id_attr(n);- let m = self.matrix(self.xf * im.xf);- let a = self.attrs(&css::transparency(n));- if let Some(shared) = self.shared_images.get(&(im.key.clone(), im.width, im.height)) {- let shared = shared.clone();- self.line(&format!("<use{id} transform=\"{m}\"{a} xlink:href=\"#{shared}\"/>"));- return;- }- let Some(href) = self.image_href(im) else { return };- self.line(&format!(- "<image{id} width=\"{}\" height=\"{}\" transform=\"{m}\" preserveAspectRatio=\"none\"{a} xlink:href=\"{}\"/>",- im.width,- im.height,- xml_escape(&href)- ));- }- NodeKind::SymbolInstance { symbol, xf } => {- let doc = self.doc;- let Some(sym) = doc.symbols.iter().find(|s| s.name == *symbol) else { return };- if self.symbol_nest > MAX_SYMBOL_NEST {- return;- }- let id = self.id_attr(n);- let a = self.attrs(&css::transparency(n));- if let Some(def) = self.symbol_use(sym, n, *xf) {- let m = self.xf * *xf;- let tr = if m == Affine::IDENTITY { String::new() } else { format!(" transform=\"{}\"", self.matrix(m)) };- self.line(&format!("<use{id} xlink:href=\"#{def}\"{tr}{a}/>"));- return;- }- // An instance of its own: the (stained) art moved by the instance, its pattern- // paints and unlinked masks left in place as on the canvas.- let mut art = vectorcraft_brush::instance_art(&sym.art, n);- let moved = self.instance_xf * *xf;- if moved.determinant().abs() > 1e-12 {- pin_to_page(&mut art, moved.inverse());- }- let saved = (self.xf, self.instance_xf);- self.xf = saved.0 * *xf;- self.instance_xf = moved;- self.line(&format!("<g{id}{a}>"));- self.depth += 1;- // The symbol's art is the instance's own picture, outside any knockout around it.- let knockout = std::mem::take(&mut self.knockout);- self.symbol_nest += 1;- self.node(&art);- self.symbol_nest -= 1;- self.knockout = knockout;- self.depth -= 1;- self.line("</g>");- (self.xf, self.instance_xf) = saved;- }- // Live blends/envelopes/meshes export their evaluated (expanded) form.- NodeKind::Blend { .. }- | NodeKind::Envelope { .. }- | NodeKind::Mesh(_)- | NodeKind::Repeat(_)- | NodeKind::PlacedDocument(_)- | NodeKind::Intertwine { .. } => {- let g = vectorcraft_effects::expand_live_deep(Some(self.doc), n);- self.share_images(&g);- self.node_body(&g);- }- }- }-- /// The `href` of image bytes `b`: a `data:` URI, or with [`ImageMode::Link`] a file written- /// next to the SVG, named after the bytes (image keys such as "raster-1" repeat across- /// documents).- fn blob_href(&mut self, b: &ImageBlob) -> String {- if self.opts.images != ImageMode::Link {- return format!("data:{};base64,{}", b.mime, base64_encode(&b.bytes));- }- let name = format!("{}.{}", b.content_key(), image_ext(&b.mime));- if self.linked_names.insert(name.clone()) {- self.linked.push(LinkedImage { name: name.clone(), bytes: b.bytes.clone() });- }- name- }-- /// A gradient `g` painted over `bounds` (the space [`Self::xf`] maps into user space) that is- /// drawn as pixels ([`GradientPaint::draws_as_pixels`]) when it paints a fill (`fill`) or a- /// stroke: an `<image>` over its painted box, clipped to `clip` (outlines in user space filled- /// by `rule`), in a group with `props` and the `side` attribute. A freeform gradient's colour- /// field, which SVG can't express, is sampled as the canvas samples it (at twice the box's size- /// in points); a linear or radial gradient at the document's raster effects resolution (at most- /// [`MAX_GRADIENT_PX`] a side), with dither's noise on a fill. Nothing is written for an empty- /// box.- #[allow(clippy::too_many_arguments)]- fn raster_paint(&mut self, g: &GradientPaint, bounds: Rect, clip: &[String], rule: FillRule, props: &Props, side: &str, fill: bool) {- use vectorcraft_color::freeform::{grid_size, painted_box, spread_scale};- let Some(b) = painted_box(bounds) else { return };- let freeform = g.gradient.kind == GradientKind::Freeform;- let (rgba, cols, rows): (Vec<u8>, u16, u16) = if freeform {- let (cols, rows) = grid_size(b, 2.0 * b.width().max(b.height()));- let field = g.freeform_on(b).field(spread_scale(b));- let q = |v: f32| (v.clamp(0.0, 1.0) * 255.0).round() as u8;- (field.grid(b, cols, rows).flat_map(|([r, g, bl], a)| [q(r), q(g), q(bl), q(a)]).collect(), cols, rows)- } else {- let k = self.doc.raster_effects_ppi / 72.0;- let along = |len: f64| (len * k).ceil().clamp(1.0, MAX_GRADIENT_PX) as u16;- let (cols, rows) = (along(b.width()), along(b.height()));- (g.pixels(b, b, cols, rows, fill, &Color::to_rgb).flatten().collect(), cols, rows)- };- let mut png = Vec::new();- let Some(img) = image::RgbaImage::from_raw(u32::from(cols), u32::from(rows), rgba) else { return };- if img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).is_err() {- return;- }- self.warn(if freeform {- "freeform gradients are written as images clipped to their shapes"- } else {- "linear and radial gradients drawn as pixels are written as images clipped to their shapes"- });- let href = self.blob_href(&ImageBlob::new("image/png", png));- let cid = self.fresh_id("clip-path");- let r = if rule == FillRule::EvenOdd { " clip-rule=\"evenodd\"" } else { "" };- self.def(1, &format!("<clipPath id=\"{cid}\">"));- for d in clip {- self.def(2, &format!("<path d=\"{d}\"{r}/>"));- }- self.def(1, "</clipPath>");- let a = self.attrs(props);- let nested = !side.is_empty();- if nested {- self.line(&format!("<g{a}{side}>"));- self.depth += 1;- self.line(&format!("<g clip-path=\"url(#{cid})\">"));- } else {- self.line(&format!("<g clip-path=\"url(#{cid})\"{a}>"));- }- self.depth += 1;- let (x, y, w, h) = (self.num(b.x0), self.num(b.y0), self.num(b.width()), self.num(b.height()));- let tr = if self.xf == Affine::IDENTITY { String::new() } else { format!(" transform=\"{}\"", self.matrix(self.xf)) };- self.line(&format!(- "<image x=\"{x}\" y=\"{y}\" width=\"{w}\" height=\"{h}\"{tr} preserveAspectRatio=\"none\" xlink:href=\"{}\"/>",- xml_escape(&href)- ));- self.depth -= 1;- self.line("</g>");- if nested {- self.depth -= 1;- self.line("</g>");- }- }-- /// The id of the `<symbol>` def instance `inst` (transform `xf`) can `<use>`, written on first- /// use. `None` when the instance needs its own copy of the art: stained by its fill, or moved- /// by a transform under which the def would not look as the canvas paints it ([`Reuse`]).- fn symbol_use(&mut self, sym: &vectorcraft_doc::Symbol, inst: &Node, xf: Affine) -> Option<String> {- // SVG Tiny has no `<symbol>`.- if self.tiny() || vectorcraft_brush::stain(inst).is_some() {- return None;- }- if !self.symbols.contains_key(&sym.name) {- let reuse = Reuse::of(self.doc, &sym.art);- self.symbols.insert(sym.name.clone(), SymbolDef { id: None, reuse });- }- let def = self.symbols.get(&sym.name)?;- if !def.reuse.allows(xf) {- return None;- }- if let Some(id) = &def.id {- return Some(id.clone());- }- // The art in symbol space, as its own picture: no knockout around it, and no object ids- // (every instance shows it).- let id = self.unique_id(&sanitize_id(&sym.name));- let saved = (self.xf, self.instance_xf, std::mem::take(&mut self.knockout), std::mem::take(&mut self.names), self.anonymous);- (self.xf, self.instance_xf, self.anonymous) = (Affine::IDENTITY, Affine::IDENTITY, false);- self.symbol_nest += 1;- let art = self.detached(3, |w| w.node(&sym.art));- self.symbol_nest -= 1;- (self.xf, self.instance_xf, self.knockout, self.names, self.anonymous) = saved;- // The symbol's name, when the id had to differ from it, comes back on import.- let name = if id == sym.name {- String::new()- } else if valid_xml_value(&sym.name) {- format!(" data-name=\"{}\"", xml_attr_escape(&sym.name))- } else {- self.warn("Symbol names containing invalid XML characters were left out of SVG name attributes");- String::new()- };- self.def(1, &format!("<symbol id=\"{id}\"{name} overflow=\"visible\">"));- self.defs.push_str(&art);- self.def(1, "</symbol>");- if let Some(def) = self.symbols.get_mut(&sym.name) {- def.id = Some(id.clone());- }- Some(id)- }-- /// Raster effects (drop shadow, glows, Gaussian blur, feather) as SVG filters: one `<g filter>`- /// per effect, the first effect innermost (the reference app's stacking order). A drop shadow- /// with Darkness darkens the screen colors, in a CMYK document too. Photoshop-style- /// filters have no SVG equivalent: they are left out with a warning (exports from the app turn- /// such objects into images first).- fn filtered(&mut self, n: &Node) {- let mut inner = n.clone();- inner.appearance.effects.retain(|e| !vectorcraft_effects::is_raster(&e.id));- let opened = self.open_filters(n, &n.appearance.effects);- self.node_body(&inner);- self.close_filters(opened);- }-- /// Open one `<g filter>` per visible raster effect of `effects` (an object's, or one fill or- /// stroke's) on `n`, outermost last effect; returns how many to close.- fn open_filters(&mut self, n: &Node, effects: &[vectorcraft_doc::Effect]) -> usize {- use vectorcraft_effects::RasterFx;- let fx = vectorcraft_effects::raster_effects(effects);- if self.tiny() {- if !fx.is_empty() {- self.warn("SVG Tiny 1.2 has no filters: shadows, glows, blurs and feathers are left out");- }- return 0;- }- let bounds = n.visual_bounds_with(&self.doc.symbol_boxes());- // An Outer Glow's silhouette grows by a quarter of a pixel of the document's raster grid first.- let grow = 18.0 / self.doc.raster_ppi();- let reach: f64 =- fx.iter().map(|f| f.outset(bounds.unwrap_or_default()) + if matches!(f, RasterFx::OuterGlow { .. }) { grow } else { 0.0 }).sum::<f64>()- + 2.0;- let region = bounds.map(|b| self.xf.transform_rect_bbox(b).inflate(reach, reach));- let mut opened = 0;- for f in fx.iter().rev() {- if matches!(f, RasterFx::Pixel(_) | RasterFx::Rasterize(_)) {- self.warn("SVG has no pixel effects such as Radial Blur, Smart Blur or Unsharp Mask: they are left out");- continue;- }- let fid = self.fresh_id("filter");- let region_attr = match region {- Some(r) => format!(- " filterUnits=\"userSpaceOnUse\" x=\"{}\" y=\"{}\" width=\"{}\" height=\"{}\"",- self.num(r.x0),- self.num(r.y0),- self.num(r.width()),- self.num(r.height())- ),- None => String::new(),- };- let sd = |blur: f64| fmt_num((blur / 2.0).max(0.0), 3);- let flood = |c: &vectorcraft_color::Color, o: f32| {- format!("<feFlood flood-color=\"{}\" flood-opacity=\"{}\"/>", c.to_hex(), fmt_num(o as f64, 3))- };- let body = match f {- // Darkness: the object blurred and moved, each color channel times 1 − darkness.- RasterFx::DropShadow { opacity, dx, dy, blur, darkness: Some(darkness), .. } => format!(- "<feGaussianBlur in=\"SourceGraphic\" stdDeviation=\"{}\"/><feOffset dx=\"{}\" dy=\"{}\"/><feComponentTransfer result=\"paint\"><feFuncR type=\"linear\" slope=\"{keep}\"/><feFuncG type=\"linear\" slope=\"{keep}\"/><feFuncB type=\"linear\" slope=\"{keep}\"/><feFuncA type=\"linear\" slope=\"{}\"/></feComponentTransfer><feMerge><feMergeNode in=\"paint\"/><feMergeNode in=\"SourceGraphic\"/></feMerge>",- sd(*blur),- self.num(*dx),- self.num(*dy),- fmt_num(*opacity as f64, 3),- keep = fmt_num(1.0 - *darkness as f64, 3)- ),- RasterFx::DropShadow { opacity, dx, dy, blur, color, .. } => format!(- "<feGaussianBlur in=\"SourceAlpha\" stdDeviation=\"{}\"/><feOffset dx=\"{}\" dy=\"{}\" result=\"shadow\"/>{}<feComposite in2=\"shadow\" operator=\"in\" result=\"paint\"/><feMerge><feMergeNode in=\"paint\"/><feMergeNode in=\"SourceGraphic\"/></feMerge>",- sd(*blur),- self.num(*dx),- self.num(*dy),- flood(color, *opacity)- ),- // The glow blurs a solid silhouette (alpha × 255 makes any alpha full) grown by a quarter raster pixel.- RasterFx::OuterGlow { opacity, blur, color, .. } => format!(- "<feComponentTransfer in=\"SourceAlpha\"><feFuncA type=\"linear\" slope=\"255\"/></feComponentTransfer><feMorphology operator=\"dilate\" radius=\"{}\"/><feGaussianBlur stdDeviation=\"{}\" result=\"glow\"/>{}<feComposite in2=\"glow\" operator=\"in\" result=\"paint\"/><feMerge><feMergeNode in=\"paint\"/><feMergeNode in=\"SourceGraphic\"/></feMerge>",- fmt_num(grow, 3),- sd(*blur),- flood(color, *opacity)- ),- RasterFx::InnerGlow { opacity, blur, color, center, .. } => {- // Edge: the blurred inverse silhouette; Center: the blurred silhouette; both clipped to the shape.- let src = if *center {- "<feGaussianBlur in=\"SourceAlpha\" stdDeviation=\"SD\" result=\"glow\"/>".replace("SD", &sd(*blur))- } else {- format!(- "<feComponentTransfer in=\"SourceAlpha\"><feFuncA type=\"table\" tableValues=\"1 0\"/></feComponentTransfer><feGaussianBlur stdDeviation=\"{}\" result=\"glow\"/>",- sd(*blur)- )- };- format!(- "{src}{}<feComposite in2=\"glow\" operator=\"in\"/><feComposite in2=\"SourceAlpha\" operator=\"in\" result=\"paint\"/><feMerge><feMergeNode in=\"SourceGraphic\"/><feMergeNode in=\"paint\"/></feMerge>",- flood(color, *opacity)- )- }- RasterFx::Feather { radius } => format!(- "<feGaussianBlur in=\"SourceAlpha\" stdDeviation=\"{}\" result=\"soft\"/><feComposite in=\"SourceGraphic\" in2=\"soft\" operator=\"in\" result=\"f\"/><feComposite in=\"f\" in2=\"SourceAlpha\" operator=\"in\"/>",- sd(*radius)- ),- RasterFx::GaussianBlur { radius } => format!("<feGaussianBlur in=\"SourceGraphic\" stdDeviation=\"{}\"/>", sd(*radius)),- RasterFx::Pixel(_) | RasterFx::Rasterize(_) => continue,- };- // Filters composite normally: a shadow's or glow's other blend mode is recorded for import.- let mode = match f {- RasterFx::DropShadow { mode, .. } | RasterFx::OuterGlow { mode, .. } | RasterFx::InnerGlow { mode, .. }- if *mode != BlendMode::Normal =>- {- format!(" {}=\"{}\"", crate::import::BLEND, blend_css(*mode))- }- _ => String::new(),- };- self.def(1, &format!("<filter id=\"{fid}\"{region_attr}{mode} color-interpolation-filters=\"sRGB\">{body}</filter>"));- self.line(&format!("<g filter=\"url(#{fid})\">"));- self.depth += 1;- opened += 1;- }- opened- }-- fn close_filters(&mut self, opened: usize) {- for _ in 0..opened {- self.depth -= 1;- self.line("</g>");- }- }-- /// The `<text>`/`<tspan>` properties of a character style. `space`: the text's layout bounds- /// and the map from text space to user space, which character gradients resolve against- /// (as on the canvas).- fn char_props(&mut self, st: &CharStyle, space: (Rect, Affine)) -> Props {- let decimals = self.opts.decimals;- let len = |v: f64| fmt_num(v, decimals);- let mut p = css::font_props(st, &len);- // Character paints resolve in the text's space (`to_user` maps it into user space).- let (bounds, to_user) = space;- let saved = std::mem::replace(&mut self.xf, to_user);- if let Paint::Gradient(g) = &st.fill- && g.gradient.dither- && g.gradient.kind != GradientKind::Freeform- {- self.warn("dithered gradients on characters are written without dither");- }- let fill = self.paint(&st.fill, Some(bounds));- p.push(("fill", fill));- // An inside or outside stroke is drawn on the glyph outlines instead- // ([`Self::aligned_char_strokes`]): SVG strokes text centred only.- if st.has_stroke() && !aligned(st) {- // Weight, cap, join, miter limit and dashes as for object strokes; a gradient spans- // the text grown by half the weight, as on the canvas.- let layer = st.stroke_layer();- self.stroke_props(&layer, layer.width, Some(layer.paint_bounds(bounds)), &mut p);- }- self.xf = saved;- p.extend(css::type_props(st, &len));- p- }-- /// Type: its characters (live text, or glyph outlines when text is exported as outlines) and,- /// as the canvas paints them, the object's own fills and strokes on the glyph outlines: those- /// below the Characters row under the characters, the others over them.- ///- /// Inline graphics ([`vectorcraft_doc::TextRun::inline`]) are written after the characters as- /// instances of their symbols (a `<use>` of the symbol's def where it can be shared), all in- /// one group carrying the object's transparency. The live text skips their characters and- /// places the text after each one; type on a path with inline graphics is written as outlines- /// (a `<textPath>` couldn't leave room for the art).- fn text_node(&mut self, n: &Node, t: &TextObject) {- let doc = self.doc;- let resolved = doc.inline_resolved(t);- let t = &*resolved;- let inline = t.runs.iter().any(|r| r.inline.is_some());- // Ruby is written as outlines with its base text: a reader's <text> can't place it. So are- // small capitals, superscript and subscript and tab leaders, which SVG text doesn't draw (#3869).- let unwritable = t.runs.iter().any(|r| r.style.small_caps.is_some() || r.style.position != vectorcraft_doc::CharPosition::Normal)- || std::iter::once(&t.para).chain(&t.paras).any(|p| p.tabs.iter().any(|tab| !tab.leader.is_empty()));- let outlined =- self.opts.outline_text || t.vertical || !t.ruby.is_empty() || (inline && matches!(t.kind, TextKind::OnPath { .. })) || unwritable;- let chars = |w: &mut Self, n: &Node| if outlined { w.text_outlines(n, t) } else { w.text(n, t) };- let painted = n.appearance.items.iter().any(|i| i.visible() && !i.paint().is_none());- // Live type with an inside or outside character stroke writes that stroke apart from the- // text, in the group.- let apart = !outlined && t.runs.iter().any(|r| aligned(&r.style));- if !painted && !inline && !apart {- return chars(self, n);- }- let id = self.id_attr(n);- let a = self.attrs(&css::transparency(n));- self.line(&format!("<g{id}{a}>"));- self.depth += 1;- let db = vectorcraft_text::FontDb::global();- let lay = vectorcraft_text::layout(db, t);- let mut all = lay.to_bezpath();- for (_, bar) in vectorcraft_text::decorations(&lay, db, t) {- all.extend(bar.iter());- }- let pd = PathData::from_bezpath(&all).transformed(t.xf);- let d = self.path_d(&pd, self.xf);- let tb = Some(t.xf.transform_rect_bbox(lay.bounds));- let (below, above) = n.appearance.split_contents();- let glyphs = |w: &mut Self, items: &[AppearanceItem]| {- if !items.is_empty() {- let ap = vectorcraft_doc::Appearance { items: items.to_vec(), ..Default::default() };- w.shape(&Node::path(NodeId(u64::MAX), pd.clone(), ap), &d, &[&pd], FillRule::NonZero, tb);- }- };- glyphs(self, below);- // The group carries the id and the object's transparency.- let mut bare = n.clone();- (bare.opacity, bare.blend, bare.isolate) = (1.0, BlendMode::Normal, false);- let anonymous = std::mem::replace(&mut self.anonymous, true);- chars(self, &bare);- for ig in &lay.inlines {- let Some(art) = t.runs.get(ig.run).and_then(|r| r.inline.as_ref()) else { continue };- let inst = Node::new(- NodeId(u64::MAX),- NodeKind::SymbolInstance { symbol: art.symbol.clone(), xf: t.xf * ig.xf * doc.symbol_natural_xf(&art.symbol) },- );- self.node(&inst);- }- glyphs(self, above);- self.anonymous = anonymous;- self.depth -= 1;- self.line("</g>");- }-- /// Text as glyph outlines: one compound path per run, painted like the run (gradients span- /// the whole text), over its colour glyphs, as on the canvas.- fn text_outlines(&mut self, n: &Node, t: &TextObject) {- let db = vectorcraft_text::FontDb::global();- let lay = vectorcraft_text::layout(db, t);- let mut runs = vec![kurbo::BezPath::new(); t.runs.len()];- // Underline and strikethrough bars join their run's outlines; ruby glyphs are painted- // with the run of the text they annotate.- let bars = vectorcraft_text::decorations(&lay, db, t);- for (run, outline) in lay- .glyphs- .iter()- .map(|g| (g.run, &g.outline))- .chain(lay.ruby.iter().map(|g| (g.run, &g.outline)))- .chain(bars.iter().map(|(r, b)| (*r, b)))- {- if let Some(bp) = runs.get_mut(run) {- bp.extend(outline.iter());- }- }- let id = self.id_attr(n);- let a = self.attrs(&css::transparency(n));- // Glyphs bent along a path (joined scripts on a curve) can only be outlines: the group- // names its text for screen readers and search.- let label = if lay.glyphs.iter().any(|g| g.bend.is_some()) {- format!(" role=\"img\" aria-label=\"{}\"", xml_escape(&t.plain_text()))- } else {- String::new()- };- self.line(&format!("<g{id}{a}{label}>"));- self.depth += 1;- // The glyphs stay in text space; the text's transform joins the document's meanwhile.- let saved = self.xf;- self.xf = saved * t.xf;- for (i, (bp, run)) in runs.iter().zip(&t.runs).enumerate() {- // Colour glyphs paint themselves, under their run's paint: bitmap glyphs (emoji) as- // their images, COLR and SVG glyphs as their art.- for g in lay.glyphs.iter().filter(|g| g.run == i) {- if let Some((image, to_text)) = g.placed_image() {- let m = self.matrix(self.xf * to_text);- let href = self.blob_href(&image.blob);- self.line(&format!(- "<image width=\"{}\" height=\"{}\" transform=\"{m}\" preserveAspectRatio=\"none\" xlink:href=\"{}\"/>",- image.width,- image.height,- xml_escape(&href)- ));- }- if let Some(art) = g.placed_colour(Affine::IDENTITY) {- self.node(&art);- }- }- if bp.elements().is_empty() {- continue;- }- let pd = PathData::from_bezpath(bp);- // An unnamed id: the pieces carry no id attribute (the group has it).- let glyphs = Node::path(NodeId(u64::MAX), pd.clone(), run.style.appearance());- let d = self.path_d(&pd, self.xf);- self.shape(&glyphs, &d, &[&pd], FillRule::NonZero, Some(lay.bounds));- }- self.xf = saved;- self.depth -= 1;- self.line("</g>");- }-- /// Point and area type, every laid-out line at its own position: wraps, indents, tabs and- /// spacing come out as on the canvas. Centred and right-aligned lines are anchored- /// (`text-anchor`) at their centre or right end, so they stay aligned in a viewer whose font- /// differs; other lines are placed where each style run (and, justified, each word) starts.- fn text(&mut self, n: &Node, t: &TextObject) {- // Live SVG text is written in logical order from left-aligned pieces: bidirectional text- // (and right-to-left paragraphs) keep their look as outlines until it is written with- // `direction`/`unicode-bidi`. So do runs set Right to Left (Character Direction), whose- // `direction="rtl"` would anchor their pieces at the right end.- let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);- let rtl_runs = t.runs.iter().any(|r| r.style.char_direction == Some(vectorcraft_doc::ParaDirection::RightToLeft));- if lay.glyphs.iter().any(|g| g.rtl) || lay.lines.iter().any(|l| l.rtl) || rtl_runs {- self.warn("bidirectional text is outlined to preserve shaping and visual order");- return self.text_outlines(n, t);- }- if let TextKind::OnPath { path, start, end } = &t.kind {- // A reader lays a `<textPath>`'s glyphs straight: joined glyphs bent along the path- // keep their look as outlines.- if lay.glyphs.iter().any(|g| g.bend.is_some()) {- self.warn("joined type bent along a path is outlined to keep its look");- return self.text_outlines(n, t);- }- // `<textPath>` has a start offset only: an end bracket, Align to Path and Spacing- // keep their look as outlines.- if end.is_some() || t.path_align != vectorcraft_doc::PathAlign::Baseline || t.path_spacing != 0.0 {- self.warn("type on a path with an end bracket, Align to Path or Spacing is outlined to keep its look");- return self.text_outlines(n, t);- }- // It cannot hang glyphs outside the start bracket either.- if hangs_on_path(t, &lay) {- self.warn("type on a path with glyphs hanging outside its brackets is outlined to keep its look");- return self.text_outlines(n, t);- }- // A `<textPath>` holds the characters of the text, not the bullets or numbers drawn- // before them.- if !lay.markers.is_empty() {- self.warn("type on a path with bullets or numbers is outlined to keep its look");- return self.text_outlines(n, t);- }- return self.text_on_path(n, t, path, *start);- }- self.note_fonts(t, &lay);- let lines = text_lines(t, &lay, self.opts.fewer_tspans);- // `drawn` holds the styles the layout draws the text in: Shrink Text to Fit scales its sizes, explicit leading and baseline shifts.- let fitted = (lay.fit_scale != 1.0).then(|| vectorcraft_text::scaled(t, lay.fit_scale));- let drawn = fitted.as_ref().unwrap_or(t);- // Each line is anchored as its paragraph is aligned. A tab starts a new chunk at its- // stop, and so does the text after an inline graphic: lines with tabs, and text with- // inline graphics, are never anchored.- let has_inline = t.runs.iter().any(|r| r.inline.is_some());- let anchors: Vec<Option<(&str, f64)>> = lines- .iter()- .map(|l| {- match t.para_at(l.para).justify {- Justify::Center => Some(("middle", 0.5)),- Justify::Right => Some(("end", 1.0)),- _ => None,- }- .filter(|_| !has_inline && !l.segs.iter().any(|s| s.brk))- })- .collect();- // Every line anchored alike (the text's only paragraph style, typically): the <text>- // carries the anchor. Otherwise each anchored line is a <tspan> carrying its own.- let uniform = anchors.first().copied().filter(|a| a.is_some() && anchors.iter().all(|b| b == a)).flatten();- // The <text> element's user space is text space.- let space = (lay.bounds, Affine::IDENTITY);- let mut base_props = self.char_props(&drawn.first_style(), space);- // A `<tspan>` cannot undo the decoration of the `<text>` around it: with bullets, which- // have none, each run's `<tspan>` carries its own.- if !lay.markers.is_empty() {- base_props.retain(|(k, _)| *k != "text-decoration");- }- let base = TextBase { props: base_props, space, anchored: uniform.is_some() };- let mut props = base.props.clone();- if let Some((a, _)) = uniform {- props.push(("text-anchor", a.into()));- }- props.extend(css::transparency(n));- let id = self.id_attr(n);- let a = self.attrs(&props);- let m = self.xf * t.xf;- let tr = if m == Affine::IDENTITY { String::new() } else { format!(" transform=\"{}\"", self.matrix(m)) };- let starts: Vec<Option<(f64, f64)>> = lines.iter().zip(&anchors).map(|(l, a)| line_start(&l.segs, a.map(|a| a.1))).collect();- // The `<text>` carries the first line's position too, so readers that place text by its- // own x/y start where the first line does.- let at = match starts.iter().flatten().next() {- Some((x, y)) => format!(" x=\"{}\" y=\"{}\"", self.num(*x), self.num(*y)),- None => String::new(),- };- let mut s = format!("<text{id}{tr}{at} xml:space=\"preserve\"{a}>");- for ((line, start), anchor) in lines.iter().zip(starts).zip(&anchors) {- let Some(start) = start else { continue };- match anchor.filter(|_| uniform.is_none()) {- // A line anchored on its own: one positioned <tspan> with the anchor around it.- Some((a, _)) => {- s.push_str(&format!("<tspan x=\"{}\" y=\"{}\" text-anchor=\"{a}\">", self.num(start.0), self.num(start.1)));- let inner = TextBase { anchored: true, ..base.clone() };- self.text_line(&mut s, drawn, &line.segs, start, &inner, false);- s.push_str("</tspan>");- }- None => self.text_line(&mut s, drawn, &line.segs, start, &base, true),- }- }- s.push_str("</text>");- self.line(&s);- self.aligned_char_strokes(t);- }-- /// The inside and outside character strokes of live type `t`, over its text (which goes- /// without them, see [`Self::char_props`]): each such run's stroke on its glyph outlines, drawn- /// twice as wide and clipped or masked to its side as aligned path strokes are- /// ([`Self::side_attr`]). The text stays live; only the stroke follows the outlines.- fn aligned_char_strokes(&mut self, t: &TextObject) {- if !t.runs.iter().any(|r| aligned(&r.style)) {- return;- }- let db = vectorcraft_text::FontDb::global();- let lay = vectorcraft_text::layout(db, t);- let bars = vectorcraft_text::decorations(&lay, db, t);- // The glyphs stay in text space; the text's transform joins the document's meanwhile.- let saved = self.xf;- self.xf = saved * t.xf;- for (i, run) in t.runs.iter().enumerate().filter(|(_, r)| aligned(&r.style)) {- let mut bp = BezPath::new();- for g in lay.glyphs.iter().filter(|g| g.run == i) {- bp.extend(g.outline.iter());- }- for (_, bar) in bars.iter().filter(|(r, _)| *r == i) {- bp.extend(bar.iter());- }- if bp.elements().is_empty() {- continue;- }- let pd = PathData::from_bezpath(&bp);- let ap = vectorcraft_doc::Appearance { items: vec![AppearanceItem::Stroke(run.style.stroke_layer())], ..Default::default() };- let d = self.path_d(&pd, self.xf);- self.shape(&Node::path(NodeId(u64::MAX), pd.clone(), ap), &d, &[&pd], FillRule::NonZero, Some(lay.bounds));- }- self.xf = saved;- }-- /// One line of laid-out text starting at `start`. Default: a positioned `<tspan>` per segment- /// (only the first of an anchored line). Fewer tspans: one positioned `<tspan>` per line with- /// the style changes nested in it, positioned again only after tabs and inline graphics.- /// Baseline shifts are relative (`dy`), undone by the next segment that isn't shifted.- /// `positioned`: false when the caller already positioned the line (an outer `<tspan>`).- fn text_line(&mut self, s: &mut String, t: &TextObject, line: &[Segment], start: (f64, f64), base: &TextBase, positioned: bool) {- let fewer = self.opts.fewer_tspans && positioned;- if fewer {- s.push_str(&format!("<tspan x=\"{}\" y=\"{}\">", self.num(start.0), self.num(start.1)));- }- let mut place = !fewer && positioned;- let mut first = true;- // The baseline shift the current text position carries.- let mut shift = 0.0;- for seg in line {- let Some(run_style) = t.runs.get(seg.run).map(|r| &r.style) else { continue };- let marker_style;- let st = if seg.marker {- marker_style = vectorcraft_doc::text::ParaList::marker_style(run_style);- &marker_style- } else {- run_style- };- let mut attrs = String::new();- if place {- let (x, y) = if first { start } else { (seg.x, seg.y) };- attrs.push_str(&format!(" x=\"{}\" y=\"{}\"", self.num(x), self.num(y)));- shift = 0.0;- }- first = false;- if st.baseline_shift != shift {- attrs.push_str(&format!(" dy=\"{}\"", self.num(shift - st.baseline_shift)));- shift = st.baseline_shift;- }- // After a tab, an inline graphic or a justified word space, and before a character that a- // reader would draw elsewhere, the next segment is placed.- place = seg.brk || (!fewer && !base.anchored && positioned);- if (st.h_scale - st.v_scale).abs() > 1e-9 || seg.scale != 1.0 {- attrs.push_str(&format!(" textLength=\"{}\" lengthAdjust=\"spacingAndGlyphs\"", self.num(seg.advance * seg.scale)));- }- if st.rotation != 0.0 {- attrs.push_str(&format!(" rotate=\"{}\"", self.num(-st.rotation)));- }- let mut diff = run_diff(&base.props, self.char_props(st, base.space));- diff.extend(direction_props(st));- attrs.push_str(&self.attrs(&diff));- let text = xml_text(&seg.text);- if attrs.is_empty() && fewer {- s.push_str(&text);- } else {- s.push_str(&format!("<tspan{attrs}>{text}</tspan>"));- }- }- if fewer {- s.push_str("</tspan>");- }- }-- /// Record the characters of laid-out type `t` under the faces that supply them, for- /// [`Self::font_faces`] (when fonts are embedded).- fn note_fonts(&mut self, t: &TextObject, lay: &vectorcraft_text::TextLayout) {- if !self.opts.embed_fonts || self.opts.outline_text {- return;- }- if self.tiny() {- return self.warn("SVG Tiny 1.2 has no web fonts: fonts are not embedded");- }- let db = FontDb::global();- let plain = t.plain_text();- let mut face: Option<Arc<FontFace>> = None;- for (i, g) in lay.glyphs.iter().enumerate() {- let Some(st) = t.runs.get(g.run).map(|r| &r.style) else { continue };- // A colour font's subset would hold no bitmaps or COLR layers: its emoji are left to the- // viewer.- if g.image.is_some() || g.colour.is_some() {- self.warn("colour emoji fonts are not embedded: viewers show emoji in their own fonts");- continue;- }- if face.as_ref().is_none_or(|f| f.id() != g.font_id) {- face = db.face_by_id(g.font_id);- }- let Some(f) = &face else { continue };- let (weight, italic) = font_descriptor(st);- let stretch = css::font_stretch(st).map(f64::to_bits);- let at = self- .fonts- .iter()- .position(|u| u.face.id() == f.id() && (u.weight, u.italic, u.stretch) == (weight, italic, stretch) && u.family == st.font_family);- let at = at.unwrap_or_else(|| {- let family = st.font_family.clone();- self.fonts.push(FontUse { family, weight, italic, stretch, face: f.clone(), chars: BTreeSet::new() });- self.fonts.len() - 1- });- let Some(chars) = self.fonts.get_mut(at).map(|u| &mut u.chars) else { continue };- // As written: a list marker's characters, a hyphen where a line breaks, capitals for All- // Caps, the style's Digits.- let src = lay.marker_text(i).unwrap_or_else(|| if g.len == 0 { "-" } else { plain.get(g.byte..g.byte + g.len).unwrap_or("") });- for c in src.chars().filter(|c| !c.is_control() && *c != '\u{ad}').map(|c| st.digits.map(c)) {- if st.all_caps {- chars.extend(c.to_uppercase());- } else {- chars.insert(c);- }- }- }- }-- /// The `@font-face` rules of the faces type uses ([`ExportOptions::embed_fonts`]): each face- /// subset to its characters (whole when its licence forbids subsetting, left out with a- /// warning when it forbids embedding). Faces sharing a description cover their own- /// characters (`unicode-range`); where two of them share characters as well, a warning says- /// that browsers draw those in one of the faces.- fn font_faces(&mut self) -> Vec<String> {- let uses = std::mem::take(&mut self.fonts);- let mut rules = Vec::new();- fn described(u: &FontUse) -> (&str, u16, bool, Option<u64>) {- (&u.family, u.weight, u.italic, u.stretch)- }- let mut clashing: Vec<&String> = vec![];- for (i, u) in uses.iter().enumerate() {- let clash = uses- .get(..i)- .unwrap_or_default()- .iter()- .any(|o| described(o) == described(u) && o.face.id() != u.face.id() && !o.chars.is_disjoint(&u.chars));- if clash && !clashing.contains(&&u.family) {- clashing.push(&u.family);- }- }- for family in clashing {- self.warn(&format!(- "type in {family} uses faces of one weight, style and width that share characters: browsers draw those characters in one of the embedded faces"- ));- }- for u in &uses {- let chars: Vec<char> = u.chars.iter().copied().collect();- let name = format!("{} {}", u.face.family, u.face.style);- let Some(font) = u.face.embed(&chars) else {- self.warn(&format!("the licence of the font {name} doesn't allow embedding: viewers show its type in their own fonts"));- continue;- };- if !font.subset {- self.warn(&format!("the font {name} is embedded whole: its licence doesn't allow subsetting"));- }- let shared = uses.iter().filter(|o| described(o) == described(u)).count() > 1;- let range = if shared { format!(";unicode-range:{}", unicode_range(&u.chars)) } else { String::new() };- let stretch = u.stretch.map(|w| format!(";font-stretch:{}%", fmt_num(f64::from_bits(w), 3))).unwrap_or_default();- let (mime, format) = if font.cff { ("font/otf", "opentype") } else { ("font/ttf", "truetype") };- rules.push(format!(- "@font-face{{font-family:{};font-weight:{};font-style:{}{stretch};src:url(data:{mime};base64,{}) format(\"{format}\"){range}}}",- css_string(&u.family),- u.weight,- if u.italic { "italic" } else { "normal" },- base64_encode(&font.data)- ));- }- rules- }-- /// Type on a path: a `<textPath>` along the path (a def).- fn text_on_path(&mut self, n: &Node, t: &TextObject, path: &PathData, start: f64) {- let id = self.id_attr(n);- let pid = self.fresh_id("text-path");- let d = self.path_d(path, self.xf * t.xf);- self.def(1, &format!("<path id=\"{pid}\" d=\"{d}\"/>"));- // The <text> element's user space is the document's; gradients span the laid-out text.- let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);- self.note_fonts(t, &lay);- let space = (lay.bounds, self.xf * t.xf);- let base = self.char_props(&t.first_style(), space);- let mut props = base.clone();- match t.para_at(0).justify {- Justify::Center | Justify::JustifyCenter => props.push(("text-anchor", "middle".into())),- Justify::Right | Justify::JustifyRight => props.push(("text-anchor", "end".into())),- _ => {}- }- props.extend(css::transparency(n));- let a = self.attrs(&props);- let offset = fmt_num(start * 100.0, 3);- let mut s = format!("<text{id} xml:space=\"preserve\"{a}><textPath xlink:href=\"#{pid}\" startOffset=\"{offset}%\">");- for run in &t.runs {- let mut diff = run_diff(&base, self.char_props(&run.style, space));- diff.extend(direction_props(&run.style));- let a = self.attrs(&diff);- s.push_str(&format!("<tspan{a}>{}</tspan>", xml_text(&run.text.replace('\n', " "))));- }- s.push_str("</textPath></text>");- self.line(&s);- self.aligned_char_strokes(t);- }-}--/// Does a character style stroke inside or outside its glyphs (not centred)?-fn aligned(st: &CharStyle) -> bool {- st.has_stroke() && st.stroke_align != StrokeAlign::Center-}--/// Does type on a path `t`, laid out as `lay`, hang glyphs outside its brackets? It does when-/// Optical Margin Alignment or its first paragraph's Roman Hanging Punctuation is on and its-/// glyphs sit elsewhere with both off.-fn hangs_on_path(t: &TextObject, lay: &vectorcraft_text::TextLayout) -> bool {- if !t.optical_margin && !t.para_at(0).roman_hanging {- return false;- }- let mut flush = t.clone();- flush.optical_margin = false;- let mut styles = flush.paragraph_styles();- for p in &mut styles {- p.roman_hanging = false;- }- flush.set_paragraph_styles(styles);- let flush = vectorcraft_text::layout(FontDb::global(), &flush);- lay.glyphs.len() != flush.glyphs.len() || lay.glyphs.iter().zip(&flush.glyphs).any(|(a, b)| a.origin != b.origin)-}--/// The `direction` and `unicode-bidi` of a `<tspan>` of characters in style `st`: an embedding in-/// its Character Direction, and nothing without one. Each `<tspan>` of characters with a direction-/// carries them, and the `<text>` does not. Type with a run set Right to Left is written as-/// outlines ([`Writer::text`]), so live text writes `direction="ltr"` only.-fn direction_props(st: &CharStyle) -> Props {- let Some(d) = st.char_direction else { return Props::new() };- let direction = if d == vectorcraft_doc::ParaDirection::RightToLeft { "rtl" } else { "ltr" };- vec![("direction", direction.into()), ("unicode-bidi", "embed".into())]-}--/// What the `<tspan>` of a run whose properties are `run` sets over its `<text>`'s `base`: the-/// properties that differ, and the initial value of each one `base` sets and the run doesn't.-fn run_diff(base: &Props, run: Props) -> Props {- let reset: Props =- base.iter().filter(|(k, _)| !run.iter().any(|(r, _)| r == k)).filter_map(|(k, _)| initial_value(k).map(|v| (*k, v.to_string()))).collect();- run.into_iter().filter(|kv| !base.contains(kv)).chain(reset).collect()-}--/// The initial value of an inherited property a run may leave unset (decorations can't be undone-/// on a `<tspan>`).-fn initial_value(k: &str) -> Option<&'static str> {- Some(match k {- "font-weight" | "font-style" | "font-stretch" | "font-feature-settings" | "font-variation-settings" => "normal",- "stroke" | "stroke-dasharray" => "none",- "stroke-width" | "stroke-opacity" => "1",- "stroke-linecap" => "butt",- "stroke-linejoin" => "miter",- "stroke-miterlimit" => "4",- "stroke-dashoffset" | "letter-spacing" => "0",- "font-kerning" => "auto",- _ => return None,- })-}--/// A shape's paths as one path (document space).-fn doc_path(paths: &[&PathData]) -> BezPath {- let mut bp = BezPath::new();- for p in paths {- bp.extend(p.to_bezpath());- }- bp-}--/// How closely stroke outlines that clip an image follow the stroke (points).-const OUTLINE_TOLERANCE: f64 = 0.01;--/// Most pixels along a side of a linear or radial gradient's image.-const MAX_GRADIENT_PX: f64 = 4096.0;--/// The gradient a fill (`fill`) or stroke paint is, if it is drawn as pixels-/// ([`GradientPaint::draws_as_pixels`]; SVG has no freeform gradients, for one).-fn pixel_gradient(p: &Paint, fill: bool) -> Option<&GradientPaint> {- match p {- Paint::Gradient(g) if g.draws_as_pixels(fill) => Some(g),- _ => None,- }-}--/// Any visible raster effect (shadow, glow, blur, feather) in `effects`?-fn has_raster(effects: &[vectorcraft_doc::Effect]) -> bool {- effects.iter().any(|e| e.visible && vectorcraft_effects::is_raster(&e.id))-}--/// What the lines of one `<text>` share.-#[derive(Clone)]-struct TextBase {- /// The `<text>` element's character properties, which each `<tspan>` differs from.- props: Props,- /// The text's layout bounds and the map from text space to user space (character paints).- space: (Rect, Affine),- /// Lines anchored at their centre or right end (`text-anchor`), positioned once each.- anchored: bool,-}--/// One laid-out line: its paragraph (index) and its segments.-struct Line {- para: usize,- segs: Vec<Segment>,-}--/// Characters of one style on one line, written as one `<tspan>`.-struct Segment {- /// Index into `TextObject::runs`.- run: usize,- /// Where a reader starts drawing the segment (text space; `y` is the baseline).- x: f64,- y: f64,- text: String,- /// The width a reader gives the segment (tracking included). On a line that is justified or- /// set with Mojikumi (unless `fewer`), that is the width without justification and Mojikumi- /// ([`reader_advances`]), for horizontally scaled type also without its last character's- /// kerning against the character after it ([`end_segment`]); elsewhere, the laid-out width.- advance: f64,- /// The next segment needs its own position (after a tab, a word space of a justified line, or- /// the next segment starts with a character the layout draws elsewhere than a reader would).- brk: bool,- /// Glyph Scaling of the segment's one glyph (Justification…), which a reader stretches it to- /// (`textLength`); 1 for other segments.- scale: f64,- /// A list marker's characters and tab, written in- /// [`vectorcraft_doc::text::ParaList::marker_style`] of the run's style.- marker: bool,-}--/// How far a reader may draw a character from where the layout draws it before the character is-/// given its own position (points).-const PLACE_TOLERANCE: f64 = 1e-6;--/// The laid-out lines of `t` as segments: a new segment at every style change, after tabs and,-/// on justified lines, after each word space (unless `fewer`). The text comes from the clusters-/// the layout placed: soft hyphens draw nothing, a line broken by hyphenation ends in `-`, all-/// caps are upper case. Unless `fewer`, a line that is justified or composed with Mojikumi also-/// starts a new segment at each character the layout draws elsewhere than a reader continuing-/// the segment would ([`reader_advances`]): a Justify All line's letter gaps, the gaps between-/// the characters of a justified Japanese line, and the spacing Mojikumi changes.-fn text_lines(t: &TextObject, lay: &vectorcraft_text::TextLayout, fewer: bool) -> Vec<Line> {- let plain = t.plain_text();- let mut lines = Vec::with_capacity(lay.lines.len());- let (mut kerned, mut unkerned) = (None, None);- for line in &lay.lines {- let para = plain.as_bytes().get(..line.start).map_or(0, |b| b.iter().filter(|&&c| c == b'\n').count());- let style = t.para_at(para);- let split_words = !fewer && !matches!(style.justify, Justify::Auto | Justify::Left | Justify::Center | Justify::Right);- // Each cluster's advance and drawing offset as a reader gives them, by its byte offset.- // Justification…'s Desired word and letter spacing and glyph scaling move characters from- // where a reader draws them, on every line.- let spaced = !fewer && !style.justification.desired_is_default();- let reader = if split_words || spaced || (!fewer && !style.mojikumi.is_none()) {- Some(&*kerned.get_or_insert_with(|| reader_advances(t, lay, true)))- } else {- None- };- // Where a reader draws the next character of the last segment, and the byte offset and- // reader's advance of the last segment's last cluster.- let mut pen = 0.0;- let mut tail = None;- let mut segs: Vec<Segment> = Vec::new();- let mut cluster = None;- // A list marker's glyphs write its characters and then a tab (glyph `i` of the layout).- let source = |i: usize, g: &vectorcraft_text::PositionedGlyph| {- lay.marker_text(i).unwrap_or_else(|| if g.len == 0 { "-" } else { plain.get(g.byte..g.byte + g.len).unwrap_or("") })- };- let mut glyphs = lay.glyphs.get(line.glyph_start..line.glyph_end).unwrap_or_default();- // Spaces where the line wrapped (it doesn't end its paragraph) don't belong to the line.- if plain.get(line.end..).is_some_and(|rest| !rest.is_empty() && !rest.starts_with('\n')) {- while let Some((_, rest)) =- glyphs.split_last().filter(|(g, rest)| source(line.glyph_start + rest.len(), g).chars().all(|c| c.is_whitespace() && c != '\t'))- {- glyphs = rest;- }- }- let mut after_inline = false;- for (k, g) in glyphs.iter().enumerate() {- let Some(run) = t.runs.get(g.run) else { continue };- // A list marker before an inline graphic is in the graphic's run, and is text.- if run.inline.is_some() && lay.marker_of(line.glyph_start + k).is_none() {- // An inline graphic (written as art): the text after it is placed anew.- if let Some(last) = segs.last_mut() {- last.brk = true;- }- after_inline = true;- cluster = None;- continue;- }- // The cluster as a reader sets it (a hyphen the layout adds is set as laid out).- let set = reader.and_then(|r| r.get(&g.byte)).filter(|_| g.len > 0);- if g.len > 0 && cluster == Some(g.byte) {- // Another glyph of the same cluster (a reader's advance covers the whole cluster).- if let Some(last) = segs.last_mut().filter(|_| set.is_none()) {- last.advance += g.advance;- pen += g.advance;- }- continue;- }- // A glyph that stands for no character (a list marker before the paragraph's first- // character) starts no cluster.- cluster = (g.len > 0).then_some(g.byte);- let (advance, x) = match set {- Some(&(advance, offset)) => {- // A glyph the layout draws before its pen (Mojikumi) starts that much earlier.- let x = g.xf.translation().x - offset;- (advance, if (x - g.origin.x).abs() > PLACE_TOLERANCE { x } else { g.origin.x })- }- None => (g.advance, g.origin.x),- };- let src: String = source(line.glyph_start + k, g).chars().filter(|c| *c != '\u{ad}').map(|c| run.style.digits.map(c)).collect();- let piece = if run.style.all_caps { src.to_uppercase() } else { src };- let brk = piece == "\t" || (split_words && !piece.is_empty() && piece.chars().all(char::is_whitespace));- // A glyph Glyph Scaling widens or narrows is a segment of its own, stretched to its width.- let scale = if reader.is_some() && (g.scale - 1.0).abs() > 1e-9 && g.scale.is_finite() { g.scale } else { 1.0 };- let fresh = std::mem::take(&mut after_inline) || scale != 1.0 || segs.last().is_some_and(|last| last.scale != 1.0);- // The layout draws the character elsewhere than a reader continuing the line would.- let moved = reader.is_some()- && segs.last().is_some_and(|last| (x - pen).abs() > PLACE_TOLERANCE || (g.origin.y - last.y).abs() > PLACE_TOLERANCE);- pen = x + advance;- // A list marker is a segment of its own, and so is the text after it. In horizontally- // scaled type a tab is a segment apart from the characters before it, so a reader- // stretching those characters to their width (`textLength`) stretches them alone.- let marker = lay.marker_of(line.glyph_start + k).is_some();- let tab_apart = piece == "\t" && (run.style.h_scale - run.style.v_scale).abs() > 1e-9;- match segs.last_mut() {- Some(last) if last.run == g.run && !last.brk && !fresh && !moved && last.marker == marker && !tab_apart => {- last.text.push_str(&piece);- last.advance += advance;- last.brk = brk;- }- last => {- if let Some(last) = last {- last.brk |= moved || last.marker != marker;- end_segment(last, tail, t, lay, &mut unkerned);- }- segs.push(Segment { run: g.run, x, y: g.origin.y, text: piece, advance, brk, scale, marker });- }- }- tail = set.map(|_| (g.byte, advance));- }- if let Some(last) = segs.last_mut() {- end_segment(last, tail, t, lay, &mut unkerned);- }- segs.retain(|s| !s.text.is_empty());- if !segs.is_empty() {- lines.push(Line { para, segs });- }- }- lines-}--/// Ends segment `seg` of horizontally scaled type (or a glyph Glyph Scaling scales), which a reader stretches to its width-/// (`textLength`): its last cluster (`tail`: byte offset and reader's advance) takes the advance-/// a reader gives it at the end of a `<tspan>`, without the font's kerning against the character-/// after it. `unkerned` holds [`reader_advances`] without kerning once a segment needs them.-fn end_segment(- seg: &mut Segment,- tail: Option<(usize, f64)>,- t: &TextObject,- lay: &vectorcraft_text::TextLayout,- unkerned: &mut Option<HashMap<usize, (f64, f64)>>,-) {- let Some((byte, advance)) = tail else { return };- if seg.scale == 1.0 && t.runs.get(seg.run).is_none_or(|r| (r.style.h_scale - r.style.v_scale).abs() <= 1e-9) {- return;- }- if let Some(&(alone, _)) = unkerned.get_or_insert_with(|| reader_advances(t, lay, false)).get(&byte) {- seg.advance += alone - advance;- }-}--/// The advance a reader of live SVG text gives each character cluster of `t` and how far from-/// its pen it draws the cluster's first glyph, keyed by the cluster's byte offset: `t` laid out-/// as point type (which isn't justified) without Mojikumi, scaled as `t`'s layout `lay` is by-/// Shrink Text to Fit. Without `kerning`, the font's pair kerning is left out (as manual-/// kerning leaves it out).-fn reader_advances(t: &TextObject, lay: &vectorcraft_text::TextLayout, kerning: bool) -> HashMap<usize, (f64, f64)> {- let mut set = TextObject { kind: TextKind::Point, ..t.clone() };- for p in std::iter::once(&mut set.para).chain(set.paras.iter_mut()) {- p.mojikumi = vectorcraft_doc::Mojikumi::None;- // A reader spaces words and letters as the font does.- p.justification = vectorcraft_doc::JustificationOptions::default();- }- if !kerning {- for r in &mut set.runs {- r.style.kerning.get_or_insert(0.0);- }- }- let mut out: HashMap<usize, (f64, f64)> = HashMap::new();- for g in vectorcraft_text::layout(FontDb::global(), &set).glyphs.iter().filter(|g| g.len > 0) {- let (advance, _) = out.entry(g.byte).or_insert((0.0, (g.xf.translation().x - g.origin.x) * lay.fit_scale));- *advance += g.advance * lay.fit_scale;- }- out-}--/// Where a line of segments starts: where its first segment starts or, `anchor`ed (0.5: center, 1:-/// right end), that point of its width. `None` for an empty line.-fn line_start(line: &[Segment], anchor: Option<f64>) -> Option<(f64, f64)> {- let (first, last) = (line.first()?, line.last()?);- let x = match anchor {- Some(f) => first.x + f * (last.x + last.advance - first.x),- None => first.x,- };- Some((x, first.y))-}--/// Does `n` paint opaquely wherever it paints (no transparency, blending, masks or effects in-/// it)? Anything this can't tell is taken as not.-fn paints_opaque(n: &Node) -> bool {- use vectorcraft_doc::{AppearanceItem, NodeKind};- let paint = |p: &Paint| match p {- Paint::None | Paint::Solid { .. } => true,- Paint::Gradient(g) => g.gradient.stops.iter().all(|s| s.opacity >= 1.0),- _ => false,- };- let items = n.appearance.items.iter().all(|i| match i {- AppearanceItem::Fill(f) => !f.visible || (f.opacity >= 1.0 && f.blend == BlendMode::Normal && f.effects.is_empty() && paint(&f.paint)),- // Brush art draws as pieces with opacities of their own (bristles vary theirs).- AppearanceItem::Stroke(s) => {- !s.visible || (s.opacity >= 1.0 && s.blend == BlendMode::Normal && s.effects.is_empty() && s.brush.is_none() && paint(&s.paint))- }- });- let own = n.opacity >= 1.0 && n.blend == BlendMode::Normal && n.extras().mask.is_none() && n.appearance.effects.is_empty() && items;- own && match &n.kind {- NodeKind::Path { .. } => true,- NodeKind::Group { children, .. } | NodeKind::Compound { children, .. } => children.iter().all(|c| paints_opaque(c)),- NodeKind::Mesh(m) => m.points.iter().all(|p| p.opacity >= 1.0),- _ => false,- }-}diff --git a/crates/svg/src/export/nodes.rs b/crates/svg/src/export/nodes.rsnew file mode 100644index 000000000..69d700844--- /dev/null+++ b/crates/svg/src/export/nodes.rs@@ -0,0 +1,705 @@+use super::output::{sanitize_id, valid_xml_value, xml_attr_escape};+use super::paint::{StrokePlan, has_raster, pixel_gradient};+use super::text::OUTLINE_TOLERANCE;+use super::*;++/// A symbol's `<symbol>` def and the instance transforms that can `<use>` it.+pub(super) struct SymbolDef {+ /// The def's id, once written.+ id: Option<String>,+ reuse: Reuse,+}++/// Which instance transforms paint a symbol's art exactly as the def under that transform (the+/// canvas transforms the art's geometry alone: stroke weights, effects, patterns and unlinked+/// masks stay put).+#[derive(Clone, Copy)]+pub(crate) struct Reuse {+ /// Translations (no pattern paints or unlinked masks).+ moves: bool,+ /// Rotations and reflections (nor effects or brushes).+ turns: bool,+ /// Any other transform (nor strokes or live objects).+ scales: bool,+}++/// How deep symbols may sit in one another's art (deeper instances are left out).+const MAX_SYMBOL_NEST: u32 = 8;++impl Reuse {+ const NONE: Self = Self { moves: false, turns: false, scales: false };++ /// What a def of symbol art `art` stands for.+ pub(crate) fn of(doc: &Document, art: &Node) -> Self {+ let mut r = Self { moves: true, turns: true, scales: true };+ r.scan(doc, art, 0);+ r+ }++ /// Narrow down to what `n` (inside symbols nested `depth` deep) allows.+ fn scan(&mut self, doc: &Document, n: &Node, depth: u32) {+ let pattern = |p: &Paint| matches!(p, Paint::Pattern { .. });+ let text_patterns = matches!(&n.kind, NodeKind::Text(t) if t.runs.iter().any(|r| pattern(&r.style.fill) || pattern(&r.style.stroke)));+ let unlinked_mask = n.extras().mask.as_ref().is_some_and(|m| !m.linked);+ if depth > MAX_SYMBOL_NEST || text_patterns || unlinked_mask || vectorcraft_doc::pattern::uses_pattern(n, None) {+ *self = Self::NONE;+ return;+ }+ let effects = |fx: &[vectorcraft_doc::Effect]| fx.iter().any(|e| e.visible);+ if effects(&n.appearance.effects) || n.appearance.items.iter().any(|i| effects(i.effects())) {+ (self.turns, self.scales) = (false, false);+ }+ for i in &n.appearance.items {+ if let AppearanceItem::Stroke(s) = i+ && s.visible+ && !s.paint.is_none()+ && s.width > 0.0+ {+ // Stroke weights don't scale; brushes can orient their art to the page.+ self.scales = false;+ self.turns &= s.brush.is_none();+ }+ }+ match &n.kind {+ NodeKind::Blend { .. }+ | NodeKind::Envelope { .. }+ | NodeKind::Mesh(_)+ | NodeKind::Repeat(_)+ | NodeKind::PlacedDocument(_)+ | NodeKind::Intertwine { .. } => (self.turns, self.scales) = (false, false),+ NodeKind::SymbolInstance { symbol, .. } => {+ if let Some(s) = doc.symbols.iter().find(|s| s.name == *symbol) {+ self.scan(doc, &s.art, depth + 1);+ }+ }+ _ => {}+ }+ if let Some(m) = &n.extras().mask {+ self.scan(doc, &m.art, depth);+ }+ for c in n.children().into_iter().flatten() {+ self.scan(doc, c, depth);+ }+ }++ /// Can the def stand for an instance with transform `xf`?+ pub(crate) fn allows(self, xf: Affine) -> bool {+ const EPS: f64 = 1e-9;+ let [a, b, c, d, _, _] = xf.as_coeffs();+ if (a - 1.0).abs() < EPS && b.abs() < EPS && c.abs() < EPS && (d - 1.0).abs() < EPS {+ return self.moves;+ }+ let rigid = (a * a + b * b - 1.0).abs() < EPS && (c * c + d * d - 1.0).abs() < EPS && (a * c + b * d).abs() < EPS;+ if rigid { self.turns } else { self.scales }+ }+}++/// Art about to be written moved by `m.inverse()` (a symbol instance's): map what the canvas+/// leaves on the page by `m` first, so it stays there. That is every pattern paint's placement+/// and the art of unlinked opacity masks.+fn pin_to_page(n: &mut Node, m: Affine) {+ vectorcraft_doc::pattern::transform_pattern_paints(n, m);+ if let Some(mask) = n.extras_if_any().and_then(|e| e.mask.as_deref_mut()) {+ let linked = mask.linked;+ let art = std::sync::Arc::make_mut(&mut mask.art);+ if !linked {+ art.transform(m, false);+ }+ pin_to_page(art, m);+ }+ for c in n.children_mut().into_iter().flatten() {+ pin_to_page(std::sync::Arc::make_mut(c), m);+ }+}++/// What SVG Tiny 1.2 does without masks.+const TINY_MASKS: &str = "SVG Tiny 1.2 has no masks: opacity masks are left out and knockout groups written as plain groups";++/// A region covering any artwork (mask and filter extents).+const BIG: &str = "x=\"-100000\" y=\"-100000\" width=\"200000\" height=\"200000\"";++/// Attributes of every `<mask>`: user-space units, and luminance taken from the sRGB values (as the+/// canvas and PDF take it) rather than from linearised ones.+pub(super) const MASK: &str = "maskUnits=\"userSpaceOnUse\" color-interpolation=\"sRGB\"";++/// Attribute of an exported opacity mask listing its options that differ from the defaults+/// (clipping, not inverted): `noclip`, `invert`.+pub(crate) const MASK_FLAGS: &str = "data-vectorcraft-mask";++impl Writer<'_> {+ /// Paint a shape (`d`) with a node's appearance stack. `paths` is the same shape in document+ /// space, for strokes that aren't plain (it may be empty when all are).+ pub(super) fn shape(&mut self, n: &Node, d: &str, paths: &[&PathData], rule: FillRule, bounds: Option<Rect>) {+ let id = self.id_attr(n);+ 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,+ })+ .collect();+ let mut bp = None;+ let plans: Vec<Option<StrokePlan>> = items+ .iter()+ .map(|i| match i {+ AppearanceItem::Stroke(s) => Some(self.stroke_plan(s, &mut bp, paths)),+ AppearanceItem::Fill(_) => None,+ })+ .collect();+ let fills = items.iter().filter(|i| matches!(i, AppearanceItem::Fill(_))).count();+ let strokes = items.len() - fills;+ // A stroke's paint box is the bounds grown by half its weight, as on the canvas.+ let paint_bounds = |s: &StrokeLayer| bounds.map(|b| s.paint_bounds(b));+ let simple = fills <= 1+ && strokes <= 1+ && !items.iter().any(|i| has_raster(i.effects()))+ && items.iter().all(|i| i.blend() == BlendMode::Normal)+ && !items.iter().any(|i| pixel_gradient(i.paint(), matches!(i, AppearanceItem::Fill(_))).is_some())+ && plans.iter().flatten().all(|p| matches!(p, StrokePlan::Written(Written { shape: WrittenShape::Stroke { .. }, side: None })));+ if simple {+ let mut p = Props::new();+ match items.iter().find_map(|i| if let AppearanceItem::Fill(f) = i { Some(f) } else { None }) {+ Some(f) => self.fill_props(f, rule, bounds, &mut p),+ None => {+ p.push(("fill", "none".into()));+ if rule == FillRule::EvenOdd {+ p.push(("fill-rule", "evenodd".into()));+ }+ }+ }+ if let Some(s) = items.iter().find_map(|i| if let AppearanceItem::Stroke(s) = i { Some(s) } else { None }) {+ self.stroke_props(s, s.width, paint_bounds(s), &mut p);+ if matches!(items.first(), Some(AppearanceItem::Stroke(_))) && fills == 1 {+ p.push(("paint-order", "stroke".into()));+ }+ }+ p.extend(css::transparency(n));+ let a = self.attrs(&p);+ self.line(&format!("<path{id} d=\"{d}\"{a}/>"));+ return;+ }+ let a = self.attrs(&css::transparency(n));+ self.line(&format!("<g{id}{a}>"));+ self.depth += 1;+ for (it, plan) in items.into_iter().zip(plans) {+ // The item's own raster effects filter that item alone.+ let filters = self.open_filters(n, it.effects());+ let mut p = Props::new();+ match (it, plan) {+ (AppearanceItem::Fill(f), _) => {+ let blend = (f.blend != BlendMode::Normal).then(|| ("mix-blend-mode", blend_css(f.blend).to_string()));+ if let (Some(g), Some(b)) = (pixel_gradient(&f.paint, true), bounds) {+ p.extend((f.opacity < 1.0).then(|| ("opacity", fmt_num(f.opacity as f64, 3))));+ p.extend(blend);+ self.raster_paint(g, b, &[d.to_string()], rule, &p, "", true);+ } else {+ self.fill_props(f, rule, bounds, &mut p);+ p.extend(blend);+ let a = self.attrs(&p);+ self.line(&format!("<path d=\"{d}\"{a}/>"));+ }+ }+ (AppearanceItem::Stroke(s), Some(StrokePlan::Brush(art))) => {+ // The brush art takes the stroke's opacity and blend mode as a group.+ if s.opacity < 1.0 {+ p.push(("opacity", fmt_num(s.opacity as f64, 3)));+ }+ if s.blend != BlendMode::Normal {+ p.push(("mix-blend-mode", blend_css(s.blend).into()));+ }+ let a = self.attrs(&p);+ self.line(&format!("<g{a}>"));+ self.depth += 1;+ for piece in &art {+ self.node(piece);+ }+ self.depth -= 1;+ self.line("</g>");+ }+ (AppearanceItem::Stroke(s), Some(StrokePlan::Written(w))) => {+ let side = self.side_attr(w.side, d, rule, w.reach(s, bounds.unwrap_or_default()));+ let blend = (s.blend != BlendMode::Normal).then(|| ("mix-blend-mode", blend_css(s.blend).to_string()));+ let opacity = (s.opacity < 1.0).then(|| ("opacity", fmt_num(s.opacity as f64, 3)));+ match (&w.shape, pixel_gradient(&s.paint, false).zip(paint_bounds(s))) {+ (WrittenShape::Stroke { width }, Some((g, b))) => {+ // The stroke's outline clips the gradient's image.+ let bp = bp.get_or_insert_with(|| doc_path(paths));+ let outline = stroke::line_outline(bp, s, *width, OUTLINE_TOLERANCE);+ let clip = self.path_d(&PathData::from_bezpath(&outline), self.xf);+ p.extend(opacity);+ p.extend(blend);+ self.raster_paint(g, b, &[clip], FillRule::NonZero, &p, &side, false);+ }+ (WrittenShape::Fill(outlines), Some((g, b))) if s.path_gradient().is_none() => {+ let clip: Vec<String> = outlines.iter().map(|o| self.path_d(&PathData::from_bezpath(o), self.xf)).collect();+ p.extend(opacity);+ p.extend(blend);+ self.raster_paint(g, b, &clip, FillRule::NonZero, &p, &side, false);+ }+ (WrittenShape::Stroke { width }, _) => {+ p.push(("fill", "none".into()));+ self.stroke_props(s, *width, paint_bounds(s), &mut p);+ p.extend(blend);+ let a = self.attrs(&p);+ self.line(&format!("<path d=\"{d}\"{a}{side}/>"));+ }+ (WrittenShape::Fill(outlines), _) if s.path_gradient().is_some() => {+ // A gradient along or across the stroke: slices clipped to its outlines.+ if let Some(ws) = bp.as_ref().and_then(|bp| stroke::written_slices(bp, rule, s, outlines)) {+ p.extend(opacity);+ p.extend(blend);+ self.sliced(&ws, &p, &side);+ }+ }+ (WrittenShape::Fill(outlines), _) => {+ let paint = self.paint(&s.paint, paint_bounds(s));+ let ds: Vec<String> = outlines.iter().map(|o| self.path_d(&PathData::from_bezpath(o), self.xf)).collect();+ let opacity = (s.opacity < 1.0).then(|| fmt_num(s.opacity as f64, 3));+ if let [one] = &ds[..] {+ p.push(("fill", paint));+ p.extend(opacity.map(|o| ("fill-opacity", o)));+ p.extend(blend);+ let a = self.attrs(&p);+ self.line(&format!("<path d=\"{one}\"{a}{side}/>"));+ } else if !ds.is_empty() {+ // The line and its arrowheads overlap: one group takes the opacity.+ p.extend(opacity.map(|o| ("opacity", o)));+ p.extend(blend);+ let a = self.attrs(&p);+ self.line(&format!("<g{a}{side}>"));+ self.depth += 1;+ let fill = self.attrs(&vec![("fill", paint)]);+ for one in &ds {+ self.line(&format!("<path d=\"{one}\"{fill}/>"));+ }+ self.depth -= 1;+ self.line("</g>");+ }+ }+ }+ }+ (AppearanceItem::Stroke(_), None) => {}+ }+ self.close_filters(filters);+ }+ self.depth -= 1;+ self.line("</g>");+ }++ /// A stroke whose gradient runs along or across it ([`stroke::written_slices`]): a group (with+ /// `props` and the `side` attribute) of its slices, clipped to its outlines.+ fn sliced(&mut self, ws: &stroke::WrittenSlices, props: &Props, side: &str) {+ self.warn("gradients along or across strokes are written as slices of linear gradients");+ let cid = self.fresh_id("clip-path");+ let clip = self.path_d(&PathData::from_bezpath(&ws.clip), self.xf);+ self.def(1, &format!("<clipPath id=\"{cid}\">"));+ self.def(2, &format!("<path d=\"{clip}\"/>"));+ self.def(1, "</clipPath>");+ let a = self.attrs(props);+ self.line(&format!("<g{a}{side}>"));+ self.depth += 1;+ self.line(&format!("<g clip-path=\"url(#{cid})\">"));+ self.depth += 1;+ for (shape, paint) in &ws.slices {+ let fill = self.paint(paint, None);+ let fill = self.attrs(&vec![("fill", fill)]);+ let d = self.path_d(&PathData::from_bezpath(shape), self.xf);+ self.line(&format!("<path d=\"{d}\"{fill}/>"));+ }+ self.depth -= 1;+ self.line("</g>");+ self.depth -= 1;+ self.line("</g>");+ }++ /// An object with an opacity mask: `<g mask="url(#…)">` around the unmasked object. The mask+ /// art goes in `<defs>`; no-clip adds a white backdrop and invert a colour-inverting filter.+ fn masked(&mut self, n: &Node, m: &vectorcraft_doc::OpacityMask) {+ if self.tiny() {+ self.warn(TINY_MASKS);+ let mut bare = n.clone();+ bare.extras_mut().mask = None;+ return self.node_body(&bare);+ }+ let mid = self.fresh_id("mask");+ // Mask art is a picture of its own: it takes no part in a knockout group around the object.+ let knockout = std::mem::take(&mut self.knockout);+ let art = self.detached(2, |w| w.node(&m.art));+ self.knockout = knockout;+ let inv = m.invert.then(|| {+ let fid = self.fresh_id("invert");+ self.def(1, &format!("<filter id=\"{fid}\" filterUnits=\"userSpaceOnUse\" color-interpolation-filters=\"sRGB\" {BIG}>"));+ self.def(2, "<feColorMatrix type=\"matrix\" values=\"-1 0 0 0 1 0 -1 0 0 1 0 0 -1 0 1 0 0 0 1 0\"/>");+ self.def(1, "</filter>");+ fid+ });+ // The mask's options, so import restores them (and its art without backdrop and filter).+ let flags: Vec<&str> = [(!m.clip).then_some("noclip"), m.invert.then_some("invert")].into_iter().flatten().collect();+ let data = if flags.is_empty() { String::new() } else { format!(" {MASK_FLAGS}=\"{}\"", flags.join(" ")) };+ self.def(1, &format!("<mask id=\"{mid}\" {MASK} {BIG}{data}>"));+ if let Some(fid) = &inv {+ self.def(1, &format!("<g filter=\"url(#{fid})\">"));+ }+ if !m.clip || m.invert {+ let c = if m.clip { "black" } else { "white" };+ self.def(1, &format!("<rect {BIG} fill=\"{c}\"/>"));+ }+ self.defs.push_str(&art);+ if inv.is_some() {+ self.def(1, "</g>");+ }+ self.def(1, "</mask>");+ self.line(&format!("<g mask=\"url(#{mid})\">"));+ self.depth += 1;+ let mut bare = n.clone();+ bare.extras_mut().mask = None;+ self.node_body(&bare);+ self.depth -= 1;+ self.line("</g>");+ }++ /// What `write` writes to the body, taken out of it (written at `depth`, for `<defs>`).+ fn detached(&mut self, depth: usize, write: impl FnOnce(&mut Self)) -> String {+ let (body, saved) = (std::mem::take(&mut self.body), self.depth);+ self.depth = depth;+ write(self);+ self.depth = saved;+ std::mem::replace(&mut self.body, body)+ }++ /// Props of a group (or layer): a knockout group is isolated, a hidden one not displayed.+ fn group_props(&self, n: &Node) -> Props {+ let mut p = css::transparency(n);+ if !n.isolate && n.knocks_out(self.knockout) {+ p.push(("isolation", "isolate".into()));+ }+ p+ }++ /// The children of group `n`, as the elements of a knockout group when it is one.+ fn group_children(&mut self, n: &Node, children: &[std::sync::Arc<Node>]) {+ let knockout = n.knocks_out(self.knockout);+ let enclosing = std::mem::replace(&mut self.knockout, knockout);+ self.children(children);+ self.knockout = enclosing;+ }++ /// Children of the group being written. SVG has no knockout groups: in one, each element is+ /// drawn through a mask of where the elements above it don't paint (the same look for Normal+ /// blending). The masks nest, so element i sits inside the masks of elements i+1…n.+ pub(super) fn children(&mut self, children: &[std::sync::Arc<Node>]) {+ if self.knockout && self.tiny() {+ self.warn(TINY_MASKS);+ }+ if !self.knockout || self.tiny() {+ for c in children {+ self.node(c);+ }+ return;+ }+ let elements = Node::knockout_elements(children);+ // Where every element over another covers it fully, drawing them in order knocks out as+ // much: the masks would only add seams along the shapes' antialiased edges.+ if elements.iter().skip(1).all(|c| paints_opaque(c)) {+ for c in elements {+ self.node(c);+ }+ return;+ }+ let Some((first, rest)) = elements.split_first() else { return };+ for c in rest.iter().rev() {+ let mid = self.knockout_mask(c);+ self.line(&format!("<g mask=\"url(#{mid})\">"));+ self.depth += 1;+ }+ self.node(first);+ for c in rest {+ self.depth -= 1;+ self.line("</g>");+ self.node(c);+ }+ }++ /// A mask that is 1 − the knockout shape of `c`: white, then `c` painted black (at full object+ /// opacity without its own mask, unless those define its shape). Returns the mask id.+ fn knockout_mask(&mut self, c: &Node) -> String {+ let filter = match &self.knockout_filter {+ Some(f) => f.clone(),+ None => {+ let f = self.fresh_id("knockout-shape");+ self.def(1, &format!("<filter id=\"{f}\" filterUnits=\"userSpaceOnUse\" {BIG}>"));+ self.def(2, "<feColorMatrix type=\"matrix\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0\"/>");+ self.def(1, "</filter>");+ self.knockout_filter = Some(f.clone());+ f+ }+ };+ let shape = if c.knockout_shape {+ c.clone()+ } else {+ let mut s = c.clone().with_mask(None);+ s.opacity = 1.0;+ s+ };+ let anonymous = std::mem::replace(&mut self.anonymous, true);+ let art = self.detached(3, |w| w.node(&shape));+ self.anonymous = anonymous;+ let mid = self.fresh_id("knockout");+ self.def(1, &format!("<mask id=\"{mid}\" {MASK} {BIG}>"));+ self.def(2, &format!("<rect {BIG} fill=\"white\"/>"));+ self.def(2, &format!("<g filter=\"url(#{filter})\">"));+ self.defs.push_str(&art);+ self.def(2, "</g>");+ self.def(1, "</mask>");+ mid+ }++ /// An object, inside `<a>` when it links to a URL (Attributes panel).+ pub(super) fn node(&mut self, n: &Node) {+ let layer = usize::from(n.is_layer());+ self.layer_nest += layer;+ match n.url().filter(|_| n.visible && !self.anonymous) {+ Some(url) => {+ self.line(&format!("<a xlink:href=\"{}\">", xml_escape(url)));+ self.depth += 1;+ self.node_body(n);+ self.depth -= 1;+ self.line("</a>");+ }+ None => self.node_body(n),+ }+ self.layer_nest -= layer;+ }++ pub(super) fn node_body(&mut self, n: &Node) {+ // Hidden layers and objects are left out, unless the options keep them (hidden). Template+ // layers never print.+ if !(n.visible || self.opts.hidden_layers) {+ return;+ }+ if has_raster(&n.appearance.effects) {+ return self.filtered(n);+ }+ if let Some(m) = n.extras().mask.as_deref()+ && !m.disabled+ {+ return self.masked(n, m);+ }+ match &n.kind {+ NodeKind::Layer { template: true, .. } => {}+ NodeKind::Layer { children, clip: false, .. } | NodeKind::Group { children, clip: false } => {+ let id = self.id_attr(n);+ let a = self.attrs(&self.group_props(n));+ self.line(&format!("<g{id}{a}>"));+ self.depth += 1;+ self.group_children(n, children);+ self.depth -= 1;+ self.line("</g>");+ }+ NodeKind::Group { children, clip: true } | NodeKind::Layer { children, clip: true, .. } => {+ let Some((clip, rest)) = children.split_first() else { return };+ let cid = self.fresh_id("clip-path");+ self.def(1, &format!("<clipPath id=\"{cid}\">"));+ // The region every output clips to; with nothing to clip by, an empty clip path+ // hides the clipped art.+ if let Some((bp, rule)) = vectorcraft_effects::clip_outline(clip) {+ let d = self.path_d(&PathData::from_bezpath(&bp), self.xf);+ let r = if rule == FillRule::EvenOdd { " clip-rule=\"evenodd\"" } else { "" };+ self.def(2, &format!("<path d=\"{d}\"{r}/>"));+ }+ self.def(1, "</clipPath>");+ let id = self.id_attr(n);+ let a = self.attrs(&self.group_props(n));+ // The clipping path's fill paints behind the clipped art and its stroke over it,+ // outside the clip (the group then wraps both).+ let paint = clip.clip_paint();+ if paint.stroke.is_some() {+ self.line(&format!("<g{id}{a}>"));+ self.depth += 1;+ self.line(&format!("<g clip-path=\"url(#{cid})\">"));+ } else {+ self.line(&format!("<g{id} clip-path=\"url(#{cid})\"{a}>"));+ }+ self.depth += 1;+ if let Some(fill) = &paint.fill {+ self.node(fill);+ }+ self.group_children(n, rest);+ self.depth -= 1;+ self.line("</g>");+ if let Some(stroke) = &paint.stroke {+ // One element keeps the clipping path's id.+ let anonymous = self.anonymous;+ self.anonymous |= paint.fill.is_some();+ self.node(stroke);+ self.anonymous = anonymous;+ self.depth -= 1;+ self.line("</g>");+ }+ }+ NodeKind::Path { guide: true, .. } => {}+ NodeKind::Path { path, rule, .. } => {+ if path.is_empty() {+ return;+ }+ let d = self.path_d(path, self.xf);+ self.shape(n, &d, &[path], *rule, n.geometric_bounds());+ }+ NodeKind::Compound { children, rule } => {+ let paths: Vec<&PathData> = children.iter().filter(|c| c.visible).filter_map(|c| c.path_data()).filter(|p| !p.is_empty()).collect();+ if paths.is_empty() {+ return;+ }+ let d: Vec<String> = paths.iter().map(|p| self.path_d(p, self.xf)).collect();+ self.shape(n, &d.join(" "), &paths, *rule, n.geometric_bounds());+ }+ NodeKind::Text(t) => self.text_node(n, t),+ NodeKind::Image(im) => {+ let id = self.id_attr(n);+ let m = self.matrix(self.xf * im.xf);+ let a = self.attrs(&css::transparency(n));+ if let Some(shared) = self.shared_images.get(&(im.key.clone(), im.width, im.height)) {+ let shared = shared.clone();+ self.line(&format!("<use{id} transform=\"{m}\"{a} xlink:href=\"#{shared}\"/>"));+ return;+ }+ let Some(href) = self.image_href(im) else { return };+ self.line(&format!(+ "<image{id} width=\"{}\" height=\"{}\" transform=\"{m}\" preserveAspectRatio=\"none\"{a} xlink:href=\"{}\"/>",+ im.width,+ im.height,+ xml_escape(&href)+ ));+ }+ NodeKind::SymbolInstance { symbol, xf } => {+ let doc = self.doc;+ let Some(sym) = doc.symbols.iter().find(|s| s.name == *symbol) else { return };+ if self.symbol_nest > MAX_SYMBOL_NEST {+ return;+ }+ let id = self.id_attr(n);+ let a = self.attrs(&css::transparency(n));+ if let Some(def) = self.symbol_use(sym, n, *xf) {+ let m = self.xf * *xf;+ let tr = if m == Affine::IDENTITY { String::new() } else { format!(" transform=\"{}\"", self.matrix(m)) };+ self.line(&format!("<use{id} xlink:href=\"#{def}\"{tr}{a}/>"));+ return;+ }+ // An instance of its own: the (stained) art moved by the instance, its pattern+ // paints and unlinked masks left in place as on the canvas.+ let mut art = vectorcraft_brush::instance_art(&sym.art, n);+ let moved = self.instance_xf * *xf;+ if moved.determinant().abs() > 1e-12 {+ pin_to_page(&mut art, moved.inverse());+ }+ let saved = (self.xf, self.instance_xf);+ self.xf = saved.0 * *xf;+ self.instance_xf = moved;+ self.line(&format!("<g{id}{a}>"));+ self.depth += 1;+ // The symbol's art is the instance's own picture, outside any knockout around it.+ let knockout = std::mem::take(&mut self.knockout);+ self.symbol_nest += 1;+ self.node(&art);+ self.symbol_nest -= 1;+ self.knockout = knockout;+ self.depth -= 1;+ self.line("</g>");+ (self.xf, self.instance_xf) = saved;+ }+ // Live blends/envelopes/meshes export their evaluated (expanded) form.+ NodeKind::Blend { .. }+ | NodeKind::Envelope { .. }+ | NodeKind::Mesh(_)+ | NodeKind::Repeat(_)+ | NodeKind::PlacedDocument(_)+ | NodeKind::Intertwine { .. } => {+ let g = vectorcraft_effects::expand_live_deep(Some(self.doc), n);+ self.share_images(&g);+ self.node_body(&g);+ }+ }+ }++ /// The id of the `<symbol>` def instance `inst` (transform `xf`) can `<use>`, written on first+ /// use. `None` when the instance needs its own copy of the art: stained by its fill, or moved+ /// by a transform under which the def would not look as the canvas paints it ([`Reuse`]).+ fn symbol_use(&mut self, sym: &vectorcraft_doc::Symbol, inst: &Node, xf: Affine) -> Option<String> {+ // SVG Tiny has no `<symbol>`.+ if self.tiny() || vectorcraft_brush::stain(inst).is_some() {+ return None;+ }+ if !self.symbols.contains_key(&sym.name) {+ let reuse = Reuse::of(self.doc, &sym.art);+ self.symbols.insert(sym.name.clone(), SymbolDef { id: None, reuse });+ }+ let def = self.symbols.get(&sym.name)?;+ if !def.reuse.allows(xf) {+ return None;+ }+ if let Some(id) = &def.id {+ return Some(id.clone());+ }+ // The art in symbol space, as its own picture: no knockout around it, and no object ids+ // (every instance shows it).+ let id = self.unique_id(&sanitize_id(&sym.name));+ let saved = (self.xf, self.instance_xf, std::mem::take(&mut self.knockout), std::mem::take(&mut self.names), self.anonymous);+ (self.xf, self.instance_xf, self.anonymous) = (Affine::IDENTITY, Affine::IDENTITY, false);+ self.symbol_nest += 1;+ let art = self.detached(3, |w| w.node(&sym.art));+ self.symbol_nest -= 1;+ (self.xf, self.instance_xf, self.knockout, self.names, self.anonymous) = saved;+ // The symbol's name, when the id had to differ from it, comes back on import.+ let name = if id == sym.name {+ String::new()+ } else if valid_xml_value(&sym.name) {+ format!(" data-name=\"{}\"", xml_attr_escape(&sym.name))+ } else {+ self.warn("Symbol names containing invalid XML characters were left out of SVG name attributes");+ String::new()+ };+ self.def(1, &format!("<symbol id=\"{id}\"{name} overflow=\"visible\">"));+ self.defs.push_str(&art);+ self.def(1, "</symbol>");+ if let Some(def) = self.symbols.get_mut(&sym.name) {+ def.id = Some(id.clone());+ }+ Some(id)+ }+}++/// A shape's paths as one path (document space).+pub(super) fn doc_path(paths: &[&PathData]) -> BezPath {+ let mut bp = BezPath::new();+ for p in paths {+ bp.extend(p.to_bezpath());+ }+ bp+}++/// Does `n` paint opaquely wherever it paints (no transparency, blending, masks or effects in+/// it)? Anything this can't tell is taken as not.+fn paints_opaque(n: &Node) -> bool {+ use vectorcraft_doc::{AppearanceItem, NodeKind};+ let paint = |p: &Paint| match p {+ Paint::None | Paint::Solid { .. } => true,+ Paint::Gradient(g) => g.gradient.stops.iter().all(|s| s.opacity >= 1.0),+ _ => false,+ };+ let items = n.appearance.items.iter().all(|i| match i {+ AppearanceItem::Fill(f) => !f.visible || (f.opacity >= 1.0 && f.blend == BlendMode::Normal && f.effects.is_empty() && paint(&f.paint)),+ // Brush art draws as pieces with opacities of their own (bristles vary theirs).+ AppearanceItem::Stroke(s) => {+ !s.visible || (s.opacity >= 1.0 && s.blend == BlendMode::Normal && s.effects.is_empty() && s.brush.is_none() && paint(&s.paint))+ }+ });+ let own = n.opacity >= 1.0 && n.blend == BlendMode::Normal && n.extras().mask.is_none() && n.appearance.effects.is_empty() && items;+ own && match &n.kind {+ NodeKind::Path { .. } => true,+ NodeKind::Group { children, .. } | NodeKind::Compound { children, .. } => children.iter().all(|c| paints_opaque(c)),+ NodeKind::Mesh(m) => m.points.iter().all(|p| p.opacity >= 1.0),+ _ => false,+ }+}diff --git a/crates/svg/src/export/output.rs b/crates/svg/src/export/output.rsnew file mode 100644index 000000000..2197b2682--- /dev/null+++ b/crates/svg/src/export/output.rs@@ -0,0 +1,422 @@+use super::*;++/// XML 1.0 literal attribute whitespace is normalized to spaces; references retain the value.+pub(super) fn xml_attr_escape(s: &str) -> String {+ xml_escape(s).replace('\t', "	").replace('\n', " ").replace('\r', " ")+}++/// Escape type for XML content. Characters XML 1.0 does not allow are dropped, except the line+/// and page breaks (U+000B, U+000C) other apps paste, which become spaces.+pub(super) fn xml_text(s: &str) -> String {+ let s: String = s+ .chars()+ .filter_map(|c| match c {+ '\u{b}' | '\u{c}' => Some(' '),+ c if valid_xml_value(c.encode_utf8(&mut [0; 4])) => Some(c),+ _ => None,+ })+ .collect();+ xml_escape(&s)+}++pub(super) fn valid_xml_value(s: &str) -> bool {+ s.chars().all(|c| matches!(c, '\t' | '\n' | '\r' | '\u{20}'..='\u{d7ff}' | '\u{e000}'..='\u{fffd}' | '\u{10000}'..='\u{10ffff}'))+}++/// An XML name without a colon (an NCName): a letter or `_`, then [`xml_name_char`]s.+fn xml_ncname(s: &str) -> bool {+ let mut chars = s.chars();+ chars.next().is_some_and(|c| c.is_alphabetic() || c == '_') && chars.all(xml_name_char)+}++/// Namespace-free XML 1.0 NameChar. The fixed `data-` prefix supplies NameStartChar.+fn xml_name_char(c: char) -> bool {+ matches!(c,+ 'A'..='Z' | 'a'..='z' | '0'..='9' | '_' | '-' | '.' | '\u{b7}' |+ '\u{c0}'..='\u{d6}' | '\u{d8}'..='\u{f6}' | '\u{f8}'..='\u{2ff}' |+ '\u{300}'..='\u{37d}' | '\u{37f}'..='\u{1fff}' | '\u{200c}'..='\u{200d}' |+ '\u{203f}'..='\u{2040}' | '\u{2070}'..='\u{218f}' | '\u{2c00}'..='\u{2fef}' |+ '\u{3001}'..='\u{d7ff}' | '\u{f900}'..='\u{fdcf}' | '\u{fdf0}'..='\u{fffd}' |+ '\u{10000}'..='\u{effff}'+ )+}++/// Write every character of `s` beyond ISO 8859-1 as a character reference. Called only when+/// names fit Latin-1, so references occur in values, text or style sheets.+pub(super) fn latin1_refs(s: &mut String) {+ if s.chars().all(|c| u32::from(c) < 0x100) {+ return;+ }+ let mut o = String::with_capacity(s.len() + 64);+ for c in s.chars() {+ if u32::from(c) < 0x100 {+ o.push(c);+ } else {+ let _ = write!(o, "&#x{:X};", u32::from(c));+ }+ }+ *s = o;+}++/// A CSS declaration block as the literal value of an `<!ENTITY>`: quotes, `%` and markup+/// characters become references that still read as themselves inside the `style` attribute.+pub(super) fn entity_value(decl: &str) -> String {+ let mut o = String::with_capacity(decl.len());+ for c in decl.chars() {+ match c {+ '"' => o.push_str("""),+ '%' => o.push_str("%"),+ // Doubly escaped: the entity's replacement text is parsed again where it is used.+ '&' => o.push_str("&#38;"),+ '<' => o.push_str("&#60;"),+ _ => o.push(c),+ }+ }+ o+}++/// The Dublin Core terms File Info writes to `<metadata>`: the format, title, author (creator),+/// description, each keyword (subject), copyright notice and URL (rights) and created date, the+/// empty ones left out.+fn dublin_core(doc: &Document) -> Vec<(&'static str, String)> {+ let info = &doc.metadata;+ let mut terms = vec![("format", "image/svg+xml".to_string())];+ let created = info.created.map(vectorcraft_doc::metadata::iso8601).unwrap_or_default();+ let fields = [("title", doc.title.as_str()), ("creator", info.author.as_str()), ("description", info.description.as_str())];+ let rights = [("rights", info.copyright_notice.as_str()), ("rights", info.copyright_url.as_str()), ("date", created.as_str())];+ let keywords = info.keywords.iter().map(|k| ("subject", k.as_str()));+ terms.extend(fields.into_iter().chain(keywords).chain(rights).filter(|(_, v)| !v.trim().is_empty()).map(|(k, v)| (k, v.to_string())));+ terms+}++/// Turn an object name into a valid, readable XML id.+pub(crate) fn sanitize_id(name: &str) -> String {+ let mut s: String = name.trim().chars().map(|c| if c.is_alphanumeric() || c == '-' || c == '_' || c == '.' { c } else { '_' }).collect();+ if s.is_empty() || !s.starts_with(|c: char| c.is_alphabetic() || c == '_') {+ s.insert(0, '_');+ }+ s+}++impl Writer<'_> {+ /// Writing the SVG Tiny 1.2 profile?+ pub(super) fn tiny(&self) -> bool {+ self.opts.profile == Profile::Tiny12+ }++ pub(super) fn num(&self, v: f64) -> String {+ fmt_num(v, self.opts.decimals)+ }++ pub(super) fn indent(&self, depth: usize) -> String {+ if self.opts.minify { String::new() } else { " ".repeat(depth) }+ }++ pub(super) fn line(&mut self, s: &str) {+ let ind = self.indent(self.depth);+ self.body.push_str(&ind);+ self.body.push_str(s);+ if !self.opts.minify {+ self.body.push('\n');+ }+ }++ pub(super) fn def(&mut self, depth: usize, s: &str) {+ let ind = self.indent(depth + 1);+ self.defs.push_str(&ind);+ self.defs.push_str(s);+ if !self.opts.minify {+ self.defs.push('\n');+ }+ }++ pub(super) fn fresh_id(&mut self, prefix: &str) -> String {+ let mut i = 1;+ loop {+ let id = format!("{}{prefix}-{i}", self.id_prefix);+ if self.used_ids.insert(id.clone()) {+ return id;+ }+ i += 1;+ }+ }++ /// `base` (with the unique prefix) if free, else `base-2`, `base-3`…+ pub(super) fn unique_id(&mut self, base: &str) -> String {+ let base = format!("{}{base}", self.id_prefix);+ if self.used_ids.insert(base.clone()) {+ return base;+ }+ let next = self.next_suffix.entry(base.clone()).or_insert(2);+ loop {+ let cand = format!("{base}-{next}");+ *next += 1;+ if self.used_ids.insert(cand.clone()) {+ return cand;+ }+ }+ }++ /// Reserve ids for every named object up front so generated def ids never collide with them.+ pub(super) fn assign_name_ids(&mut self) {+ if self.opts.object_ids == ObjectIds::Minimal {+ return;+ }+ let mut named: Vec<(NodeId, String)> = Vec::new();+ self.doc.walk(|n| {+ if let Some(name) = &n.name {+ named.push((n.id, sanitize_id(name)));+ }+ });+ for (id, base) in named {+ let cand = self.unique_id(&base);+ self.names.insert(id, cand);+ }+ }++ /// ` id="…"` for a named object, plus ` data-name="…"` with the name itself when the id had to+ /// differ from it (spaces, punctuation, duplicates, the unique prefix).+ /// The id of `n`'s element (with its name when the id isn't it), then the object's own data+ /// as `data-*` attributes. Sublayers also retain their import marker.+ pub(super) fn id_attr(&mut self, n: &Node) -> String {+ if self.anonymous {+ return String::new();+ }+ let mut out = self.names.get(&n.id).map_or_else(String::new, |id| format!(" id=\"{}\"", xml_escape(id)));+ if let (Some(id), Some(name)) = (self.names.get(&n.id), n.name.as_deref())+ && name != id+ {+ if valid_xml_value(name) {+ out.push_str(&format!(" data-name=\"{}\"", xml_attr_escape(name)));+ } else {+ self.warn("Object names containing invalid XML characters were left out of SVG name attributes");+ }+ }+ // Preserve sublayer identity independently of object data attributes.+ if !out.is_empty() && n.is_layer() && self.layer_nest > 1 {+ out.push_str(&format!(" {}=\"sublayer\"", crate::import::SUBLAYER));+ }+ let mut keys = HashSet::new();+ for (k, v) in n.extras().attrs.as_deref().map_or(&[][..], |a| a.data.as_slice()) {+ // Ours (`name`, `vc-…`) are written by the export itself.+ if k == "name" || k.starts_with("vc-") {+ continue;+ }+ if k.is_empty() || !k.chars().all(xml_name_char) || !valid_xml_value(v) {+ self.warn("Data attributes with invalid XML names or characters were left out of SVG");+ continue;+ }+ // Native data is an ordered list. Keep the first valid value of each key.+ if !keys.insert(k.as_str()) {+ self.warn("Repeated data attribute keys were written only once in SVG");+ continue;+ }+ self.non_latin1_names |= k.chars().any(|c| u32::from(c) > 0xff);+ out.push_str(&format!(" data-{k}=\"{}\"", xml_attr_escape(v)));+ }+ self.foreign_attrs(n, &mut out);+ self.event_attrs(n, &mut out);+ out+ }++ /// `n`'s attributes in other applications' namespaces (`plotter:pen="2"`), added to `out`.+ /// Each namespace is declared once, on the root, under the prefix the file gave it unless the+ /// export uses that prefix itself or for another namespace ([`Writer::foreign_prefix`]).+ fn foreign_attrs(&mut self, n: &Node, out: &mut String) {+ let attrs = n.extras().attrs.as_deref().map_or(&[][..], |a| a.foreign.as_slice());+ let mut seen = HashSet::new();+ for a in attrs {+ if !xml_ncname(&a.prefix) || !xml_ncname(&a.name) || a.ns.is_empty() || !valid_xml_value(&a.ns) || !valid_xml_value(&a.value) {+ self.warn("Attributes of other applications with invalid XML names or characters were left out of SVG");+ continue;+ }+ // Native data is a list: one attribute per namespace and name.+ if !seen.insert((a.ns.as_str(), a.name.as_str())) {+ self.warn("Repeated attributes of other applications were written only once in SVG");+ continue;+ }+ let prefix = self.foreign_prefix(&a.ns, &a.prefix);+ self.non_latin1_names |= prefix.chars().chain(a.name.chars()).any(|c| u32::from(c) > 0xff);+ out.push_str(&format!(" {prefix}:{}=\"{}\"", a.name, xml_attr_escape(&a.value)));+ }+ }++ /// The prefix namespace `ns` is written under: `wanted` (the file's), else `wanted2`,+ /// `wanted3`… when the export's own prefixes or another namespace already have it. XML keeps+ /// prefixes starting with `xml` for itself: those become `ns`, `ns2`…+ fn foreign_prefix(&mut self, ns: &str, wanted: &str) -> String {+ if let Some(p) = self.foreign_ns.get(ns) {+ return p.clone();+ }+ const OURS: [&str; 5] = ["svg", "xlink", "rdf", "dc", "vectorcraft"];+ let base = if wanted.to_ascii_lowercase().starts_with("xml") { "ns" } else { wanted };+ let taken = |p: &str| OURS.contains(&p) || self.foreign_ns.values().any(|q| q == p);+ let mut prefix = base.to_string();+ let mut k = 2;+ while taken(&prefix) {+ prefix = format!("{base}{k}");+ k += 1;+ }+ self.foreign_ns.insert(ns.to_string(), prefix.clone());+ prefix+ }++ /// Window › SVG Interactivity: `n`'s events as event attributes (`onclick="…"`), added to+ /// `out`. The SVG Tiny 1.2 profile leaves them out with a warning.+ fn event_attrs(&mut self, n: &Node, out: &mut String) {+ let events = n.extras().attrs.as_deref().map_or(&[][..], |a| a.events.as_slice());+ if events.is_empty() {+ return;+ }+ if self.tiny() {+ self.warn("SVG Tiny 1.2 has no event attributes: SVG Interactivity events were left out");+ return;+ }+ let mut seen = HashSet::new();+ for (event, script) in events {+ // Native data can name anything: only the panel's events are written, once each.+ if !SVG_EVENTS.contains(&event.as_str()) || !valid_xml_value(script) {+ self.warn("SVG Interactivity events with unknown names or invalid XML characters were left out of SVG");+ continue;+ }+ if !seen.insert(event.as_str()) {+ self.warn("Repeated SVG Interactivity events were written only once in SVG");+ continue;+ }+ out.push_str(&format!(" {event}=\"{}\"", xml_attr_escape(script)));+ }+ }++ pub(super) fn matrix(&self, m: Affine) -> String {+ let c = m.as_coeffs();+ format!("matrix({} {} {} {} {} {})", self.num(c[0]), self.num(c[1]), self.num(c[2]), self.num(c[3]), self.num(c[4]), self.num(c[5]))+ }++ /// Style properties as attributes, an inline style, or a CSS class, per the styling option.+ pub(super) fn attrs(&mut self, props: &Props) -> String {+ if props.is_empty() {+ return String::new();+ }+ // SVG Tiny has presentation attributes alone.+ let styling = if self.tiny() { Styling::PresentationAttributes } else { self.opts.styling };+ match styling {+ Styling::PresentationAttributes => {+ // CSS-only properties go in a style attribute (SVG Tiny has none: left out).+ let (style, attrs): (Vec<_>, Vec<_>) = props.iter().partition(|(k, _)| {+ matches!(*k, "mix-blend-mode" | "isolation" | "font-feature-settings" | "font-variation-settings" | "font-kerning")+ });+ let mut s: String = attrs.iter().map(|(k, v)| format!(" {k}=\"{}\"", xml_escape(v))).collect();+ if !style.is_empty() {+ if self.tiny() {+ self.warn("SVG Tiny 1.2 has no style sheets: blend modes, isolation, font features and font variation settings are left out");+ } else {+ s.push_str(&format!(" style=\"{}\"", xml_escape(&css::declarations(style))));+ }+ }+ s+ }+ Styling::InlineStyle => format!(" style=\"{}\"", xml_escape(&css::declarations(props))),+ Styling::StyleEntities => format!(" style=\"&st{};\"", self.class(css::declarations(props))),+ Styling::InternalCss => {+ let i = self.class(css::declarations(props));+ format!(" class=\"{}cls-{i}\"", self.id_prefix)+ }+ }+ }++ /// The 1-based number of a distinct declaration block (a CSS class or a style entity).+ fn class(&mut self, decl: String) -> usize {+ if let Some(&i) = self.class_ids.get(decl.as_str()) {+ return i;+ }+ let i = self.classes.len() + 1;+ self.class_ids.insert(decl.clone(), i);+ self.classes.push(decl);+ i+ }++ /// `<metadata>`: the Dublin Core terms of File Info ([`ExportOptions::metadata`]) and the+ /// native document ([`ExportOptions::preserve_editing`]) with the [`body_hash`] of the markup+ /// around this element.+ pub(super) fn metadata(&self, out: &mut String, native: Option<(&[u8], String)>) {+ if !self.opts.metadata && native.is_none() {+ return;+ }+ let nl = if self.opts.minify { "" } else { "\n" };+ let mut line = |depth: usize, s: &str| {+ out.push_str(&self.indent(depth));+ out.push_str(s);+ out.push_str(nl);+ };+ line(1, "<metadata>");+ if self.opts.metadata {+ line(2, "<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">");+ line(3, "<rdf:Description rdf:about=\"\">");+ for (term, value) in dublin_core(self.doc) {+ line(4, &format!("<dc:{term}>{}</dc:{term}>", xml_escape(&value)));+ }+ line(3, "</rdf:Description>");+ line(2, "</rdf:RDF>");+ }+ if let Some((bytes, hash)) = native {+ line(+ 2,+ &format!(+ "<vectorcraft:document xmlns:vectorcraft=\"{EDITING_NS}\" hash=\"{hash}\"><![CDATA[{}]]></vectorcraft:document>",+ base64_encode(bytes)+ ),+ );+ }+ line(1, "</metadata>");+ }++ pub(super) fn path_d(&self, p: &PathData, m: Affine) -> String {+ let mut s = String::new();+ // Each point as "x y", appended in place (no string per number or per point).+ let dec = self.opts.decimals;+ let pt = |s: &mut String, p: Point| {+ let p = m * p;+ crate::push_num(s, p.x, dec);+ s.push(' ');+ crate::push_num(s, p.y, dec);+ };+ for sp in &p.subpaths {+ let n = sp.anchors.len();+ if n == 0 {+ continue;+ }+ if !s.is_empty() {+ s.push(' ');+ }+ s.push('M');+ pt(&mut s, sp.anchors[0].p);+ for i in 0..sp.segment_count() {+ let (a, b) = (&sp.anchors[i], &sp.anchors[(i + 1) % n]);+ if sp.segment_is_line(i) {+ if sp.closed && i == n - 1 {+ break;+ }+ s.push_str(" L");+ pt(&mut s, b.p);+ } else {+ s.push_str(" C");+ pt(&mut s, a.h_out);+ s.push(' ');+ pt(&mut s, b.h_in);+ s.push(' ');+ pt(&mut s, b.p);+ }+ }+ if sp.closed {+ s.push_str(" Z");+ }+ }+ s+ }++ pub(super) fn warn(&mut self, w: &str) {+ if !self.warnings.iter().any(|x| x == w) {+ self.warnings.push(w.to_string());+ }+ }+}diff --git a/crates/svg/src/export/paint.rs b/crates/svg/src/export/paint.rsnew file mode 100644index 000000000..412098b72--- /dev/null+++ b/crates/svg/src/export/paint.rs@@ -0,0 +1,503 @@+use super::nodes::{MASK, doc_path};+use super::output::sanitize_id;+use super::*;++/// Image `b` as SVG viewers show it: PNG, JPEG, GIF, WebP and SVG as they are, other formats (a+/// CMYK TIFF) as PNG.+fn web_image(b: &ImageBlob) -> std::borrow::Cow<'_, ImageBlob> {+ use std::borrow::Cow;+ if matches!(b.mime.as_str(), "image/png" | "image/jpeg" | "image/jpg" | "image/gif" | "image/webp" | "image/svg+xml") {+ return Cow::Borrowed(b);+ }+ let png = image::load_from_memory(&b.bytes).ok().and_then(|img| {+ let mut out = Vec::new();+ img.write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png).ok()?;+ Some(out)+ });+ png.map_or(Cow::Borrowed(b), |png| Cow::Owned(ImageBlob::png(png)))+}++/// The usual file extension of an image MIME type.+fn image_ext(mime: &str) -> &str {+ match mime {+ "image/jpeg" => "jpg",+ "image/svg+xml" => "svg",+ m => m.strip_prefix("image/").filter(|e| !e.is_empty() && e.chars().all(|c| c.is_ascii_alphanumeric())).unwrap_or("bin"),+ }+}++/// How one stroke is written.+pub(super) enum StrokePlan {+ /// Its brush art (document space).+ Brush(Vec<Node>),+ Written(Written),+}++impl Writer<'_> {+ /// The `href` of image `im`: its file with [`ImageMode::Link`] (or when its pixels are+ /// missing), else its bytes. `None` when it has neither.+ pub(super) fn image_href(&mut self, im: &vectorcraft_doc::ImageObject) -> Option<String> {+ let (doc, link) = (self.doc, self.opts.images == ImageMode::Link);+ match (im.link.as_ref().filter(|_| link), doc.image_blob(im)) {+ (Some(l), _) => Some(l.path.clone()),+ (None, Some(b)) if !b.bytes.is_empty() => Some(self.blob_href(&web_image(b))),+ _ => im.link.as_ref().map(|l| l.path.clone()),+ }+ }++ /// Images drawn more than once in `art` (the pieces of a distorted image) go into the defs+ /// once; each piece then draws them with `<use>`.+ pub(super) fn share_images(&mut self, art: &Node) {+ // Each image's count and its first piece, which shows what they all show.+ let mut seen: HashMap<(String, u32, u32), (usize, vectorcraft_doc::ImageObject)> = HashMap::new();+ art.walk(&mut |c| {+ if let NodeKind::Image(im) = &c.kind {+ seen.entry((im.key.clone(), im.width, im.height)).or_insert_with(|| (0, (**im).clone())).0 += 1;+ }+ });+ let mut repeated: Vec<_> = seen.into_iter().filter(|(k, (n, _))| *n > 1 && !self.shared_images.contains_key(k)).collect();+ repeated.sort_by(|a, b| a.0.cmp(&b.0));+ for ((key, width, height), (_, im)) in repeated {+ let Some(href) = self.image_href(&im) else { continue };+ let id = self.fresh_id("image");+ self.def(+ 0,+ &format!(+ "<image id=\"{id}\" width=\"{width}\" height=\"{height}\" preserveAspectRatio=\"none\" xlink:href=\"{}\"/>",+ xml_escape(&href)+ ),+ );+ self.shared_images.insert((key, width, height), id);+ }+ }++ /// A fill or stroke value. Gradients resolve unset geometry against `bounds` (the space+ /// [`Self::xf`] maps into user space, as the renderer does).+ pub(super) fn paint(&mut self, p: &Paint, bounds: Option<Rect>) -> String {+ match p {+ Paint::None => "none".into(),+ Paint::Pattern { pattern, xf } => match self.pattern_def(pattern, *xf) {+ Some(id) => format!("url(#{id})"),+ None => "none".into(),+ },+ Paint::Solid { color, .. } => color.to_hex(),+ Paint::Gradient(g) => format!("url(#{})", self.gradient_def(g, bounds.unwrap_or(Rect::new(0.0, 0.0, 1.0, 1.0)))),+ }+ }++ /// A `<pattern>` def for pattern `name` placed by `xf`: one period (super-tile) of the tiling,+ /// with every instance that reaches into it.+ fn pattern_def(&mut self, name: &str, xf: Affine) -> Option<String> {+ let doc = self.doc;+ let def = doc.pattern(name)?;+ let m = self.xf * xf;+ let key = format!("{name}|{:?}", m.as_coeffs());+ if let Some(id) = self.patterns.get(&key) {+ return Some(id.clone());+ }+ if self.pattern_nest > 4 {+ return None;+ }+ let id = self.fresh_id("pattern");+ self.patterns.insert(key, id.clone());+ let (pw, ph) = def.period();+ let (saved_body, saved_xf, saved_depth) = (std::mem::take(&mut self.body), self.xf, self.depth);+ self.depth = 3;+ self.pattern_nest += 1;+ for o in def.offsets_covering(Rect::new(0.0, 0.0, pw, ph)) {+ self.xf = def.instance_xf(o);+ for a in &def.art {+ self.node(a);+ }+ }+ self.pattern_nest -= 1;+ let content = std::mem::replace(&mut self.body, saved_body);+ self.xf = saved_xf;+ self.depth = saved_depth;+ let head = format!(+ "<pattern id=\"{id}\" patternUnits=\"userSpaceOnUse\" width=\"{}\" height=\"{}\" patternTransform=\"{}\">",+ self.num(pw),+ self.num(ph),+ self.matrix(m)+ );+ self.def(1, &head);+ self.defs.push_str(&content);+ self.def(1, "</pattern>");+ Some(id)+ }++ /// The id of a `<linearGradient>`/`<radialGradient>` def for `g` resolved against `bounds`.+ /// Identical gradients share one def; a gradient from a swatch takes the swatch's name as its+ /// id. A midpoint other than halfway is written as an extra stop marked `data-vc-midpoint`+ /// (what import turns back into a midpoint).+ fn gradient_def(&mut self, g: &GradientPaint, bounds: Rect) -> String {+ if g.gradient.kind == GradientKind::Freeform {+ // Object fills and strokes are images (see `raster_paint`); characters' paints aren't.+ self.warn("freeform gradients on characters are written as linear gradients");+ }+ let mut geom = g.resolve(bounds);+ geom.transform(self.xf, g.gradient.kind);+ let (s, e) = (geom.start, geom.end);+ // An off-centre focal point: `fx`/`fy`, in the gradient's own (unsquashed) space.+ let focal = |w: &Self, f: Point| format!(" fx=\"{}\" fy=\"{}\"", w.num(f.x), w.num(f.y));+ let (tag, prefix, attrs) = match g.gradient.kind {+ GradientKind::Radial => {+ let r = self.num((e - s).hypot());+ let attrs = if (geom.aspect - 1.0).abs() < 1e-9 {+ let f = geom.focal.map(|f| focal(self, f)).unwrap_or_default();+ format!(" cx=\"{}\" cy=\"{}\" r=\"{r}\"{f}", self.num(s.x), self.num(s.y))+ } else {+ let v = e - s;+ let m = Affine::translate(s.to_vec2()) * Affine::rotate(v.y.atan2(v.x)) * Affine::scale_non_uniform(1.0, geom.aspect);+ let f = geom.focal.map(|f| focal(self, m.inverse() * f)).unwrap_or_default();+ format!(" cx=\"0\" cy=\"0\" r=\"{r}\"{f} gradientTransform=\"{}\"", self.matrix(m))+ };+ ("radialGradient", "radial-gradient", attrs)+ }+ GradientKind::Linear | GradientKind::Freeform => (+ "linearGradient",+ "linear-gradient",+ format!(" x1=\"{}\" y1=\"{}\" x2=\"{}\" y2=\"{}\"", self.num(s.x), self.num(s.y), self.num(e.x), self.num(e.y)),+ ),+ };+ let stops: Vec<String> = g+ .gradient+ .expanded()+ .map(|(offset, c, o, mid)| {+ let op = if o < 1.0 { format!(" stop-opacity=\"{}\"", fmt_num(o as f64, 3)) } else { String::new() };+ let mid = mid.map(|m| format!(" data-vc-midpoint=\"{}\"", fmt_num(m as f64, 4))).unwrap_or_default();+ format!("<stop offset=\"{}\" stop-color=\"{}\"{op}{mid}/>", fmt_num(offset as f64, 4), c.to_hex())+ })+ .collect();+ let key = format!("{tag}{attrs}{}", stops.concat());+ if let Some(id) = self.gradients.get(&key) {+ return id.clone();+ }+ let id = match &g.swatch {+ Some(name) => self.unique_id(&sanitize_id(name)),+ None => self.fresh_id(prefix),+ };+ self.gradients.insert(key, id.clone());+ self.def(1, &format!("<{tag} id=\"{id}\"{attrs} gradientUnits=\"userSpaceOnUse\">"));+ for stop in &stops {+ self.def(2, stop);+ }+ self.def(1, &format!("</{tag}>"));+ id+ }++ pub(super) fn fill_props(&mut self, f: &FillLayer, rule: FillRule, bounds: Option<Rect>, p: &mut Props) {+ let paint = self.paint(&f.paint, bounds);+ p.push(("fill", paint));+ if f.opacity < 1.0 {+ p.push(("fill-opacity", fmt_num(f.opacity as f64, 3)));+ }+ if rule == FillRule::EvenOdd {+ p.push(("fill-rule", "evenodd".into()));+ }+ }++ pub(super) fn stroke_props(&mut self, s: &StrokeLayer, width: f64, bounds: Option<Rect>, p: &mut Props) {+ let paint = self.paint(&s.paint, bounds);+ p.push(("stroke", paint));+ if s.opacity < 1.0 {+ p.push(("stroke-opacity", fmt_num(s.opacity as f64, 3)));+ }+ if (width - 1.0).abs() > 1e-9 {+ p.push(("stroke-width", self.num(width)));+ }+ match s.cap {+ LineCap::Butt => {}+ LineCap::Round => p.push(("stroke-linecap", "round".into())),+ LineCap::Square => p.push(("stroke-linecap", "square".into())),+ }+ match s.join {+ LineJoin::Miter => {+ if (s.miter_limit - 4.0).abs() > 1e-9 {+ p.push(("stroke-miterlimit", self.num(s.miter_limit)));+ }+ }+ LineJoin::Round => p.push(("stroke-linejoin", "round".into())),+ LineJoin::Bevel => p.push(("stroke-linejoin", "bevel".into())),+ }+ if let Some(d) = &s.dash+ && d.is_dashed()+ {+ p.push(("stroke-dasharray", d.pattern.iter().map(|v| self.num(*v)).collect::<Vec<_>>().join(" ")));+ if d.offset != 0.0 {+ p.push(("stroke-dashoffset", self.num(d.offset)));+ }+ }+ }++ /// How stroke `st` is written (`bp`: the shape in document space, built on first use from+ /// `paths`): its brush art, or a plain stroke or filled outlines matching the canvas.+ pub(super) fn stroke_plan(&mut self, st: &StrokeLayer, bp: &mut Option<BezPath>, paths: &[&PathData]) -> StrokePlan {+ if stroke::is_plain(st) {+ return StrokePlan::Written(stroke::for_writer(&BezPath::new(), st));+ }+ let bp = bp.get_or_insert_with(|| doc_path(paths));+ let doc = self.doc;+ let brushes = self.brushes.get_or_insert_with(|| vectorcraft_brush::library(doc));+ match st.brush.as_deref().and_then(|name| brushes.iter().find(|b| b.name == name)) {+ Some(b) => StrokePlan::Brush(vectorcraft_brush::stroke_pieces(doc, b, bp, st)),+ None => StrokePlan::Written(stroke::for_writer(bp, st)),+ }+ }++ /// The `clip-path` (inside) or `mask` (outside) attribute that keeps an aligned stroke on its+ /// side of the shape `d`; `reach` (document space) is what the stroke covers.+ pub(super) fn side_attr(&mut self, side: Option<StrokeAlign>, d: &str, rule: FillRule, reach: Rect) -> String {+ match side {+ None | Some(StrokeAlign::Center) => String::new(),+ Some(StrokeAlign::Inside) => {+ let cid = self.fresh_id("clip-path");+ let r = if rule == FillRule::EvenOdd { " clip-rule=\"evenodd\"" } else { "" };+ self.def(1, &format!("<clipPath id=\"{cid}\">"));+ self.def(2, &format!("<path d=\"{d}\"{r}/>"));+ self.def(1, "</clipPath>");+ format!(" clip-path=\"url(#{cid})\"")+ }+ Some(StrokeAlign::Outside) if self.tiny() => {+ // No masks: clipped by everything around the shape instead.+ let cid = self.fresh_id("clip-path");+ let b = self.xf.transform_rect_bbox(reach).inflate(1.0, 1.0);+ let (x0, y0, x1, y1) = (self.num(b.x0), self.num(b.y0), self.num(b.x1), self.num(b.y1));+ self.def(1, &format!("<clipPath id=\"{cid}\">"));+ self.def(2, &format!("<path d=\"M{x0} {y0} H{x1} V{y1} H{x0} Z {d}\" clip-rule=\"evenodd\"/>"));+ self.def(1, "</clipPath>");+ format!(" clip-path=\"url(#{cid})\"")+ }+ Some(StrokeAlign::Outside) => {+ let mid = self.fresh_id("mask");+ let b = self.xf.transform_rect_bbox(reach).inflate(1.0, 1.0);+ let (x, y, w, h) = (self.num(b.x0), self.num(b.y0), self.num(b.width()), self.num(b.height()));+ let fr = if rule == FillRule::EvenOdd { " fill-rule=\"evenodd\"" } else { "" };+ self.def(1, &format!("<mask id=\"{mid}\" {MASK} x=\"{x}\" y=\"{y}\" width=\"{w}\" height=\"{h}\">"));+ self.def(2, &format!("<rect x=\"{x}\" y=\"{y}\" width=\"{w}\" height=\"{h}\" fill=\"#fff\"/>"));+ self.def(2, &format!("<path d=\"{d}\" fill=\"#000\"{fr}/>"));+ self.def(1, "</mask>");+ format!(" mask=\"url(#{mid})\"")+ }+ }+ }++ /// The `href` of image bytes `b`: a `data:` URI, or with [`ImageMode::Link`] a file written+ /// next to the SVG, named after the bytes (image keys such as "raster-1" repeat across+ /// documents).+ pub(super) fn blob_href(&mut self, b: &ImageBlob) -> String {+ if self.opts.images != ImageMode::Link {+ return format!("data:{};base64,{}", b.mime, base64_encode(&b.bytes));+ }+ let name = format!("{}.{}", b.content_key(), image_ext(&b.mime));+ if self.linked_names.insert(name.clone()) {+ self.linked.push(LinkedImage { name: name.clone(), bytes: b.bytes.clone() });+ }+ name+ }++ /// A gradient `g` painted over `bounds` (the space [`Self::xf`] maps into user space) that is+ /// drawn as pixels ([`GradientPaint::draws_as_pixels`]) when it paints a fill (`fill`) or a+ /// stroke: an `<image>` over its painted box, clipped to `clip` (outlines in user space filled+ /// by `rule`), in a group with `props` and the `side` attribute. A freeform gradient's colour+ /// field, which SVG can't express, is sampled as the canvas samples it (at twice the box's size+ /// in points); a linear or radial gradient at the document's raster effects resolution (at most+ /// [`MAX_GRADIENT_PX`] a side), with dither's noise on a fill. Nothing is written for an empty+ /// box.+ #[allow(clippy::too_many_arguments)]+ pub(super) fn raster_paint(&mut self, g: &GradientPaint, bounds: Rect, clip: &[String], rule: FillRule, props: &Props, side: &str, fill: bool) {+ use vectorcraft_color::freeform::{grid_size, painted_box, spread_scale};+ let Some(b) = painted_box(bounds) else { return };+ let freeform = g.gradient.kind == GradientKind::Freeform;+ let (rgba, cols, rows): (Vec<u8>, u16, u16) = if freeform {+ let (cols, rows) = grid_size(b, 2.0 * b.width().max(b.height()));+ let field = g.freeform_on(b).field(spread_scale(b));+ let q = |v: f32| (v.clamp(0.0, 1.0) * 255.0).round() as u8;+ (field.grid(b, cols, rows).flat_map(|([r, g, bl], a)| [q(r), q(g), q(bl), q(a)]).collect(), cols, rows)+ } else {+ let k = self.doc.raster_effects_ppi / 72.0;+ let along = |len: f64| (len * k).ceil().clamp(1.0, MAX_GRADIENT_PX) as u16;+ let (cols, rows) = (along(b.width()), along(b.height()));+ (g.pixels(b, b, cols, rows, fill, &Color::to_rgb).flatten().collect(), cols, rows)+ };+ let mut png = Vec::new();+ let Some(img) = image::RgbaImage::from_raw(u32::from(cols), u32::from(rows), rgba) else { return };+ if img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).is_err() {+ return;+ }+ self.warn(if freeform {+ "freeform gradients are written as images clipped to their shapes"+ } else {+ "linear and radial gradients drawn as pixels are written as images clipped to their shapes"+ });+ let href = self.blob_href(&ImageBlob::new("image/png", png));+ let cid = self.fresh_id("clip-path");+ let r = if rule == FillRule::EvenOdd { " clip-rule=\"evenodd\"" } else { "" };+ self.def(1, &format!("<clipPath id=\"{cid}\">"));+ for d in clip {+ self.def(2, &format!("<path d=\"{d}\"{r}/>"));+ }+ self.def(1, "</clipPath>");+ let a = self.attrs(props);+ let nested = !side.is_empty();+ if nested {+ self.line(&format!("<g{a}{side}>"));+ self.depth += 1;+ self.line(&format!("<g clip-path=\"url(#{cid})\">"));+ } else {+ self.line(&format!("<g clip-path=\"url(#{cid})\"{a}>"));+ }+ self.depth += 1;+ let (x, y, w, h) = (self.num(b.x0), self.num(b.y0), self.num(b.width()), self.num(b.height()));+ let tr = if self.xf == Affine::IDENTITY { String::new() } else { format!(" transform=\"{}\"", self.matrix(self.xf)) };+ self.line(&format!(+ "<image x=\"{x}\" y=\"{y}\" width=\"{w}\" height=\"{h}\"{tr} preserveAspectRatio=\"none\" xlink:href=\"{}\"/>",+ xml_escape(&href)+ ));+ self.depth -= 1;+ self.line("</g>");+ if nested {+ self.depth -= 1;+ self.line("</g>");+ }+ }++ /// Raster effects (drop shadow, glows, Gaussian blur, feather) as SVG filters: one `<g filter>`+ /// per effect, the first effect innermost (the reference app's stacking order). A drop shadow+ /// with Darkness darkens the screen colors, in a CMYK document too. Photoshop-style+ /// filters have no SVG equivalent: they are left out with a warning (exports from the app turn+ /// such objects into images first).+ pub(super) fn filtered(&mut self, n: &Node) {+ let mut inner = n.clone();+ inner.appearance.effects.retain(|e| !vectorcraft_effects::is_raster(&e.id));+ let opened = self.open_filters(n, &n.appearance.effects);+ self.node_body(&inner);+ self.close_filters(opened);+ }++ /// Open one `<g filter>` per visible raster effect of `effects` (an object's, or one fill or+ /// stroke's) on `n`, outermost last effect; returns how many to close.+ pub(super) fn open_filters(&mut self, n: &Node, effects: &[vectorcraft_doc::Effect]) -> usize {+ use vectorcraft_effects::RasterFx;+ let fx = vectorcraft_effects::raster_effects(effects);+ if self.tiny() {+ if !fx.is_empty() {+ self.warn("SVG Tiny 1.2 has no filters: shadows, glows, blurs and feathers are left out");+ }+ return 0;+ }+ let bounds = n.visual_bounds_with(&self.doc.symbol_boxes());+ // An Outer Glow's silhouette grows by a quarter of a pixel of the document's raster grid first.+ let grow = 18.0 / self.doc.raster_ppi();+ let reach: f64 =+ fx.iter().map(|f| f.outset(bounds.unwrap_or_default()) + if matches!(f, RasterFx::OuterGlow { .. }) { grow } else { 0.0 }).sum::<f64>()+ + 2.0;+ let region = bounds.map(|b| self.xf.transform_rect_bbox(b).inflate(reach, reach));+ let mut opened = 0;+ for f in fx.iter().rev() {+ if matches!(f, RasterFx::Pixel(_) | RasterFx::Rasterize(_)) {+ self.warn("SVG has no pixel effects such as Radial Blur, Smart Blur or Unsharp Mask: they are left out");+ continue;+ }+ let fid = self.fresh_id("filter");+ let region_attr = match region {+ Some(r) => format!(+ " filterUnits=\"userSpaceOnUse\" x=\"{}\" y=\"{}\" width=\"{}\" height=\"{}\"",+ self.num(r.x0),+ self.num(r.y0),+ self.num(r.width()),+ self.num(r.height())+ ),+ None => String::new(),+ };+ let sd = |blur: f64| fmt_num((blur / 2.0).max(0.0), 3);+ let flood = |c: &vectorcraft_color::Color, o: f32| {+ format!("<feFlood flood-color=\"{}\" flood-opacity=\"{}\"/>", c.to_hex(), fmt_num(o as f64, 3))+ };+ let body = match f {+ // Darkness: the object blurred and moved, each color channel times 1 − darkness.+ RasterFx::DropShadow { opacity, dx, dy, blur, darkness: Some(darkness), .. } => format!(+ "<feGaussianBlur in=\"SourceGraphic\" stdDeviation=\"{}\"/><feOffset dx=\"{}\" dy=\"{}\"/><feComponentTransfer result=\"paint\"><feFuncR type=\"linear\" slope=\"{keep}\"/><feFuncG type=\"linear\" slope=\"{keep}\"/><feFuncB type=\"linear\" slope=\"{keep}\"/><feFuncA type=\"linear\" slope=\"{}\"/></feComponentTransfer><feMerge><feMergeNode in=\"paint\"/><feMergeNode in=\"SourceGraphic\"/></feMerge>",+ sd(*blur),+ self.num(*dx),+ self.num(*dy),+ fmt_num(*opacity as f64, 3),+ keep = fmt_num(1.0 - *darkness as f64, 3)+ ),+ RasterFx::DropShadow { opacity, dx, dy, blur, color, .. } => format!(+ "<feGaussianBlur in=\"SourceAlpha\" stdDeviation=\"{}\"/><feOffset dx=\"{}\" dy=\"{}\" result=\"shadow\"/>{}<feComposite in2=\"shadow\" operator=\"in\" result=\"paint\"/><feMerge><feMergeNode in=\"paint\"/><feMergeNode in=\"SourceGraphic\"/></feMerge>",+ sd(*blur),+ self.num(*dx),+ self.num(*dy),+ flood(color, *opacity)+ ),+ // The glow blurs a solid silhouette (alpha × 255 makes any alpha full) grown by a quarter raster pixel.+ RasterFx::OuterGlow { opacity, blur, color, .. } => format!(+ "<feComponentTransfer in=\"SourceAlpha\"><feFuncA type=\"linear\" slope=\"255\"/></feComponentTransfer><feMorphology operator=\"dilate\" radius=\"{}\"/><feGaussianBlur stdDeviation=\"{}\" result=\"glow\"/>{}<feComposite in2=\"glow\" operator=\"in\" result=\"paint\"/><feMerge><feMergeNode in=\"paint\"/><feMergeNode in=\"SourceGraphic\"/></feMerge>",+ fmt_num(grow, 3),+ sd(*blur),+ flood(color, *opacity)+ ),+ RasterFx::InnerGlow { opacity, blur, color, center, .. } => {+ // Edge: the blurred inverse silhouette; Center: the blurred silhouette; both clipped to the shape.+ let src = if *center {+ "<feGaussianBlur in=\"SourceAlpha\" stdDeviation=\"SD\" result=\"glow\"/>".replace("SD", &sd(*blur))+ } else {+ format!(+ "<feComponentTransfer in=\"SourceAlpha\"><feFuncA type=\"table\" tableValues=\"1 0\"/></feComponentTransfer><feGaussianBlur stdDeviation=\"{}\" result=\"glow\"/>",+ sd(*blur)+ )+ };+ format!(+ "{src}{}<feComposite in2=\"glow\" operator=\"in\"/><feComposite in2=\"SourceAlpha\" operator=\"in\" result=\"paint\"/><feMerge><feMergeNode in=\"SourceGraphic\"/><feMergeNode in=\"paint\"/></feMerge>",+ flood(color, *opacity)+ )+ }+ RasterFx::Feather { radius } => format!(+ "<feGaussianBlur in=\"SourceAlpha\" stdDeviation=\"{}\" result=\"soft\"/><feComposite in=\"SourceGraphic\" in2=\"soft\" operator=\"in\" result=\"f\"/><feComposite in=\"f\" in2=\"SourceAlpha\" operator=\"in\"/>",+ sd(*radius)+ ),+ RasterFx::GaussianBlur { radius } => format!("<feGaussianBlur in=\"SourceGraphic\" stdDeviation=\"{}\"/>", sd(*radius)),+ RasterFx::Pixel(_) | RasterFx::Rasterize(_) => continue,+ };+ // Filters composite normally: a shadow's or glow's other blend mode is recorded for import.+ let mode = match f {+ RasterFx::DropShadow { mode, .. } | RasterFx::OuterGlow { mode, .. } | RasterFx::InnerGlow { mode, .. }+ if *mode != BlendMode::Normal =>+ {+ format!(" {}=\"{}\"", crate::import::BLEND, blend_css(*mode))+ }+ _ => String::new(),+ };+ self.def(1, &format!("<filter id=\"{fid}\"{region_attr}{mode} color-interpolation-filters=\"sRGB\">{body}</filter>"));+ self.line(&format!("<g filter=\"url(#{fid})\">"));+ self.depth += 1;+ opened += 1;+ }+ opened+ }++ pub(super) fn close_filters(&mut self, opened: usize) {+ for _ in 0..opened {+ self.depth -= 1;+ self.line("</g>");+ }+ }+}++/// Most pixels along a side of a linear or radial gradient's image.+const MAX_GRADIENT_PX: f64 = 4096.0;++/// The gradient a fill (`fill`) or stroke paint is, if it is drawn as pixels+/// ([`GradientPaint::draws_as_pixels`]; SVG has no freeform gradients, for one).+pub(super) fn pixel_gradient(p: &Paint, fill: bool) -> Option<&GradientPaint> {+ match p {+ Paint::Gradient(g) if g.draws_as_pixels(fill) => Some(g),+ _ => None,+ }+}++/// Any visible raster effect (shadow, glow, blur, feather) in `effects`?+pub(super) fn has_raster(effects: &[vectorcraft_doc::Effect]) -> bool {+ effects.iter().any(|e| e.visible && vectorcraft_effects::is_raster(&e.id))+}diff --git a/crates/svg/src/export/text.rs b/crates/svg/src/export/text.rsnew file mode 100644index 000000000..7b5e55d84--- /dev/null+++ b/crates/svg/src/export/text.rs@@ -0,0 +1,806 @@+use super::output::xml_text;+use super::*;++/// `chars` (sorted) as a CSS `unicode-range` (`U+41-5A,U+61`).+fn unicode_range(chars: &BTreeSet<char>) -> String {+ let mut runs: Vec<(u32, u32)> = Vec::new();+ for c in chars.iter().map(|c| u32::from(*c)) {+ match runs.last_mut() {+ Some((_, end)) if c == *end + 1 => *end = c,+ _ => runs.push((c, c)),+ }+ }+ let one = |(a, b): (u32, u32)| if a == b { format!("U+{a:X}") } else { format!("U+{a:X}-{b:X}") };+ runs.into_iter().map(one).collect::<Vec<_>>().join(",")+}++/// The characters type uses from one face, under one `@font-face` description: the family the+/// type names and the weight, italic and width its style asks for.+pub(super) struct FontUse {+ family: String,+ weight: u16,+ italic: bool,+ /// The `font-stretch` percentage ([`css::font_stretch`]), as bits; `None` for the normal width.+ stretch: Option<u64>,+ face: Arc<FontFace>,+ chars: BTreeSet<char>,+}++impl Writer<'_> {+ /// The `<text>`/`<tspan>` properties of a character style. `space`: the text's layout bounds+ /// and the map from text space to user space, which character gradients resolve against+ /// (as on the canvas).+ fn char_props(&mut self, st: &CharStyle, space: (Rect, Affine)) -> Props {+ let decimals = self.opts.decimals;+ let len = |v: f64| fmt_num(v, decimals);+ let mut p = css::font_props(st, &len);+ // Character paints resolve in the text's space (`to_user` maps it into user space).+ let (bounds, to_user) = space;+ let saved = std::mem::replace(&mut self.xf, to_user);+ if let Paint::Gradient(g) = &st.fill+ && g.gradient.dither+ && g.gradient.kind != GradientKind::Freeform+ {+ self.warn("dithered gradients on characters are written without dither");+ }+ let fill = self.paint(&st.fill, Some(bounds));+ p.push(("fill", fill));+ // An inside or outside stroke is drawn on the glyph outlines instead+ // ([`Self::aligned_char_strokes`]): SVG strokes text centred only.+ if st.has_stroke() && !aligned(st) {+ // Weight, cap, join, miter limit and dashes as for object strokes; a gradient spans+ // the text grown by half the weight, as on the canvas.+ let layer = st.stroke_layer();+ self.stroke_props(&layer, layer.width, Some(layer.paint_bounds(bounds)), &mut p);+ }+ self.xf = saved;+ p.extend(css::type_props(st, &len));+ p+ }++ /// Type: its characters (live text, or glyph outlines when text is exported as outlines) and,+ /// as the canvas paints them, the object's own fills and strokes on the glyph outlines: those+ /// below the Characters row under the characters, the others over them.+ ///+ /// Inline graphics ([`vectorcraft_doc::TextRun::inline`]) are written after the characters as+ /// instances of their symbols (a `<use>` of the symbol's def where it can be shared), all in+ /// one group carrying the object's transparency. The live text skips their characters and+ /// places the text after each one; type on a path with inline graphics is written as outlines+ /// (a `<textPath>` couldn't leave room for the art).+ pub(super) fn text_node(&mut self, n: &Node, t: &TextObject) {+ let doc = self.doc;+ let resolved = doc.inline_resolved(t);+ let t = &*resolved;+ let inline = t.runs.iter().any(|r| r.inline.is_some());+ // Ruby is written as outlines with its base text: a reader's <text> can't place it. So are+ // small capitals, superscript and subscript and tab leaders, which SVG text doesn't draw (#3869).+ let unwritable = t.runs.iter().any(|r| r.style.small_caps.is_some() || r.style.position != vectorcraft_doc::CharPosition::Normal)+ || std::iter::once(&t.para).chain(&t.paras).any(|p| p.tabs.iter().any(|tab| !tab.leader.is_empty()));+ let outlined =+ self.opts.outline_text || t.vertical || !t.ruby.is_empty() || (inline && matches!(t.kind, TextKind::OnPath { .. })) || unwritable;+ let chars = |w: &mut Self, n: &Node| if outlined { w.text_outlines(n, t) } else { w.text(n, t) };+ let painted = n.appearance.items.iter().any(|i| i.visible() && !i.paint().is_none());+ // Live type with an inside or outside character stroke writes that stroke apart from the+ // text, in the group.+ let apart = !outlined && t.runs.iter().any(|r| aligned(&r.style));+ if !painted && !inline && !apart {+ return chars(self, n);+ }+ let id = self.id_attr(n);+ let a = self.attrs(&css::transparency(n));+ self.line(&format!("<g{id}{a}>"));+ self.depth += 1;+ let db = vectorcraft_text::FontDb::global();+ let lay = vectorcraft_text::layout(db, t);+ let mut all = lay.to_bezpath();+ for (_, bar) in vectorcraft_text::decorations(&lay, db, t) {+ all.extend(bar.iter());+ }+ let pd = PathData::from_bezpath(&all).transformed(t.xf);+ let d = self.path_d(&pd, self.xf);+ let tb = Some(t.xf.transform_rect_bbox(lay.bounds));+ let (below, above) = n.appearance.split_contents();+ let glyphs = |w: &mut Self, items: &[AppearanceItem]| {+ if !items.is_empty() {+ let ap = vectorcraft_doc::Appearance { items: items.to_vec(), ..Default::default() };+ w.shape(&Node::path(NodeId(u64::MAX), pd.clone(), ap), &d, &[&pd], FillRule::NonZero, tb);+ }+ };+ glyphs(self, below);+ // The group carries the id and the object's transparency.+ let mut bare = n.clone();+ (bare.opacity, bare.blend, bare.isolate) = (1.0, BlendMode::Normal, false);+ let anonymous = std::mem::replace(&mut self.anonymous, true);+ chars(self, &bare);+ for ig in &lay.inlines {+ let Some(art) = t.runs.get(ig.run).and_then(|r| r.inline.as_ref()) else { continue };+ let inst = Node::new(+ NodeId(u64::MAX),+ NodeKind::SymbolInstance { symbol: art.symbol.clone(), xf: t.xf * ig.xf * doc.symbol_natural_xf(&art.symbol) },+ );+ self.node(&inst);+ }+ glyphs(self, above);+ self.anonymous = anonymous;+ self.depth -= 1;+ self.line("</g>");+ }++ /// Text as glyph outlines: one compound path per run, painted like the run (gradients span+ /// the whole text), over its colour glyphs, as on the canvas.+ fn text_outlines(&mut self, n: &Node, t: &TextObject) {+ let db = vectorcraft_text::FontDb::global();+ let lay = vectorcraft_text::layout(db, t);+ let mut runs = vec![kurbo::BezPath::new(); t.runs.len()];+ // Underline and strikethrough bars join their run's outlines; ruby glyphs are painted+ // with the run of the text they annotate.+ let bars = vectorcraft_text::decorations(&lay, db, t);+ for (run, outline) in lay+ .glyphs+ .iter()+ .map(|g| (g.run, &g.outline))+ .chain(lay.ruby.iter().map(|g| (g.run, &g.outline)))+ .chain(bars.iter().map(|(r, b)| (*r, b)))+ {+ if let Some(bp) = runs.get_mut(run) {+ bp.extend(outline.iter());+ }+ }+ let id = self.id_attr(n);+ let a = self.attrs(&css::transparency(n));+ // Glyphs bent along a path (joined scripts on a curve) can only be outlines: the group+ // names its text for screen readers and search.+ let label = if lay.glyphs.iter().any(|g| g.bend.is_some()) {+ format!(" role=\"img\" aria-label=\"{}\"", xml_escape(&t.plain_text()))+ } else {+ String::new()+ };+ self.line(&format!("<g{id}{a}{label}>"));+ self.depth += 1;+ // The glyphs stay in text space; the text's transform joins the document's meanwhile.+ let saved = self.xf;+ self.xf = saved * t.xf;+ for (i, (bp, run)) in runs.iter().zip(&t.runs).enumerate() {+ // Colour glyphs paint themselves, under their run's paint: bitmap glyphs (emoji) as+ // their images, COLR and SVG glyphs as their art.+ for g in lay.glyphs.iter().filter(|g| g.run == i) {+ if let Some((image, to_text)) = g.placed_image() {+ let m = self.matrix(self.xf * to_text);+ let href = self.blob_href(&image.blob);+ self.line(&format!(+ "<image width=\"{}\" height=\"{}\" transform=\"{m}\" preserveAspectRatio=\"none\" xlink:href=\"{}\"/>",+ image.width,+ image.height,+ xml_escape(&href)+ ));+ }+ if let Some(art) = g.placed_colour(Affine::IDENTITY) {+ self.node(&art);+ }+ }+ if bp.elements().is_empty() {+ continue;+ }+ let pd = PathData::from_bezpath(bp);+ // An unnamed id: the pieces carry no id attribute (the group has it).+ let glyphs = Node::path(NodeId(u64::MAX), pd.clone(), run.style.appearance());+ let d = self.path_d(&pd, self.xf);+ self.shape(&glyphs, &d, &[&pd], FillRule::NonZero, Some(lay.bounds));+ }+ self.xf = saved;+ self.depth -= 1;+ self.line("</g>");+ }++ /// Point and area type, every laid-out line at its own position: wraps, indents, tabs and+ /// spacing come out as on the canvas. Centred and right-aligned lines are anchored+ /// (`text-anchor`) at their centre or right end, so they stay aligned in a viewer whose font+ /// differs; other lines are placed where each style run (and, justified, each word) starts.+ fn text(&mut self, n: &Node, t: &TextObject) {+ // Live SVG text is written in logical order from left-aligned pieces: bidirectional text+ // (and right-to-left paragraphs) keep their look as outlines until it is written with+ // `direction`/`unicode-bidi`. So do runs set Right to Left (Character Direction), whose+ // `direction="rtl"` would anchor their pieces at the right end.+ let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);+ let rtl_runs = t.runs.iter().any(|r| r.style.char_direction == Some(vectorcraft_doc::ParaDirection::RightToLeft));+ if lay.glyphs.iter().any(|g| g.rtl) || lay.lines.iter().any(|l| l.rtl) || rtl_runs {+ self.warn("bidirectional text is outlined to preserve shaping and visual order");+ return self.text_outlines(n, t);+ }+ if let TextKind::OnPath { path, start, end } = &t.kind {+ // A reader lays a `<textPath>`'s glyphs straight: joined glyphs bent along the path+ // keep their look as outlines.+ if lay.glyphs.iter().any(|g| g.bend.is_some()) {+ self.warn("joined type bent along a path is outlined to keep its look");+ return self.text_outlines(n, t);+ }+ // `<textPath>` has a start offset only: an end bracket, Align to Path and Spacing+ // keep their look as outlines.+ if end.is_some() || t.path_align != vectorcraft_doc::PathAlign::Baseline || t.path_spacing != 0.0 {+ self.warn("type on a path with an end bracket, Align to Path or Spacing is outlined to keep its look");+ return self.text_outlines(n, t);+ }+ // It cannot hang glyphs outside the start bracket either.+ if hangs_on_path(t, &lay) {+ self.warn("type on a path with glyphs hanging outside its brackets is outlined to keep its look");+ return self.text_outlines(n, t);+ }+ // A `<textPath>` holds the characters of the text, not the bullets or numbers drawn+ // before them.+ if !lay.markers.is_empty() {+ self.warn("type on a path with bullets or numbers is outlined to keep its look");+ return self.text_outlines(n, t);+ }+ return self.text_on_path(n, t, path, *start);+ }+ self.note_fonts(t, &lay);+ let lines = text_lines(t, &lay, self.opts.fewer_tspans);+ // `drawn` holds the styles the layout draws the text in: Shrink Text to Fit scales its sizes, explicit leading and baseline shifts.+ let fitted = (lay.fit_scale != 1.0).then(|| vectorcraft_text::scaled(t, lay.fit_scale));+ let drawn = fitted.as_ref().unwrap_or(t);+ // Each line is anchored as its paragraph is aligned. A tab starts a new chunk at its+ // stop, and so does the text after an inline graphic: lines with tabs, and text with+ // inline graphics, are never anchored.+ let has_inline = t.runs.iter().any(|r| r.inline.is_some());+ let anchors: Vec<Option<(&str, f64)>> = lines+ .iter()+ .map(|l| {+ match t.para_at(l.para).justify {+ Justify::Center => Some(("middle", 0.5)),+ Justify::Right => Some(("end", 1.0)),+ _ => None,+ }+ .filter(|_| !has_inline && !l.segs.iter().any(|s| s.brk))+ })+ .collect();+ // Every line anchored alike (the text's only paragraph style, typically): the <text>+ // carries the anchor. Otherwise each anchored line is a <tspan> carrying its own.+ let uniform = anchors.first().copied().filter(|a| a.is_some() && anchors.iter().all(|b| b == a)).flatten();+ // The <text> element's user space is text space.+ let space = (lay.bounds, Affine::IDENTITY);+ let mut base_props = self.char_props(&drawn.first_style(), space);+ // A `<tspan>` cannot undo the decoration of the `<text>` around it: with bullets, which+ // have none, each run's `<tspan>` carries its own.+ if !lay.markers.is_empty() {+ base_props.retain(|(k, _)| *k != "text-decoration");+ }+ let base = TextBase { props: base_props, space, anchored: uniform.is_some() };+ let mut props = base.props.clone();+ if let Some((a, _)) = uniform {+ props.push(("text-anchor", a.into()));+ }+ props.extend(css::transparency(n));+ let id = self.id_attr(n);+ let a = self.attrs(&props);+ let m = self.xf * t.xf;+ let tr = if m == Affine::IDENTITY { String::new() } else { format!(" transform=\"{}\"", self.matrix(m)) };+ let starts: Vec<Option<(f64, f64)>> = lines.iter().zip(&anchors).map(|(l, a)| line_start(&l.segs, a.map(|a| a.1))).collect();+ // The `<text>` carries the first line's position too, so readers that place text by its+ // own x/y start where the first line does.+ let at = match starts.iter().flatten().next() {+ Some((x, y)) => format!(" x=\"{}\" y=\"{}\"", self.num(*x), self.num(*y)),+ None => String::new(),+ };+ let mut s = format!("<text{id}{tr}{at} xml:space=\"preserve\"{a}>");+ for ((line, start), anchor) in lines.iter().zip(starts).zip(&anchors) {+ let Some(start) = start else { continue };+ match anchor.filter(|_| uniform.is_none()) {+ // A line anchored on its own: one positioned <tspan> with the anchor around it.+ Some((a, _)) => {+ s.push_str(&format!("<tspan x=\"{}\" y=\"{}\" text-anchor=\"{a}\">", self.num(start.0), self.num(start.1)));+ let inner = TextBase { anchored: true, ..base.clone() };+ self.text_line(&mut s, drawn, &line.segs, start, &inner, false);+ s.push_str("</tspan>");+ }+ None => self.text_line(&mut s, drawn, &line.segs, start, &base, true),+ }+ }+ s.push_str("</text>");+ self.line(&s);+ self.aligned_char_strokes(t);+ }++ /// The inside and outside character strokes of live type `t`, over its text (which goes+ /// without them, see [`Self::char_props`]): each such run's stroke on its glyph outlines, drawn+ /// twice as wide and clipped or masked to its side as aligned path strokes are+ /// ([`Self::side_attr`]). The text stays live; only the stroke follows the outlines.+ fn aligned_char_strokes(&mut self, t: &TextObject) {+ if !t.runs.iter().any(|r| aligned(&r.style)) {+ return;+ }+ let db = vectorcraft_text::FontDb::global();+ let lay = vectorcraft_text::layout(db, t);+ let bars = vectorcraft_text::decorations(&lay, db, t);+ // The glyphs stay in text space; the text's transform joins the document's meanwhile.+ let saved = self.xf;+ self.xf = saved * t.xf;+ for (i, run) in t.runs.iter().enumerate().filter(|(_, r)| aligned(&r.style)) {+ let mut bp = BezPath::new();+ for g in lay.glyphs.iter().filter(|g| g.run == i) {+ bp.extend(g.outline.iter());+ }+ for (_, bar) in bars.iter().filter(|(r, _)| *r == i) {+ bp.extend(bar.iter());+ }+ if bp.elements().is_empty() {+ continue;+ }+ let pd = PathData::from_bezpath(&bp);+ let ap = vectorcraft_doc::Appearance { items: vec![AppearanceItem::Stroke(run.style.stroke_layer())], ..Default::default() };+ let d = self.path_d(&pd, self.xf);+ self.shape(&Node::path(NodeId(u64::MAX), pd.clone(), ap), &d, &[&pd], FillRule::NonZero, Some(lay.bounds));+ }+ self.xf = saved;+ }++ /// One line of laid-out text starting at `start`. Default: a positioned `<tspan>` per segment+ /// (only the first of an anchored line). Fewer tspans: one positioned `<tspan>` per line with+ /// the style changes nested in it, positioned again only after tabs and inline graphics.+ /// Baseline shifts are relative (`dy`), undone by the next segment that isn't shifted.+ /// `positioned`: false when the caller already positioned the line (an outer `<tspan>`).+ fn text_line(&mut self, s: &mut String, t: &TextObject, line: &[Segment], start: (f64, f64), base: &TextBase, positioned: bool) {+ let fewer = self.opts.fewer_tspans && positioned;+ if fewer {+ s.push_str(&format!("<tspan x=\"{}\" y=\"{}\">", self.num(start.0), self.num(start.1)));+ }+ let mut place = !fewer && positioned;+ let mut first = true;+ // The baseline shift the current text position carries.+ let mut shift = 0.0;+ for seg in line {+ let Some(run_style) = t.runs.get(seg.run).map(|r| &r.style) else { continue };+ let marker_style;+ let st = if seg.marker {+ marker_style = vectorcraft_doc::text::ParaList::marker_style(run_style);+ &marker_style+ } else {+ run_style+ };+ let mut attrs = String::new();+ if place {+ let (x, y) = if first { start } else { (seg.x, seg.y) };+ attrs.push_str(&format!(" x=\"{}\" y=\"{}\"", self.num(x), self.num(y)));+ shift = 0.0;+ }+ first = false;+ if st.baseline_shift != shift {+ attrs.push_str(&format!(" dy=\"{}\"", self.num(shift - st.baseline_shift)));+ shift = st.baseline_shift;+ }+ // After a tab, an inline graphic or a justified word space, and before a character that a+ // reader would draw elsewhere, the next segment is placed.+ place = seg.brk || (!fewer && !base.anchored && positioned);+ if (st.h_scale - st.v_scale).abs() > 1e-9 || seg.scale != 1.0 {+ attrs.push_str(&format!(" textLength=\"{}\" lengthAdjust=\"spacingAndGlyphs\"", self.num(seg.advance * seg.scale)));+ }+ if st.rotation != 0.0 {+ attrs.push_str(&format!(" rotate=\"{}\"", self.num(-st.rotation)));+ }+ let mut diff = run_diff(&base.props, self.char_props(st, base.space));+ diff.extend(direction_props(st));+ attrs.push_str(&self.attrs(&diff));+ let text = xml_text(&seg.text);+ if attrs.is_empty() && fewer {+ s.push_str(&text);+ } else {+ s.push_str(&format!("<tspan{attrs}>{text}</tspan>"));+ }+ }+ if fewer {+ s.push_str("</tspan>");+ }+ }++ /// Record the characters of laid-out type `t` under the faces that supply them, for+ /// [`Self::font_faces`] (when fonts are embedded).+ fn note_fonts(&mut self, t: &TextObject, lay: &vectorcraft_text::TextLayout) {+ if !self.opts.embed_fonts || self.opts.outline_text {+ return;+ }+ if self.tiny() {+ return self.warn("SVG Tiny 1.2 has no web fonts: fonts are not embedded");+ }+ let db = FontDb::global();+ let plain = t.plain_text();+ let mut face: Option<Arc<FontFace>> = None;+ for (i, g) in lay.glyphs.iter().enumerate() {+ let Some(st) = t.runs.get(g.run).map(|r| &r.style) else { continue };+ // A colour font's subset would hold no bitmaps or COLR layers: its emoji are left to the+ // viewer.+ if g.image.is_some() || g.colour.is_some() {+ self.warn("colour emoji fonts are not embedded: viewers show emoji in their own fonts");+ continue;+ }+ if face.as_ref().is_none_or(|f| f.id() != g.font_id) {+ face = db.face_by_id(g.font_id);+ }+ let Some(f) = &face else { continue };+ let (weight, italic) = font_descriptor(st);+ let stretch = css::font_stretch(st).map(f64::to_bits);+ let at = self+ .fonts+ .iter()+ .position(|u| u.face.id() == f.id() && (u.weight, u.italic, u.stretch) == (weight, italic, stretch) && u.family == st.font_family);+ let at = at.unwrap_or_else(|| {+ let family = st.font_family.clone();+ self.fonts.push(FontUse { family, weight, italic, stretch, face: f.clone(), chars: BTreeSet::new() });+ self.fonts.len() - 1+ });+ let Some(chars) = self.fonts.get_mut(at).map(|u| &mut u.chars) else { continue };+ // As written: a list marker's characters, a hyphen where a line breaks, capitals for All+ // Caps, the style's Digits.+ let src = lay.marker_text(i).unwrap_or_else(|| if g.len == 0 { "-" } else { plain.get(g.byte..g.byte + g.len).unwrap_or("") });+ for c in src.chars().filter(|c| !c.is_control() && *c != '\u{ad}').map(|c| st.digits.map(c)) {+ if st.all_caps {+ chars.extend(c.to_uppercase());+ } else {+ chars.insert(c);+ }+ }+ }+ }++ /// The `@font-face` rules of the faces type uses ([`ExportOptions::embed_fonts`]): each face+ /// subset to its characters (whole when its licence forbids subsetting, left out with a+ /// warning when it forbids embedding). Faces sharing a description cover their own+ /// characters (`unicode-range`); where two of them share characters as well, a warning says+ /// that browsers draw those in one of the faces.+ pub(super) fn font_faces(&mut self) -> Vec<String> {+ let uses = std::mem::take(&mut self.fonts);+ let mut rules = Vec::new();+ fn described(u: &FontUse) -> (&str, u16, bool, Option<u64>) {+ (&u.family, u.weight, u.italic, u.stretch)+ }+ let mut clashing: Vec<&String> = vec![];+ for (i, u) in uses.iter().enumerate() {+ let clash = uses+ .get(..i)+ .unwrap_or_default()+ .iter()+ .any(|o| described(o) == described(u) && o.face.id() != u.face.id() && !o.chars.is_disjoint(&u.chars));+ if clash && !clashing.contains(&&u.family) {+ clashing.push(&u.family);+ }+ }+ for family in clashing {+ self.warn(&format!(+ "type in {family} uses faces of one weight, style and width that share characters: browsers draw those characters in one of the embedded faces"+ ));+ }+ for u in &uses {+ let chars: Vec<char> = u.chars.iter().copied().collect();+ let name = format!("{} {}", u.face.family, u.face.style);+ let Some(font) = u.face.embed(&chars) else {+ self.warn(&format!("the licence of the font {name} doesn't allow embedding: viewers show its type in their own fonts"));+ continue;+ };+ if !font.subset {+ self.warn(&format!("the font {name} is embedded whole: its licence doesn't allow subsetting"));+ }+ let shared = uses.iter().filter(|o| described(o) == described(u)).count() > 1;+ let range = if shared { format!(";unicode-range:{}", unicode_range(&u.chars)) } else { String::new() };+ let stretch = u.stretch.map(|w| format!(";font-stretch:{}%", fmt_num(f64::from_bits(w), 3))).unwrap_or_default();+ let (mime, format) = if font.cff { ("font/otf", "opentype") } else { ("font/ttf", "truetype") };+ rules.push(format!(+ "@font-face{{font-family:{};font-weight:{};font-style:{}{stretch};src:url(data:{mime};base64,{}) format(\"{format}\"){range}}}",+ css_string(&u.family),+ u.weight,+ if u.italic { "italic" } else { "normal" },+ base64_encode(&font.data)+ ));+ }+ rules+ }++ /// Type on a path: a `<textPath>` along the path (a def).+ fn text_on_path(&mut self, n: &Node, t: &TextObject, path: &PathData, start: f64) {+ let id = self.id_attr(n);+ let pid = self.fresh_id("text-path");+ let d = self.path_d(path, self.xf * t.xf);+ self.def(1, &format!("<path id=\"{pid}\" d=\"{d}\"/>"));+ // The <text> element's user space is the document's; gradients span the laid-out text.+ let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);+ self.note_fonts(t, &lay);+ let space = (lay.bounds, self.xf * t.xf);+ let base = self.char_props(&t.first_style(), space);+ let mut props = base.clone();+ match t.para_at(0).justify {+ Justify::Center | Justify::JustifyCenter => props.push(("text-anchor", "middle".into())),+ Justify::Right | Justify::JustifyRight => props.push(("text-anchor", "end".into())),+ _ => {}+ }+ props.extend(css::transparency(n));+ let a = self.attrs(&props);+ let offset = fmt_num(start * 100.0, 3);+ let mut s = format!("<text{id} xml:space=\"preserve\"{a}><textPath xlink:href=\"#{pid}\" startOffset=\"{offset}%\">");+ for run in &t.runs {+ let mut diff = run_diff(&base, self.char_props(&run.style, space));+ diff.extend(direction_props(&run.style));+ let a = self.attrs(&diff);+ s.push_str(&format!("<tspan{a}>{}</tspan>", xml_text(&run.text.replace('\n', " "))));+ }+ s.push_str("</textPath></text>");+ self.line(&s);+ self.aligned_char_strokes(t);+ }+}++/// Does a character style stroke inside or outside its glyphs (not centred)?+fn aligned(st: &CharStyle) -> bool {+ st.has_stroke() && st.stroke_align != StrokeAlign::Center+}++/// Does type on a path `t`, laid out as `lay`, hang glyphs outside its brackets? It does when+/// Optical Margin Alignment or its first paragraph's Roman Hanging Punctuation is on and its+/// glyphs sit elsewhere with both off.+fn hangs_on_path(t: &TextObject, lay: &vectorcraft_text::TextLayout) -> bool {+ if !t.optical_margin && !t.para_at(0).roman_hanging {+ return false;+ }+ let mut flush = t.clone();+ flush.optical_margin = false;+ let mut styles = flush.paragraph_styles();+ for p in &mut styles {+ p.roman_hanging = false;+ }+ flush.set_paragraph_styles(styles);+ let flush = vectorcraft_text::layout(FontDb::global(), &flush);+ lay.glyphs.len() != flush.glyphs.len() || lay.glyphs.iter().zip(&flush.glyphs).any(|(a, b)| a.origin != b.origin)+}++/// The `direction` and `unicode-bidi` of a `<tspan>` of characters in style `st`: an embedding in+/// its Character Direction, and nothing without one. Each `<tspan>` of characters with a direction+/// carries them, and the `<text>` does not. Type with a run set Right to Left is written as+/// outlines ([`Writer::text`]), so live text writes `direction="ltr"` only.+fn direction_props(st: &CharStyle) -> Props {+ let Some(d) = st.char_direction else { return Props::new() };+ let direction = if d == vectorcraft_doc::ParaDirection::RightToLeft { "rtl" } else { "ltr" };+ vec![("direction", direction.into()), ("unicode-bidi", "embed".into())]+}++/// What the `<tspan>` of a run whose properties are `run` sets over its `<text>`'s `base`: the+/// properties that differ, and the initial value of each one `base` sets and the run doesn't.+fn run_diff(base: &Props, run: Props) -> Props {+ let reset: Props =+ base.iter().filter(|(k, _)| !run.iter().any(|(r, _)| r == k)).filter_map(|(k, _)| initial_value(k).map(|v| (*k, v.to_string()))).collect();+ run.into_iter().filter(|kv| !base.contains(kv)).chain(reset).collect()+}++/// The initial value of an inherited property a run may leave unset (decorations can't be undone+/// on a `<tspan>`).+fn initial_value(k: &str) -> Option<&'static str> {+ Some(match k {+ "font-weight" | "font-style" | "font-stretch" | "font-feature-settings" | "font-variation-settings" => "normal",+ "stroke" | "stroke-dasharray" => "none",+ "stroke-width" | "stroke-opacity" => "1",+ "stroke-linecap" => "butt",+ "stroke-linejoin" => "miter",+ "stroke-miterlimit" => "4",+ "stroke-dashoffset" | "letter-spacing" => "0",+ "font-kerning" => "auto",+ _ => return None,+ })+}++/// How closely stroke outlines that clip an image follow the stroke (points).+pub(super) const OUTLINE_TOLERANCE: f64 = 0.01;++/// What the lines of one `<text>` share.+#[derive(Clone)]+struct TextBase {+ /// The `<text>` element's character properties, which each `<tspan>` differs from.+ props: Props,+ /// The text's layout bounds and the map from text space to user space (character paints).+ space: (Rect, Affine),+ /// Lines anchored at their centre or right end (`text-anchor`), positioned once each.+ anchored: bool,+}++/// One laid-out line: its paragraph (index) and its segments.+struct Line {+ para: usize,+ segs: Vec<Segment>,+}++/// Characters of one style on one line, written as one `<tspan>`.+struct Segment {+ /// Index into `TextObject::runs`.+ run: usize,+ /// Where a reader starts drawing the segment (text space; `y` is the baseline).+ x: f64,+ y: f64,+ text: String,+ /// The width a reader gives the segment (tracking included). On a line that is justified or+ /// set with Mojikumi (unless `fewer`), that is the width without justification and Mojikumi+ /// ([`reader_advances`]), for horizontally scaled type also without its last character's+ /// kerning against the character after it ([`end_segment`]); elsewhere, the laid-out width.+ advance: f64,+ /// The next segment needs its own position (after a tab, a word space of a justified line, or+ /// the next segment starts with a character the layout draws elsewhere than a reader would).+ brk: bool,+ /// Glyph Scaling of the segment's one glyph (Justification…), which a reader stretches it to+ /// (`textLength`); 1 for other segments.+ scale: f64,+ /// A list marker's characters and tab, written in+ /// [`vectorcraft_doc::text::ParaList::marker_style`] of the run's style.+ marker: bool,+}++/// How far a reader may draw a character from where the layout draws it before the character is+/// given its own position (points).+const PLACE_TOLERANCE: f64 = 1e-6;++/// The laid-out lines of `t` as segments: a new segment at every style change, after tabs and,+/// on justified lines, after each word space (unless `fewer`). The text comes from the clusters+/// the layout placed: soft hyphens draw nothing, a line broken by hyphenation ends in `-`, all+/// caps are upper case. Unless `fewer`, a line that is justified or composed with Mojikumi also+/// starts a new segment at each character the layout draws elsewhere than a reader continuing+/// the segment would ([`reader_advances`]): a Justify All line's letter gaps, the gaps between+/// the characters of a justified Japanese line, and the spacing Mojikumi changes.+fn text_lines(t: &TextObject, lay: &vectorcraft_text::TextLayout, fewer: bool) -> Vec<Line> {+ let plain = t.plain_text();+ let mut lines = Vec::with_capacity(lay.lines.len());+ let (mut kerned, mut unkerned) = (None, None);+ for line in &lay.lines {+ let para = plain.as_bytes().get(..line.start).map_or(0, |b| b.iter().filter(|&&c| c == b'\n').count());+ let style = t.para_at(para);+ let split_words = !fewer && !matches!(style.justify, Justify::Auto | Justify::Left | Justify::Center | Justify::Right);+ // Each cluster's advance and drawing offset as a reader gives them, by its byte offset.+ // Justification…'s Desired word and letter spacing and glyph scaling move characters from+ // where a reader draws them, on every line.+ let spaced = !fewer && !style.justification.desired_is_default();+ let reader = if split_words || spaced || (!fewer && !style.mojikumi.is_none()) {+ Some(&*kerned.get_or_insert_with(|| reader_advances(t, lay, true)))+ } else {+ None+ };+ // Where a reader draws the next character of the last segment, and the byte offset and+ // reader's advance of the last segment's last cluster.+ let mut pen = 0.0;+ let mut tail = None;+ let mut segs: Vec<Segment> = Vec::new();+ let mut cluster = None;+ // A list marker's glyphs write its characters and then a tab (glyph `i` of the layout).+ let source = |i: usize, g: &vectorcraft_text::PositionedGlyph| {+ lay.marker_text(i).unwrap_or_else(|| if g.len == 0 { "-" } else { plain.get(g.byte..g.byte + g.len).unwrap_or("") })+ };+ let mut glyphs = lay.glyphs.get(line.glyph_start..line.glyph_end).unwrap_or_default();+ // Spaces where the line wrapped (it doesn't end its paragraph) don't belong to the line.+ if plain.get(line.end..).is_some_and(|rest| !rest.is_empty() && !rest.starts_with('\n')) {+ while let Some((_, rest)) =+ glyphs.split_last().filter(|(g, rest)| source(line.glyph_start + rest.len(), g).chars().all(|c| c.is_whitespace() && c != '\t'))+ {+ glyphs = rest;+ }+ }+ let mut after_inline = false;+ for (k, g) in glyphs.iter().enumerate() {+ let Some(run) = t.runs.get(g.run) else { continue };+ // A list marker before an inline graphic is in the graphic's run, and is text.+ if run.inline.is_some() && lay.marker_of(line.glyph_start + k).is_none() {+ // An inline graphic (written as art): the text after it is placed anew.+ if let Some(last) = segs.last_mut() {+ last.brk = true;+ }+ after_inline = true;+ cluster = None;+ continue;+ }+ // The cluster as a reader sets it (a hyphen the layout adds is set as laid out).+ let set = reader.and_then(|r| r.get(&g.byte)).filter(|_| g.len > 0);+ if g.len > 0 && cluster == Some(g.byte) {+ // Another glyph of the same cluster (a reader's advance covers the whole cluster).+ if let Some(last) = segs.last_mut().filter(|_| set.is_none()) {+ last.advance += g.advance;+ pen += g.advance;+ }+ continue;+ }+ // A glyph that stands for no character (a list marker before the paragraph's first+ // character) starts no cluster.+ cluster = (g.len > 0).then_some(g.byte);+ let (advance, x) = match set {+ Some(&(advance, offset)) => {+ // A glyph the layout draws before its pen (Mojikumi) starts that much earlier.+ let x = g.xf.translation().x - offset;+ (advance, if (x - g.origin.x).abs() > PLACE_TOLERANCE { x } else { g.origin.x })+ }+ None => (g.advance, g.origin.x),+ };+ let src: String = source(line.glyph_start + k, g).chars().filter(|c| *c != '\u{ad}').map(|c| run.style.digits.map(c)).collect();+ let piece = if run.style.all_caps { src.to_uppercase() } else { src };+ let brk = piece == "\t" || (split_words && !piece.is_empty() && piece.chars().all(char::is_whitespace));+ // A glyph Glyph Scaling widens or narrows is a segment of its own, stretched to its width.+ let scale = if reader.is_some() && (g.scale - 1.0).abs() > 1e-9 && g.scale.is_finite() { g.scale } else { 1.0 };+ let fresh = std::mem::take(&mut after_inline) || scale != 1.0 || segs.last().is_some_and(|last| last.scale != 1.0);+ // The layout draws the character elsewhere than a reader continuing the line would.+ let moved = reader.is_some()+ && segs.last().is_some_and(|last| (x - pen).abs() > PLACE_TOLERANCE || (g.origin.y - last.y).abs() > PLACE_TOLERANCE);+ pen = x + advance;+ // A list marker is a segment of its own, and so is the text after it. In horizontally+ // scaled type a tab is a segment apart from the characters before it, so a reader+ // stretching those characters to their width (`textLength`) stretches them alone.+ let marker = lay.marker_of(line.glyph_start + k).is_some();+ let tab_apart = piece == "\t" && (run.style.h_scale - run.style.v_scale).abs() > 1e-9;+ match segs.last_mut() {+ Some(last) if last.run == g.run && !last.brk && !fresh && !moved && last.marker == marker && !tab_apart => {+ last.text.push_str(&piece);+ last.advance += advance;+ last.brk = brk;+ }+ last => {+ if let Some(last) = last {+ last.brk |= moved || last.marker != marker;+ end_segment(last, tail, t, lay, &mut unkerned);+ }+ segs.push(Segment { run: g.run, x, y: g.origin.y, text: piece, advance, brk, scale, marker });+ }+ }+ tail = set.map(|_| (g.byte, advance));+ }+ if let Some(last) = segs.last_mut() {+ end_segment(last, tail, t, lay, &mut unkerned);+ }+ segs.retain(|s| !s.text.is_empty());+ if !segs.is_empty() {+ lines.push(Line { para, segs });+ }+ }+ lines+}++/// Ends segment `seg` of horizontally scaled type (or a glyph Glyph Scaling scales), which a reader stretches to its width+/// (`textLength`): its last cluster (`tail`: byte offset and reader's advance) takes the advance+/// a reader gives it at the end of a `<tspan>`, without the font's kerning against the character+/// after it. `unkerned` holds [`reader_advances`] without kerning once a segment needs them.+fn end_segment(+ seg: &mut Segment,+ tail: Option<(usize, f64)>,+ t: &TextObject,+ lay: &vectorcraft_text::TextLayout,+ unkerned: &mut Option<HashMap<usize, (f64, f64)>>,+) {+ let Some((byte, advance)) = tail else { return };+ if seg.scale == 1.0 && t.runs.get(seg.run).is_none_or(|r| (r.style.h_scale - r.style.v_scale).abs() <= 1e-9) {+ return;+ }+ if let Some(&(alone, _)) = unkerned.get_or_insert_with(|| reader_advances(t, lay, false)).get(&byte) {+ seg.advance += alone - advance;+ }+}++/// The advance a reader of live SVG text gives each character cluster of `t` and how far from+/// its pen it draws the cluster's first glyph, keyed by the cluster's byte offset: `t` laid out+/// as point type (which isn't justified) without Mojikumi, scaled as `t`'s layout `lay` is by+/// Shrink Text to Fit. Without `kerning`, the font's pair kerning is left out (as manual+/// kerning leaves it out).+fn reader_advances(t: &TextObject, lay: &vectorcraft_text::TextLayout, kerning: bool) -> HashMap<usize, (f64, f64)> {+ let mut set = TextObject { kind: TextKind::Point, ..t.clone() };+ for p in std::iter::once(&mut set.para).chain(set.paras.iter_mut()) {+ p.mojikumi = vectorcraft_doc::Mojikumi::None;+ // A reader spaces words and letters as the font does.+ p.justification = vectorcraft_doc::JustificationOptions::default();+ }+ if !kerning {+ for r in &mut set.runs {+ r.style.kerning.get_or_insert(0.0);+ }+ }+ let mut out: HashMap<usize, (f64, f64)> = HashMap::new();+ for g in vectorcraft_text::layout(FontDb::global(), &set).glyphs.iter().filter(|g| g.len > 0) {+ let (advance, _) = out.entry(g.byte).or_insert((0.0, (g.xf.translation().x - g.origin.x) * lay.fit_scale));+ *advance += g.advance * lay.fit_scale;+ }+ out+}++/// Where a line of segments starts: where its first segment starts or, `anchor`ed (0.5: center, 1:+/// right end), that point of its width. `None` for an empty line.+fn line_start(line: &[Segment], anchor: Option<f64>) -> Option<(f64, f64)> {+ let (first, last) = (line.first()?, line.last()?);+ let x = match anchor {+ Some(f) => first.x + f * (last.x + last.advance - first.x),+ None => first.x,+ };+ Some((x, first.y))+}