Final changes for merge!

Author: Keavon

demo-artwork/isometric-fountain.graphite

@@ -726,9 +726,6 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 				let center_in_viewport = DAffine2::from_translation(document_to_viewport.inverse().transform_point2(viewport_location - ipp.viewport_bounds.top_left));
 				let center_in_viewport_layerspace = center_in_viewport;
 
-				// Scale the image to fit into a 512x512 box
-				let image_size = image_size / DVec2::splat((image_size.max_element() / 512.).max(1.));
-
 				// Make layer the size of the image
 				let fit_image_size = DAffine2::from_scale_angle_translation(image_size, 0., image_size / -2.);
 

demo-artwork/painted-dreams.graphite

@@ -113,6 +113,7 @@ pub(crate) fn property_from_type(
 			match concrete_type.alias.as_ref().map(|x| x.as_ref()) {
 				// Aliased types (ambiguous values)
 				Some("Percentage") => number_widget(document_node, node_id, index, name, number_input.percentage().min(min(0.)).max(max(100.)), true).into(),
+				Some("SignedPercentage") => number_widget(document_node, node_id, index, name, number_input.percentage().min(min(-100.)).max(max(100.)), true).into(),
 				Some("Angle") => number_widget(document_node, node_id, index, name, number_input.mode_range().min(min(-180.)).max(max(180.)).unit("°"), true).into(),
 				Some("PixelLength") => number_widget(document_node, node_id, index, name, number_input.min(min(0.)).unit("px"), true).into(),
 				Some("Length") => number_widget(document_node, node_id, index, name, number_input.min(min(0.)), true).into(),
@@ -1092,45 +1093,6 @@ fn centroid_widget(document_node: &DocumentNode, node_id: NodeId, index: usize)
 	LayoutGroup::Row { widgets }
 }
 
-pub(crate) fn levels_properties(document_node: &DocumentNode, node_id: NodeId, _context: &mut NodePropertiesContext) -> Vec<LayoutGroup> {
-	let input_shadows = number_widget(document_node, node_id, 1, "Shadows", NumberInput::default().mode_range().min(0.).max(100.).unit("%"), true);
-	let input_midtones = number_widget(document_node, node_id, 2, "Midtones", NumberInput::default().mode_range().min(0.).max(100.).unit("%"), true);
-	let input_highlights = number_widget(document_node, node_id, 3, "Highlights", NumberInput::default().mode_range().min(0.).max(100.).unit("%"), true);
-	let output_minimums = number_widget(document_node, node_id, 4, "Output Minimums", NumberInput::default().mode_range().min(0.).max(100.).unit("%"), true);
-	let output_maximums = number_widget(document_node, node_id, 5, "Output Maximums", NumberInput::default().mode_range().min(0.).max(100.).unit("%"), true);
-
-	vec![
-		LayoutGroup::Row { widgets: input_shadows },
-		LayoutGroup::Row { widgets: input_midtones },
-		LayoutGroup::Row { widgets: input_highlights },
-		LayoutGroup::Row { widgets: output_minimums },
-		LayoutGroup::Row { widgets: output_maximums },
-	]
-}
-
-pub(crate) fn black_and_white_properties(document_node: &DocumentNode, node_id: NodeId, _context: &mut NodePropertiesContext) -> Vec<LayoutGroup> {
-	const MIN: f64 = -200.;
-	const MAX: f64 = 300.;
-	// TODO: Add tint color (blended above using the "Color" blend mode)
-	let tint = color_widget(document_node, node_id, 1, "Tint", ColorButton::default(), true);
-	let r_weight = number_widget(document_node, node_id, 2, "Reds", NumberInput::default().mode_range().min(MIN).max(MAX).unit("%"), true);
-	let y_weight = number_widget(document_node, node_id, 3, "Yellows", NumberInput::default().mode_range().min(MIN).max(MAX).unit("%"), true);
-	let g_weight = number_widget(document_node, node_id, 4, "Greens", NumberInput::default().mode_range().min(MIN).max(MAX).unit("%"), true);
-	let c_weight = number_widget(document_node, node_id, 5, "Cyans", NumberInput::default().mode_range().min(MIN).max(MAX).unit("%"), true);
-	let b_weight = number_widget(document_node, node_id, 6, "Blues", NumberInput::default().mode_range().min(MIN).max(MAX).unit("%"), true);
-	let m_weight = number_widget(document_node, node_id, 7, "Magentas", NumberInput::default().mode_range().min(MIN).max(MAX).unit("%"), true);
-
-	vec![
-		tint,
-		LayoutGroup::Row { widgets: r_weight },
-		LayoutGroup::Row { widgets: y_weight },
-		LayoutGroup::Row { widgets: g_weight },
-		LayoutGroup::Row { widgets: c_weight },
-		LayoutGroup::Row { widgets: b_weight },
-		LayoutGroup::Row { widgets: m_weight },
-	]
-}
-
 pub(crate) fn load_image_properties(document_node: &DocumentNode, node_id: NodeId, _context: &mut NodePropertiesContext) -> Vec<LayoutGroup> {
 	let url = text_widget(document_node, node_id, 1, "URL", true);
 
@@ -1300,14 +1262,34 @@ pub(crate) fn noise_pattern_properties(document_node: &DocumentNode, node_id: No
 }
 
 pub(crate) fn brightness_contrast_properties(document_node: &DocumentNode, node_id: NodeId, _context: &mut NodePropertiesContext) -> Vec<LayoutGroup> {
-	let brightness = number_widget(document_node, node_id, 1, "Brightness", NumberInput::default().min(-150.).max(150.), true);
-	let contrast = number_widget(document_node, node_id, 2, "Contrast", NumberInput::default().min(-100.).max(100.), true);
-	let use_legacy = bool_widget(document_node, node_id, 3, "Use Legacy", CheckboxInput::default(), true);
+	let is_use_classic = match &document_node.inputs[3].as_value() {
+		Some(&TaggedValue::Bool(value)) => value,
+		_ => false,
+	};
+	let ((b_min, b_max), (c_min, c_max)) = if is_use_classic { ((-100., 100.), (-100., 100.)) } else { ((-100., 150.), (-50., 100.)) };
+
+	let brightness = number_widget(
+		document_node,
+		node_id,
+		1,
+		"Brightness",
+		NumberInput::default().mode_range().range_min(Some(b_min)).range_max(Some(b_max)).unit("%").display_decimal_places(2),
+		true,
+	);
+	let contrast = number_widget(
+		document_node,
+		node_id,
+		2,
+		"Contrast",
+		NumberInput::default().mode_range().range_min(Some(c_min)).range_max(Some(c_max)).unit("%").display_decimal_places(2),
+		true,
+	);
+	let use_classic = bool_widget(document_node, node_id, 3, "Use Classic", CheckboxInput::default(), true);
 
 	vec![
 		LayoutGroup::Row { widgets: brightness },
 		LayoutGroup::Row { widgets: contrast },
-		LayoutGroup::Row { widgets: use_legacy },
+		LayoutGroup::Row { widgets: use_classic },
 	]
 }
 
@@ -2620,11 +2602,3 @@ pub(crate) fn color_fill_properties(document_node: &DocumentNode, node_id: NodeI
 	let color = color_widget(document_node, node_id, 1, "Color", ColorButton::default(), true);
 	vec![color]
 }
-
-pub(crate) fn color_overlay_properties(document_node: &DocumentNode, node_id: NodeId, _context: &mut NodePropertiesContext) -> Vec<LayoutGroup> {
-	let color = color_widget(document_node, node_id, 1, "Color", ColorButton::default(), true);
-	let blend_mode = blend_mode(document_node, node_id, 2, "Blend Mode", true);
-	let opacity = number_widget(document_node, node_id, 3, "Opacity", NumberInput::default().percentage(), true);
-
-	vec![color, blend_mode, LayoutGroup::Row { widgets: opacity }]
-}

demo-artwork/procedural-string-lights.graphite

@@ -465,6 +465,9 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
 						// 	document.network_interface.set_implementation(node_id, &[], document_node.implementation);
 						// }
 						document.network_interface.replace_implementation(node_id, &[], document_node.implementation);
+						document
+							.network_interface
+							.replace_implementation_metadata(node_id, &[], node_definition.default_node_template().persistent_node_metadata);
 					}
 					let Some(node) = document.network_interface.network(&[]).unwrap().nodes.get(node_id) else {
 						log::error!("could not get node in deserialize_document");
@@ -528,7 +531,7 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
 						}
 					}
 
-					// Upgrade construct layer implementation from https://github.com/GraphiteEditor/Graphite/pull/1946
+					// Upgrade layer implementation from https://github.com/GraphiteEditor/Graphite/pull/1946
 					if reference == "Merge" || reference == "Artboard" {
 						let node_definition = crate::messages::portfolio::document::node_graph::document_node_definitions::resolve_document_node_type(reference).unwrap();
 						let new_merge_node = node_definition.default_node_template();

demo-artwork/red-dress.graphite

@@ -461,6 +461,7 @@
 		<LayoutCol class="table">
 			{#if rulersVisible}
 				<LayoutRow class="ruler-or-scrollbar top-ruler">
+					<LayoutCol class="ruler-corner"></LayoutCol>
 					<RulerInput origin={rulerOrigin.x} majorMarkSpacing={rulerSpacing} numberInterval={rulerInterval} direction="Horizontal" bind:this={rulerHorizontal} />
 				</LayoutRow>
 			{/if}
@@ -653,8 +654,23 @@
 					flex: 0 0 auto;
 				}
 
+				.ruler-corner {
+					background: var(--color-2-mildblack);
+					width: 16px;
+					position: relative;
+
+					&::after {
+						content: "";
+						background: var(--color-5-dullgray);
+						position: absolute;
+						width: 1px;
+						height: 1px;
+						right: 0;
+						bottom: 0;
+					}
+				}
+
 				.top-ruler .ruler-input {
-					padding-left: 16px;
 					margin-right: 16px;
 				}
 

demo-artwork/valley-of-spires.graphite

@@ -116,16 +116,19 @@
 <style lang="scss" global>
 	.ruler-input {
 		flex: 1 1 100%;
-		background: var(--color-4-dimgray);
+		background: var(--color-2-mildblack);
 		overflow: hidden;
 		position: relative;
+		box-sizing: border-box;
 
 		&.horizontal {
 			height: 16px;
+			border-bottom: 1px solid var(--color-5-dullgray);
 		}
 
 		&.vertical {
 			width: 16px;
+			border-right: 1px solid var(--color-5-dullgray);
 
 			svg text {
 				text-anchor: end;
@@ -137,7 +140,7 @@
 
 			path {
 				stroke-width: 1px;
-				stroke: var(--color-6-lowergray);
+				stroke: var(--color-5-dullgray);
 			}
 
 			text {

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

@@ -735,7 +735,7 @@ impl EditorHandle {
 				for node_id in nodes_to_upgrade {
 					document
 						.network_interface
-						.replace_implementation(&node_id, &[], DocumentNodeImplementation::proto("graphene_core::ConstructArtboardNode"));
+						.replace_implementation(&node_id, &[], DocumentNodeImplementation::proto("graphene_core::ToArtboardNode"));
 					document
 						.network_interface
 						.add_input(&node_id, &[], TaggedValue::IVec2(glam::IVec2::default()), false, 2, "".to_string());

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

@@ -102,7 +102,7 @@ Instead of manually implementing the `Node` trait with complex generics, one can
 
 ```rs
 #[node_macro::node(category("Raster: Adjustments"))]
-fn opacity_node(_input: (), #[default(424242)] color: Color,#[min(0.1)] opacity_multiplier: f64) -> Color {
+fn opacity(_input: (), #[default(424242)] color: Color,#[min(0.1)] opacity_multiplier: f64) -> Color {
 	let opacity_multiplier = opacity_multiplier as f32 / 100.;
 	Color::from_rgbaf32_unchecked(color.r(), color.g(), color.b(), color.a() * opacity_multiplier)
 }

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

@@ -6,7 +6,6 @@ use crate::vector::VectorData;
 use crate::Color;
 
 use dyn_any::DynAny;
-use node_macro::node;
 
 use core::ops::{Deref, DerefMut};
 use glam::{DAffine2, IVec2};
@@ -227,13 +226,13 @@ impl ArtboardGroup {
 		Default::default()
 	}
 
-	fn add_artboard(&mut self, artboard: Artboard, node_id: Option<NodeId>) {
+	fn append_artboard(&mut self, artboard: Artboard, node_id: Option<NodeId>) {
 		self.artboards.push((artboard, node_id));
 	}
 }
 
-#[node]
-async fn construct_layer<F: 'n + Copy + Send>(
+#[node_macro::node(category(""))]
+async fn layer<F: 'n + Copy + Send>(
 	#[implementations((), Footprint)] footprint: F,
 	#[implementations(((), GraphicGroup), (Footprint, GraphicGroup))] stack: impl Node<F, Output = GraphicGroup>,
 	#[implementations(((), GraphicElement), (Footprint, GraphicElement))] graphic_element: impl Node<F, Output = GraphicElement>,
@@ -254,8 +253,8 @@ async fn construct_layer<F: 'n + Copy + Send>(
 	stack
 }
 
-#[node]
-async fn to_graphic_element<F: 'n + Send, Data: Into<GraphicElement> + 'n>(
+#[node_macro::node(category("Debug"))]
+async fn to_element<F: 'n + Send, Data: Into<GraphicElement> + 'n>(
 	#[implementations((), (), (), (), Footprint)] footprint: F,
 	#[implementations(
 	 	((), VectorData),
@@ -272,8 +271,8 @@ async fn to_graphic_element<F: 'n + Send, Data: Into<GraphicElement> + 'n>(
 	data.eval(footprint).await.into()
 }
 
-#[node(name("Group"), category("General"))]
-async fn group<F: 'n + Send, Data: Into<GraphicGroup> + 'n>(
+#[node_macro::node(category("General"))]
+async fn to_group<F: 'n + Send, Data: Into<GraphicGroup> + 'n>(
 	#[implementations((), (), (), (), Footprint)] footprint: F,
 	#[implementations(
 		((), VectorData),
@@ -290,8 +289,8 @@ async fn group<F: 'n + Send, Data: Into<GraphicGroup> + 'n>(
 	element.eval(footprint).await.into()
 }
 
-#[node]
-async fn construct_artboard<F: 'n + Copy + Send + ApplyTransform>(
+#[node_macro::node(category(""))]
+async fn to_artboard<F: 'n + Copy + Send + ApplyTransform>(
 	#[implementations((), Footprint)] mut footprint: F,
 	#[implementations(((), GraphicGroup), (Footprint, GraphicGroup))] contents: impl Node<F, Output = GraphicGroup>,
 	label: String,
@@ -312,8 +311,8 @@ async fn construct_artboard<F: 'n + Copy + Send + ApplyTransform>(
 		clip,
 	}
 }
-#[node]
-async fn add_artboard<F: 'n + Copy + Send>(
+#[node_macro::node(category(""))]
+async fn append_artboard<F: 'n + Copy + Send>(
 	#[implementations((), Footprint)] footprint: F,
 	#[implementations(((), ArtboardGroup), (Footprint, ArtboardGroup))] artboards: impl Node<F, Output = ArtboardGroup>,
 	#[implementations(((), Artboard), (Footprint, Artboard))] artboard: impl Node<F, Output = Artboard>,
@@ -324,7 +323,7 @@ async fn add_artboard<F: 'n + Copy + Send>(
 
 	// Get the penultimate element of the node path, or None if the path is too short
 	let encapsulating_node_id = node_path.get(node_path.len().wrapping_sub(2)).copied();
-	artboards.add_artboard(artboard, encapsulating_node_id);
+	artboards.append_artboard(artboard, encapsulating_node_id);
 
 	artboards
 }

editor/src/messages/portfolio/portfolio_message_handler.rs

@@ -224,75 +224,75 @@ fn logical_not(_: (), input: bool) -> bool {
 }
 
 // Bool Value
-#[node_macro::node(category("Value"), name("Bool Value"))]
+#[node_macro::node(category("Value"))]
 fn bool_value(_: (), _primary: (), #[name("Bool")] bool_value: bool) -> bool {
 	bool_value
 }
 
 // Number Value
-#[node_macro::node(category("Value"), name("Number Value"))]
+#[node_macro::node(category("Value"))]
 fn number_value(_: (), _primary: (), number: f64) -> f64 {
 	number
 }
 
 // Percentage Value
-#[node_macro::node(category("Value"), name("Percentage Value"))]
+#[node_macro::node(category("Value"))]
 fn percentage_value(_: (), _primary: (), percentage: Percentage) -> f64 {
 	percentage
 }
 
 // Vector2 Value
-#[node_macro::node(category("Value"), name("Vector2 Value"))]
+#[node_macro::node(category("Value"))]
 fn vector2_value(_: (), _primary: (), x: f64, y: f64) -> glam::DVec2 {
 	glam::DVec2::new(x, y)
 }
 
 // TODO: Make it possible to give Color::BLACK instead of 000000ff as the default
 // Color Value
-#[node_macro::node(category("Value"), name("Color Value"))]
+#[node_macro::node(category("Value"))]
 fn color_value(_: (), _primary: (), #[default(000000ff)] color: crate::Color) -> crate::Color {
 	color
 }
 
 // Gradient Value
-#[node_macro::node(category("Value"), name("Gradient Value"))]
+#[node_macro::node(category("Value"))]
 fn gradient_value(_: (), _primary: (), gradient: crate::vector::style::GradientStops) -> crate::vector::style::GradientStops {
 	gradient
 }
 
 // Color Channel Value
-#[node_macro::node(category("Value"), name("Color Channel Value"))]
+#[node_macro::node(category("Value"))]
 fn color_channel_value(_: (), _primary: (), color_channel: crate::raster::adjustments::RedGreenBlue) -> crate::raster::adjustments::RedGreenBlue {
 	color_channel
 }
 
 // Blend Mode Value
-#[node_macro::node(category("Value"), name("Blend Mode Value"))]
+#[node_macro::node(category("Value"))]
 fn blend_mode_value(_: (), _primary: (), blend_mode: crate::raster::BlendMode) -> crate::raster::BlendMode {
 	blend_mode
 }
 
 // Size Of
 #[cfg(feature = "std")]
-#[node_macro::node]
+#[node_macro::node(category("Debug"))]
 fn size_of(_: (), ty: crate::Type) -> Option<usize> {
 	ty.size()
 }
 
 // Some
-#[node_macro::node]
+#[node_macro::node(category("Debug"))]
 fn some<T>(_: (), #[implementations(f64, f32, u32, u64, String, crate::Color)] input: T) -> Option<T> {
 	Some(input)
 }
 
 // Unwrap
-#[node_macro::node]
+#[node_macro::node(category("Debug"))]
 fn unwrap<T: Default>(_: (), #[implementations(Option<f64>, Option<f32>, Option<u32>, Option<u64>, Option<String>, Option<crate::Color>)] input: Option<T>) -> T {
 	input.unwrap_or_default()
 }
 
 // Clone
-#[node_macro::node]
+#[node_macro::node(category("Debug"))]
 fn clone<'i, T: Clone + 'i>(_: (), #[implementations(&crate::raster::ImageFrame<crate::Color>)] value: &'i T) -> T {
 	value.clone()
 }