diff --git a/editor/src/consts.rs b/editor/src/consts.rs index d14efb2409..adffec9a37 100644 --- a/editor/src/consts.rs +++ b/editor/src/consts.rs @@ -53,6 +53,10 @@ pub const PIVOT_CROSSHAIR_THICKNESS: f64 = 1.; pub const PIVOT_CROSSHAIR_LENGTH: f64 = 9.; pub const PIVOT_DIAMETER: f64 = 5.; +// Transform overlay +pub const ANGLE_MEASURE_RADIUS_FACTOR: f64 = 0.04; +pub const ARC_MEASURE_RADIUS_FACTOR_RANGE: (f64, f64) = (0.05, 0.15); + // Transformation cage pub const BOUNDS_SELECT_THRESHOLD: f64 = 10.; pub const BOUNDS_ROTATE_THRESHOLD: f64 = 20.; @@ -88,6 +92,7 @@ pub const COLOR_OVERLAY_RED: &str = "#ef5454"; pub const COLOR_OVERLAY_GRAY: &str = "#cccccc"; pub const COLOR_OVERLAY_WHITE: &str = "#ffffff"; pub const COLOR_OVERLAY_SNAP_BACKGROUND: &str = "#000000cc"; +pub const COLOR_OVERLAY_TRANSPARENT: &str = "#ffffff00"; // Document pub const DEFAULT_DOCUMENT_NAME: &str = "Untitled Document"; diff --git a/editor/src/messages/portfolio/document/document_message_handler.rs b/editor/src/messages/portfolio/document/document_message_handler.rs index df73cf00a1..bef9f93292 100644 --- a/editor/src/messages/portfolio/document/document_message_handler.rs +++ b/editor/src/messages/portfolio/document/document_message_handler.rs @@ -1034,9 +1034,8 @@ impl MessageHandler> for DocumentMessag self.graph_fade_artwork_percentage = percentage; responses.add(FrontendMessage::UpdateGraphFadeArtwork { percentage }); } - DocumentMessage::SetNodePinned { node_id, pinned } => { - responses.add(DocumentMessage::StartTransaction); + responses.add(DocumentMessage::AddTransaction); responses.add(NodeGraphMessage::SetPinned { node_id, pinned }); responses.add(NodeGraphMessage::RunDocumentGraph); responses.add(NodeGraphMessage::SelectedNodesUpdated); @@ -1064,6 +1063,7 @@ impl MessageHandler> for DocumentMessag DocumentMessage::SetToNodeOrLayer { node_id, is_layer } => { responses.add(DocumentMessage::StartTransaction); responses.add(NodeGraphMessage::SetToNodeOrLayer { node_id, is_layer }); + responses.add(DocumentMessage::EndTransaction); } DocumentMessage::SetViewMode { view_mode } => { self.view_mode = view_mode; diff --git a/editor/src/messages/portfolio/document/navigation/navigation_message_handler.rs b/editor/src/messages/portfolio/document/navigation/navigation_message_handler.rs index 670784c5c7..d9696d7e8b 100644 --- a/editor/src/messages/portfolio/document/navigation/navigation_message_handler.rs +++ b/editor/src/messages/portfolio/document/navigation/navigation_message_handler.rs @@ -99,7 +99,7 @@ impl MessageHandler> for Navigation key_groups: vec![KeysGroup(vec![Key::Control]).into()], key_groups_mac: None, mouse: None, - label: String::from("Snap 15°"), + label: "Snap 15°".into(), plus: false, slash: false, }]), @@ -129,7 +129,7 @@ impl MessageHandler> for Navigation key_groups: vec![KeysGroup(vec![Key::Control]).into()], key_groups_mac: None, mouse: None, - label: String::from("Increments"), + label: "Increments".into(), plus: false, slash: false, }]), diff --git a/editor/src/messages/portfolio/document/overlays/utility_types.rs b/editor/src/messages/portfolio/document/overlays/utility_types.rs index edf903bdf5..4be7a567d7 100644 --- a/editor/src/messages/portfolio/document/overlays/utility_types.rs +++ b/editor/src/messages/portfolio/document/overlays/utility_types.rs @@ -1,5 +1,7 @@ use super::utility_functions::overlay_canvas_context; -use crate::consts::{COLOR_OVERLAY_BLUE, COLOR_OVERLAY_WHITE, COLOR_OVERLAY_YELLOW, MANIPULATOR_GROUP_MARKER_SIZE, PIVOT_CROSSHAIR_LENGTH, PIVOT_CROSSHAIR_THICKNESS, PIVOT_DIAMETER}; +use crate::consts::{ + COLOR_OVERLAY_BLUE, COLOR_OVERLAY_TRANSPARENT, COLOR_OVERLAY_WHITE, COLOR_OVERLAY_YELLOW, MANIPULATOR_GROUP_MARKER_SIZE, PIVOT_CROSSHAIR_LENGTH, PIVOT_CROSSHAIR_THICKNESS, PIVOT_DIAMETER, +}; use crate::messages::prelude::Message; use bezier_rs::{Bezier, Subpath}; @@ -188,6 +190,65 @@ impl OverlayContext { self.render_context.fill(); self.render_context.stroke(); } + + pub fn draw_arc(&mut self, center: DVec2, radius: f64, start_from: f64, end_at: f64) { + let segments = ((end_at - start_from).abs() / (std::f64::consts::PI / 4.)).ceil() as usize; + let step = (end_at - start_from) / segments as f64; + let half_step = step / 2.; + let factor = 4. / 3. * half_step.sin() / (1. + half_step.cos()); + + self.render_context.begin_path(); + + for i in 0..segments { + let start_angle = start_from + step * i as f64; + let end_angle = start_angle + step; + let start_vec = DVec2::from_angle(start_angle); + let end_vec = DVec2::from_angle(end_angle); + + let start = center + radius * start_vec; + let end = center + radius * end_vec; + + let handle_start = start + start_vec.perp() * radius * factor; + let handle_end = end - end_vec.perp() * radius * factor; + + let bezier = Bezier { + start, + end, + handles: bezier_rs::BezierHandles::Cubic { handle_start, handle_end }, + }; + + self.bezier_command(bezier, DAffine2::IDENTITY, i == 0); + } + + self.render_context.stroke(); + } + + pub fn draw_angle(&mut self, pivot: DVec2, radius: f64, arc_radius: f64, offset_angle: f64, angle: f64) { + let color_line = COLOR_OVERLAY_BLUE; + + let end_point1 = pivot + radius * DVec2::from_angle(angle + offset_angle); + let end_point2 = pivot + radius * DVec2::from_angle(offset_angle); + self.line(pivot, end_point1, Some(color_line)); + self.line(pivot, end_point2, Some(color_line)); + + self.draw_arc(pivot, arc_radius, offset_angle, (angle) % TAU + offset_angle); + } + + pub fn draw_scale(&mut self, start: DVec2, scale: f64, radius: f64, text: &str) { + let sign = scale.signum(); + self.line(start + DVec2::X * radius * sign, start + DVec2::X * (radius * scale), None); + self.circle(start, radius, Some(COLOR_OVERLAY_TRANSPARENT), None); + self.circle(start, radius * scale.abs(), Some(COLOR_OVERLAY_TRANSPARENT), None); + self.text( + text, + COLOR_OVERLAY_BLUE, + None, + DAffine2::from_translation(start + sign * DVec2::X * radius * (1. + scale.abs()) / 2.), + 2., + [Pivot::Middle, Pivot::End], + ) + } + pub fn pivot(&mut self, position: DVec2) { let (x, y) = (position.round() - DVec2::splat(0.5)).into(); @@ -300,6 +361,10 @@ impl OverlayContext { self.render_context.stroke(); } + pub fn get_width(&self, text: &str) -> f64 { + self.render_context.measure_text(text).expect("Failed to measure text dimensions").width() + } + pub fn text(&self, text: &str, font_color: &str, background_color: Option<&str>, transform: DAffine2, padding: f64, pivot: [Pivot; 2]) { let metrics = self.render_context.measure_text(text).expect("Failed to measure the text dimensions"); let x = match pivot[0] { diff --git a/editor/src/messages/portfolio/document/utility_types/transformation.rs b/editor/src/messages/portfolio/document/utility_types/transformation.rs index 27c2567da2..ccd7627bbc 100644 --- a/editor/src/messages/portfolio/document/utility_types/transformation.rs +++ b/editor/src/messages/portfolio/document/utility_types/transformation.rs @@ -122,14 +122,15 @@ pub enum Axis { } impl Axis { - pub fn set_or_toggle(&mut self, target: Axis) { - // If constrained to an axis and target is requesting the same axis, toggle back to Both - if *self == target { - *self = Axis::Both; + pub fn contrainted_to_axis(self, target: Axis, local: bool) -> (Self, bool) { + if self != target { + return (target, false); } - // If current axis is different from the target axis, switch to the target - else { - *self = target; + + if local { + (Axis::Both, false) + } else { + (self, true) } } } @@ -142,20 +143,17 @@ pub struct Translation { } impl Translation { - pub fn to_dvec(self) -> DVec2 { + pub fn to_dvec(self, transform: DAffine2) -> DVec2 { if let Some(value) = self.typed_distance { - if self.constraint == Axis::Y { - return DVec2::new(0., value); - } else { - return DVec2::new(value, 0.); + let document_displacement = if self.constraint == Axis::Y { DVec2::new(0., value) } else { DVec2::new(value, 0.) }; + transform.transform_vector2(document_displacement) + } else { + match self.constraint { + Axis::Both => self.dragged_distance, + Axis::X => DVec2::new(self.dragged_distance.x, 0.), + Axis::Y => DVec2::new(0., self.dragged_distance.y), } } - - match self.constraint { - Axis::Both => self.dragged_distance, - Axis::X => DVec2::new(self.dragged_distance.x, 0.), - Axis::Y => DVec2::new(0., self.dragged_distance.y), - } } #[must_use] @@ -173,6 +171,11 @@ impl Translation { constraint: self.constraint, } } + + pub fn with_constraint(self, target: Axis, local: bool) -> (Self, bool) { + let (constraint, local) = self.constraint.contrainted_to_axis(target, local); + (Self { constraint, ..self }, local) + } } #[derive(Default, Debug, Clone, PartialEq, Copy)] @@ -206,6 +209,11 @@ impl Rotation { typed_angle: None, } } + + pub fn negate(self) -> Self { + let dragged_angle = -self.dragged_angle; + Self { dragged_angle, ..self } + } } #[derive(Debug, Clone, PartialEq, Copy)] @@ -226,9 +234,17 @@ impl Default for Scale { } impl Scale { - pub fn to_dvec(self, snap: bool) -> DVec2 { + pub fn to_f64(self, snap: bool) -> f64 { let factor = if let Some(value) = self.typed_factor { value } else { self.dragged_factor }; - let factor = if snap { (factor / SCALE_SNAP_INTERVAL).round() * SCALE_SNAP_INTERVAL } else { factor }; + if snap { + (factor / SCALE_SNAP_INTERVAL).round() * SCALE_SNAP_INTERVAL + } else { + factor + } + } + + pub fn to_dvec(self, snap: bool) -> DVec2 { + let factor = self.to_f64(snap); match self.constraint { Axis::Both => DVec2::splat(factor), @@ -237,6 +253,11 @@ impl Scale { } } + pub fn negate(self) -> Self { + let dragged_factor = -self.dragged_factor; + Self { dragged_factor, ..self } + } + #[must_use] pub fn increment_amount(self, delta: f64) -> Self { Self { @@ -253,6 +274,11 @@ impl Scale { constraint: self.constraint, } } + + pub fn with_constraint(self, target: Axis, local: bool) -> (Self, bool) { + let (constraint, local) = self.constraint.contrainted_to_axis(target, local); + (Self { constraint, ..self }, local) + } } #[derive(Default, Debug, Clone, PartialEq, Copy)] @@ -265,32 +291,51 @@ pub enum TransformOperation { } impl TransformOperation { - pub fn apply_transform_operation(&self, selected: &mut Selected, snapping: bool, axis_constraint: Axis) { + pub fn apply_transform_operation(&self, selected: &mut Selected, snapping: bool, local: bool, quad: Quad, transform: DAffine2) { + let quad = quad.0; + let edge = quad[1] - quad[0]; if self != &TransformOperation::None { let transformation = match self { - TransformOperation::Grabbing(translation) => DAffine2::from_translation(translation.to_dvec()), + TransformOperation::Grabbing(translation) => { + if local { + DAffine2::from_angle(edge.to_angle()) * DAffine2::from_translation(translation.to_dvec(transform)) * DAffine2::from_angle(-edge.to_angle()) + } else { + DAffine2::from_translation(translation.to_dvec(transform)) + } + } TransformOperation::Rotating(rotation) => DAffine2::from_angle(rotation.to_f64(snapping)), - TransformOperation::Scaling(scale) => DAffine2::from_scale(scale.to_dvec(snapping)), + TransformOperation::Scaling(scale) => { + if local { + DAffine2::from_angle(edge.to_angle()) * DAffine2::from_scale(scale.to_dvec(snapping)) * DAffine2::from_angle(-edge.to_angle()) + } else { + DAffine2::from_scale(scale.to_dvec(snapping)) + } + } TransformOperation::None => unreachable!(), }; selected.update_transforms(transformation); - self.hints(snapping, axis_constraint, selected.responses); + self.hints(selected.responses); } } - pub fn constrain_axis(&mut self, axis: Axis, selected: &mut Selected, snapping: bool) { - match self { - TransformOperation::None => (), - TransformOperation::Grabbing(translation) => translation.constraint.set_or_toggle(axis), - TransformOperation::Rotating(_) => (), - TransformOperation::Scaling(scale) => scale.constraint.set_or_toggle(axis), + pub fn constrain_axis(&mut self, axis: Axis, selected: &mut Selected, snapping: bool, mut local: bool, quad: Quad, transform: DAffine2) -> bool { + (*self, local) = match self { + TransformOperation::Grabbing(translation) => { + let (translation, local) = translation.with_constraint(axis, local); + (TransformOperation::Grabbing(translation), local) + } + TransformOperation::Scaling(scale) => { + let (scale, local) = scale.with_constraint(axis, local); + (TransformOperation::Scaling(scale), local) + } + _ => (*self, false), }; - - self.apply_transform_operation(selected, snapping, axis); + self.apply_transform_operation(selected, snapping, local, quad, transform); + local } - pub fn grs_typed(&mut self, typed: Option, selected: &mut Selected, snapping: bool) { + pub fn grs_typed(&mut self, typed: Option, selected: &mut Selected, snapping: bool, local: bool, quad: Quad, transform: DAffine2) { match self { TransformOperation::None => (), TransformOperation::Grabbing(translation) => translation.typed_distance = typed, @@ -298,16 +343,10 @@ impl TransformOperation { TransformOperation::Scaling(scale) => scale.typed_factor = typed, }; - let axis_constraint = match self { - TransformOperation::Grabbing(grabbing) => grabbing.constraint, - TransformOperation::Scaling(scaling) => scaling.constraint, - _ => Axis::Both, - }; - - self.apply_transform_operation(selected, snapping, axis_constraint); + self.apply_transform_operation(selected, snapping, local, quad, transform); } - pub fn hints(&self, snapping: bool, axis_constraint: Axis, responses: &mut VecDeque) { + pub fn hints(&self, responses: &mut VecDeque) { use crate::messages::input_mapper::utility_types::input_keyboard::Key; use crate::messages::tool::utility_types::{HintData, HintGroup, HintInfo}; @@ -321,25 +360,20 @@ impl TransformOperation { input_hints.push(HintInfo::keys([Key::KeyY], "Along Y Axis")); } - // TODO: Eventually, move this somewhere else (maybe an overlay in the corner of the viewport, design is TBD) since servicable but not ideal for UI design consistency to have it in the hints bar - let axis_text = |vector: DVec2, separate: bool| match (axis_constraint, separate) { - (Axis::Both, false) => format!("by {:.3}", vector.x), - (Axis::Both, true) => format!("by {:.3}, {:.3}", vector.x, vector.y), - (Axis::X, _) => format!("X by {:.3}", vector.x), - (Axis::Y, _) => format!("Y by {:.3}", vector.y), - }; - let grs_value_text = match self { - TransformOperation::None => String::new(), - // TODO: Fix that the translation is showing numbers in viewport space, not document space - TransformOperation::Grabbing(translation) => format!("Translating {}", axis_text(translation.to_dvec(), true)), - TransformOperation::Rotating(rotation) => format!("Rotating by {:.3}°", rotation.to_f64(snapping) * 360. / std::f64::consts::TAU), - TransformOperation::Scaling(scale) => format!("Scaling {}", axis_text(scale.to_dvec(snapping), false)), - }; - let grs_value = vec![HintInfo::label(grs_value_text)]; - - let hint_data = HintData(vec![HintGroup(input_hints), HintGroup(grs_value)]); + let hint_data = HintData(vec![HintGroup(input_hints)]); responses.add(FrontendMessage::UpdateInputHints { hint_data }); } + + pub fn negate(&mut self, selected: &mut Selected, snapping: bool, local: bool, quad: Quad, transform: DAffine2) { + if *self != TransformOperation::None { + *self = match self { + TransformOperation::Scaling(scale) => TransformOperation::Scaling(scale.negate()), + TransformOperation::Rotating(rotation) => TransformOperation::Rotating(rotation.negate()), + _ => *self, + }; + self.apply_transform_operation(selected, snapping, local, quad, transform); + } + } } pub struct Selected<'a> { @@ -402,6 +436,32 @@ impl<'a> Selected<'a> { (min + max) / 2. } + pub fn bounding_box(&mut self) -> Quad { + let metadata = self.network_interface.document_metadata(); + + let transform = self + .network_interface + .selected_nodes(&[]) + .unwrap() + .selected_visible_and_unlocked_layers(self.network_interface) + .find(|layer| !self.network_interface.is_artboard(&layer.to_node(), &[])) + .map(|layer| metadata.transform_to_viewport(layer)) + .unwrap_or(DAffine2::IDENTITY); + + if transform.matrix2.determinant() == 0. { + return Default::default(); + } + + let bounds = self + .selected + .iter() + .filter_map(|&layer| metadata.bounding_box_with_transform(layer, transform.inverse() * metadata.transform_to_viewport(layer))) + .reduce(Quad::combine_bounds) + .unwrap_or_default(); + + transform * Quad::from_box(bounds) + } + fn transform_layer(document_metadata: &DocumentMetadata, layer: LayerNodeIdentifier, original_transform: Option<&DAffine2>, transformation: DAffine2, responses: &mut VecDeque) { let Some(&original_transform) = original_transform else { return }; let to = document_metadata.downstream_transform_to_viewport(layer); diff --git a/editor/src/messages/tool/common_functionality/shape_editor.rs b/editor/src/messages/tool/common_functionality/shape_editor.rs index 6ecdbcea1d..c01bc18bd3 100644 --- a/editor/src/messages/tool/common_functionality/shape_editor.rs +++ b/editor/src/messages/tool/common_functionality/shape_editor.rs @@ -878,9 +878,7 @@ impl ShapeState { pub fn break_path_at_selected_point(&self, document: &DocumentMessageHandler, responses: &mut VecDeque) { for (&layer, state) in &self.selected_shape_state { - let Some(vector_data) = document.network_interface.compute_modified_vector(layer) else { - continue; - }; + let Some(vector_data) = document.network_interface.compute_modified_vector(layer) else { continue }; for &delete in &state.selected_points { let Some(point) = delete.get_anchor(&vector_data) else { continue }; diff --git a/editor/src/messages/tool/common_functionality/snapping/layer_snapper.rs b/editor/src/messages/tool/common_functionality/snapping/layer_snapper.rs index a630ecd202..1d1d9efd20 100644 --- a/editor/src/messages/tool/common_functionality/snapping/layer_snapper.rs +++ b/editor/src/messages/tool/common_functionality/snapping/layer_snapper.rs @@ -156,7 +156,7 @@ impl LayerSnapper { target: path.target, distance, tolerance, - curves: [path.bounds.is_none().then_some(path.document_curve), Some(constraint_path)], + curves: [path.bounds.is_none().then_some(path.document_curve), None], source: point.source, target_bounds: path.bounds, at_intersection: true, diff --git a/editor/src/messages/tool/tool_messages/line_tool.rs b/editor/src/messages/tool/tool_messages/line_tool.rs index 76cf518d92..b752839591 100644 --- a/editor/src/messages/tool/tool_messages/line_tool.rs +++ b/editor/src/messages/tool/tool_messages/line_tool.rs @@ -293,18 +293,21 @@ fn generate_transform(tool_data: &mut LineToolData, snap_data: SnapData, lock_an let mut angle = -(document_points[1] - document_points[0]).angle_to(DVec2::X); let mut line_length = (document_points[1] - document_points[0]).length(); + if lock_angle { angle = tool_data.angle; - } - if snap_angle { + } else if snap_angle { let snap_resolution = LINE_ROTATE_SNAP_ANGLE.to_radians(); angle = (angle / snap_resolution).round() * snap_resolution; } + tool_data.angle = angle; + if lock_angle { let angle_vec = DVec2::new(angle.cos(), angle.sin()); line_length = (document_points[1] - document_points[0]).dot(angle_vec); } + document_points[1] = document_points[0] + line_length * DVec2::new(angle.cos(), angle.sin()); let constrained = snap_angle || lock_angle; diff --git a/editor/src/messages/tool/tool_messages/path_tool.rs b/editor/src/messages/tool/tool_messages/path_tool.rs index 7f5858839f..9bdddafb8c 100644 --- a/editor/src/messages/tool/tool_messages/path_tool.rs +++ b/editor/src/messages/tool/tool_messages/path_tool.rs @@ -301,6 +301,7 @@ struct PathToolData { saved_points_before_anchor_select_toggle: Vec, select_anchor_toggled: bool, dragging_state: DraggingState, + current_selected_handle_id: Option, angle: f64, } @@ -450,15 +451,20 @@ impl PathToolData { } fn update_colinear(&mut self, equidistant: bool, toggle_colinear: bool, shape_editor: &mut ShapeState, document: &DocumentMessageHandler, responses: &mut VecDeque) -> bool { + // Check handle colinear state + let is_colinear = self + .selection_status + .angle() + .map(|angle| match angle { + ManipulatorAngle::Colinear => true, + ManipulatorAngle::Free | ManipulatorAngle::Mixed => false, + }) + .unwrap_or(false); + // Check if the toggle_colinear key has just been pressed if toggle_colinear && !self.toggle_colinear_debounce { self.opposing_handle_lengths = None; - let colinear = self.selection_status.angle().is_some_and(|angle| match angle { - ManipulatorAngle::Colinear => true, - ManipulatorAngle::Free => false, - ManipulatorAngle::Mixed => false, - }); - if colinear { + if is_colinear { shape_editor.disable_colinear_handles_state_on_selected(&document.network_interface, responses); } else { shape_editor.convert_selected_manipulators_to_colinear_handles(responses, document); @@ -469,13 +475,46 @@ impl PathToolData { self.toggle_colinear_debounce = toggle_colinear; if equidistant && self.opposing_handle_lengths.is_none() { + if !is_colinear { + // Try to get selected handle info + let Some((_, _, selected_handle_id)) = self.try_get_selected_handle_and_anchor(shape_editor, document) else { + self.opposing_handle_lengths = Some(shape_editor.opposing_handle_lengths(document)); + return false; + }; + + let Some((layer, _)) = shape_editor.selected_shape_state.iter().next() else { + self.opposing_handle_lengths = Some(shape_editor.opposing_handle_lengths(document)); + return false; + }; + + let Some(vector_data) = document.network_interface.compute_modified_vector(*layer) else { + self.opposing_handle_lengths = Some(shape_editor.opposing_handle_lengths(document)); + return false; + }; + + // Check if handle has a pair (to ignore handles of edges of open paths) + if let Some(handle_pair) = selected_handle_id.get_handle_pair(&vector_data) { + let opposite_handle_length = handle_pair.iter().filter(|&&h| h.to_manipulator_point() != selected_handle_id).find_map(|&h| { + let opp_handle_pos = h.to_manipulator_point().get_position(&vector_data)?; + let opp_anchor_id = h.to_manipulator_point().get_anchor(&vector_data)?; + let opp_anchor_pos = vector_data.point_domain.position_from_id(opp_anchor_id)?; + Some((opp_handle_pos - opp_anchor_pos).length()) + }); + + // Make handles colinear if opposite handle is zero length + if opposite_handle_length.map_or(false, |l| l == 0.) { + shape_editor.convert_selected_manipulators_to_colinear_handles(responses, document); + return true; + } + } + } self.opposing_handle_lengths = Some(shape_editor.opposing_handle_lengths(document)); } false } /// Attempts to get a single selected handle. Also retrieves the position of the anchor it is connected to. Used for the purpose of snapping the angle. - fn try_get_selected_handle_and_anchor(&self, shape_editor: &ShapeState, document: &DocumentMessageHandler) -> Option<(DVec2, DVec2)> { + fn try_get_selected_handle_and_anchor(&self, shape_editor: &ShapeState, document: &DocumentMessageHandler) -> Option<(DVec2, DVec2, ManipulatorPointId)> { // Only count selections of a single layer let (layer, selection) = shape_editor.selected_shape_state.iter().next()?; @@ -486,6 +525,7 @@ impl PathToolData { // Only count selected handles let selected_handle = selection.selected().next()?.as_handle()?; + let handle_id = selected_handle.to_manipulator_point(); let layer_to_document = document.metadata().transform_to_document(*layer); let vector_data = document.network_interface.compute_modified_vector(*layer)?; @@ -497,24 +537,26 @@ impl PathToolData { let handle_position_document = layer_to_document.transform_point2(handle_position_local); let anchor_position_document = layer_to_document.transform_point2(anchor_position_local); - Some((handle_position_document, anchor_position_document)) + Some((handle_position_document, anchor_position_document, handle_id)) } - fn calculate_handle_angle(&mut self, handle_vector: DVec2, lock_angle: bool, snap_angle: bool) -> f64 { - let mut handle_angle = -handle_vector.angle_to(DVec2::X); + fn calculate_handle_angle(&mut self, handle_vector: DVec2, handle_id: ManipulatorPointId, lock_angle: bool, snap_angle: bool) -> f64 { + let current_angle = -handle_vector.angle_to(DVec2::X); // When the angle is locked we use the old angle - if lock_angle { - handle_angle = self.angle + if self.current_selected_handle_id == Some(handle_id) && lock_angle { + return self.angle; } // Round the angle to the closest increment - if snap_angle { + let mut handle_angle = current_angle; + if snap_angle && !lock_angle { let snap_resolution = HANDLE_ROTATE_SNAP_ANGLE.to_radians(); handle_angle = (handle_angle / snap_resolution).round() * snap_resolution; } - // Cache the old handle angle for the lock angle. + // Cache the angle and handle id for lock angle + self.current_selected_handle_id = Some(handle_id); self.angle = handle_angle; handle_angle @@ -566,10 +608,10 @@ impl PathToolData { let current_mouse = input.mouse.position; let raw_delta = document_to_viewport.inverse().transform_vector2(current_mouse - previous_mouse); - let snapped_delta = if let Some((handle_pos, anchor_pos)) = self.try_get_selected_handle_and_anchor(shape_editor, document) { + let snapped_delta = if let Some((handle_pos, anchor_pos, handle_id)) = self.try_get_selected_handle_and_anchor(shape_editor, document) { let cursor_pos = handle_pos + raw_delta; - let handle_angle = self.calculate_handle_angle(cursor_pos - anchor_pos, lock_angle, snap_angle); + let handle_angle = self.calculate_handle_angle(cursor_pos - anchor_pos, handle_id, lock_angle, snap_angle); let constrained_direction = DVec2::new(handle_angle.cos(), handle_angle.sin()); let projected_length = (cursor_pos - anchor_pos).dot(constrained_direction); @@ -929,7 +971,9 @@ impl Fsm for PathToolFsmState { if nearest_point.is_some() { // Flip the selected point between smooth and sharp if !tool_data.double_click_handled && tool_data.drag_start_pos.distance(input.mouse.position) <= DRAG_THRESHOLD { + responses.add(DocumentMessage::StartTransaction); shape_editor.flip_smooth_sharp(&document.network_interface, input.mouse.position, SELECTION_TOLERANCE, responses); + responses.add(DocumentMessage::EndTransaction); responses.add(PathToolMessage::SelectedPointUpdated); } diff --git a/editor/src/messages/tool/tool_messages/select_tool.rs b/editor/src/messages/tool/tool_messages/select_tool.rs index d2bf877ddd..044b981a58 100644 --- a/editor/src/messages/tool/tool_messages/select_tool.rs +++ b/editor/src/messages/tool/tool_messages/select_tool.rs @@ -502,7 +502,7 @@ impl Fsm for SelectToolFsmState { // Measure with Alt held down // TODO: Don't use `Key::Alt` directly, instead take it as a variable from the input mappings list like in all other places - if input.keyboard.get(Key::Alt as usize) { + if !matches!(self, Self::ResizingBounds { .. }) && input.keyboard.get(Key::Alt as usize) { let hovered_bounds = document .metadata() .bounding_box_with_transform(layer, transform.inverse() * document.metadata().transform_to_viewport(layer)); diff --git a/editor/src/messages/tool/transform_layer/transform_layer_message.rs b/editor/src/messages/tool/transform_layer/transform_layer_message.rs index 54788c3e7d..353f19a508 100644 --- a/editor/src/messages/tool/transform_layer/transform_layer_message.rs +++ b/editor/src/messages/tool/transform_layer/transform_layer_message.rs @@ -1,8 +1,9 @@ use crate::messages::input_mapper::utility_types::input_keyboard::Key; +use crate::messages::portfolio::document::overlays::utility_types::OverlayContext; use crate::messages::prelude::*; #[impl_message(Message, ToolMessage, TransformLayer)] -#[derive(PartialEq, Eq, Clone, Debug, serde::Serialize, serde::Deserialize)] +#[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)] pub enum TransformLayerMessage { // Messages ApplyTransformOperation, @@ -12,6 +13,7 @@ pub enum TransformLayerMessage { CancelTransformOperation, ConstrainX, ConstrainY, + Overlays(OverlayContext), PointerMove { slow_key: Key, snap_key: Key }, SelectionChanged, TypeBackspace, diff --git a/editor/src/messages/tool/transform_layer/transform_layer_message_handler.rs b/editor/src/messages/tool/transform_layer/transform_layer_message_handler.rs index 477796c89c..bf0428ef46 100644 --- a/editor/src/messages/tool/transform_layer/transform_layer_message_handler.rs +++ b/editor/src/messages/tool/transform_layer/transform_layer_message_handler.rs @@ -1,13 +1,18 @@ -use crate::consts::SLOWING_DIVISOR; +use crate::consts::{ANGLE_MEASURE_RADIUS_FACTOR, ARC_MEASURE_RADIUS_FACTOR_RANGE, COLOR_OVERLAY_BLUE, COLOR_OVERLAY_SNAP_BACKGROUND, COLOR_OVERLAY_WHITE, SLOWING_DIVISOR}; use crate::messages::input_mapper::utility_types::input_mouse::ViewportPosition; +use crate::messages::portfolio::document::overlays::utility_types::{OverlayProvider, Pivot}; use crate::messages::portfolio::document::utility_types::transformation::{Axis, OriginalTransforms, Selected, TransformOperation, Typing}; use crate::messages::prelude::*; use crate::messages::tool::common_functionality::shape_editor::ShapeState; use crate::messages::tool::utility_types::{ToolData, ToolType}; +use graphene_core::renderer::Quad; use graphene_core::vector::ManipulatorPointId; -use glam::DVec2; +use glam::{DAffine2, DVec2}; +use std::f64::consts::TAU; + +const TRANSFORM_GRS_OVERLAY_PROVIDER: OverlayProvider = |context| TransformLayerMessage::Overlays(context).into(); #[derive(Debug, Clone, Default)] pub struct TransformLayerMessageHandler { @@ -15,6 +20,8 @@ pub struct TransformLayerMessageHandler { slow: bool, snap: bool, + local: bool, + fixed_bbox: Quad, typing: Typing, mouse_position: ViewportPosition, @@ -30,12 +37,7 @@ impl TransformLayerMessageHandler { } pub fn hints(&self, responses: &mut VecDeque) { - let axis_constraint = match self.transform_operation { - TransformOperation::Grabbing(grabbing) => grabbing.constraint, - TransformOperation::Scaling(scaling) => scaling.constraint, - _ => Axis::Both, - }; - self.transform_operation.hints(self.snap, axis_constraint, responses); + self.transform_operation.hints(responses); } } @@ -99,6 +101,7 @@ impl MessageHandler> for TransformLayer selected.responses.add(DocumentMessage::StartTransaction); }; + let document_to_viewport = document.metadata().document_to_viewport; match message { TransformLayerMessage::ApplyTransformOperation => { @@ -111,6 +114,7 @@ impl MessageHandler> for TransformLayer responses.add(DocumentMessage::EndTransaction); responses.add(ToolMessage::UpdateHints); responses.add(NodeGraphMessage::RunDocumentGraph); + responses.add(OverlaysMessage::RemoveProvider(TRANSFORM_GRS_OVERLAY_PROVIDER)); } TransformLayerMessage::BeginGrab => { if (!using_path_tool && !using_select_tool) @@ -126,8 +130,12 @@ impl MessageHandler> for TransformLayer begin_operation(self.transform_operation, &mut self.typing, &mut self.mouse_position, &mut self.start_mouse); self.transform_operation = TransformOperation::Grabbing(Default::default()); + self.local = false; + self.fixed_bbox = selected.bounding_box(); selected.original_transforms.clear(); + + responses.add(OverlaysMessage::AddProvider(TRANSFORM_GRS_OVERLAY_PROVIDER)); } TransformLayerMessage::BeginRotate => { let selected_points: Vec<&ManipulatorPointId> = shape_editor.selected_points().collect(); @@ -172,7 +180,12 @@ impl MessageHandler> for TransformLayer self.transform_operation = TransformOperation::Rotating(Default::default()); + self.local = false; + self.fixed_bbox = selected.bounding_box(); + selected.original_transforms.clear(); + + responses.add(OverlaysMessage::AddProvider(TRANSFORM_GRS_OVERLAY_PROVIDER)); } TransformLayerMessage::BeginScale => { let selected_points: Vec<&ManipulatorPointId> = shape_editor.selected_points().collect(); @@ -216,7 +229,12 @@ impl MessageHandler> for TransformLayer self.transform_operation = TransformOperation::Scaling(Default::default()); + self.local = false; + self.fixed_bbox = selected.bounding_box(); + selected.original_transforms.clear(); + + responses.add(OverlaysMessage::AddProvider(TRANSFORM_GRS_OVERLAY_PROVIDER)); } TransformLayerMessage::CancelTransformOperation => { selected.revert_operation(); @@ -228,21 +246,164 @@ impl MessageHandler> for TransformLayer responses.add(DocumentMessage::AbortTransaction); responses.add(ToolMessage::UpdateHints); + + responses.add(OverlaysMessage::RemoveProvider(TRANSFORM_GRS_OVERLAY_PROVIDER)); } - TransformLayerMessage::ConstrainX => self.transform_operation.constrain_axis(Axis::X, &mut selected, self.snap), - TransformLayerMessage::ConstrainY => self.transform_operation.constrain_axis(Axis::Y, &mut selected, self.snap), - TransformLayerMessage::PointerMove { slow_key, snap_key } => { - self.slow = input.keyboard.get(slow_key as usize); + TransformLayerMessage::ConstrainX => { + self.local = self + .transform_operation + .constrain_axis(Axis::X, &mut selected, self.snap, self.local, self.fixed_bbox, document_to_viewport) + } + TransformLayerMessage::ConstrainY => { + self.local = self + .transform_operation + .constrain_axis(Axis::Y, &mut selected, self.snap, self.local, self.fixed_bbox, document_to_viewport) + } + TransformLayerMessage::Overlays(mut overlay_context) => { + for layer in document.metadata().all_layers() { + if !document.network_interface.is_artboard(&layer.to_node(), &[]) { + continue; + }; + + let viewport_box = input.viewport_bounds.size(); + let transform = DAffine2::from_translation(DVec2::new(0., viewport_box.y)) * DAffine2::from_scale(DVec2::splat(1.2)); - let new_snap = input.keyboard.get(snap_key as usize); - if new_snap != self.snap { - self.snap = new_snap; let axis_constraint = match self.transform_operation { TransformOperation::Grabbing(grabbing) => grabbing.constraint, TransformOperation::Scaling(scaling) => scaling.constraint, _ => Axis::Both, }; - self.transform_operation.apply_transform_operation(&mut selected, self.snap, axis_constraint); + + let format_rounded = |value: f64, precision: usize| format!("{:.*}", precision, value).trim_end_matches('0').trim_end_matches('.').to_string(); + + let axis_text = |vector: DVec2, separate: bool| match (axis_constraint, separate) { + (Axis::Both, false) => format!("by {}", format_rounded(vector.x, 3)), + (Axis::Both, true) => format!("by ({}, {})", format_rounded(vector.x, 3), format_rounded(vector.y, 3)), + (Axis::X, _) => format!("X by {}", format_rounded(vector.x, 3)), + (Axis::Y, _) => format!("Y by {}", format_rounded(vector.y, 3)), + }; + + let grs_value_text = match self.transform_operation { + TransformOperation::None => String::new(), + TransformOperation::Grabbing(translation) => format!( + "Translating {}", + axis_text(document_to_viewport.inverse().transform_vector2(translation.to_dvec(document_to_viewport)), true) + ), + TransformOperation::Rotating(rotation) => format!("Rotating by {}°", format_rounded(rotation.to_f64(self.snap).to_degrees(), 3)), + TransformOperation::Scaling(scale) => format!("Scaling {}", axis_text(scale.to_dvec(self.snap), false)), + }; + + match self.transform_operation { + TransformOperation::None => (), + TransformOperation::Grabbing(translation) => { + let translation = document_to_viewport.inverse().transform_vector2(translation.to_dvec(document_to_viewport)); + let vec_to_end = self.mouse_position - self.start_mouse; + let quad = Quad::from_box([self.pivot, self.pivot + vec_to_end]).0; + let e1 = (self.fixed_bbox.0[1] - self.fixed_bbox.0[0]).normalize(); + + if matches!(axis_constraint, Axis::Both | Axis::X) { + let end = if self.local { + (quad[1] - quad[0]).length() * e1 * e1.dot(quad[1] - quad[0]).signum() + quad[0] + } else { + quad[1] + }; + overlay_context.line(quad[0], end, None); + + let x_transform = DAffine2::from_translation((quad[0] + end) / 2.); + overlay_context.text(&format_rounded(translation.x, 3), COLOR_OVERLAY_BLUE, None, x_transform, 4., [Pivot::Middle, Pivot::End]); + } + + if matches!(axis_constraint, Axis::Both | Axis::Y) { + let end = if self.local { + (quad[3] - quad[0]).length() * e1.perp() * e1.perp().dot(quad[3] - quad[0]).signum() + quad[0] + } else { + quad[3] + }; + overlay_context.line(quad[0], end, None); + let x_parameter = vec_to_end.x.clamp(-1., 1.); + let y_transform = DAffine2::from_translation((quad[0] + end) / 2. + x_parameter * DVec2::X * 0.); + let pivot_selection = if x_parameter > 0. { + Pivot::Start + } else if x_parameter == 0. { + Pivot::Middle + } else { + Pivot::End + }; + overlay_context.text(&format_rounded(translation.y, 2), COLOR_OVERLAY_BLUE, None, y_transform, 3., [pivot_selection, Pivot::Middle]); + } + if matches!(axis_constraint, Axis::Both) { + overlay_context.dashed_line(quad[1], quad[2], None, Some(2.), Some(2.), Some(0.5)); + overlay_context.dashed_line(quad[3], quad[2], None, Some(2.), Some(2.), Some(0.5)); + } + } + TransformOperation::Scaling(scale) => { + let scale = scale.to_f64(self.snap); + let text = format!("{}x", format_rounded(scale, 3)); + let extension_vector = self.mouse_position - self.start_mouse; + let local_edge = self.start_mouse - self.pivot; + let quad = self.fixed_bbox.0; + let local_edge = match axis_constraint { + Axis::X => { + if self.local { + local_edge.project_onto(quad[1] - quad[0]) + } else { + local_edge.with_y(0.) + } + } + Axis::Y => { + if self.local { + local_edge.project_onto(quad[3] - quad[0]) + } else { + local_edge.with_x(0.) + } + } + _ => local_edge, + }; + let boundary_point = local_edge + self.pivot; + let projected_pointer = extension_vector.project_onto(local_edge); + let dashed_till = if extension_vector.dot(local_edge) < 0. { local_edge + projected_pointer } else { local_edge }; + let lined_till = projected_pointer + boundary_point; + if dashed_till.dot(local_edge) > 0. { + overlay_context.dashed_line(self.pivot, self.pivot + dashed_till, None, Some(4.), Some(4.), Some(0.5)); + } + overlay_context.line(boundary_point, lined_till, None); + + let transform = DAffine2::from_translation(boundary_point.midpoint(self.pivot) + local_edge.perp().normalize() * local_edge.element_product().signum() * 24.); + overlay_context.text(&text, COLOR_OVERLAY_BLUE, None, transform, 16., [Pivot::Middle, Pivot::Middle]); + } + TransformOperation::Rotating(rotation) => { + let angle = rotation.to_f64(self.snap); + let quad = self.fixed_bbox.0; + let offset_angle = (quad[1] - quad[0]).to_angle(); + let width = viewport_box.max_element(); + let radius = self.start_mouse.distance(self.pivot); + let arc_radius = ANGLE_MEASURE_RADIUS_FACTOR * width; + let radius = radius.clamp(ARC_MEASURE_RADIUS_FACTOR_RANGE.0 * width, ARC_MEASURE_RADIUS_FACTOR_RANGE.1 * width); + let text = format!("{}°", format_rounded(angle.to_degrees(), 2)); + let text_texture_width = overlay_context.get_width(&text) / 2.; + let text_texture_height = 12.; + let text_angle_on_unit_circle = DVec2::from_angle((angle % TAU) / 2. + offset_angle); + let text_texture_position = DVec2::new( + (arc_radius + 4. + text_texture_width) * text_angle_on_unit_circle.x, + (arc_radius + text_texture_height) * text_angle_on_unit_circle.y, + ); + let transform = DAffine2::from_translation(text_texture_position + self.pivot); + overlay_context.draw_angle(self.pivot, radius, arc_radius, offset_angle, angle); + overlay_context.text(&text, COLOR_OVERLAY_BLUE, None, transform, 16., [Pivot::Middle, Pivot::Middle]); + } + } + + overlay_context.text(&grs_value_text, COLOR_OVERLAY_WHITE, Some(COLOR_OVERLAY_SNAP_BACKGROUND), transform, 4., [Pivot::Start, Pivot::End]); + } + } + TransformLayerMessage::PointerMove { slow_key, snap_key } => { + self.slow = input.keyboard.get(slow_key as usize); + + let new_snap = input.keyboard.get(snap_key as usize); + if new_snap != self.snap { + self.snap = new_snap; + self.transform_operation + .apply_transform_operation(&mut selected, self.snap, self.local, self.fixed_bbox, document_to_viewport); } if self.typing.digits.is_empty() { @@ -252,9 +413,9 @@ impl MessageHandler> for TransformLayer TransformOperation::None => unreachable!(), TransformOperation::Grabbing(translation) => { let change = if self.slow { delta_pos / SLOWING_DIVISOR } else { delta_pos }; - let axis_constraint = translation.constraint; self.transform_operation = TransformOperation::Grabbing(translation.increment_amount(change)); - self.transform_operation.apply_transform_operation(&mut selected, self.snap, axis_constraint); + self.transform_operation + .apply_transform_operation(&mut selected, self.snap, self.local, self.fixed_bbox, document_to_viewport); } TransformOperation::Rotating(rotation) => { let start_offset = *selected.pivot - self.mouse_position; @@ -264,7 +425,8 @@ impl MessageHandler> for TransformLayer let change = if self.slow { angle / SLOWING_DIVISOR } else { angle }; self.transform_operation = TransformOperation::Rotating(rotation.increment_amount(change)); - self.transform_operation.apply_transform_operation(&mut selected, self.snap, Axis::Both); + self.transform_operation + .apply_transform_operation(&mut selected, self.snap, self.local, self.fixed_bbox, document_to_viewport); } TransformOperation::Scaling(scale) => { let change = { @@ -274,11 +436,17 @@ impl MessageHandler> for TransformLayer (current_frame_dist - previous_frame_dist) / start_transform_dist }; - + let region_negate = (self.start_mouse - *selected.pivot).dot(self.mouse_position - *selected.pivot) < 0.; let change = if self.slow { change / SLOWING_DIVISOR } else { change }; - let axis_constraint = scale.constraint; + let change = change * scale.dragged_factor.signum(); self.transform_operation = TransformOperation::Scaling(scale.increment_amount(change)); - self.transform_operation.apply_transform_operation(&mut selected, self.snap, axis_constraint); + if region_negate { + let tmp_operation = TransformOperation::Scaling(scale.negate()); + tmp_operation.apply_transform_operation(&mut selected, self.snap, self.local, self.fixed_bbox, document_to_viewport); + } else { + self.transform_operation + .apply_transform_operation(&mut selected, self.snap, self.local, self.fixed_bbox, document_to_viewport); + } } }; } @@ -289,10 +457,24 @@ impl MessageHandler> for TransformLayer let target_layers = document.network_interface.selected_nodes(&[]).unwrap().selected_layers(document.metadata()).collect(); shape_editor.set_selected_layers(target_layers); } - TransformLayerMessage::TypeBackspace => self.transform_operation.grs_typed(self.typing.type_backspace(), &mut selected, self.snap), - TransformLayerMessage::TypeDecimalPoint => self.transform_operation.grs_typed(self.typing.type_decimal_point(), &mut selected, self.snap), - TransformLayerMessage::TypeDigit { digit } => self.transform_operation.grs_typed(self.typing.type_number(digit), &mut selected, self.snap), - TransformLayerMessage::TypeNegate => self.transform_operation.grs_typed(self.typing.type_negate(), &mut selected, self.snap), + TransformLayerMessage::TypeBackspace => self + .transform_operation + .grs_typed(self.typing.type_backspace(), &mut selected, self.snap, self.local, self.fixed_bbox, document_to_viewport), + TransformLayerMessage::TypeDecimalPoint => { + self.transform_operation + .grs_typed(self.typing.type_decimal_point(), &mut selected, self.snap, self.local, self.fixed_bbox, document_to_viewport) + } + TransformLayerMessage::TypeDigit { digit } => { + self.transform_operation + .grs_typed(self.typing.type_number(digit), &mut selected, self.snap, self.local, self.fixed_bbox, document_to_viewport) + } + TransformLayerMessage::TypeNegate => { + if self.typing.digits.is_empty() { + self.transform_operation.negate(&mut selected, self.snap, self.local, self.fixed_bbox, document_to_viewport) + } + self.transform_operation + .grs_typed(self.typing.type_negate(), &mut selected, self.snap, self.local, self.fixed_bbox, document_to_viewport) + } } } diff --git a/editor/src/messages/tool/utility_types.rs b/editor/src/messages/tool/utility_types.rs index 948451b17b..a547a3af61 100644 --- a/editor/src/messages/tool/utility_types.rs +++ b/editor/src/messages/tool/utility_types.rs @@ -15,6 +15,7 @@ use crate::node_graph_executor::NodeGraphExecutor; use graphene_core::raster::color::Color; use graphene_core::text::FontCache; +use std::borrow::Cow; use std::fmt::{self, Debug}; pub struct ToolActionHandlerData<'a> { @@ -492,7 +493,7 @@ pub struct HintInfo { /// No such icon is shown if `None` is given, and it can be combined with `key_groups` if desired. pub mouse: Option, /// The text describing what occurs with this input combination. - pub label: String, + pub label: Cow<'static, str>, /// Draws a prepended "+" symbol which indicates that this is a refinement upon a previous hint in the group. pub plus: bool, /// Draws a prepended "/" symbol which indicates that this is an alternative to a previous hint in the group. @@ -500,7 +501,7 @@ pub struct HintInfo { } impl HintInfo { - pub fn keys(keys: impl IntoIterator, label: impl Into) -> Self { + pub fn keys(keys: impl IntoIterator, label: impl Into>) -> Self { let keys: Vec<_> = keys.into_iter().collect(); Self { key_groups: vec![KeysGroup(keys).into()], @@ -512,7 +513,7 @@ impl HintInfo { } } - pub fn multi_keys(multi_keys: impl IntoIterator>, label: impl Into) -> Self { + pub fn multi_keys(multi_keys: impl IntoIterator>, label: impl Into>) -> Self { let key_groups = multi_keys.into_iter().map(|keys| KeysGroup(keys.into_iter().collect()).into()).collect(); Self { key_groups, @@ -524,7 +525,7 @@ impl HintInfo { } } - pub fn mouse(mouse_motion: MouseMotion, label: impl Into) -> Self { + pub fn mouse(mouse_motion: MouseMotion, label: impl Into>) -> Self { Self { key_groups: vec![], key_groups_mac: None, @@ -535,7 +536,7 @@ impl HintInfo { } } - pub fn label(label: impl Into) -> Self { + pub fn label(label: impl Into>) -> Self { Self { key_groups: vec![], key_groups_mac: None, @@ -546,7 +547,7 @@ impl HintInfo { } } - pub fn keys_and_mouse(keys: impl IntoIterator, mouse_motion: MouseMotion, label: impl Into) -> Self { + pub fn keys_and_mouse(keys: impl IntoIterator, mouse_motion: MouseMotion, label: impl Into>) -> Self { let keys: Vec<_> = keys.into_iter().collect(); Self { key_groups: vec![KeysGroup(keys).into()], @@ -558,7 +559,7 @@ impl HintInfo { } } - pub fn multi_keys_and_mouse(multi_keys: impl IntoIterator>, mouse_motion: MouseMotion, label: impl Into) -> Self { + pub fn multi_keys_and_mouse(multi_keys: impl IntoIterator>, mouse_motion: MouseMotion, label: impl Into>) -> Self { let key_groups = multi_keys.into_iter().map(|keys| KeysGroup(keys.into_iter().collect()).into()).collect(); Self { key_groups, @@ -570,7 +571,7 @@ impl HintInfo { } } - pub fn arrow_keys(label: impl Into) -> Self { + pub fn arrow_keys(label: impl Into>) -> Self { let multi_keys = [[Key::ArrowUp], [Key::ArrowRight], [Key::ArrowDown], [Key::ArrowLeft]]; Self::multi_keys(multi_keys, label) }