GraphiteEditor · Keavon · Jul 13, 2025 · Jul 13, 2025
diff --git a/editor/src/dispatcher.rs b/editor/src/dispatcher.rs
@@ -1,6 +1,6 @@
 use crate::messages::debug::utility_types::MessageLoggingVerbosity;
-use crate::messages::dialog::DialogMessageData;
-use crate::messages::portfolio::document::node_graph::document_node_definitions;
+use crate::messages::dialog::DialogMessageContext;
+use crate::messages::layout::layout_message_handler::LayoutMessageContext;
 use crate::messages::prelude::*;
 
 #[derive(Debug, Default)]
@@ -91,7 +91,7 @@ impl Dispatcher {
 	pub fn handle_message<T: Into<Message>>(&mut self, message: T, process_after_all_current: bool) {
 		let message = message.into();
 		// Add all additional messages to the buffer if it exists (except from the end buffer message)
-		if !matches!(message, Message::EndBuffer(_)) {
+		if !matches!(message, Message::EndBuffer { .. }) {
 			if let Some(buffered_queue) = &mut self.buffered_queue {
 				Self::schedule_execution(buffered_queue, true, [message]);
 
@@ -126,71 +126,19 @@ impl Dispatcher {
 
 			// Process the action by forwarding it to the relevant message handler, or saving the FrontendMessage to be sent to the frontend
 			match message {
-				Message::StartBuffer => {
-					self.buffered_queue = Some(std::mem::take(&mut self.message_queues));
-				}
-				Message::EndBuffer(render_metadata) => {
-					// Assign the message queue to the currently buffered queue
-					if let Some(buffered_queue) = self.buffered_queue.take() {
-						self.cleanup_queues(false);
-						assert!(self.message_queues.is_empty(), "message queues are always empty when ending a buffer");
-						self.message_queues = buffered_queue;
-					};
-
-					let graphene_std::renderer::RenderMetadata {
-						upstream_footprints: footprints,
-						local_transforms,
-						first_instance_source_id,
-						click_targets,
-						clip_targets,
-					} = render_metadata;
-
-					// Run these update state messages immediately
-					let messages = [
-						DocumentMessage::UpdateUpstreamTransforms {
-							upstream_footprints: footprints,
-							local_transforms,
-							first_instance_source_id,
-						},
-						DocumentMessage::UpdateClickTargets { click_targets },
-						DocumentMessage::UpdateClipTargets { clip_targets },
-					];
-					Self::schedule_execution(&mut self.message_queues, false, messages.map(Message::from));
-				}
-				Message::NoOp => {}
-				Message::Init => {
-					// Load persistent data from the browser database
-					queue.add(FrontendMessage::TriggerLoadFirstAutoSaveDocument);
-					queue.add(FrontendMessage::TriggerLoadPreferences);
-
-					// Display the menu bar at the top of the window
-					queue.add(MenuBarMessage::SendLayout);
-
-					// Send the information for tooltips and categories for each node/input.
-					queue.add(FrontendMessage::SendUIMetadata {
-						node_descriptions: document_node_definitions::collect_node_descriptions(),
-						node_types: document_node_definitions::collect_node_types(),
-					});
-
-					// Finish loading persistent data from the browser database
-					queue.add(FrontendMessage::TriggerLoadRestAutoSaveDocuments);
-				}
 				Message::Animation(message) => {
 					self.message_handlers.animation_message_handler.process_message(message, &mut queue, ());
 				}
-				Message::Batched(messages) => {
-					messages.iter().for_each(|message| self.handle_message(message.to_owned(), false));
-				}
 				Message::Broadcast(message) => self.message_handlers.broadcast_message_handler.process_message(message, &mut queue, ()),
 				Message::Debug(message) => {
 					self.message_handlers.debug_message_handler.process_message(message, &mut queue, ());
 				}
 				Message::Dialog(message) => {
-					let data = DialogMessageData {
+					let context = DialogMessageContext {
 						portfolio: &self.message_handlers.portfolio_message_handler,
 						preferences: &self.message_handlers.preferences_message_handler,
 					};
-					self.message_handlers.dialog_message_handler.process_message(message, &mut queue, data);
+					self.message_handlers.dialog_message_handler.process_message(message, &mut queue, context);
 				}
 				Message::Frontend(message) => {
 					// Handle these messages immediately by returning early
@@ -213,20 +161,21 @@ impl Dispatcher {
 
 					self.message_handlers
 						.input_preprocessor_message_handler
-						.process_message(message, &mut queue, InputPreprocessorMessageData { keyboard_platform });
+						.process_message(message, &mut queue, InputPreprocessorMessageContext { keyboard_platform });
 				}
 				Message::KeyMapping(message) => {
 					let input = &self.message_handlers.input_preprocessor_message_handler;
 					let actions = self.collect_actions();
 
 					self.message_handlers
 						.key_mapping_message_handler
-						.process_message(message, &mut queue, KeyMappingMessageData { input, actions });
+						.process_message(message, &mut queue, KeyMappingMessageContext { input, actions });
 				}
 				Message::Layout(message) => {
 					let action_input_mapping = &|action_to_find: &MessageDiscriminant| self.message_handlers.key_mapping_message_handler.action_input_mapping(action_to_find);
+					let context = LayoutMessageContext { action_input_mapping };
 
-					self.message_handlers.layout_message_handler.process_message(message, &mut queue, action_input_mapping);
+					self.message_handlers.layout_message_handler.process_message(message, &mut queue, context);
 				}
 				Message::Portfolio(message) => {
 					let ipp = &self.message_handlers.input_preprocessor_message_handler;
@@ -240,7 +189,7 @@ impl Dispatcher {
 					self.message_handlers.portfolio_message_handler.process_message(
 						message,
 						&mut queue,
-						PortfolioMessageData {
+						PortfolioMessageContext {
 							ipp,
 							preferences,
 							current_tool,
@@ -261,7 +210,7 @@ impl Dispatcher {
 						return;
 					};
 
-					let data = ToolMessageData {
+					let context = ToolMessageContext {
 						document_id,
 						document,
 						input: &self.message_handlers.input_preprocessor_message_handler,
@@ -270,11 +219,46 @@ impl Dispatcher {
 						preferences: &self.message_handlers.preferences_message_handler,
 					};
 
-					self.message_handlers.tool_message_handler.process_message(message, &mut queue, data);
+					self.message_handlers.tool_message_handler.process_message(message, &mut queue, context);
 				}
 				Message::Workspace(message) => {
 					self.message_handlers.workspace_message_handler.process_message(message, &mut queue, ());
 				}
+				Message::NoOp => {}
+				Message::Batched { messages } => {
+					messages.iter().for_each(|message| self.handle_message(message.to_owned(), false));
+				}
+				Message::StartBuffer => {
+					self.buffered_queue = Some(std::mem::take(&mut self.message_queues));
+				}
+				Message::EndBuffer { render_metadata } => {
+					// Assign the message queue to the currently buffered queue
+					if let Some(buffered_queue) = self.buffered_queue.take() {
+						self.cleanup_queues(false);
+						assert!(self.message_queues.is_empty(), "message queues are always empty when ending a buffer");
+						self.message_queues = buffered_queue;
+					};
+
+					let graphene_std::renderer::RenderMetadata {
+						upstream_footprints: footprints,
+						local_transforms,
+						first_instance_source_id,
+						click_targets,
+						clip_targets,
+					} = render_metadata;
+
+					// Run these update state messages immediately
+					let messages = [
+						DocumentMessage::UpdateUpstreamTransforms {
+							upstream_footprints: footprints,
+							local_transforms,
+							first_instance_source_id,
+						},
+						DocumentMessage::UpdateClickTargets { click_targets },
+						DocumentMessage::UpdateClipTargets { clip_targets },
+					];
+					Self::schedule_execution(&mut self.message_queues, false, messages.map(Message::from));
+				}
 			}
 
 			// If there are child messages, append the queue to the list of queues

diff --git a/editor/src/messages/animation/animation_message.rs b/editor/src/messages/animation/animation_message.rs
@@ -9,9 +9,9 @@ pub enum AnimationMessage {
 	EnableLivePreview,
 	DisableLivePreview,
 	RestartAnimation,
-	SetFrameIndex(f64),
-	SetTime(f64),
+	SetFrameIndex { frame: f64 },
+	SetTime { time: f64 },
 	UpdateTime,
 	IncrementFrameCounter,
-	SetAnimationTimeMode(AnimationTimeMode),
+	SetAnimationTimeMode { animation_time_mode: AnimationTimeMode },
 }
diff --git a/editor/src/messages/animation/animation_message_handler.rs b/editor/src/messages/animation/animation_message_handler.rs
@@ -59,7 +59,7 @@ impl AnimationMessageHandler {
 
 #[message_handler_data]
 impl MessageHandler<AnimationMessage, ()> for AnimationMessageHandler {
-	fn process_message(&mut self, message: AnimationMessage, responses: &mut VecDeque<Message>, _data: ()) {
+	fn process_message(&mut self, message: AnimationMessage, responses: &mut VecDeque<Message>, _: ()) {
 		match message {
 			AnimationMessage::ToggleLivePreview => match self.animation_state {
 				AnimationState::Stopped => responses.add(AnimationMessage::EnableLivePreview),
@@ -82,13 +82,13 @@ impl MessageHandler<AnimationMessage, ()> for AnimationMessageHandler {
 				// Update the restart and pause/play buttons
 				responses.add(PortfolioMessage::UpdateDocumentWidgets);
 			}
-			AnimationMessage::SetFrameIndex(frame) => {
+			AnimationMessage::SetFrameIndex { frame } => {
 				self.frame_index = frame;
 				responses.add(PortfolioMessage::SubmitActiveGraphRender);
 				// Update the restart and pause/play buttons
 				responses.add(PortfolioMessage::UpdateDocumentWidgets);
 			}
-			AnimationMessage::SetTime(time) => {
+			AnimationMessage::SetTime { time } => {
 				self.timestamp = time;
 				responses.add(AnimationMessage::UpdateTime);
 			}
@@ -120,7 +120,7 @@ impl MessageHandler<AnimationMessage, ()> for AnimationMessageHandler {
 				// Update the restart and pause/play buttons
 				responses.add(PortfolioMessage::UpdateDocumentWidgets);
 			}
-			AnimationMessage::SetAnimationTimeMode(animation_time_mode) => {
+			AnimationMessage::SetAnimationTimeMode { animation_time_mode } => {
 				self.animation_time_mode = animation_time_mode;
 			}
 		}

diff --git a/editor/src/messages/broadcast/broadcast_message_handler.rs b/editor/src/messages/broadcast/broadcast_message_handler.rs
@@ -7,7 +7,7 @@ pub struct BroadcastMessageHandler {
 
 #[message_handler_data]
 impl MessageHandler<BroadcastMessage, ()> for BroadcastMessageHandler {
-	fn process_message(&mut self, message: BroadcastMessage, responses: &mut VecDeque<Message>, _data: ()) {
+	fn process_message(&mut self, message: BroadcastMessage, responses: &mut VecDeque<Message>, _: ()) {
 		match message {
 			// Sub-messages
 			BroadcastMessage::TriggerEvent(event) => {

diff --git a/editor/src/messages/debug/debug_message_handler.rs b/editor/src/messages/debug/debug_message_handler.rs
@@ -8,7 +8,7 @@ pub struct DebugMessageHandler {
 
 #[message_handler_data]
 impl MessageHandler<DebugMessage, ()> for DebugMessageHandler {
-	fn process_message(&mut self, message: DebugMessage, responses: &mut VecDeque<Message>, _data: ()) {
+	fn process_message(&mut self, message: DebugMessage, responses: &mut VecDeque<Message>, _: ()) {
 		match message {
 			DebugMessage::ToggleTraceLogs => {
 				if log::max_level() == log::LevelFilter::Debug {

diff --git a/editor/src/messages/dialog/dialog_message_handler.rs b/editor/src/messages/dialog/dialog_message_handler.rs
@@ -3,7 +3,7 @@ use crate::messages::layout::utility_types::widget_prelude::*;
 use crate::messages::prelude::*;
 
 #[derive(ExtractField)]
-pub struct DialogMessageData<'a> {
+pub struct DialogMessageContext<'a> {
 	pub portfolio: &'a PortfolioMessageHandler,
 	pub preferences: &'a PreferencesMessageHandler,
 }
@@ -17,14 +17,14 @@ pub struct DialogMessageHandler {
 }
 
 #[message_handler_data]
-impl MessageHandler<DialogMessage, DialogMessageData<'_>> for DialogMessageHandler {
-	fn process_message(&mut self, message: DialogMessage, responses: &mut VecDeque<Message>, data: DialogMessageData) {
-		let DialogMessageData { portfolio, preferences } = data;
+impl MessageHandler<DialogMessage, DialogMessageContext<'_>> for DialogMessageHandler {
+	fn process_message(&mut self, message: DialogMessage, responses: &mut VecDeque<Message>, context: DialogMessageContext) {
+		let DialogMessageContext { portfolio, preferences } = context;
 
 		match message {
-			DialogMessage::ExportDialog(message) => self.export_dialog.process_message(message, responses, ExportDialogMessageData { portfolio }),
+			DialogMessage::ExportDialog(message) => self.export_dialog.process_message(message, responses, ExportDialogMessageContext { portfolio }),
 			DialogMessage::NewDocumentDialog(message) => self.new_document_dialog.process_message(message, responses, ()),
-			DialogMessage::PreferencesDialog(message) => self.preferences_dialog.process_message(message, responses, PreferencesDialogMessageData { preferences }),
+			DialogMessage::PreferencesDialog(message) => self.preferences_dialog.process_message(message, responses, PreferencesDialogMessageContext { preferences }),
 
 			DialogMessage::CloseAllDocumentsWithConfirmation => {
 				let dialog = simple_dialogs::CloseAllDocumentsDialog {

diff --git a/editor/src/messages/dialog/export_dialog/export_dialog_message_handler.rs b/editor/src/messages/dialog/export_dialog/export_dialog_message_handler.rs
@@ -4,7 +4,7 @@ use crate::messages::portfolio::document::utility_types::document_metadata::Laye
 use crate::messages::prelude::*;
 
 #[derive(ExtractField)]
-pub struct ExportDialogMessageData<'a> {
+pub struct ExportDialogMessageContext<'a> {
 	pub portfolio: &'a PortfolioMessageHandler,
 }
 
@@ -33,9 +33,9 @@ impl Default for ExportDialogMessageHandler {
 }
 
 #[message_handler_data]
-impl MessageHandler<ExportDialogMessage, ExportDialogMessageData<'_>> for ExportDialogMessageHandler {
-	fn process_message(&mut self, message: ExportDialogMessage, responses: &mut VecDeque<Message>, data: ExportDialogMessageData) {
-		let ExportDialogMessageData { portfolio } = data;
+impl MessageHandler<ExportDialogMessage, ExportDialogMessageContext<'_>> for ExportDialogMessageHandler {
+	fn process_message(&mut self, message: ExportDialogMessage, responses: &mut VecDeque<Message>, context: ExportDialogMessageContext) {
+		let ExportDialogMessageContext { portfolio } = context;
 
 		match message {
 			ExportDialogMessage::FileType(export_type) => self.file_type = export_type,

diff --git a/editor/src/messages/dialog/export_dialog/mod.rs b/editor/src/messages/dialog/export_dialog/mod.rs
@@ -4,4 +4,4 @@ mod export_dialog_message_handler;
 #[doc(inline)]
 pub use export_dialog_message::{ExportDialogMessage, ExportDialogMessageDiscriminant};
 #[doc(inline)]
-pub use export_dialog_message_handler::{ExportDialogMessageData, ExportDialogMessageHandler};
+pub use export_dialog_message_handler::{ExportDialogMessageContext, ExportDialogMessageHandler};
diff --git a/editor/src/messages/dialog/mod.rs b/editor/src/messages/dialog/mod.rs
@@ -16,4 +16,4 @@ pub mod simple_dialogs;
 #[doc(inline)]
 pub use dialog_message::{DialogMessage, DialogMessageDiscriminant};
 #[doc(inline)]
-pub use dialog_message_handler::{DialogMessageData, DialogMessageHandler};
+pub use dialog_message_handler::{DialogMessageContext, DialogMessageHandler};
diff --git a/editor/src/messages/dialog/new_document_dialog/new_document_dialog_message_handler.rs b/editor/src/messages/dialog/new_document_dialog/new_document_dialog_message_handler.rs
@@ -13,7 +13,7 @@ pub struct NewDocumentDialogMessageHandler {
 
 #[message_handler_data]
 impl MessageHandler<NewDocumentDialogMessage, ()> for NewDocumentDialogMessageHandler {
-	fn process_message(&mut self, message: NewDocumentDialogMessage, responses: &mut VecDeque<Message>, _data: ()) {
+	fn process_message(&mut self, message: NewDocumentDialogMessage, responses: &mut VecDeque<Message>, _: ()) {
 		match message {
 			NewDocumentDialogMessage::Name(name) => self.name = name,
 			NewDocumentDialogMessage::Infinite(infinite) => self.infinite = infinite,

diff --git a/editor/src/messages/dialog/preferences_dialog/mod.rs b/editor/src/messages/dialog/preferences_dialog/mod.rs
@@ -4,4 +4,4 @@ mod preferences_dialog_message_handler;
 #[doc(inline)]
 pub use preferences_dialog_message::{PreferencesDialogMessage, PreferencesDialogMessageDiscriminant};
 #[doc(inline)]
-pub use preferences_dialog_message_handler::{PreferencesDialogMessageData, PreferencesDialogMessageHandler};
+pub use preferences_dialog_message_handler::{PreferencesDialogMessageContext, PreferencesDialogMessageHandler};
diff --git a/editor/src/messages/dialog/preferences_dialog/preferences_dialog_message_handler.rs b/editor/src/messages/dialog/preferences_dialog/preferences_dialog_message_handler.rs
@@ -5,7 +5,7 @@ use crate::messages::preferences::SelectionMode;
 use crate::messages::prelude::*;
 
 #[derive(ExtractField)]
-pub struct PreferencesDialogMessageData<'a> {
+pub struct PreferencesDialogMessageContext<'a> {
 	pub preferences: &'a PreferencesMessageHandler,
 }
 
@@ -14,9 +14,9 @@ pub struct PreferencesDialogMessageData<'a> {
 pub struct PreferencesDialogMessageHandler {}
 
 #[message_handler_data]
-impl MessageHandler<PreferencesDialogMessage, PreferencesDialogMessageData<'_>> for PreferencesDialogMessageHandler {
-	fn process_message(&mut self, message: PreferencesDialogMessage, responses: &mut VecDeque<Message>, data: PreferencesDialogMessageData) {
-		let PreferencesDialogMessageData { preferences } = data;
+impl MessageHandler<PreferencesDialogMessage, PreferencesDialogMessageContext<'_>> for PreferencesDialogMessageHandler {
+	fn process_message(&mut self, message: PreferencesDialogMessage, responses: &mut VecDeque<Message>, context: PreferencesDialogMessageContext) {
+		let PreferencesDialogMessageContext { preferences } = context;
 
 		match message {
 			PreferencesDialogMessage::Confirm => {}

diff --git a/editor/src/messages/globals/globals_message_handler.rs b/editor/src/messages/globals/globals_message_handler.rs
@@ -5,7 +5,7 @@ pub struct GlobalsMessageHandler {}
 
 #[message_handler_data]
 impl MessageHandler<GlobalsMessage, ()> for GlobalsMessageHandler {
-	fn process_message(&mut self, message: GlobalsMessage, _responses: &mut VecDeque<Message>, _data: ()) {
+	fn process_message(&mut self, message: GlobalsMessage, _responses: &mut VecDeque<Message>, _: ()) {
 		match message {
 			GlobalsMessage::SetPlatform { platform } => {
 				if GLOBAL_PLATFORM.get() != Some(&platform) {

diff --git a/editor/src/messages/input_mapper/input_mapper_message_handler.rs b/editor/src/messages/input_mapper/input_mapper_message_handler.rs
@@ -7,7 +7,7 @@ use crate::messages::prelude::*;
 use std::fmt::Write;
 
 #[derive(ExtractField)]
-pub struct InputMapperMessageData<'a> {
+pub struct InputMapperMessageContext<'a> {
 	pub input: &'a InputPreprocessorMessageHandler,
 	pub actions: ActionList,
 }
@@ -18,9 +18,9 @@ pub struct InputMapperMessageHandler {
 }
 
 #[message_handler_data]
-impl MessageHandler<InputMapperMessage, InputMapperMessageData<'_>> for InputMapperMessageHandler {
-	fn process_message(&mut self, message: InputMapperMessage, responses: &mut VecDeque<Message>, data: InputMapperMessageData) {
-		let InputMapperMessageData { input, actions } = data;
+impl MessageHandler<InputMapperMessage, InputMapperMessageContext<'_>> for InputMapperMessageHandler {
+	fn process_message(&mut self, message: InputMapperMessage, responses: &mut VecDeque<Message>, context: InputMapperMessageContext) {
+		let InputMapperMessageContext { input, actions } = context;
 
 		if let Some(message) = self.mapping.match_input_message(message, &input.keyboard, actions) {
 			responses.add(message);