Move Vec<NodeId> to Table<NodeId>

Author: Keavon

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

@@ -170,6 +170,7 @@ fn generate_layout(introspected_data: &Arc<dyn std::any::Any + Send + Sync + 'st
 		Table<Color>,
 		Table<GradientStops>,
 		Table<String>,
+		Table<NodeId>,
 		Table<f64>,
 		Table<u8>,
 		GradientStops,
@@ -791,6 +792,26 @@ impl TableRowLayout for AlphaBlending {
 	}
 }
 
+impl TableRowLayout for NodeId {
+	fn type_name() -> &'static str {
+		"NodeId"
+	}
+	fn identifier(&self) -> String {
+		format!("Node {self}")
+	}
+	fn cell_widget(&self, _target: PathStep) -> WidgetInstance {
+		let node_id = *self;
+		TextButton::new("Go to Node")
+			.tooltip_description("Click to select the node with this ID in the graph.")
+			.on_update(move |_| NodeGraphMessage::SelectedNodesSet { nodes: vec![node_id] }.into())
+			.narrow(true)
+			.widget_instance()
+	}
+	fn element_page(&self, _data: &mut LayoutData) -> Vec<LayoutGroup> {
+		vec![LayoutGroup::row(vec![self.cell_widget(PathStep::Element(0))])]
+	}
+}
+
 impl TableRowLayout for Option<NodeId> {
 	fn type_name() -> &'static str {
 		"NodeId"
@@ -830,6 +851,7 @@ macro_rules! known_table_row_types {
 			Table<Color>,
 			Table<GradientStops>,
 			Table<String>,
+			Table<NodeId>,
 			Table<f64>,
 			Table<u8>,
 			GradientStops,

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

@@ -216,7 +216,7 @@ pub enum DocumentNodeMetadata {
 impl DocumentNodeMetadata {
 	pub fn ty(&self) -> Type {
 		match self {
-			DocumentNodeMetadata::DocumentNodePath => concrete!(Vec<NodeId>),
+			DocumentNodeMetadata::DocumentNodePath => concrete!(core_types::table::Table<NodeId>),
 		}
 	}
 }
@@ -930,7 +930,10 @@ impl NodeNetwork {
 			let (tagged_value, exposed) = match previous_export {
 				NodeInput::Value { tagged_value, exposed } => (tagged_value, exposed),
 				NodeInput::Reflection(reflect) => match reflect {
-					DocumentNodeMetadata::DocumentNodePath => (TaggedValue::NodePath(path.to_vec()).into(), false),
+					DocumentNodeMetadata::DocumentNodePath => {
+						let table: core_types::table::Table<NodeId> = path.iter().copied().map(core_types::table::TableRow::new_from_element).collect();
+						(TaggedValue::NodeIdTable(table).into(), false)
+					}
 				},
 				previous_export => {
 					*export = previous_export;

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

@@ -175,17 +175,14 @@ tagged_value! {
 	U64(u64),
 	Bool(bool),
 	String(String),
-	// ========================
-	// LISTS OF PRIMITIVE TYPES
-	// ========================
-	NodePath(Vec<NodeId>),
 	// ===========
 	// TABLE TYPES
 	// ===========
 	StringTable(Table<String>),
 	#[serde(deserialize_with = "core_types::misc::migrate_vec_f64_to_table")] // TODO: Eventually remove this migration document upgrade code
 	#[serde(alias = "VecF64", alias = "VecF32", alias = "F64Array4")]
 	F64Table(Table<f64>),
+	NodeIdTable(Table<NodeId>),
 	#[serde(deserialize_with = "graphic_types::migrations::migrate_vector")] // TODO: Eventually remove this migration document upgrade code
 	#[serde(alias = "VectorData")]
 	Vector(Table<Vector>),

node-graph/interpreted-executor/src/node_registry.rs

@@ -97,6 +97,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Option<f64>]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Option<NodeId>]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Table<String>]),
+		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Table<NodeId>]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Table<f64>]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Table<u8>]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Graphic]),
@@ -153,6 +154,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Image<Color>]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Table<GradientStops>]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Table<String>]),
+		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Table<NodeId>]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Table<f64>]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Table<u8>]),
 		#[cfg(target_family = "wasm")]

node-graph/nodes/gcore/src/context_modification.rs

@@ -28,6 +28,7 @@ async fn context_modification<T>(
 		Context -> DVec2,
 		Context -> Option<NodeId>,
 		Context -> Table<String>,
+		Context -> Table<NodeId>,
 		Context -> Table<f64>,
 		Context -> Table<u8>,
 		Context -> Table<Vector>,

node-graph/nodes/graphic/src/graphic.rs

@@ -173,9 +173,10 @@ where
 /// Used as the value source for stamping the `editor:layer` attribute on each row of a layer's output,
 /// which lets editor tools (e.g. selection, click target routing) trace data back to its owning layer.
 #[node_macro::node(category(""))]
-pub fn parent_layer(_: impl Ctx, node_path: Vec<NodeId>) -> Option<NodeId> {
+pub fn parent_layer(_: impl Ctx, node_path: Table<NodeId>) -> Option<NodeId> {
 	// Get the penultimate element of the node path, or None if the path is too short
-	node_path.get(node_path.len().wrapping_sub(2)).copied()
+	let index = node_path.len().wrapping_sub(2);
+	node_path.element(index).copied()
 }
 
 /// Writes a per-row attribute column on the input table. The value-producing input is evaluated once per row,
@@ -247,11 +248,14 @@ pub async fn legacy_layer_extend<T: 'n + Send + Clone>(
 	#[expose]
 	#[implementations(Table<Artboard>, Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Raster<GPU>>, Table<Color>, Table<GradientStops>)]
 	new: Table<T>,
-	nested_node_path: Vec<NodeId>,
+	nested_node_path: Table<NodeId>,
 ) -> Table<T> {
 	// Get the penultimate element of the node path, or None if the path is too short
 	// This is used to get the ID of the user-facing parent layer-style node (which encapsulates this internal node).
-	let layer = nested_node_path.get(nested_node_path.len().wrapping_sub(2)).copied();
+	let layer = {
+		let index = nested_node_path.len().wrapping_sub(2);
+		nested_node_path.element(index).copied()
+	};
 
 	let mut base = base;
 	for mut row in new.into_iter() {

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

@@ -7,16 +7,19 @@ use vector_types::vector::VectorModification;
 
 /// Applies a differential modification to a vector path, associating changes made by the Pen and Path tools to indices of edited points and segments.
 #[node_macro::node(category(""))]
-async fn path_modify(_ctx: impl Ctx, mut vector: Table<Vector>, modification: Box<VectorModification>, node_path: Vec<NodeId>) -> Table<Vector> {
+async fn path_modify(_ctx: impl Ctx, mut vector: Table<Vector>, modification: Box<VectorModification>, node_path: Table<NodeId>) -> Table<Vector> {
 	use core_types::table::TableRow;
 
 	if vector.is_empty() {
 		vector.push(TableRow::default());
 	}
 	modification.apply(vector.element_mut(0).expect("push should give one item"));
 
-	// Update the source node id
-	let this_node_path = node_path.iter().rev().nth(1).copied();
+	// Update the source node id (penultimate element in the path, identifying the user-facing layer node)
+	let this_node_path = {
+		let index = node_path.len().wrapping_sub(2);
+		node_path.element(index).copied()
+	};
 	let existing: Option<NodeId> = vector.attribute_cloned_or_default("editor:layer", 0);
 	vector.set_attribute("editor:layer", 0, existing.or(this_node_path));