Restructure project directories (#333)

`/client/web` -> `/frontend`
`/client/cli` -> *delete for now*
`/client/native` -> *delete for now*
`/core/editor` -> `/editor`
`/core/document` -> `/graphene`
`/core/renderer` -> `/charcoal`
`/core/proc-macro` -> `/proc-macros` *(now plural)*

editor/src/tool/mod.rs

@@ -0,0 +1,195 @@
+pub mod tool_message_handler;
+pub mod tool_options;
+pub mod tools;
+
+use crate::document::DocumentMessageHandler;
+use crate::input::InputPreprocessor;
+use crate::message_prelude::*;
+use crate::{
+	communication::{message::Message, MessageHandler},
+	Color,
+};
+use std::collections::VecDeque;
+use std::{
+	collections::HashMap,
+	fmt::{self, Debug},
+};
+pub use tool_message_handler::ToolMessageHandler;
+use tool_options::ToolOptions;
+pub use tool_options::*;
+use tools::*;
+
+pub mod tool_messages {
+	pub use super::tool_message_handler::{ToolMessage, ToolMessageDiscriminant};
+	pub use super::tools::ellipse::{EllipseMessage, EllipseMessageDiscriminant};
+	pub use super::tools::rectangle::{RectangleMessage, RectangleMessageDiscriminant};
+}
+
+pub type ToolActionHandlerData<'a> = (&'a DocumentMessageHandler, &'a DocumentToolData, &'a InputPreprocessor);
+
+pub trait Fsm {
+	type ToolData;
+
+	fn transition(
+		self,
+		message: ToolMessage,
+		document: &DocumentMessageHandler,
+		tool_data: &DocumentToolData,
+		data: &mut Self::ToolData,
+		input: &InputPreprocessor,
+		messages: &mut VecDeque<Message>,
+	) -> Self;
+}
+
+#[derive(Debug, Clone)]
+pub struct DocumentToolData {
+	pub primary_color: Color,
+	pub secondary_color: Color,
+	pub tool_options: HashMap<ToolType, ToolOptions>,
+}
+
+type SubToolMessageHandler = dyn for<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>>;
+pub struct ToolData {
+	pub active_tool_type: ToolType,
+	pub tools: HashMap<ToolType, Box<SubToolMessageHandler>>,
+}
+
+impl fmt::Debug for ToolData {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		f.debug_struct("ToolData").field("active_tool_type", &self.active_tool_type).field("tool_options", &"[…]").finish()
+	}
+}
+
+impl ToolData {
+	pub fn active_tool_mut(&mut self) -> &mut Box<SubToolMessageHandler> {
+		self.tools.get_mut(&self.active_tool_type).expect("The active tool is not initialized")
+	}
+	pub fn active_tool(&self) -> &SubToolMessageHandler {
+		self.tools.get(&self.active_tool_type).map(|x| x.as_ref()).expect("The active tool is not initialized")
+	}
+}
+
+#[derive(Debug)]
+pub struct ToolFsmState {
+	pub document_tool_data: DocumentToolData,
+	pub tool_data: ToolData,
+}
+
+impl Default for ToolFsmState {
+	fn default() -> Self {
+		ToolFsmState {
+			tool_data: ToolData {
+				active_tool_type: ToolType::Select,
+				tools: gen_tools_hash_map! {
+					Rectangle => rectangle::Rectangle,
+					Select => select::Select,
+					Crop => crop::Crop,
+					Navigate => navigate::Navigate,
+					Eyedropper => eyedropper::Eyedropper,
+					Path => path::Path,
+					Pen => pen::Pen,
+					Line => line::Line,
+					Shape => shape::Shape,
+					Ellipse => ellipse::Ellipse,
+					Fill => fill::Fill,
+				},
+			},
+			document_tool_data: DocumentToolData {
+				primary_color: Color::BLACK,
+				secondary_color: Color::WHITE,
+				tool_options: default_tool_options(),
+			},
+		}
+	}
+}
+
+impl ToolFsmState {
+	pub fn new() -> Self {
+		Self::default()
+	}
+
+	pub fn swap_colors(&mut self) {
+		std::mem::swap(&mut self.document_tool_data.primary_color, &mut self.document_tool_data.secondary_color);
+	}
+}
+
+fn default_tool_options() -> HashMap<ToolType, ToolOptions> {
+	let tool_init = |tool: ToolType| (tool, tool.default_options());
+	std::array::IntoIter::new([
+		tool_init(ToolType::Select),
+		tool_init(ToolType::Ellipse),
+		tool_init(ToolType::Shape), // TODO: Add more tool defaults
+	])
+	.collect()
+}
+
+#[repr(usize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ToolType {
+	Select,
+	Crop,
+	Navigate,
+	Eyedropper,
+	Text,
+	Fill,
+	Gradient,
+	Brush,
+	Heal,
+	Clone,
+	Patch,
+	BlurSharpen,
+	Relight,
+	Path,
+	Pen,
+	Freehand,
+	Spline,
+	Line,
+	Rectangle,
+	Ellipse,
+	Shape,
+}
+
+impl fmt::Display for ToolType {
+	fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+		use ToolType::*;
+
+		let name = match_variant_name!(match (self) {
+			Select,
+			Crop,
+			Navigate,
+			Eyedropper,
+			Text,
+			Fill,
+			Gradient,
+			Brush,
+			Heal,
+			Clone,
+			Patch,
+			BlurSharpen,
+			Relight,
+			Path,
+			Pen,
+			Freehand,
+			Spline,
+			Line,
+			Rectangle,
+			Ellipse,
+			Shape
+		});
+
+		formatter.write_str(name)
+	}
+}
+
+impl ToolType {
+	fn default_options(&self) -> ToolOptions {
+		match self {
+			ToolType::Select => ToolOptions::Select { append_mode: SelectAppendMode::New },
+			ToolType::Ellipse => ToolOptions::Ellipse,
+			ToolType::Shape => ToolOptions::Shape {
+				shape_type: ShapeType::Polygon { vertices: 6 },
+			},
+			_ => todo!(),
+		}
+	}
+}

editor/src/tool/tool_message_handler.rs

@@ -0,0 +1,126 @@
+use crate::message_prelude::*;
+use graphene::color::Color;
+
+use crate::input::InputPreprocessor;
+use crate::{
+	document::DocumentMessageHandler,
+	tool::{tool_options::ToolOptions, DocumentToolData, ToolFsmState, ToolType},
+};
+use std::collections::VecDeque;
+
+#[impl_message(Message, Tool)]
+#[derive(PartialEq, Clone, Debug)]
+pub enum ToolMessage {
+	SelectTool(ToolType),
+	SelectPrimaryColor(Color),
+	SelectSecondaryColor(Color),
+	SwapColors,
+	ResetColors,
+	SetToolOptions(ToolType, ToolOptions),
+	#[child]
+	Fill(FillMessage),
+	#[child]
+	Rectangle(RectangleMessage),
+	#[child]
+	Ellipse(EllipseMessage),
+	#[child]
+	Select(SelectMessage),
+	#[child]
+	Line(LineMessage),
+	#[child]
+	Crop(CropMessage),
+	#[child]
+	Eyedropper(EyedropperMessage),
+	#[child]
+	Navigate(NavigateMessage),
+	#[child]
+	Path(PathMessage),
+	#[child]
+	Pen(PenMessage),
+	#[child]
+	Shape(ShapeMessage),
+}
+
+#[derive(Debug, Default)]
+pub struct ToolMessageHandler {
+	tool_state: ToolFsmState,
+}
+impl MessageHandler<ToolMessage, (&DocumentMessageHandler, &InputPreprocessor)> for ToolMessageHandler {
+	fn process_action(&mut self, message: ToolMessage, data: (&DocumentMessageHandler, &InputPreprocessor), responses: &mut VecDeque<Message>) {
+		let (document, input) = data;
+		use ToolMessage::*;
+		match message {
+			SelectPrimaryColor(c) => {
+				self.tool_state.document_tool_data.primary_color = c;
+				update_working_colors(&self.tool_state.document_tool_data, responses);
+			}
+			SelectSecondaryColor(c) => {
+				self.tool_state.document_tool_data.secondary_color = c;
+				update_working_colors(&self.tool_state.document_tool_data, responses);
+			}
+			SelectTool(tool) => {
+				let mut reset = |tool| match tool {
+					ToolType::Ellipse => responses.push_back(EllipseMessage::Abort.into()),
+					ToolType::Rectangle => responses.push_back(RectangleMessage::Abort.into()),
+					ToolType::Shape => responses.push_back(ShapeMessage::Abort.into()),
+					ToolType::Line => responses.push_back(LineMessage::Abort.into()),
+					ToolType::Pen => responses.push_back(PenMessage::Abort.into()),
+					_ => (),
+				};
+				reset(tool);
+				reset(self.tool_state.tool_data.active_tool_type);
+				self.tool_state.tool_data.active_tool_type = tool;
+
+				responses.push_back(FrontendMessage::SetActiveTool { tool_name: tool.to_string() }.into())
+			}
+			SwapColors => {
+				let doc_data = &mut self.tool_state.document_tool_data;
+				std::mem::swap(&mut doc_data.primary_color, &mut doc_data.secondary_color);
+				update_working_colors(doc_data, responses);
+			}
+			ResetColors => {
+				let doc_data = &mut self.tool_state.document_tool_data;
+				doc_data.primary_color = Color::BLACK;
+				doc_data.secondary_color = Color::WHITE;
+				update_working_colors(doc_data, responses);
+			}
+			SetToolOptions(tool_type, tool_options) => {
+				self.tool_state.document_tool_data.tool_options.insert(tool_type, tool_options);
+			}
+			message => {
+				let tool_type = match message {
+					Fill(_) => ToolType::Fill,
+					Rectangle(_) => ToolType::Rectangle,
+					Ellipse(_) => ToolType::Ellipse,
+					Shape(_) => ToolType::Shape,
+					Line(_) => ToolType::Line,
+					Pen(_) => ToolType::Pen,
+					Select(_) => ToolType::Select,
+					Crop(_) => ToolType::Crop,
+					Eyedropper(_) => ToolType::Eyedropper,
+					Navigate(_) => ToolType::Navigate,
+					Path(_) => ToolType::Path,
+					_ => unreachable!(),
+				};
+				if let Some(tool) = self.tool_state.tool_data.tools.get_mut(&tool_type) {
+					tool.process_action(message, (document, &self.tool_state.document_tool_data, input), responses);
+				}
+			}
+		}
+	}
+	fn actions(&self) -> ActionList {
+		let mut list = actions!(ToolMessageDiscriminant; ResetColors, SwapColors, SelectTool, SetToolOptions);
+		list.extend(self.tool_state.tool_data.active_tool().actions());
+		list
+	}
+}
+
+fn update_working_colors(doc_data: &DocumentToolData, responses: &mut VecDeque<Message>) {
+	responses.push_back(
+		FrontendMessage::UpdateWorkingColors {
+			primary: doc_data.primary_color,
+			secondary: doc_data.secondary_color,
+		}
+		.into(),
+	);
+}

editor/src/tool/tool_options.rs

@@ -0,0 +1,23 @@
+use serde::{Deserialize, Serialize};
+
+// TODO: Rename this `ToolOption` to not be plural in a separate commit (together with `enum LayerDataTypes`)
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Serialize, Deserialize, Hash)]
+pub enum ToolOptions {
+	Select { append_mode: SelectAppendMode },
+	Ellipse,
+	Shape { shape_type: ShapeType },
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Serialize, Deserialize, Hash)]
+pub enum SelectAppendMode {
+	New,
+	Add,
+	Subtract,
+	Intersect,
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Serialize, Deserialize, Hash)]
+pub enum ShapeType {
+	Star { vertices: u32 },
+	Polygon { vertices: u32 },
+}

editor/src/tool/tools/crop.rs

@@ -0,0 +1,18 @@
+use crate::message_prelude::*;
+use crate::tool::ToolActionHandlerData;
+
+#[derive(Default)]
+pub struct Crop;
+
+#[impl_message(Message, ToolMessage, Crop)]
+#[derive(PartialEq, Clone, Debug, Hash)]
+pub enum CropMessage {
+	MouseMove,
+}
+
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Crop {
+	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+		todo!("{}::handle_input {:?} {:?} {:?} ", module_path!(), action, data, responses);
+	}
+	advertise_actions!();
+}

editor/src/tool/tools/ellipse.rs

@@ -0,0 +1,119 @@
+use crate::input::keyboard::Key;
+use crate::input::InputPreprocessor;
+use crate::tool::{DocumentToolData, Fsm, ToolActionHandlerData};
+use crate::{document::DocumentMessageHandler, message_prelude::*};
+use glam::DAffine2;
+use graphene::{layers::style, Operation};
+
+use super::resize::*;
+
+#[derive(Default)]
+pub struct Ellipse {
+	fsm_state: EllipseToolFsmState,
+	data: EllipseToolData,
+}
+
+#[impl_message(Message, ToolMessage, Ellipse)]
+#[derive(PartialEq, Clone, Debug, Hash)]
+pub enum EllipseMessage {
+	DragStart,
+	DragStop,
+	Resize { center: Key, lock_ratio: Key },
+	Abort,
+}
+
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Ellipse {
+	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+		self.fsm_state = self.fsm_state.transition(action, data.0, data.1, &mut self.data, data.2, responses);
+	}
+	fn actions(&self) -> ActionList {
+		use EllipseToolFsmState::*;
+		match self.fsm_state {
+			Ready => actions!(EllipseMessageDiscriminant; DragStart),
+			Dragging => actions!(EllipseMessageDiscriminant; DragStop, Abort, Resize),
+		}
+	}
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum EllipseToolFsmState {
+	Ready,
+	Dragging,
+}
+
+impl Default for EllipseToolFsmState {
+	fn default() -> Self {
+		EllipseToolFsmState::Ready
+	}
+}
+#[derive(Clone, Debug, Default)]
+struct EllipseToolData {
+	sides: u8,
+	data: Resize,
+}
+
+impl Fsm for EllipseToolFsmState {
+	type ToolData = EllipseToolData;
+
+	fn transition(
+		self,
+		event: ToolMessage,
+		document: &DocumentMessageHandler,
+		tool_data: &DocumentToolData,
+		data: &mut Self::ToolData,
+		input: &InputPreprocessor,
+		responses: &mut VecDeque<Message>,
+	) -> Self {
+		let mut shape_data = &mut data.data;
+		use EllipseMessage::*;
+		use EllipseToolFsmState::*;
+		if let ToolMessage::Ellipse(event) = event {
+			match (self, event) {
+				(Ready, DragStart) => {
+					shape_data.drag_start = input.mouse.position;
+					responses.push_back(DocumentMessage::StartTransaction.into());
+					shape_data.path = Some(vec![generate_hash(&*responses, input, document.document.hash())]);
+					responses.push_back(DocumentMessage::DeselectAllLayers.into());
+
+					responses.push_back(
+						Operation::AddEllipse {
+							path: shape_data.path.clone().unwrap(),
+							insert_index: -1,
+							transform: DAffine2::ZERO.to_cols_array(),
+							style: style::PathStyle::new(None, Some(style::Fill::new(tool_data.primary_color))),
+						}
+						.into(),
+					);
+
+					Dragging
+				}
+				(state, Resize { center, lock_ratio }) => {
+					if let Some(message) = shape_data.calculate_transform(center, lock_ratio, input) {
+						responses.push_back(message);
+					}
+
+					state
+				}
+				(Dragging, DragStop) => {
+					// TODO: introduce comparison threshold when operating with canvas coordinates (https://github.com/GraphiteEditor/Graphite/issues/100)
+					match shape_data.drag_start == input.mouse.position {
+						true => responses.push_back(DocumentMessage::AbortTransaction.into()),
+						false => responses.push_back(DocumentMessage::CommitTransaction.into()),
+					}
+
+					shape_data.path = None;
+					Ready
+				}
+				(Dragging, Abort) => {
+					responses.push_back(DocumentMessage::AbortTransaction.into());
+					shape_data.path = None;
+
+					Ready
+				}
+				_ => self,
+			}
+		} else {
+			self
+		}
+	}
+}

editor/src/tool/tools/eyedropper.rs

@@ -0,0 +1,39 @@
+use crate::consts::SELECTION_TOLERANCE;
+use crate::message_prelude::*;
+use crate::tool::{ToolActionHandlerData, ToolMessage};
+use glam::DVec2;
+use graphene::layers::LayerDataType;
+use graphene::Quad;
+
+#[derive(Default)]
+pub struct Eyedropper;
+
+#[impl_message(Message, ToolMessage, Eyedropper)]
+#[derive(PartialEq, Clone, Debug, Hash)]
+pub enum EyedropperMessage {
+	LeftMouseDown,
+	RightMouseDown,
+}
+
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Eyedropper {
+	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+		let mouse_pos = data.2.mouse.position;
+		let tolerance = DVec2::splat(SELECTION_TOLERANCE);
+		let quad = Quad::from_box([mouse_pos.as_f64() - tolerance, mouse_pos.as_f64() + tolerance]);
+
+		if let Some(path) = data.0.document.intersects_quad_root(quad).last() {
+			if let Ok(layer) = data.0.document.layer(path) {
+				if let LayerDataType::Shape(s) = &layer.data {
+					s.style.fill().and_then(|fill| {
+						fill.color().map(|color| match action {
+							ToolMessage::Eyedropper(EyedropperMessage::LeftMouseDown) => responses.push_back(ToolMessage::SelectPrimaryColor(color).into()),
+							ToolMessage::Eyedropper(EyedropperMessage::RightMouseDown) => responses.push_back(ToolMessage::SelectSecondaryColor(color).into()),
+							_ => {}
+						})
+					});
+				}
+			}
+		}
+	}
+	advertise_actions!(EyedropperMessageDiscriminant; LeftMouseDown, RightMouseDown);
+}

editor/src/tool/tools/fill.rs

@@ -0,0 +1,33 @@
+use crate::consts::SELECTION_TOLERANCE;
+use crate::message_prelude::*;
+use crate::tool::ToolActionHandlerData;
+use glam::DVec2;
+use graphene::{Operation, Quad};
+
+#[derive(Default)]
+pub struct Fill;
+
+#[impl_message(Message, ToolMessage, Fill)]
+#[derive(PartialEq, Clone, Debug, Hash)]
+pub enum FillMessage {
+	MouseDown,
+}
+
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Fill {
+	fn process_action(&mut self, _action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+		let mouse_pos = data.2.mouse.position;
+		let tolerance = DVec2::splat(SELECTION_TOLERANCE);
+		let quad = Quad::from_box([mouse_pos.as_f64() - tolerance, mouse_pos.as_f64() + tolerance]);
+
+		if let Some(path) = data.0.document.intersects_quad_root(quad).last() {
+			responses.push_back(
+				Operation::FillLayer {
+					path: path.to_vec(),
+					color: data.1.primary_color,
+				}
+				.into(),
+			);
+		}
+	}
+	advertise_actions!(FillMessageDiscriminant; MouseDown);
+}

editor/src/tool/tools/line.rs

@@ -0,0 +1,161 @@
+use std::f64::consts::PI;
+
+use crate::consts::LINE_ROTATE_SNAP_ANGLE;
+use crate::input::keyboard::Key;
+use crate::input::{mouse::ViewportPosition, InputPreprocessor};
+use crate::tool::{DocumentToolData, Fsm, ToolActionHandlerData};
+use crate::{document::DocumentMessageHandler, message_prelude::*};
+use glam::{DAffine2, DVec2};
+use graphene::{layers::style, Operation};
+
+#[derive(Default)]
+pub struct Line {
+	fsm_state: LineToolFsmState,
+	data: LineToolData,
+}
+
+#[impl_message(Message, ToolMessage, Line)]
+#[derive(PartialEq, Clone, Debug, Hash)]
+pub enum LineMessage {
+	DragStart,
+	DragStop,
+	Redraw { center: Key, lock_angle: Key, snap_angle: Key },
+	Abort,
+}
+
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Line {
+	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+		self.fsm_state = self.fsm_state.transition(action, data.0, data.1, &mut self.data, data.2, responses);
+	}
+	fn actions(&self) -> ActionList {
+		use LineToolFsmState::*;
+		match self.fsm_state {
+			Ready => actions!(LineMessageDiscriminant;  DragStart),
+			Dragging => actions!(LineMessageDiscriminant; DragStop, Redraw, Abort),
+		}
+	}
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum LineToolFsmState {
+	Ready,
+	Dragging,
+}
+
+impl Default for LineToolFsmState {
+	fn default() -> Self {
+		LineToolFsmState::Ready
+	}
+}
+#[derive(Clone, Debug, Default)]
+struct LineToolData {
+	drag_start: ViewportPosition,
+	drag_current: ViewportPosition,
+	angle: f64,
+	path: Option<Vec<LayerId>>,
+}
+
+impl Fsm for LineToolFsmState {
+	type ToolData = LineToolData;
+
+	fn transition(
+		self,
+		event: ToolMessage,
+		document: &DocumentMessageHandler,
+		tool_data: &DocumentToolData,
+		data: &mut Self::ToolData,
+		input: &InputPreprocessor,
+		responses: &mut VecDeque<Message>,
+	) -> Self {
+		use LineMessage::*;
+		use LineToolFsmState::*;
+		if let ToolMessage::Line(event) = event {
+			match (self, event) {
+				(Ready, DragStart) => {
+					data.drag_start = input.mouse.position;
+					responses.push_back(DocumentMessage::StartTransaction.into());
+					data.path = Some(vec![generate_hash(&*responses, input, document.document.hash())]);
+					responses.push_back(DocumentMessage::DeselectAllLayers.into());
+
+					responses.push_back(
+						Operation::AddLine {
+							path: data.path.clone().unwrap(),
+							insert_index: -1,
+							transform: DAffine2::ZERO.to_cols_array(),
+							style: style::PathStyle::new(Some(style::Stroke::new(tool_data.primary_color, 5.)), None),
+						}
+						.into(),
+					);
+
+					Dragging
+				}
+				(Dragging, Redraw { center, snap_angle, lock_angle }) => {
+					data.drag_current = input.mouse.position;
+
+					let values: Vec<_> = [lock_angle, snap_angle, center].iter().map(|k| input.keyboard.get(*k as usize)).collect();
+					responses.push_back(generate_transform(data, values[0], values[1], values[2]));
+
+					Dragging
+				}
+				(Dragging, DragStop) => {
+					data.drag_current = input.mouse.position;
+
+					// TODO; introduce comparison threshold when operating with canvas coordinates (https://github.com/GraphiteEditor/Graphite/issues/100)
+					match data.drag_start == input.mouse.position {
+						true => responses.push_back(DocumentMessage::AbortTransaction.into()),
+						false => responses.push_back(DocumentMessage::CommitTransaction.into()),
+					}
+
+					data.path = None;
+
+					Ready
+				}
+				(Dragging, Abort) => {
+					responses.push_back(DocumentMessage::AbortTransaction.into());
+					data.path = None;
+					Ready
+				}
+				_ => self,
+			}
+		} else {
+			self
+		}
+	}
+}
+
+fn generate_transform(data: &mut LineToolData, lock: bool, snap: bool, center: bool) -> Message {
+	let mut start = data.drag_start.as_f64();
+	let stop = data.drag_current.as_f64();
+
+	let dir = stop - start;
+
+	let mut angle = -dir.angle_between(DVec2::X);
+
+	if lock {
+		angle = data.angle
+	};
+
+	if snap {
+		let snap_resolution = LINE_ROTATE_SNAP_ANGLE.to_radians();
+		angle = (angle / snap_resolution).round() * snap_resolution;
+	}
+
+	data.angle = angle;
+
+	let mut scale = dir.length();
+
+	if lock {
+		let angle_vec = DVec2::new(angle.cos(), angle.sin());
+		scale = dir.dot(angle_vec);
+	}
+
+	if center {
+		start -= dir / 2.;
+	}
+
+	Operation::SetLayerTransformInViewport {
+		path: data.path.clone().unwrap(),
+		transform: glam::DAffine2::from_scale_angle_translation(DVec2::splat(scale), angle, start).to_cols_array(),
+	}
+	.into()
+}

editor/src/tool/tools/mod.rs

@@ -0,0 +1,15 @@
+// already implemented
+pub mod ellipse;
+pub mod fill;
+pub mod line;
+pub mod pen;
+pub mod rectangle;
+pub mod resize;
+pub mod shape;
+
+// not implemented yet
+pub mod crop;
+pub mod eyedropper;
+pub mod navigate;
+pub mod path;
+pub mod select;

editor/src/tool/tools/navigate.rs

@@ -0,0 +1,18 @@
+use crate::message_prelude::*;
+use crate::tool::ToolActionHandlerData;
+
+#[derive(Default)]
+pub struct Navigate;
+
+#[impl_message(Message, ToolMessage, Navigate)]
+#[derive(PartialEq, Clone, Debug, Hash)]
+pub enum NavigateMessage {
+	MouseMove,
+}
+
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Navigate {
+	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+		todo!("{}::handle_input {:?} {:?} {:?} ", module_path!(), action, data, responses);
+	}
+	advertise_actions!();
+}

editor/src/tool/tools/path.rs

@@ -0,0 +1,18 @@
+use crate::message_prelude::*;
+use crate::tool::ToolActionHandlerData;
+
+#[derive(Default)]
+pub struct Path;
+
+#[impl_message(Message, ToolMessage, Path)]
+#[derive(PartialEq, Clone, Debug, Hash)]
+pub enum PathMessage {
+	MouseMove,
+}
+
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Path {
+	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+		todo!("{}::handle_input {:?} {:?} {:?} ", module_path!(), action, data, responses);
+	}
+	advertise_actions!();
+}

editor/src/tool/tools/pen.rs

@@ -0,0 +1,147 @@
+use crate::input::InputPreprocessor;
+use crate::tool::{DocumentToolData, Fsm, ToolActionHandlerData};
+use crate::{document::DocumentMessageHandler, message_prelude::*};
+use glam::DAffine2;
+use graphene::{layers::style, Operation};
+
+#[derive(Default)]
+pub struct Pen {
+	fsm_state: PenToolFsmState,
+	data: PenToolData,
+}
+
+#[impl_message(Message, ToolMessage, Pen)]
+#[derive(PartialEq, Clone, Debug, Hash)]
+pub enum PenMessage {
+	Undo,
+	DragStart,
+	DragStop,
+	PointerMove,
+	Confirm,
+	Abort,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum PenToolFsmState {
+	Ready,
+	Dragging,
+}
+
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Pen {
+	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+		self.fsm_state = self.fsm_state.transition(action, data.0, data.1, &mut self.data, data.2, responses);
+	}
+	fn actions(&self) -> ActionList {
+		use PenToolFsmState::*;
+		match self.fsm_state {
+			Ready => actions!(PenMessageDiscriminant; Undo, DragStart, DragStop, Confirm, Abort),
+			Dragging => actions!(PenMessageDiscriminant; DragStop, PointerMove, Confirm, Abort),
+		}
+	}
+}
+
+impl Default for PenToolFsmState {
+	fn default() -> Self {
+		PenToolFsmState::Ready
+	}
+}
+#[derive(Clone, Debug, Default)]
+struct PenToolData {
+	points: Vec<DAffine2>,
+	next_point: DAffine2,
+	path: Option<Vec<LayerId>>,
+}
+
+impl Fsm for PenToolFsmState {
+	type ToolData = PenToolData;
+
+	fn transition(
+		self,
+		event: ToolMessage,
+		document: &DocumentMessageHandler,
+		tool_data: &DocumentToolData,
+		data: &mut Self::ToolData,
+		input: &InputPreprocessor,
+		responses: &mut VecDeque<Message>,
+	) -> Self {
+		let transform = document.document.root.transform;
+		let pos = transform.inverse() * DAffine2::from_translation(input.mouse.position.as_f64());
+
+		use PenMessage::*;
+		use PenToolFsmState::*;
+		if let ToolMessage::Pen(event) = event {
+			match (self, event) {
+				(Ready, DragStart) => {
+					responses.push_back(DocumentMessage::StartTransaction.into());
+					responses.push_back(DocumentMessage::DeselectAllLayers.into());
+					data.path = Some(vec![generate_hash(&*responses, input, document.document.hash())]);
+
+					data.points.push(pos);
+					data.next_point = pos;
+
+					Dragging
+				}
+				(Dragging, DragStop) => {
+					// TODO: introduce comparison threshold when operating with canvas coordinates (https://github.com/GraphiteEditor/Graphite/issues/100)
+					if data.points.last() != Some(&pos) {
+						data.points.push(pos);
+						data.next_point = pos;
+					}
+
+					responses.extend(make_operation(data, tool_data, true));
+
+					Dragging
+				}
+				(Dragging, PointerMove) => {
+					data.next_point = pos;
+
+					responses.extend(make_operation(data, tool_data, true));
+
+					Dragging
+				}
+				(Dragging, Confirm) => {
+					if data.points.len() >= 2 {
+						responses.push_back(DocumentMessage::DeselectAllLayers.into());
+						responses.extend(make_operation(data, tool_data, false));
+						responses.push_back(DocumentMessage::CommitTransaction.into());
+					} else {
+						responses.push_back(DocumentMessage::AbortTransaction.into());
+					}
+
+					data.path = None;
+					data.points.clear();
+
+					Ready
+				}
+				(Dragging, Abort) => {
+					responses.push_back(DocumentMessage::AbortTransaction.into());
+					data.points.clear();
+					data.path = None;
+
+					Ready
+				}
+				_ => self,
+			}
+		} else {
+			self
+		}
+	}
+}
+
+fn make_operation(data: &PenToolData, tool_data: &DocumentToolData, show_preview: bool) -> [Message; 2] {
+	let mut points: Vec<(f64, f64)> = data.points.iter().map(|p| (p.translation.x, p.translation.y)).collect();
+	if show_preview {
+		points.push((data.next_point.translation.x, data.next_point.translation.y))
+	}
+	[
+		Operation::DeleteLayer { path: data.path.clone().unwrap() }.into(),
+		Operation::AddPen {
+			path: data.path.clone().unwrap(),
+			insert_index: -1,
+			transform: DAffine2::IDENTITY.to_cols_array(),
+			points,
+			style: style::PathStyle::new(Some(style::Stroke::new(tool_data.primary_color, 5.)), Some(style::Fill::none())),
+		}
+		.into(),
+	]
+}

editor/src/tool/tools/rectangle.rs

@@ -0,0 +1,119 @@
+use crate::input::keyboard::Key;
+use crate::input::InputPreprocessor;
+use crate::tool::{DocumentToolData, Fsm, ToolActionHandlerData};
+use crate::{document::DocumentMessageHandler, message_prelude::*};
+use glam::DAffine2;
+use graphene::{layers::style, Operation};
+
+use super::resize::*;
+
+#[derive(Default)]
+pub struct Rectangle {
+	fsm_state: RectangleToolFsmState,
+	data: RectangleToolData,
+}
+
+#[impl_message(Message, ToolMessage, Rectangle)]
+#[derive(PartialEq, Clone, Debug, Hash)]
+pub enum RectangleMessage {
+	DragStart,
+	DragStop,
+	Resize { center: Key, lock_ratio: Key },
+	Abort,
+}
+
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Rectangle {
+	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+		self.fsm_state = self.fsm_state.transition(action, data.0, data.1, &mut self.data, data.2, responses);
+	}
+	fn actions(&self) -> ActionList {
+		use RectangleToolFsmState::*;
+		match self.fsm_state {
+			Ready => actions!(RectangleMessageDiscriminant; DragStart),
+			Dragging => actions!(RectangleMessageDiscriminant; DragStop, Abort, Resize),
+		}
+	}
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum RectangleToolFsmState {
+	Ready,
+	Dragging,
+}
+
+impl Default for RectangleToolFsmState {
+	fn default() -> Self {
+		RectangleToolFsmState::Ready
+	}
+}
+#[derive(Clone, Debug, Default)]
+struct RectangleToolData {
+	sides: u8,
+	data: Resize,
+}
+
+impl Fsm for RectangleToolFsmState {
+	type ToolData = RectangleToolData;
+
+	fn transition(
+		self,
+		event: ToolMessage,
+		document: &DocumentMessageHandler,
+		tool_data: &DocumentToolData,
+		data: &mut Self::ToolData,
+		input: &InputPreprocessor,
+		responses: &mut VecDeque<Message>,
+	) -> Self {
+		let mut shape_data = &mut data.data;
+		use RectangleMessage::*;
+		use RectangleToolFsmState::*;
+		if let ToolMessage::Rectangle(event) = event {
+			match (self, event) {
+				(Ready, DragStart) => {
+					shape_data.drag_start = input.mouse.position;
+					responses.push_back(DocumentMessage::StartTransaction.into());
+					shape_data.path = Some(vec![generate_hash(&*responses, input, document.document.hash())]);
+					responses.push_back(DocumentMessage::DeselectAllLayers.into());
+
+					responses.push_back(
+						Operation::AddRect {
+							path: shape_data.path.clone().unwrap(),
+							insert_index: -1,
+							transform: DAffine2::ZERO.to_cols_array(),
+							style: style::PathStyle::new(None, Some(style::Fill::new(tool_data.primary_color))),
+						}
+						.into(),
+					);
+
+					Dragging
+				}
+				(state, Resize { center, lock_ratio }) => {
+					if let Some(message) = shape_data.calculate_transform(center, lock_ratio, input) {
+						responses.push_back(message);
+					}
+
+					state
+				}
+				(Dragging, DragStop) => {
+					// TODO: introduce comparison threshold when operating with canvas coordinates (https://github.com/GraphiteEditor/Graphite/issues/100)
+					match shape_data.drag_start == input.mouse.position {
+						true => responses.push_back(DocumentMessage::AbortTransaction.into()),
+						false => responses.push_back(DocumentMessage::CommitTransaction.into()),
+					}
+
+					shape_data.path = None;
+					Ready
+				}
+				(Dragging, Abort) => {
+					responses.push_back(DocumentMessage::AbortTransaction.into());
+					shape_data.path = None;
+
+					Ready
+				}
+				_ => self,
+			}
+		} else {
+			self
+		}
+	}
+}

editor/src/tool/tools/resize.rs

@@ -0,0 +1,34 @@
+use crate::input::keyboard::Key;
+use crate::input::{mouse::ViewportPosition, InputPreprocessor};
+use crate::message_prelude::*;
+use glam::{DAffine2, Vec2Swizzles};
+use graphene::Operation;
+
+#[derive(Clone, Debug, Default)]
+pub struct Resize {
+	pub drag_start: ViewportPosition,
+	pub path: Option<Vec<LayerId>>,
+}
+impl Resize {
+	pub fn calculate_transform(&self, center: Key, lock_ratio: Key, ipp: &InputPreprocessor) -> Option<Message> {
+		let mut start = self.drag_start.as_f64();
+		let stop = ipp.mouse.position.as_f64();
+
+		let mut size = stop - start;
+		if ipp.keyboard.get(lock_ratio as usize) {
+			size = size.abs().max(size.abs().yx()) * size.signum();
+		}
+		if ipp.keyboard.get(center as usize) {
+			start -= size;
+			size *= 2.;
+		}
+
+		self.path.clone().map(|path| {
+			Operation::SetLayerTransformInViewport {
+				path,
+				transform: DAffine2::from_scale_angle_translation(size, 0., start).to_cols_array(),
+			}
+			.into()
+		})
+	}
+}

editor/src/tool/tools/select.rs

@@ -0,0 +1,196 @@
+use graphene::color::Color;
+use graphene::layers::style;
+use graphene::layers::style::Fill;
+use graphene::layers::style::Stroke;
+use graphene::Operation;
+use graphene::Quad;
+
+use glam::{DAffine2, DVec2};
+use serde::{Deserialize, Serialize};
+
+use crate::input::{mouse::ViewportPosition, InputPreprocessor};
+use crate::tool::{DocumentToolData, Fsm, ToolActionHandlerData};
+use crate::{
+	consts::SELECTION_TOLERANCE,
+	document::{AlignAggregate, AlignAxis, DocumentMessageHandler, FlipAxis},
+	message_prelude::*,
+};
+
+#[derive(Default)]
+pub struct Select {
+	fsm_state: SelectToolFsmState,
+	data: SelectToolData,
+}
+
+#[impl_message(Message, ToolMessage, Select)]
+#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, Hash)]
+pub enum SelectMessage {
+	DragStart,
+	DragStop,
+	MouseMove,
+	Abort,
+
+	Align(AlignAxis, AlignAggregate),
+	FlipHorizontal,
+	FlipVertical,
+}
+
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Select {
+	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+		self.fsm_state = self.fsm_state.transition(action, data.0, data.1, &mut self.data, data.2, responses);
+	}
+	fn actions(&self) -> ActionList {
+		use SelectToolFsmState::*;
+		match self.fsm_state {
+			Ready => actions!(SelectMessageDiscriminant; DragStart),
+			Dragging => actions!(SelectMessageDiscriminant; DragStop, MouseMove),
+			DrawingBox => actions!(SelectMessageDiscriminant; DragStop, MouseMove, Abort),
+		}
+	}
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum SelectToolFsmState {
+	Ready,
+	Dragging,
+	DrawingBox,
+}
+
+impl Default for SelectToolFsmState {
+	fn default() -> Self {
+		SelectToolFsmState::Ready
+	}
+}
+
+#[derive(Clone, Debug, Default)]
+struct SelectToolData {
+	drag_start: ViewportPosition,
+	drag_current: ViewportPosition,
+	layers_dragging: Vec<Vec<LayerId>>, // Paths and offsets
+	box_id: Option<Vec<LayerId>>,
+}
+
+impl SelectToolData {
+	fn selection_quad(&self) -> Quad {
+		let bbox = self.selection_box();
+		Quad::from_box(bbox)
+	}
+
+	fn selection_box(&self) -> [DVec2; 2] {
+		if self.drag_current == self.drag_start {
+			let tolerance = DVec2::splat(SELECTION_TOLERANCE);
+			[self.drag_start.as_f64() - tolerance, self.drag_start.as_f64() + tolerance]
+		} else {
+			[self.drag_start.as_f64(), self.drag_current.as_f64()]
+		}
+	}
+}
+
+impl Fsm for SelectToolFsmState {
+	type ToolData = SelectToolData;
+
+	fn transition(
+		self,
+		event: ToolMessage,
+		document: &DocumentMessageHandler,
+		_tool_data: &DocumentToolData,
+		data: &mut Self::ToolData,
+		input: &InputPreprocessor,
+		responses: &mut VecDeque<Message>,
+	) -> Self {
+		use SelectMessage::*;
+		use SelectToolFsmState::*;
+		if let ToolMessage::Select(event) = event {
+			match (self, event) {
+				(Ready, DragStart) => {
+					data.drag_start = input.mouse.position;
+					data.drag_current = input.mouse.position;
+					let mut selected: Vec<_> = document.selected_layers().cloned().collect();
+					let quad = data.selection_quad();
+					let intersection = document.document.intersects_quad_root(quad);
+					// If no layer is currently selected and the user clicks on a shape, select that.
+					if selected.is_empty() {
+						if let Some(layer) = intersection.last() {
+							selected.push(layer.clone());
+							responses.push_back(DocumentMessage::SelectLayers(selected.clone()).into());
+						}
+					}
+					// If the user clicks on a layer that is in their current selection, go into the dragging mode.
+					// Otherwise enter the box select mode
+					if selected.iter().any(|path| intersection.contains(path)) {
+						data.layers_dragging = selected;
+						Dragging
+					} else {
+						responses.push_back(DocumentMessage::DeselectAllLayers.into());
+						data.box_id = Some(vec![generate_hash(&*responses, input, document.document.hash())]);
+						responses.push_back(
+							Operation::AddBoundingBox {
+								path: data.box_id.clone().unwrap(),
+								transform: DAffine2::ZERO.to_cols_array(),
+								style: style::PathStyle::new(Some(Stroke::new(Color::from_rgb8(0x00, 0xA8, 0xFF), 1.0)), Some(Fill::none())),
+							}
+							.into(),
+						);
+						DrawingBox
+					}
+				}
+				(Dragging, MouseMove) => {
+					for path in data.layers_dragging.iter() {
+						responses.push_back(
+							Operation::TransformLayerInViewport {
+								path: path.clone(),
+								transform: DAffine2::from_translation(input.mouse.position.as_f64() - data.drag_current.as_f64()).to_cols_array(),
+							}
+							.into(),
+						);
+					}
+					data.drag_current = input.mouse.position;
+					Dragging
+				}
+				(DrawingBox, MouseMove) => {
+					data.drag_current = input.mouse.position;
+					let start = data.drag_start.as_f64();
+					let size = data.drag_current.as_f64() - start;
+
+					responses.push_back(
+						Operation::SetLayerTransformInViewport {
+							path: data.box_id.clone().unwrap(),
+							transform: DAffine2::from_scale_angle_translation(size, 0., start).to_cols_array(),
+						}
+						.into(),
+					);
+					DrawingBox
+				}
+				(Dragging, DragStop) => Ready,
+				(DrawingBox, Abort) => {
+					responses.push_back(Operation::DeleteLayer { path: data.box_id.take().unwrap() }.into());
+					Ready
+				}
+				(DrawingBox, DragStop) => {
+					let quad = data.selection_quad();
+					responses.push_back(DocumentMessage::SelectLayers(document.document.intersects_quad_root(quad)).into());
+					responses.push_back(Operation::DeleteLayer { path: data.box_id.take().unwrap() }.into());
+					Ready
+				}
+				(_, Align(axis, aggregate)) => {
+					responses.push_back(DocumentMessage::AlignSelectedLayers(axis, aggregate).into());
+
+					self
+				}
+				(_, FlipHorizontal) => {
+					responses.push_back(DocumentMessage::FlipSelectedLayers(FlipAxis::X).into());
+
+					self
+				}
+				(_, FlipVertical) => {
+					responses.push_back(DocumentMessage::FlipSelectedLayers(FlipAxis::Y).into());
+
+					self
+				}
+				_ => self,
+			}
+		} else {
+			self
+		}
+	}
+}

editor/src/tool/tools/shape.rs

@@ -0,0 +1,126 @@
+use crate::input::keyboard::Key;
+use crate::input::InputPreprocessor;
+use crate::tool::{DocumentToolData, Fsm, ShapeType, ToolActionHandlerData, ToolOptions, ToolType};
+use crate::{document::DocumentMessageHandler, message_prelude::*};
+use glam::DAffine2;
+use graphene::{layers::style, Operation};
+
+use super::resize::*;
+
+#[derive(Default)]
+pub struct Shape {
+	fsm_state: ShapeToolFsmState,
+	data: ShapeToolData,
+}
+
+#[impl_message(Message, ToolMessage, Shape)]
+#[derive(PartialEq, Clone, Debug, Hash)]
+pub enum ShapeMessage {
+	DragStart,
+	DragStop,
+	Resize { center: Key, lock_ratio: Key },
+	Abort,
+}
+
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Shape {
+	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+		self.fsm_state = self.fsm_state.transition(action, data.0, data.1, &mut self.data, data.2, responses);
+	}
+	fn actions(&self) -> ActionList {
+		use ShapeToolFsmState::*;
+		match self.fsm_state {
+			Ready => actions!(ShapeMessageDiscriminant; DragStart),
+			Dragging => actions!(ShapeMessageDiscriminant; DragStop, Abort, Resize),
+		}
+	}
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum ShapeToolFsmState {
+	Ready,
+	Dragging,
+}
+
+impl Default for ShapeToolFsmState {
+	fn default() -> Self {
+		ShapeToolFsmState::Ready
+	}
+}
+#[derive(Clone, Debug, Default)]
+struct ShapeToolData {
+	sides: u8,
+	data: Resize,
+}
+
+impl Fsm for ShapeToolFsmState {
+	type ToolData = ShapeToolData;
+
+	fn transition(
+		self,
+		event: ToolMessage,
+		document: &DocumentMessageHandler,
+		tool_data: &DocumentToolData,
+		data: &mut Self::ToolData,
+		input: &InputPreprocessor,
+		responses: &mut VecDeque<Message>,
+	) -> Self {
+		let mut shape_data = &mut data.data;
+		use ShapeMessage::*;
+		use ShapeToolFsmState::*;
+		if let ToolMessage::Shape(event) = event {
+			match (self, event) {
+				(Ready, DragStart) => {
+					shape_data.drag_start = input.mouse.position;
+					responses.push_back(DocumentMessage::StartTransaction.into());
+					shape_data.path = Some(vec![generate_hash(&*responses, input, document.document.hash())]);
+					responses.push_back(DocumentMessage::DeselectAllLayers.into());
+					data.sides = match tool_data.tool_options.get(&ToolType::Shape) {
+						Some(&ToolOptions::Shape {
+							shape_type: ShapeType::Polygon { vertices },
+						}) => vertices as u8,
+						_ => 6,
+					};
+
+					responses.push_back(
+						Operation::AddShape {
+							path: shape_data.path.clone().unwrap(),
+							insert_index: -1,
+							transform: DAffine2::ZERO.to_cols_array(),
+							sides: data.sides,
+							style: style::PathStyle::new(None, Some(style::Fill::new(tool_data.primary_color))),
+						}
+						.into(),
+					);
+
+					Dragging
+				}
+				(state, Resize { center, lock_ratio }) => {
+					if let Some(message) = shape_data.calculate_transform(center, lock_ratio, input) {
+						responses.push_back(message);
+					}
+
+					state
+				}
+				(Dragging, DragStop) => {
+					// TODO: introduce comparison threshold when operating with canvas coordinates (https://github.com/GraphiteEditor/Graphite/issues/100)
+					match shape_data.drag_start == input.mouse.position {
+						true => responses.push_back(DocumentMessage::AbortTransaction.into()),
+						false => responses.push_back(DocumentMessage::CommitTransaction.into()),
+					}
+
+					shape_data.path = None;
+					Ready
+				}
+				(Dragging, Abort) => {
+					responses.push_back(DocumentMessage::AbortTransaction.into());
+					shape_data.path = None;
+
+					Ready
+				}
+				_ => self,
+			}
+		} else {
+			self
+		}
+	}
+}