fix: serde migration for old documents

Author: mohan-bee

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

@@ -515,10 +515,12 @@ fn apply_usvg_stroke(stroke: &usvg::Stroke, modify_inputs: &mut ModifyInputsCont
 			align: StrokeAlign::Center,
 			paint_order: PaintOrder::StrokeAbove,
 			transform,
+			non_scaling: false,
 		})
 	}
 }
 
+
 fn apply_usvg_fill(fill: &usvg::Fill, modify_inputs: &mut ModifyInputsContext, bounds_transform: DAffine2, graphite_gradient_stops: &HashMap<String, GradientStops>) {
 	modify_inputs.fill_set(match &fill.paint() {
 		usvg::Paint::Color(color) => Fill::solid(usvg_color(*color, fill.opacity().get())),

editor/src/messages/portfolio/document_migration.rs

@@ -1093,6 +1093,26 @@ fn migrate_node(node_id: &NodeId, node: &DocumentNode, network_path: &[NodeId],
 		document.network_interface.set_input(&InputConnector::node(*node_id, 9), old_inputs[4].clone(), network_path);
 	}
 
+	// Upgrade Stroke node to add "_backup_color" and "_backup_gradient" (10 -> 12)
+	if reference == DefinitionIdentifier::ProtoNode(graphene_std::vector::stroke::IDENTIFIER) && inputs_count == 10 {
+		let mut node_template = resolve_document_node_type(&reference)?.default_node_template();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template)?;
+		for i in 0..10 {
+			document.network_interface.set_input(&InputConnector::node(*node_id, i), old_inputs[i].clone(), network_path);
+		}
+	}
+
+	// Upgrade Fill node to add "_backup_color" and "_backup_gradient" (2 -> 4)
+	if reference == DefinitionIdentifier::ProtoNode(graphene_std::vector_nodes::fill::IDENTIFIER) && inputs_count == 2 {
+		let mut node_template = resolve_document_node_type(&reference)?.default_node_template();
+		let old_inputs = document.network_interface.replace_inputs(node_id, network_path, &mut node_template)?;
+		for i in 0..2 {
+			document.network_interface.set_input(&InputConnector::node(*node_id, i), old_inputs[i].clone(), network_path);
+		}
+	}
+
+
+
 	// Upgrade the old "Spline" node to the new "Spline" node
 	if reference == DefinitionIdentifier::ProtoNode(graphene_std::vector::spline::IDENTIFIER)
 		|| reference == DefinitionIdentifier::ProtoNode(ProtoNodeIdentifier::new("graphene_core::vector::generator_nodes::SplineNode"))

node-graph/graph-craft/src/document/value.rs

@@ -403,9 +403,34 @@ impl TaggedValue {
 					() if ty == TypeId::of::<bool>() => FromStr::from_str(string).map(TaggedValue::Bool).ok()?,
 					// `Color` (not in a table) is still currently needed by `BlackAndWhiteNode` and `ColorOverlayNode` GPU `shader_node(PerPixelAdjust)` variants
 					() if ty == TypeId::of::<Color>() => to_color(string).map(|color| TaggedValue::Color(Table::new_from_element(color)))?,
-					() if ty == TypeId::of::<Table<Color>>() => to_color(string).map(|color| TaggedValue::Color(Table::new_from_element(color)))?,
-					() if ty == TypeId::of::<Table<GradientStops>>() => to_gradient(string).map(|color| TaggedValue::GradientTable(Table::new_from_element(color)))?,
-					() if ty == TypeId::of::<Fill>() => to_color(string).map(|color| TaggedValue::Fill(Fill::solid(color)))?,
+					() if ty == TypeId::of::<Table<Color>>() => {
+						if string.trim().replace(' ', "") == "Table::new()" {
+							Some(TaggedValue::Color(Table::new()))
+						} else {
+							to_color(string).map(|color| TaggedValue::Color(Table::new_from_element(color)))
+						}
+					}?,
+					() if ty == TypeId::of::<Table<GradientStops>>() => {
+						if string.trim().replace(' ', "") == "Table::new()" {
+							Some(TaggedValue::GradientTable(Table::new()))
+						} else {
+							to_gradient(string).map(|color| TaggedValue::GradientTable(Table::new_from_element(color)))
+						}
+					}?,
+					() if ty == TypeId::of::<Fill>() => {
+						if string.trim().replace(' ', "") == "Fill::default()" {
+							Some(TaggedValue::Fill(Fill::default()))
+						} else {
+							to_color(string).map(|color| TaggedValue::Fill(Fill::solid(color)))
+						}
+					}?,
+					() if ty == TypeId::of::<graphic_types::vector_types::vector::style::Gradient>() => {
+						if string.trim().replace(' ', "") == "Gradient::default()" {
+							Some(TaggedValue::Gradient(graphic_types::vector_types::vector::style::Gradient::default()))
+						} else {
+							None
+						}
+					}?,
 					() if ty == TypeId::of::<ReferencePoint>() => to_reference_point(string).map(TaggedValue::ReferencePoint)?,
 					_ => return None,
 				};

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

@@ -316,10 +316,80 @@ fn daffine2_identity() -> DAffine2 {
 	DAffine2::IDENTITY
 }
 
+/// Helper module for deserializing the `Stroke::paint` field, supporting both the
+/// new `"paint": Fill` format and the legacy `"color": Color` format from old `.graphite` files.
+mod stroke_paint_migration {
+	use super::*;
+	use serde::Deserialize;
+
+	/// Legacy representation: old `.graphite` files stored a bare `Color` in a field called `"color"`.
+	#[derive(Deserialize)]
+	struct OldStroke {
+		#[serde(default)]
+		color: Option<Color>,
+		#[serde(default)]
+		paint: Option<Fill>,
+		#[serde(default)]
+		weight: f64,
+		#[serde(default)]
+		dash_lengths: Vec<f64>,
+		#[serde(default)]
+		dash_offset: f64,
+		#[serde(default, alias = "line_cap")]
+		cap: StrokeCap,
+		#[serde(default, alias = "line_join")]
+		join: StrokeJoin,
+		#[serde(default = "default_miter_limit", alias = "line_join_miter_limit")]
+		join_miter_limit: f64,
+		#[serde(default)]
+		align: StrokeAlign,
+		#[serde(default = "super::daffine2_identity")]
+		transform: DAffine2,
+		#[serde(default)]
+		non_scaling: bool,
+		#[serde(default)]
+		paint_order: PaintOrder,
+	}
+
+
+	fn default_miter_limit() -> f64 {
+		4.
+	}
+
+	/// Attempt to deserialize a `Stroke` from either the new or old format.
+	pub fn deserialize_stroke<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<Stroke, D::Error> {
+		let old = OldStroke::deserialize(deserializer)?;
+
+		// If the new `paint` field is present, use it directly.
+		// Otherwise, fall back to converting the legacy `color` field into `Fill::Solid`.
+		let paint = match old.paint {
+			Some(paint) => paint,
+			None => match old.color {
+				Some(color) => Fill::Solid(color),
+				None => Fill::Solid(Color::from_rgba8_srgb(0, 0, 0, 255)),
+			},
+		};
+
+		Ok(Stroke {
+			paint,
+			weight: old.weight,
+			dash_lengths: old.dash_lengths,
+			dash_offset: old.dash_offset,
+			cap: old.cap,
+			join: old.join,
+			join_miter_limit: old.join_miter_limit,
+			align: old.align,
+			transform: old.transform,
+			non_scaling: old.non_scaling,
+			paint_order: old.paint_order,
+		})
+	}
+
+}
+
 #[repr(C)]
 #[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, DynAny)]
-#[serde(default)]
+#[derive(Debug, Clone, PartialEq, serde::Serialize, DynAny)]
 pub struct Stroke {
 	/// Stroke paint (solid color or gradient)
 	pub paint: Fill,
@@ -337,10 +407,17 @@ pub struct Stroke {
 	pub align: StrokeAlign,
 	#[serde(default = "daffine2_identity")]
 	pub transform: DAffine2,
-	#[serde(default)]
+	pub non_scaling: bool,
 	pub paint_order: PaintOrder,
 }
 
+
+impl<'de> serde::Deserialize<'de> for Stroke {
+	fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+		stroke_paint_migration::deserialize_stroke(deserializer)
+	}
+}
+
 impl std::hash::Hash for Stroke {
 	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
 		self.paint.hash(state);
@@ -355,8 +432,10 @@ impl std::hash::Hash for Stroke {
 		self.join_miter_limit.to_bits().hash(state);
 		self.align.hash(state);
 		self.transform.to_cols_array().iter().for_each(|x| x.to_bits().hash(state));
+		self.non_scaling.hash(state);
 		self.paint_order.hash(state);
 	}
+
 }
 
 impl Stroke {
@@ -371,10 +450,12 @@ impl Stroke {
 			join_miter_limit: 4.,
 			align: StrokeAlign::Center,
 			transform: DAffine2::IDENTITY,
+			non_scaling: false,
 			paint_order: PaintOrder::StrokeAbove,
 		}
 	}
 
+
 	pub fn lerp(&self, other: &Self, time: f64) -> Self {
 		Self {
 			paint: self.paint.lerp(&other.paint, time),
@@ -389,10 +470,12 @@ impl Stroke {
 				time * self.transform.matrix2 + (1. - time) * other.transform.matrix2,
 				self.transform.translation * time + other.transform.translation * (1. - time),
 			),
+			non_scaling: if time < 0.5 { self.non_scaling } else { other.non_scaling },
 			paint_order: if time < 0.5 { self.paint_order } else { other.paint_order },
 		}
 	}
 
+
 	/// Get the current stroke color.
 	pub fn color(&self) -> Option<Color> {
 		match &self.paint {
@@ -515,6 +598,7 @@ impl Default for Stroke {
 			join_miter_limit: 4.,
 			align: StrokeAlign::Center,
 			transform: DAffine2::IDENTITY,
+			non_scaling: false,
 			paint_order: PaintOrder::default(),
 		}
 	}

node-graph/nodes/vector/src/vector_nodes.rs

@@ -241,6 +241,7 @@ async fn stroke<V, L: IntoF64Vec, F: Into<Fill> + 'n + Send>(
 	miter_limit: f64,
 	// <https://svgwg.org/svg2-draft/painting.html#PaintOrderProperty>
 	/// The order to paint the stroke on top of the fill, or the fill on top of the stroke.
+	#[default(PaintOrder::StrokeAbove)]
 	paint_order: PaintOrder,
 	/// The stroke dash lengths. Each length forms a distance in a pattern where the first length is a dash, the second is a gap, and so on. If the list is an odd length, the pattern repeats with solid-gap roles reversed.
 	#[implementations(
@@ -289,9 +290,11 @@ where
 		join_miter_limit: miter_limit,
 		align,
 		transform: DAffine2::IDENTITY,
+		non_scaling: false,
 		paint_order,
 	};
 
+
 	for vector in content.vector_iter_mut() {
 		let mut stroke = stroke.clone();
 		stroke.transform *= *vector.transform;