Rename tools (#537)

* Rename tools

* Rename Text -> TextLayer

editor/src/viewport_tools/tools/crop_tool.rs

@@ -17,7 +17,7 @@ use glam::{DVec2, Vec2Swizzles};
 use serde::{Deserialize, Serialize};
 
 #[derive(Default)]
-pub struct Crop {
+pub struct CropTool {
 	fsm_state: CropToolFsmState,
 	data: CropToolData,
 }
@@ -25,7 +25,7 @@ pub struct Crop {
 #[remain::sorted]
 #[impl_message(Message, ToolMessage, Crop)]
 #[derive(PartialEq, Clone, Debug, Hash, Serialize, Deserialize)]
-pub enum CropMessage {
+pub enum CropToolMessage {
 	// Standard messages
 	#[remain::unsorted]
 	Abort,
@@ -42,7 +42,7 @@ pub enum CropMessage {
 	PointerUp,
 }
 
-impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Crop {
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for CropTool {
 	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
 		if action == ToolMessage::UpdateHints {
 			self.fsm_state.update_hints(responses);
@@ -62,10 +62,10 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Crop {
 		}
 	}
 
-	advertise_actions!(CropMessageDiscriminant; PointerDown, PointerUp, PointerMove, DeleteSelected, Abort);
+	advertise_actions!(CropToolMessageDiscriminant; PointerDown, PointerUp, PointerMove, DeleteSelected, Abort);
 }
 
-impl PropertyHolder for Crop {}
+impl PropertyHolder for CropTool {}
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 enum CropToolFsmState {
@@ -107,7 +107,7 @@ impl Fsm for CropToolFsmState {
 	) -> Self {
 		if let ToolMessage::Crop(event) = event {
 			match (self, event) {
-				(CropToolFsmState::Ready | CropToolFsmState::ResizingBounds | CropToolFsmState::Dragging, CropMessage::DocumentIsDirty) => {
+				(CropToolFsmState::Ready | CropToolFsmState::ResizingBounds | CropToolFsmState::Dragging, CropToolMessage::DocumentIsDirty) => {
 					let mut buffer = Vec::new();
 					match (
 						data.selected_board.map(|path| document.artboard_bounding_box_and_transform(&[path])).unwrap_or(None),
@@ -131,7 +131,7 @@ impl Fsm for CropToolFsmState {
 					buffer.into_iter().rev().for_each(|message| responses.push_front(message));
 					self
 				}
-				(CropToolFsmState::Ready, CropMessage::PointerDown) => {
+				(CropToolFsmState::Ready, CropToolMessage::PointerDown) => {
 					data.drag_start = input.mouse.position;
 					data.drag_current = input.mouse.position;
 
@@ -188,7 +188,7 @@ impl Fsm for CropToolFsmState {
 						}
 					}
 				}
-				(CropToolFsmState::ResizingBounds, CropMessage::PointerMove { constrain_axis_or_aspect, center }) => {
+				(CropToolFsmState::ResizingBounds, CropToolMessage::PointerMove { constrain_axis_or_aspect, center }) => {
 					if let Some(bounds) = &data.bounding_box_overlays {
 						if let Some(movement) = &bounds.selected_edges {
 							let from_center = input.keyboard.get(center as usize);
@@ -214,7 +214,7 @@ impl Fsm for CropToolFsmState {
 					}
 					CropToolFsmState::ResizingBounds
 				}
-				(CropToolFsmState::Dragging, CropMessage::PointerMove { constrain_axis_or_aspect, .. }) => {
+				(CropToolFsmState::Dragging, CropToolMessage::PointerMove { constrain_axis_or_aspect, .. }) => {
 					if let Some(bounds) = &data.bounding_box_overlays {
 						let axis_align = input.keyboard.get(constrain_axis_or_aspect as usize);
 
@@ -243,7 +243,7 @@ impl Fsm for CropToolFsmState {
 					}
 					CropToolFsmState::Dragging
 				}
-				(CropToolFsmState::Drawing, CropMessage::PointerMove { constrain_axis_or_aspect, center }) => {
+				(CropToolFsmState::Drawing, CropToolMessage::PointerMove { constrain_axis_or_aspect, center }) => {
 					let mouse_position = input.mouse.position;
 					let snapped_mouse_position = data.snap_handler.snap_position(responses, input.viewport_bounds.size(), document, mouse_position);
 
@@ -277,7 +277,7 @@ impl Fsm for CropToolFsmState {
 
 					CropToolFsmState::Drawing
 				}
-				(CropToolFsmState::Ready, CropMessage::PointerMove { .. }) => {
+				(CropToolFsmState::Ready, CropToolMessage::PointerMove { .. }) => {
 					let cursor = data.bounding_box_overlays.as_ref().map_or(MouseCursorIcon::Default, |bounds| bounds.get_cursor(input, false));
 
 					if data.cursor != cursor {
@@ -287,7 +287,7 @@ impl Fsm for CropToolFsmState {
 
 					CropToolFsmState::Ready
 				}
-				(CropToolFsmState::ResizingBounds, CropMessage::PointerUp) => {
+				(CropToolFsmState::ResizingBounds, CropToolMessage::PointerUp) => {
 					data.snap_handler.cleanup(responses);
 
 					if let Some(bounds) = &mut data.bounding_box_overlays {
@@ -296,7 +296,7 @@ impl Fsm for CropToolFsmState {
 
 					CropToolFsmState::Ready
 				}
-				(CropToolFsmState::Drawing, CropMessage::PointerUp) => {
+				(CropToolFsmState::Drawing, CropToolMessage::PointerUp) => {
 					data.snap_handler.cleanup(responses);
 
 					if let Some(bounds) = &mut data.bounding_box_overlays {
@@ -307,7 +307,7 @@ impl Fsm for CropToolFsmState {
 
 					CropToolFsmState::Ready
 				}
-				(CropToolFsmState::Dragging, CropMessage::PointerUp) => {
+				(CropToolFsmState::Dragging, CropToolMessage::PointerUp) => {
 					data.snap_handler.cleanup(responses);
 
 					if let Some(bounds) = &mut data.bounding_box_overlays {
@@ -316,14 +316,14 @@ impl Fsm for CropToolFsmState {
 
 					CropToolFsmState::Ready
 				}
-				(_, CropMessage::DeleteSelected) => {
+				(_, CropToolMessage::DeleteSelected) => {
 					if let Some(artboard) = data.selected_board.take() {
 						responses.push_back(ArtboardMessage::DeleteArtboard { artboard }.into());
 						responses.push_back(ToolMessage::DocumentIsDirty.into());
 					}
 					CropToolFsmState::Ready
 				}
-				(_, CropMessage::Abort) => {
+				(_, CropToolMessage::Abort) => {
 					if let Some(bounding_box_overlays) = data.bounding_box_overlays.take() {
 						bounding_box_overlays.delete(responses);
 					}

editor/src/viewport_tools/tools/ellipse_tool.rs

@@ -16,7 +16,7 @@ use glam::DAffine2;
 use serde::{Deserialize, Serialize};
 
 #[derive(Default)]
-pub struct Ellipse {
+pub struct EllipseTool {
 	fsm_state: EllipseToolFsmState,
 	data: EllipseToolData,
 }
@@ -24,7 +24,7 @@ pub struct Ellipse {
 #[remain::sorted]
 #[impl_message(Message, ToolMessage, Ellipse)]
 #[derive(PartialEq, Clone, Debug, Hash, Serialize, Deserialize)]
-pub enum EllipseMessage {
+pub enum EllipseToolMessage {
 	// Standard messages
 	#[remain::unsorted]
 	Abort,
@@ -38,9 +38,9 @@ pub enum EllipseMessage {
 	},
 }
 
-impl PropertyHolder for Ellipse {}
+impl PropertyHolder for EllipseTool {}
 
-impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Ellipse {
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for EllipseTool {
 	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
 		if action == ToolMessage::UpdateHints {
 			self.fsm_state.update_hints(responses);
@@ -65,8 +65,8 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Ellipse {
 		use EllipseToolFsmState::*;
 
 		match self.fsm_state {
-			Ready => actions!(EllipseMessageDiscriminant; DragStart),
-			Drawing => actions!(EllipseMessageDiscriminant; DragStop, Abort, Resize),
+			Ready => actions!(EllipseToolMessageDiscriminant; DragStart),
+			Drawing => actions!(EllipseToolMessageDiscriminant; DragStop, Abort, Resize),
 		}
 	}
 }
@@ -102,8 +102,8 @@ impl Fsm for EllipseToolFsmState {
 		input: &InputPreprocessorMessageHandler,
 		responses: &mut VecDeque<Message>,
 	) -> Self {
-		use EllipseMessage::*;
 		use EllipseToolFsmState::*;
+		use EllipseToolMessage::*;
 
 		let mut shape_data = &mut data.data;
 

editor/src/viewport_tools/tools/eyedropper_tool.rs

@@ -15,7 +15,7 @@ use glam::DVec2;
 use serde::{Deserialize, Serialize};
 
 #[derive(Default)]
-pub struct Eyedropper {
+pub struct EyedropperTool {
 	fsm_state: EyedropperToolFsmState,
 	data: EyedropperToolData,
 }
@@ -23,7 +23,7 @@ pub struct Eyedropper {
 #[remain::sorted]
 #[impl_message(Message, ToolMessage, Eyedropper)]
 #[derive(PartialEq, Clone, Debug, Hash, Serialize, Deserialize)]
-pub enum EyedropperMessage {
+pub enum EyedropperToolMessage {
 	// Standard messages
 	#[remain::unsorted]
 	Abort,
@@ -33,9 +33,9 @@ pub enum EyedropperMessage {
 	RightMouseDown,
 }
 
-impl PropertyHolder for Eyedropper {}
+impl PropertyHolder for EyedropperTool {}
 
-impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Eyedropper {
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for EyedropperTool {
 	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
 		if action == ToolMessage::UpdateHints {
 			self.fsm_state.update_hints(responses);
@@ -56,7 +56,7 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Eyedropper {
 		}
 	}
 
-	advertise_actions!(EyedropperMessageDiscriminant; LeftMouseDown, RightMouseDown);
+	advertise_actions!(EyedropperToolMessageDiscriminant; LeftMouseDown, RightMouseDown);
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -87,8 +87,8 @@ impl Fsm for EyedropperToolFsmState {
 		input: &InputPreprocessorMessageHandler,
 		responses: &mut VecDeque<Message>,
 	) -> Self {
-		use EyedropperMessage::*;
 		use EyedropperToolFsmState::*;
+		use EyedropperToolMessage::*;
 
 		if let ToolMessage::Eyedropper(event) = event {
 			match (self, event) {
@@ -103,8 +103,8 @@ impl Fsm for EyedropperToolFsmState {
 							if let LayerDataType::Shape(shape) = &layer.data {
 								if let Some(fill) = shape.style.fill() {
 									match lmb_or_rmb {
-										EyedropperMessage::LeftMouseDown => responses.push_back(ToolMessage::SelectPrimaryColor { color: fill.color() }.into()),
-										EyedropperMessage::RightMouseDown => responses.push_back(ToolMessage::SelectSecondaryColor { color: fill.color() }.into()),
+										EyedropperToolMessage::LeftMouseDown => responses.push_back(ToolMessage::SelectPrimaryColor { color: fill.color() }.into()),
+										EyedropperToolMessage::RightMouseDown => responses.push_back(ToolMessage::SelectSecondaryColor { color: fill.color() }.into()),
 										_ => {}
 									}
 								}

editor/src/viewport_tools/tools/fill_tool.rs

@@ -15,7 +15,7 @@ use glam::DVec2;
 use serde::{Deserialize, Serialize};
 
 #[derive(Default)]
-pub struct Fill {
+pub struct FillTool {
 	fsm_state: FillToolFsmState,
 	data: FillToolData,
 }
@@ -23,7 +23,7 @@ pub struct Fill {
 #[remain::sorted]
 #[impl_message(Message, ToolMessage, Fill)]
 #[derive(PartialEq, Clone, Debug, Hash, Serialize, Deserialize)]
-pub enum FillMessage {
+pub enum FillToolMessage {
 	// Standard messages
 	#[remain::unsorted]
 	Abort,
@@ -33,9 +33,9 @@ pub enum FillMessage {
 	RightMouseDown,
 }
 
-impl PropertyHolder for Fill {}
+impl PropertyHolder for FillTool {}
 
-impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Fill {
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for FillTool {
 	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
 		if action == ToolMessage::UpdateHints {
 			self.fsm_state.update_hints(responses);
@@ -56,7 +56,7 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Fill {
 		}
 	}
 
-	advertise_actions!(FillMessageDiscriminant; LeftMouseDown, RightMouseDown);
+	advertise_actions!(FillToolMessageDiscriminant; LeftMouseDown, RightMouseDown);
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -87,8 +87,8 @@ impl Fsm for FillToolFsmState {
 		input: &InputPreprocessorMessageHandler,
 		responses: &mut VecDeque<Message>,
 	) -> Self {
-		use FillMessage::*;
 		use FillToolFsmState::*;
+		use FillToolMessage::*;
 
 		if let ToolMessage::Fill(event) = event {
 			match (self, event) {

editor/src/viewport_tools/tools/freehand_tool.rs

@@ -14,7 +14,7 @@ use glam::{DAffine2, DVec2};
 use serde::{Deserialize, Serialize};
 
 #[derive(Default)]
-pub struct Freehand {
+pub struct FreehandTool {
 	fsm_state: FreehandToolFsmState,
 	data: FreehandToolData,
 	options: FreehandOptions,
@@ -33,7 +33,7 @@ impl Default for FreehandOptions {
 #[remain::sorted]
 #[impl_message(Message, ToolMessage, Freehand)]
 #[derive(PartialEq, Clone, Debug, Hash, Serialize, Deserialize)]
-pub enum FreehandMessage {
+pub enum FreehandToolMessage {
 	// Standard messages
 	#[remain::unsorted]
 	Abort,
@@ -42,12 +42,12 @@ pub enum FreehandMessage {
 	DragStart,
 	DragStop,
 	PointerMove,
-	UpdateOptions(FreehandMessageOptionsUpdate),
+	UpdateOptions(FreehandToolMessageOptionsUpdate),
 }
 
 #[remain::sorted]
 #[derive(PartialEq, Clone, Debug, Hash, Serialize, Deserialize)]
-pub enum FreehandMessageOptionsUpdate {
+pub enum FreehandToolMessageOptionsUpdate {
 	LineWeight(u32),
 }
 
@@ -57,7 +57,7 @@ enum FreehandToolFsmState {
 	Drawing,
 }
 
-impl PropertyHolder for Freehand {
+impl PropertyHolder for FreehandTool {
 	fn properties(&self) -> WidgetLayout {
 		WidgetLayout::new(vec![LayoutRow::Row {
 			name: "".into(),
@@ -67,14 +67,14 @@ impl PropertyHolder for Freehand {
 				value: self.options.line_weight as f64,
 				is_integer: true,
 				min: Some(1.),
-				on_update: WidgetCallback::new(|number_input| FreehandMessage::UpdateOptions(FreehandMessageOptionsUpdate::LineWeight(number_input.value as u32)).into()),
+				on_update: WidgetCallback::new(|number_input| FreehandToolMessage::UpdateOptions(FreehandToolMessageOptionsUpdate::LineWeight(number_input.value as u32)).into()),
 				..NumberInput::default()
 			}))],
 		}])
 	}
 }
 
-impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Freehand {
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for FreehandTool {
 	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
 		if action == ToolMessage::UpdateHints {
 			self.fsm_state.update_hints(responses);
@@ -86,9 +86,9 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Freehand {
 			return;
 		}
 
-		if let ToolMessage::Freehand(FreehandMessage::UpdateOptions(action)) = action {
+		if let ToolMessage::Freehand(FreehandToolMessage::UpdateOptions(action)) = action {
 			match action {
-				FreehandMessageOptionsUpdate::LineWeight(line_weight) => self.options.line_weight = line_weight,
+				FreehandToolMessageOptionsUpdate::LineWeight(line_weight) => self.options.line_weight = line_weight,
 			}
 			return;
 		}
@@ -106,8 +106,8 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Freehand {
 		use FreehandToolFsmState::*;
 
 		match self.fsm_state {
-			Ready => actions!(FreehandMessageDiscriminant; DragStart, DragStop, Abort),
-			Drawing => actions!(FreehandMessageDiscriminant; DragStop, PointerMove, Abort),
+			Ready => actions!(FreehandToolMessageDiscriminant; DragStart, DragStop, Abort),
+			Drawing => actions!(FreehandToolMessageDiscriminant; DragStop, PointerMove, Abort),
 		}
 	}
 }
@@ -138,8 +138,8 @@ impl Fsm for FreehandToolFsmState {
 		input: &InputPreprocessorMessageHandler,
 		responses: &mut VecDeque<Message>,
 	) -> Self {
-		use FreehandMessage::*;
 		use FreehandToolFsmState::*;
+		use FreehandToolMessage::*;
 
 		let transform = document.graphene_document.root.transform;
 

editor/src/viewport_tools/tools/line_tool.rs

@@ -17,7 +17,7 @@ use glam::{DAffine2, DVec2};
 use serde::{Deserialize, Serialize};
 
 #[derive(Default)]
-pub struct Line {
+pub struct LineTool {
 	fsm_state: LineToolFsmState,
 	data: LineToolData,
 	options: LineOptions,
@@ -36,7 +36,7 @@ impl Default for LineOptions {
 #[remain::sorted]
 #[impl_message(Message, ToolMessage, Line)]
 #[derive(PartialEq, Clone, Debug, Hash, Serialize, Deserialize)]
-pub enum LineMessage {
+pub enum LineToolMessage {
 	// Standard messages
 	#[remain::unsorted]
 	Abort,
@@ -58,7 +58,7 @@ pub enum LineOptionsUpdate {
 	LineWeight(u32),
 }
 
-impl PropertyHolder for Line {
+impl PropertyHolder for LineTool {
 	fn properties(&self) -> WidgetLayout {
 		WidgetLayout::new(vec![LayoutRow::Row {
 			name: "".into(),
@@ -68,14 +68,14 @@ impl PropertyHolder for Line {
 				value: self.options.line_weight as f64,
 				is_integer: true,
 				min: Some(0.),
-				on_update: WidgetCallback::new(|number_input| LineMessage::UpdateOptions(LineOptionsUpdate::LineWeight(number_input.value as u32)).into()),
+				on_update: WidgetCallback::new(|number_input| LineToolMessage::UpdateOptions(LineOptionsUpdate::LineWeight(number_input.value as u32)).into()),
 				..NumberInput::default()
 			}))],
 		}])
 	}
 }
 
-impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Line {
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for LineTool {
 	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
 		if action == ToolMessage::UpdateHints {
 			self.fsm_state.update_hints(responses);
@@ -87,7 +87,7 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Line {
 			return;
 		}
 
-		if let ToolMessage::Line(LineMessage::UpdateOptions(action)) = action {
+		if let ToolMessage::Line(LineToolMessage::UpdateOptions(action)) = action {
 			match action {
 				LineOptionsUpdate::LineWeight(line_weight) => self.options.line_weight = line_weight,
 			}
@@ -107,8 +107,8 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Line {
 		use LineToolFsmState::*;
 
 		match self.fsm_state {
-			Ready => actions!(LineMessageDiscriminant; DragStart),
-			Drawing => actions!(LineMessageDiscriminant; DragStop, Redraw, Abort),
+			Ready => actions!(LineToolMessageDiscriminant; DragStart),
+			Drawing => actions!(LineToolMessageDiscriminant; DragStop, Redraw, Abort),
 		}
 	}
 }
@@ -149,8 +149,8 @@ impl Fsm for LineToolFsmState {
 		input: &InputPreprocessorMessageHandler,
 		responses: &mut VecDeque<Message>,
 	) -> Self {
-		use LineMessage::*;
 		use LineToolFsmState::*;
+		use LineToolMessage::*;
 
 		if let ToolMessage::Line(event) = event {
 			match (self, event) {

editor/src/viewport_tools/tools/mod.rs

@@ -1,15 +1,15 @@
-pub mod crop;
-pub mod ellipse;
-pub mod eyedropper;
-pub mod fill;
-pub mod freehand;
-pub mod line;
-pub mod navigate;
-pub mod path;
-pub mod pen;
-pub mod rectangle;
-pub mod select;
-pub mod shape;
+pub mod crop_tool;
+pub mod ellipse_tool;
+pub mod eyedropper_tool;
+pub mod fill_tool;
+pub mod freehand_tool;
+pub mod line_tool;
+pub mod navigate_tool;
+pub mod path_tool;
+pub mod pen_tool;
+pub mod rectangle_tool;
+pub mod select_tool;
+pub mod shape_tool;
 pub mod shared;
-pub mod spline;
-pub mod text;
+pub mod spline_tool;
+pub mod text_tool;

editor/src/viewport_tools/tools/navigate_tool.rs

@@ -11,7 +11,7 @@ use glam::DVec2;
 use serde::{Deserialize, Serialize};
 
 #[derive(Default)]
-pub struct Navigate {
+pub struct NavigateTool {
 	fsm_state: NavigateToolFsmState,
 	data: NavigateToolData,
 }
@@ -19,7 +19,7 @@ pub struct Navigate {
 #[remain::sorted]
 #[impl_message(Message, ToolMessage, Navigate)]
 #[derive(PartialEq, Clone, Debug, Hash, Serialize, Deserialize)]
-pub enum NavigateMessage {
+pub enum NavigateToolMessage {
 	// Standard messages
 	#[remain::unsorted]
 	Abort,
@@ -38,9 +38,9 @@ pub enum NavigateMessage {
 	ZoomCanvasBegin,
 }
 
-impl PropertyHolder for Navigate {}
+impl PropertyHolder for NavigateTool {}
 
-impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Navigate {
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for NavigateTool {
 	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
 		if action == ToolMessage::UpdateHints {
 			self.fsm_state.update_hints(responses);
@@ -65,8 +65,8 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Navigate {
 		use NavigateToolFsmState::*;
 
 		match self.fsm_state {
-			Ready => actions!(NavigateMessageDiscriminant; TranslateCanvasBegin, RotateCanvasBegin, ZoomCanvasBegin),
-			_ => actions!(NavigateMessageDiscriminant; ClickZoom, PointerMove, TransformCanvasEnd),
+			Ready => actions!(NavigateToolMessageDiscriminant; TranslateCanvasBegin, RotateCanvasBegin, ZoomCanvasBegin),
+			_ => actions!(NavigateToolMessageDiscriminant; ClickZoom, PointerMove, TransformCanvasEnd),
 		}
 	}
 }
@@ -105,7 +105,7 @@ impl Fsm for NavigateToolFsmState {
 		messages: &mut VecDeque<Message>,
 	) -> Self {
 		if let ToolMessage::Navigate(navigate) = message {
-			use NavigateMessage::*;
+			use NavigateToolMessage::*;
 
 			match navigate {
 				ClickZoom { zoom_in } => {

editor/src/viewport_tools/tools/path_tool.rs

@@ -16,7 +16,7 @@ use glam::DVec2;
 use serde::{Deserialize, Serialize};
 
 #[derive(Default)]
-pub struct Path {
+pub struct PathTool {
 	fsm_state: PathToolFsmState,
 	data: PathToolData,
 }
@@ -24,7 +24,7 @@ pub struct Path {
 #[remain::sorted]
 #[impl_message(Message, ToolMessage, Path)]
 #[derive(PartialEq, Clone, Debug, Hash, Serialize, Deserialize)]
-pub enum PathMessage {
+pub enum PathToolMessage {
 	// Standard messages
 	#[remain::unsorted]
 	Abort,
@@ -44,9 +44,9 @@ pub enum PathMessage {
 	},
 }
 
-impl PropertyHolder for Path {}
+impl PropertyHolder for PathTool {}
 
-impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Path {
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for PathTool {
 	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
 		if action == ToolMessage::UpdateHints {
 			self.fsm_state.update_hints(responses);
@@ -72,8 +72,8 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Path {
 		use PathToolFsmState::*;
 
 		match self.fsm_state {
-			Ready => actions!(PathMessageDiscriminant; DragStart),
-			Dragging => actions!(PathMessageDiscriminant; DragStop, PointerMove),
+			Ready => actions!(PathToolMessageDiscriminant; DragStart),
+			Dragging => actions!(PathToolMessageDiscriminant; DragStop, PointerMove),
 		}
 	}
 }
@@ -115,8 +115,8 @@ impl Fsm for PathToolFsmState {
 		responses: &mut VecDeque<Message>,
 	) -> Self {
 		if let ToolMessage::Path(event) = event {
-			use PathMessage::*;
 			use PathToolFsmState::*;
+			use PathToolMessage::*;
 
 			match (self, event) {
 				// TODO: Capture a tool event instead of doing this?

editor/src/viewport_tools/tools/pen_tool.rs

@@ -18,7 +18,7 @@ use kurbo::{PathEl, Point};
 use serde::{Deserialize, Serialize};
 
 #[derive(Default)]
-pub struct Pen {
+pub struct PenTool {
 	fsm_state: PenToolFsmState,
 	data: PenToolData,
 	options: PenOptions,
@@ -37,7 +37,7 @@ impl Default for PenOptions {
 #[remain::sorted]
 #[impl_message(Message, ToolMessage, Pen)]
 #[derive(PartialEq, Clone, Debug, Hash, Serialize, Deserialize)]
-pub enum PenMessage {
+pub enum PenToolMessage {
 	// Standard messages
 	#[remain::unsorted]
 	DocumentIsDirty,
@@ -65,7 +65,7 @@ pub enum PenOptionsUpdate {
 	LineWeight(u32),
 }
 
-impl PropertyHolder for Pen {
+impl PropertyHolder for PenTool {
 	fn properties(&self) -> WidgetLayout {
 		WidgetLayout::new(vec![LayoutRow::Row {
 			name: "".into(),
@@ -75,14 +75,14 @@ impl PropertyHolder for Pen {
 				value: self.options.line_weight as f64,
 				is_integer: true,
 				min: Some(0.),
-				on_update: WidgetCallback::new(|number_input| PenMessage::UpdateOptions(PenOptionsUpdate::LineWeight(number_input.value as u32)).into()),
+				on_update: WidgetCallback::new(|number_input| PenToolMessage::UpdateOptions(PenOptionsUpdate::LineWeight(number_input.value as u32)).into()),
 				..NumberInput::default()
 			}))],
 		}])
 	}
 }
 
-impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Pen {
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for PenTool {
 	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
 		if action == ToolMessage::UpdateHints {
 			self.fsm_state.update_hints(responses);
@@ -94,7 +94,7 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Pen {
 			return;
 		}
 
-		if let ToolMessage::Pen(PenMessage::UpdateOptions(action)) = action {
+		if let ToolMessage::Pen(PenToolMessage::UpdateOptions(action)) = action {
 			match action {
 				PenOptionsUpdate::LineWeight(line_weight) => self.options.line_weight = line_weight,
 			}
@@ -114,8 +114,8 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Pen {
 		use PenToolFsmState::*;
 
 		match self.fsm_state {
-			Ready => actions!(PenMessageDiscriminant; Undo, DragStart, DragStop, Confirm, Abort),
-			Drawing => actions!(PenMessageDiscriminant; DragStart, DragStop, PointerMove, Confirm, Abort),
+			Ready => actions!(PenToolMessageDiscriminant; Undo, DragStart, DragStop, Confirm, Abort),
+			Drawing => actions!(PenToolMessageDiscriminant; DragStart, DragStop, PointerMove, Confirm, Abort),
 		}
 	}
 }
@@ -149,8 +149,8 @@ impl Fsm for PenToolFsmState {
 		input: &InputPreprocessorMessageHandler,
 		responses: &mut VecDeque<Message>,
 	) -> Self {
-		use PenMessage::*;
 		use PenToolFsmState::*;
+		use PenToolMessage::*;
 
 		let transform = document.graphene_document.root.transform;
 

editor/src/viewport_tools/tools/rectangle_tool.rs

@@ -16,7 +16,7 @@ use glam::DAffine2;
 use serde::{Deserialize, Serialize};
 
 #[derive(Default)]
-pub struct Rectangle {
+pub struct RectangleTool {
 	fsm_state: RectangleToolFsmState,
 	data: RectangleToolData,
 }
@@ -24,7 +24,7 @@ pub struct Rectangle {
 #[remain::sorted]
 #[impl_message(Message, ToolMessage, Rectangle)]
 #[derive(PartialEq, Clone, Debug, Hash, Serialize, Deserialize)]
-pub enum RectangleMessage {
+pub enum RectangleToolMessage {
 	// Standard messages
 	#[remain::unsorted]
 	Abort,
@@ -38,9 +38,9 @@ pub enum RectangleMessage {
 	},
 }
 
-impl PropertyHolder for Rectangle {}
+impl PropertyHolder for RectangleTool {}
 
-impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Rectangle {
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for RectangleTool {
 	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
 		if action == ToolMessage::UpdateHints {
 			self.fsm_state.update_hints(responses);
@@ -65,8 +65,8 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Rectangle {
 		use RectangleToolFsmState::*;
 
 		match self.fsm_state {
-			Ready => actions!(RectangleMessageDiscriminant; DragStart),
-			Drawing => actions!(RectangleMessageDiscriminant; DragStop, Abort, Resize),
+			Ready => actions!(RectangleToolMessageDiscriminant; DragStart),
+			Drawing => actions!(RectangleToolMessageDiscriminant; DragStop, Abort, Resize),
 		}
 	}
 }
@@ -101,8 +101,8 @@ impl Fsm for RectangleToolFsmState {
 		input: &InputPreprocessorMessageHandler,
 		responses: &mut VecDeque<Message>,
 	) -> Self {
-		use RectangleMessage::*;
 		use RectangleToolFsmState::*;
+		use RectangleToolMessage::*;
 
 		let mut shape_data = &mut data.data;
 

editor/src/viewport_tools/tools/resize.rs

@@ -1,57 +0,0 @@
-use crate::document::DocumentMessageHandler;
-use crate::input::keyboard::Key;
-use crate::input::mouse::ViewportPosition;
-use crate::input::InputPreprocessorMessageHandler;
-use crate::message_prelude::*;
-use crate::viewport_tools::snapping::SnapHandler;
-
-use graphene::Operation;
-
-use glam::{DAffine2, DVec2, Vec2Swizzles};
-
-#[derive(Clone, Debug, Default)]
-pub struct Resize {
-	pub drag_start: ViewportPosition,
-	pub path: Option<Vec<LayerId>>,
-	snap_handler: SnapHandler,
-}
-impl Resize {
-	/// Starts a resize, assigning the snap targets and snapping the starting position.
-	pub fn start(&mut self, responses: &mut VecDeque<Message>, viewport_bounds: DVec2, document: &DocumentMessageHandler, mouse_position: DVec2) {
-		let layers = document.all_layers_sorted();
-		self.snap_handler.start_snap(responses, viewport_bounds, document, layers);
-		self.drag_start = self.snap_handler.snap_position(document, mouse_position);
-	}
-
-	pub fn calculate_transform(&self, document: &DocumentMessageHandler, center: Key, lock_ratio: Key, ipp: &InputPreprocessorMessageHandler) -> Option<Message> {
-		if let Some(path) = &self.path {
-			let mut start = self.drag_start;
-
-			let stop = self.snap_handler.snap_position(document, ipp.mouse.position);
-
-			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.;
-			}
-
-			Some(
-				Operation::SetLayerTransformInViewport {
-					path: path.to_vec(),
-					transform: DAffine2::from_scale_angle_translation(size, 0., start).to_cols_array(),
-				}
-				.into(),
-			)
-		} else {
-			None
-		}
-	}
-
-	pub fn cleanup(&mut self, responses: &mut VecDeque<Message>) {
-		self.snap_handler.cleanup(responses);
-		self.path = None;
-	}
-}

editor/src/viewport_tools/tools/select_tool.rs

@@ -23,7 +23,7 @@ use glam::{DAffine2, DVec2};
 use serde::{Deserialize, Serialize};
 
 #[derive(Default)]
-pub struct Select {
+pub struct SelectTool {
 	fsm_state: SelectToolFsmState,
 	data: SelectToolData,
 }
@@ -31,7 +31,7 @@ pub struct Select {
 #[remain::sorted]
 #[impl_message(Message, ToolMessage, Select)]
 #[derive(PartialEq, Clone, Debug, Hash, Serialize, Deserialize)]
-pub enum SelectMessage {
+pub enum SelectToolMessage {
 	// Standard messages
 	#[remain::unsorted]
 	Abort,
@@ -57,7 +57,7 @@ pub enum SelectMessage {
 	},
 }
 
-impl PropertyHolder for Select {
+impl PropertyHolder for SelectTool {
 	fn properties(&self) -> WidgetLayout {
 		WidgetLayout::new(vec![LayoutRow::Row {
 			name: "".into(),
@@ -160,14 +160,14 @@ impl PropertyHolder for Select {
 					icon: "FlipHorizontal".into(),
 					tooltip: "Flip Horizontal".into(),
 					size: 24,
-					on_update: WidgetCallback::new(|_| SelectMessage::FlipHorizontal.into()),
+					on_update: WidgetCallback::new(|_| SelectToolMessage::FlipHorizontal.into()),
 					..IconButton::default()
 				})),
 				WidgetHolder::new(Widget::IconButton(IconButton {
 					icon: "FlipVertical".into(),
 					tooltip: "Flip Vertical".into(),
 					size: 24,
-					on_update: WidgetCallback::new(|_| SelectMessage::FlipVertical.into()),
+					on_update: WidgetCallback::new(|_| SelectToolMessage::FlipVertical.into()),
 					..IconButton::default()
 				})),
 				WidgetHolder::new(Widget::Separator(Separator {
@@ -230,7 +230,7 @@ impl PropertyHolder for Select {
 	}
 }
 
-impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Select {
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for SelectTool {
 	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
 		if action == ToolMessage::UpdateHints {
 			self.fsm_state.update_hints(responses);
@@ -254,9 +254,9 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Select {
 		use SelectToolFsmState::*;
 
 		match self.fsm_state {
-			Ready => actions!(SelectMessageDiscriminant; DragStart, PointerMove, EditLayer),
-			Dragging => actions!(SelectMessageDiscriminant; DragStop, PointerMove, EditLayer),
-			_ => actions!(SelectMessageDiscriminant; DragStop, PointerMove, Abort, EditLayer),
+			Ready => actions!(SelectToolMessageDiscriminant; DragStart, PointerMove, EditLayer),
+			Dragging => actions!(SelectToolMessageDiscriminant; DragStop, PointerMove, EditLayer),
+			_ => actions!(SelectToolMessageDiscriminant; DragStop, PointerMove, Abort, EditLayer),
 		}
 	}
 }
@@ -317,8 +317,8 @@ impl Fsm for SelectToolFsmState {
 		input: &InputPreprocessorMessageHandler,
 		responses: &mut VecDeque<Message>,
 	) -> Self {
-		use SelectMessage::*;
 		use SelectToolFsmState::*;
+		use SelectToolMessage::*;
 
 		if let ToolMessage::Select(event) = event {
 			match (self, event) {
@@ -446,7 +446,7 @@ impl Fsm for SelectToolFsmState {
 				}
 				(Dragging, PointerMove { axis_align, .. }) => {
 					// TODO: This is a cheat. Break out the relevant functionality from the handler above and call it from there and here.
-					responses.push_front(SelectMessage::DocumentIsDirty.into());
+					responses.push_front(SelectToolMessage::DocumentIsDirty.into());
 
 					let mouse_position = axis_align_drag(input.keyboard.get(axis_align as usize), input.mouse.position, data.drag_start);
 

editor/src/viewport_tools/tools/shape_tool.rs

@@ -16,7 +16,7 @@ use glam::DAffine2;
 use serde::{Deserialize, Serialize};
 
 #[derive(Default)]
-pub struct Shape {
+pub struct ShapeTool {
 	fsm_state: ShapeToolFsmState,
 	data: ShapeToolData,
 	options: ShapeOptions,
@@ -35,7 +35,7 @@ impl Default for ShapeOptions {
 #[remain::sorted]
 #[impl_message(Message, ToolMessage, Shape)]
 #[derive(PartialEq, Clone, Debug, Hash, Serialize, Deserialize)]
-pub enum ShapeMessage {
+pub enum ShapeToolMessage {
 	// Standard messages
 	#[remain::unsorted]
 	Abort,
@@ -56,7 +56,7 @@ pub enum ShapeOptionsUpdate {
 	Vertices(u8),
 }
 
-impl PropertyHolder for Shape {
+impl PropertyHolder for ShapeTool {
 	fn properties(&self) -> WidgetLayout {
 		WidgetLayout::new(vec![LayoutRow::Row {
 			name: "".into(),
@@ -66,14 +66,14 @@ impl PropertyHolder for Shape {
 				is_integer: true,
 				min: Some(3.),
 				max: Some(256.),
-				on_update: WidgetCallback::new(|number_input| ShapeMessage::UpdateOptions(ShapeOptionsUpdate::Vertices(number_input.value as u8)).into()),
+				on_update: WidgetCallback::new(|number_input| ShapeToolMessage::UpdateOptions(ShapeOptionsUpdate::Vertices(number_input.value as u8)).into()),
 				..NumberInput::default()
 			}))],
 		}])
 	}
 }
 
-impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Shape {
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for ShapeTool {
 	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
 		if action == ToolMessage::UpdateHints {
 			self.fsm_state.update_hints(responses);
@@ -85,7 +85,7 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Shape {
 			return;
 		}
 
-		if let ToolMessage::Shape(ShapeMessage::UpdateOptions(action)) = action {
+		if let ToolMessage::Shape(ShapeToolMessage::UpdateOptions(action)) = action {
 			match action {
 				ShapeOptionsUpdate::Vertices(vertices) => self.options.vertices = vertices,
 			}
@@ -105,8 +105,8 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Shape {
 		use ShapeToolFsmState::*;
 
 		match self.fsm_state {
-			Ready => actions!(ShapeMessageDiscriminant; DragStart),
-			Drawing => actions!(ShapeMessageDiscriminant; DragStop, Abort, Resize),
+			Ready => actions!(ShapeToolMessageDiscriminant; DragStart),
+			Drawing => actions!(ShapeToolMessageDiscriminant; DragStop, Abort, Resize),
 		}
 	}
 }
@@ -142,8 +142,8 @@ impl Fsm for ShapeToolFsmState {
 		input: &InputPreprocessorMessageHandler,
 		responses: &mut VecDeque<Message>,
 	) -> Self {
-		use ShapeMessage::*;
 		use ShapeToolFsmState::*;
+		use ShapeToolMessage::*;
 
 		let mut shape_data = &mut data.data;
 

editor/src/viewport_tools/tools/spline_tool.rs

@@ -16,7 +16,7 @@ use glam::{DAffine2, DVec2};
 use serde::{Deserialize, Serialize};
 
 #[derive(Default)]
-pub struct Spline {
+pub struct SplineTool {
 	fsm_state: SplineToolFsmState,
 	data: SplineToolData,
 	options: SplineOptions,
@@ -35,7 +35,7 @@ impl Default for SplineOptions {
 #[remain::sorted]
 #[impl_message(Message, ToolMessage, Spline)]
 #[derive(PartialEq, Clone, Debug, Hash, Serialize, Deserialize)]
-pub enum SplineMessage {
+pub enum SplineToolMessage {
 	// Standard messages
 	#[remain::unsorted]
 	Abort,
@@ -61,7 +61,7 @@ pub enum SplineOptionsUpdate {
 	LineWeight(u32),
 }
 
-impl PropertyHolder for Spline {
+impl PropertyHolder for SplineTool {
 	fn properties(&self) -> WidgetLayout {
 		WidgetLayout::new(vec![LayoutRow::Row {
 			name: "".into(),
@@ -71,14 +71,14 @@ impl PropertyHolder for Spline {
 				value: self.options.line_weight as f64,
 				is_integer: true,
 				min: Some(0.),
-				on_update: WidgetCallback::new(|number_input| SplineMessage::UpdateOptions(SplineOptionsUpdate::LineWeight(number_input.value as u32)).into()),
+				on_update: WidgetCallback::new(|number_input| SplineToolMessage::UpdateOptions(SplineOptionsUpdate::LineWeight(number_input.value as u32)).into()),
 				..NumberInput::default()
 			}))],
 		}])
 	}
 }
 
-impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Spline {
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for SplineTool {
 	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
 		if action == ToolMessage::UpdateHints {
 			self.fsm_state.update_hints(responses);
@@ -90,7 +90,7 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Spline {
 			return;
 		}
 
-		if let ToolMessage::Spline(SplineMessage::UpdateOptions(action)) = action {
+		if let ToolMessage::Spline(SplineToolMessage::UpdateOptions(action)) = action {
 			match action {
 				SplineOptionsUpdate::LineWeight(line_weight) => self.options.line_weight = line_weight,
 			}
@@ -110,8 +110,8 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Spline {
 		use SplineToolFsmState::*;
 
 		match self.fsm_state {
-			Ready => actions!(SplineMessageDiscriminant; Undo, DragStart, DragStop, Confirm, Abort),
-			Drawing => actions!(SplineMessageDiscriminant; DragStop, PointerMove, Confirm, Abort),
+			Ready => actions!(SplineToolMessageDiscriminant; Undo, DragStart, DragStop, Confirm, Abort),
+			Drawing => actions!(SplineToolMessageDiscriminant; DragStop, PointerMove, Confirm, Abort),
 		}
 	}
 }
@@ -144,8 +144,8 @@ impl Fsm for SplineToolFsmState {
 		input: &InputPreprocessorMessageHandler,
 		responses: &mut VecDeque<Message>,
 	) -> Self {
-		use SplineMessage::*;
 		use SplineToolFsmState::*;
+		use SplineToolMessage::*;
 
 		let transform = document.graphene_document.root.transform;
 

editor/src/viewport_tools/tools/text_tool.rs

@@ -16,7 +16,7 @@ use kurbo::Shape;
 use serde::{Deserialize, Serialize};
 
 #[derive(Default)]
-pub struct Text {
+pub struct TextTool {
 	fsm_state: TextToolFsmState,
 	data: TextToolData,
 	options: TextOptions,
@@ -61,7 +61,7 @@ pub enum TextOptionsUpdate {
 	FontSize(u32),
 }
 
-impl PropertyHolder for Text {
+impl PropertyHolder for TextTool {
 	fn properties(&self) -> WidgetLayout {
 		WidgetLayout::new(vec![LayoutRow::Row {
 			name: "".into(),
@@ -78,7 +78,7 @@ impl PropertyHolder for Text {
 	}
 }
 
-impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Text {
+impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for TextTool {
 	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
 		if action == ToolMessage::UpdateHints {
 			self.fsm_state.update_hints(responses);