Add proportional editing to the Path tool

editor/src/consts.rs

@@ -122,6 +122,7 @@ pub const ASYMPTOTIC_EFFECT: f64 = 0.5;
 pub const SCALE_EFFECT: f64 = 0.5;
 
 // COLORS
+pub const COLOR_OVERLAY_TRANSPARENT: &str = "transparent";
 pub const COLOR_OVERLAY_BLUE: &str = "#00a8ff";
 pub const COLOR_OVERLAY_YELLOW: &str = "#ffc848";
 pub const COLOR_OVERLAY_GREEN: &str = "#63ce63";

editor/src/messages/input_mapper/input_mappings.rs

@@ -251,6 +251,8 @@ pub fn input_mappings() -> Mapping {
 		entry!(KeyDown(ArrowDown); modifiers=[Shift, ArrowLeft], action_dispatch=PathToolMessage::NudgeSelectedPoints { delta_x: -BIG_NUDGE_AMOUNT, delta_y: BIG_NUDGE_AMOUNT }),
 		entry!(KeyDown(ArrowDown); modifiers=[Shift, ArrowRight], action_dispatch=PathToolMessage::NudgeSelectedPoints { delta_x: BIG_NUDGE_AMOUNT, delta_y: BIG_NUDGE_AMOUNT }),
 		entry!(KeyDown(KeyJ); modifiers=[Accel], action_dispatch=ToolMessage::Path(PathToolMessage::ClosePath)),
+		entry!(KeyDown(KeyP); modifiers=[Alt], action_dispatch=PathToolMessage::ToggleProportionalEditing),
+		entry!(WheelScroll; action_dispatch=PathToolMessage::AdjustProportionalRadius),
 		//
 		// PenToolMessage
 		entry!(PointerMove; refresh_keys=[Control, Alt, Shift, KeyC], action_dispatch=PenToolMessage::PointerMove { snap_angle: Shift, break_handle: Alt, lock_angle: Control, colinear: KeyC, move_anchor_with_handles: Space }),
@@ -376,9 +378,9 @@ pub fn input_mappings() -> Mapping {
 		entry!(KeyDown(ArrowRight); action_dispatch=DocumentMessage::NudgeSelectedLayers { delta_x: NUDGE_AMOUNT, delta_y: 0., resize: Alt, resize_opposite_corner: Control }),
 		//
 		// TransformLayerMessage
-		entry!(KeyDown(KeyG); action_dispatch=TransformLayerMessage::BeginGRS { transform_type: TransformType::Grab }),
-		entry!(KeyDown(KeyR); action_dispatch=TransformLayerMessage::BeginGRS { transform_type: TransformType::Rotate }),
-		entry!(KeyDown(KeyS); action_dispatch=TransformLayerMessage::BeginGRS { transform_type: TransformType::Scale }),
+		entry!(KeyDown(KeyG); action_dispatch=TransformLayerMessage::BeginGRS { transform_type: TransformType::Grab, proportional_editing_data: None }),
+		entry!(KeyDown(KeyR); action_dispatch=TransformLayerMessage::BeginGRS { transform_type: TransformType::Rotate, proportional_editing_data: None }),
+		entry!(KeyDown(KeyS); action_dispatch=TransformLayerMessage::BeginGRS { transform_type: TransformType::Scale, proportional_editing_data: None }),
 		entry!(KeyDown(Digit0); action_dispatch=TransformLayerMessage::TypeDigit { digit: 0 }),
 		entry!(KeyDown(Digit1); action_dispatch=TransformLayerMessage::TypeDigit { digit: 1 }),
 		entry!(KeyDown(Digit2); action_dispatch=TransformLayerMessage::TypeDigit { digit: 2 }),

editor/src/messages/layout/utility_types/widgets/input_widgets.rs

@@ -67,6 +67,10 @@ pub struct DropdownInput {
 
 	#[serde(skip)]
 	pub tooltip_shortcut: Option<ActionKeys>,
+
+	// Styling
+	#[serde(rename = "minWidth")]
+	pub min_width: u32,
 	//
 	// Callbacks
 	// `on_update` exists on the `MenuListEntry`, not this parent `DropdownInput`

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

@@ -4,4 +4,5 @@ pub mod error;
 pub mod misc;
 pub mod network_interface;
 pub mod nodes;
+pub mod proportional_editing;
 pub mod transformation;

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

@@ -0,0 +1,273 @@
+use glam::DVec2;
+use graphene_std::vector::PointId;
+use std::collections::{HashMap, HashSet};
+
+use super::document_metadata::LayerNodeIdentifier;
+use crate::messages::prelude::*;
+use crate::messages::tool::{
+	common_functionality::shape_editor::ShapeState,
+	tool_messages::{
+		path_tool::{PathOptionsUpdate, PathToolData, PathToolOptions},
+		tool_prelude::{DropdownInput, LayoutGroup, MenuListEntry, NumberInput, Separator, SeparatorType, TextLabel},
+	},
+};
+
+#[derive(PartialEq, Eq, Hash, Copy, Clone, Debug, Default, serde::Serialize, serde::Deserialize, specta::Type)]
+pub enum ProportionalFalloffType {
+	#[default]
+	Smooth = 0,
+	Sphere = 1,
+	Root = 2,
+	InverseSquare = 3,
+	Sharp = 4,
+	Linear = 5,
+	Constant = 6,
+	Random = 7,
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq)]
+pub struct ProportionalEditingData {
+	pub center: DVec2,
+	pub affected_points: HashMap<LayerNodeIdentifier, Vec<(PointId, f64)>>,
+	pub falloff_type: ProportionalFalloffType,
+	pub radius: u32,
+}
+
+pub fn proportional_editing_options(options: &PathToolOptions) -> Vec<LayoutGroup> {
+	let mut widgets = Vec::new();
+
+	// Header row with title
+	widgets.push(LayoutGroup::Row {
+		widgets: vec![TextLabel::new("Proportional Editing").bold(true).widget_holder()],
+	});
+
+	let callback = |message| Message::Batched(Box::new([PathToolMessage::UpdateOptions(PathOptionsUpdate::ProportionalEditingEnabled(true)).into(), message]));
+
+	// Falloff type row
+	widgets.push(LayoutGroup::Row {
+		widgets: vec![
+			TextLabel::new("Falloff").table_align(true).min_width(80).widget_holder(),
+			Separator::new(SeparatorType::Unrelated).widget_holder(),
+			DropdownInput::new(vec![vec![
+				MenuListEntry::new("Smooth")
+					.label("Smooth")
+					.on_commit(move |_| callback(PathToolMessage::UpdateOptions(PathOptionsUpdate::ProportionalFalloffType(ProportionalFalloffType::Smooth)).into())),
+				MenuListEntry::new("Sphere")
+					.label("Sphere")
+					.on_commit(move |_| callback(PathToolMessage::UpdateOptions(PathOptionsUpdate::ProportionalFalloffType(ProportionalFalloffType::Sphere)).into())),
+				MenuListEntry::new("Root")
+					.label("Root")
+					.on_commit(move |_| callback(PathToolMessage::UpdateOptions(PathOptionsUpdate::ProportionalFalloffType(ProportionalFalloffType::Root)).into())),
+				MenuListEntry::new("Inverse Square")
+					.label("Inverse Square")
+					.on_commit(move |_| callback(PathToolMessage::UpdateOptions(PathOptionsUpdate::ProportionalFalloffType(ProportionalFalloffType::InverseSquare)).into())),
+				MenuListEntry::new("Sharp")
+					.label("Sharp")
+					.on_commit(move |_| callback(PathToolMessage::UpdateOptions(PathOptionsUpdate::ProportionalFalloffType(ProportionalFalloffType::Sharp)).into())),
+				MenuListEntry::new("Linear")
+					.label("Linear")
+					.on_commit(move |_| callback(PathToolMessage::UpdateOptions(PathOptionsUpdate::ProportionalFalloffType(ProportionalFalloffType::Linear)).into())),
+				MenuListEntry::new("Constant")
+					.label("Constant")
+					.on_commit(move |_| callback(PathToolMessage::UpdateOptions(PathOptionsUpdate::ProportionalFalloffType(ProportionalFalloffType::Constant)).into())),
+				MenuListEntry::new("Random")
+					.label("Random")
+					.on_commit(move |_| callback(PathToolMessage::UpdateOptions(PathOptionsUpdate::ProportionalFalloffType(ProportionalFalloffType::Random)).into())),
+			]])
+			.min_width(120)
+			.selected_index(Some(options.proportional_falloff_type as u32))
+			.widget_holder(),
+		],
+	});
+
+	// Radius row
+	widgets.push(LayoutGroup::Row {
+		widgets: vec![
+			TextLabel::new("Radius").table_align(true).min_width(80).widget_holder(),
+			Separator::new(SeparatorType::Unrelated).widget_holder(),
+			NumberInput::new(Some(options.proportional_radius as f64))
+				.unit(" px")
+				.min(1.)
+				.int()
+				.min_width(120)
+				.on_update(move |number_input| callback(PathToolMessage::UpdateOptions(PathOptionsUpdate::ProportionalRadius(number_input.value.unwrap_or(1.) as u32)).into()))
+				.widget_holder(),
+		],
+	});
+
+	widgets
+}
+
+pub fn calculate_proportional_affected_points(
+	path_tool_data: &mut PathToolData,
+	document: &DocumentMessageHandler,
+	shape_editor: &ShapeState,
+	radius: u32,
+	proportional_falloff_type: ProportionalFalloffType,
+) {
+	path_tool_data.proportional_affected_points.clear();
+
+	let radius = radius as f64;
+
+	// If initial positions haven't been stored yet, do it now
+	if path_tool_data.initial_point_positions.is_empty() {
+		store_initial_point_positions(path_tool_data, document);
+	}
+
+	// Collect all selected points with their initial world positions
+	let mut selected_points_world_pos = Vec::new();
+	let selected_point_ids: HashSet<_> = shape_editor.selected_points().filter_map(|point| point.as_anchor()).collect();
+
+	// Extract initial positions of selected points
+	for (_layer, points_map) in &path_tool_data.initial_point_positions {
+		for &point_id in &selected_point_ids {
+			if let Some(&world_pos) = points_map.get(&point_id) {
+				selected_points_world_pos.push(world_pos);
+			}
+		}
+	}
+
+	// Find all affected points using initial positions
+	for (layer, points_map) in &path_tool_data.initial_point_positions {
+		let selected_points: HashSet<_> = shape_editor.selected_points().filter_map(|point| point.as_anchor()).collect();
+
+		let mut layer_affected_points = Vec::new();
+
+		// Check each point in the layer
+		for (&point_id, &initial_position) in points_map {
+			if !selected_points.contains(&point_id) {
+				// Find the smallest distance to any selected point using initial positions
+				let min_distance = selected_points_world_pos
+					.iter()
+					.map(|&selected_pos| initial_position.distance(selected_pos))
+					.filter(|&distance| distance <= radius)
+					.min_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
+
+				if let Some(distance) = min_distance {
+					let factor = path_tool_data.calculate_falloff_factor(distance, radius, proportional_falloff_type);
+					layer_affected_points.push((point_id, factor));
+				}
+			}
+		}
+
+		if !layer_affected_points.is_empty() {
+			path_tool_data.proportional_affected_points.insert(*layer, layer_affected_points);
+		}
+	}
+
+	// Find all affected points using initial positions
+	// NOTE: This works based on initial affected point location -> original selected point location for falloff calculation
+	for (layer, points_map) in &path_tool_data.initial_point_positions {
+		let selected_points: HashSet<_> = shape_editor.selected_points().filter_map(|point| point.as_anchor()).collect();
+
+		let mut layer_affected_points = Vec::new();
+
+		// Check each point in the layer
+		for (&point_id, &initial_position) in points_map {
+			if !selected_points.contains(&point_id) {
+				// Find the smallest distance to any selected point using initial positions
+				let min_distance = selected_points_world_pos
+					.iter()
+					.map(|&selected_pos| initial_position.distance(selected_pos))
+					.filter(|&distance| distance <= radius)
+					.min_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
+
+				if let Some(distance) = min_distance {
+					let factor = path_tool_data.calculate_falloff_factor(distance, radius, proportional_falloff_type);
+					layer_affected_points.push((point_id, factor));
+				}
+			}
+		}
+
+		if !layer_affected_points.is_empty() {
+			path_tool_data.proportional_affected_points.insert(*layer, layer_affected_points);
+		}
+	}
+}
+
+pub fn store_initial_point_positions(path_tool_data: &mut PathToolData, document: &DocumentMessageHandler) {
+	path_tool_data.initial_point_positions.clear();
+
+	// Store positions of all points in selected layers
+	for layer in document.network_interface.selected_nodes().selected_layers(document.metadata()) {
+		if let Some(vector_data) = document.network_interface.compute_modified_vector(layer) {
+			let transform = document.metadata().transform_to_document(layer);
+			let mut layer_points = HashMap::new();
+
+			// Store all point positions in document space
+			for (i, &point_id) in vector_data.point_domain.ids().iter().enumerate() {
+				let position = vector_data.point_domain.positions()[i];
+				let world_pos = transform.transform_point2(position);
+				layer_points.insert(point_id, world_pos);
+			}
+
+			if !layer_points.is_empty() {
+				path_tool_data.initial_point_positions.insert(layer, layer_points);
+			}
+		}
+	}
+}
+
+pub fn update_proportional_positions(path_tool_data: &mut PathToolData, document: &DocumentMessageHandler, shape_editor: &mut ShapeState, responses: &mut VecDeque<Message>) {
+	// Get a set of all selected point IDs across all layers
+	let selected_points: HashSet<PointId> = shape_editor.selected_points().filter_map(|point| point.as_anchor()).collect();
+
+	for (layer, affected_points) in &path_tool_data.proportional_affected_points {
+		if let Some(vector_data) = document.network_interface.compute_modified_vector(*layer) {
+			let transform = document.metadata().transform_to_document(*layer);
+			let inverse_transform = transform.inverse();
+
+			for (point_id, factor) in affected_points {
+				// Skip this point if it's in the selected_points set
+				if selected_points.contains(point_id) {
+					continue;
+				}
+
+				if let Some(initial_doc_pos) = path_tool_data.initial_point_positions.get(layer).and_then(|pts| pts.get(point_id)) {
+					// Calculate displacement from initial position to target position
+					let displacement_document_space = path_tool_data.total_delta * (*factor);
+					let target_document_space_position = *initial_doc_pos + displacement_document_space;
+					let target_layer_space_position = inverse_transform.transform_point2(target_document_space_position);
+
+					// Get current position and calculate delta
+					if let Some(current_layer_space_position) = vector_data.point_domain.position_from_id(*point_id) {
+						let delta = target_layer_space_position - current_layer_space_position;
+						shape_editor.move_anchor(*point_id, &vector_data, delta, *layer, None, responses);
+					}
+				}
+			}
+		}
+	}
+}
+
+pub fn reset_removed_points(
+	path_tool_data: &mut PathToolData,
+	previous: &HashMap<LayerNodeIdentifier, Vec<(PointId, f64)>>,
+	document: &DocumentMessageHandler,
+	shape_editor: &mut ShapeState,
+	responses: &mut VecDeque<Message>,
+) {
+	for (layer, prev_points) in previous {
+		let current_points = path_tool_data
+			.proportional_affected_points
+			.get(layer)
+			.map(|v| v.iter().map(|(id, _)| *id).collect::<HashSet<_>>())
+			.unwrap_or_default();
+
+		for (point_id, _) in prev_points {
+			if !current_points.contains(point_id) {
+				if let Some(initial_doc_pos) = path_tool_data.initial_point_positions.get(layer).and_then(|pts| pts.get(point_id)) {
+					let inverse_transform = document.metadata().transform_to_document(*layer).inverse();
+					let target_layer_pos = inverse_transform.transform_point2(*initial_doc_pos);
+
+					if let Some(vector_data) = document.network_interface.compute_modified_vector(*layer) {
+						if let Some(current_layer_pos) = vector_data.point_domain.position_from_id(*point_id) {
+							let delta = target_layer_pos - current_layer_pos;
+							shape_editor.move_anchor(*point_id, &vector_data, delta, *layer, None, responses);
+						}
+					}
+				}
+			}
+		}
+	}
+}

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

@@ -253,6 +253,34 @@ impl ClosestSegment {
 
 // TODO Consider keeping a list of selected manipulators to minimize traversals of the layers
 impl ShapeState {
+	/// Calculates the center point of all selected manipulator points (anchors and handles)
+	pub fn selection_center(&self, document: &DocumentMessageHandler) -> Option<DVec2> {
+		let mut sum = DVec2::ZERO;
+		let mut count = 0;
+
+		// Iterate through all selected layers and their selection states
+		for (&layer, state) in &self.selected_shape_state {
+			// Get the transform from layer space to document space
+			let transform = document.metadata().transform_to_document(layer);
+
+			// Get the vector data for this layer
+			if let Some(vector_data) = document.network_interface.compute_modified_vector(layer) {
+				// Process each selected point in this layer
+				for point in state.selected() {
+					// Get the position in layer space coordinates
+					if let Some(position) = point.get_position(&vector_data) {
+						// Convert to document space and accumulate
+						sum += transform.transform_point2(position);
+						count += 1;
+					}
+				}
+			}
+		}
+
+		// Return average position if we have any points
+		if count > 0 { Some(sum / count as f64) } else { None }
+	}
+
 	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