fix cmd + g group case

Author: Ayush2k02

editor/src/messages/tool/common_functionality/shape_editor.rs

@@ -421,6 +421,55 @@ impl ShapeState {
 		(point.as_handle().is_some() && self.ignore_handles) || (point.as_anchor().is_some() && self.ignore_anchors)
 	}
 
+	/// Creates a dummy segment insertion to trigger graph reorganization.
+	/// This dummy segment will fail to insert (because PointIds become invalid during execution),
+	/// but the important side effect is that it triggers the reorganization we need.
+	fn create_dummy_segment_to_trigger_graph_reorganization(layer: LayerNodeIdentifier, start_point: PointId, end_point: PointId, responses: &mut VecDeque<Message>) {
+		let dummy_segment_id = SegmentId::generate();
+		let dummy_modification = VectorModificationType::InsertSegment {
+			id: dummy_segment_id,
+			points: [start_point, end_point],
+			handles: [None, None],
+		};
+		responses.add(GraphOperationMessage::Vector {
+			layer,
+			modification_type: dummy_modification,
+		});
+		responses.add(NodeGraphMessage::RunDocumentGraph);
+	}
+
+	/// a two-step process: trigger reorganization, then use position-based lookup.
+	fn handle_grouped_transform_close_path(document: &DocumentMessageHandler, layer: LayerNodeIdentifier, start_point: PointId, end_point: PointId, responses: &mut VecDeque<Message>) {
+		// Get the layer's transform (handles rotation, scaling, translation)
+		let layer_transform = document.metadata().transform_to_document(layer);
+
+		let start_local_pos = document.network_interface.compute_modified_vector(layer).and_then(|v| v.point_domain.position_from_id(start_point));
+		let end_local_pos = document.network_interface.compute_modified_vector(layer).and_then(|v| v.point_domain.position_from_id(end_point));
+
+		if let (Some(start_local), Some(end_local)) = (start_local_pos, end_local_pos) {
+			// Transform positions to document/world space
+			// These positions are stable (won't change during reorganization)
+			let start_pos = layer_transform.transform_point2(start_local);
+			let end_pos = layer_transform.transform_point2(end_local);
+
+			// This segment insertion will fail, but causes point domain reorganization
+			Self::create_dummy_segment_to_trigger_graph_reorganization(layer, start_point, end_point, responses);
+
+			// Defer position-based connection to run after reorganization completes
+			// By then, PointIds will be stable with their new remapped values
+			responses.add(DeferMessage::AfterGraphRun {
+				messages: vec![
+					ToolMessage::Path(PathToolMessage::ConnectPointsByPosition {
+						layer,
+						start_position: start_pos,
+						end_position: end_pos,
+					})
+					.into(),
+				],
+			});
+		}
+	}
+
 	pub fn close_selected_path(&self, document: &DocumentMessageHandler, responses: &mut VecDeque<Message>) {
 		// First collect all selected anchor points across all layers
 		let all_selected_points: Vec<(LayerNodeIdentifier, PointId)> = self
@@ -447,26 +496,33 @@ impl ShapeState {
 			let (layer2, end_point) = all_selected_points[1];
 
 			if layer1 == layer2 {
-				// Same layer: create segment directly
+				// Same layer case
 				if start_point == end_point {
 					return;
 				}
 
-				let segment_id = SegmentId::generate();
-				let modification_type = VectorModificationType::InsertSegment {
-					id: segment_id,
-					points: [end_point, start_point],
-					handles: [None, None],
-				};
-				responses.add(GraphOperationMessage::Vector { layer: layer1, modification_type });
+				// Check if this is a grouped layer with multiple disconnected segments
+				let has_multiple_segments = document.network_interface.compute_modified_vector(layer1).map(|v| v.segment_domain.ids().len() > 1).unwrap_or(false);
+
+				if has_multiple_segments {
+					// Grouped paths: use helper function to handle reorganization
+					Self::handle_grouped_transform_close_path(document, layer1, start_point, end_point, responses);
+				} else {
+					// Single segment: PointIDs are stable, use immediate insertion
+					let segment_id = SegmentId::generate();
+					let modification_type = VectorModificationType::InsertSegment {
+						id: segment_id,
+						points: [end_point, start_point],
+						handles: [None, None],
+					};
+					responses.add(GraphOperationMessage::Vector { layer: layer1, modification_type });
+				}
 			} else {
 				// Different layers: merge first, then create segment
 
 				// Get the local positions of the selected points
-				let start_local_pos = document.network_interface.compute_modified_vector(layer1)
-					.and_then(|v| v.point_domain.position_from_id(start_point));
-				let end_local_pos = document.network_interface.compute_modified_vector(layer2)
-					.and_then(|v| v.point_domain.position_from_id(end_point));
+				let start_local_pos = document.network_interface.compute_modified_vector(layer1).and_then(|v| v.point_domain.position_from_id(start_point));
+				let end_local_pos = document.network_interface.compute_modified_vector(layer2).and_then(|v| v.point_domain.position_from_id(end_point));
 
 				// Transform to document/world space
 				let start_transform = document.metadata().transform_to_document(layer1);
@@ -478,13 +534,15 @@ impl ShapeState {
 
 					merge_layers(document, layer1, layer2, responses);
 
-					// Connect the points
 					responses.add(DeferMessage::AfterGraphRun {
-						messages: vec![ToolMessage::Path(PathToolMessage::ConnectPointsByPosition {
-							layer: layer1,
-							start_position: start_pos,
-							end_position: end_pos,
-						}).into()],
+						messages: vec![
+							ToolMessage::Path(PathToolMessage::ConnectPointsByPosition {
+								layer: layer1,
+								start_position: start_pos,
+								end_position: end_pos,
+							})
+							.into(),
+						],
 					});
 				}
 			}

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

@@ -2689,30 +2689,44 @@ impl Fsm for PathToolFsmState {
 				let mut start_point_id = None;
 				let mut end_point_id = None;
 
-				for (i, &pos) in positions.iter().enumerate() {
-					if start_point_id.is_none() && (pos - start_position).length() < POSITION_TOLERANCE {
+				// Get the merged layer's transform to convert local positions to document space
+				let layer_transform = document.metadata().transform_to_document(layer);
+
+				for (i, &local_pos) in positions.iter().enumerate() {
+					// Transform the local position to document space for comparison
+					let doc_pos = layer_transform.transform_point2(local_pos);
+
+					let start_distance = (doc_pos - start_position).length();
+					let end_distance = (doc_pos - end_position).length();
+
+					if start_point_id.is_none() && start_distance < POSITION_TOLERANCE {
 						start_point_id = Some(point_ids[i]);
 					}
-					if end_point_id.is_none() && (pos - end_position).length() < POSITION_TOLERANCE {
+					if end_point_id.is_none() && end_distance < POSITION_TOLERANCE {
 						end_point_id = Some(point_ids[i]);
 					}
 					if start_point_id.is_some() && end_point_id.is_some() {
 						break;
 					}
 				}
 
-				if let (Some(start_id), Some(end_id)) = (start_point_id, end_point_id) {
-					// Clear existing selection 
-					shape_editor.deselect_all_points();
-					shape_editor.set_selected_layers(vec![layer]);
+			if let (Some(start_id), Some(end_id)) = (start_point_id, end_point_id) {
+				// Create segment directly
+				responses.add(DocumentMessage::StartTransaction);
 
-					shape_editor.select_point_by_layer_and_id(ManipulatorPointId::Anchor(start_id), layer);
-					shape_editor.select_point_by_layer_and_id(ManipulatorPointId::Anchor(end_id), layer);
+				let segment_id = SegmentId::generate();
+				let modification_type = VectorModificationType::InsertSegment {
+					id: segment_id,
+					points: [end_id, start_id],
+					handles: [None, None],
+				};
 
-					responses.add(PathToolMessage::ClosePath);
-				}
+				responses.add(GraphOperationMessage::Vector { layer, modification_type });
+				responses.add(DocumentMessage::EndTransaction);
+				responses.add(OverlaysMessage::Draw);
+			}
 
-				self
+			self
 			}
 			(_, PathToolMessage::StartSlidingPoint) => {
 				responses.add(DocumentMessage::StartTransaction);