Fix export

Author: jsjgdh

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

@@ -619,11 +619,14 @@ fn escape_xml_attr(value: &str) -> String {
 
 #[derive(Debug, Default, Clone)]
 struct TextPathAttrs {
+	pub start_offset: Option<String>,
 	pub method: Option<String>,
 	pub spacing: Option<String>,
 	pub side: Option<String>,
 	pub text_length: Option<f64>,
 	pub length_adjust: Option<String>,
+	pub path_length: Option<f64>,
+	pub direction: Option<String>,
 }
 
 fn pre_parse_textpath_attrs(svg: &str) -> std::collections::HashMap<String, Vec<TextPathAttrs>> {
@@ -638,11 +641,14 @@ fn pre_parse_textpath_attrs(svg: &str) -> std::collections::HashMap<String, Vec<
 				continue;
 			};
 			map.entry(path_id).or_default().push(TextPathAttrs {
+				start_offset: node.attribute("startOffset").map(str::to_string),
 				method: node.attribute("method").map(str::to_string),
 				spacing: node.attribute("spacing").map(str::to_string),
 				side: node.attribute("side").map(str::to_string),
 				text_length: node.attribute("textLength").and_then(|v| v.parse().ok()),
 				length_adjust: node.attribute("lengthAdjust").map(str::to_string),
+				path_length: node.attribute("pathLength").and_then(|v| v.parse().ok()),
+				direction: node.attribute("direction").or_else(|| node.attribute("style").and_then(|s| s.split(';').find(|p| p.trim().starts_with("direction")).and_then(|p| p.split(':').last()).map(|v| v.trim()))).map(str::to_string),
 			});
 		}
 	}
@@ -802,20 +808,21 @@ fn import_usvg_text(
 	text: &usvg::Text,
 	transform: usvg::Transform,
 	layer: LayerNodeIdentifier,
-	parent: LayerNodeIdentifier,
-	insert_index: usize,
+	_parent: LayerNodeIdentifier,
+	_insert_index: usize,
 	textpath_attrs: &mut HashMap<String, Vec<TextPathAttrs>>,
 ) {
 	log::info!("Importing usvg text node with {} chunks", text.chunks().len());
 
-	for (i, chunk) in text.chunks().iter().enumerate() {
-		let current_layer = if i == 0 {
-			layer
-		} else {
+	let chunks = text.chunks();
+	for (i, chunk) in chunks.iter().enumerate() {
+		let current_layer = if chunks.len() > 1 {
 			let new_id = NodeId::new();
 			let new_layer = modify_inputs.create_layer(new_id);
-			modify_inputs.network_interface.move_layer_to_stack_for_import(new_layer, parent, insert_index, &[]);
+			modify_inputs.network_interface.move_layer_to_stack_for_import(new_layer, layer, i, &[]);
 			new_layer
+		} else {
+			layer
 		};
 		modify_inputs.layer_node = Some(current_layer);
 
@@ -834,7 +841,12 @@ fn import_usvg_text(
 			let tp_id = text_path.id();
 			let tp_attrs = take_textpath_attrs(textpath_attrs, tp_id);
 			let path_subpaths = convert_tiny_skia_path(text_path.path());
-			let start_offset = text_path.start_offset() as f64;
+
+			let (start_offset, start_offset_percent) = match tp_attrs.start_offset.as_deref() {
+				Some(s) if s.ends_with('%') => (s.trim_end_matches('%').parse::<f64>().unwrap_or(0.0) / 100.0, true),
+				Some(s) => (s.parse::<f64>().unwrap_or(0.0), false),
+				None => (text_path.start_offset() as f64, false),
+			};
 
 			modify_inputs.insert_text_on_path(
 				chunk.text().to_string(),
@@ -843,12 +855,15 @@ fn import_usvg_text(
 				letter_spacing,
 				path_subpaths,
 				start_offset,
+				start_offset_percent,
 				text_anchor(chunk.anchor()),
 				text_path_side(&tp_attrs),
 				text_path_method(&tp_attrs),
 				text_path_spacing(&tp_attrs),
 				tp_attrs.text_length,
 				text_length_adjust(&tp_attrs),
+				tp_attrs.path_length,
+				tp_attrs.direction.as_deref() == Some("rtl"),
 				usvg_transform(transform),
 				current_layer,
 			);

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

@@ -298,12 +298,15 @@ impl<'a> ModifyInputsContext<'a> {
 		character_spacing: f64,
 		path_subpaths: Vec<Subpath<PointId>>,
 		start_offset: f64,
+		start_offset_percent: bool,
 		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,
+		path_length: Option<f64>,
+		rtl: bool,
 		transform: DAffine2,
 		layer: LayerNodeIdentifier,
 	) {
@@ -318,17 +321,17 @@ impl<'a> ModifyInputsContext<'a> {
 				Some(NodeInput::value(TaggedValue::F64(font_size), false)),
 				Some(NodeInput::value(TaggedValue::F64(character_spacing), false)),
 				Some(NodeInput::value(TaggedValue::F64(start_offset), false)),
-				Some(NodeInput::value(TaggedValue::Bool(false), false)),
+				Some(NodeInput::value(TaggedValue::Bool(start_offset_percent), 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)),
+				Some(NodeInput::value(TaggedValue::Bool(path_length.is_some()), false)),
+				Some(NodeInput::value(TaggedValue::F64(path_length.unwrap_or(0.0)), false)),
+				Some(NodeInput::value(TaggedValue::Bool(rtl), false)),
 			]);
 
 		let text_on_path_id = NodeId::new();

node-graph/libraries/rendering/src/renderer.rs

@@ -794,9 +794,14 @@ impl Render for Table<Graphic> {
 
 impl Render for Table<Vector> {
 	fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) {
+		let mut text_on_path_exported = false;
 		for row in self.iter() {
 			if render_params.for_export {
 				if let Some(ref meta) = row.element.text_on_path_metadata {
+					if text_on_path_exported {
+						continue;
+					}
+					text_on_path_exported = true;
 					let path_id = format!("textpath-{}", generate_uuid());
 					write!(&mut render.svg_defs, r#"<path id="{path_id}" d="{}" fill="none"/>"#, escape_xml_attr(&meta.path_d)).unwrap();
 
@@ -813,9 +818,11 @@ impl Render for Table<Vector> {
 					let anchor_style = format!("text-anchor: {};", meta.text_anchor);
 					let method = &meta.method;
 					let spacing = &meta.spacing;
+					let direction_attr = if meta.rtl { r#" direction="rtl""# } else { "" };
+					let path_length_attr = meta.path_length.map(|pl| format!(r#" pathLength="{pl}""#)).unwrap_or_default();
 					let text = escape_xml_text(&meta.text);
 
-					render.leaf_node(format!(r##"<text style="{font_style_css} {anchor_style}"{transform_attr}><textPath href="#{path_id}" startOffset="{start_offset_attr}" method="{method}" spacing="{spacing}"{side_attr}{text_length_attr}>{text}</textPath></text>"##));
+					render.leaf_node(format!(r##"<text style="{font_style_css} {anchor_style}"{transform_attr}{direction_attr}><textPath href="#{path_id}" startOffset="{start_offset_attr}" method="{method}" spacing="{spacing}"{side_attr}{text_length_attr}{path_length_attr}>{text}</textPath></text>"##));
 					continue;
 				}
 			}

node-graph/libraries/vector-types/src/vector/vector_types.rs

@@ -40,6 +40,8 @@ pub struct TextOnPathMetadata {
 	pub text_length: Option<f64>,
 	/// "spacing" | "spacingAndGlyphs"
 	pub length_adjust: String,
+	pub path_length: Option<f64>,
+	pub rtl: bool,
 }
 
 /// Represents vector graphics data, composed of Bézier curves in a path or mesh arrangement.
@@ -98,8 +100,18 @@ impl<Upstream> std::hash::Hash for Vector<Upstream> {
 			metadata.text.hash(state);
 			metadata.font_family.hash(state);
 			metadata.font_style.hash(state);
-			(metadata.font_size as u64).hash(state);
+			metadata.font_size.to_bits().hash(state);
 			metadata.path_d.hash(state);
+			metadata.start_offset.to_bits().hash(state);
+			metadata.start_offset_percent.hash(state);
+			metadata.text_anchor.hash(state);
+			metadata.side.hash(state);
+			metadata.method.hash(state);
+			metadata.spacing.hash(state);
+			metadata.text_length.map(|tl| tl.to_bits()).hash(state);
+			metadata.length_adjust.hash(state);
+			metadata.path_length.map(|pl| pl.to_bits()).hash(state);
+			metadata.rtl.hash(state);
 		}
 	}
 }

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

@@ -14,6 +14,7 @@ pub struct PathBuilder<Upstream: Default + 'static> {
 	current_point: Point,
 	is_text_on_path: bool,
 	scale: f64,
+	glyph_index: u64,
 }
 
 impl<Upstream: Default + 'static> PathBuilder<Upstream> {
@@ -25,6 +26,7 @@ impl<Upstream: Default + 'static> PathBuilder<Upstream> {
 			current_point: Point::ZERO,
 			is_text_on_path,
 			scale,
+			glyph_index: 0,
 		}
 	}
 
@@ -63,21 +65,17 @@ impl<Upstream: Default + 'static> PathBuilder<Upstream> {
 		};
 		let transform = if let Some(skew) = style_skew { transform * skew } else { transform };
 
-		let subpaths = std::mem::take(&mut self.glyph_subpaths);
+		let mut vector = Vector::from_subpaths(self.glyph_subpaths.clone(), false);
+		vector.transform(transform);
 		if per_glyph_instances {
-			let mut vector = Vector::from_subpaths(subpaths, false);
-			vector.transform(transform);
 			self.vector_table.push(TableRow::new_from_element(vector));
+		} else if self.vector_table.is_empty() {
+			self.vector_table = Table::new_from_element(vector);
 		} else {
-			let mut vector = Vector::from_subpaths(subpaths, false);
-			vector.transform(transform);
-			if self.vector_table.is_empty() {
-				self.vector_table = Table::new_from_element(vector);
-			} else {
-				let current_vector = self.vector_table.iter_mut().next().unwrap();
-				current_vector.element.concat(&vector, DAffine2::IDENTITY, 0);
-			}
+			let current_vector = self.vector_table.iter_mut().next().unwrap();
+			current_vector.element.concat(&vector, DAffine2::IDENTITY, self.glyph_index);
 		}
+		self.glyph_index += 1;
 	}
 
 	pub fn draw_glyph_with_mapping(&mut self, glyph: &OutlineGlyph<'_>, size: f32, normalized_coords: &[NormalizedCoord], style_skew: Option<DAffine2>, mapping_function: impl Fn(DVec2) -> DVec2) {
@@ -110,7 +108,14 @@ impl<Upstream: Default + 'static> PathBuilder<Upstream> {
 		let run_y = glyph_run.baseline();
 
 		let synthesis = run.synthesis();
-		let style_skew = synthesis.skew().map(|angle| DAffine2::from_cols_array(&[1., 0., -(angle as f64).to_radians().tan(), 1., 0., 0.]));
+		let style_skew = synthesis.skew().map(|angle| {
+			let skew = DAffine2::from_cols_array(&[1., 0., -(angle as f64).to_radians().tan(), 1., 0., 0.]);
+			if per_glyph_instances || self.is_text_on_path {
+				skew
+			} else {
+				DAffine2::from_translation(DVec2::new(0., run_y as f64)) * skew * DAffine2::from_translation(DVec2::new(0., -run_y as f64))
+			}
+		});
 		let tilt_skew = (tilt != 0.).then(|| DAffine2::from_cols_array(&[1., 0., -tilt.to_radians().tan(), 1., 0., 0.]));
 
 		let font = run.font();

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

@@ -204,11 +204,19 @@ fn is_glyph_hidden(mid: f64, _start_offset: f64, total_length: f64, is_closed: b
 	mid < -1e-3 || mid > total_length + 1e-3
 }
 
-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,
+fn resolve_startpoint(abs_offset: f64, total_advance: f64, text_anchor: TextAnchor, rtl: bool) -> f64 {
+	if !rtl {
+		match text_anchor {
+			TextAnchor::Start => abs_offset,
+			TextAnchor::Middle => abs_offset - total_advance / 2.0,
+			TextAnchor::End => abs_offset - total_advance,
+		}
+	} else {
+		match text_anchor {
+			TextAnchor::Start => abs_offset,
+			TextAnchor::Middle => abs_offset + total_advance / 2.0,
+			TextAnchor::End => abs_offset + total_advance,
+		}
 	}
 }
 
@@ -285,10 +293,18 @@ pub fn place_text_on_path<Upstream: Default + 'static>(
 
 	log::info!("Placing text on path: {} (length: {})", text, lut.total_length);
 
-	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 abs_offset = if let Some(pl) = path_length.filter(|&l| l > 1e-9) {
+		let scale = lut.total_length / pl;
+		let offset = if start_offset_percent { start_offset * lut.total_length } else { start_offset * scale };
+		if rtl { lut.total_length - offset } else { offset }
+	} else if start_offset_percent {
+		let offset = start_offset * lut.total_length;
+		if rtl { lut.total_length - offset } else { offset }
+	} else if rtl {
+		lut.total_length - start_offset
+	} else {
+		start_offset
+	};
 
 	let mut path_builder = crate::path_builder::PathBuilder::new(true, layout.scale() as f64);
 
@@ -307,7 +323,7 @@ pub fn place_text_on_path<Upstream: Default + 'static>(
 		};
 
 		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 line_start = resolve_startpoint(abs_offset, effective_line_width, text_anchor, rtl);
 
 		let mut cumulative_offset = 0.0_f64;
 		let mut glyph_index = 0_usize;
@@ -326,9 +342,12 @@ pub fn place_text_on_path<Upstream: Default + 'static>(
 				glyph_run.glyphs().for_each(|glyph| {
 					let scaled_advance = glyph.advance as f64 * advance_scale;
 					cumulative_offset += if glyph_index > 0 { spacing_delta } else { 0.0 };
-					let glyph_origin = line_start + (run_x as f64 - glyph_run.offset() as f64 + glyph.x as f64) * advance_scale + cumulative_offset;
-					let mid = glyph_origin + scaled_advance / 2.0;
-					let adjusted_mid = mid + text_path_spacing_adjustment(spacing, &lut, mid, scaled_advance);
+					
+					let glyph_x_offset = (run_x as f64 - glyph_run.offset() as f64 + glyph.x as f64) * advance_scale + cumulative_offset;
+					let mid = if rtl { line_start - glyph_x_offset - scaled_advance / 2.0 } else { line_start + glyph_x_offset + scaled_advance / 2.0 };
+					
+					let spacing_adj = text_path_spacing_adjustment(spacing, &lut, mid, scaled_advance);
+					let adjusted_mid = if rtl { mid - spacing_adj } else { mid + spacing_adj };
 
 					run_x += glyph.advance;
 					glyph_index += 1;
@@ -396,6 +415,8 @@ pub fn place_text_on_path<Upstream: Default + 'static>(
 			LengthAdjust::SpacingAndGlyphs => "spacingAndGlyphs",
 		}
 		.to_string(),
+		path_length,
+		rtl,
 	});
 	for row in result.iter_mut() {
 		row.element.text_on_path_metadata = Some(Arc::clone(&metadata));