Implement W3C SVG 2 compliant text-on-path placement

Author: jsjgdh

node-graph/nodes/text/src/text_on_path.rs

@@ -5,7 +5,8 @@ use kurbo::{BezPath, ParamCurve, ParamCurveArclen, ParamCurveDeriv, PathEl, Path
 use parley::PositionedLayoutItem;
 use skrifa::MetadataProvider;
 use skrifa::raw::FontRef as ReadFontsRef;
-use vector_types::Vector;
+use std::sync::Arc;
+use vector_types::{TextOnPathMetadata, Vector};
 
 #[derive(Debug, Default, Clone, Copy, PartialEq, Hash, serde::Serialize, serde::Deserialize, DynAny, node_macro::ChoiceType)]
 pub enum TextPathSide {
@@ -22,6 +23,27 @@ pub enum TextAnchor {
 	End,
 }
 
+#[derive(Debug, Default, Clone, Copy, PartialEq, Hash, serde::Serialize, serde::Deserialize, DynAny, node_macro::ChoiceType)]
+pub enum TextPathMethod {
+	#[default]
+	Align,
+	Stretch,
+}
+
+#[derive(Debug, Default, Clone, Copy, PartialEq, Hash, serde::Serialize, serde::Deserialize, DynAny, node_macro::ChoiceType)]
+pub enum TextPathSpacing {
+	#[default]
+	Exact,
+	Auto,
+}
+
+#[derive(Debug, Default, Clone, Copy, PartialEq, Hash, serde::Serialize, serde::Deserialize, DynAny, node_macro::ChoiceType)]
+pub enum LengthAdjust {
+	#[default]
+	Spacing,
+	SpacingAndGlyphs,
+}
+
 pub struct ArcLengthLut {
 	lengths: Vec<f64>,
 	params: Vec<(usize, f64)>,
@@ -174,26 +196,29 @@ fn maybe_reverse_path(path: BezPath, side: TextPathSide) -> BezPath {
 	}
 }
 
-fn is_glyph_hidden(mid: f64, start_offset: f64, total_length: f64, is_closed: bool, text_anchor: TextAnchor) -> bool {
-	if !is_closed {
-		return mid < 0.0 || mid > total_length;
-	}
+fn is_glyph_hidden(mid: f64, start_offset: f64, total_length: f64, is_closed: bool, text_anchor: TextAnchor, rtl: bool) -> bool {
+	if !is_closed { return mid < 0.0 || mid > total_length; }
 	let d = mid - start_offset;
-	match text_anchor {
+	let effective_anchor = if rtl { match text_anchor { TextAnchor::Start => TextAnchor::End, TextAnchor::End => TextAnchor::Start, _ => text_anchor } } else { text_anchor };
+	match effective_anchor {
 		TextAnchor::Start => d < 0.0 || d > total_length,
 		TextAnchor::Middle => d < -total_length / 2.0 || d > total_length / 2.0,
 		TextAnchor::End => d < -total_length || d > 0.0,
 	}
 }
 
 fn resolve_startpoint(abs_offset: f64, total_advance: f64, text_anchor: TextAnchor) -> f64 {
-	match text_anchor {
-		TextAnchor::Start => abs_offset,
-		TextAnchor::Middle => abs_offset - total_advance / 2.0,
-		TextAnchor::End => abs_offset - total_advance,
-	}
+	match text_anchor { TextAnchor::Start => abs_offset, TextAnchor::Middle => abs_offset - total_advance / 2.0, TextAnchor::End => abs_offset - total_advance }
+}
+
+fn curvature_spacing_adjustment(lut: &ArcLengthLut, mid: f64, advance: f64) -> f64 {
+	let half = advance / 2.0;
+	let (_, a0) = at_with_extension(lut, mid - half);
+	let (_, a1) = at_with_extension(lut, mid + half);
+	advance * (a1 - a0).abs() * 0.1
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn place_text_on_path<Upstream: Default + 'static>(
 	text: &str,
 	path_table: &Table<Vector<Upstream>>,
@@ -204,17 +229,25 @@ pub fn place_text_on_path<Upstream: Default + 'static>(
 	start_offset_percent: bool,
 	side: TextPathSide,
 	text_anchor: TextAnchor,
+	method: TextPathMethod,
+	spacing: TextPathSpacing,
+	text_length: Option<f64>,
+	length_adjust: LengthAdjust,
+	path_length: Option<f64>,
+	rtl: bool,
 	font_cache: &crate::FontCache,
 ) -> Table<Vector<Upstream>> {
-	let Some(path_row) = path_table.iter().next() else { return Table::new() };
-	let bezpath = path_row.element.stroke_bezpath_iter().find(|path| path.segments().next().is_some());
-	let Some(bezpath) = bezpath else { return Table::new() };
+	// TODO: Support method="stretch" (warp glyph outlines along path perpendiculars)
+	if method == TextPathMethod::Stretch {
+		log::warn!("textPath method='stretch' is not yet implemented; falling back to 'align'");
+	}
+
+	let Some(original_bezpath) = path_table.iter().next().and_then(|row| row.element.stroke_bezpath_iter().find(|p| p.segments().next().is_some())) else { return Table::new() };
+	let path_d_for_export = original_bezpath.to_svg();
 
-	let bezpath = maybe_reverse_path(bezpath, side);
+	let bezpath = maybe_reverse_path(original_bezpath, side);
 	let lut = ArcLengthLut::build(&bezpath, 100);
-	if lut.total_length < 1e-9 {
-		return Table::new();
-	}
+	if lut.total_length < 1e-9 { return Table::new(); }
 
 	let typesetting = crate::TypesettingConfig {
 		font_size,
@@ -225,13 +258,30 @@ pub fn place_text_on_path<Upstream: Default + 'static>(
 	let layout = crate::TextContext::with_thread_local(|ctx| ctx.layout_text(text, font, font_cache, typesetting));
 	let Some(layout) = layout else { return Table::new() };
 
-	let abs_offset = if start_offset_percent { start_offset * lut.total_length } else { start_offset };
+	let mut abs_offset = if start_offset_percent { start_offset * lut.total_length } else { start_offset };
+	if let Some(author_length) = path_length.filter(|&l| l > 1e-9) { abs_offset *= lut.total_length / author_length; }
 
 	let mut path_builder = crate::path_builder::PathBuilder::new(true, layout.scale() as f64);
 
 	layout.lines().for_each(|line| {
 		let line_width = line.metrics().advance as f64;
-		let line_start = resolve_startpoint(abs_offset, line_width, text_anchor);
+
+		let glyph_count: usize = line.items().map(|item| if let PositionedLayoutItem::GlyphRun(gr) = item { gr.glyphs().count() } else { 0 }).sum();
+
+		let (advance_scale, spacing_delta) = if let Some(target) = text_length.filter(|&t| t > 0.0 && line_width > 1e-9) {
+			match length_adjust {
+				LengthAdjust::Spacing => (1.0, (target - line_width) / glyph_count.saturating_sub(1).max(1) as f64),
+				LengthAdjust::SpacingAndGlyphs => (target / line_width, 0.0),
+			}
+		} else {
+			(1.0, 0.0)
+		};
+
+		let effective_line_width = line_width * advance_scale + spacing_delta * glyph_count.saturating_sub(1) as f64;
+		let line_start = resolve_startpoint(abs_offset, effective_line_width, text_anchor);
+
+		let mut cumulative_offset = 0.0_f64;
+		let mut glyph_index = 0_usize;
 
 		line.items().for_each(|item| {
 			if let PositionedLayoutItem::GlyphRun(glyph_run) = item {
@@ -244,12 +294,16 @@ pub fn place_text_on_path<Upstream: Default + 'static>(
 				let outlines = ReadFontsRef::from_index(font.data.as_ref(), font.index).unwrap().outline_glyphs();
 
 				glyph_run.glyphs().for_each(|glyph| {
-					let glyph_path_pos = line_start + run_x as f64;
-					let mid = glyph_path_pos + glyph.advance as f64 / 2.0;
+					let raw_advance = glyph.advance as f64 * advance_scale;
+					cumulative_offset += if glyph_index > 0 { spacing_delta } else { 0.0 };
+					let mid = line_start + run_x as f64 * advance_scale + cumulative_offset - glyph_run.offset() as f64 * advance_scale + raw_advance / 2.0;
+					let adjusted_mid = mid + if spacing == TextPathSpacing::Auto { curvature_spacing_adjustment(&lut, mid, raw_advance) } else { 0.0 };
+
 					run_x += glyph.advance;
+					glyph_index += 1;
 
-					if !is_glyph_hidden(mid, abs_offset, lut.total_length, lut.is_closed, text_anchor) {
-						let effective_mid = if lut.is_closed { mid.rem_euclid(lut.total_length) } else { mid };
+					if !is_glyph_hidden(adjusted_mid, abs_offset, lut.total_length, lut.is_closed, text_anchor, rtl) {
+						let effective_mid = if lut.is_closed { adjusted_mid.rem_euclid(lut.total_length) } else { adjusted_mid };
 						let (point, angle) = if lut.is_closed { lut.at_or_zero(effective_mid) } else { at_with_extension(&lut, effective_mid) };
 
 						if let Some(glyph_outline) = outlines.get(skrifa::GlyphId::from(glyph.id)) {
@@ -259,10 +313,34 @@ pub fn place_text_on_path<Upstream: Default + 'static>(
 							path_builder.draw_glyph(&glyph_outline, font_size, &normalized_coords, style_skew, final_transform, true);
 						}
 					}
+
+					cumulative_offset += raw_advance - glyph.advance as f64;
 				});
 			}
 		});
 	});
 
-	path_builder.finalize()
+	let mut result = path_builder.finalize();
+
+	// Attach text-on-path metadata so SVG export can emit <text><textPath> instead of raw outlines
+	let metadata = Arc::new(TextOnPathMetadata {
+		text: text.to_string(),
+		font_family: font.font_family.clone(),
+		font_style: font.font_style.clone(),
+		font_size,
+		path_d: path_d_for_export,
+		start_offset,
+		start_offset_percent,
+		text_anchor: match text_anchor { TextAnchor::Start => "start", TextAnchor::Middle => "middle", TextAnchor::End => "end" }.to_string(),
+		side: match side { TextPathSide::Left => "left", TextPathSide::Right => "right" }.to_string(),
+		method: match method { TextPathMethod::Align => "align", TextPathMethod::Stretch => "stretch" }.to_string(),
+		spacing: match spacing { TextPathSpacing::Exact => "exact", TextPathSpacing::Auto => "auto" }.to_string(),
+		text_length,
+		length_adjust: match length_adjust { LengthAdjust::Spacing => "spacing", LengthAdjust::SpacingAndGlyphs => "spacingAndGlyphs" }.to_string(),
+	});
+	for row in result.iter_mut() {
+		row.element.text_on_path_metadata = Some(Arc::clone(&metadata));
+	}
+
+	result
 }