Implement raw XML pre-parsing for SVG textPath import

Author: jsjgdh

editor/src/messages/portfolio/document/graph_operation/graph_operation_message_handler.rs

@@ -430,6 +430,9 @@ impl MessageHandler<GraphOperationMessage, GraphOperationMessageContext<'_>> for
 
 				let graphite_gradient_stops = extract_graphite_gradient_stops(&svg);
 
+				// Pre-parse the raw SVG XML for <textPath> attributes that usvg doesn't expose
+				let textpath_attrs = pre_parse_textpath_attrs(&svg);
+
 				// Pass identity so each leaf layer receives only its SVG-native transform from `abs_transform`.
 				// The placement offset is then applied once to the root group layer below.
 				import_usvg_node(
@@ -439,6 +442,7 @@ impl MessageHandler<GraphOperationMessage, GraphOperationMessageContext<'_>> for
 					parent,
 					insert_index,
 					&graphite_gradient_stops,
+					&textpath_attrs,
 				);
 
 				// After import, `layer_node` is set to the root group. Apply the placement transform to it
@@ -538,6 +542,55 @@ fn parse_hex_stop_color(hex: &str, opacity: f32) -> Option<Color> {
 	Some(Color::from_rgbaf32_unchecked(r, g, b, opacity))
 }
 
+#[derive(Debug, Default, Clone)]
+struct TextPathAttrs {
+	pub method: Option<String>,
+	pub spacing: Option<String>,
+	pub side: Option<String>,
+	pub text_length: Option<f64>,
+	pub length_adjust: Option<String>,
+}
+
+fn pre_parse_textpath_attrs(svg: &str) -> std::collections::HashMap<String, TextPathAttrs> {
+	fn get_attr<'a>(attrs_str: &'a str, name: &str) -> Option<&'a str> {
+		['"', '\''].into_iter().find_map(|q| {
+			let pattern = format!("{name}={q}");
+			let rest = &attrs_str[attrs_str.find(&pattern)? + pattern.len()..];
+			Some(&rest[..rest.find(q)?])
+		})
+	}
+
+	let mut map = std::collections::HashMap::new();
+	let mut search = svg;
+
+	while let Some(text_start) = search.find("<text") {
+		search = &search[text_start..];
+		let tag_end = search.find('>').unwrap_or(search.len());
+		let text_tag = &search[..=tag_end];
+		let text_id = get_attr(text_tag, "id").unwrap_or("").to_string();
+
+		search = &search[tag_end.saturating_add(1).min(search.len())..];
+
+		if let Some(tp_start) = search.find("<textPath") {
+			let tp_end = search[tp_start..].find('>').map(|e| tp_start + e).unwrap_or(search.len());
+			let tp_tag = &search[tp_start..=tp_end];
+
+			map.insert(
+				text_id,
+				TextPathAttrs {
+					method: get_attr(tp_tag, "method").map(str::to_string),
+					spacing: get_attr(tp_tag, "spacing").map(str::to_string),
+					side: get_attr(tp_tag, "side").map(str::to_string),
+					text_length: get_attr(tp_tag, "textLength").and_then(|v| v.parse().ok()),
+					length_adjust: get_attr(tp_tag, "lengthAdjust").map(str::to_string),
+				},
+			);
+		}
+	}
+
+	map
+}
+
 /// Import a usvg node as the root of an SVG import operation.
 ///
 /// The root layer uses the full `move_layer_to_stack` (with push/collision logic) to correctly
@@ -551,6 +604,7 @@ fn import_usvg_node(
 	parent: LayerNodeIdentifier,
 	insert_index: usize,
 	graphite_gradient_stops: &HashMap<String, GradientStops>,
+	textpath_attrs: &HashMap<String, TextPathAttrs>,
 ) {
 	let layer = modify_inputs.create_layer(id);
 
@@ -571,7 +625,7 @@ fn import_usvg_node(
 			modify_inputs.import = true;
 
 			for child in group.children() {
-				let extent = import_usvg_node_inner(modify_inputs, child, NodeId::new(), layer, 0, graphite_gradient_stops, &mut group_extents_map);
+				let extent = import_usvg_node_inner(modify_inputs, child, NodeId::new(), layer, 0, graphite_gradient_stops, &mut group_extents_map, textpath_attrs);
 				child_extents_svg_order.push(extent);
 			}
 
@@ -596,7 +650,7 @@ fn import_usvg_node(
 			warn!("Skip image");
 		}
 		usvg::Node::Text(text) => {
-			import_usvg_text(modify_inputs, text, node.abs_transform(), layer, parent, insert_index);
+			import_usvg_text(modify_inputs, text, node.abs_transform(), layer, parent, insert_index, textpath_attrs);
 		}
 	}
 }
@@ -614,6 +668,7 @@ fn import_usvg_node_inner(
 	insert_index: usize,
 	graphite_gradient_stops: &HashMap<String, GradientStops>,
 	group_extents_map: &mut HashMap<LayerNodeIdentifier, Vec<u32>>,
+	textpath_attrs: &HashMap<String, TextPathAttrs>,
 ) -> u32 {
 	let layer = modify_inputs.create_layer(id);
 	modify_inputs.network_interface.move_layer_to_stack_for_import(layer, parent, insert_index, &[]);
@@ -623,7 +678,7 @@ fn import_usvg_node_inner(
 		usvg::Node::Group(group) => {
 			let mut child_extents: Vec<u32> = Vec::new();
 			for child in group.children() {
-				let extent = import_usvg_node_inner(modify_inputs, child, NodeId::new(), layer, 0, graphite_gradient_stops, group_extents_map);
+				let extent = import_usvg_node_inner(modify_inputs, child, NodeId::new(), layer, 0, graphite_gradient_stops, group_extents_map, textpath_attrs);
 				child_extents.push(extent);
 			}
 			modify_inputs.layer_node = Some(layer);
@@ -642,7 +697,7 @@ fn import_usvg_node_inner(
 			0
 		}
 		usvg::Node::Text(text) => {
-			import_usvg_text(modify_inputs, text, node.abs_transform(), layer, parent, insert_index);
+			import_usvg_text(modify_inputs, text, node.abs_transform(), layer, parent, insert_index, textpath_attrs);
 			0
 		}
 		usvg::Node::Path(path) => {
@@ -675,8 +730,12 @@ fn import_usvg_path(modify_inputs: &mut ModifyInputsContext, node: &usvg::Node,
 	}
 }
 
-fn import_usvg_text(modify_inputs: &mut ModifyInputsContext, text: &usvg::Text, transform: usvg::Transform, layer: LayerNodeIdentifier, parent: LayerNodeIdentifier, insert_index: usize) {
-	use graphene_std::text::TextAnchor;
+fn import_usvg_text(modify_inputs: &mut ModifyInputsContext, text: &usvg::Text, transform: usvg::Transform, layer: LayerNodeIdentifier, parent: LayerNodeIdentifier, insert_index: usize, textpath_attrs: &HashMap<String, TextPathAttrs>) {
+	use graphene_std::text::{LengthAdjust, TextAnchor, TextPathMethod, TextPathSide, TextPathSpacing};
+
+	// Look up pre-parsed textPath attrs using the <text> element id (or "" for unidentified elements)
+	let text_id = text.id();
+	let tp_attrs = textpath_attrs.get(text_id).cloned().unwrap_or_default();
 
 	for (i, chunk) in text.chunks().iter().enumerate() {
 		let current_layer = if i == 0 {
@@ -717,7 +776,12 @@ fn import_usvg_text(modify_inputs: &mut ModifyInputsContext, text: &usvg::Text,
 				transform.tx as f64,
 				transform.ty as f64,
 			]);
-			modify_inputs.insert_text_on_path(chunk.text().to_string(), font, font_size, letter_spacing, path_subpaths, start_offset, anchor, affine, current_layer);
+			let method = if tp_attrs.method.as_deref() == Some("stretch") { TextPathMethod::Stretch } else { TextPathMethod::Align };
+			let spacing = if tp_attrs.spacing.as_deref() == Some("auto") { TextPathSpacing::Auto } else { TextPathSpacing::Exact };
+			let side = if tp_attrs.side.as_deref() == Some("right") { TextPathSide::Right } else { TextPathSide::Left };
+			let length_adjust = if tp_attrs.length_adjust.as_deref() == Some("spacingAndGlyphs") { LengthAdjust::SpacingAndGlyphs } else { LengthAdjust::Spacing };
+
+			modify_inputs.insert_text_on_path(chunk.text().to_string(), font, font_size, letter_spacing, path_subpaths, start_offset, anchor, side, method, spacing, tp_attrs.text_length, length_adjust, affine, current_layer);
 			modify_inputs.fill_set(Fill::Solid(Color::BLACK));
 		} else {
 			// Regular text fallback

editor/src/messages/portfolio/document/graph_operation/utility_types.rs

@@ -299,28 +299,36 @@ impl<'a> ModifyInputsContext<'a> {
 		path_subpaths: Vec<Subpath<PointId>>,
 		start_offset: f64,
 		text_anchor: TextAnchor,
+		side: graphene_std::text::TextPathSide,
+		method: graphene_std::text::TextPathMethod,
+		spacing: graphene_std::text::TextPathSpacing,
+		text_length: Option<f64>,
+		length_adjust: graphene_std::text::LengthAdjust,
 		transform: DAffine2,
 		layer: LayerNodeIdentifier,
 	) {
-		use graphene_std::text::TextPathSide;
-
-		// Create the path vector object
 		let path_vector = Table::new_from_element(Vector::from_subpaths(path_subpaths, true));
-
-		// Create the Text On Path node directly using the vector as a value input
 		let text_on_path_node = resolve_proto_node_type(graphene_std::text::text_on_path::IDENTIFIER)
 			.expect("Text On Path node does not exist")
 			.node_template_input_override([
 				Some(NodeInput::scope("editor-api")),
 				Some(NodeInput::value(TaggedValue::String(text), false)),
-				Some(NodeInput::value(TaggedValue::Vector(path_vector), false)), // path input passed as vector value directly
+				Some(NodeInput::value(TaggedValue::Vector(path_vector), false)),
 				Some(NodeInput::value(TaggedValue::Font(font), false)),
 				Some(NodeInput::value(TaggedValue::F64(font_size), false)),
 				Some(NodeInput::value(TaggedValue::F64(character_spacing), false)),
-				Some(NodeInput::value(TaggedValue::F64(start_offset), false)), // start_offset
-				Some(NodeInput::value(TaggedValue::Bool(false), false)),       // start_offset_percent
-				Some(NodeInput::value(TaggedValue::TextPathSide(TextPathSide::Left), false)),
+				Some(NodeInput::value(TaggedValue::F64(start_offset), false)),
+				Some(NodeInput::value(TaggedValue::Bool(false), false)),
+				Some(NodeInput::value(TaggedValue::TextPathSide(side), false)),
 				Some(NodeInput::value(TaggedValue::TextAnchor(text_anchor), false)),
+				Some(NodeInput::value(TaggedValue::TextPathMethod(method), false)),
+				Some(NodeInput::value(TaggedValue::TextPathSpacing(spacing), false)),
+				Some(NodeInput::value(TaggedValue::Bool(text_length.is_some()), false)),
+				Some(NodeInput::value(TaggedValue::F64(text_length.unwrap_or(0.0)), false)),
+				Some(NodeInput::value(TaggedValue::LengthAdjust(length_adjust), false)),
+				Some(NodeInput::value(TaggedValue::Bool(false), false)),
+				Some(NodeInput::value(TaggedValue::F64(0.0), false)),
+				Some(NodeInput::value(TaggedValue::Bool(false), false)),
 			]);
 
 		let text_on_path_id = NodeId::new();