Generalize LayerNodeIdentifier, monitor_nodes support for Artboard node, adjust ResizeArtboard/ClearArtboards, move alias validation to Rust

Author: adamgerhant

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

@@ -835,6 +835,7 @@ impl DocumentMessageHandler {
 		self.metadata
 			.root()
 			.descendants(&self.metadata)
+			//.artboard_descendants(&self.metadata, &self.network)
 			.filter(|&layer| self.selected_nodes.layer_visible(layer, self.metadata()))
 			.filter_map(|layer| self.metadata.click_target(layer).map(|targets| (layer, targets)))
 			.filter(move |(layer, target)| target.iter().any(|target: &ClickTarget| target.intersect_point(point, self.metadata.transform_to_document(*layer))))

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

@@ -197,9 +197,8 @@ impl MessageHandler<GraphOperationMessage, GraphOperationMessageData<'_>> for Gr
 				load_network_structure(document_network, document_metadata, selected_nodes, collapsed);
 			}
 			GraphOperationMessage::ResizeArtboard { id, location, dimensions } => {
-				if let Some(mut modify_inputs) = ModifyInputsContext::new_with_layer(id, document_network, document_metadata, node_graph, responses) {
-					modify_inputs.resize_artboard(location, dimensions);
-				}
+				let mut modify_inputs = ModifyInputsContext::new(document_network, document_metadata, node_graph, responses);
+				modify_inputs.resize_artboard(location, dimensions);
 			}
 			GraphOperationMessage::DeleteLayer { id } => {
 				let mut modify_inputs = ModifyInputsContext::new(document_network, document_metadata, node_graph, responses);
@@ -218,20 +217,15 @@ impl MessageHandler<GraphOperationMessage, GraphOperationMessageData<'_>> for Gr
 			}
 			GraphOperationMessage::ClearArtboards => {
 				let mut modify_inputs = ModifyInputsContext::new(document_network, document_metadata, node_graph, responses);
-				let layer_nodes = modify_inputs.document_network.nodes.iter().filter(|(_, node)| node.is_layer()).map(|(id, _)| *id).collect::<Vec<_>>();
-				for layer in layer_nodes {
-					let artboards = modify_inputs
-						.document_network
-						.upstream_flow_back_from_nodes(vec![layer], true)
-						.filter_map(|(node, _id)| if node.is_artboard() { Some(_id) } else { None })
-						.collect::<Vec<_>>();
-					if artboards.is_empty() {
-						continue;
-					}
-					for artboard in artboards {
-						modify_inputs.delete_artboard(artboard, selected_nodes);
-					}
-					modify_inputs.delete_layer(layer, selected_nodes, true);
+				let artboard_nodes = modify_inputs
+					.document_network
+					.nodes
+					.iter()
+					.filter(|(_, node)| node.is_artboard())
+					.map(|(id, _)| *id)
+					.collect::<Vec<_>>();
+				for artboard in artboard_nodes {
+					modify_inputs.delete_artboard(artboard, selected_nodes);
 				}
 				load_network_structure(document_network, document_metadata, selected_nodes, collapsed);
 			}

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

@@ -177,7 +177,7 @@ impl<'a> ModifyInputsContext<'a> {
 
 		// Update the document metadata structure
 		if let Some(new_id) = new_id {
-			let parent = if self.document_network.nodes.get(&output_node_id).is_some_and(|node| node.is_layer()) {
+			let parent = if self.document_network.nodes.get(&output_node_id).is_some_and(|node| node.is_layer) {
 				LayerNodeIdentifier::new(output_node_id, self.document_network)
 			} else {
 				LayerNodeIdentifier::ROOT
@@ -217,12 +217,6 @@ impl<'a> ModifyInputsContext<'a> {
 			Default::default(),
 		);
 
-		// Doesn't work
-		// let artboard_node = resolve_document_node_type("Artboard").expect("Artboard node").default_document_node();
-
-		// Works
-		// let artboard_node = resolve_document_node_type("Layer").expect("Layer node").default_document_node();
-
 		// Get node that feeds into output. If it exists, connect the new artboard node in between. Else connect the new artboard directly to output.
 		let output_node_primary_input = self.document_network.nodes.get(&output_node_id)?.primary_input();
 		let created_node_id = if let NodeInput::Node { node_id, .. } = &output_node_primary_input? {
@@ -236,6 +230,11 @@ impl<'a> ModifyInputsContext<'a> {
 			shift = IVec2::new(-8, 3);
 			self.insert_node_before(new_id, output_node_id, 0, artboard_node, shift)
 		};
+
+		if let Some(new_id) = created_node_id {
+			let new_child = LayerNodeIdentifier::new_unchecked(new_id);
+			LayerNodeIdentifier::ROOT.push_front_child(self.document_metadata, new_child);
+		}
 		//self.responses.add(NodeGraphMessage::RunDocumentGraph);
 		created_node_id
 	}
@@ -559,8 +558,8 @@ impl<'a> ModifyInputsContext<'a> {
 
 	pub fn resize_artboard(&mut self, location: IVec2, dimensions: IVec2) {
 		self.modify_inputs("Artboard", false, |inputs, _node_id, _metadata| {
-			inputs[1] = NodeInput::value(TaggedValue::IVec2(location), false);
-			inputs[2] = NodeInput::value(TaggedValue::IVec2(dimensions), false);
+			inputs[2] = NodeInput::value(TaggedValue::IVec2(location), false);
+			inputs[3] = NodeInput::value(TaggedValue::IVec2(dimensions), false);
 		});
 	}
 

editor/src/messages/portfolio/document/node_graph/document_node_types.rs

@@ -2984,6 +2984,7 @@ impl DocumentNodeDefinition {
 
 		DocumentNode {
 			name: self.name.to_string(),
+			is_layer: self.is_layer,
 			inputs,
 			manual_composition: self.manual_composition.clone(),
 			has_primary_output: self.has_primary_output,

editor/src/messages/portfolio/document/node_graph/node_graph_message_handler.rs

@@ -700,6 +700,8 @@ impl NodeGraphMessageHandler {
 
 		let mut nodes = Vec::new();
 		for (&node_id, node) in &network.nodes {
+			let alias = (!node.alias.is_empty()).then_some(node.alias.clone()).unwrap_or(node.name.clone());
+
 			let node_path = vec![node_id];
 			// TODO: This should be based on the graph runtime type inference system in order to change the colors of node connectors to match the data type in use
 			let Some(document_node_definition) = document_node_types::resolve_document_node_type(&node.name) else {
@@ -746,8 +748,9 @@ impl NodeGraphMessageHandler {
 
 			nodes.push(FrontendNode {
 				id: node_id,
-				is_layer: node.is_layer,
-				alias: node.alias.clone(),
+				//is_layer: node.is_layer,
+				is_layer: false,
+				alias,
 				name: node.name.clone(),
 				primary_input,
 				exposed_inputs,
@@ -782,7 +785,7 @@ impl NodeGraphMessageHandler {
 					expanded: layer.has_children(metadata) && !collapsed.0.contains(&layer),
 					depth: layer.ancestors(metadata).count() - 1,
 					parent_id: layer.parent(metadata).map(|parent| parent.to_node()),
-					name: network.nodes.get(&node_id).map(|node| node.alias.clone()).unwrap_or_default(),
+					name: network.nodes.get(&node_id).map(|node| node.alias.clone()).unwrap_or(node.name.clone()),
 					tooltip: if cfg!(debug_assertions) { format!("Layer ID: {node_id}") } else { "".into() },
 					visible: node.visible,
 				};

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

@@ -142,16 +142,16 @@ impl DocumentMetadata {
 	/// Loads the structure of layer nodes from a node graph.
 	pub fn load_structure(&mut self, graph: &NodeNetwork, selected_nodes: &mut SelectedNodes) {
 		fn first_child_layer<'a>(graph: &'a NodeNetwork, node: &DocumentNode) -> Option<(&'a DocumentNode, NodeId)> {
-			graph.upstream_flow_back_from_nodes(vec![node.primary_input()?.as_node()?], true).find(|(node, _)| node.is_layer())
+			graph.upstream_flow_back_from_nodes(vec![node.primary_input()?.as_node()?], true).find(|(node, _)| node.is_layer)
 		}
 
 		self.structure = HashMap::from_iter([(LayerNodeIdentifier::ROOT, NodeRelations::default())]);
 		self.artboards = HashSet::new();
 		self.folders = HashSet::new();
 		self.hidden = HashSet::new();
-
-		let id = graph.exports[0].node_id;
-		let Some(output_node) = graph.nodes.get(&id) else {
+		// Refers to output node: NodeId(0)
+		let output_node_id = graph.exports[0].node_id;
+		let Some(output_node) = graph.nodes.get(&output_node_id) else {
 			return;
 		};
 		let Some((layer_node, node_id)) = first_child_layer(graph, output_node) else {
@@ -340,7 +340,7 @@ impl LayerNodeIdentifier {
 	#[track_caller]
 	pub fn new(node_id: NodeId, network: &NodeNetwork) -> Self {
 		debug_assert!(
-			node_id == LayerNodeIdentifier::ROOT.to_node() || network.nodes.get(&node_id).is_some_and(|node| node.is_layer()),
+			node_id == LayerNodeIdentifier::ROOT.to_node() || network.nodes.get(&node_id).is_some_and(|node| node.is_layer),
 			"Layer identifier constructed from non-layer node {node_id}: {:#?}",
 			network.nodes.get(&node_id)
 		);
@@ -418,6 +418,27 @@ impl LayerNodeIdentifier {
 		}
 	}
 
+	/// TODO: Delete this. Only used for comparing to descendants() functionality in click_xray
+	/// Returns an iterator over all artboards connected to ROOT node (output node, id = 0). Should be replaced
+	pub fn artboard_descendants<'a>(self, metadata: &'a DocumentMetadata, network: &'a NodeNetwork) -> DescendantsIter<'a> {
+		let front = network.nodes.get(&NodeId(0)).and_then(|document_node| {
+			if let Some(graph_craft::document::NodeInput::Node { node_id, .. }) = document_node.inputs.get(0).as_ref() {
+				Some(LayerNodeIdentifier::new_unchecked(*node_id))
+			} else {
+				None
+			}
+		});
+		let back = network.nodes.get(&NodeId(0)).and_then(|document_node| {
+			let mut current_node_id = &NodeId(0);
+			// Loop until current node does not have an input of type Node.
+			while let Some(graph_craft::document::NodeInput::Node { node_id, .. }) = &network.nodes.get(&current_node_id).and_then(|document_node| document_node.inputs.get(0)) {
+				current_node_id = node_id;
+			}
+			Some(LayerNodeIdentifier::new_unchecked(*current_node_id))
+		});
+		DescendantsIter { front, back, metadata }
+	}
+
 	/// Add a child towards the top of the Layers panel
 	pub fn push_front_child(self, metadata: &mut DocumentMetadata, new: LayerNodeIdentifier) {
 		assert!(!metadata.structure.contains_key(&new), "Cannot add already existing layer");

editor/src/messages/tool/tool_messages/artboard_tool.rs

@@ -125,7 +125,7 @@ impl ArtboardToolData {
 
 		let mut intersections = document
 			.click_xray(input.mouse.position)
-			.filter(|&layer| is_layer_fed_by_node_of_name(layer, &document.network, "Artboard"));
+			.filter(|&layer| document.network.nodes.get(&layer.to_node()).map_or(false, |document_node| document_node.is_artboard()));
 
 		if let Some(intersection) = intersections.next() {
 			self.selected_artboard = Some(intersection);

editor/src/node_graph_executor.rs

@@ -275,14 +275,28 @@ impl NodeRuntime {
 				continue;
 			};
 
+			enum IntrospectedData<'a> {
+				GraphicElement(&'a graphene_core::GraphicElement),
+				Artboard(&'a graphene_core::Artboard),
+			}
+
+			let introspected_data_output = introspected_data
+				.downcast_ref::<IORecord<Footprint, graphene_core::GraphicElement>>()
+				.and_then(|io_data| Some(IntrospectedData::GraphicElement(&io_data.output)))
+				.or_else(|| {
+					introspected_data
+						.downcast_ref::<IORecord<Footprint, graphene_core::Artboard>>()
+						.and_then(|io_data| Some(IntrospectedData::Artboard(&io_data.output)))
+				});
+
+			let graphic_element: Option<GraphicElement> = match introspected_data_output {
+				Some(IntrospectedData::GraphicElement(graphic_element)) => Some(graphic_element.clone()),
+				Some(IntrospectedData::Artboard(artboard)) => Some(<graphene_core::Artboard as Into<graphene_core::GraphicElement>>::into(artboard.clone())),
+				_ => None,
+			};
 			// If this is `GraphicElement` data:
 			// Regenerate click targets and thumbnails for the layers in the graph, modifying the state and updating the UI.
-			if let Some(io_data) = introspected_data.downcast_ref::<IORecord<Footprint, graphene_core::GraphicElement>>() {
-				let graphic_element = &io_data.output;
-
-				// UPDATE CLICK TARGETS
-
-				// Get the previously stored click targets and wipe them out, then regenerate them
+			if let Some(graphic_element) = graphic_element {
 				let click_targets = self.click_targets.entry(parent_network_node_id).or_default();
 				click_targets.clear();
 				graphic_element.add_click_targets(click_targets);

frontend/src/components/views/Graph.svelte

@@ -884,7 +884,7 @@
 				<div class="details">
 					<!-- TODO: Allow the user to edit the name, just like in the Layers panel -->
 					<span title={editor.instance.inDevelopmentMode() ? `Node ID: ${node.id}` : undefined} bind:offsetWidth={layerNameLabelWidths[String(node.id)]}>
-						{node.alias || "Layer"}
+						{node.alias}
 					</span>
 				</div>
 				<IconButton

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

@@ -811,7 +811,7 @@ impl<'a> Iterator for FlowIter<'a> {
 			let node_id = self.stack.pop()?;
 
 			if let Some(document_node) = self.network.nodes.get(&node_id) {
-				let skip = if document_node.is_layer() { 1 } else { 0 };
+				let skip = if document_node.is_layer { 1 } else { 0 };
 				let take = if self.only_follow_primary { 1 } else { usize::MAX };
 				let inputs = document_node.inputs.iter().skip(skip).take(take);