Cleanup and add dynamic hints

Author: 4adex

editor/src/messages/input_mapper/input_mappings.rs

@@ -212,7 +212,7 @@ pub fn input_mappings() -> Mapping {
 		entry!(KeyDown(Delete); modifiers=[Shift], action_dispatch=PathToolMessage::BreakPath),
 		entry!(KeyDown(Backspace); modifiers=[Shift], action_dispatch=PathToolMessage::BreakPath),
 		entry!(KeyDownNoRepeat(Tab); action_dispatch=PathToolMessage::SwapSelectedHandles),
-		entry!(KeyDown(MouseLeft); action_dispatch=PathToolMessage::MouseDown { extend_selection: Shift, lasso_select: Control, handle_drag_from_anchor: Alt, drag_restore_handle: Control }),
+		entry!(KeyDown(MouseLeft); action_dispatch=PathToolMessage::MouseDown { extend_selection: Shift, lasso_select: Control, handle_drag_from_anchor: Alt, drag_restore_handle: Control , molding_in_segment_edit: KeyA}),
 		entry!(KeyDown(MouseRight); action_dispatch=PathToolMessage::RightClick),
 		entry!(KeyDown(Escape); action_dispatch=PathToolMessage::Escape),
 		entry!(KeyDown(KeyG); action_dispatch=PathToolMessage::GRS { key: KeyG }),

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

@@ -624,15 +624,6 @@ impl ShapeState {
 		None
 	}
 
-	// pub fn get_segment_selection_state(&mut self, network_interface: &NodeNetworkInterface, mouse_position: DVec2, select_threshold: f64) -> Option<(bool, Option<SelectedSegmentsInfo>)> {
-	// 	if let Some(segment) = self.upper_closest_segment(network_interface, mouse_position, select_threshold) {
-	// 		let vector_data = network_interface.compute_modified_vector(segment.layer);
-
-	// 		let selected_shape_state = self.selected_shape_state.get_mut(&segment.layer)?;
-	// 		let already_selected = selected_shape_state.is_selected_segment(segment.segment);
-	// 	}
-	// }
-
 	pub fn select_anchor_point_by_id(&mut self, layer: LayerNodeIdentifier, id: PointId, extend_selection: bool) {
 		if !extend_selection {
 			self.deselect_all_points();
@@ -1876,15 +1867,14 @@ impl ShapeState {
 				None
 			};
 
-			// Checking the selection of handles
+			// Selection segments
 			for (id, bezier, _, _) in vector_data.segment_bezier_iter() {
 				if select_segments {
-					// Checking for selection of segments if they lie inside the bounding box or lasso polygon
+					// Select segments if they lie inside the bounding box or lasso polygon
 					let segment_bbox = calculate_bezier_bbox(bezier);
 					let bottom_left = transform.transform_point2(segment_bbox[0]);
 					let top_right = transform.transform_point2(segment_bbox[1]);
 
-					// Here take account of toched selection prefrences
 					let select = match selection_shape {
 						SelectionShape::Box(quad) => {
 							let enclosed = quad[0].min(quad[1]).cmple(bottom_left).all() && quad[0].max(quad[1]).cmpge(top_right).all();
@@ -1897,12 +1887,14 @@ impl ShapeState {
 							}
 						}
 						SelectionShape::Lasso(_) => {
-							//First check if the segement bbox intersects with lasso polygon (atleast one of the points of bbox should lie in lasso polygon)
 							let polygon = polygon_subpath.as_ref().expect("If `selection_shape` is a polygon then subpath is constructed beforehand.");
 
-							// Sample 10 points on the bezier and check if all lie inside the polygon or not
+							// Sample 10 points on the bezier and check if all or some lie inside the polygon
 							let points = bezier.compute_lookup_table(Some(10), None);
-							points.map(|p| transform.transform_point2(p)).all(|p| polygon.contains_point(p))
+							match selection_mode {
+								SelectionMode::Enclosed => points.map(|p| transform.transform_point2(p)).all(|p| polygon.contains_point(p)),
+								_ => points.map(|p| transform.transform_point2(p)).any(|p| polygon.contains_point(p)),
+							}
 						}
 					};
 
@@ -1914,7 +1906,7 @@ impl ShapeState {
 					}
 				}
 
-				// Checking for selection of handles
+				// Selecting handles
 				for (position, id) in [(bezier.handle_start(), ManipulatorPointId::PrimaryHandle(id)), (bezier.handle_end(), ManipulatorPointId::EndHandle(id))] {
 					let Some(position) = position else { continue };
 					let transformed_position = transform.transform_point2(position);

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

@@ -70,6 +70,7 @@ pub enum PathToolMessage {
 		lasso_select: Key,
 		handle_drag_from_anchor: Key,
 		drag_restore_handle: Key,
+		molding_in_segment_edit: Key,
 	},
 	NudgeSelectedPoints {
 		delta_x: f64,
@@ -542,6 +543,7 @@ impl PathToolData {
 		lasso_select: bool,
 		handle_drag_from_anchor: bool,
 		drag_zero_handle: bool,
+		molding_in_segment_edit: bool,
 		path_overlay_mode: PathOverlayMode,
 		segment_editing_mode: bool,
 		point_editing_mode: bool,
@@ -655,7 +657,7 @@ impl PathToolData {
 		else if let Some(segment) = shape_editor.upper_closest_segment(&document.network_interface, input.mouse.position, SELECTION_THRESHOLD) {
 			responses.add(DocumentMessage::StartTransaction);
 
-			if segment_editing_mode {
+			if segment_editing_mode && !molding_in_segment_edit {
 				let layer = segment.layer();
 				let segment_id = segment.segment();
 				let already_selected = shape_editor.selected_shape_state.get(&layer).map_or(false, |state| state.is_selected_segment(segment_id));
@@ -1333,7 +1335,7 @@ impl Fsm for PathToolFsmState {
 	fn transition(self, event: ToolMessage, tool_data: &mut Self::ToolData, tool_action_data: &mut ToolActionHandlerData, tool_options: &Self::ToolOptions, responses: &mut VecDeque<Message>) -> Self {
 		let ToolActionHandlerData { document, input, shape_editor, .. } = tool_action_data;
 
-		update_dynamic_hints(self, responses, shape_editor, document, tool_data);
+		update_dynamic_hints(self, responses, shape_editor, document, tool_data, tool_options);
 
 		let ToolMessage::Path(event) = event else { return self };
 		match (self, event) {
@@ -1423,8 +1425,6 @@ impl Fsm for PathToolFsmState {
 						let Some(selected_shape_state) = shape_editor.selected_shape_state.get_mut(&layer) else {
 							continue;
 						};
-						// let selected_segments = selected_shape_state.selected_segments().collect::<Vec<_>>();
-						// log::info!("selected segments are: {:?}", selected_segments);
 						if selected_shape_state.is_selected_segment(segment_id) {
 							overlay_context.outline_select_bezier(bezier, transform);
 						}
@@ -1436,7 +1436,6 @@ impl Fsm for PathToolFsmState {
 						tool_data.update_closest_segment(shape_editor, input.mouse.position, document, tool_options.path_overlay_mode);
 
 						if let Some(closest_segment) = &tool_data.segment {
-							//Do this only when the segment editing mode is turned off
 							if tool_options.path_editing_mode.segment_editing_mode {
 								let transform = document.metadata().transform_to_viewport(closest_segment.layer());
 								overlay_context.outline_overlay_bezier(closest_segment.bezier(), transform);
@@ -1477,7 +1476,7 @@ impl Fsm for PathToolFsmState {
 						let polygon = &tool_data.lasso_polygon;
 
 						match (selection_shape, selection_mode, tool_data.started_drawing_from_inside) {
-							// Don't draw this if it is from inside a shape and selection just began
+							// Don't draw box if it is from inside a shape and selection just began
 							(SelectionShapeType::Box, SelectionMode::Enclosed, false) => overlay_context.dashed_quad(quad, None, fill_color, Some(4.), Some(4.), Some(0.5)),
 							(SelectionShapeType::Lasso, SelectionMode::Enclosed, _) => overlay_context.dashed_polygon(polygon, None, fill_color, Some(4.), Some(4.), Some(0.5)),
 							(SelectionShapeType::Box, _, false) => overlay_context.quad(quad, None, fill_color),
@@ -1528,12 +1527,14 @@ impl Fsm for PathToolFsmState {
 					lasso_select,
 					handle_drag_from_anchor,
 					drag_restore_handle,
+					molding_in_segment_edit,
 				},
 			) => {
 				let extend_selection = input.keyboard.get(extend_selection as usize);
 				let lasso_select = input.keyboard.get(lasso_select as usize);
 				let handle_drag_from_anchor = input.keyboard.get(handle_drag_from_anchor as usize);
 				let drag_zero_handle = input.keyboard.get(drag_restore_handle as usize);
+				let molding_in_segment_edit = input.keyboard.get(molding_in_segment_edit as usize);
 
 				tool_data.selection_mode = None;
 				tool_data.lasso_polygon.clear();
@@ -1547,6 +1548,7 @@ impl Fsm for PathToolFsmState {
 					lasso_select,
 					handle_drag_from_anchor,
 					drag_zero_handle,
+					molding_in_segment_edit,
 					tool_options.path_overlay_mode,
 					tool_options.path_editing_mode.segment_editing_mode,
 					tool_options.path_editing_mode.point_editing_mode,
@@ -1627,15 +1629,6 @@ impl Fsm for PathToolFsmState {
 					tool_data.handle_drag_toggle = true;
 				}
 
-				// This is responsible for selecting all the anchors if nothing is selected
-				// Should also check that if there is some segment selection or not
-
-				// if tool_data.selection_status.is_none() {
-				// 	if let Some(layer) = document.click(input) {
-				// 		shape_editor.select_all_anchors_in_layer(document, layer);
-				// 	}
-				// }
-
 				let anchor_and_handle_toggled = input.keyboard.get(move_anchor_with_handles as usize);
 				let initial_press = anchor_and_handle_toggled && !tool_data.select_anchor_toggled;
 				let released_from_toggle = tool_data.select_anchor_toggled && !anchor_and_handle_toggled;
@@ -1914,7 +1907,7 @@ impl Fsm for PathToolFsmState {
 				};
 
 				if tool_data.drag_start_pos == previous_mouse {
-					// If the click happened inside of a node then don't set selected nodes to empty array
+					// If click happens inside of a shape then don't set selected nodes to empty
 					if document.click(&input).is_none() {
 						responses.add(NodeGraphMessage::SelectedNodesSet { nodes: vec![] });
 					}
@@ -2007,7 +2000,6 @@ impl Fsm for PathToolFsmState {
 				}
 				// Segment editing mode
 				else if let Some(nearest_segment) = nearest_segment {
-					//Condition this upon whether user has selected segment editing mode or not
 					if segment_mode {
 						let clicked_selected = shape_editor.selected_segments().any(|&segment| segment == nearest_segment.segment());
 						if !drag_occurred && extend_selection {
@@ -2409,7 +2401,14 @@ fn calculate_adjacent_anchor_tangent(
 	}
 }
 
-fn update_dynamic_hints(state: PathToolFsmState, responses: &mut VecDeque<Message>, shape_editor: &mut ShapeState, document: &DocumentMessageHandler, tool_data: &PathToolData) {
+fn update_dynamic_hints(
+	state: PathToolFsmState,
+	responses: &mut VecDeque<Message>,
+	shape_editor: &mut ShapeState,
+	document: &DocumentMessageHandler,
+	tool_data: &PathToolData,
+	tool_options: &PathToolOptions,
+) {
 	// Condinting based on currently selected segment if it has any one g1 continuous handle
 
 	let hint_data = match state {
@@ -2443,12 +2442,27 @@ fn update_dynamic_hints(state: PathToolFsmState, responses: &mut VecDeque<Messag
 				drag_selected_hints.push(HintInfo::multi_keys([[Key::Control], [Key::Shift]], "Slide").prepend_plus());
 			}
 
-			let mut hint_data = vec![
-				HintGroup(vec![HintInfo::mouse(MouseMotion::Lmb, "Select Point"), HintInfo::keys([Key::Shift], "Extend").prepend_plus()]),
-				HintGroup(vec![HintInfo::mouse(MouseMotion::LmbDrag, "Select Area"), HintInfo::keys([Key::Control], "Lasso").prepend_plus()]),
-				HintGroup(vec![HintInfo::mouse(MouseMotion::Lmb, "Insert Point on Segment")]),
-				HintGroup(vec![HintInfo::keys_and_mouse([Key::Alt], MouseMotion::Lmb, "Delete Segment")]),
-			];
+			let mut hint_data = match (tool_data.segment.is_some(), tool_options.path_editing_mode.segment_editing_mode) {
+				(true, true) => {
+					vec![
+						HintGroup(vec![HintInfo::mouse(MouseMotion::Lmb, "Select Segment"), HintInfo::keys([Key::Shift], "Extend").prepend_plus()]),
+						HintGroup(vec![HintInfo::keys_and_mouse([Key::KeyA], MouseMotion::Lmb, "Mold Segment")]),
+					]
+				}
+				(true, false) => {
+					vec![
+						HintGroup(vec![HintInfo::mouse(MouseMotion::Lmb, "Insert Point on Segment")]),
+						HintGroup(vec![HintInfo::mouse(MouseMotion::LmbDrag, "Mold Segment")]),
+						HintGroup(vec![HintInfo::keys_and_mouse([Key::Alt], MouseMotion::Lmb, "Delete Segment")]),
+					]
+				}
+				(false, _) => {
+					vec![
+						HintGroup(vec![HintInfo::mouse(MouseMotion::Lmb, "Select Point"), HintInfo::keys([Key::Shift], "Extend").prepend_plus()]),
+						HintGroup(vec![HintInfo::mouse(MouseMotion::LmbDrag, "Select Area"), HintInfo::keys([Key::Control], "Lasso").prepend_plus()]),
+					]
+				}
+			};
 
 			if at_least_one_anchor_selected {
 				// TODO: Dynamically show either "Smooth" or "Sharp" based on the current state

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

@@ -583,26 +583,6 @@ impl ManipulatorPointId {
 	}
 }
 
-// #[derive(Clone, Copy, Debug, DynAny)]
-// pub struct SelectedSegment {
-// 	segment: SegmentId,
-// 	points: [PointId; 2],
-// }
-
-// impl PartialEq for SelectedSegment {
-// 	fn eq(&self, other: &Self) -> bool {
-// 		self.segment == other.segment
-// 	}
-// }
-
-// impl Eq for SelectedSegment {}
-
-// impl Hash for SelectedSegment {
-// 	fn hash<H: Hasher>(&self, state: &mut H) {
-// 		self.segment.hash(state);
-// 	}
-// }
-
 /// The type of handle found on a bézier curve.
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, DynAny)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]