Clean up arg order in process_message() so data is last

editor/src/dispatcher.rs

@@ -106,15 +106,15 @@ impl Dispatcher {
 					queue.push_back(FrontendMessage::TriggerFontLoad { font, is_default: true }.into());
 				}
 
-				Broadcast(message) => self.message_handlers.broadcast_message_handler.process_message(message, (), &mut queue),
+				Broadcast(message) => self.message_handlers.broadcast_message_handler.process_message(message, &mut queue, ()),
 				Debug(message) => {
-					self.message_handlers.debug_message_handler.process_message(message, (), &mut queue);
+					self.message_handlers.debug_message_handler.process_message(message, &mut queue, ());
 				}
 				Dialog(message) => {
 					self.message_handlers.dialog_message_handler.process_message(
 						message,
-						(&self.message_handlers.portfolio_message_handler, &self.message_handlers.preferences_message_handler),
 						&mut queue,
+						(&self.message_handlers.portfolio_message_handler, &self.message_handlers.preferences_message_handler),
 					);
 				}
 				Frontend(message) => {
@@ -131,55 +131,53 @@ impl Dispatcher {
 					}
 				}
 				Globals(message) => {
-					self.message_handlers.globals_message_handler.process_message(message, (), &mut queue);
+					self.message_handlers.globals_message_handler.process_message(message, &mut queue, ());
 				}
 				InputMapper(message) => {
 					let actions = self.collect_actions();
 
 					self.message_handlers
 						.input_mapper_message_handler
-						.process_message(message, (&self.message_handlers.input_preprocessor_message_handler, actions), &mut queue);
+						.process_message(message, &mut queue, (&self.message_handlers.input_preprocessor_message_handler, actions));
 				}
 				InputPreprocessor(message) => {
 					let keyboard_platform = GLOBAL_PLATFORM.get().copied().unwrap_or_default().as_keyboard_platform_layout();
 
-					self.message_handlers.input_preprocessor_message_handler.process_message(message, keyboard_platform, &mut queue);
+					self.message_handlers.input_preprocessor_message_handler.process_message(message, &mut queue, keyboard_platform);
 				}
 				Layout(message) => {
 					let action_input_mapping = &|action_to_find: &MessageDiscriminant| self.message_handlers.input_mapper_message_handler.action_input_mapping(action_to_find);
 
-					self.message_handlers.layout_message_handler.process_message(message, action_input_mapping, &mut queue);
+					self.message_handlers.layout_message_handler.process_message(message, &mut queue, action_input_mapping);
 				}
 				Portfolio(message) => {
 					self.message_handlers.portfolio_message_handler.process_message(
 						message,
-						(&self.message_handlers.input_preprocessor_message_handler, &self.message_handlers.preferences_message_handler),
 						&mut queue,
+						(&self.message_handlers.input_preprocessor_message_handler, &self.message_handlers.preferences_message_handler),
 					);
 				}
 				Preferences(message) => {
-					self.message_handlers.preferences_message_handler.process_message(message, (), &mut queue);
+					self.message_handlers.preferences_message_handler.process_message(message, &mut queue, ());
 				}
 				Tool(message) => {
 					if let Some(document) = self.message_handlers.portfolio_message_handler.active_document() {
 						self.message_handlers.tool_message_handler.process_message(
 							message,
+							&mut queue,
 							(
 								document,
 								self.message_handlers.portfolio_message_handler.active_document_id().unwrap(),
 								&self.message_handlers.input_preprocessor_message_handler,
 								&self.message_handlers.portfolio_message_handler.persistent_data,
 							),
-							&mut queue,
 						);
 					} else {
 						warn!("Called ToolMessage without an active document.\nGot {:?}", message);
 					}
 				}
 				Workspace(message) => {
-					self.message_handlers
+					self.message_handlers.workspace_message_handler.process_message(message, &mut queue, ());
-						.workspace_message_handler
-						.process_message(message, &self.message_handlers.input_preprocessor_message_handler, &mut queue);
 				}
 			}
 

editor/src/generate_ts_types.rs

@@ -1,6 +1,7 @@
 /// Running this test will generate a `types.ts` file at the root of the repo,
 /// containing every type annotated with `specta::Type`
 // #[cfg(all(test, feature = "specta-export"))]
+#[ignore]
 #[test]
 fn generate_ts_types() {
 	use crate::messages::prelude::FrontendMessage;

editor/src/messages/broadcast/broadcast_message_handler.rs

@@ -7,7 +7,7 @@ pub struct BroadcastMessageHandler {
 
 impl MessageHandler<BroadcastMessage, ()> for BroadcastMessageHandler {
 	#[remain::check]
-	fn process_message(&mut self, message: BroadcastMessage, _data: (), responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: BroadcastMessage, responses: &mut VecDeque<Message>, _data: ()) {
 		#[remain::sorted]
 		match message {
 			// Sub-messages

editor/src/messages/debug/debug_message_handler.rs

@@ -8,7 +8,7 @@ pub struct DebugMessageHandler {
 
 impl MessageHandler<DebugMessage, ()> for DebugMessageHandler {
 	#[remain::check]
-	fn process_message(&mut self, message: DebugMessage, _data: (), responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: DebugMessage, responses: &mut VecDeque<Message>, _data: ()) {
 		match message {
 			DebugMessage::ToggleTraceLogs => {
 				if log::max_level() == log::LevelFilter::Debug {

editor/src/messages/dialog/dialog_message_handler.rs

@@ -12,15 +12,15 @@ pub struct DialogMessageHandler {
 
 impl MessageHandler<DialogMessage, (&PortfolioMessageHandler, &PreferencesMessageHandler)> for DialogMessageHandler {
 	#[remain::check]
-	fn process_message(&mut self, message: DialogMessage, (portfolio, preferences): (&PortfolioMessageHandler, &PreferencesMessageHandler), responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: DialogMessage, responses: &mut VecDeque<Message>, (portfolio, preferences): (&PortfolioMessageHandler, &PreferencesMessageHandler)) {
 		#[remain::sorted]
 		match message {
 			#[remain::unsorted]
-			DialogMessage::ExportDialog(message) => self.export_dialog.process_message(message, (), responses),
+			DialogMessage::ExportDialog(message) => self.export_dialog.process_message(message, responses, ()),
 			#[remain::unsorted]
-			DialogMessage::NewDocumentDialog(message) => self.new_document_dialog.process_message(message, (), responses),
+			DialogMessage::NewDocumentDialog(message) => self.new_document_dialog.process_message(message, responses, ()),
 			#[remain::unsorted]
-			DialogMessage::PreferencesDialog(message) => self.preferences_dialog.process_message(message, preferences, responses),
+			DialogMessage::PreferencesDialog(message) => self.preferences_dialog.process_message(message, responses, preferences),
 
 			DialogMessage::CloseAllDocumentsWithConfirmation => {
 				let dialog = simple_dialogs::CloseAllDocumentsDialog;

editor/src/messages/dialog/export_dialog/export_dialog_message_handler.rs

@@ -20,7 +20,7 @@ pub struct ExportDialogMessageHandler {
 }
 
 impl MessageHandler<ExportDialogMessage, ()> for ExportDialogMessageHandler {
-	fn process_message(&mut self, message: ExportDialogMessage, _data: (), responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ExportDialogMessage, responses: &mut VecDeque<Message>, _data: ()) {
 		match message {
 			ExportDialogMessage::FileName(name) => self.file_name = name,
 			ExportDialogMessage::FileType(export_type) => self.file_type = export_type,

editor/src/messages/dialog/new_document_dialog/new_document_dialog_message_handler.rs

@@ -16,7 +16,7 @@ pub struct NewDocumentDialogMessageHandler {
 }
 
 impl MessageHandler<NewDocumentDialogMessage, ()> for NewDocumentDialogMessageHandler {
-	fn process_message(&mut self, message: NewDocumentDialogMessage, _data: (), responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: NewDocumentDialogMessage, responses: &mut VecDeque<Message>, _data: ()) {
 		match message {
 			NewDocumentDialogMessage::Name(name) => self.name = name,
 			NewDocumentDialogMessage::Infinite(infinite) => self.infinite = infinite,

editor/src/messages/dialog/preferences_dialog/preferences_dialog_message_handler.rs

@@ -10,7 +10,7 @@ use crate::messages::prelude::*;
 pub struct PreferencesDialogMessageHandler {}
 
 impl MessageHandler<PreferencesDialogMessage, &PreferencesMessageHandler> for PreferencesDialogMessageHandler {
-	fn process_message(&mut self, message: PreferencesDialogMessage, preferences: &PreferencesMessageHandler, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: PreferencesDialogMessage, responses: &mut VecDeque<Message>, preferences: &PreferencesMessageHandler) {
 		match message {
 			PreferencesDialogMessage::Confirm => {}
 		}

editor/src/messages/globals/globals_message_handler.rs

@@ -5,7 +5,7 @@ pub struct GlobalsMessageHandler {}
 
 impl MessageHandler<GlobalsMessage, ()> for GlobalsMessageHandler {
 	#[remain::check]
-	fn process_message(&mut self, message: GlobalsMessage, _data: (), _responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: GlobalsMessage, _responses: &mut VecDeque<Message>, _data: ()) {
 		match message {
 			GlobalsMessage::SetPlatform { platform } => {
 				if GLOBAL_PLATFORM.get() != Some(&platform) {

editor/src/messages/input_mapper/input_mapper_message_handler.rs

@@ -11,7 +11,7 @@ pub struct InputMapperMessageHandler {
 }
 
 impl MessageHandler<InputMapperMessage, (&InputPreprocessorMessageHandler, ActionList)> for InputMapperMessageHandler {
-	fn process_message(&mut self, message: InputMapperMessage, (input, actions): (&InputPreprocessorMessageHandler, ActionList), responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: InputMapperMessage, responses: &mut VecDeque<Message>, (input, actions): (&InputPreprocessorMessageHandler, ActionList)) {
 		if let Some(message) = self.mapping.match_input_message(message, &input.keyboard, actions) {
 			responses.push_back(message);
 		}

editor/src/messages/input_preprocessor/input_preprocessor_message_handler.rs

@@ -17,9 +17,7 @@ pub struct InputPreprocessorMessageHandler {
 
 impl MessageHandler<InputPreprocessorMessage, KeyboardPlatformLayout> for InputPreprocessorMessageHandler {
 	#[remain::check]
-	fn process_message(&mut self, message: InputPreprocessorMessage, data: KeyboardPlatformLayout, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: InputPreprocessorMessage, responses: &mut VecDeque<Message>, keyboard_platform: KeyboardPlatformLayout) {
-		let keyboard_platform = data;
-
 		#[remain::sorted]
 		match message {
 			InputPreprocessorMessage::BoundsOfViewports { bounds_of_viewports } => {
@@ -197,7 +195,7 @@ mod test {
 
 		let mut responses = VecDeque::new();
 
-		input_preprocessor.process_message(message, KeyboardPlatformLayout::Standard, &mut responses);
+		input_preprocessor.process_message(message, &mut responses, KeyboardPlatformLayout::Standard);
 
 		assert!(input_preprocessor.keyboard.get(Key::Alt as usize));
 		assert_eq!(responses.pop_front(), Some(InputMapperMessage::KeyDown(Key::Alt).into()));
@@ -213,7 +211,7 @@ mod test {
 
 		let mut responses = VecDeque::new();
 
-		input_preprocessor.process_message(message, KeyboardPlatformLayout::Standard, &mut responses);
+		input_preprocessor.process_message(message, &mut responses, KeyboardPlatformLayout::Standard);
 
 		assert!(input_preprocessor.keyboard.get(Key::Control as usize));
 		assert_eq!(responses.pop_front(), Some(InputMapperMessage::KeyDown(Key::Control).into()));
@@ -229,7 +227,7 @@ mod test {
 
 		let mut responses = VecDeque::new();
 
-		input_preprocessor.process_message(message, KeyboardPlatformLayout::Standard, &mut responses);
+		input_preprocessor.process_message(message, &mut responses, KeyboardPlatformLayout::Standard);
 
 		assert!(input_preprocessor.keyboard.get(Key::Shift as usize));
 		assert_eq!(responses.pop_front(), Some(InputMapperMessage::KeyDown(Key::Shift).into()));
@@ -246,7 +244,7 @@ mod test {
 
 		let mut responses = VecDeque::new();
 
-		input_preprocessor.process_message(message, KeyboardPlatformLayout::Standard, &mut responses);
+		input_preprocessor.process_message(message, &mut responses, KeyboardPlatformLayout::Standard);
 
 		assert!(!input_preprocessor.keyboard.get(Key::Control as usize));
 		assert_eq!(responses.pop_front(), Some(InputMapperMessage::KeyUp(Key::Control).into()));
@@ -262,7 +260,7 @@ mod test {
 
 		let mut responses = VecDeque::new();
 
-		input_preprocessor.process_message(message, KeyboardPlatformLayout::Standard, &mut responses);
+		input_preprocessor.process_message(message, &mut responses, KeyboardPlatformLayout::Standard);
 
 		assert!(input_preprocessor.keyboard.get(Key::Control as usize));
 		assert!(input_preprocessor.keyboard.get(Key::Shift as usize));

editor/src/messages/layout/layout_message_handler.rs

@@ -45,9 +45,7 @@ impl LayoutMessageHandler {
 
 impl<F: Fn(&MessageDiscriminant) -> Vec<KeysGroup>> MessageHandler<LayoutMessage, F> for LayoutMessageHandler {
 	#[remain::check]
-	fn process_message(&mut self, message: LayoutMessage, data: F, responses: &mut std::collections::VecDeque<Message>) {
+	fn process_message(&mut self, message: LayoutMessage, responses: &mut std::collections::VecDeque<Message>, action_input_mapping: F) {
-		let action_input_mapping = data;
-
 		use LayoutMessage::*;
 		#[remain::sorted]
 		match message {

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

@@ -20,7 +20,7 @@ pub struct ArtboardMessageHandler {
 
 impl MessageHandler<ArtboardMessage, &FontCache> for ArtboardMessageHandler {
 	#[remain::check]
-	fn process_message(&mut self, message: ArtboardMessage, font_cache: &FontCache, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ArtboardMessage, responses: &mut VecDeque<Message>, font_cache: &FontCache) {
 		use ArtboardMessage::*;
 
 		#[remain::sorted]

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

@@ -109,8 +109,8 @@ impl MessageHandler<DocumentMessage, (u64, &InputPreprocessorMessageHandler, &Pe
 	fn process_message(
 		&mut self,
 		message: DocumentMessage,
-		(document_id, ipp, persistent_data, preferences): (u64, &InputPreprocessorMessageHandler, &PersistentData, &PreferencesMessageHandler),
 		responses: &mut VecDeque<Message>,
+		(document_id, ipp, persistent_data, preferences): (u64, &InputPreprocessorMessageHandler, &PersistentData, &PreferencesMessageHandler),
 	) {
 		use DocumentMessage::*;
 
@@ -177,21 +177,21 @@ impl MessageHandler<DocumentMessage, (u64, &InputPreprocessorMessageHandler, &Pe
 			},
 			#[remain::unsorted]
 			Artboard(message) => {
-				self.artboard_message_handler.process_message(message, &persistent_data.font_cache, responses);
+				self.artboard_message_handler.process_message(message, responses, &persistent_data.font_cache);
 			}
 			#[remain::unsorted]
 			Navigation(message) => {
-				self.navigation_handler.process_message(message, (&self.document_legacy, ipp), responses);
+				self.navigation_handler.process_message(message, responses, (&self.document_legacy, ipp));
 			}
 			#[remain::unsorted]
 			Overlays(message) => {
 				self.overlays_message_handler
-					.process_message(message, (self.overlays_visible, &persistent_data.font_cache, ipp), responses);
+					.process_message(message, responses, (self.overlays_visible, &persistent_data.font_cache, ipp));
 			}
 			#[remain::unsorted]
 			TransformLayer(message) => {
 				self.transform_layer_handler
-					.process_message(message, (&mut self.layer_metadata, &mut self.document_legacy, ipp, &persistent_data.font_cache), responses);
+					.process_message(message, responses, (&mut self.layer_metadata, &mut self.document_legacy, ipp, &persistent_data.font_cache));
 			}
 			#[remain::unsorted]
 			PropertiesPanel(message) => {
@@ -202,12 +202,12 @@ impl MessageHandler<DocumentMessage, (u64, &InputPreprocessorMessageHandler, &Pe
 					node_graph_message_handler: &self.node_graph_handler,
 				};
 				self.properties_panel_message_handler
-					.process_message(message, (persistent_data, properties_panel_message_handler_data), responses);
+					.process_message(message, responses, (persistent_data, properties_panel_message_handler_data));
 			}
 			#[remain::unsorted]
 			NodeGraph(message) => {
 				let selected_layers = &mut self.layer_metadata.iter().filter_map(|(path, data)| data.selected.then_some(path.as_slice()));
-				self.node_graph_handler.process_message(message, (&mut self.document_legacy, selected_layers), responses);
+				self.node_graph_handler.process_message(message, responses, (&mut self.document_legacy, selected_layers));
 			}
 
 			// Messages
@@ -1074,7 +1074,7 @@ impl DocumentMessageHandler {
 			.to_cols_array()
 			.iter()
 			.enumerate()
-			.fold(String::new(), |accum, (i, entry)| accum + &(entry.to_string() + if i == 5 { "" } else { "," }));
+			.fold(String::new(), |acc, (i, entry)| acc + &(entry.to_string() + if i == 5 { "" } else { "," }));
 		let svg = format!(
 			r#"<svg xmlns="http://www.w3.org/2000/svg" preserveAspectRatio="none" viewBox="0 0 1 1" width="{}" height="{}">{}{}<g transform="matrix({})">{}{}</g></svg>"#,
 			size.x, size.y, "\n", outside_artboards, matrix, artboards, artwork

editor/src/messages/portfolio/document/navigation/navigation_message_handler.rs

@@ -50,7 +50,7 @@ impl Default for NavigationMessageHandler {
 
 impl MessageHandler<NavigationMessage, (&Document, &InputPreprocessorMessageHandler)> for NavigationMessageHandler {
 	#[remain::check]
-	fn process_message(&mut self, message: NavigationMessage, (document, ipp): (&Document, &InputPreprocessorMessageHandler), responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: NavigationMessage, responses: &mut VecDeque<Message>, (document, ipp): (&Document, &InputPreprocessorMessageHandler)) {
 		use NavigationMessage::*;
 
 		#[remain::sorted]

editor/src/messages/portfolio/document/node_graph/node_graph_message_handler.rs

@@ -184,12 +184,12 @@ impl NodeGraphMessageHandler {
 				let is_hidden = self.selected_nodes.iter().any(|id| network.disabled.contains(id));
 
 				// Check if multiple nodes are selected
-				let mutliple_nodes = selected_nodes.next().is_some();
+				let multiple_nodes = selected_nodes.next().is_some();
 
 				// Generate the enable or disable button accordingly
 				let hide_button = WidgetHolder::new(Widget::TextButton(TextButton {
 					label: if is_hidden { "Show" } else { "Hide" }.to_string(),
-					tooltip: if is_hidden { "Show node" } else { "Hide node" }.to_string() + if mutliple_nodes { "s" } else { "" },
+					tooltip: if is_hidden { "Show node" } else { "Hide node" }.to_string() + if multiple_nodes { "s" } else { "" },
 					tooltip_shortcut: action_keys!(NodeGraphMessageDiscriminant::ToggleHidden),
 					on_update: WidgetCallback::new(move |_| NodeGraphMessage::ToggleHidden.into()),
 					..Default::default()
@@ -203,7 +203,7 @@ impl NodeGraphMessageHandler {
 				// Is this node the current output
 				let is_output = network.output == node_id;
 
-				// Don't show stop previewing button on the origional output node
+				// Don't show stop previewing button on the original output node
 				if !(is_output && network.previous_output.filter(|&id| id != self.selected_nodes[0]).is_none()) {
 					let output_button = WidgetHolder::new(Widget::TextButton(TextButton {
 						label: if is_output { "End Preview" } else { "Preview" }.to_string(),
@@ -386,7 +386,7 @@ impl NodeGraphMessageHandler {
 
 impl MessageHandler<NodeGraphMessage, (&mut Document, &mut dyn Iterator<Item = &[LayerId]>)> for NodeGraphMessageHandler {
 	#[remain::check]
-	fn process_message(&mut self, message: NodeGraphMessage, (document, selected): (&mut Document, &mut dyn Iterator<Item = &[LayerId]>), responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: NodeGraphMessage, responses: &mut VecDeque<Message>, (document, selected): (&mut Document, &mut dyn Iterator<Item = &[LayerId]>)) {
 		#[remain::sorted]
 		match message {
 			NodeGraphMessage::CloseNodeGraph => {
@@ -416,7 +416,7 @@ impl MessageHandler<NodeGraphMessage, (&mut Document, &mut dyn Iterator<Item = &
 					return;
 				};
 				let Some((input_index, _)) = input_node.inputs.iter().enumerate().filter(|input|input.1.is_exposed()).nth(input_node_connector_index) else {
-					error!("Failed to find actual index of connector indes {input_node_connector_index} on node {input_node:#?}");
+					error!("Failed to find actual index of connector index {input_node_connector_index} on node {input_node:#?}");
 					return;
 				};
 

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

@@ -11,7 +11,7 @@ pub struct OverlaysMessageHandler {
 
 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>) {
+	fn process_message(&mut self, message: OverlaysMessage, responses: &mut VecDeque<Message>, (overlays_visible, font_cache, ipp): (bool, &FontCache, &InputPreprocessorMessageHandler)) {
 		use OverlaysMessage::*;
 
 		#[remain::sorted]

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

@@ -19,7 +19,7 @@ pub struct PropertiesPanelMessageHandler {
 
 impl<'a> MessageHandler<PropertiesPanelMessage, (&PersistentData, PropertiesPanelMessageHandlerData<'a>)> for PropertiesPanelMessageHandler {
 	#[remain::check]
-	fn process_message(&mut self, message: PropertiesPanelMessage, (persistent_data, data): (&PersistentData, PropertiesPanelMessageHandlerData), responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: PropertiesPanelMessage, responses: &mut VecDeque<Message>, (persistent_data, data): (&PersistentData, PropertiesPanelMessageHandlerData)) {
 		let PropertiesPanelMessageHandlerData {
 			artwork_document,
 			artboard_document,

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

@@ -28,7 +28,7 @@ pub struct TransformLayerMessageHandler {
 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>) {
+	fn process_message(&mut self, message: TransformLayerMessage, responses: &mut VecDeque<Message>, (layer_metadata, document, ipp, font_cache): TransformData) {
 		use TransformLayerMessage::*;
 
 		let selected_layers = layer_metadata.iter().filter_map(|(layer_path, data)| data.selected.then_some(layer_path)).collect::<Vec<_>>();

editor/src/messages/portfolio/menu_bar/menu_bar_message_handler.rs

@@ -10,7 +10,7 @@ pub struct MenuBarMessageHandler {}
 
 impl MessageHandler<MenuBarMessage, ()> for MenuBarMessageHandler {
 	#[remain::check]
-	fn process_message(&mut self, message: MenuBarMessage, _data: (), responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: MenuBarMessage, responses: &mut VecDeque<Message>, _data: ()) {
 		use MenuBarMessage::*;
 
 		#[remain::sorted]

editor/src/messages/portfolio/portfolio_message_handler.rs

@@ -36,17 +36,17 @@ pub struct PortfolioMessageHandler {
 
 impl MessageHandler<PortfolioMessage, (&InputPreprocessorMessageHandler, &PreferencesMessageHandler)> for PortfolioMessageHandler {
 	#[remain::check]
-	fn process_message(&mut self, message: PortfolioMessage, (ipp, preferences): (&InputPreprocessorMessageHandler, &PreferencesMessageHandler), responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: PortfolioMessage, responses: &mut VecDeque<Message>, (ipp, preferences): (&InputPreprocessorMessageHandler, &PreferencesMessageHandler)) {
 		#[remain::sorted]
 		match message {
 			// Sub-messages
 			#[remain::unsorted]
-			PortfolioMessage::MenuBar(message) => self.menu_bar_message_handler.process_message(message, (), responses),
+			PortfolioMessage::MenuBar(message) => self.menu_bar_message_handler.process_message(message, responses, ()),
 			#[remain::unsorted]
 			PortfolioMessage::Document(message) => {
 				if let Some(document_id) = self.active_document_id {
 					if let Some(document) = self.documents.get_mut(&document_id) {
-						document.process_message(message, (document_id, ipp, &self.persistent_data, preferences), responses)
+						document.process_message(message, responses, (document_id, ipp, &self.persistent_data, preferences))
 					}
 				}
 			}
@@ -55,7 +55,7 @@ impl MessageHandler<PortfolioMessage, (&InputPreprocessorMessageHandler, &Prefer
 			#[remain::unsorted]
 			PortfolioMessage::DocumentPassMessage { document_id, message } => {
 				if let Some(document) = self.documents.get_mut(&document_id) {
-					document.process_message(message, (document_id, ipp, &self.persistent_data, preferences), responses)
+					document.process_message(message, responses, (document_id, ipp, &self.persistent_data, preferences))
 				}
 			}
 			PortfolioMessage::AutoSaveActiveDocument => {
@@ -749,7 +749,7 @@ impl PortfolioMessageHandler {
 		let size_estimate = (image_width * image_height * 4) as usize;
 
 		let mut result_bytes = Vec::with_capacity(size_estimate);
-		result_bytes.extend(image.data.into_iter().flat_map(|colour| colour.to_rgba8()));
+		result_bytes.extend(image.data.into_iter().flat_map(|color| color.to_rgba8()));
 		let mut output: ImageBuffer<Rgba<u8>, _> = image::ImageBuffer::from_raw(image_width, image_height, result_bytes).ok_or_else(|| "Invalid image size".to_string())?;
 		if let Some(size) = resize {
 			let size = size.as_uvec2();

editor/src/messages/preferences/preferences_message_handler.rs

@@ -19,7 +19,7 @@ impl Default for PreferencesMessageHandler {
 
 impl MessageHandler<PreferencesMessage, ()> for PreferencesMessageHandler {
 	#[remain::check]
-	fn process_message(&mut self, message: PreferencesMessage, _data: (), responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: PreferencesMessage, responses: &mut VecDeque<Message>, _data: ()) {
 		match message {
 			PreferencesMessage::Load { preferences } => {
 				if let Ok(deserialized_preferences) = serde_json::from_str::<PreferencesMessageHandler>(&preferences) {

editor/src/messages/tool/tool_message_handler.rs

@@ -18,8 +18,8 @@ impl MessageHandler<ToolMessage, (&DocumentMessageHandler, u64, &InputPreprocess
 	fn process_message(
 		&mut self,
 		message: ToolMessage,
-		(document, document_id, input, persistent_data): (&DocumentMessageHandler, u64, &InputPreprocessorMessageHandler, &PersistentData),
 		responses: &mut VecDeque<Message>,
+		(document, document_id, input, persistent_data): (&DocumentMessageHandler, u64, &InputPreprocessorMessageHandler, &PersistentData),
 	) {
 		#[remain::sorted]
 		match message {
@@ -73,12 +73,12 @@ impl MessageHandler<ToolMessage, (&DocumentMessageHandler, u64, &InputPreprocess
 				let mut send_abort_to_tool = |tool_type, update_hints_and_cursor: bool| {
 					if let Some(tool) = tool_data.tools.get_mut(&tool_type) {
 						if let Some(tool_abort_message) = tool.event_to_message_map().tool_abort {
-							tool.process_message(tool_abort_message, (document, document_id, document_data, input, &persistent_data.font_cache), responses);
+							tool.process_message(tool_abort_message, responses, (document, document_id, document_data, input, &persistent_data.font_cache));
 						}
 
 						if update_hints_and_cursor {
-							tool.process_message(ToolMessage::UpdateHints, (document, document_id, document_data, input, &persistent_data.font_cache), responses);
+							tool.process_message(ToolMessage::UpdateHints, responses, (document, document_id, document_data, input, &persistent_data.font_cache));
-							tool.process_message(ToolMessage::UpdateCursor, (document, document_id, document_data, input, &persistent_data.font_cache), responses);
+							tool.process_message(ToolMessage::UpdateCursor, responses, (document, document_id, document_data, input, &persistent_data.font_cache));
 						}
 					}
 				};
@@ -134,10 +134,10 @@ impl MessageHandler<ToolMessage, (&DocumentMessageHandler, u64, &InputPreprocess
 				// Set initial hints and cursor
 				tool_data
 					.active_tool_mut()
-					.process_message(ToolMessage::UpdateHints, (document, document_id, document_data, input, &persistent_data.font_cache), responses);
+					.process_message(ToolMessage::UpdateHints, responses, (document, document_id, document_data, input, &persistent_data.font_cache));
 				tool_data
 					.active_tool_mut()
-					.process_message(ToolMessage::UpdateCursor, (document, document_id, document_data, input, &persistent_data.font_cache), responses);
+					.process_message(ToolMessage::UpdateCursor, responses, (document, document_id, document_data, input, &persistent_data.font_cache));
 			}
 			ToolMessage::RefreshToolOptions => {
 				let tool_data = &mut self.tool_state.tool_data;
@@ -196,7 +196,7 @@ impl MessageHandler<ToolMessage, (&DocumentMessageHandler, u64, &InputPreprocess
 
 				if let Some(tool) = tool_data.tools.get_mut(&tool_type) {
 					if tool_type == tool_data.active_tool_type {
-						tool.process_message(tool_message, (document, document_id, document_data, input, &persistent_data.font_cache), responses);
+						tool.process_message(tool_message, responses, (document, document_id, document_data, input, &persistent_data.font_cache));
 					}
 				}
 			}

editor/src/messages/tool/tool_messages/artboard_tool.rs

@@ -59,8 +59,8 @@ impl ToolMetadata for ArtboardTool {
 }
 
 impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for ArtboardTool {
-	fn process_message(&mut self, message: ToolMessage, transition_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
-		self.fsm_state.process_event(message, &mut self.data, transition_data, &(), responses, false);
+		self.fsm_state.process_event(message, &mut self.data, tool_data, &(), responses, false);
 	}
 
 	advertise_actions!(ArtboardToolMessageDiscriminant;

editor/src/messages/tool/tool_messages/ellipse_tool.rs

@@ -50,8 +50,8 @@ impl ToolMetadata for EllipseTool {
 impl PropertyHolder for EllipseTool {}
 
 impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for EllipseTool {
-	fn process_message(&mut self, message: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
-		self.fsm_state.process_event(message, &mut self.data, data, &(), responses, true);
+		self.fsm_state.process_event(message, &mut self.data, tool_data, &(), responses, true);
 	}
 
 	fn actions(&self) -> ActionList {

editor/src/messages/tool/tool_messages/eyedropper_tool.rs

@@ -44,8 +44,8 @@ impl ToolMetadata for EyedropperTool {
 impl PropertyHolder for EyedropperTool {}
 
 impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for EyedropperTool {
-	fn process_message(&mut self, message: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
-		self.fsm_state.process_event(message, &mut self.data, data, &(), responses, true);
+		self.fsm_state.process_event(message, &mut self.data, tool_data, &(), responses, true);
 	}
 
 	advertise_actions!(EyedropperToolMessageDiscriminant;

editor/src/messages/tool/tool_messages/fill_tool.rs

@@ -47,8 +47,8 @@ impl ToolMetadata for FillTool {
 impl PropertyHolder for FillTool {}
 
 impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for FillTool {
-	fn process_message(&mut self, message: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
-		self.fsm_state.process_event(message, &mut self.data, data, &(), responses, true);
+		self.fsm_state.process_event(message, &mut self.data, tool_data, &(), responses, true);
 	}
 
 	advertise_actions!(FillToolMessageDiscriminant;

editor/src/messages/tool/tool_messages/freehand_tool.rs

@@ -83,7 +83,7 @@ impl PropertyHolder for FreehandTool {
 }
 
 impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for FreehandTool {
-	fn process_message(&mut self, message: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
 		if let ToolMessage::Freehand(FreehandToolMessage::UpdateOptions(action)) = message {
 			match action {
 				FreehandToolMessageOptionsUpdate::LineWeight(line_weight) => self.options.line_weight = line_weight,
@@ -91,7 +91,7 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for FreehandTool
 			return;
 		}
 
-		self.fsm_state.process_event(message, &mut self.data, data, &self.options, responses, true);
+		self.fsm_state.process_event(message, &mut self.data, tool_data, &self.options, responses, true);
 	}
 
 	fn actions(&self) -> ActionList {

editor/src/messages/tool/tool_messages/gradient_tool.rs

@@ -77,7 +77,7 @@ impl ToolMetadata for GradientTool {
 }
 
 impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for GradientTool {
-	fn process_message(&mut self, message: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
 		if let ToolMessage::Gradient(GradientToolMessage::UpdateOptions(action)) = message {
 			match action {
 				GradientOptionsUpdate::Type(gradient_type) => {
@@ -91,7 +91,7 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for GradientTool
 			return;
 		}
 
-		self.fsm_state.process_event(message, &mut self.data, data, &self.options, responses, false);
+		self.fsm_state.process_event(message, &mut self.data, tool_data, &self.options, responses, false);
 	}
 
 	advertise_actions!(GradientToolMessageDiscriminant;

editor/src/messages/tool/tool_messages/imaginate_tool.rs

@@ -38,7 +38,7 @@ pub enum ImaginateToolMessage {
 impl PropertyHolder for ImaginateTool {}
 
 impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for ImaginateTool {
-	fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
 		self.fsm_state.process_event(message, &mut self.tool_data, tool_data, &(), responses, true);
 	}
 

editor/src/messages/tool/tool_messages/line_tool.rs

@@ -83,7 +83,7 @@ impl PropertyHolder for LineTool {
 }
 
 impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for LineTool {
-	fn process_message(&mut self, message: ToolMessage, transition_data: ToolActionHandlerData<'a>, messages: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ToolMessage, messages: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
 		if let ToolMessage::Line(LineToolMessage::UpdateOptions(action)) = message {
 			match action {
 				LineOptionsUpdate::LineWeight(line_weight) => self.options.line_weight = line_weight,
@@ -91,7 +91,7 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for LineTool {
 			return;
 		}
 
-		self.fsm_state.process_event(message, &mut self.tool_data, transition_data, &self.options, messages, true);
+		self.fsm_state.process_event(message, &mut self.tool_data, tool_data, &self.options, messages, true);
 	}
 
 	fn actions(&self) -> ActionList {

editor/src/messages/tool/tool_messages/navigate_tool.rs

@@ -51,7 +51,7 @@ impl ToolMetadata for NavigateTool {
 impl PropertyHolder for NavigateTool {}
 
 impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for NavigateTool {
-	fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
 		self.fsm_state.process_event(message, &mut self.tool_data, tool_data, &(), responses, true);
 	}
 

editor/src/messages/tool/tool_messages/node_graph_frame_tool.rs

@@ -37,7 +37,7 @@ pub enum NodeGraphFrameToolMessage {
 impl PropertyHolder for NodeGraphFrameTool {}
 
 impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for NodeGraphFrameTool {
-	fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
 		self.fsm_state.process_event(message, &mut self.tool_data, tool_data, &(), responses, true);
 	}
 

editor/src/messages/tool/tool_messages/path_tool.rs

@@ -61,7 +61,7 @@ impl ToolMetadata for PathTool {
 impl PropertyHolder for PathTool {}
 
 impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for PathTool {
-	fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
 		self.fsm_state.process_event(message, &mut self.tool_data, tool_data, &(), responses, true);
 	}
 

editor/src/messages/tool/tool_messages/pen_tool.rs

@@ -98,7 +98,7 @@ impl PropertyHolder for PenTool {
 }
 
 impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for PenTool {
-	fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
 		if let ToolMessage::Pen(PenToolMessage::UpdateOptions(action)) = message {
 			match action {
 				PenOptionsUpdate::LineWeight(line_weight) => self.options.line_weight = line_weight,

editor/src/messages/tool/tool_messages/rectangle_tool.rs

@@ -38,7 +38,7 @@ pub enum RectangleToolMessage {
 impl PropertyHolder for RectangleTool {}
 
 impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for RectangleTool {
-	fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
 		self.fsm_state.process_event(message, &mut self.tool_data, tool_data, &(), responses, true);
 	}
 

editor/src/messages/tool/tool_messages/select_tool.rs

@@ -197,7 +197,7 @@ impl PropertyHolder for SelectTool {
 }
 
 impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for SelectTool {
-	fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
 		self.fsm_state.process_event(message, &mut self.tool_data, tool_data, &(), responses, false);
 
 		if self.tool_data.pivot.should_refresh_pivot_position() {

editor/src/messages/tool/tool_messages/shape_tool.rs

@@ -81,7 +81,7 @@ impl PropertyHolder for ShapeTool {
 }
 
 impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for ShapeTool {
-	fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
 		if let ToolMessage::Shape(ShapeToolMessage::UpdateOptions(action)) = message {
 			match action {
 				ShapeOptionsUpdate::Vertices(vertices) => self.options.vertices = vertices,

editor/src/messages/tool/tool_messages/spline_tool.rs

@@ -87,7 +87,7 @@ impl PropertyHolder for SplineTool {
 }
 
 impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for SplineTool {
-	fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
 		if let ToolMessage::Spline(SplineToolMessage::UpdateOptions(action)) = message {
 			match action {
 				SplineOptionsUpdate::LineWeight(line_weight) => self.options.line_weight = line_weight,

editor/src/messages/tool/tool_messages/text_tool.rs

@@ -127,7 +127,7 @@ impl PropertyHolder for TextTool {
 }
 
 impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for TextTool {
-	fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
 		if let ToolMessage::Text(TextToolMessage::UpdateOptions(action)) = message {
 			match action {
 				TextOptionsUpdate::Font { family, style } => {

editor/src/messages/workspace/workspace_message_handler.rs

@@ -5,9 +5,9 @@ pub struct WorkspaceMessageHandler {
 	node_graph_visible: bool,
 }
 
-impl MessageHandler<WorkspaceMessage, &InputPreprocessorMessageHandler> for WorkspaceMessageHandler {
+impl MessageHandler<WorkspaceMessage, ()> for WorkspaceMessageHandler {
 	#[remain::check]
-	fn process_message(&mut self, message: WorkspaceMessage, _ipp: &InputPreprocessorMessageHandler, responses: &mut VecDeque<Message>) {
+	fn process_message(&mut self, message: WorkspaceMessage, responses: &mut VecDeque<Message>, _data: ()) {
 		use WorkspaceMessage::*;
 
 		#[remain::sorted]

editor/src/utility_traits.rs

@@ -10,7 +10,7 @@ where
 	<M::Discriminant as TransitiveChild>::TopParent: TransitiveChild<Parent = <M::Discriminant as TransitiveChild>::TopParent, TopParent = <M::Discriminant as TransitiveChild>::TopParent> + AsMessage,
 {
 	/// Return true if the Action is consumed.
-	fn process_message(&mut self, message: M, data: D, responses: &mut VecDeque<Message>);
+	fn process_message(&mut self, message: M, responses: &mut VecDeque<Message>, data: D);
 
 	fn actions(&self) -> ActionList;
 }