Node network subgraph editing (#1750)

* Breadcrumb visualization, nested network consistency, create definitions for Merge internal nodes

* Add index to network inputs, remove imports usage from flatten network

* Replace NodeOutput with NodeInput::Node

* Fully remove imports field, remove unnecessary identity nodes, move Output node to encapsulating network

* Replace previous_outputs with root_node, fix adding artboard/layer to empty network

* Import/Export UI nodes

* Display input/output types dynamically from compiled network

* Add LayerNodeIdentifer::ROOT_PARENT

* Prevent .to_node() on ROOT_PARENT

* Separate NodeGraphMessage and GraphOperationMessage

* General bug fixes with nested networks

* Change layer color, various bug fixes and improvements

* Fix disconnect and set node input for proto nodes and UI export node

* Dashed line to export for previewed node

* Fix deleting proto nodes and nodes that feed into export

* Allow modifications to nodes outside of nested network

* Get network from Node Id parameter

* Change root_node to previous_root_node

* Get TaggedValue from proto node implementation type when disconnecting

* Improve preview functionality and state

* Artboard position and delete children fix

* Name inputs/outputs based on DocumentNodeDefinition or type, fix new artboard/layer insertion

* replace "Link" with "Wire", adjust previewing

* Various bug fixes and improvements

* Modify Sample and Poisson-Disk points, fix incorrect input index and deleting currently viewed node

* Open demo artwork

* Fix opening already upgraded documents and refactor FrontendGraphDataType usages

* Fix deleting within network and other bugs

* Get default node input from compiled network when copying, fix previews, tests, demo artwork

* Code cleanup

* Hide EditorApi and add a comment describing unresolved Import node input types

* Code review

* Replace placeholder ROOT_PARENT NodeId with std::u64::MAX

* Breadcrumb padding

---------

Co-authored-by: Keavon Chambers <keavon@keavon.com>

node-graph/gcore/src/consts.rs

@@ -3,3 +3,7 @@ use crate::raster::Color;
 // RENDERING
 pub const LAYER_OUTLINE_STROKE_COLOR: Color = Color::BLACK;
 pub const LAYER_OUTLINE_STROKE_WEIGHT: f64 = 1.;
+
+// Fonts
+pub const DEFAULT_FONT_FAMILY: &str = "Cabin";
+pub const DEFAULT_FONT_STYLE: &str = "Normal (400)";

node-graph/gcore/src/graphic_element.rs

@@ -134,16 +134,16 @@ impl ArtboardGroup {
 	}
 }
 
-pub struct ConstructLayerNode<GraphicElement, Stack> {
-	graphic_element: GraphicElement,
+pub struct ConstructLayerNode<Stack, GraphicElement> {
 	stack: Stack,
+	graphic_element: GraphicElement,
 }
 
 #[node_fn(ConstructLayerNode)]
-async fn construct_layer<Data: Into<GraphicElement>, Fut1: Future<Output = Data>, Fut2: Future<Output = GraphicGroup>>(
+async fn construct_layer<Data: Into<GraphicElement>, Fut1: Future<Output = GraphicGroup>, Fut2: Future<Output = Data>>(
 	footprint: crate::transform::Footprint,
-	graphic_element: impl Node<crate::transform::Footprint, Output = Fut1>,
-	mut stack: impl Node<crate::transform::Footprint, Output = Fut2>,
+	mut stack: impl Node<crate::transform::Footprint, Output = Fut1>,
+	graphic_element: impl Node<crate::transform::Footprint, Output = Fut2>,
 ) -> GraphicGroup {
 	let graphic_element = self.graphic_element.eval(footprint).await;
 	let mut stack = self.stack.eval(footprint).await;
@@ -192,16 +192,16 @@ async fn construct_artboard<Fut: Future<Output = GraphicGroup>>(
 		clip,
 	}
 }
-pub struct AddArtboardNode<Artboard, ArtboardGroup> {
-	artboard: Artboard,
+pub struct AddArtboardNode<ArtboardGroup, Artboard> {
 	artboards: ArtboardGroup,
+	artboard: Artboard,
 }
 
 #[node_fn(AddArtboardNode)]
-async fn add_artboard<Data: Into<Artboard>, Fut1: Future<Output = Data>, Fut2: Future<Output = ArtboardGroup>>(
+async fn add_artboard<Data: Into<Artboard>, Fut1: Future<Output = ArtboardGroup>, Fut2: Future<Output = Data>>(
 	footprint: Footprint,
-	artboard: impl Node<Footprint, Output = Fut1>,
-	mut artboards: impl Node<Footprint, Output = Fut2>,
+	artboards: impl Node<Footprint, Output = Fut1>,
+	artboard: impl Node<Footprint, Output = Fut2>,
 ) -> ArtboardGroup {
 	let artboard = self.artboard.eval(footprint).await;
 	let mut artboards = self.artboards.eval(footprint).await;

node-graph/gcore/src/memo.rs

@@ -177,7 +177,7 @@ impl<T> LetNode<T> {
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct EndLetNode<Input, Parameter> {
 	input: Input,
-	paramenter: PhantomData<Parameter>,
+	parameter: PhantomData<Parameter>,
 }
 impl<'i, T: 'i, Parameter: 'i + From<T>, Input> Node<'i, T> for EndLetNode<Input, Parameter>
 where
@@ -192,7 +192,7 @@ where
 
 impl<Input, Parameter> EndLetNode<Input, Parameter> {
 	pub const fn new(input: Input) -> EndLetNode<Input, Parameter> {
-		EndLetNode { input, paramenter: PhantomData }
+		EndLetNode { input, parameter: PhantomData }
 	}
 }
 

node-graph/gcore/src/ops.rs

@@ -429,17 +429,17 @@ mod test {
 	pub fn map_result() {
 		let value: ClonedNode<Result<&u32, ()>> = ClonedNode(Ok(&4u32));
 		assert_eq!(value.eval(()), Ok(&4u32));
-		//let type_erased_clone = clone as &dyn for<'a> Node<'a, &'a u32, Output = u32>;
+		// let type_erased_clone = clone as &dyn for<'a> Node<'a, &'a u32, Output = u32>;
 		let map_result = MapResultNode::new(ValueNode::new(FnNode::new(|x: &u32| *x)));
-		//et type_erased = &map_result as &dyn for<'a> Node<'a, Result<&'a u32, ()>, Output = Result<u32, ()>>;
+		// let type_erased = &map_result as &dyn for<'a> Node<'a, Result<&'a u32, ()>, Output = Result<u32, ()>>;
 		assert_eq!(map_result.eval(Ok(&4u32)), Ok(4u32));
 		let fst = value.then(map_result);
-		//let type_erased = &fst as &dyn for<'a> Node<'a, (), Output = Result<u32, ()>>;
+		// let type_erased = &fst as &dyn for<'a> Node<'a, (), Output = Result<u32, ()>>;
 		assert_eq!(fst.eval(()), Ok(4u32));
 	}
 	#[test]
 	pub fn flat_map_result() {
-		let fst = ValueNode(Ok(&4u32)).then(CloneNode::new()); //.then(FlatMapResultNode::new(FnNode::new(|x| Ok(x))));
+		let fst = ValueNode(Ok(&4u32)).then(CloneNode::new());
 		let fn_node: FnNode<_, &u32, Result<&u32, _>> = FnNode::new(|_| Err(8u32));
 		assert_eq!(fn_node.eval(&4u32), Err(8u32));
 		let flat_map = FlatMapResultNode::new(ValueNode::new(fn_node));

node-graph/gcore/src/quantization.rs

@@ -186,7 +186,7 @@ mod test {
 		let quantized = quantize_color(color, [quant; 4]);
 		assert_eq!(quantized.0, 0x7f7f7f7f);
 		let _dequantized = dequantize_color(quantized, [quant; 4]);
-		//assert_eq!(color, dequantized);
+		// assert_eq!(color, dequantized);
 	}
 
 	#[test]

node-graph/gcore/src/raster/color.rs

@@ -767,7 +767,7 @@ impl Color {
 	/// ```
 	/// use graphene_core::raster::color::Color;
 	/// let color = Color::from_rgbaf32(0.114, 0.103, 0.98, 0.97).unwrap();
-	/// //TODO: Add test
+	/// // TODO: Add test
 	/// ```
 	#[inline(always)]
 	pub fn to_rgba8_srgb(&self) -> [u8; 4] {

node-graph/gcore/src/types.rs

@@ -118,7 +118,7 @@ impl PartialEq for TypeDescriptor {
 			(Some(id), Some(other_id)) => id == other_id,
 			_ => {
 				// TODO: Add a flag to disable this warning
-				//warn!("TypeDescriptor::eq: comparing types without ids based on name");
+				// warn!("TypeDescriptor::eq: comparing types without ids based on name");
 				self.name == other.name
 			}
 		}
@@ -214,6 +214,15 @@ impl Type {
 			Self::Future(_) => None,
 		}
 	}
+
+	pub fn nested_type(self) -> Type {
+		match self {
+			Self::Generic(_) => self,
+			Self::Concrete(_) => self,
+			Self::Fn(_, output) => output.nested_type(),
+			Self::Future(_) => self,
+		}
+	}
 }
 
 fn format_type(ty: &str) -> String {