Rename stroke_paint_.. to stroke_..

Author: YohYamasaki

editor/src/messages/portfolio/document/document_message.rs

@@ -234,14 +234,14 @@ pub enum DocumentMessage {
 		vector_data: HashMap<NodeId, Arc<Vector>>,
 	},
 	// `Message` is only serialized at `editor_wrapper.rs`, and only inputs from JS pass through it.
-	// `UpdateFillAttributes` and `UpdateStrokePaintAttributes` are produced inside `editor.handle_message` by `node_graph_executor.rs` and consumed in the same dispatch loop, so it never reaches that serialization point.
+	// `UpdateFillAttributes` and `UpdateStrokeAttributes` are produced inside `editor.handle_message` by `node_graph_executor.rs` and consumed in the same dispatch loop, so it never reaches that serialization point.
 	#[serde(skip)]
 	UpdateFillAttributes {
 		fill_attributes: HashMap<NodeId, Arc<List<Graphic>>>,
 	},
 	#[serde(skip)]
-	UpdateStrokePaintAttributes {
-		stroke_paint_attributes: HashMap<NodeId, Arc<List<Graphic>>>,
+	UpdateStrokeAttributes {
+		stroke_attributes: HashMap<NodeId, Arc<List<Graphic>>>,
 	},
 	Undo,
 	UngroupSelectedLayers,

editor/src/messages/portfolio/document/document_message_handler.rs

@@ -1367,9 +1367,9 @@ impl MessageHandler<DocumentMessage, DocumentMessageContext<'_>> for DocumentMes
 					.collect();
 				self.network_interface.update_fill_attributes(layer_fill_attributes);
 			}
-			DocumentMessage::UpdateStrokePaintAttributes { stroke_paint_attributes } => {
+			DocumentMessage::UpdateStrokeAttributes { stroke_attributes } => {
 				// Convert NodeId keys to LayerNodeIdentifier keys, filtering to only layers
-				let layer_stroke_paint_attributes = stroke_paint_attributes
+				let layer_stroke_attributes = stroke_attributes
 					.into_iter()
 					.filter(|(node_id, _)| self.network_interface.document_network().nodes.contains_key(node_id))
 					.filter_map(|(node_id, attrs)| {
@@ -1379,7 +1379,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageContext<'_>> for DocumentMes
 						})
 					})
 					.collect();
-				self.network_interface.update_stroke_paint_attributes(layer_stroke_paint_attributes);
+				self.network_interface.update_stroke_attributes(layer_stroke_attributes);
 			}
 			DocumentMessage::Undo => {
 				if self.network_interface.transaction_status() != TransactionStatus::Finished {
@@ -2440,7 +2440,7 @@ impl DocumentMessageHandler {
 			};
 
 			let fill_graphic_list = self.network_interface.document_metadata().layer_fill_attributes.get(&layer);
-			let stroke_paint_graphic_list = self.network_interface.document_metadata().layer_stroke_paint_attributes.get(&layer);
+			let stroke_graphic_list = self.network_interface.document_metadata().layer_stroke_attributes.get(&layer);
 
 			let has_fill = if let Some(list) = fill_graphic_list {
 				list.element(0).is_some()
@@ -2449,13 +2449,13 @@ impl DocumentMessageHandler {
 			};
 			// `style.stroke` is `Some` whenever a `Stroke` node is in the chain, even with weight 0 or a transparent color.
 			// So `is_some()` would treat invisibly-stroked fill-only layers as having a stroke.
-			// `ATTR_STROKE_PAINT_GRAPHIC` is the source of truth when set; fall back to `style.stroke.color` only when no row attribute is present.
-			let stroke_paint_visible = if let Some(list) = stroke_paint_graphic_list {
+			// `ATTR_STROKE_GRAPHIC` is the source of truth when set; fall back to `style.stroke.color` only when no row attribute is present.
+			let stroke_visible = if let Some(list) = stroke_graphic_list {
 				list.element(0).is_some_and(|g| !g.is_fully_transparent())
 			} else {
 				style.stroke.as_ref().and_then(|s| s.color()).is_some_and(|c| c.a() != 0.)
 			};
-			let has_stroke = style.stroke.as_ref().is_some_and(|s| s.has_renderable_stroke()) && stroke_paint_visible;
+			let has_stroke = style.stroke.as_ref().is_some_and(|s| s.has_renderable_stroke()) && stroke_visible;
 
 			// No stroke means there's nothing to solidify. Fill-only layers are already in the desired form, so skip.
 			if !has_stroke {

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

@@ -44,9 +44,9 @@ pub struct DocumentMetadata {
 	/// Per-layer `ATTR_FILL_GRAPHIC` row attribute, exposed so message handlers can read paint
 	/// information that lives on the list.
 	pub layer_fill_attributes: HashMap<LayerNodeIdentifier, Arc<List<Graphic>>>,
-	/// Per-layer `ATTR_STROKE_PAINT_GRAPHIC` row attribute, exposed so message handlers can read
+	/// Per-layer `ATTR_STROKE_GRAPHIC` row attribute, exposed so message handlers can read
 	/// stroke paint information that lives on the list.
-	pub layer_stroke_paint_attributes: HashMap<LayerNodeIdentifier, Arc<List<Graphic>>>,
+	pub layer_stroke_attributes: HashMap<LayerNodeIdentifier, Arc<List<Graphic>>>,
 	/// Transform from document space to viewport space.
 	pub document_to_viewport: DAffine2,
 }

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

@@ -3409,9 +3409,9 @@ impl NodeNetworkInterface {
 		self.document_metadata.layer_fill_attributes = new_layer_fill_attributes;
 	}
 
-	/// Update the per-layer `ATTR_STROKE_PAINT_GRAPHIC` snapshot.
-	pub fn update_stroke_paint_attributes(&mut self, new_layer_stroke_paint_attributes: HashMap<LayerNodeIdentifier, Arc<List<Graphic>>>) {
-		self.document_metadata.layer_stroke_paint_attributes = new_layer_stroke_paint_attributes;
+	/// Update the per-layer `ATTR_STROKE_GRAPHIC` snapshot.
+	pub fn update_stroke_attributes(&mut self, new_layer_stroke_attributes: HashMap<LayerNodeIdentifier, Arc<List<Graphic>>>) {
+		self.document_metadata.layer_stroke_attributes = new_layer_stroke_attributes;
 	}
 }
 

editor/src/node_graph_executor.rs

@@ -447,7 +447,7 @@ impl NodeGraphExecutor {
 			clip_targets,
 			vector_data,
 			fill_attributes,
-			stroke_paint_attributes,
+			stroke_attributes,
 			backgrounds: _,
 		} = render_output.metadata;
 
@@ -463,7 +463,7 @@ impl NodeGraphExecutor {
 		responses.add(DocumentMessage::UpdateClipTargets { clip_targets });
 		responses.add(DocumentMessage::UpdateVectorData { vector_data });
 		responses.add(DocumentMessage::UpdateFillAttributes { fill_attributes });
-		responses.add(DocumentMessage::UpdateStrokePaintAttributes { stroke_paint_attributes });
+		responses.add(DocumentMessage::UpdateStrokeAttributes { stroke_attributes });
 		responses.add(DocumentMessage::RenderScrollbars);
 		responses.add(DocumentMessage::RenderRulers);
 		responses.add(OverlaysMessage::Draw);

node-graph/libraries/core-types/src/list.rs

@@ -81,7 +81,7 @@ pub const ATTR_GRADIENT_TYPE: &str = "gradient_type";
 pub const ATTR_FILL_GRAPHIC: &str = "fill_graphic";
 
 /// List<Graphic> data for stroke.
-pub const ATTR_STROKE_PAINT_GRAPHIC: &str = "stroke_paint_graphic";
+pub const ATTR_STROKE_GRAPHIC: &str = "stroke_graphic";
 
 // ========================
 // TRAIT: AnyAttributeValue

node-graph/libraries/graphic-types/src/graphic.rs

@@ -2,7 +2,7 @@ use std::borrow::Cow;
 
 use core_types::bounds::{BoundingBox, RenderBoundingBox};
 use core_types::graphene_hash::CacheHash;
-use core_types::list::{ATTR_FILL_GRAPHIC, ATTR_STROKE_PAINT_GRAPHIC, Item, List};
+use core_types::list::{ATTR_FILL_GRAPHIC, ATTR_STROKE_GRAPHIC, Item, List};
 use core_types::ops::ListConvert;
 use core_types::render_complexity::RenderComplexity;
 use core_types::uuid::NodeId;
@@ -209,8 +209,8 @@ pub fn fill_graphic_list_at(list: &List<Vector>, index: usize) -> Option<Cow<'_,
 /// Look up the stroke paint graphics for a vector row, falling back to the legacy
 /// `style.stroke.color` when the row attribute is absent or empty.
 /// TODO: Remove once all stroke paint sources flow through `List<Graphic>` directly without going through `Stroke.color`.
-pub fn stroke_paint_graphic_list_at(list: &List<Vector>, index: usize) -> Option<Cow<'_, List<Graphic>>> {
-	list.attribute::<List<Graphic>>(ATTR_STROKE_PAINT_GRAPHIC, index).map(Cow::Borrowed).or_else(|| {
+pub fn stroke_graphic_list_at(list: &List<Vector>, index: usize) -> Option<Cow<'_, List<Graphic>>> {
+	list.attribute::<List<Graphic>>(ATTR_STROKE_GRAPHIC, index).map(Cow::Borrowed).or_else(|| {
 		let vector = list.element(index)?;
 		color_to_graphic_list(vector.style.stroke().and_then(|s| s.color())).map(Cow::Owned)
 	})
@@ -253,7 +253,7 @@ pub fn is_fill_fully_transparent_at(list: &List<Vector>, index: usize) -> bool {
 /// This avoids the `List<Graphic>` allocation that the legacy `Stroke.color` fallback path performs.
 /// TODO: Remove once all stroke paint sources flow through `List<Graphic>` directly without going through `Stroke.color`.
 pub fn is_stroke_opaque_at(list: &List<Vector>, index: usize) -> bool {
-	if let Some(graphic_list) = list.attribute::<List<Graphic>>(ATTR_STROKE_PAINT_GRAPHIC, index) {
+	if let Some(graphic_list) = list.attribute::<List<Graphic>>(ATTR_STROKE_GRAPHIC, index) {
 		return graphic_list.element(0).is_some_and(|graphic| graphic.is_opaque());
 	}
 	let Some(color) = list.element(index).and_then(|vector| vector.style.stroke()).and_then(|stroke| stroke.color()) else {
@@ -267,7 +267,7 @@ pub fn is_stroke_opaque_at(list: &List<Vector>, index: usize) -> bool {
 /// This avoids the `List<Graphic>` allocation that the legacy `Stroke.color` fallback path performs.
 /// TODO: Remove once all stroke paint sources flow through `List<Graphic>` directly without going through `Stroke.color`.
 pub fn is_stroke_fully_transparent_at(list: &List<Vector>, index: usize) -> bool {
-	if let Some(graphic_list) = list.attribute::<List<Graphic>>(ATTR_STROKE_PAINT_GRAPHIC, index) {
+	if let Some(graphic_list) = list.attribute::<List<Graphic>>(ATTR_STROKE_GRAPHIC, index) {
 		return graphic_list.element(0).is_none_or(|graphic| graphic.is_fully_transparent());
 	}
 	let Some(color) = list.element(index).and_then(|vector| vector.style.stroke()).and_then(|stroke| stroke.color()) else {
@@ -446,7 +446,7 @@ impl Graphic {
 				};
 
 				let stroke_invisible_or_transparent = element.style.stroke().is_none_or(|stroke| !stroke.has_renderable_stroke())
-					|| if let Some(graphic_list) = vector.attribute::<List<Graphic>>(ATTR_STROKE_PAINT_GRAPHIC, index) {
+					|| if let Some(graphic_list) = vector.attribute::<List<Graphic>>(ATTR_STROKE_GRAPHIC, index) {
 						graphic_list.element(0).is_none_or(|graphic| graphic.is_fully_transparent())
 					} else {
 						element.style.stroke().and_then(|stroke| stroke.color()).is_none_or(|color| color.a() == 0.)

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

@@ -6,7 +6,7 @@ use core_types::bounds::BoundingBox;
 use core_types::bounds::RenderBoundingBox;
 use core_types::color::Color;
 use core_types::color::SRGBA8;
-use core_types::list::{ATTR_FILL_GRAPHIC, ATTR_STROKE_PAINT_GRAPHIC, Item, List};
+use core_types::list::{ATTR_FILL_GRAPHIC, ATTR_STROKE_GRAPHIC, Item, List};
 use core_types::math::quad::Quad;
 use core_types::render_complexity::RenderComplexity;
 use core_types::transform::Footprint;
@@ -18,7 +18,7 @@ use core_types::{
 use dyn_any::DynAny;
 use glam::{DAffine2, DVec2};
 use graphene_hash::CacheHashWrapper;
-use graphic_types::graphic::{fill_graphic_list_at, is_stroke_fully_transparent_at, stroke_paint_graphic_list_at};
+use graphic_types::graphic::{fill_graphic_list_at, is_stroke_fully_transparent_at, stroke_graphic_list_at};
 use graphic_types::raster_types::{BitmapMut, CPU, GPU, Image, Raster};
 use graphic_types::vector_types::gradient::{GradientStops, GradientType};
 use graphic_types::vector_types::subpath::Subpath;
@@ -454,10 +454,10 @@ pub struct RenderMetadata {
 	/// information that lives on the list rather than on `PathStyle.fill`.
 	#[cfg_attr(feature = "serde", serde(skip))]
 	pub fill_attributes: HashMap<NodeId, Arc<List<Graphic>>>,
-	/// Per-layer `ATTR_STROKE_PAINT_GRAPHIC` row attribute, exposed so message handlers can read
+	/// Per-layer `ATTR_STROKE_GRAPHIC` row attribute, exposed so message handlers can read
 	/// stroke paint information that lives on the list rather than on `Stroke.color`.
 	#[cfg_attr(feature = "serde", serde(skip))]
-	pub stroke_paint_attributes: HashMap<NodeId, Arc<List<Graphic>>>,
+	pub stroke_attributes: HashMap<NodeId, Arc<List<Graphic>>>,
 	pub backgrounds: Vec<Background>,
 }
 
@@ -482,7 +482,7 @@ impl RenderMetadata {
 			clip_targets,
 			vector_data,
 			fill_attributes,
-			stroke_paint_attributes,
+			stroke_attributes,
 			backgrounds,
 		} = self;
 		upstream_footprints.extend(other.upstream_footprints.iter());
@@ -494,7 +494,7 @@ impl RenderMetadata {
 		clip_targets.extend(other.clip_targets.iter());
 		vector_data.extend(other.vector_data.iter().map(|(id, data)| (*id, data.clone())));
 		fill_attributes.extend(other.fill_attributes.iter().map(|(id, data)| (*id, data.clone())));
-		stroke_paint_attributes.extend(other.stroke_paint_attributes.iter().map(|(id, data)| (*id, data.clone())));
+		stroke_attributes.extend(other.stroke_attributes.iter().map(|(id, data)| (*id, data.clone())));
 
 		// TODO: Find a better non O(n^2) way to merge backgrounds
 		for background in &other.backgrounds {
@@ -1073,13 +1073,13 @@ impl Render for List<Vector> {
 			let fill_graphic_list = fill_graphic_list_at(self, index);
 			let fill_graphic = fill_graphic_list.as_ref().and_then(|l| l.element(0));
 
-			let stroke_paint_graphic_list = stroke_paint_graphic_list_at(self, index);
-			let stroke_paint_graphic = stroke_paint_graphic_list.as_ref().and_then(|l| l.element(0));
+			let stroke_graphic_list = stroke_graphic_list_at(self, index);
+			let stroke_graphic = stroke_graphic_list.as_ref().and_then(|l| l.element(0));
 
 			let path_is_closed = vector.stroke_bezier_paths().all(|path| path.closed());
 			let can_draw_aligned_stroke = path_is_closed
 				&& vector.style.stroke().is_some_and(|stroke| stroke.has_renderable_stroke() && stroke.align.is_not_centered())
-				&& stroke_paint_graphic.is_some_and(|graphic| !graphic.is_fully_transparent());
+				&& stroke_graphic.is_some_and(|graphic| !graphic.is_fully_transparent());
 			let can_use_paint_order = !(fill_graphic.is_none_or(|graphic| !graphic.is_opaque()) || mask_type == MaskType::Clip);
 
 			let needs_separate_alignment_fill = can_draw_aligned_stroke && !can_use_paint_order;
@@ -1176,7 +1176,7 @@ impl Render for List<Vector> {
 					.style
 					.stroke()
 					.map(|stroke| {
-						if stroke_paint_graphic_list.as_ref().and_then(|l| l.element(0)).is_some() {
+						if stroke_graphic_list.as_ref().and_then(|l| l.element(0)).is_some() {
 							stroke.render(
 								defs,
 								item_transform,
@@ -1194,9 +1194,9 @@ impl Render for List<Vector> {
 					.unwrap_or_default();
 
 				// Need to avoid generating only paint attribute, otherwise SVG uses 1px width stroke as a fallback
-				let stroke_paint_visible = vector.style.stroke().is_some_and(|stroke| stroke.has_renderable_stroke()) && stroke_paint_graphic.is_some_and(|g| !g.is_fully_transparent());
-				let stroke_paint_attribute = if stroke_paint_visible {
-					stroke_paint_graphic_list
+				let stroke_visible = vector.style.stroke().is_some_and(|stroke| stroke.has_renderable_stroke()) && stroke_graphic.is_some_and(|g| !g.is_fully_transparent());
+				let stroke_attribute = if stroke_visible {
+					stroke_graphic_list
 						.as_deref()
 						.map(|list| {
 							// Gradient should align with the fill path bbox so that a shared gradient lines up across fill and stroke.
@@ -1247,7 +1247,7 @@ impl Render for List<Vector> {
 				}
 				attributes.push_val(fill_attribute);
 				attributes.push_val(stroke_shape_attribute);
-				attributes.push_val(stroke_paint_attribute);
+				attributes.push_val(stroke_attribute);
 
 				if vector.is_branching() && !use_face_fill {
 					attributes.push("fill-rule", "evenodd");
@@ -1317,7 +1317,7 @@ impl Render for List<Vector> {
 			}
 
 			let fill_graphic_list = fill_graphic_list_at(self, index);
-			let stroke_paint_graphic_list = stroke_paint_graphic_list_at(self, index);
+			let stroke_graphic_list = stroke_graphic_list_at(self, index);
 
 			// If we're using opacity or a blend mode, we need to push a layer
 			let blend_mode = match render_params.render_mode {
@@ -1410,11 +1410,11 @@ impl Render for List<Vector> {
 			};
 
 			let do_stroke = |scene: &mut Scene, width_scale: f64, context: &mut RenderContext| {
-				let Some(stroke_paint_graphic_list) = stroke_paint_graphic_list.as_deref() else { return };
+				let Some(stroke_graphic_list) = stroke_graphic_list.as_deref() else { return };
 				let Some(stroke) = element.style.stroke() else { return };
 
-				for paint_idx in 0..stroke_paint_graphic_list.len() {
-					let Some(stroke_paint_graphic) = stroke_paint_graphic_list.element(paint_idx) else {
+				for paint_idx in 0..stroke_graphic_list.len() {
+					let Some(stroke_graphic) = stroke_graphic_list.element(paint_idx) else {
 						continue;
 					};
 
@@ -1443,7 +1443,7 @@ impl Render for List<Vector> {
 						continue;
 					};
 
-					match stroke_paint_graphic {
+					match stroke_graphic {
 						Graphic::Color(list) => {
 							let Some(color) = list.element(0) else { continue };
 							let brush = peniko::Brush::Solid(SRGBA8::from(*color).to_peniko_color());
@@ -1467,7 +1467,7 @@ impl Render for List<Vector> {
 							let stroked = peniko::kurbo::stroke(path.iter(), &stroke, &StrokeOpts::default(), 0.01);
 
 							scene.push_clip_layer(peniko::Fill::NonZero, kurbo::Affine::new(element_transform.to_cols_array()), &stroked);
-							stroke_paint_graphic.render_to_vello(scene, multiplied_transform, context, render_params);
+							stroke_graphic.render_to_vello(scene, multiplied_transform, context, render_params);
 							scene.pop_layer();
 						}
 					};
@@ -1609,12 +1609,12 @@ impl Render for List<Vector> {
 				metadata.vector_data.entry(element_id).or_insert_with(|| Arc::new(source.clone()));
 
 				// Surface row attribute paint sources (only for item 0) so message handlers can read
-				// `ATTR_FILL_GRAPHIC` / `ATTR_STROKE_PAINT_GRAPHIC` without rebuilding the list.
-				if let Some(fill_paint) = self.attribute::<List<Graphic>>(ATTR_FILL_GRAPHIC, index).cloned() {
-					metadata.fill_attributes.entry(element_id).or_insert_with(|| Arc::new(fill_paint));
+				// `ATTR_FILL_GRAPHIC` / `ATTR_STROKE_GRAPHIC` without rebuilding the list.
+				if let Some(fill_graphic) = self.attribute::<List<Graphic>>(ATTR_FILL_GRAPHIC, index).cloned() {
+					metadata.fill_attributes.entry(element_id).or_insert_with(|| Arc::new(fill_graphic));
 				}
-				if let Some(stroke_paint) = self.attribute::<List<Graphic>>(ATTR_STROKE_PAINT_GRAPHIC, index).cloned() {
-					metadata.stroke_paint_attributes.entry(element_id).or_insert_with(|| Arc::new(stroke_paint));
+				if let Some(stroke_graphic) = self.attribute::<List<Graphic>>(ATTR_STROKE_GRAPHIC, index).cloned() {
+					metadata.stroke_attributes.entry(element_id).or_insert_with(|| Arc::new(stroke_graphic));
 				}
 
 				// Surface `editor:text_frame` for the Text tool's drag cage

node-graph/nodes/math/src/lib.rs

@@ -1,5 +1,5 @@
 use core_types::Context;
-use core_types::list::{ATTR_FILL_GRAPHIC, ATTR_STROKE_PAINT_GRAPHIC, List};
+use core_types::list::{ATTR_FILL_GRAPHIC, ATTR_STROKE_GRAPHIC, List};
 use core_types::registry::types::{Fraction, Percentage, PixelSize};
 use core_types::transform::Footprint;
 use core_types::{Color, Ctx, num_traits};
@@ -1008,10 +1008,10 @@ fn fill_graphic<P: IntoGraphicList + 'n + Send>(
 	vectors
 }
 
-/// Sets the `stroke_paint_graphic` attribute on each item of the input vector list.
+/// Sets the `stroke_graphic` attribute on each item of the input vector list.
 /// Used for testing of gradient and clipping-based stroke rendering until the proper Stroke node refactor lands.
 #[node_macro::node(category("Debug"))]
-fn stroke_paint_graphic<P: IntoGraphicList + 'n + Send>(
+fn stroke_graphic<P: IntoGraphicList + 'n + Send>(
 	_: impl Ctx,
 	mut vectors: List<Vector>,
 	#[implementations(
@@ -1022,11 +1022,11 @@ fn stroke_paint_graphic<P: IntoGraphicList + 'n + Send>(
         List<Color>,
         List<GradientStops>,
     )]
-	stroke_paint_graphic: P,
+	stroke_graphic: P,
 ) -> List<Vector> {
-	let paint_list = stroke_paint_graphic.into_graphic_list();
+	let paint_list = stroke_graphic.into_graphic_list();
 	for row_idx in 0..vectors.len() {
-		vectors.set_attribute(ATTR_STROKE_PAINT_GRAPHIC, row_idx, paint_list.clone());
+		vectors.set_attribute(ATTR_STROKE_GRAPHIC, row_idx, paint_list.clone());
 	}
 	vectors
 }