Refactor internal shape and reduce reliance on Kurbo

.vscode/settings.json

@@ -46,4 +46,5 @@
 	"html.format.wrapLineLength": 200,
 	"files.eol": "\n",
 	"files.insertFinalNewline": true,
+	"rust-analyzer.procMacro.attributes.enable": true,
 }

editor/src/communication/dispatcher.rs

@@ -460,8 +460,23 @@ mod test {
 	}
 
 	#[test]
+	/// If this test is failing take a look at `GRAPHITE_DOCUMENT_VERSION` in `editor/src/consts.rs`, it may need to be updated.
+	/// This test will fail when you make changes to the underlying serialization format for a document.
 	fn check_if_graphite_file_version_upgrade_is_needed() {
  use crate::layout::widgets::{LayoutGroup, TextLabel, Widget};
+ let print_problem_to_terminal_on_failure = |value: &String| {
+ println!();
+ println!("-------------------------------------------------");
+ println!("Failed test due to receiving a DisplayDialogError while loading the Graphite sample file!");
+ println!("This is most likely caused by forgetting to bump the `GRAPHITE_DOCUMENT_VERSION` in `editor/src/consts.rs`");
+ println!("After bumping this version number, please replace the `graphite-test-document.graphite` with a valid file [saved from the editor].");
+ println!("DisplayDialogError details:");
+ println!();
+ println!("Description: {}", value);
+ println!("-------------------------------------------------");
+ println!();
+ panic!()
+ };
 
  init_logger();
  set_uuid_seed(0);
@@ -473,20 +488,11 @@ mod test {
  });
 
  for response in responses {
+ // Check for the existence of the file format incompatibility warning dialog after opening the test file
  if let FrontendMessage::UpdateDialogDetails { layout_target: _, layout } = response {
  if let LayoutGroup::Row { widgets } = &layout[0] {
  if let Widget::TextLabel(TextLabel { value, .. }) = &widgets[0].widget {
- println!();
- println!("-------------------------------------------------");
- println!("Failed test due to receiving a DisplayDialogError while loading the Graphite sample file!");
- println!("This is most likely caused by forgetting to bump the `GRAPHITE_DOCUMENT_VERSION` in `editor/src/consts.rs`");
- println!("Once bumping this version number please replace the `graphite-test-document.graphite` with a valid file.");
- println!("DisplayDialogError details:");
- println!();
- println!("Description: {}", value);
- println!("-------------------------------------------------");
- println!();
- panic!()
+ print_problem_to_terminal_on_failure(value);
  }
  }
  }

editor/src/consts.rs

@@ -70,5 +70,5 @@ pub const DEFAULT_FONT_FAMILY: &str = "Merriweather";
 pub const DEFAULT_FONT_STYLE: &str = "Normal (400)";
 
 // Document
-pub const GRAPHITE_DOCUMENT_VERSION: &str = "0.0.8"; // Remember to save a simple document and replace the test file at: editor\src\communication\graphite-test-document.graphite
+pub const GRAPHITE_DOCUMENT_VERSION: &str = "0.0.10"; // Remember to save a simple document and replace the test file at: editor\src\communication\graphite-test-document.graphite
 pub const VIEWPORT_ZOOM_TO_FIT_PADDING_SCALE_FACTOR: f32 = 1.05;

editor/src/dialog/dialog_message_handler.rs

@@ -1,9 +1,9 @@
+use super::*;
 use crate::document::PortfolioMessageHandler;
-use crate::layout::{layout_message::LayoutTarget, widgets::PropertyHolder};
+use crate::layout::layout_message::LayoutTarget;
+use crate::layout::widgets::PropertyHolder;
 use crate::message_prelude::*;
 
-use super::*;
-
 #[derive(Debug, Default, Clone)]
 pub struct DialogMessageHandler {
 	export_dialog: Export,

editor/src/dialog/dialogs/coming_soon_dialog.rs

@@ -1,4 +1,5 @@
-use crate::{layout::widgets::*, message_prelude::FrontendMessage};
+use crate::layout::widgets::*;
+use crate::message_prelude::FrontendMessage;
 
 use std::fmt::Write;
 

editor/src/dialog/dialogs/error_dialog.rs

@@ -1,4 +1,5 @@
-use crate::{layout::widgets::*, message_prelude::FrontendMessage};
+use crate::layout::widgets::*;
+use crate::message_prelude::FrontendMessage;
 
 /// A dialog to notify users of a non-fatal error.
 pub struct Error {

editor/src/document/document_message.rs

@@ -53,7 +53,9 @@ pub enum DocumentMessage {
  layer_path: Vec<LayerId>,
 	},
 	DeleteSelectedLayers,
+	DeleteSelectedVectorPoints,
 	DeselectAllLayers,
+	DeselectAllVectorPoints,
 	DirtyRenderDocument,
 	DirtyRenderDocumentInOutlineView,
 	DocumentHistoryBackward,
@@ -81,6 +83,11 @@ pub enum DocumentMessage {
  insert_index: isize,
  reverse_index: bool,
 	},
+	MoveSelectedVectorPoints {
+ layer_path: Vec<LayerId>,
+ delta: (f64, f64),
+ absolute_position: (f64, f64),
+	},
 	NudgeSelectedLayers {
  delta_x: f64,
  delta_y: f64,
@@ -144,6 +151,11 @@ pub enum DocumentMessage {
 	ToggleLayerVisibility {
  layer_path: Vec<LayerId>,
 	},
+	ToggleSelectedHandleMirroring {
+ layer_path: Vec<LayerId>,
+ toggle_distance: bool,
+ toggle_angle: bool,
+	},
 	Undo,
 	UngroupLayers {
  folder_path: Vec<LayerId>,

editor/src/document/document_message_handler.rs

@@ -14,7 +14,6 @@ use crate::layout::widgets::{
 	SeparatorDirection, SeparatorType, Widget, WidgetCallback, WidgetHolder, WidgetLayout,
 };
 use crate::message_prelude::*;
-use crate::viewport_tools::vector_editor::vector_shape::VectorShape;
 use crate::EditorError;
 
 use graphene::color::Color;
@@ -24,6 +23,7 @@ use graphene::layers::folder_layer::FolderLayer;
 use graphene::layers::layer_info::{LayerDataType, LayerDataTypeDiscriminant};
 use graphene::layers::style::{Fill, RenderData, ViewMode};
 use graphene::layers::text_layer::{Font, FontCache};
+use graphene::layers::vector::vector_shape::VectorShape;
 use graphene::{DocumentError, DocumentResponse, LayerId, Operation as DocumentOperation};
 
 use glam::{DAffine2, DVec2};
@@ -158,28 +158,6 @@ impl DocumentMessageHandler {
  self.artboard_message_handler.artboards_graphene_document.bounding_box_and_transform(path, font_cache).unwrap_or(None)
 	}
 
-	/// Create a new vector shape representation with the underlying kurbo data, VectorManipulatorShape
-	pub fn selected_visible_layers_vector_shapes(&self, responses: &mut VecDeque<Message>, font_cache: &FontCache) -> Vec<VectorShape> {
- let shapes = self.selected_layers().filter_map(|path_to_shape| {
- let viewport_transform = self.graphene_document.generate_transform_relative_to_viewport(path_to_shape).ok()?;
- let layer = self.graphene_document.layer(path_to_shape);
-
- match &layer {
- Ok(layer) if layer.visible => {}
- _ => return None,
- };
-
- // TODO: Create VectorManipulatorShape when creating a kurbo shape as a stopgap, rather than on each new selection
- match &layer.ok()?.data {
- LayerDataType::Shape(shape) => Some(VectorShape::new(path_to_shape.to_vec(), viewport_transform, &shape.path, shape.closed, responses)),
- LayerDataType::Text(text) => Some(VectorShape::new(path_to_shape.to_vec(), viewport_transform, &text.to_bez_path_nonmut(font_cache), true, responses)),
- _ => None,
- }
- });
-
- shapes.collect::<Vec<VectorShape>>()
-	}
-
 	pub fn selected_layers(&self) -> impl Iterator<Item = &[LayerId]> {
  self.layer_metadata.iter().filter_map(|(path, data)| data.selected.then(|| path.as_slice()))
 	}
@@ -223,6 +201,22 @@ impl DocumentMessageHandler {
  })
 	}
 
+	/// Returns a copy of all the currently selected VectorShapes.
+	pub fn selected_vector_shapes(&self) -> Vec<VectorShape> {
+ self.selected_visible_layers()
+ .flat_map(|layer| self.graphene_document.layer(layer))
+ .flat_map(|layer| layer.as_vector_shape_copy())
+ .collect::<Vec<VectorShape>>()
+	}
+
+	/// Returns references to all the currently selected VectorShapes.
+	pub fn selected_vector_shapes_ref(&self) -> Vec<&VectorShape> {
+ self.selected_visible_layers()
+ .flat_map(|layer| self.graphene_document.layer(layer))
+ .flat_map(|layer| layer.as_vector_shape())
+ .collect::<Vec<&VectorShape>>()
+	}
+
 	/// Returns the bounding boxes for all visible layers and artboards, optionally excluding any paths.
 	pub fn bounding_boxes<'a>(&'a self, ignore_document: Option<&'a Vec<Vec<LayerId>>>, ignore_artboard: Option<LayerId>, font_cache: &'a FontCache) -> impl Iterator<Item = [DVec2; 2]> + 'a {
  self.visible_layers()
@@ -998,14 +992,28 @@ impl MessageHandler<DocumentMessage, (&InputPreprocessorMessageHandler, &FontCac
  responses.push_front(BroadcastSignal::SelectionChanged.into());
  responses.push_back(BroadcastSignal::DocumentIsDirty.into());
  }
+ DeleteSelectedVectorPoints => {
+ responses.push_back(StartTransaction.into());
+
+ responses.push_front(
+ DocumentOperation::DeleteSelectedVectorPoints {
+ layer_paths: self.selected_layers_without_children().iter().map(|path| path.to_vec()).collect(),
+ }
+ .into(),
+ );
+ }
  DeselectAllLayers => {
  responses.push_front(SetSelectedLayers { replacement_selected_layers: vec![] }.into());
  self.layer_range_selection_reference.clear();
  }
+ DeselectAllVectorPoints => {
+ for layer_path in self.selected_layers_without_children() {
+ responses.push_back(DocumentOperation::DeselectAllVectorPoints { layer_path: layer_path.to_vec() }.into());
+ }
+ }
  DirtyRenderDocument => {
  // Mark all non-overlay caches as dirty
  GrapheneDocument::mark_children_as_dirty(&mut self.graphene_document.root);
-
  responses.push_back(DocumentMessage::RenderDocument.into());
  }
  DirtyRenderDocumentInOutlineView => {
@@ -1163,6 +1171,12 @@ impl MessageHandler<DocumentMessage, (&InputPreprocessorMessageHandler, &FontCac
  .into(),
  );
  }
+ MoveSelectedVectorPoints { layer_path, delta, absolute_position } => {
+ self.backup(responses);
+ if let Ok(_layer) = self.graphene_document.layer(&layer_path) {
+ responses.push_back(DocumentOperation::MoveSelectedVectorPoints { layer_path, delta, absolute_position }.into());
+ }
+ }
  NudgeSelectedLayers { delta_x, delta_y } => {
  self.backup(responses);
  for path in self.selected_layers().map(|path| path.to_vec()) {
@@ -1462,6 +1476,20 @@ impl MessageHandler<DocumentMessage, (&InputPreprocessorMessageHandler, &FontCac
  responses.push_back(DocumentOperation::ToggleLayerVisibility { path: layer_path }.into());
  responses.push_back(BroadcastSignal::DocumentIsDirty.into());
  }
+ ToggleSelectedHandleMirroring {
+ layer_path,
+ toggle_distance,
+ toggle_angle,
+ } => {
+ responses.push_back(
+ DocumentOperation::SetSelectedHandleMirroring {
+ layer_path,
+ toggle_distance,
+ toggle_angle,
+ }
+ .into(),
+ );
+ }
  Undo => {
  responses.push_back(BroadcastSignal::ToolAbort.into());
  responses.push_back(DocumentHistoryBackward.into());

editor/src/document/portfolio_message_handler.rs

@@ -1,11 +1,12 @@
 use super::clipboards::{CopyBufferEntry, INTERNAL_CLIPBOARD_COUNT};
 use super::{DocumentMessageHandler, MenuBarMessageHandler};
 use crate::consts::{DEFAULT_DOCUMENT_NAME, GRAPHITE_DOCUMENT_VERSION};
+use crate::dialog;
 use crate::frontend::utility_types::FrontendDocumentDetails;
 use crate::input::InputPreprocessorMessageHandler;
 use crate::layout::layout_message::LayoutTarget;
 use crate::layout::widgets::PropertyHolder;
-use crate::{dialog, message_prelude::*};
+use crate::message_prelude::*;
 
 use graphene::layers::layer_info::LayerDataTypeDiscriminant;
 use graphene::layers::text_layer::{Font, FontCache};

editor/src/input/input_mapper.rs

@@ -103,9 +103,11 @@ impl Default for Mapping {
  // Path
  entry! {action=PathToolMessage::DragStart { add_to_selection: KeyShift }, key_down=Lmb},
  entry! {action=PathToolMessage::PointerMove { alt_mirror_angle: KeyAlt, shift_mirror_distance: KeyShift }, message=InputMapperMessage::PointerMove},
+ entry! {action=PathToolMessage::Delete, key_down=KeyDelete},
+ entry! {action=PathToolMessage::Delete, key_down=KeyBackspace},
  entry! {action=PathToolMessage::DragStop, key_up=Lmb},
  // Pen
- entry! {action=PenToolMessage::PointerMove, message=InputMapperMessage::PointerMove},
+ entry! {action=PenToolMessage::PointerMove { snap_angle: KeyControl, break_handle: KeyShift }, message=InputMapperMessage::PointerMove},
  entry! {action=PenToolMessage::DragStart, key_down=Lmb},
  entry! {action=PenToolMessage::DragStop, key_up=Lmb},
  entry! {action=PenToolMessage::Confirm, key_down=Rmb},

editor/src/layout/widgets.rs

@@ -1,10 +1,10 @@
-use std::rc::Rc;
-
 use super::layout_message::LayoutTarget;
-use crate::{input::keyboard::Key, message_prelude::*};
+use crate::input::keyboard::Key;
+use crate::message_prelude::*;
 
 use derivative::*;
 use serde::{Deserialize, Serialize};
+use std::rc::Rc;
 
 pub trait PropertyHolder {
 	fn properties(&self) -> Layout {

editor/src/viewport_tools/snapping.rs

@@ -7,6 +7,7 @@ use crate::message_prelude::*;
 
 use graphene::layers::layer_info::{Layer, LayerDataType};
 use graphene::layers::style::{self, Stroke};
+use graphene::layers::vector::constants::ControlPointType;
 use graphene::{LayerId, Operation};
 
 use glam::{DAffine2, DVec2};
@@ -52,16 +53,18 @@ impl SnapOverlays {
  responses.push_back(
  DocumentMessage::Overlays(
  if is_axis {
- Operation::AddOverlayLine {
+ Operation::AddLine {
  path: layer_path.clone(),
  transform,
  style: style::PathStyle::new(Some(Stroke::new(COLOR_ACCENT, 1.0)), style::Fill::None),
+ insert_index: -1,
  }
  } else {
- Operation::AddOverlayEllipse {
+ Operation::AddEllipse {
  path: layer_path.clone(),
  transform,
  style: style::PathStyle::new(None, style::Fill::Solid(COLOR_ACCENT)),
+ insert_index: -1,
  }
  }
  .into(),
@@ -246,43 +249,44 @@ impl SnapHandler {
 	/// Add the control points (optionally including bézier handles) of the specified shape layer to the snapping points
 	///
 	/// This should be called after start_snap
-	pub fn add_snap_path(&mut self, document_message_handler: &DocumentMessageHandler, layer: &Layer, path: &[LayerId], include_handles: bool) {
- if let LayerDataType::Shape(s) = &layer.data {
+	pub fn add_snap_path(&mut self, document_message_handler: &DocumentMessageHandler, layer: &Layer, path: &[LayerId], include_handles: bool, ignore_points: &[(&[LayerId], u64, ControlPointType)]) {
+ if let LayerDataType::Shape(shape_layer) = &layer.data {
  let transform = document_message_handler.graphene_document.multiply_transforms(path).unwrap();
- let snap_points = s
- .path
- .iter()
- .flat_map(|shape| {
+ let snap_points = shape_layer
+ .shape
+ .anchors()
+ .enumerate()
+ .flat_map(|(id, shape)| {
  if include_handles {
- match shape {
- kurbo::PathEl::MoveTo(point) => vec![point],
- kurbo::PathEl::LineTo(point) => vec![point],
- kurbo::PathEl::QuadTo(handle1, point) => vec![handle1, point],
- kurbo::PathEl::CurveTo(handle1, handle2, point) => vec![handle1, handle2, point],
- kurbo::PathEl::ClosePath => vec![],
- }
+ [
+ (*id, &shape.points[ControlPointType::Anchor]),
+ (*id, &shape.points[ControlPointType::InHandle]),
+ (*id, &shape.points[ControlPointType::OutHandle]),
+ ]
  } else {
- match shape {
- kurbo::PathEl::MoveTo(point) => vec![point],
- kurbo::PathEl::LineTo(point) => vec![point],
- kurbo::PathEl::QuadTo(_, point) => vec![point],
- kurbo::PathEl::CurveTo(_, _, point) => vec![point],
- kurbo::PathEl::ClosePath => vec![],
- }
+ [(*id, &shape.points[ControlPointType::Anchor]), (0, &None), (0, &None)]
  }
  })
- .map(|point| DVec2::new(point.x, point.y))
+ .filter_map(|(id, point)| point.as_ref().map(|val| (id, val)))
+ .filter(|(id, point)| !ignore_points.contains(&(path, *id, point.manipulator_type)))
+ .map(|(_id, point)| DVec2::new(point.position.x, point.position.y))
  .map(|pos| transform.transform_point2(pos));
  self.add_snap_points(document_message_handler, snap_points);
  }
 	}
 
 	/// Adds all of the shape handles in the document, including bézier handles of the points specified
-	pub fn add_all_document_handles(&mut self, document_message_handler: &DocumentMessageHandler, include_handles: &[&[LayerId]], exclude: &[&[LayerId]]) {
+	pub fn add_all_document_handles(
+ &mut self,
+ document_message_handler: &DocumentMessageHandler,
+ include_handles: &[&[LayerId]],
+ exclude: &[&[LayerId]],
+ ignore_points: &[(&[LayerId], u64, ControlPointType)],
+	) {
  for path in document_message_handler.all_layers() {
  if !exclude.contains(&path) {
  let layer = document_message_handler.graphene_document.layer(path).expect("Could not get layer for snapping");
- self.add_snap_path(document_message_handler, layer, path, include_handles.contains(&path));
+ self.add_snap_path(document_message_handler, layer, path, include_handles.contains(&path), ignore_points);
  }
  }
 	}