Make the data model use Item and List types universally, with nodes authored as rank-polymorphic kernels

editor/src/messages/clipboard/clipboard_message_handler.rs

@@ -252,9 +252,20 @@ impl MessageHandler<ClipboardMessage, ClipboardMessageContext<'_>> for Clipboard
 				let mut vectors = Vec::new();
 				let mut resources = Vec::new();
 				for item in items {
+					// Pasted templates skip document migration, so stored types normalize here
 					match item {
-						ClipboardItem::Layer(entry) => layers.push(entry),
-						ClipboardItem::Nodes(nodes) => node_groups.push(nodes),
+						ClipboardItem::Layer(mut entry) => {
+							for (_, template) in &mut entry.nodes {
+								template.document_node.normalize_stored_types();
+							}
+							layers.push(entry);
+						}
+						ClipboardItem::Nodes(mut nodes) => {
+							for (_, template) in &mut nodes {
+								template.document_node.normalize_stored_types();
+							}
+							node_groups.push(nodes);
+						}
 						ClipboardItem::Vector(vector) => vectors.push(vector),
 						ClipboardItem::Resource(resource) => resources.push(resource),
 					}

editor/src/messages/color_picker/color_picker_message_handler.rs

@@ -5,7 +5,7 @@ use crate::messages::prelude::*;
 use graphene_std::Color;
 use graphene_std::color::SRGBA8;
 use graphene_std::core_types::misc::parse_css_color;
-use graphene_std::vector::style::{FillChoice, FillChoiceUI, GradientStops, GradientStopsUI};
+use graphene_std::vector::style::{FillChoice, FillChoiceUI, Gradient, GradientUI};
 
 /// Bounds for a midpoint position (relative to the interval between two adjacent gradient stops).
 const MIN_MIDPOINT: f64 = 0.01;
@@ -28,7 +28,7 @@ pub struct ColorPickerMessageHandler {
 	old_is_none: bool,
 
 	// When set, the picker is editing a gradient: the visual pickers and inputs target the active stop's color.
-	gradient: Option<GradientStops>,
+	gradient: Option<Gradient>,
 	active_marker_index: Option<u32>,
 	active_marker_is_midpoint: bool,
 
@@ -430,7 +430,7 @@ impl ColorPickerMessageHandler {
 			// For gradient editing, the markers' handle colors mirror their gradient stop colors
 			let markers = gradient.iter().map(|stop| SpectrumMarker::new(stop.position, stop.midpoint, stop.color)).collect();
 			let mut row_widgets = vec![
-				SpectrumInput::new(GradientStopsUI::from(gradient))
+				SpectrumInput::new(GradientUI::from(gradient))
 					.markers(markers)
 					.active_marker_index(self.active_marker_index)
 					.active_marker_is_midpoint(self.active_marker_is_midpoint)

editor/src/messages/layout/utility_types/widgets/input_widgets.rs

@@ -6,7 +6,7 @@ use derivative::*;
 use graphene_std::Color;
 use graphene_std::color::SRGBA8;
 use graphene_std::transform::ReferencePoint;
-use graphene_std::vector::style::{FillChoiceUI, GradientStopsUI};
+use graphene_std::vector::style::{FillChoiceUI, GradientUI};
 use graphite_proc_macros::WidgetBuilder;
 
 #[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
@@ -531,7 +531,7 @@ pub struct SpectrumInput {
 	// Content
 	/// The colored gradient drawn behind the markers (display-only, caller-owned).
 	#[widget_builder(constructor)]
-	pub track: GradientStopsUI,
+	pub track: GradientUI,
 	/// CSS `linear-gradient(...)` string for the track strip's `background-image`. Auto-populated from `track` at layout-send time.
 	#[serde(rename = "trackCSS")]
 	#[widget_builder(skip)]

editor/src/messages/portfolio/document/data_panel/data_panel_message_handler.rs

@@ -8,12 +8,13 @@ use glam::{Affine2, DAffine2, Vec2};
 use graph_craft::document::NodeId;
 use graphene_std::blending::BlendMode;
 use graphene_std::color::SRGBA8;
-use graphene_std::gradient::GradientStops;
-use graphene_std::list::List;
+use graphene_std::gradient::Gradient;
+use graphene_std::list::{Item, List, NodeIdPath};
 use graphene_std::memo::IORecord;
 use graphene_std::raster_types::{CPU, GPU, Raster};
 use graphene_std::vector::Vector;
-use graphene_std::vector::style::{FillChoice, FillChoiceUI, GradientSpreadMethod, GradientType};
+use graphene_std::vector::misc::BoxCorners;
+use graphene_std::vector::style::{DashPattern, FillChoice, FillChoiceUI, GradientSpreadMethod, GradientType};
 use graphene_std::{Artboard, Color, Context, Graphic};
 use std::any::Any;
 use std::sync::Arc;
@@ -176,10 +177,10 @@ macro_rules! generate_layout_downcast {
 }
 // TODO: We simply try all these types sequentially. Find a better strategy.
 fn generate_layout(introspected_data: &Arc<dyn std::any::Any + Send + Sync + 'static>, data: &mut LayoutData) -> Option<Vec<LayoutGroup>> {
-	// `List<NodeId>` is interpreted as a path (e.g. the value produced by `path_of_subgraph`), shown as a
+	// `Item<NodeIdPath>` is interpreted as a path (e.g. the value produced by `path_of_subgraph`), shown as a
 	// `List` where each item's NodeId resolves against the prefix made up of the items above it.
-	if let Some(io) = introspected_data.downcast_ref::<IORecord<Context, List<NodeId>>>() {
-		return Some(table_node_id_path_layout_with_breadcrumb(&io.output, data));
+	if let Some(io) = introspected_data.downcast_ref::<IORecord<Context, Item<NodeIdPath>>>() {
+		return Some(table_node_id_path_layout_with_breadcrumb(&io.output.element().0, data));
 	}
 	generate_layout_downcast!(introspected_data, data, [
 		List<Artboard>,
@@ -188,16 +189,34 @@ fn generate_layout(introspected_data: &Arc<dyn std::any::Any + Send + Sync + 'st
 		List<Raster<CPU>>,
 		List<Raster<GPU>>,
 		List<Color>,
-		List<GradientStops>,
+		List<Gradient>,
 		List<String>,
 		List<f64>,
-		List<u8>,
 		List<bool>,
 		List<DAffine2>,
 		List<BlendMode>,
 		List<GradientType>,
 		List<GradientSpreadMethod>,
-		GradientStops,
+		Item<Artboard>,
+		Item<Graphic>,
+		Item<Vector>,
+		Item<Raster<CPU>>,
+		Item<Raster<GPU>>,
+		Item<Color>,
+		Item<Gradient>,
+		Item<String>,
+		Item<f64>,
+		Item<u8>,
+		Item<u32>,
+		Item<bool>,
+		Item<DVec2>,
+		Item<DAffine2>,
+		Item<BlendMode>,
+		Item<GradientType>,
+		Item<GradientSpreadMethod>,
+		Item<DashPattern>,
+		Item<BoxCorners>,
+		Gradient,
 		f64,
 		u32,
 		u64,
@@ -246,6 +265,57 @@ trait TableItemLayout {
 	}
 }
 
+impl<T: TableItemLayout> TableItemLayout for Item<T> {
+	fn type_name() -> &'static str {
+		T::type_name()
+	}
+	fn identifier(&self) -> String {
+		self.element().identifier()
+	}
+	fn value_page(&self, data: &mut LayoutData) -> Vec<LayoutGroup> {
+		if let Some(step) = data.desired_path.get(data.current_depth).cloned() {
+			match step {
+				PathStep::Element(_) => {
+					data.current_depth += 1;
+					let result = self.element().layout_with_breadcrumb(data);
+					data.current_depth -= 1;
+					return result;
+				}
+				PathStep::Attribute { key, .. } => {
+					if let Some(any) = self.attributes().get_any(&key) {
+						data.current_depth += 1;
+						if let Some(result) = drilldown_attribute_layout(any, data) {
+							data.current_depth -= 1;
+							return result;
+						}
+						data.current_depth -= 1;
+						warn!("Drilldown unsupported for attribute {key:?}");
+					}
+					data.desired_path.truncate(data.current_depth);
+				}
+			}
+		}
+
+		let attribute_keys: Vec<String> = self.attributes().keys().map(str::to_string).collect();
+
+		// A single element, so no leading ID column, unlike the `List` table
+		let mut values = vec![self.element().value_widget(PathStep::Element(0), data)];
+		for key in &attribute_keys {
+			let target = PathStep::Attribute { row: 0, key: key.clone() };
+			let widget = self.attributes().get_any(key).and_then(|any| dispatch_value_widget(any, target, data)).unwrap_or_else(|| {
+				let text = self.attributes().display_value(key, display_value_override).unwrap_or_else(|| "-".to_string());
+				TextLabel::new(text).narrow(true).widget_instance()
+			});
+			values.push(widget);
+		}
+
+		let mut column_names = vec!["element"];
+		column_names.extend(attribute_keys.iter().map(|s| s.as_str()));
+
+		vec![LayoutGroup::table(vec![column_headings(&column_names), values], false)]
+	}
+}
+
 impl<T: TableItemLayout> TableItemLayout for List<T> {
 	fn type_name() -> &'static str {
 		"List"
@@ -324,12 +394,53 @@ impl TableItemLayout for Artboard {
 	}
 }
 
+impl TableItemLayout for DashPattern {
+	fn type_name() -> &'static str {
+		"DashPattern"
+	}
+	fn identifier(&self) -> String {
+		"DashPattern".to_string()
+	}
+	// The wrapping `Item` already contributes the breadcrumb; the inner list supplies the next level
+	fn layout_with_breadcrumb(&self, data: &mut LayoutData) -> Vec<LayoutGroup> {
+		self.value_page(data)
+	}
+	// Label the spreadsheet's element button with the inner list's identifier, like Artboard
+	fn value_widget(&self, target: PathStep, data: &LayoutData) -> WidgetInstance {
+		self.0.value_widget(target, data)
+	}
+	fn value_page(&self, data: &mut LayoutData) -> Vec<LayoutGroup> {
+		self.0.layout_with_breadcrumb(data)
+	}
+}
+
+impl TableItemLayout for BoxCorners {
+	fn type_name() -> &'static str {
+		"BoxCorners"
+	}
+	fn identifier(&self) -> String {
+		"BoxCorners".to_string()
+	}
+	// The wrapping `Item` already contributes the breadcrumb; the inner list supplies the next level
+	fn layout_with_breadcrumb(&self, data: &mut LayoutData) -> Vec<LayoutGroup> {
+		self.value_page(data)
+	}
+	// Label the spreadsheet's element button with the inner list's identifier, like Artboard
+	fn value_widget(&self, target: PathStep, data: &LayoutData) -> WidgetInstance {
+		self.0.value_widget(target, data)
+	}
+	fn value_page(&self, data: &mut LayoutData) -> Vec<LayoutGroup> {
+		self.0.layout_with_breadcrumb(data)
+	}
+}
+
 impl TableItemLayout for Graphic {
 	fn type_name() -> &'static str {
 		"Graphic"
 	}
 	fn identifier(&self) -> String {
 		match self {
+			Self::None => "None".to_string(),
 			Self::Graphic(list) => list.identifier(),
 			Self::Vector(list) => list.identifier(),
 			Self::RasterCPU(list) => list.identifier(),
@@ -345,6 +456,7 @@ impl TableItemLayout for Graphic {
 	}
 	fn value_page(&self, data: &mut LayoutData) -> Vec<LayoutGroup> {
 		match self {
+			Self::None => label("None"),
 			Self::Graphic(list) => list.layout_with_breadcrumb(data),
 			Self::Vector(list) => list.layout_with_breadcrumb(data),
 			Self::RasterCPU(list) => list.layout_with_breadcrumb(data),
@@ -512,7 +624,7 @@ impl TableItemLayout for Raster<GPU> {
 		format!("Raster ({} x {})", self.data().width(), self.data().height())
 	}
 	fn value_page(&self, _data: &mut LayoutData) -> Vec<LayoutGroup> {
-		let widgets = vec![TextLabel::new("Raster is a texture on the GPU and cannot currently be displayed here").widget_instance()];
+		let widgets = vec![TextLabel::new("This raster data is a texture on the GPU. It currently cannot be displayed here.").widget_instance()];
 		vec![LayoutGroup::row(widgets)]
 	}
 }
@@ -537,7 +649,7 @@ impl TableItemLayout for Color {
 	}
 }
 
-impl TableItemLayout for GradientStops {
+impl TableItemLayout for Gradient {
 	fn type_name() -> &'static str {
 		"Gradient"
 	}
@@ -905,12 +1017,10 @@ macro_rules! known_item_types {
 			List<Raster<CPU>>,
 			List<Raster<GPU>>,
 			List<Color>,
-			List<GradientStops>,
+			List<Gradient>,
 			List<String>,
-			List<NodeId>,
 			List<f64>,
-			List<u8>,
-			GradientStops,
+			Gradient,
 			Color,
 			NodeId,
 			DAffine2,
@@ -949,6 +1059,10 @@ fn display_value_override(any: &dyn Any) -> Option<String> {
 /// element-column rendering and attribute-column rendering. Returns `None` for unrecognized
 /// types so the caller can fall back to a debug-formatted [`TextLabel`].
 fn dispatch_value_widget(any: &dyn Any, target: PathStep, data: &LayoutData) -> Option<WidgetInstance> {
+	// `NodeIdPath` (e.g. the `editor:layer_path` attribute) drills into its inner path list, matching `drilldown_attribute_layout`.
+	if let Some(path) = any.downcast_ref::<NodeIdPath>() {
+		return Some(path.0.value_widget(target, data));
+	}
 	macro_rules! check {
 		( $($ty:ty),* $(,)? ) => {
 			$(
@@ -1005,10 +1119,10 @@ fn table_node_id_path_layout_with_breadcrumb(path: &List<NodeId>, data: &mut Lay
 /// Mirrors [`dispatch_value_widget`] but routes to [`TableItemLayout::layout_with_breadcrumb`].
 /// Returns `None` for unrecognized types.
 fn drilldown_attribute_layout(any: &dyn Any, data: &mut LayoutData) -> Option<Vec<LayoutGroup>> {
-	// `List<NodeId>` is interpreted as a path (e.g. the `editor:layer_path` attribute), so each item's NodeId value
-	// resolves against the prefix made up of preceding items. Handled before the generic `List<T>` blanket impl.
-	if let Some(path) = any.downcast_ref::<List<NodeId>>() {
-		return Some(table_node_id_path_layout_with_breadcrumb(path, data));
+	// `NodeIdPath` is interpreted as a path (e.g. the `editor:layer_path` attribute), so each item's NodeId value
+	// resolves against the prefix made up of preceding items. Handled before the generic blanket impl.
+	if let Some(path) = any.downcast_ref::<NodeIdPath>() {
+		return Some(table_node_id_path_layout_with_breadcrumb(&path.0, data));
 	}
 	macro_rules! check {
 		( $($ty:ty),* $(,)? ) => {