fork/Graphite
1
0
Fork 0
mirror of https://github.com/GraphiteEditor/Graphite.git synced 2026-09-30 21:58:12 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix assorted Clippy lints (#3390)

Browse Source
This commit is contained in:
Dennis Kobert
2025-11-17 07:58:31 +00:00
committed by GitHub
parent ebb434692a
commit 181c30bc0a
30 changed files with 669 additions and 694 deletions
Download Patch File Download Diff File Expand all files Collapse all files
editor/src/messages/tool/tool_messages/brush_tool.rs
+11 -11
View File
@@ -411,18 +411,18 @@ impl Fsm for BrushToolFsmState {
}
(BrushToolFsmState::Drawing, BrushToolMessage::PointerMove) => {
if let Some(layer) = tool_data.layer {
if let Some(stroke) = tool_data.strokes.last_mut() {
let layer_position = document
.network_interface
.document_metadata()
.downstream_transform_to_viewport(layer)
.inverse()
.transform_point2(input.mouse.position);
let layer_position = tool_data.transform.inverse().transform_point2(layer_position);
if let Some(layer) = tool_data.layer
&& let Some(stroke) = tool_data.strokes.last_mut()
{
let layer_position = document
.network_interface
.document_metadata()
.downstream_transform_to_viewport(layer)
.inverse()
.transform_point2(input.mouse.position);
let layer_position = tool_data.transform.inverse().transform_point2(layer_position);
stroke.trace.push(BrushInputSample { position: layer_position })
}
stroke.trace.push(BrushInputSample { position: layer_position })
}
tool_data.update_strokes(responses);
editor/src/messages/tool/tool_messages/freehand_tool.rs
+11 -13
View File
@@ -367,20 +367,18 @@ fn extend_path_with_next_segment(tool_data: &mut FreehandToolData, position: DVe
modification_type: VectorModificationType::InsertPoint { id, position },
});
if extend {
if let Some((_, previous_position)) = tool_data.end_point {
let next_id = SegmentId::generate();
let points = [previous_position, id];
if extend && let Some((_, previous_position)) = tool_data.end_point {
let next_id = SegmentId::generate();
let points = [previous_position, id];
responses.add(GraphOperationMessage::Vector {
layer,
modification_type: VectorModificationType::InsertSegment {
id: next_id,
points,
handles: [None, None],
},
});
}
responses.add(GraphOperationMessage::Vector {
layer,
modification_type: VectorModificationType::InsertSegment {
id: next_id,
points,
handles: [None, None],
},
});
}
tool_data.dragged = true;
editor/src/messages/tool/tool_messages/gradient_tool.rs
+9 -10
View File
@@ -474,10 +474,10 @@ impl Fsm for GradientToolFsmState {
}
(GradientToolFsmState::Drawing, GradientToolMessage::PointerOutsideViewport { .. }) => {
// Auto-panning
if let Some(shift) = tool_data.auto_panning.shift_viewport(input, viewport, responses) {
if let Some(selected_gradient) = &mut tool_data.selected_gradient {
selected_gradient.transform.translation += shift;
}
if let Some(shift) = tool_data.auto_panning.shift_viewport(input, viewport, responses)
&& let Some(selected_gradient) = &mut tool_data.selected_gradient
{
selected_gradient.transform.translation += shift;
}
GradientToolFsmState::Drawing
@@ -497,12 +497,11 @@ impl Fsm for GradientToolFsmState {
tool_data.snap_manager.cleanup(responses);
let was_dragging = tool_data.selected_gradient.is_some();
if !was_dragging {
if let Some(selected_layer) = document.click(input, viewport) {
if let Some(gradient) = get_gradient(selected_layer, &document.network_interface) {
tool_data.selected_gradient = Some(SelectedGradient::new(gradient, selected_layer, document));
}
}
if !was_dragging
&& let Some(selected_layer) = document.click(input, viewport)
&& let Some(gradient) = get_gradient(selected_layer, &document.network_interface)
{
tool_data.selected_gradient = Some(SelectedGradient::new(gradient, selected_layer, document));
}
GradientToolFsmState::Ready
}
editor/src/messages/tool/tool_messages/path_tool.rs
+37 -42
View File
@@ -750,8 +750,8 @@ impl PathToolData {
// If the point is already selected and shift (`extend_selection`) is used, keep the selection unchanged.
// Otherwise, select the first point within the threshold.
if !(already_selected && extend_selection) {
if let Some(updated_selection_info) = shape_editor.change_point_selection(
if !(already_selected && extend_selection)
&& let Some(updated_selection_info) = shape_editor.change_point_selection(
&document.network_interface,
input.mouse.position,
SELECTION_THRESHOLD,
@@ -759,8 +759,7 @@ impl PathToolData {
path_overlay_mode,
self.frontier_handles_info.as_ref(),
) {
selection_info = updated_selection_info;
}
selection_info = updated_selection_info;
}
if let Some(selected_points) = selection_info {
@@ -778,28 +777,26 @@ impl PathToolData {
self.saved_selection_before_handle_drag = old_selection;
}
if handle_drag_from_anchor {
if let Some((layer, point)) = shape_editor.find_nearest_point_indices(&document.network_interface, input.mouse.position, SELECTION_THRESHOLD) {
// Check that selected point is an anchor
if let (Some(point_id), Some(vector)) = (point.as_anchor(), document.network_interface.compute_modified_vector(layer)) {
let handles = vector.all_connected(point_id).collect::<Vec<_>>();
self.alt_clicked_on_anchor = true;
for handle in &handles {
let modification_type = handle.set_relative_position(DVec2::ZERO);
responses.add(GraphOperationMessage::Vector { layer, modification_type });
for &handles in &vector.colinear_manipulators {
if handles.contains(handle) {
let modification_type = VectorModificationType::SetG1Continuous { handles, enabled: false };
responses.add(GraphOperationMessage::Vector { layer, modification_type });
}
if handle_drag_from_anchor && let Some((layer, point)) = shape_editor.find_nearest_point_indices(&document.network_interface, input.mouse.position, SELECTION_THRESHOLD) {
// Check that selected point is an anchor
if let (Some(point_id), Some(vector)) = (point.as_anchor(), document.network_interface.compute_modified_vector(layer)) {
let handles = vector.all_connected(point_id).collect::<Vec<_>>();
self.alt_clicked_on_anchor = true;
for handle in &handles {
let modification_type = handle.set_relative_position(DVec2::ZERO);
responses.add(GraphOperationMessage::Vector { layer, modification_type });
for &handles in &vector.colinear_manipulators {
if handles.contains(handle) {
let modification_type = VectorModificationType::SetG1Continuous { handles, enabled: false };
responses.add(GraphOperationMessage::Vector { layer, modification_type });
}
}
let manipulator_point_id = handles[0].to_manipulator_point();
shape_editor.deselect_all_points();
shape_editor.select_point_by_layer_and_id(manipulator_point_id, layer);
responses.add(PathToolMessage::SelectedPointUpdated);
}
let manipulator_point_id = handles[0].to_manipulator_point();
shape_editor.deselect_all_points();
shape_editor.select_point_by_layer_and_id(manipulator_point_id, layer);
responses.add(PathToolMessage::SelectedPointUpdated);
}
}
@@ -2098,19 +2095,19 @@ impl Fsm for PathToolFsmState {
let break_molding = input.keyboard.get(break_colinear_molding as usize);
// Logic for molding segment
if let Some(segment) = &mut tool_data.segment {
if let Some(molding_segment_handles) = tool_data.molding_info {
tool_data.temporary_adjacent_handles_while_molding = segment.mold_handle_positions(
document,
responses,
molding_segment_handles,
input.mouse.position,
break_molding,
tool_data.temporary_adjacent_handles_while_molding,
);
if let Some(segment) = &mut tool_data.segment
&& let Some(molding_segment_handles) = tool_data.molding_info
{
tool_data.temporary_adjacent_handles_while_molding = segment.mold_handle_positions(
document,
responses,
molding_segment_handles,
input.mouse.position,
break_molding,
tool_data.temporary_adjacent_handles_while_molding,
);
return PathToolFsmState::Dragging(tool_data.dragging_state);
}
return PathToolFsmState::Dragging(tool_data.dragging_state);
}
let anchor_and_handle_toggled = input.keyboard.get(move_anchor_with_handles as usize);
@@ -3384,15 +3381,13 @@ fn update_dynamic_hints(
let at_least_one_point_selected = shape_editor.selected_points().count() >= 1;
let mut single_colinear_anchor_selected = false;
if single_anchor_selected {
if let (Some(anchor), Some(layer)) = (
if single_anchor_selected
&& let (Some(anchor), Some(layer)) = (
shape_editor.selected_points().next(),
document.network_interface.selected_nodes().selected_layers(document.metadata()).next(),
) {
if let Some(vector) = document.network_interface.compute_modified_vector(layer) {
single_colinear_anchor_selected = vector.colinear(*anchor)
}
}
) && let Some(vector) = document.network_interface.compute_modified_vector(layer)
{
single_colinear_anchor_selected = vector.colinear(*anchor)
}
let drag_selected_hints = vec![HintInfo::mouse(MouseMotion::LmbDrag, "Drag Selected")];
editor/src/messages/tool/tool_messages/pen_tool.rs
+44 -45
View File
@@ -728,8 +728,8 @@ impl PenToolData {
// Store the segment
let id = SegmentId::generate();
if self.path_closed {
if let Some((handles, handle1_pos)) = match self.get_opposite_handle_type(TargetHandle::PreviewInHandle, &vector) {
if self.path_closed
&& let Some((handles, handle1_pos)) = match self.get_opposite_handle_type(TargetHandle::PreviewInHandle, &vector) {
TargetHandle::PriorOutHandle(segment) => {
let handles = [HandleId::end(id), HandleId::primary(segment)];
let handle1_pos = handles[1].to_manipulator_point().get_position(&vector);
@@ -742,15 +742,14 @@ impl PenToolData {
}
_ => None,
} {
let angle = (handle_end - next_point).angle_to(handle1_pos - next_point);
let pi = std::f64::consts::PI;
let colinear = (angle - pi).abs() < 1e-6 || (angle + pi).abs() < 1e-6;
responses.add(GraphOperationMessage::Vector {
layer,
modification_type: VectorModificationType::SetG1Continuous { handles, enabled: colinear },
});
self.cleanup(responses);
}
let angle = (handle_end - next_point).angle_to(handle1_pos - next_point);
let pi = std::f64::consts::PI;
let colinear = (angle - pi).abs() < 1e-6 || (angle + pi).abs() < 1e-6;
responses.add(GraphOperationMessage::Vector {
layer,
modification_type: VectorModificationType::SetG1Continuous { handles, enabled: colinear },
});
self.cleanup(responses);
}
self.prior_segment = Some(id);
@@ -938,10 +937,10 @@ impl PenToolData {
}
fn move_anchor_and_handles(&mut self, delta: DVec2, layer: LayerNodeIdentifier, responses: &mut VecDeque<Message>, vector: &Vector) {
if self.handle_end.is_none() {
if let Some(latest_pt) = self.latest_point_mut() {
latest_pt.pos += delta;
}
if self.handle_end.is_none()
&& let Some(latest_pt) = self.latest_point_mut()
{
latest_pt.pos += delta;
}
let Some(end_point) = self.prior_segment_endpoint else { return };
@@ -1210,10 +1209,11 @@ impl PenToolData {
snap.update_indicator(snapped);
}
if let Some(relative) = relative.map(|layer| transform.transform_point2(layer)) {
if (relative - document_pos) != DVec2::ZERO && (relative - document_pos).length_squared() > f64::EPSILON * 100. {
self.angle = -(relative - document_pos).angle_to(DVec2::X)
}
if let Some(relative) = relative.map(|layer| transform.transform_point2(layer))
&& (relative - document_pos) != DVec2::ZERO
&& (relative - document_pos).length_squared() > f64::EPSILON * 100.
{
self.angle = -(relative - document_pos).angle_to(DVec2::X)
}
transform.inverse().transform_point2(document_pos)
@@ -1245,20 +1245,20 @@ impl PenToolData {
self.current_layer = Some(layer);
self.extend_existing_path(document, layer, point, position);
return;
} else if preferences.vector_meshes {
if let Some(closest_segment) = shape_editor.upper_closest_segment(&document.network_interface, viewport_vec, tolerance) {
let (point, segments) = closest_segment.adjusted_insert(responses);
let layer = closest_segment.layer();
let position = closest_segment.closest_point_document();
} else if preferences.vector_meshes
&& let Some(closest_segment) = shape_editor.upper_closest_segment(&document.network_interface, viewport_vec, tolerance)
{
let (point, segments) = closest_segment.adjusted_insert(responses);
let layer = closest_segment.layer();
let position = closest_segment.closest_point_document();
// Setting any one of the new segments created as the previous segment
self.prior_segment_endpoint = Some(point);
self.prior_segment_layer = Some(layer);
self.prior_segments = Some(segments.to_vec());
// Setting any one of the new segments created as the previous segment
self.prior_segment_endpoint = Some(point);
self.prior_segment_layer = Some(layer);
self.prior_segments = Some(segments.to_vec());
self.extend_existing_path(document, layer, point, position);
return;
}
self.extend_existing_path(document, layer, point, position);
return;
}
if append {
@@ -1629,13 +1629,14 @@ impl Fsm for PenToolFsmState {
let viewport_vec = document.metadata().document_to_viewport.transform_point2(snapped.snapped_point_document);
let close_to_point = closest_point(document, viewport_vec, tolerance, document.metadata().all_layers(), |_| false, preferences).is_some();
if preferences.vector_meshes && !close_to_point {
if let Some(closest_segment) = shape_editor.upper_closest_segment(&document.network_interface, viewport_vec, tolerance) {
let pos = closest_segment.closest_point_to_viewport();
let perp = closest_segment.calculate_perp(document);
overlay_context.manipulator_anchor(pos, true, None);
overlay_context.line(pos - perp * SEGMENT_OVERLAY_SIZE, pos + perp * SEGMENT_OVERLAY_SIZE, Some(COLOR_OVERLAY_BLUE), None);
}
if preferences.vector_meshes
&& !close_to_point
&& let Some(closest_segment) = shape_editor.upper_closest_segment(&document.network_interface, viewport_vec, tolerance)
{
let pos = closest_segment.closest_point_to_viewport();
let perp = closest_segment.calculate_perp(document);
overlay_context.manipulator_anchor(pos, true, None);
overlay_context.line(pos - perp * SEGMENT_OVERLAY_SIZE, pos + perp * SEGMENT_OVERLAY_SIZE, Some(COLOR_OVERLAY_BLUE), None);
}
tool_data.snap_manager.draw_overlays(SnapData::new(document, input, viewport), &mut overlay_context);
self
@@ -1758,13 +1759,11 @@ impl Fsm for PenToolFsmState {
let snapped = tool_data.snap_manager.free_snap(&SnapData::new(document, input, viewport), &point, SnapTypeConfiguration::default());
let viewport = document.metadata().document_to_viewport.transform_point2(snapped.snapped_point_document);
let close_to_point = closest_point(document, viewport, tolerance, document.metadata().all_layers(), |_| false, preferences).is_some();
if !close_to_point {
if let Some(closest_segment) = shape_editor.upper_closest_segment(&document.network_interface, viewport, tolerance) {
let pos = closest_segment.closest_point_to_viewport();
let perp = closest_segment.calculate_perp(document);
overlay_context.manipulator_anchor(pos, true, None);
overlay_context.line(pos - perp * SEGMENT_OVERLAY_SIZE, pos + perp * SEGMENT_OVERLAY_SIZE, Some(COLOR_OVERLAY_BLUE), None);
}
if !close_to_point && let Some(closest_segment) = shape_editor.upper_closest_segment(&document.network_interface, viewport, tolerance) {
let pos = closest_segment.closest_point_to_viewport();
let perp = closest_segment.calculate_perp(document);
overlay_context.manipulator_anchor(pos, true, None);
overlay_context.line(pos - perp * SEGMENT_OVERLAY_SIZE, pos + perp * SEGMENT_OVERLAY_SIZE, Some(COLOR_OVERLAY_BLUE), None);
}
}
editor/src/messages/tool/tool_messages/select_tool.rs
+45 -46
View File
@@ -776,19 +776,19 @@ impl Fsm for SelectToolFsmState {
let is_resizing_or_rotating = matches!(self, SelectToolFsmState::ResizingBounds | SelectToolFsmState::SkewingBounds { .. } | SelectToolFsmState::RotatingBounds);
if overlay_context.visibility_settings.transform_cage() {
if let Some(bounds) = tool_data.bounding_box_manager.as_mut() {
let edges = bounds.check_selected_edges(input.mouse.position);
let is_skewing = matches!(self, SelectToolFsmState::SkewingBounds { .. });
let is_near_square = edges.is_some_and(|hover_edge| bounds.over_extended_edge_midpoint(input.mouse.position, hover_edge));
if is_skewing || (dragging_bounds && is_near_square && !is_resizing_or_rotating) {
bounds.render_skew_gizmos(&mut overlay_context, tool_data.skew_edge);
}
if !is_skewing && dragging_bounds {
if let Some(edges) = edges {
tool_data.skew_edge = bounds.get_closest_edge(edges, input.mouse.position);
}
}
if overlay_context.visibility_settings.transform_cage()
&& let Some(bounds) = tool_data.bounding_box_manager.as_mut()
{
let edges = bounds.check_selected_edges(input.mouse.position);
let is_skewing = matches!(self, SelectToolFsmState::SkewingBounds { .. });
let is_near_square = edges.is_some_and(|hover_edge| bounds.over_extended_edge_midpoint(input.mouse.position, hover_edge));
if is_skewing || (dragging_bounds && is_near_square && !is_resizing_or_rotating) {
bounds.render_skew_gizmos(&mut overlay_context, tool_data.skew_edge);
}
if !is_skewing
&& dragging_bounds && let Some(edges) = edges
{
tool_data.skew_edge = bounds.get_closest_edge(edges, input.mouse.position);
}
}
@@ -887,33 +887,32 @@ impl Fsm for SelectToolFsmState {
compass_rose_state.axis_type().and_then(|axis| axis.is_constraint().then_some((axis, true)))
};
if show_compass_with_ring.is_some() {
if let Some((axis, hover)) = axis_state {
if axis.is_constraint() {
let e0 = tool_data
.bounding_box_manager
.as_ref()
.map(|bounding_box_manager| bounding_box_manager.transform * Quad::from_box(bounding_box_manager.bounds))
.map_or(DVec2::X, |quad| (quad.top_left() - quad.top_right()).normalize_or(DVec2::X));
if show_compass_with_ring.is_some()
&& let Some((axis, hover)) = axis_state
&& axis.is_constraint()
{
let e0 = tool_data
.bounding_box_manager
.as_ref()
.map(|bounding_box_manager| bounding_box_manager.transform * Quad::from_box(bounding_box_manager.bounds))
.map_or(DVec2::X, |quad| (quad.top_left() - quad.top_right()).normalize_or(DVec2::X));
let (direction, color) = match axis {
Axis::X => (e0, COLOR_OVERLAY_RED),
Axis::Y => (e0.perp(), COLOR_OVERLAY_GREEN),
_ => unreachable!(),
};
let (direction, color) = match axis {
Axis::X => (e0, COLOR_OVERLAY_RED),
Axis::Y => (e0.perp(), COLOR_OVERLAY_GREEN),
_ => unreachable!(),
};
let viewport_diagonal = viewport.size().into_dvec2().length();
let viewport_diagonal = viewport.size().into_dvec2().length();
let color = if !hover {
color
} else {
let color_string = &graphene_std::Color::from_rgb_str(color.strip_prefix('#').unwrap()).unwrap().with_alpha(0.25).to_rgba_hex_srgb();
&format!("#{color_string}")
};
let line_center = tool_data.line_center;
overlay_context.line(line_center - direction * viewport_diagonal, line_center + direction * viewport_diagonal, Some(color), None);
}
}
let color = if !hover {
color
} else {
let color_string = &graphene_std::Color::from_rgb_str(color.strip_prefix('#').unwrap()).unwrap().with_alpha(0.25).to_rgba_hex_srgb();
&format!("#{color_string}")
};
let line_center = tool_data.line_center;
overlay_context.line(line_center - direction * viewport_diagonal, line_center + direction * viewport_diagonal, Some(color), None);
}
if axis_state.is_none_or(|(axis, _)| !axis.is_constraint()) && tool_data.axis_align {
@@ -1369,11 +1368,11 @@ impl Fsm for SelectToolFsmState {
}
(SelectToolFsmState::ResizingBounds | SelectToolFsmState::SkewingBounds { .. }, SelectToolMessage::PointerOutsideViewport { .. }) => {
// Auto-panning
if let Some(shift) = tool_data.auto_panning.shift_viewport(input, viewport, responses) {
if let Some(bounds) = &mut tool_data.bounding_box_manager {
bounds.center_of_transformation += shift;
bounds.original_bound_transform.translation += shift;
}
if let Some(shift) = tool_data.auto_panning.shift_viewport(input, viewport, responses)
&& let Some(bounds) = &mut tool_data.bounding_box_manager
{
bounds.center_of_transformation += shift;
bounds.original_bound_transform.translation += shift;
}
self
@@ -1499,10 +1498,10 @@ impl Fsm for SelectToolFsmState {
tool_data.axis_align = false;
tool_data.snap_manager.cleanup(responses);
if !matches!(self, SelectToolFsmState::DraggingPivot) {
if let Some(bounds) = &mut tool_data.bounding_box_manager {
bounds.original_transforms.clear();
}
if !matches!(self, SelectToolFsmState::DraggingPivot)
&& let Some(bounds) = &mut tool_data.bounding_box_manager
{
bounds.original_transforms.clear();
}
let selection = tool_data.nested_selection_behavior;
editor/src/messages/tool/tool_messages/text_tool.rs
+64 -68
View File
@@ -560,10 +560,10 @@ impl Fsm for TextToolFsmState {
bounding_box_manager.render_quad(&mut overlay_context);
// Draw red overlay if text is clipped
let transformed_quad = layer_transform * bounds;
if let Some((text, font, typesetting, _)) = graph_modification_utils::get_text(layer.unwrap(), &document.network_interface) {
if lines_clipping(text.as_str(), font, font_cache, typesetting) {
overlay_context.line(transformed_quad.0[2], transformed_quad.0[3], Some(COLOR_OVERLAY_RED), Some(3.));
}
if let Some((text, font, typesetting, _)) = graph_modification_utils::get_text(layer.unwrap(), &document.network_interface)
&& lines_clipping(text.as_str(), font, font_cache, typesetting)
{
overlay_context.line(transformed_quad.0[2], transformed_quad.0[3], Some(COLOR_OVERLAY_RED), Some(3.));
}
bounding_box_manager.render_overlays(&mut overlay_context, false);
@@ -697,63 +697,63 @@ impl Fsm for TextToolFsmState {
TextToolFsmState::Dragging
}
(TextToolFsmState::ResizingBounds, TextToolMessage::PointerMove { center, lock_ratio }) => {
if let Some(bounds) = &mut tool_data.bounding_box_manager {
if let Some(movement) = &mut bounds.selected_edges {
let (centered, constrain) = (input.keyboard.key(center), input.keyboard.key(lock_ratio));
let center_position = centered.then_some(bounds.center_of_transformation);
if let Some(bounds) = &mut tool_data.bounding_box_manager
&& let Some(movement) = &mut bounds.selected_edges
{
let (centered, constrain) = (input.keyboard.key(center), input.keyboard.key(lock_ratio));
let center_position = centered.then_some(bounds.center_of_transformation);
let Some(dragging_layer) = tool_data.layer_dragging else { return TextToolFsmState::Ready };
let Some(node_id) = graph_modification_utils::get_text_id(dragging_layer.id, &document.network_interface) else {
warn!("Cannot get text node id");
tool_data.layer_dragging.take();
return TextToolFsmState::Ready;
};
let Some(dragging_layer) = tool_data.layer_dragging else { return TextToolFsmState::Ready };
let Some(node_id) = graph_modification_utils::get_text_id(dragging_layer.id, &document.network_interface) else {
warn!("Cannot get text node id");
tool_data.layer_dragging.take();
return TextToolFsmState::Ready;
};
let selected = vec![dragging_layer.id];
let snap = Some(SizeSnapData {
manager: &mut tool_data.resize.snap_manager,
points: &mut tool_data.snap_candidates,
snap_data: SnapData::ignore(document, input, viewport, &selected),
});
let selected = vec![dragging_layer.id];
let snap = Some(SizeSnapData {
manager: &mut tool_data.resize.snap_manager,
points: &mut tool_data.snap_candidates,
snap_data: SnapData::ignore(document, input, viewport, &selected),
});
let (position, size) = movement.new_size(input.mouse.position, bounds.original_bound_transform, center_position, constrain, snap);
// Normalize so the size is always positive
let (position, size) = (position.min(position + size), size.abs());
let (position, size) = movement.new_size(input.mouse.position, bounds.original_bound_transform, center_position, constrain, snap);
// Normalize so the size is always positive
let (position, size) = (position.min(position + size), size.abs());
// Compute the offset needed for the top left in bounds space
let original_position = movement.bounds[0].min(movement.bounds[1]);
let translation_bounds_space = position - original_position;
// Compute the offset needed for the top left in bounds space
let original_position = movement.bounds[0].min(movement.bounds[1]);
let translation_bounds_space = position - original_position;
// Compute a transformation from bounds->viewport->layer
let transform_to_layer = document.metadata().transform_to_viewport(dragging_layer.id).inverse() * bounds.original_bound_transform;
let size_layer = transform_to_layer.transform_vector2(size);
// Compute a transformation from bounds->viewport->layer
let transform_to_layer = document.metadata().transform_to_viewport(dragging_layer.id).inverse() * bounds.original_bound_transform;
let size_layer = transform_to_layer.transform_vector2(size);
// Find the translation necessary from the original position in viewport space
let translation_viewport = bounds.original_bound_transform.transform_vector2(translation_bounds_space);
// Find the translation necessary from the original position in viewport space
let translation_viewport = bounds.original_bound_transform.transform_vector2(translation_bounds_space);
responses.add(NodeGraphMessage::SetInput {
input_connector: InputConnector::node(node_id, 6),
input: NodeInput::value(TaggedValue::OptionalF64(Some(size_layer.x)), false),
});
responses.add(NodeGraphMessage::SetInput {
input_connector: InputConnector::node(node_id, 7),
input: NodeInput::value(TaggedValue::OptionalF64(Some(size_layer.y)), false),
});
responses.add(GraphOperationMessage::TransformSet {
layer: dragging_layer.id,
transform: DAffine2::from_translation(translation_viewport) * document.metadata().document_to_viewport * dragging_layer.original_transform,
transform_in: TransformIn::Viewport,
skip_rerender: false,
});
responses.add(NodeGraphMessage::RunDocumentGraph);
responses.add(NodeGraphMessage::SetInput {
input_connector: InputConnector::node(node_id, 6),
input: NodeInput::value(TaggedValue::OptionalF64(Some(size_layer.x)), false),
});
responses.add(NodeGraphMessage::SetInput {
input_connector: InputConnector::node(node_id, 7),
input: NodeInput::value(TaggedValue::OptionalF64(Some(size_layer.y)), false),
});
responses.add(GraphOperationMessage::TransformSet {
layer: dragging_layer.id,
transform: DAffine2::from_translation(translation_viewport) * document.metadata().document_to_viewport * dragging_layer.original_transform,
transform_in: TransformIn::Viewport,
skip_rerender: false,
});
responses.add(NodeGraphMessage::RunDocumentGraph);
// Auto-panning
let messages = [
TextToolMessage::PointerOutsideViewport { center, lock_ratio }.into(),
TextToolMessage::PointerMove { center, lock_ratio }.into(),
];
tool_data.auto_panning.setup_by_mouse_position(input, viewport, &messages, responses);
}
// Auto-panning
let messages = [
TextToolMessage::PointerOutsideViewport { center, lock_ratio }.into(),
TextToolMessage::PointerMove { center, lock_ratio }.into(),
];
tool_data.auto_panning.setup_by_mouse_position(input, viewport, &messages, responses);
}
TextToolFsmState::ResizingBounds
}
@@ -771,11 +771,11 @@ impl Fsm for TextToolFsmState {
}
(TextToolFsmState::ResizingBounds | TextToolFsmState::Dragging, TextToolMessage::PointerOutsideViewport { .. }) => {
// Auto-panning
if let Some(shift) = tool_data.auto_panning.shift_viewport(input, viewport, responses) {
if let Some(bounds) = &mut tool_data.bounding_box_manager {
bounds.center_of_transformation += shift;
bounds.original_bound_transform.translation += shift;
}
if let Some(shift) = tool_data.auto_panning.shift_viewport(input, viewport, responses)
&& let Some(bounds) = &mut tool_data.bounding_box_manager
{
bounds.center_of_transformation += shift;
bounds.original_bound_transform.translation += shift;
}
self
@@ -808,11 +808,9 @@ impl Fsm for TextToolFsmState {
let has_dragged = (start - end).length_squared() > DRAG_THRESHOLD * DRAG_THRESHOLD;
// Check if the user has clicked (no dragging) on some existing text
if !has_dragged {
if let Some(clicked_text_layer_path) = TextToolData::check_click(document, input, font_cache) {
tool_data.start_editing_layer(clicked_text_layer_path, self, document, font_cache, responses);
return TextToolFsmState::Editing;
}
if !has_dragged && let Some(clicked_text_layer_path) = TextToolData::check_click(document, input, font_cache) {
tool_data.start_editing_layer(clicked_text_layer_path, self, document, font_cache, responses);
return TextToolFsmState::Editing;
}
// Otherwise create some new text
@@ -846,11 +844,9 @@ impl Fsm for TextToolFsmState {
bounds.original_transforms.clear();
}
if drag_too_small {
if let Some(layer_info) = &tool_data.layer_dragging {
tool_data.start_editing_layer(layer_info.id, self, document, font_cache, responses);
return TextToolFsmState::Editing;
}
if drag_too_small && let Some(layer_info) = &tool_data.layer_dragging {
tool_data.start_editing_layer(layer_info.id, self, document, font_cache, responses);
return TextToolFsmState::Editing;
}
tool_data.layer_dragging.take();