Restructure the entire editor codebase to consistently match the message hierarchy

Closes #744

editor/src/messages/portfolio/document/artboard/artboard_message.rs

@@ -0,0 +1,37 @@
+use crate::messages::prelude::*;
+
+use graphene::LayerId;
+use graphene::Operation as DocumentOperation;
+
+use serde::{Deserialize, Serialize};
+
+#[remain::sorted]
+#[impl_message(Message, DocumentMessage, Artboard)]
+#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
+pub enum ArtboardMessage {
+	// Sub-messages
+	#[remain::unsorted]
+	DispatchOperation(Box<DocumentOperation>),
+
+	// Messages
+	AddArtboard {
+		id: Option<LayerId>,
+		position: (f64, f64),
+		size: (f64, f64),
+	},
+	DeleteArtboard {
+		artboard: LayerId,
+	},
+	RenderArtboards,
+	ResizeArtboard {
+		artboard: LayerId,
+		position: (f64, f64),
+		size: (f64, f64),
+	},
+}
+
+impl From<DocumentOperation> for ArtboardMessage {
+	fn from(operation: DocumentOperation) -> Self {
+		Self::DispatchOperation(Box::new(operation))
+	}
+}

editor/src/messages/portfolio/document/artboard/artboard_message_handler.rs

@@ -0,0 +1,116 @@
+use crate::messages::prelude::*;
+
+use crate::application::generate_uuid;
+use graphene::color::Color;
+use graphene::document::Document as GrapheneDocument;
+use graphene::layers::style::{self, Fill, RenderData, ViewMode};
+use graphene::layers::text_layer::FontCache;
+use graphene::DocumentResponse;
+use graphene::LayerId;
+use graphene::Operation as DocumentOperation;
+
+use glam::DAffine2;
+use serde::{Deserialize, Serialize};
+use std::collections::VecDeque;
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct ArtboardMessageHandler {
+	pub artboards_graphene_document: GrapheneDocument,
+	pub artboard_ids: Vec<LayerId>,
+}
+
+impl MessageHandler<ArtboardMessage, &FontCache> for ArtboardMessageHandler {
+	#[remain::check]
+	fn process_message(&mut self, message: ArtboardMessage, font_cache: &FontCache, responses: &mut VecDeque<Message>) {
+		use ArtboardMessage::*;
+
+		#[remain::sorted]
+		match message {
+			// Sub-messages
+			#[remain::unsorted]
+			DispatchOperation(operation) => match self.artboards_graphene_document.handle_operation(*operation, font_cache) {
+				Ok(Some(document_responses)) => {
+					for response in document_responses {
+						match &response {
+							DocumentResponse::LayerChanged { path } => responses.push_back(PropertiesPanelMessage::CheckSelectedWasUpdated { path: path.clone() }.into()),
+							DocumentResponse::DeletedLayer { path } => responses.push_back(PropertiesPanelMessage::CheckSelectedWasDeleted { path: path.clone() }.into()),
+							DocumentResponse::DocumentChanged => responses.push_back(ArtboardMessage::RenderArtboards.into()),
+							_ => {}
+						};
+						responses.push_back(BroadcastEvent::DocumentIsDirty.into());
+					}
+				}
+				Ok(None) => {}
+				Err(e) => log::error!("Artboard Error: {:?}", e),
+			},
+
+			// Messages
+			AddArtboard { id, position, size } => {
+				let artboard_id = id.unwrap_or_else(generate_uuid);
+				self.artboard_ids.push(artboard_id);
+
+				responses.push_back(
+					ArtboardMessage::DispatchOperation(
+						DocumentOperation::AddRect {
+							path: vec![artboard_id],
+							insert_index: -1,
+							transform: DAffine2::from_scale_angle_translation(size.into(), 0., position.into()).to_cols_array(),
+							style: style::PathStyle::new(None, Fill::solid(Color::WHITE)),
+						}
+						.into(),
+					)
+					.into(),
+				);
+
+				responses.push_back(DocumentMessage::RenderDocument.into());
+			}
+			DeleteArtboard { artboard } => {
+				self.artboard_ids.retain(|&id| id != artboard);
+
+				responses.push_back(ArtboardMessage::DispatchOperation(Box::new(DocumentOperation::DeleteLayer { path: vec![artboard] })).into());
+
+				responses.push_back(DocumentMessage::RenderDocument.into());
+			}
+			RenderArtboards => {
+				// Render an infinite canvas if there are no artboards
+				if self.artboard_ids.is_empty() {
+					responses.push_back(
+						FrontendMessage::UpdateDocumentArtboards {
+							svg: r##"<rect width="100%" height="100%" fill="#ffffff" />"##.to_string(),
+						}
+						.into(),
+					)
+				} else {
+					let render_data = RenderData::new(ViewMode::Normal, font_cache, None, false);
+					responses.push_back(
+						FrontendMessage::UpdateDocumentArtboards {
+							svg: self.artboards_graphene_document.render_root(render_data),
+						}
+						.into(),
+					);
+				}
+			}
+			ResizeArtboard { artboard, position, size } => {
+				responses.push_back(
+					ArtboardMessage::DispatchOperation(Box::new(DocumentOperation::SetLayerTransform {
+						path: vec![artboard],
+						transform: DAffine2::from_scale_angle_translation(size.into(), 0., position.into()).to_cols_array(),
+					}))
+					.into(),
+				);
+
+				responses.push_back(DocumentMessage::RenderDocument.into());
+			}
+		}
+	}
+
+	fn actions(&self) -> ActionList {
+		actions!(ArtboardMessageDiscriminant;)
+	}
+}
+
+impl ArtboardMessageHandler {
+	pub fn is_infinite_canvas(&self) -> bool {
+		self.artboard_ids.is_empty()
+	}
+}

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

@@ -0,0 +1,7 @@
+mod artboard_message;
+mod artboard_message_handler;
+
+#[doc(inline)]
+pub use artboard_message::{ArtboardMessage, ArtboardMessageDiscriminant};
+#[doc(inline)]
+pub use artboard_message_handler::ArtboardMessageHandler;

editor/src/messages/portfolio/document/document_message.rs

@@ -0,0 +1,185 @@
+use crate::messages::frontend::utility_types::{ExportBounds, FileType};
+use crate::messages::portfolio::document::utility_types::layer_panel::LayerMetadata;
+use crate::messages::portfolio::document::utility_types::misc::{AlignAggregate, AlignAxis, FlipAxis};
+use crate::messages::prelude::*;
+
+use graphene::boolean_ops::BooleanOperation as BooleanOperationType;
+use graphene::layers::blend_mode::BlendMode;
+use graphene::layers::style::ViewMode;
+use graphene::LayerId;
+use graphene::Operation as DocumentOperation;
+
+use serde::{Deserialize, Serialize};
+
+#[remain::sorted]
+#[impl_message(Message, PortfolioMessage, Document)]
+#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
+pub enum DocumentMessage {
+	// Sub-messages
+	#[remain::unsorted]
+	DispatchOperation(Box<DocumentOperation>),
+	#[remain::unsorted]
+	#[child]
+	Artboard(ArtboardMessage),
+	#[remain::unsorted]
+	#[child]
+	Movement(MovementMessage),
+	#[remain::unsorted]
+	#[child]
+	Overlays(OverlaysMessage),
+	#[remain::unsorted]
+	#[child]
+	TransformLayer(TransformLayerMessage),
+	#[remain::unsorted]
+	#[child]
+	PropertiesPanel(PropertiesPanelMessage),
+
+	// Messages
+	AbortTransaction,
+	AddSelectedLayers {
+		additional_layers: Vec<Vec<LayerId>>,
+	},
+	AlignSelectedLayers {
+		axis: AlignAxis,
+		aggregate: AlignAggregate,
+	},
+	BooleanOperation(BooleanOperationType),
+	CommitTransaction,
+	CreateEmptyFolder {
+		container_path: Vec<LayerId>,
+	},
+	DebugPrintDocument,
+	DeleteLayer {
+		layer_path: Vec<LayerId>,
+	},
+	DeleteSelectedLayers,
+	DeleteSelectedManipulatorPoints,
+	DeselectAllLayers,
+	DeselectAllManipulatorPoints,
+	DirtyRenderDocument,
+	DirtyRenderDocumentInOutlineView,
+	DocumentHistoryBackward,
+	DocumentHistoryForward,
+	DocumentStructureChanged,
+	DuplicateSelectedLayers,
+	ExportDocument {
+		file_name: String,
+		file_type: FileType,
+		scale_factor: f64,
+		bounds: ExportBounds,
+	},
+	FlipSelectedLayers {
+		flip_axis: FlipAxis,
+	},
+	FolderChanged {
+		affected_folder_path: Vec<LayerId>,
+	},
+	GroupSelectedLayers,
+	LayerChanged {
+		affected_layer_path: Vec<LayerId>,
+	},
+	MoveSelectedLayersTo {
+		folder_path: Vec<LayerId>,
+		insert_index: isize,
+		reverse_index: bool,
+	},
+	MoveSelectedManipulatorPoints {
+		layer_path: Vec<LayerId>,
+		delta: (f64, f64),
+		absolute_position: (f64, f64),
+	},
+	NudgeSelectedLayers {
+		delta_x: f64,
+		delta_y: f64,
+	},
+	PasteImage {
+		mime: String,
+		image_data: Vec<u8>,
+		mouse: Option<(f64, f64)>,
+	},
+	Redo,
+	RenameLayer {
+		layer_path: Vec<LayerId>,
+		new_name: String,
+	},
+	RenderDocument,
+	RollbackTransaction,
+	SaveDocument,
+	SelectAllLayers,
+	SelectedLayersLower,
+	SelectedLayersLowerToBack,
+	SelectedLayersRaise,
+	SelectedLayersRaiseToFront,
+	SelectedLayersReorder {
+		relative_index_offset: isize,
+	},
+	SelectLayer {
+		layer_path: Vec<LayerId>,
+		ctrl: bool,
+		shift: bool,
+	},
+	SetBlendModeForSelectedLayers {
+		blend_mode: BlendMode,
+	},
+	SetLayerExpansion {
+		layer_path: Vec<LayerId>,
+		set_expanded: bool,
+	},
+	SetLayerName {
+		layer_path: Vec<LayerId>,
+		name: String,
+	},
+	SetOpacityForSelectedLayers {
+		opacity: f64,
+	},
+	SetOverlaysVisibility {
+		visible: bool,
+	},
+	SetSelectedLayers {
+		replacement_selected_layers: Vec<Vec<LayerId>>,
+	},
+	SetSnapping {
+		snap: bool,
+	},
+	SetTexboxEditability {
+		path: Vec<LayerId>,
+		editable: bool,
+	},
+	SetViewMode {
+		view_mode: ViewMode,
+	},
+	StartTransaction,
+	ToggleLayerExpansion {
+		layer_path: Vec<LayerId>,
+	},
+	ToggleLayerVisibility {
+		layer_path: Vec<LayerId>,
+	},
+	ToggleSelectedHandleMirroring {
+		layer_path: Vec<LayerId>,
+		toggle_distance: bool,
+		toggle_angle: bool,
+	},
+	Undo,
+	UngroupLayers {
+		folder_path: Vec<LayerId>,
+	},
+	UngroupSelectedLayers,
+	UpdateLayerMetadata {
+		layer_path: Vec<LayerId>,
+		layer_metadata: LayerMetadata,
+	},
+	ZoomCanvasToFitAll,
+}
+
+impl From<DocumentOperation> for DocumentMessage {
+	fn from(operation: DocumentOperation) -> DocumentMessage {
+		DocumentMessage::DispatchOperation(Box::new(operation))
+	}
+}
+
+impl From<DocumentOperation> for Message {
+	fn from(operation: DocumentOperation) -> Message {
+		DocumentMessage::DispatchOperation(Box::new(operation)).into()
+	}
+}

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

@@ -0,0 +1,14 @@
+mod document_message;
+mod document_message_handler;
+
+pub mod artboard;
+pub mod movement;
+pub mod overlays;
+pub mod properties_panel;
+pub mod transform_layer;
+pub mod utility_types;
+
+#[doc(inline)]
+pub use document_message::{DocumentMessage, DocumentMessageDiscriminant};
+#[doc(inline)]
+pub use document_message_handler::DocumentMessageHandler;

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

@@ -0,0 +1,7 @@
+mod movement_message;
+mod movement_message_handler;
+
+#[doc(inline)]
+pub use movement_message::{MovementMessage, MovementMessageDiscriminant};
+#[doc(inline)]
+pub use movement_message_handler::MovementMessageHandler;

editor/src/messages/portfolio/document/movement/movement_message.rs

@@ -0,0 +1,49 @@
+use crate::messages::input_mapper::utility_types::input_keyboard::Key;
+use crate::messages::prelude::*;
+
+use glam::DVec2;
+use serde::{Deserialize, Serialize};
+
+#[remain::sorted]
+#[impl_message(Message, DocumentMessage, Movement)]
+#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
+pub enum MovementMessage {
+	// Messages
+	DecreaseCanvasZoom {
+		center_on_mouse: bool,
+	},
+	FitViewportToBounds {
+		bounds: [DVec2; 2],
+		padding_scale_factor: Option<f32>,
+		prevent_zoom_past_100: bool,
+	},
+	IncreaseCanvasZoom {
+		center_on_mouse: bool,
+	},
+	PointerMove {
+		snap_angle: Key,
+		wait_for_snap_angle_release: bool,
+		snap_zoom: Key,
+		zoom_from_viewport: Option<DVec2>,
+	},
+	RotateCanvasBegin,
+	SetCanvasRotation {
+		angle_radians: f64,
+	},
+	SetCanvasZoom {
+		zoom_factor: f64,
+	},
+	TransformCanvasEnd,
+	TranslateCanvas {
+		delta: DVec2,
+	},
+	TranslateCanvasBegin,
+	TranslateCanvasByViewportFraction {
+		delta: DVec2,
+	},
+	WheelCanvasTranslate {
+		use_y_as_x: bool,
+	},
+	WheelCanvasZoom,
+	ZoomCanvasBegin,
+}

editor/src/messages/portfolio/document/movement/movement_message_handler.rs

@@ -0,0 +1,353 @@
+use crate::consts::{VIEWPORT_ROTATE_SNAP_INTERVAL, VIEWPORT_SCROLL_RATE, VIEWPORT_ZOOM_LEVELS, VIEWPORT_ZOOM_MOUSE_RATE, VIEWPORT_ZOOM_SCALE_MAX, VIEWPORT_ZOOM_SCALE_MIN, VIEWPORT_ZOOM_WHEEL_RATE};
+use crate::messages::frontend::utility_types::MouseCursorIcon;
+use crate::messages::input_mapper::utility_types::input_keyboard::{Key, KeysGroup};
+use crate::messages::input_mapper::utility_types::input_mouse::{ViewportBounds, ViewportPosition};
+use crate::messages::prelude::*;
+use crate::messages::tool::utility_types::{HintData, HintGroup, HintInfo};
+
+use graphene::document::Document;
+use graphene::Operation as DocumentOperation;
+
+use glam::{DAffine2, DVec2};
+use serde::{Deserialize, Serialize};
+use std::collections::VecDeque;
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct MovementMessageHandler {
+	pub pan: DVec2,
+	panning: bool,
+	snap_tilt: bool,
+	snap_tilt_released: bool,
+
+	pub tilt: f64,
+	tilting: bool,
+
+	pub zoom: f64,
+	zooming: bool,
+	snap_zoom: bool,
+
+	mouse_position: ViewportPosition,
+}
+
+impl Default for MovementMessageHandler {
+	fn default() -> Self {
+		Self {
+			pan: DVec2::ZERO,
+			panning: false,
+			snap_tilt: false,
+			snap_tilt_released: false,
+
+			tilt: 0.,
+			tilting: false,
+
+			zoom: 1.,
+			zooming: false,
+			snap_zoom: false,
+
+			mouse_position: ViewportPosition::default(),
+		}
+	}
+}
+
+impl MessageHandler<MovementMessage, (&Document, &InputPreprocessorMessageHandler)> for MovementMessageHandler {
+	#[remain::check]
+	fn process_message(&mut self, message: MovementMessage, data: (&Document, &InputPreprocessorMessageHandler), responses: &mut VecDeque<Message>) {
+		use MovementMessage::*;
+
+		let (document, ipp) = data;
+
+		#[remain::sorted]
+		match message {
+			DecreaseCanvasZoom { center_on_mouse } => {
+				let new_scale = *VIEWPORT_ZOOM_LEVELS.iter().rev().find(|scale| **scale < self.zoom).unwrap_or(&self.zoom);
+				if center_on_mouse {
+					responses.push_back(self.center_zoom(ipp.viewport_bounds.size(), new_scale / self.zoom, ipp.mouse.position));
+				}
+				responses.push_back(SetCanvasZoom { zoom_factor: new_scale }.into());
+			}
+			FitViewportToBounds {
+				bounds: [bounds_corner_a, bounds_corner_b],
+				padding_scale_factor,
+				prevent_zoom_past_100,
+			} => {
+				let pos1 = document.root.transform.inverse().transform_point2(bounds_corner_a);
+				let pos2 = document.root.transform.inverse().transform_point2(bounds_corner_b);
+				let v1 = document.root.transform.inverse().transform_point2(DVec2::ZERO);
+				let v2 = document.root.transform.inverse().transform_point2(ipp.viewport_bounds.size());
+
+				let center = v1.lerp(v2, 0.5) - pos1.lerp(pos2, 0.5);
+				let size = (pos2 - pos1) / (v2 - v1);
+				let size = 1. / size;
+				let new_scale = size.min_element();
+
+				self.pan += center;
+				self.zoom *= new_scale;
+
+				self.zoom /= padding_scale_factor.unwrap_or(1.) as f64;
+
+				if self.zoom > 1. && prevent_zoom_past_100 {
+					self.zoom = 1.
+				}
+
+				responses.push_back(BroadcastEvent::DocumentIsDirty.into());
+				responses.push_back(DocumentMessage::DirtyRenderDocumentInOutlineView.into());
+				responses.push_back(PortfolioMessage::UpdateDocumentWidgets.into());
+				self.create_document_transform(&ipp.viewport_bounds, responses);
+			}
+			IncreaseCanvasZoom { center_on_mouse } => {
+				let new_scale = *VIEWPORT_ZOOM_LEVELS.iter().find(|scale| **scale > self.zoom).unwrap_or(&self.zoom);
+				if center_on_mouse {
+					responses.push_back(self.center_zoom(ipp.viewport_bounds.size(), new_scale / self.zoom, ipp.mouse.position));
+				}
+				responses.push_back(SetCanvasZoom { zoom_factor: new_scale }.into());
+			}
+			PointerMove {
+				snap_angle,
+				wait_for_snap_angle_release,
+				snap_zoom,
+				zoom_from_viewport,
+			} => {
+				if self.panning {
+					let delta = ipp.mouse.position - self.mouse_position;
+
+					responses.push_back(TranslateCanvas { delta }.into());
+				}
+
+				if self.tilting {
+					let new_snap = ipp.keyboard.get(snap_angle as usize);
+					if !(wait_for_snap_angle_release && new_snap && !self.snap_tilt_released) {
+						// When disabling snap, keep the viewed rotation as it was previously.
+						if !new_snap && self.snap_tilt {
+							self.tilt = self.snapped_angle();
+						}
+						self.snap_tilt = new_snap;
+						self.snap_tilt_released = true;
+					}
+
+					let half_viewport = ipp.viewport_bounds.size() / 2.;
+					let rotation = {
+						let start_offset = self.mouse_position - half_viewport;
+						let end_offset = ipp.mouse.position - half_viewport;
+						start_offset.angle_between(end_offset)
+					};
+
+					responses.push_back(SetCanvasRotation { angle_radians: self.tilt + rotation }.into());
+				}
+
+				if self.zooming {
+					let zoom_start = self.snapped_scale();
+
+					let new_snap = ipp.keyboard.get(snap_zoom as usize);
+					// When disabling snap, keep the viewed zoom as it was previously
+					if !new_snap && self.snap_zoom {
+						self.zoom = self.snapped_scale();
+					}
+					self.snap_zoom = new_snap;
+
+					let difference = self.mouse_position.y as f64 - ipp.mouse.position.y as f64;
+					let amount = 1. + difference * VIEWPORT_ZOOM_MOUSE_RATE;
+
+					self.zoom *= amount;
+					if let Some(mouse) = zoom_from_viewport {
+						let zoom_factor = self.snapped_scale() / zoom_start;
+
+						responses.push_back(SetCanvasZoom { zoom_factor: self.zoom }.into());
+						responses.push_back(self.center_zoom(ipp.viewport_bounds.size(), zoom_factor, mouse));
+					} else {
+						responses.push_back(SetCanvasZoom { zoom_factor: self.zoom }.into());
+					}
+				}
+
+				self.mouse_position = ipp.mouse.position;
+			}
+			RotateCanvasBegin => {
+				responses.push_back(FrontendMessage::UpdateMouseCursor { cursor: MouseCursorIcon::Default }.into());
+				responses.push_back(
+					FrontendMessage::UpdateInputHints {
+						hint_data: HintData(vec![HintGroup(vec![HintInfo {
+							key_groups: vec![KeysGroup(vec![Key::KeyControl])],
+							key_groups_mac: None,
+							mouse: None,
+							label: String::from("Snap 15°"),
+							plus: false,
+						}])]),
+					}
+					.into(),
+				);
+
+				self.tilting = true;
+				self.mouse_position = ipp.mouse.position;
+			}
+			SetCanvasRotation { angle_radians } => {
+				self.tilt = angle_radians;
+				self.create_document_transform(&ipp.viewport_bounds, responses);
+				responses.push_back(BroadcastEvent::DocumentIsDirty.into());
+				responses.push_back(PortfolioMessage::UpdateDocumentWidgets.into());
+			}
+			SetCanvasZoom { zoom_factor } => {
+				self.zoom = zoom_factor.clamp(VIEWPORT_ZOOM_SCALE_MIN, VIEWPORT_ZOOM_SCALE_MAX);
+				responses.push_back(BroadcastEvent::DocumentIsDirty.into());
+				responses.push_back(DocumentMessage::DirtyRenderDocumentInOutlineView.into());
+				responses.push_back(PortfolioMessage::UpdateDocumentWidgets.into());
+				self.create_document_transform(&ipp.viewport_bounds, responses);
+			}
+			TransformCanvasEnd => {
+				self.tilt = self.snapped_angle();
+				self.zoom = self.snapped_scale();
+				responses.push_back(BroadcastEvent::DocumentIsDirty.into());
+				responses.push_back(ToolMessage::UpdateCursor.into());
+				responses.push_back(ToolMessage::UpdateHints.into());
+				self.snap_tilt = false;
+				self.snap_tilt_released = false;
+				self.snap_zoom = false;
+				self.panning = false;
+				self.tilting = false;
+				self.zooming = false;
+			}
+			TranslateCanvas { delta } => {
+				let transformed_delta = document.root.transform.inverse().transform_vector2(delta);
+
+				self.pan += transformed_delta;
+				responses.push_back(BroadcastEvent::DocumentIsDirty.into());
+				self.create_document_transform(&ipp.viewport_bounds, responses);
+			}
+			TranslateCanvasBegin => {
+				responses.push_back(FrontendMessage::UpdateMouseCursor { cursor: MouseCursorIcon::Grabbing }.into());
+				responses.push_back(FrontendMessage::UpdateInputHints { hint_data: HintData(Vec::new()) }.into());
+
+				self.panning = true;
+				self.mouse_position = ipp.mouse.position;
+			}
+			TranslateCanvasByViewportFraction { delta } => {
+				let transformed_delta = document.root.transform.inverse().transform_vector2(delta * ipp.viewport_bounds.size());
+
+				self.pan += transformed_delta;
+				responses.push_back(BroadcastEvent::DocumentIsDirty.into());
+				self.create_document_transform(&ipp.viewport_bounds, responses);
+			}
+			WheelCanvasTranslate { use_y_as_x } => {
+				let delta = match use_y_as_x {
+					false => -ipp.mouse.scroll_delta.as_dvec2(),
+					true => (-ipp.mouse.scroll_delta.y as f64, 0.).into(),
+				} * VIEWPORT_SCROLL_RATE;
+				responses.push_back(TranslateCanvas { delta }.into());
+			}
+			WheelCanvasZoom => {
+				let scroll = ipp.mouse.scroll_delta.scroll_delta();
+				let mut zoom_factor = 1. + scroll.abs() * VIEWPORT_ZOOM_WHEEL_RATE;
+				if ipp.mouse.scroll_delta.y > 0 {
+					zoom_factor = 1. / zoom_factor
+				};
+
+				responses.push_back(self.center_zoom(ipp.viewport_bounds.size(), zoom_factor, ipp.mouse.position));
+				responses.push_back(SetCanvasZoom { zoom_factor: self.zoom * zoom_factor }.into());
+			}
+			ZoomCanvasBegin => {
+				responses.push_back(FrontendMessage::UpdateMouseCursor { cursor: MouseCursorIcon::ZoomIn }.into());
+				responses.push_back(
+					FrontendMessage::UpdateInputHints {
+						hint_data: HintData(vec![HintGroup(vec![HintInfo {
+							key_groups: vec![KeysGroup(vec![Key::KeyControl])],
+							key_groups_mac: None,
+							mouse: None,
+							label: String::from("Snap Increments"),
+							plus: false,
+						}])]),
+					}
+					.into(),
+				);
+
+				self.zooming = true;
+				self.mouse_position = ipp.mouse.position;
+			}
+		}
+	}
+
+	fn actions(&self) -> ActionList {
+		let mut common = actions!(MovementMessageDiscriminant;
+			TranslateCanvasBegin,
+			RotateCanvasBegin,
+			ZoomCanvasBegin,
+			SetCanvasZoom,
+			SetCanvasRotation,
+			WheelCanvasZoom,
+			IncreaseCanvasZoom,
+			DecreaseCanvasZoom,
+			WheelCanvasTranslate,
+			TranslateCanvas,
+			TranslateCanvasByViewportFraction,
+		);
+
+		if self.panning || self.tilting || self.zooming {
+			let transforming = actions!(MovementMessageDiscriminant;
+				PointerMove,
+				TransformCanvasEnd,
+			);
+			common.extend(transforming);
+		}
+		common
+	}
+}
+
+impl MovementMessageHandler {
+	pub fn snapped_angle(&self) -> f64 {
+		let increment_radians: f64 = VIEWPORT_ROTATE_SNAP_INTERVAL.to_radians();
+		if self.snap_tilt {
+			(self.tilt / increment_radians).round() * increment_radians
+		} else {
+			self.tilt
+		}
+	}
+
+	pub fn snapped_scale(&self) -> f64 {
+		if self.snap_zoom {
+			*VIEWPORT_ZOOM_LEVELS
+				.iter()
+				.min_by(|a, b| (**a - self.zoom).abs().partial_cmp(&(**b - self.zoom).abs()).unwrap())
+				.unwrap_or(&self.zoom)
+		} else {
+			self.zoom
+		}
+	}
+
+	pub fn calculate_offset_transform(&self, offset: DVec2) -> DAffine2 {
+		// TODO: replace with DAffine2::from_scale_angle_translation and fix the errors
+		let offset_transform = DAffine2::from_translation(offset);
+		let scale_transform = DAffine2::from_scale(DVec2::splat(self.snapped_scale()));
+		let angle_transform = DAffine2::from_angle(self.snapped_angle());
+		let translation_transform = DAffine2::from_translation(self.pan);
+		scale_transform * offset_transform * angle_transform * translation_transform
+	}
+
+	fn create_document_transform(&self, viewport_bounds: &ViewportBounds, responses: &mut VecDeque<Message>) {
+		let half_viewport = viewport_bounds.size() / 2.;
+		let scaled_half_viewport = half_viewport / self.snapped_scale();
+		responses.push_back(
+			DocumentOperation::SetLayerTransform {
+				path: vec![],
+				transform: self.calculate_offset_transform(scaled_half_viewport).to_cols_array(),
+			}
+			.into(),
+		);
+
+		responses.push_back(
+			ArtboardMessage::DispatchOperation(
+				DocumentOperation::SetLayerTransform {
+					path: vec![],
+					transform: self.calculate_offset_transform(scaled_half_viewport).to_cols_array(),
+				}
+				.into(),
+			)
+			.into(),
+		);
+	}
+
+	pub fn center_zoom(&self, viewport_bounds: DVec2, zoom_factor: f64, mouse: DVec2) -> Message {
+		let new_viewport_bounds = viewport_bounds / zoom_factor;
+		let delta_size = viewport_bounds - new_viewport_bounds;
+		let mouse_fraction = mouse / viewport_bounds;
+		let delta = delta_size * (DVec2::splat(0.5) - mouse_fraction);
+
+		MovementMessage::TranslateCanvas { delta }.into()
+	}
+}

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

@@ -0,0 +1,7 @@
+mod overlays_message;
+mod overlays_message_handler;
+
+#[doc(inline)]
+pub use overlays_message::{OverlaysMessage, OverlaysMessageDiscriminant};
+#[doc(inline)]
+pub use overlays_message_handler::OverlaysMessageHandler;

editor/src/messages/portfolio/document/overlays/overlays_message.rs

@@ -0,0 +1,24 @@
+use crate::messages::prelude::*;
+
+use graphene::Operation as DocumentOperation;
+
+use serde::{Deserialize, Serialize};
+
+#[remain::sorted]
+#[impl_message(Message, DocumentMessage, Overlays)]
+#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
+pub enum OverlaysMessage {
+	// Sub-messages
+	#[remain::unsorted]
+	DispatchOperation(Box<DocumentOperation>),
+
+	// Messages
+	ClearAllOverlays,
+	Rerender,
+}
+
+impl From<DocumentOperation> for OverlaysMessage {
+	fn from(operation: DocumentOperation) -> OverlaysMessage {
+		Self::DispatchOperation(Box::new(operation))
+	}
+}

editor/src/messages/portfolio/document/overlays/overlays_message_handler.rs

@@ -0,0 +1,51 @@
+use crate::messages::prelude::*;
+
+use graphene::document::Document as GrapheneDocument;
+use graphene::layers::style::{RenderData, ViewMode};
+use graphene::layers::text_layer::FontCache;
+
+#[derive(Debug, Clone, Default)]
+pub struct OverlaysMessageHandler {
+	pub overlays_graphene_document: GrapheneDocument,
+}
+
+impl MessageHandler<OverlaysMessage, (bool, &FontCache, &InputPreprocessorMessageHandler)> for OverlaysMessageHandler {
+	#[remain::check]
+	fn process_message(&mut self, message: OverlaysMessage, (overlays_visible, font_cache, ipp): (bool, &FontCache, &InputPreprocessorMessageHandler), responses: &mut VecDeque<Message>) {
+		use OverlaysMessage::*;
+
+		#[remain::sorted]
+		match message {
+			// Sub-messages
+			#[remain::unsorted]
+			DispatchOperation(operation) => match self.overlays_graphene_document.handle_operation(*operation, font_cache) {
+				Ok(_) => responses.push_back(OverlaysMessage::Rerender.into()),
+				Err(e) => log::error!("OverlaysError: {:?}", e),
+			},
+
+			// Messages
+			ClearAllOverlays => todo!(),
+			Rerender =>
+			// Render overlays
+			{
+				responses.push_back(
+					FrontendMessage::UpdateDocumentOverlays {
+						svg: if overlays_visible {
+							let render_data = RenderData::new(ViewMode::Normal, font_cache, Some(ipp.document_bounds()), false);
+							self.overlays_graphene_document.render_root(render_data)
+						} else {
+							String::from("")
+						},
+					}
+					.into(),
+				)
+			}
+		}
+	}
+
+	fn actions(&self) -> ActionList {
+		actions!(OverlaysMessageDiscriminant;
+			ClearAllOverlays,
+		)
+	}
+}

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

@@ -0,0 +1,10 @@
+mod properties_panel_message;
+mod properties_panel_message_handler;
+
+pub mod utility_functions;
+pub mod utility_types;
+
+#[doc(inline)]
+pub use properties_panel_message::{PropertiesPanelMessage, PropertiesPanelMessageDiscriminant};
+#[doc(inline)]
+pub use properties_panel_message_handler::PropertiesPanelMessageHandler;

editor/src/messages/portfolio/document/properties_panel/properties_panel_message.rs

@@ -0,0 +1,29 @@
+use super::utility_types::TransformOp;
+use crate::messages::portfolio::document::utility_types::misc::TargetDocument;
+use crate::messages::prelude::*;
+
+use graphene::layers::style::{Fill, Stroke};
+use graphene::LayerId;
+
+use serde::{Deserialize, Serialize};
+
+#[remain::sorted]
+#[impl_message(Message, DocumentMessage, PropertiesPanel)]
+#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
+pub enum PropertiesPanelMessage {
+	// Messages
+	CheckSelectedWasDeleted { path: Vec<LayerId> },
+	CheckSelectedWasUpdated { path: Vec<LayerId> },
+	ClearSelection,
+	Deactivate,
+	Init,
+	ModifyFill { fill: Fill },
+	ModifyFont { font_family: String, font_style: String, size: f64 },
+	ModifyName { name: String },
+	ModifyStroke { stroke: Stroke },
+	ModifyText { new_text: String },
+	ModifyTransform { value: f64, transform_op: TransformOp },
+	ResendActiveProperties,
+	SetActiveLayers { paths: Vec<Vec<LayerId>>, document: TargetDocument },
+	UpdateSelectedDocumentProperties,
+}

editor/src/messages/portfolio/document/properties_panel/properties_panel_message_handler.rs

@@ -0,0 +1,166 @@
+use super::utility_functions::{register_artboard_layer_properties, register_artwork_layer_properties};
+use super::utility_types::PropertiesPanelMessageHandlerData;
+use crate::messages::layout::utility_types::layout_widget::{Layout, WidgetLayout};
+use crate::messages::layout::utility_types::misc::LayoutTarget;
+use crate::messages::portfolio::document::properties_panel::utility_functions::apply_transform_operation;
+use crate::messages::portfolio::document::utility_types::misc::TargetDocument;
+use crate::messages::prelude::*;
+
+use graphene::{LayerId, Operation};
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct PropertiesPanelMessageHandler {
+	active_selection: Option<(Vec<LayerId>, TargetDocument)>,
+}
+
+impl<'a> MessageHandler<PropertiesPanelMessage, PropertiesPanelMessageHandlerData<'a>> for PropertiesPanelMessageHandler {
+	#[remain::check]
+	fn process_message(&mut self, message: PropertiesPanelMessage, data: PropertiesPanelMessageHandlerData, responses: &mut VecDeque<Message>) {
+		let PropertiesPanelMessageHandlerData {
+			artwork_document,
+			artboard_document,
+			selected_layers,
+			font_cache,
+		} = data;
+		let get_document = |document_selector: TargetDocument| match document_selector {
+			TargetDocument::Artboard => artboard_document,
+			TargetDocument::Artwork => artwork_document,
+		};
+		use PropertiesPanelMessage::*;
+		match message {
+			SetActiveLayers { paths, document } => {
+				if paths.len() != 1 {
+					// TODO: Allow for multiple selected layers
+					responses.push_back(PropertiesPanelMessage::ClearSelection.into())
+				} else {
+					let path = paths.into_iter().next().unwrap();
+					self.active_selection = Some((path, document));
+					responses.push_back(PropertiesPanelMessage::ResendActiveProperties.into())
+				}
+			}
+			ClearSelection => {
+				responses.push_back(
+					LayoutMessage::SendLayout {
+						layout: Layout::WidgetLayout(WidgetLayout::new(vec![])),
+						layout_target: LayoutTarget::PropertiesOptions,
+					}
+					.into(),
+				);
+				responses.push_back(
+					LayoutMessage::SendLayout {
+						layout: Layout::WidgetLayout(WidgetLayout::new(vec![])),
+						layout_target: LayoutTarget::PropertiesSections,
+					}
+					.into(),
+				);
+				self.active_selection = None;
+			}
+			Deactivate => responses.push_back(
+				BroadcastMessage::UnsubscribeEvent {
+					on: BroadcastEvent::SelectionChanged,
+					message: Box::new(PropertiesPanelMessage::UpdateSelectedDocumentProperties.into()),
+				}
+				.into(),
+			),
+			Init => responses.push_back(
+				BroadcastMessage::SubscribeEvent {
+					on: BroadcastEvent::SelectionChanged,
+					send: Box::new(PropertiesPanelMessage::UpdateSelectedDocumentProperties.into()),
+				}
+				.into(),
+			),
+			ModifyFont { font_family, font_style, size } => {
+				let (path, _) = self.active_selection.clone().expect("Received update for properties panel with no active layer");
+
+				responses.push_back(self.create_document_operation(Operation::ModifyFont { path, font_family, font_style, size }));
+				responses.push_back(ResendActiveProperties.into());
+			}
+			ModifyTransform { value, transform_op } => {
+				let (path, target_document) = self.active_selection.as_ref().expect("Received update for properties panel with no active layer");
+				let layer = get_document(*target_document).layer(path).unwrap();
+
+				let transform = apply_transform_operation(layer, transform_op, value, font_cache);
+
+				responses.push_back(self.create_document_operation(Operation::SetLayerTransform { path: path.clone(), transform }));
+			}
+			ModifyName { name } => {
+				let (path, _) = self.active_selection.clone().expect("Received update for properties panel with no active layer");
+				responses.push_back(self.create_document_operation(Operation::SetLayerName { path, name }))
+			}
+			ModifyFill { fill } => {
+				let (path, _) = self.active_selection.clone().expect("Received update for properties panel with no active layer");
+				responses.push_back(self.create_document_operation(Operation::SetLayerFill { path, fill }));
+			}
+			ModifyStroke { stroke } => {
+				let (path, _) = self.active_selection.clone().expect("Received update for properties panel with no active layer");
+				responses.push_back(self.create_document_operation(Operation::SetLayerStroke { path, stroke }))
+			}
+			ModifyText { new_text } => {
+				let (path, _) = self.active_selection.clone().expect("Received update for properties panel with no active layer");
+				responses.push_back(Operation::SetTextContent { path, new_text }.into())
+			}
+			CheckSelectedWasUpdated { path } => {
+				if self.matches_selected(&path) {
+					responses.push_back(PropertiesPanelMessage::ResendActiveProperties.into())
+				}
+			}
+			CheckSelectedWasDeleted { path } => {
+				if self.matches_selected(&path) {
+					self.active_selection = None;
+					responses.push_back(
+						LayoutMessage::SendLayout {
+							layout_target: LayoutTarget::PropertiesOptions,
+							layout: Layout::WidgetLayout(WidgetLayout::default()),
+						}
+						.into(),
+					);
+					responses.push_back(
+						LayoutMessage::SendLayout {
+							layout_target: LayoutTarget::PropertiesSections,
+							layout: Layout::WidgetLayout(WidgetLayout::default()),
+						}
+						.into(),
+					);
+				}
+			}
+			ResendActiveProperties => {
+				if let Some((path, target_document)) = self.active_selection.clone() {
+					let layer = get_document(target_document).layer(&path).unwrap();
+					match target_document {
+						TargetDocument::Artboard => register_artboard_layer_properties(layer, responses, font_cache),
+						TargetDocument::Artwork => register_artwork_layer_properties(layer, responses, font_cache),
+					}
+				}
+			}
+			UpdateSelectedDocumentProperties => responses.push_back(
+				PropertiesPanelMessage::SetActiveLayers {
+					paths: selected_layers.map(|path| path.to_vec()).collect(),
+					document: TargetDocument::Artwork,
+				}
+				.into(),
+			),
+		}
+	}
+
+	fn actions(&self) -> ActionList {
+		actions!(PropertiesMessageDiscriminant;)
+	}
+}
+
+impl PropertiesPanelMessageHandler {
+	fn matches_selected(&self, path: &[LayerId]) -> bool {
+		let last_active_path_id = self.active_selection.as_ref().and_then(|(v, _)| v.last().copied());
+		let last_modified = path.last().copied();
+		matches!((last_active_path_id, last_modified), (Some(active_last), Some(modified_last)) if active_last == modified_last)
+	}
+
+	fn create_document_operation(&self, operation: Operation) -> Message {
+		let (_, target_document) = self.active_selection.as_ref().unwrap();
+		match *target_document {
+			TargetDocument::Artboard => ArtboardMessage::DispatchOperation(Box::new(operation)).into(),
+			TargetDocument::Artwork => DocumentMessage::DispatchOperation(Box::new(operation)).into(),
+		}
+	}
+}

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

@@ -0,0 +1,23 @@
+use graphene::document::Document as GrapheneDocument;
+use graphene::layers::text_layer::FontCache;
+use graphene::LayerId;
+
+use serde::{Deserialize, Serialize};
+
+pub struct PropertiesPanelMessageHandlerData<'a> {
+	pub artwork_document: &'a GrapheneDocument,
+	pub artboard_document: &'a GrapheneDocument,
+	pub selected_layers: &'a mut dyn Iterator<Item = &'a [LayerId]>,
+	pub font_cache: &'a FontCache,
+}
+
+#[derive(PartialEq, Eq, Clone, Copy, Debug, Serialize, Deserialize)]
+pub enum TransformOp {
+	X,
+	Y,
+	ScaleX,
+	ScaleY,
+	Width,
+	Height,
+	Rotation,
+}

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

@@ -0,0 +1,7 @@
+mod transform_layer_message;
+mod transform_layer_message_handler;
+
+#[doc(inline)]
+pub use transform_layer_message::{TransformLayerMessage, TransformLayerMessageDiscriminant};
+#[doc(inline)]
+pub use transform_layer_message_handler::TransformLayerMessageHandler;

editor/src/messages/portfolio/document/transform_layer/transform_layer_message.rs

@@ -0,0 +1,23 @@
+use crate::messages::input_mapper::utility_types::input_keyboard::Key;
+use crate::messages::prelude::*;
+
+use serde::{Deserialize, Serialize};
+
+#[remain::sorted]
+#[impl_message(Message, DocumentMessage, TransformLayer)]
+#[derive(PartialEq, Eq, Clone, Debug, Serialize, Deserialize)]
+pub enum TransformLayerMessage {
+	// Messages
+	ApplyTransformOperation,
+	BeginGrab,
+	BeginRotate,
+	BeginScale,
+	CancelTransformOperation,
+	ConstrainX,
+	ConstrainY,
+	PointerMove { slow_key: Key, snap_key: Key },
+	TypeBackspace,
+	TypeDecimalPoint,
+	TypeDigit { digit: u8 },
+	TypeNegate,
+}

editor/src/messages/portfolio/document/transform_layer/transform_layer_message_handler.rs

@@ -0,0 +1,186 @@
+use crate::consts::SLOWING_DIVISOR;
+use crate::messages::input_mapper::utility_types::input_mouse::ViewportPosition;
+use crate::messages::portfolio::document::utility_types::layer_panel::LayerMetadata;
+use crate::messages::portfolio::document::utility_types::transformation::{Axis, OriginalTransforms, Selected, TransformOperation, Typing};
+use crate::messages::prelude::*;
+
+use graphene::document::Document;
+use graphene::LayerId;
+
+use glam::DVec2;
+use graphene::layers::text_layer::FontCache;
+use std::collections::{HashMap, VecDeque};
+
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct TransformLayerMessageHandler {
+	transform_operation: TransformOperation,
+
+	slow: bool,
+	snap: bool,
+	typing: Typing,
+
+	mouse_position: ViewportPosition,
+	start_mouse: ViewportPosition,
+
+	original_transforms: OriginalTransforms,
+	pivot: DVec2,
+}
+
+type TransformData<'a> = (&'a mut HashMap<Vec<LayerId>, LayerMetadata>, &'a mut Document, &'a InputPreprocessorMessageHandler, &'a FontCache);
+impl<'a> MessageHandler<TransformLayerMessage, TransformData<'a>> for TransformLayerMessageHandler {
+	#[remain::check]
+	fn process_message(&mut self, message: TransformLayerMessage, (layer_metadata, document, ipp, font_cache): TransformData, responses: &mut VecDeque<Message>) {
+		use TransformLayerMessage::*;
+
+		let selected_layers = layer_metadata.iter().filter_map(|(layer_path, data)| data.selected.then(|| layer_path)).collect::<Vec<_>>();
+		let mut selected = Selected::new(&mut self.original_transforms, &mut self.pivot, &selected_layers, responses, document);
+
+		let mut begin_operation = |operation: TransformOperation, typing: &mut Typing, mouse_position: &mut DVec2, start_mouse: &mut DVec2| {
+			if operation != TransformOperation::None {
+				selected.revert_operation();
+				typing.clear();
+			} else {
+				*selected.pivot = selected.calculate_pivot(font_cache);
+			}
+
+			*mouse_position = ipp.mouse.position;
+			*start_mouse = ipp.mouse.position;
+		};
+
+		#[remain::sorted]
+		match message {
+			ApplyTransformOperation => {
+				self.original_transforms.clear();
+				self.typing.clear();
+
+				self.transform_operation = TransformOperation::None;
+
+				responses.push_back(BroadcastEvent::DocumentIsDirty.into());
+			}
+			BeginGrab => {
+				if let TransformOperation::Grabbing(_) = self.transform_operation {
+					return;
+				}
+
+				begin_operation(self.transform_operation, &mut self.typing, &mut self.mouse_position, &mut self.start_mouse);
+
+				self.transform_operation = TransformOperation::Grabbing(Default::default());
+
+				responses.push_back(BroadcastEvent::DocumentIsDirty.into());
+			}
+			BeginRotate => {
+				if let TransformOperation::Rotating(_) = self.transform_operation {
+					return;
+				}
+
+				begin_operation(self.transform_operation, &mut self.typing, &mut self.mouse_position, &mut self.start_mouse);
+
+				self.transform_operation = TransformOperation::Rotating(Default::default());
+
+				responses.push_back(BroadcastEvent::DocumentIsDirty.into());
+			}
+			BeginScale => {
+				if let TransformOperation::Scaling(_) = self.transform_operation {
+					return;
+				}
+
+				begin_operation(self.transform_operation, &mut self.typing, &mut self.mouse_position, &mut self.start_mouse);
+
+				self.transform_operation = TransformOperation::Scaling(Default::default());
+				self.transform_operation.apply_transform_operation(&mut selected, self.snap);
+
+				responses.push_back(BroadcastEvent::DocumentIsDirty.into());
+			}
+			CancelTransformOperation => {
+				selected.revert_operation();
+
+				selected.original_transforms.clear();
+				self.typing.clear();
+
+				self.transform_operation = TransformOperation::None;
+
+				responses.push_back(BroadcastEvent::DocumentIsDirty.into());
+			}
+			ConstrainX => self.transform_operation.constrain_axis(Axis::X, &mut selected, self.snap),
+			ConstrainY => self.transform_operation.constrain_axis(Axis::Y, &mut selected, self.snap),
+			PointerMove { slow_key, snap_key } => {
+				self.slow = ipp.keyboard.get(slow_key as usize);
+
+				let new_snap = ipp.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);
+				}
+
+				if self.typing.digits.is_empty() {
+					let delta_pos = ipp.mouse.position - self.mouse_position;
+
+					match self.transform_operation {
+						TransformOperation::None => unreachable!(),
+						TransformOperation::Grabbing(translation) => {
+							let change = if self.slow { delta_pos / SLOWING_DIVISOR } else { delta_pos };
+							self.transform_operation = TransformOperation::Grabbing(translation.increment_amount(change));
+							self.transform_operation.apply_transform_operation(&mut selected, self.snap);
+						}
+						TransformOperation::Rotating(rotation) => {
+							let selected_pivot = selected.calculate_pivot(font_cache);
+							let angle = {
+								let start_offset = self.mouse_position - selected_pivot;
+								let end_offset = ipp.mouse.position - selected_pivot;
+
+								start_offset.angle_between(end_offset)
+							};
+
+							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);
+						}
+						TransformOperation::Scaling(scale) => {
+							let change = {
+								let previous_frame_dist = (self.mouse_position - *selected.pivot).length();
+								let current_frame_dist = (ipp.mouse.position - *selected.pivot).length();
+								let start_transform_dist = (self.start_mouse - *selected.pivot).length();
+
+								(current_frame_dist - previous_frame_dist) / start_transform_dist
+							};
+
+							let change = if self.slow { change / SLOWING_DIVISOR } else { change };
+							self.transform_operation = TransformOperation::Scaling(scale.increment_amount(change));
+							self.transform_operation.apply_transform_operation(&mut selected, self.snap);
+						}
+					};
+				}
+				self.mouse_position = ipp.mouse.position;
+			}
+			TypeBackspace => self.transform_operation.handle_typed(self.typing.type_backspace(), &mut selected, self.snap),
+			TypeDecimalPoint => self.transform_operation.handle_typed(self.typing.type_decimal_point(), &mut selected, self.snap),
+			TypeDigit { digit } => self.transform_operation.handle_typed(self.typing.type_number(digit), &mut selected, self.snap),
+			TypeNegate => self.transform_operation.handle_typed(self.typing.type_negate(), &mut selected, self.snap),
+		}
+	}
+
+	fn actions(&self) -> ActionList {
+		let mut common = actions!(TransformLayerMessageDiscriminant;
+			BeginGrab,
+			BeginScale,
+			BeginRotate,
+		);
+
+		if self.transform_operation != TransformOperation::None {
+			let active = actions!(TransformLayerMessageDiscriminant;
+				PointerMove,
+				CancelTransformOperation,
+				ApplyTransformOperation,
+				TypeDigit,
+				TypeBackspace,
+				TypeDecimalPoint,
+				TypeNegate,
+				ConstrainX,
+				ConstrainY,
+			);
+			common.extend(active);
+		}
+
+		common
+	}
+}

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

@@ -0,0 +1,23 @@
+use super::layer_panel::LayerMetadata;
+
+use graphene::layers::layer_info::Layer;
+
+use serde::{Deserialize, Serialize};
+
+#[repr(u8)]
+#[derive(Serialize, Deserialize, Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Clipboard {
+	Internal,
+
+	_InternalClipboardCount, // Keep this as the last entry in internal clipboards since it is used for counting the number of enum variants
+
+	Device,
+}
+
+pub const INTERNAL_CLIPBOARD_COUNT: u8 = Clipboard::_InternalClipboardCount as u8;
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct CopyBufferEntry {
+	pub layer: Layer,
+	pub layer_metadata: LayerMetadata,
+}

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

@@ -0,0 +1,41 @@
+use graphene::color::Color;
+use graphene::DocumentError;
+
+use thiserror::Error;
+
+/// The error type used by the Graphite editor.
+#[derive(Clone, Debug, Error)]
+pub enum EditorError {
+	#[error("Failed to execute operation:\n{0}")]
+	InvalidOperation(String),
+
+	#[error("Tried to construct an invalid color:\n{0:?}")]
+	Color(String),
+
+	#[error("The requested tool does not exist")]
+	UnknownTool,
+
+	#[error("The operation caused a document error:\n{0:?}")]
+	Document(String),
+
+	#[error("A rollback was initiated but no transaction was in progress")]
+	NoTransactionInProgress,
+
+	#[error("{0}")]
+	Misc(String),
+}
+
+macro_rules! derive_from {
+	($type:ty, $kind:ident) => {
+		impl From<$type> for EditorError {
+			fn from(error: $type) -> Self {
+				EditorError::$kind(format!("{:?}", error))
+			}
+		}
+	};
+}
+
+derive_from!(&str, Misc);
+derive_from!(String, Misc);
+derive_from!(Color, Color);
+derive_from!(DocumentError, Document);

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

@@ -0,0 +1,92 @@
+use graphene::layers::layer_info::{Layer, LayerData, LayerDataTypeDiscriminant};
+use graphene::layers::style::{RenderData, ViewMode};
+use graphene::layers::text_layer::FontCache;
+use graphene::LayerId;
+
+use glam::{DAffine2, DVec2};
+use serde::ser::SerializeStruct;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
+pub struct RawBuffer(Vec<u8>);
+
+impl From<Vec<u64>> for RawBuffer {
+	fn from(iter: Vec<u64>) -> Self {
+		// https://github.com/rust-lang/rust-clippy/issues/4484
+		let v_from_raw: Vec<u8> = unsafe {
+			// prepare for an auto-forget of the initial vec:
+			let v_orig: &mut Vec<_> = &mut *std::mem::ManuallyDrop::new(iter);
+			Vec::from_raw_parts(v_orig.as_mut_ptr() as *mut u8, v_orig.len() * 8, v_orig.capacity() * 8)
+			// v_orig is never used again, so no aliasing issue
+		};
+		Self(v_from_raw)
+	}
+}
+
+impl Serialize for RawBuffer {
+	fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+		let mut buffer = serializer.serialize_struct("Buffer", 2)?;
+		buffer.serialize_field("pointer", &(self.0.as_ptr() as usize))?;
+		buffer.serialize_field("length", &(self.0.len()))?;
+		buffer.end()
+	}
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Copy)]
+pub struct LayerMetadata {
+	pub selected: bool,
+	pub expanded: bool,
+}
+
+impl LayerMetadata {
+	pub fn new(expanded: bool) -> Self {
+		Self { selected: false, expanded }
+	}
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct LayerPanelEntry {
+	pub name: String,
+	pub visible: bool,
+	pub layer_type: LayerDataTypeDiscriminant,
+	pub layer_metadata: LayerMetadata,
+	pub path: Vec<LayerId>,
+	pub thumbnail: String,
+}
+
+impl LayerPanelEntry {
+	pub fn new(layer_metadata: &LayerMetadata, transform: DAffine2, layer: &Layer, path: Vec<LayerId>, font_cache: &FontCache) -> Self {
+		let name = layer.name.clone().unwrap_or_else(|| String::from(""));
+		let arr = layer.data.bounding_box(transform, font_cache).unwrap_or([DVec2::ZERO, DVec2::ZERO]);
+		let arr = arr.iter().map(|x| (*x).into()).collect::<Vec<(f64, f64)>>();
+
+		let mut thumbnail = String::new();
+		let mut svg_defs = String::new();
+		let render_data = RenderData::new(ViewMode::Normal, font_cache, None, false);
+		layer.data.clone().render(&mut thumbnail, &mut svg_defs, &mut vec![transform], render_data);
+		let transform = transform.to_cols_array().iter().map(ToString::to_string).collect::<Vec<_>>().join(",");
+		let thumbnail = if let [(x_min, y_min), (x_max, y_max)] = arr.as_slice() {
+			format!(
+				r#"<svg xmlns="http://www.w3.org/2000/svg" viewBox="{} {} {} {}"><defs>{}</defs><g transform="matrix({})">{}</g></svg>"#,
+				x_min,
+				y_min,
+				x_max - x_min,
+				y_max - y_min,
+				svg_defs,
+				transform,
+				thumbnail,
+			)
+		} else {
+			String::new()
+		};
+
+		LayerPanelEntry {
+			name,
+			visible: layer.visible,
+			layer_type: (&layer.data).into(),
+			layer_metadata: *layer_metadata,
+			path,
+			thumbnail,
+		}
+	}
+}

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

@@ -0,0 +1,95 @@
+pub use super::layer_panel::{LayerMetadata, LayerPanelEntry};
+
+use graphene::document::Document as GrapheneDocument;
+use graphene::LayerId;
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::fmt;
+
+pub type DocumentSave = (GrapheneDocument, HashMap<Vec<LayerId>, LayerMetadata>);
+
+#[derive(PartialEq, Eq, Clone, Debug, Serialize, Deserialize, Hash)]
+pub enum FlipAxis {
+	X,
+	Y,
+}
+
+#[derive(PartialEq, Eq, Clone, Debug, Serialize, Deserialize, Hash)]
+pub enum AlignAxis {
+	X,
+	Y,
+}
+
+#[derive(PartialEq, Eq, Clone, Debug, Serialize, Deserialize, Hash)]
+pub enum AlignAggregate {
+	Min,
+	Max,
+	Center,
+	Average,
+}
+
+#[derive(PartialEq, Eq, Clone, Copy, Debug, Serialize, Deserialize)]
+pub enum TargetDocument {
+	Artboard,
+	Artwork,
+}
+
+#[derive(PartialEq, Eq, Clone, Copy, Debug, Serialize, Deserialize)]
+pub enum DocumentMode {
+	DesignMode,
+	SelectMode,
+	GuideMode,
+}
+
+impl fmt::Display for DocumentMode {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		let text = match self {
+			DocumentMode::DesignMode => "Design Mode".to_string(),
+			DocumentMode::SelectMode => "Select Mode".to_string(),
+			DocumentMode::GuideMode => "Guide Mode".to_string(),
+		};
+		write!(f, "{}", text)
+	}
+}
+
+impl DocumentMode {
+	pub fn icon_name(&self) -> String {
+		match self {
+			DocumentMode::DesignMode => "ViewportDesignMode".to_string(),
+			DocumentMode::SelectMode => "ViewportSelectMode".to_string(),
+			DocumentMode::GuideMode => "ViewportGuideMode".to_string(),
+		}
+	}
+}
+
+#[derive(PartialEq, Eq, Clone, Copy, Default, Debug, Serialize, Deserialize)]
+pub enum Platform {
+	#[default]
+	Unknown,
+	Windows,
+	Mac,
+	Linux,
+}
+
+impl Platform {
+	pub fn as_keyboard_platform_layout(&self) -> KeyboardPlatformLayout {
+		match self {
+			Platform::Mac => KeyboardPlatformLayout::Mac,
+			Platform::Unknown => {
+				log::warn!("The platform has not been set, remember to send `PortfolioMessage::SetPlatform` during editor initialization.");
+				KeyboardPlatformLayout::Standard
+			}
+			_ => KeyboardPlatformLayout::Standard,
+		}
+	}
+}
+
+#[derive(PartialEq, Eq, Clone, Copy, Default, Debug, Serialize, Deserialize)]
+pub enum KeyboardPlatformLayout {
+	/// Standard keyboard mapping used by Windows and Linux
+	#[default]
+	Standard,
+	/// Keyboard mapping used by Macs where Command is sometimes used in favor of Control
+	Mac,
+}

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

@@ -0,0 +1,6 @@
+pub mod clipboards;
+pub mod error;
+pub mod layer_panel;
+pub mod misc;
+pub mod transformation;
+pub mod vectorize_layer_metadata;

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

@@ -0,0 +1,361 @@
+use crate::consts::{ROTATE_SNAP_ANGLE, SCALE_SNAP_INTERVAL};
+use crate::messages::prelude::*;
+
+use graphene::document::Document;
+use graphene::layers::text_layer::FontCache;
+use graphene::LayerId;
+use graphene::Operation as DocumentOperation;
+
+use glam::{DAffine2, DVec2};
+use std::collections::{HashMap, VecDeque};
+
+pub type OriginalTransforms = HashMap<Vec<LayerId>, DAffine2>;
+
+#[derive(Debug, Clone, PartialEq, Eq, Copy)]
+pub enum Axis {
+	Both,
+	X,
+	Y,
+}
+
+impl Default for Axis {
+	fn default() -> Self {
+		Self::Both
+	}
+}
+
+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;
+		}
+		// If current axis is different from the target axis, switch to the target
+		else {
+			*self = target;
+		}
+	}
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Copy)]
+pub struct Translation {
+	pub dragged_distance: DVec2,
+	pub typed_distance: Option<f64>,
+	pub constraint: Axis,
+}
+
+impl Translation {
+	pub fn to_dvec(self) -> DVec2 {
+		if let Some(value) = self.typed_distance {
+			if self.constraint == Axis::Y {
+				return DVec2::new(0., value);
+			} else {
+				return DVec2::new(value, 0.);
+			}
+		}
+
+		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]
+	pub fn increment_amount(self, delta: DVec2) -> Self {
+		Self {
+			dragged_distance: self.dragged_distance + delta,
+			typed_distance: None,
+			constraint: self.constraint,
+		}
+	}
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Copy)]
+pub struct Rotation {
+	pub dragged_angle: f64,
+	pub typed_angle: Option<f64>,
+}
+
+impl Rotation {
+	pub fn to_f64(self, snap: bool) -> f64 {
+		if let Some(value) = self.typed_angle {
+			value.to_radians()
+		} else if snap {
+			let snap_resolution = ROTATE_SNAP_ANGLE.to_radians();
+			(self.dragged_angle / snap_resolution).round() * snap_resolution
+		} else {
+			self.dragged_angle
+		}
+	}
+
+	#[must_use]
+	pub fn increment_amount(self, delta: f64) -> Self {
+		Self {
+			dragged_angle: self.dragged_angle + delta,
+			typed_angle: None,
+		}
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Copy)]
+pub struct Scale {
+	pub dragged_factor: f64,
+	pub typed_factor: Option<f64>,
+	pub constraint: Axis,
+}
+
+impl Default for Scale {
+	fn default() -> Self {
+		Self {
+			dragged_factor: 1.,
+			typed_factor: None,
+			constraint: Axis::default(),
+		}
+	}
+}
+
+impl Scale {
+	pub fn to_dvec(self, snap: bool) -> DVec2 {
+		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 };
+
+		match self.constraint {
+			Axis::Both => DVec2::splat(factor),
+			Axis::X => DVec2::new(factor, 1.),
+			Axis::Y => DVec2::new(1., factor),
+		}
+	}
+
+	#[must_use]
+	pub fn increment_amount(self, delta: f64) -> Self {
+		Self {
+			dragged_factor: self.dragged_factor + delta,
+			typed_factor: None,
+			constraint: self.constraint,
+		}
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Copy)]
+pub enum TransformOperation {
+	None,
+	Grabbing(Translation),
+	Rotating(Rotation),
+	Scaling(Scale),
+}
+
+impl Default for TransformOperation {
+	fn default() -> Self {
+		TransformOperation::None
+	}
+}
+
+impl TransformOperation {
+	pub fn apply_transform_operation(&self, selected: &mut Selected, snapping: bool) {
+		if self != &TransformOperation::None {
+			let transformation = match self {
+				TransformOperation::Grabbing(translation) => DAffine2::from_translation(translation.to_dvec()),
+				TransformOperation::Rotating(rotation) => DAffine2::from_angle(rotation.to_f64(snapping)),
+				TransformOperation::Scaling(scale) => DAffine2::from_scale(scale.to_dvec(snapping)),
+				TransformOperation::None => unreachable!(),
+			};
+
+			selected.update_transforms(transformation);
+		}
+	}
+
+	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),
+		};
+
+		self.apply_transform_operation(selected, snapping);
+	}
+
+	pub fn handle_typed(&mut self, typed: Option<f64>, selected: &mut Selected, snapping: bool) {
+		match self {
+			TransformOperation::None => (),
+			TransformOperation::Grabbing(translation) => translation.typed_distance = typed,
+			TransformOperation::Rotating(rotation) => rotation.typed_angle = typed,
+			TransformOperation::Scaling(scale) => scale.typed_factor = typed,
+		};
+
+		self.apply_transform_operation(selected, snapping);
+	}
+}
+
+pub struct Selected<'a> {
+	pub selected: &'a [&'a Vec<LayerId>],
+	pub responses: &'a mut VecDeque<Message>,
+	pub document: &'a Document,
+	pub original_transforms: &'a mut OriginalTransforms,
+	pub pivot: &'a mut DVec2,
+}
+
+impl<'a> Selected<'a> {
+	pub fn new(original_transforms: &'a mut OriginalTransforms, pivot: &'a mut DVec2, selected: &'a [&'a Vec<LayerId>], responses: &'a mut VecDeque<Message>, document: &'a Document) -> Self {
+		for path in selected {
+			if !original_transforms.contains_key(*path) {
+				if let Ok(layer) = document.layer(path) {
+					original_transforms.insert(path.to_vec(), layer.transform);
+				} else {
+					log::warn!("Didn't find a layer for {:?}", path);
+				}
+			}
+		}
+		Self {
+			selected,
+			responses,
+			document,
+			original_transforms,
+			pivot,
+		}
+	}
+
+	pub fn calculate_pivot(&mut self, font_cache: &FontCache) -> DVec2 {
+		let xy_summation = self
+			.selected
+			.iter()
+			.map(|path| {
+				let multiplied_transform = self.document.multiply_transforms(path).unwrap();
+
+				let bounds = self
+					.document
+					.layer(path)
+					.unwrap()
+					.aabb_for_transform(multiplied_transform, font_cache)
+					.unwrap_or([multiplied_transform.translation; 2]);
+
+				(bounds[0] + bounds[1]) / 2.
+			})
+			.fold(DVec2::ZERO, |summation, next| summation + next);
+
+		xy_summation / self.selected.len() as f64
+	}
+
+	pub fn update_transforms(&mut self, delta: DAffine2) {
+		if !self.selected.is_empty() {
+			let pivot = DAffine2::from_translation(*self.pivot);
+			let transformation = pivot * delta * pivot.inverse();
+
+			// TODO: Cache the result of `shallowest_unique_layers` to avoid this heavy computation every frame of movement, see https://github.com/GraphiteEditor/Graphite/pull/481
+			for layer_path in Document::shallowest_unique_layers(self.selected.iter()) {
+				let parent_folder_path = &layer_path[..layer_path.len() - 1];
+				let original_layer_transforms = *self.original_transforms.get(*layer_path).unwrap();
+
+				let to = self.document.generate_transform_across_scope(parent_folder_path, None).unwrap();
+				let new = to.inverse() * transformation * to * original_layer_transforms;
+
+				self.responses.push_back(
+					DocumentOperation::SetLayerTransform {
+						path: layer_path.to_vec(),
+						transform: new.to_cols_array(),
+					}
+					.into(),
+				);
+			}
+
+			self.responses.push_back(BroadcastEvent::DocumentIsDirty.into());
+		}
+	}
+
+	pub fn revert_operation(&mut self) {
+		for path in self.selected {
+			if let Some(transform) = self.original_transforms.get(*path) {
+				// Push front to stop document switching before sending the transform
+				self.responses.push_front(
+					DocumentOperation::SetLayerTransform {
+						path: path.to_vec(),
+						transform: transform.to_cols_array(),
+					}
+					.into(),
+				);
+			}
+		}
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct Typing {
+	pub digits: Vec<u8>,
+	pub contains_decimal: bool,
+	pub negative: bool,
+}
+
+const DECIMAL_POINT: u8 = 10;
+
+impl Typing {
+	pub fn type_number(&mut self, number: u8) -> Option<f64> {
+		self.digits.push(number);
+
+		self.evaluate()
+	}
+
+	pub fn type_backspace(&mut self) -> Option<f64> {
+		if self.digits.is_empty() {
+			return None;
+		}
+
+		match self.digits.pop() {
+			Some(DECIMAL_POINT) => self.contains_decimal = false,
+			Some(_) => (),
+			None => self.negative = false,
+		}
+
+		self.evaluate()
+	}
+
+	pub fn type_decimal_point(&mut self) -> Option<f64> {
+		if !self.contains_decimal {
+			self.contains_decimal = true;
+			self.digits.push(DECIMAL_POINT);
+		}
+
+		self.evaluate()
+	}
+
+	pub fn type_negate(&mut self) -> Option<f64> {
+		self.negative = !self.negative;
+
+		self.evaluate()
+	}
+
+	pub fn evaluate(&self) -> Option<f64> {
+		if self.digits.is_empty() {
+			return None;
+		}
+
+		let mut result = 0_f64;
+		let mut running_decimal_place = 0_i32;
+
+		for digit in &self.digits {
+			if *digit == DECIMAL_POINT {
+				if running_decimal_place == 0 {
+					running_decimal_place = 1;
+				}
+			} else if running_decimal_place == 0 {
+				result *= 10.;
+				result += *digit as f64;
+			} else {
+				result += *digit as f64 * 0.1_f64.powi(running_decimal_place);
+				running_decimal_place += 1;
+			}
+		}
+
+		if self.negative {
+			result = -result;
+		}
+
+		Some(result)
+	}
+
+	pub fn clear(&mut self) {
+		self.digits.clear();
+		self.contains_decimal = false;
+		self.negative = false;
+	}
+}

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

@@ -0,0 +1,25 @@
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::iter::FromIterator;
+
+/// Necessary because serde can't serialize hashmaps when the keys don't implement display.
+pub fn serialize<'a, T, K, V, S>(target: T, ser: S) -> Result<S::Ok, S::Error>
+where
+	S: Serializer,
+	T: IntoIterator<Item = (&'a K, &'a V)>,
+	K: Serialize + 'a,
+	V: Serialize + 'a,
+{
+	let container: Vec<_> = target.into_iter().collect();
+	serde::Serialize::serialize(&container, ser)
+}
+
+pub fn deserialize<'de, T, K, V, D>(des: D) -> Result<T, D::Error>
+where
+	D: Deserializer<'de>,
+	T: FromIterator<(K, V)>,
+	K: Deserialize<'de>,
+	V: Deserialize<'de>,
+{
+	let container: Vec<_> = serde::Deserialize::deserialize(des)?;
+	Ok(T::from_iter(container.into_iter()))
+}