Merge branch 'GraphiteEditor:master' into granular-overlays-settings

Author: seam0s-dev

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

@@ -413,21 +413,13 @@ impl<'a> ModifyInputsContext<'a> {
 	pub fn transform_set_direct(&mut self, transform: DAffine2, skip_rerender: bool, transform_node_id: Option<NodeId>) {
 		// If the Transform node didn't exist yet, create it now
 		let Some(transform_node_id) = transform_node_id.or_else(|| {
-			// Check if the transform is the identity transform within an epsilon
-			let is_identity = {
-				let transform = transform.to_scale_angle_translation();
-				let identity = DAffine2::IDENTITY.to_scale_angle_translation();
-
-				(transform.0.x - identity.0.x).abs() < 1e-6
-					&& (transform.0.y - identity.0.y).abs() < 1e-6
-					&& (transform.1 - identity.1).abs() < 1e-6
-					&& (transform.2.x - identity.2.x).abs() < 1e-6
-					&& (transform.2.y - identity.2.y).abs() < 1e-6
-			};
-
-			// We don't want to pollute the graph with an unnecessary Transform node, so we avoid creating and setting it by returning None
-			if is_identity {
-				return None;
+			// Check if the transform is the identity transform and if so, don't create a new Transform node
+			if let Some((scale, angle, translation)) = (transform.matrix2.determinant() != 0.).then(|| transform.to_scale_angle_translation()) {
+				// Check if the transform is the identity transform within an epsilon
+				if scale.x.abs() < 1e-6 && scale.y.abs() < 1e-6 && angle.abs() < 1e-6 && translation.x.abs() < 1e-6 && translation.y.abs() < 1e-6 {
+					// We don't want to pollute the graph with an unnecessary Transform node, so we avoid creating and setting it by returning None
+					return None;
+				}
 			}
 
 			// Create the Transform node

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

@@ -302,30 +302,6 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 					return;
 				}
 
-				let Some(network_metadata) = network_interface.network_metadata(selection_network_path) else {
-					log::error!("Could not get network metadata in NodeGraphMessage::EnterNestedNetwork");
-					return;
-				};
-
-				let click = ipp.mouse.position;
-				let node_graph_point = network_metadata.persistent_metadata.navigation_metadata.node_graph_to_viewport.inverse().transform_point2(click);
-
-				// Check if clicked on empty area (no node, no input/output connector)
-				let clicked_id = network_interface.node_from_click(click, selection_network_path);
-				let clicked_input = network_interface.input_connector_from_click(click, selection_network_path);
-				let clicked_output = network_interface.output_connector_from_click(click, selection_network_path);
-
-				if clicked_id.is_none() && clicked_input.is_none() && clicked_output.is_none() && self.context_menu.is_none() {
-					// Create a context menu with node creation options
-					self.context_menu = Some(ContextMenuInformation {
-						context_menu_coordinates: (node_graph_point.x as i32, node_graph_point.y as i32),
-						context_menu_data: ContextMenuData::CreateNode { compatible_type: None },
-					});
-
-					responses.add(FrontendMessage::UpdateContextMenuInformation {
-						context_menu_information: self.context_menu.clone(),
-					});
-				}
 				let Some(node_id) = network_interface.node_from_click(ipp.mouse.position, selection_network_path) else {
 					return;
 				};

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

@@ -80,6 +80,11 @@ impl DocumentMetadata {
 	}
 
 	pub fn transform_to_viewport(&self, layer: LayerNodeIdentifier) -> DAffine2 {
+		// We're not allowed to convert the root parent to a node id
+		if layer == LayerNodeIdentifier::ROOT_PARENT {
+			return self.document_to_viewport;
+		}
+
 		let footprint = self.upstream_footprints.get(&layer.to_node()).map(|footprint| footprint.transform).unwrap_or(self.document_to_viewport);
 		let local_transform = self.local_transforms.get(&layer.to_node()).copied().unwrap_or_default();
 

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

@@ -1169,7 +1169,7 @@ impl NodeNetworkInterface {
 			if is_layer && *reference == Some("Merge".to_string()) {
 				"Untitled Layer".to_string()
 			} else {
-				reference.clone().unwrap_or("Untitled node".to_string())
+				reference.clone().unwrap_or("Untitled Node".to_string())
 			}
 		} else {
 			self.display_name(node_id, network_path)

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

@@ -527,6 +527,8 @@ impl Fsm for GradientToolFsmState {
 
 #[cfg(test)]
 mod test_gradient {
+	use crate::messages::input_mapper::utility_types::input_mouse::EditorMouseState;
+	use crate::messages::input_mapper::utility_types::input_mouse::ScrollDelta;
 	use crate::messages::portfolio::document::{graph_operation::utility_types::TransformIn, utility_types::misc::GroupFolderType};
 	pub use crate::test_utils::test_prelude::*;
 	use glam::DAffine2;
@@ -650,4 +652,57 @@ mod test_gradient {
 		assert!(transform.transform_point2(gradient.start).abs_diff_eq(DVec2::new(2., 3.), 1e-10));
 		assert!(transform.transform_point2(gradient.end).abs_diff_eq(DVec2::new(24., 4.), 1e-10));
 	}
+
+	#[tokio::test]
+	async fn double_click_insert_stop() {
+		let mut editor = EditorTestUtils::create();
+		editor.new_document().await;
+
+		editor.drag_tool(ToolType::Rectangle, -5., -3., 100., 100., ModifierKeys::empty()).await;
+
+		editor.select_primary_color(Color::GREEN).await;
+		editor.select_secondary_color(Color::BLUE).await;
+
+		editor.drag_tool(ToolType::Gradient, 0., 0., 100., 0., ModifierKeys::empty()).await;
+
+		// Get initial gradient state (should have 2 stops)
+		let initial_fills = get_fills(&mut editor).await;
+		assert_eq!(initial_fills.len(), 1);
+		let (initial_fill, _) = initial_fills.first().unwrap();
+		let initial_gradient = initial_fill.as_gradient().unwrap();
+		assert_eq!(initial_gradient.stops.len(), 2);
+
+		editor.select_tool(ToolType::Gradient).await;
+
+		// Simulate a double click
+		let click_position = DVec2::new(50., 0.);
+		let modifier_keys = ModifierKeys::empty();
+
+		// Send the DoubleClick event
+		editor
+			.handle_message(InputPreprocessorMessage::DoubleClick {
+				editor_mouse_state: EditorMouseState {
+					editor_position: click_position,
+					mouse_keys: MouseKeys::LEFT,
+					scroll_delta: ScrollDelta::default(),
+				},
+				modifier_keys,
+			})
+			.await;
+
+		// Check that a new stop has been added
+		let updated_fills = get_fills(&mut editor).await;
+		assert_eq!(updated_fills.len(), 1);
+		let (updated_fill, _) = updated_fills.first().unwrap();
+		let updated_gradient = updated_fill.as_gradient().unwrap();
+
+		assert_eq!(updated_gradient.stops.len(), 3);
+
+		let positions: Vec<f64> = updated_gradient.stops.iter().map(|(pos, _)| *pos).collect();
+		assert!(
+			positions.iter().any(|pos| (pos - 0.5).abs() < 0.1),
+			"Expected to find a stop near position 0.5, but found: {:?}",
+			positions
+		);
+	}
 }

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

@@ -356,6 +356,7 @@ struct PenToolData {
 	path_closed: bool,
 
 	handle_mode: HandleMode,
+	prior_segment_layer: Option<LayerNodeIdentifier>,
 	prior_segment_endpoint: Option<PointId>,
 	prior_segment: Option<SegmentId>,
 	handle_type: TargetHandle,
@@ -380,6 +381,13 @@ impl PenToolData {
 		self.latest_points.push(point);
 	}
 
+	fn cleanup(&mut self, responses: &mut VecDeque<Message>) {
+		self.handle_end = None;
+		self.latest_points.clear();
+		self.point_index = 0;
+		self.snap_manager.cleanup(responses);
+	}
+
 	/// Check whether target handle is primary, end, or `self.handle_end`
 	fn check_end_handle_type(&self, vector_data: &VectorData) -> TargetHandle {
 		match (self.handle_end, self.prior_segment_endpoint, self.prior_segment, self.path_closed) {
@@ -1253,9 +1261,13 @@ impl PenToolData {
 		let viewport = document.metadata().document_to_viewport.transform_point2(snapped.snapped_point_document);
 
 		let tolerance = crate::consts::SNAP_POINT_TOLERANCE;
+		self.prior_segment = None;
+		self.prior_segment_endpoint = None;
+		self.prior_segment_layer = None;
 
 		if let Some((layer, point, _position)) = closest_point(document, viewport, tolerance, document.metadata().all_layers(), |_| false, preferences) {
 			self.prior_segment_endpoint = Some(point);
+			self.prior_segment_layer = Some(layer);
 			let vector_data = document.network_interface.compute_modified_vector(layer).unwrap();
 			let segment = vector_data.all_connected(point).collect::<Vec<_>>().first().map(|s| s.segment);
 			self.prior_segment = segment;
@@ -1905,16 +1917,62 @@ impl Fsm for PenToolFsmState {
 
 				state
 			}
-			(PenToolFsmState::DraggingHandle(..) | PenToolFsmState::PlacingAnchor, PenToolMessage::Confirm) => {
+			(PenToolFsmState::DraggingHandle(..), PenToolMessage::Confirm) => {
+				// Confirm to end path
+				if let Some((vector_data, layer)) = layer.and_then(|layer| document.network_interface.compute_modified_vector(layer)).zip(layer) {
+					let single_point_in_layer = vector_data.point_domain.ids().len() == 1;
+					tool_data.finish_placing_handle(SnapData::new(document, input), transform, preferences, responses);
+					let latest_points = tool_data.latest_points.len() == 1;
+
+					if latest_points && single_point_in_layer {
+						responses.add(NodeGraphMessage::DeleteNodes {
+							node_ids: vec![layer.to_node()],
+							delete_children: true,
+						});
+						responses.add(NodeGraphMessage::RunDocumentGraph);
+					} else if (latest_points && tool_data.prior_segment_endpoint.is_none())
+						|| (tool_data.prior_segment_endpoint.is_some() && tool_data.prior_segment_layer != Some(layer) && latest_points)
+					{
+						let vector_modification = VectorModificationType::RemovePoint {
+							id: tool_data.latest_point().unwrap().id,
+						};
+						responses.add(GraphOperationMessage::Vector {
+							layer,
+							modification_type: vector_modification,
+						});
+						responses.add(PenToolMessage::Abort);
+					} else {
+						responses.add(DocumentMessage::EndTransaction);
+					}
+				}
+
+				tool_data.cleanup(responses);
+				tool_data.cleanup_target_selections(shape_editor, layer, document, responses);
+
+				responses.add(OverlaysMessage::Draw);
+
+				PenToolFsmState::Ready
+			}
+			(PenToolFsmState::PlacingAnchor, PenToolMessage::Confirm) => {
 				responses.add(DocumentMessage::EndTransaction);
-				tool_data.handle_end = None;
-				tool_data.latest_points.clear();
-				tool_data.point_index = 0;
-				tool_data.snap_manager.cleanup(responses);
+				tool_data.cleanup(responses);
 				tool_data.cleanup_target_selections(shape_editor, layer, document, responses);
 
 				PenToolFsmState::Ready
 			}
+			(PenToolFsmState::DraggingHandle(..), PenToolMessage::Abort) => {
+				if tool_data.handle_end.is_none() {
+					responses.add(DocumentMessage::AbortTransaction);
+					tool_data.cleanup(responses);
+					tool_data.cleanup_target_selections(shape_editor, layer, document, responses);
+
+					PenToolFsmState::Ready
+				} else {
+					tool_data
+						.place_anchor(SnapData::new(document, input), transform, input.mouse.position, preferences, responses)
+						.unwrap_or(PenToolFsmState::Ready)
+				}
+			}
 			(_, PenToolMessage::Abort) => {
 				let should_delete_layer = if layer.is_some() {
 					let vector_data = document.network_interface.compute_modified_vector(layer.unwrap()).unwrap();
@@ -1924,10 +1982,7 @@ impl Fsm for PenToolFsmState {
 				};
 
 				responses.add(DocumentMessage::AbortTransaction);
-				tool_data.handle_end = None;
-				tool_data.latest_points.clear();
-				tool_data.point_index = 0;
-				tool_data.snap_manager.cleanup(responses);
+				tool_data.cleanup(responses);
 				tool_data.cleanup_target_selections(shape_editor, layer, document, responses);
 
 				if should_delete_layer {
@@ -1989,8 +2044,8 @@ impl Fsm for PenToolFsmState {
 				let mut dragging_hint_data = HintData(Vec::new());
 				dragging_hint_data.0.push(HintGroup(vec![
 					HintInfo::mouse(MouseMotion::Rmb, ""),
-					HintInfo::keys([Key::Escape], "").prepend_slash(),
-					HintInfo::keys([Key::Enter], "End Path").prepend_slash(),
+					HintInfo::keys([Key::Escape], "Cancel Segment").prepend_slash(),
+					HintInfo::keys([Key::Enter], "End Path"),
 				]));
 
 				let mut toggle_group = match mode {

node-graph/gcore/src/graphic_element/renderer.rs

@@ -1,7 +1,6 @@
 mod quad;
 mod rect;
 
-use crate::consts::{LAYER_OUTLINE_STROKE_COLOR, LAYER_OUTLINE_STROKE_WEIGHT};
 use crate::raster::image::ImageFrameTable;
 use crate::raster::{BlendMode, Image};
 use crate::transform::{Footprint, Transform};
@@ -465,6 +464,7 @@ impl GraphicElementRendered for VectorDataTable {
 
 	#[cfg(feature = "vello")]
 	fn render_to_vello(&self, scene: &mut Scene, parent_transform: DAffine2, _: &mut RenderContext, render_params: &RenderParams) {
+		use crate::consts::{LAYER_OUTLINE_STROKE_COLOR, LAYER_OUTLINE_STROKE_WEIGHT};
 		use crate::vector::style::{GradientType, LineCap, LineJoin};
 		use vello::kurbo::{Cap, Join};
 		use vello::peniko;

node-graph/gcore/src/vector/vector_data.rs

@@ -194,9 +194,22 @@ impl VectorData {
 
 	/// Compute the bounding boxes of the subpaths with the specified transform
 	pub fn bounding_box_with_transform(&self, transform: DAffine2) -> Option<[DVec2; 2]> {
-		self.segment_bezier_iter()
+		let combine = |[a_min, a_max]: [DVec2; 2], [b_min, b_max]: [DVec2; 2]| [a_min.min(b_min), a_max.max(b_max)];
+
+		let anchor_bounds = self
+			.point_domain
+			.positions()
+			.iter()
+			.map(|&point| transform.transform_point2(point))
+			.map(|point| [point, point])
+			.reduce(combine);
+
+		let segment_bounds = self
+			.segment_bezier_iter()
 			.map(|(_, bezier, _, _)| bezier.apply_transformation(|point| transform.transform_point2(point)).bounding_box())
-			.reduce(|b1, b2| [b1[0].min(b2[0]), b1[1].max(b2[1])])
+			.reduce(combine);
+
+		anchor_bounds.iter().chain(segment_bounds.iter()).copied().reduce(combine)
 	}
 
 	/// Calculate the corners of the bounding box but with a nonzero size.