Add invalid type

Author: adamgerhant

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

@@ -7,10 +7,12 @@ use crate::messages::portfolio::document::utility_types::nodes::CollapsedLayers;
 use crate::messages::prelude::*;
 use crate::messages::tool::common_functionality::graph_modification_utils::get_clip_mode;
 use glam::{DAffine2, DVec2, IVec2};
+use graph_craft::document::value::TaggedValue;
 use graph_craft::document::{NodeId, NodeInput};
 use graphene_std::Color;
 use graphene_std::renderer::Quad;
 use graphene_std::renderer::convert_usvg_path::convert_usvg_path;
+use graphene_std::table::Table;
 use graphene_std::text::{Font, TypesettingConfig};
 use graphene_std::vector::style::{Fill, Gradient, GradientStops, GradientType, PaintOrder, Stroke, StrokeAlign, StrokeCap, StrokeJoin};
 
@@ -140,10 +142,16 @@ impl MessageHandler<GraphOperationMessage, GraphOperationMessageContext<'_>> for
 								skip_rerender: true,
 							});
 						}
+						// Set the bottom input of the artboard back to artboard
+						let bottom_input = NodeInput::value(TaggedValue::Artboard(Table::new()), true);
+						network_interface.set_input(&InputConnector::node(artboard_layer.to_node(), 0), bottom_input, &[]);
 					} else {
 						// We have some non layers (e.g. just a rectangle node). We disconnect the bottom input and connect it to the left input.
 						network_interface.disconnect_input(&InputConnector::node(artboard_layer.to_node(), 0), &[]);
 						network_interface.set_input(&InputConnector::node(artboard_layer.to_node(), 1), primary_input, &[]);
+						// Set the bottom input of the artboard back to artboard
+						let bottom_input = NodeInput::value(TaggedValue::Artboard(Table::new()), true);
+						network_interface.set_input(&InputConnector::node(artboard_layer.to_node(), 0), bottom_input, &[]);
 					}
 				}
 				responses.add_front(NodeGraphMessage::SelectedNodesSet { nodes: vec![id] });

editor/src/messages/portfolio/document/node_graph/document_node_definitions/document_node_derive.rs

@@ -6,7 +6,37 @@ use graphene_std::registry::*;
 use graphene_std::*;
 use std::collections::HashSet;
 
+/// Traverses a document node template and metadata in parallel to link the protonodes to their reference
+fn traverse_node(node: &DocumentNode, node_metadata: &mut DocumentNodePersistentMetadata) {
+	match &node.implementation {
+		DocumentNodeImplementation::Network(node_network) => {
+			for (nested_node_id, nested_node) in node_network.nodes.iter() {
+				let nested_metadata = node_metadata
+					.network_metadata
+					.as_mut()
+					.expect("Network node must have network metadata")
+					.persistent_metadata
+					.node_metadata
+					.get_mut(nested_node_id)
+					.expect("Network metadata must have corresponding  node id");
+				traverse_node(nested_node, &mut nested_metadata.persistent_metadata);
+			}
+		}
+		DocumentNodeImplementation::ProtoNode(proto_node_identifier) => {
+			if let Some(metadata) = NODE_METADATA.lock().unwrap().get(&proto_node_identifier) {
+				node_metadata.reference = Some(metadata.display_name.to_string());
+			}
+		}
+		DocumentNodeImplementation::Extract => {}
+	}
+}
+
 pub(super) fn post_process_nodes(mut custom: Vec<DocumentNodeDefinition>) -> Vec<DocumentNodeDefinition> {
+	// Link the protonodes with custom networks to their reference
+	for node in custom.iter_mut() {
+		traverse_node(&node.node_template.document_node, &mut node.node_template.persistent_node_metadata);
+	}
+
 	// Remove struct generics
 	for DocumentNodeDefinition { node_template, .. } in custom.iter_mut() {
 		let NodeTemplate {

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

@@ -23,7 +23,6 @@ use crate::messages::tool::utility_types::{HintData, HintGroup, HintInfo};
 use crate::messages::viewport::Position;
 use glam::{DAffine2, DVec2, IVec2};
 use graph_craft::document::{DocumentNodeImplementation, NodeId, NodeInput};
-use graph_craft::proto::GraphErrors;
 use graphene_std::math::math_ext::QuadExt;
 use graphene_std::vector::algorithms::bezpath_algorithms::bezpath_is_inside_bezpath;
 use graphene_std::*;
@@ -51,7 +50,6 @@ pub struct NodeGraphMessageContext<'a> {
 pub struct NodeGraphMessageHandler {
 	// TODO: Remove network and move to NodeNetworkInterface
 	pub network: Vec<NodeId>,
-	pub node_graph_errors: GraphErrors,
 	has_selection: bool,
 	widgets: [LayoutGroup; 2],
 	/// Used to add a transaction for the first node move when dragging.
@@ -1628,7 +1626,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphMessageContext<'a>> for NodeG
 					if node_bbox[1].x >= document_bbox[0].x && node_bbox[0].x <= document_bbox[1].x && node_bbox[1].y >= document_bbox[0].y && node_bbox[0].y <= document_bbox[1].y {
 						nodes.push(*node_id);
 					}
-					for error in &self.node_graph_errors {
+					for error in &network_interface.resolved_types.node_graph_errors {
 						if error.node_path.contains(node_id) {
 							nodes.push(*node_id);
 						}
@@ -1992,8 +1990,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphMessageContext<'a>> for NodeG
 				responses.add(NodeGraphMessage::SendGraph);
 			}
 			NodeGraphMessage::UpdateTypes { resolved_types, node_graph_errors } => {
-				network_interface.resolved_types.update(resolved_types);
-				self.node_graph_errors = node_graph_errors;
+				network_interface.resolved_types.update(resolved_types, node_graph_errors);
 			}
 			NodeGraphMessage::UpdateActionButtons => {
 				if selection_network_path == breadcrumb_network_path {
@@ -2554,13 +2551,14 @@ impl NodeGraphMessageHandler {
 
 			let locked = network_interface.is_locked(&node_id, breadcrumb_network_path);
 
-			let errors = self
+			let errors = network_interface
+				.resolved_types
 				.node_graph_errors
 				.iter()
 				.find(|error| error.node_path == node_id_path)
 				.map(|error| format!("{:?}", error.error.clone()))
 				.or_else(|| {
-					if self.node_graph_errors.iter().any(|error| error.node_path.starts_with(&node_id_path)) {
+					if network_interface.resolved_types.node_graph_errors.iter().any(|error| error.node_path.starts_with(&node_id_path)) {
 						Some("Node graph type error within this node".to_string())
 					} else {
 						None
@@ -2743,7 +2741,6 @@ impl Default for NodeGraphMessageHandler {
 	fn default() -> Self {
 		Self {
 			network: Vec::new(),
-			node_graph_errors: Vec::new(),
 			has_selection: false,
 			widgets: [LayoutGroup::Row { widgets: Vec::new() }, LayoutGroup::Row { widgets: Vec::new() }],
 			drag_start: None,
@@ -2775,7 +2772,6 @@ impl Default for NodeGraphMessageHandler {
 impl PartialEq for NodeGraphMessageHandler {
 	fn eq(&self, other: &Self) -> bool {
 		self.network == other.network
-			&& self.node_graph_errors == other.node_graph_errors
 			&& self.has_selection == other.has_selection
 			&& self.widgets == other.widgets
 			&& self.drag_start == other.drag_start

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

@@ -1574,7 +1574,6 @@ pub(crate) fn generate_node_properties(node_id: NodeId, context: &mut NodeProper
 				let mut display_decimal_places = None;
 				let mut step = None;
 				let mut unit_suffix = None;
-
 				let input_type = match implementation {
 					DocumentNodeImplementation::ProtoNode(proto_node_identifier) => 'early_return: {
 						if let Some(field) = graphene_std::registry::NODE_METADATA

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

@@ -16,6 +16,7 @@ pub enum FrontendGraphDataType {
 	Color,
 	Gradient,
 	Typography,
+	Invalid,
 }
 
 impl FrontendGraphDataType {

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

@@ -8,7 +8,7 @@ use super::nodes::SelectedNodes;
 use crate::consts::{EXPORTS_TO_RIGHT_EDGE_PIXEL_GAP, EXPORTS_TO_TOP_EDGE_PIXEL_GAP, GRID_SIZE, IMPORTS_TO_LEFT_EDGE_PIXEL_GAP, IMPORTS_TO_TOP_EDGE_PIXEL_GAP};
 use crate::messages::portfolio::document::graph_operation::utility_types::ModifyInputsContext;
 use crate::messages::portfolio::document::node_graph::document_node_definitions::{DocumentNodeDefinition, resolve_document_node_type};
-use crate::messages::portfolio::document::node_graph::utility_types::{Direction, FrontendClickTargets, FrontendGraphInput, FrontendGraphOutput};
+use crate::messages::portfolio::document::node_graph::utility_types::{Direction, FrontendClickTargets, FrontendGraphDataType, FrontendGraphInput, FrontendGraphOutput};
 use crate::messages::portfolio::document::utility_types::network_interface::resolved_types::ResolvedDocumentNodeTypes;
 use crate::messages::portfolio::document::utility_types::wires::{GraphWireStyle, WirePath, WirePathUpdate, build_vector_wire};
 use crate::messages::tool::common_functionality::graph_modification_utils;
@@ -625,7 +625,7 @@ impl NodeNetworkInterface {
 		}
 		let input_type = self.input_type(input_connector, network_path);
 		let data_type = input_type.displayed_type();
-		let resolved_type = input_type.resolved_type_name();
+		let resolved_type = input_type.resolved_type_node_string();
 
 		let connected_to = self
 			.upstream_output_connector(input_connector, network_path)
@@ -656,7 +656,7 @@ impl NodeNetworkInterface {
 
 				let export_name = if !export_name.is_empty() {
 					export_name
-				} else if let Some(export_type_name) = input_type.compiled_nested_type_name() {
+				} else if let Some(export_type_name) = input_type.compiled_nested_type().map(|nested| nested.to_string()) {
 					export_type_name
 				} else {
 					format!("Export index {}", export_index)
@@ -679,7 +679,6 @@ impl NodeNetworkInterface {
 	/// Returns None if there is an error, it is the document network, a hidden primary output or import
 	pub fn frontend_output_from_connector(&mut self, output_connector: &OutputConnector, network_path: &[NodeId]) -> Option<FrontendGraphOutput> {
 		let output_type = self.output_type(output_connector, network_path);
-
 		let (name, description) = match output_connector {
 			OutputConnector::Node { node_id, output_index } => {
 				// Do not display the primary output port for a node if it is a network node with a hidden primary export
@@ -690,7 +689,7 @@ impl NodeNetworkInterface {
 				let node_metadata = self.node_metadata(node_id, network_path)?;
 				let output_name = node_metadata.persistent_metadata.output_names.get(*output_index).cloned().unwrap_or_default();
 
-				let output_name = if !output_name.is_empty() { output_name } else { output_type.resolved_type_name() };
+				let output_name = if !output_name.is_empty() { output_name } else { output_type.resolved_type_node_string() };
 				(output_name, String::new())
 			}
 			OutputConnector::Import(import_index) => {
@@ -707,7 +706,7 @@ impl NodeNetworkInterface {
 
 				let import_name = if !import_name.is_empty() {
 					import_name
-				} else if let Some(import_type_name) = output_type.compiled_nested_type_name() {
+				} else if let Some(import_type_name) = output_type.compiled_nested_type().map(|nested| nested.to_string()) {
 					import_type_name
 				} else {
 					format!("Import index {}", import_index)
@@ -717,7 +716,7 @@ impl NodeNetworkInterface {
 			}
 		};
 		let data_type = output_type.displayed_type();
-		let resolved_type = output_type.resolved_type_name();
+		let resolved_type = output_type.resolved_type_node_string();
 		let mut connected_to = self
 			.outward_wires(network_path)
 			.and_then(|outward_wires| outward_wires.get(output_connector))
@@ -977,7 +976,7 @@ impl NodeNetworkInterface {
 		};
 		let description = input_metadata.input_description.to_string();
 		let name = if input_metadata.input_name.is_empty() {
-			self.input_type(&InputConnector::node(*node_id, input_index), network_path).resolved_type_name()
+			self.input_type(&InputConnector::node(*node_id, input_index), network_path).resolved_type_node_string()
 		} else {
 			input_metadata.input_name.to_string()
 		};
@@ -1015,7 +1014,7 @@ impl NodeNetworkInterface {
 	pub fn description(&self, node_id: &NodeId, network_path: &[NodeId]) -> String {
 		self.get_node_definition(node_id, network_path)
 			.map(|node_definition| node_definition.description.to_string())
-			.filter(|description: &String| description != "TODO")
+			.filter(|description| description != "TODO")
 			.unwrap_or_default()
 	}
 
@@ -2455,7 +2454,10 @@ impl NodeNetworkInterface {
 	pub fn wire_path_from_input(&mut self, input: &InputConnector, graph_wire_style: GraphWireStyle, dashed: bool, network_path: &[NodeId]) -> Option<WirePath> {
 		let (vector_wire, thick) = self.vector_wire_from_input(input, graph_wire_style, network_path)?;
 		let path_string = vector_wire.to_svg();
-		let data_type = self.input_type(input, network_path).displayed_type();
+		let data_type = self
+			.upstream_output_connector(input, network_path)
+			.map(|output| self.output_type(&output, network_path).displayed_type())
+			.unwrap_or(FrontendGraphDataType::General);
 		Some(WirePath {
 			path_string,
 			data_type,