Add struct field visualization to the editor message hierarchy tree visualization on the website

desktop/src/app.rs

@@ -61,8 +61,8 @@ impl WinitApp {
 	}
 
 	fn send_messages_to_editor(&mut self, mut responses: Vec<FrontendMessage>) {
-		for message in responses.extract_if(.., |m| matches!(m, FrontendMessage::RenderOverlays(_))) {
-			let FrontendMessage::RenderOverlays(overlay_context) = message else { unreachable!() };
+		for message in responses.extract_if(.., |m| matches!(m, FrontendMessage::RenderOverlays { .. })) {
+			let FrontendMessage::RenderOverlays { context: overlay_context } = message else { unreachable!() };
 			if let Some(graphics_state) = &mut self.graphics_state {
 				let scene = overlay_context.take_scene();
 				graphics_state.set_overlays_scene(scene);

editor/src/dispatcher.rs

@@ -52,7 +52,7 @@ const SIDE_EFFECT_FREE_MESSAGES: &[MessageDiscriminant] = &[
 	MessageDiscriminant::Frontend(FrontendMessageDiscriminant::TriggerFontLoad),
 ];
 const DEBUG_MESSAGE_BLOCK_LIST: &[MessageDiscriminant] = &[
-	MessageDiscriminant::Broadcast(BroadcastMessageDiscriminant::TriggerEvent(BroadcastEventDiscriminant::AnimationFrame)),
+	MessageDiscriminant::Broadcast(BroadcastMessageDiscriminant::TriggerEvent(EventMessageDiscriminant::AnimationFrame)),
 	MessageDiscriminant::Animation(AnimationMessageDiscriminant::IncrementFrameCounter),
 ];
 // TODO: Find a way to combine these with the list above. We use strings for now since these are the standard variant names used by multiple messages. But having these also type-checked would be best.

editor/src/messages/animation/animation_message.rs

@@ -1,6 +1,5 @@
-use crate::messages::prelude::*;
-
 use super::animation_message_handler::AnimationTimeMode;
+use crate::messages::prelude::*;
 
 #[impl_message(Message, Animation)]
 #[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]

editor/src/messages/broadcast/broadcast_message.rs

@@ -5,15 +5,15 @@ use crate::messages::prelude::*;
 pub enum BroadcastMessage {
 	// Sub-messages
 	#[child]
-	TriggerEvent(BroadcastEvent),
+	TriggerEvent(EventMessage),
 
 	// Messages
 	SubscribeEvent {
-		on: BroadcastEvent,
+		on: EventMessage,
 		send: Box<Message>,
 	},
 	UnsubscribeEvent {
-		on: BroadcastEvent,
-		message: Box<Message>,
+		on: EventMessage,
+		send: Box<Message>,
 	},
 }

editor/src/messages/broadcast/broadcast_message_handler.rs

@@ -2,27 +2,24 @@ use crate::messages::prelude::*;
 
 #[derive(Debug, Clone, Default, ExtractField)]
 pub struct BroadcastMessageHandler {
-	listeners: HashMap<BroadcastEvent, Vec<Message>>,
+	event: EventMessageHandler,
+	listeners: HashMap<EventMessage, Vec<Message>>,
 }
 
 #[message_handler_data]
 impl MessageHandler<BroadcastMessage, ()> for BroadcastMessageHandler {
 	fn process_message(&mut self, message: BroadcastMessage, responses: &mut VecDeque<Message>, _: ()) {
 		match message {
 			// Sub-messages
-			BroadcastMessage::TriggerEvent(event) => {
-				for message in self.listeners.entry(event).or_default() {
-					responses.add_front(message.clone())
-				}
-			}
+			BroadcastMessage::TriggerEvent(message) => self.event.process_message(message, responses, EventMessageContext { listeners: &mut self.listeners }),
 
 			// Messages
 			BroadcastMessage::SubscribeEvent { on, send } => self.listeners.entry(on).or_default().push(*send),
-			BroadcastMessage::UnsubscribeEvent { on, message } => self.listeners.entry(on).or_default().retain(|msg| *msg != *message),
+			BroadcastMessage::UnsubscribeEvent { on, send } => self.listeners.entry(on).or_default().retain(|msg| *msg != *send),
 		}
 	}
 
 	fn actions(&self) -> ActionList {
-		actions!(BroadcastEventDiscriminant;)
+		actions!(EventMessageDiscriminant;)
 	}
 }

editor/src/messages/broadcast/broadcast_event.rs → editor/src/messages/broadcast/event/event_message.rs

@@ -1,8 +1,8 @@
 use crate::messages::prelude::*;
 
-#[derive(PartialEq, Eq, Clone, Debug, serde::Serialize, serde::Deserialize, Hash)]
 #[impl_message(Message, BroadcastMessage, TriggerEvent)]
-pub enum BroadcastEvent {
+#[derive(PartialEq, Eq, Clone, Debug, serde::Serialize, serde::Deserialize, Hash)]
+pub enum EventMessage {
 	/// Triggered by requestAnimationFrame in JS
 	AnimationFrame,
 	CanvasTransformed,

editor/src/messages/broadcast/event/event_message_handler.rs

@@ -0,0 +1,22 @@
+use crate::messages::prelude::*;
+
+#[derive(ExtractField)]
+pub struct EventMessageContext<'a> {
+	pub listeners: &'a mut HashMap<EventMessage, Vec<Message>>,
+}
+
+#[derive(Debug, Clone, Default, ExtractField)]
+pub struct EventMessageHandler {}
+
+#[message_handler_data]
+impl MessageHandler<EventMessage, EventMessageContext<'_>> for EventMessageHandler {
+	fn process_message(&mut self, message: EventMessage, responses: &mut VecDeque<Message>, context: EventMessageContext) {
+		for message in context.listeners.entry(message).or_default() {
+			responses.add_front(message.clone())
+		}
+	}
+
+	fn actions(&self) -> ActionList {
+		actions!(EventMessageDiscriminant;)
+	}
+}

editor/src/messages/broadcast/event/mod.rs

@@ -0,0 +1,7 @@
+mod event_message;
+mod event_message_handler;
+
+#[doc(inline)]
+pub use event_message::{EventMessage, EventMessageDiscriminant};
+#[doc(inline)]
+pub use event_message_handler::{EventMessageContext, EventMessageHandler};

editor/src/messages/broadcast/mod.rs

@@ -1,7 +1,7 @@
 mod broadcast_message;
 mod broadcast_message_handler;
 
-pub mod broadcast_event;
+pub mod event;
 
 #[doc(inline)]
 pub use broadcast_message::{BroadcastMessage, BroadcastMessageDiscriminant};

editor/src/messages/defer/defer_message.rs

@@ -3,8 +3,8 @@ use crate::messages::prelude::*;
 #[impl_message(Message, Defer)]
 #[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub enum DeferMessage {
-	SetGraphSubmissionIndex(u64),
-	TriggerGraphRun(u64, DocumentId),
+	SetGraphSubmissionIndex { execution_id: u64 },
+	TriggerGraphRun { execution_id: u64, document_id: DocumentId },
 	AfterGraphRun { messages: Vec<Message> },
 	TriggerNavigationReady,
 	AfterNavigationReady { messages: Vec<Message> },

editor/src/messages/defer/defer_message_handler.rs

@@ -24,10 +24,10 @@ impl MessageHandler<DeferMessage, DeferMessageContext<'_>> for DeferMessageHandl
 			DeferMessage::AfterNavigationReady { messages } => {
 				self.after_viewport_resize.extend_from_slice(&messages);
 			}
-			DeferMessage::SetGraphSubmissionIndex(execution_id) => {
+			DeferMessage::SetGraphSubmissionIndex { execution_id } => {
 				self.current_graph_submission_id = execution_id + 1;
 			}
-			DeferMessage::TriggerGraphRun(execution_id, document_id) => {
+			DeferMessage::TriggerGraphRun { execution_id, document_id } => {
 				let after_graph_run = self.after_graph_run.entry(document_id).or_default();
 				if after_graph_run.is_empty() {
 					return;

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

@@ -4,10 +4,10 @@ use crate::messages::prelude::*;
 #[impl_message(Message, DialogMessage, ExportDialog)]
 #[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub enum ExportDialogMessage {
-	FileType(FileType),
-	ScaleFactor(f64),
-	TransparentBackground(bool),
-	ExportBounds(ExportBounds),
+	FileType { file_type: FileType },
+	ScaleFactor { factor: f64 },
+	TransparentBackground { transparent: bool },
+	ExportBounds { bounds: ExportBounds },
 
 	Submit,
 }

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

@@ -38,10 +38,10 @@ impl MessageHandler<ExportDialogMessage, ExportDialogMessageContext<'_>> for Exp
 		let ExportDialogMessageContext { portfolio } = context;
 
 		match message {
-			ExportDialogMessage::FileType(export_type) => self.file_type = export_type,
-			ExportDialogMessage::ScaleFactor(factor) => self.scale_factor = factor,
-			ExportDialogMessage::TransparentBackground(transparent_background) => self.transparent_background = transparent_background,
-			ExportDialogMessage::ExportBounds(export_area) => self.bounds = export_area,
+			ExportDialogMessage::FileType { file_type } => self.file_type = file_type,
+			ExportDialogMessage::ScaleFactor { factor } => self.scale_factor = factor,
+			ExportDialogMessage::TransparentBackground { transparent } => self.transparent_background = transparent,
+			ExportDialogMessage::ExportBounds { bounds } => self.bounds = bounds,
 
 			ExportDialogMessage::Submit => responses.add_front(PortfolioMessage::SubmitDocumentExport {
 				file_name: portfolio.active_document().map(|document| document.name.clone()).unwrap_or_default(),
@@ -84,7 +84,11 @@ impl LayoutHolder for ExportDialogMessageHandler {
 	fn layout(&self) -> Layout {
 		let entries = [(FileType::Png, "PNG"), (FileType::Jpg, "JPG"), (FileType::Svg, "SVG")]
 			.into_iter()
-			.map(|(val, name)| RadioEntryData::new(format!("{val:?}")).label(name).on_update(move |_| ExportDialogMessage::FileType(val).into()))
+			.map(|(file_type, name)| {
+				RadioEntryData::new(format!("{file_type:?}"))
+					.label(name)
+					.on_update(move |_| ExportDialogMessage::FileType { file_type }.into())
+			})
 			.collect();
 
 		let export_type = vec![
@@ -101,7 +105,7 @@ impl LayoutHolder for ExportDialogMessageHandler {
 				.min(0.)
 				.max((1_u64 << f64::MANTISSA_DIGITS) as f64)
 				.disabled(self.file_type == FileType::Svg)
-				.on_update(|number_input: &NumberInput| ExportDialogMessage::ScaleFactor(number_input.value.unwrap()).into())
+				.on_update(|number_input: &NumberInput| ExportDialogMessage::ScaleFactor { factor: number_input.value.unwrap() }.into())
 				.min_width(200)
 				.widget_holder(),
 		];
@@ -125,10 +129,10 @@ impl LayoutHolder for ExportDialogMessageHandler {
 			.map(|choice| {
 				choice
 					.into_iter()
-					.map(|(val, name, disabled)| {
-						MenuListEntry::new(format!("{val:?}"))
+					.map(|(bounds, name, disabled)| {
+						MenuListEntry::new(format!("{bounds:?}"))
 							.label(name)
-							.on_commit(move |_| ExportDialogMessage::ExportBounds(val).into())
+							.on_commit(move |_| ExportDialogMessage::ExportBounds { bounds }.into())
 							.disabled(disabled)
 					})
 					.collect::<Vec<_>>()
@@ -151,7 +155,7 @@ impl LayoutHolder for ExportDialogMessageHandler {
 			Separator::new(SeparatorType::Unrelated).widget_holder(),
 			CheckboxInput::new(self.transparent_background)
 				.disabled(self.file_type == FileType::Jpg)
-				.on_update(move |value: &CheckboxInput| ExportDialogMessage::TransparentBackground(value.checked).into())
+				.on_update(move |value: &CheckboxInput| ExportDialogMessage::TransparentBackground { transparent: value.checked }.into())
 				.for_label(checkbox_id)
 				.widget_holder(),
 		];

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

@@ -3,10 +3,10 @@ use crate::messages::prelude::*;
 #[impl_message(Message, DialogMessage, NewDocumentDialog)]
 #[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub enum NewDocumentDialogMessage {
-	Name(String),
-	Infinite(bool),
-	DimensionsX(f64),
-	DimensionsY(f64),
+	Name { name: String },
+	Infinite { infinite: bool },
+	DimensionsX { width: f64 },
+	DimensionsY { height: f64 },
 
 	Submit,
 }

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

@@ -20,10 +20,10 @@ pub struct NewDocumentDialogMessageHandler {
 impl<'a> MessageHandler<NewDocumentDialogMessage, NewDocumentDialogMessageContext<'a>> for NewDocumentDialogMessageHandler {
 	fn process_message(&mut self, message: NewDocumentDialogMessage, responses: &mut VecDeque<Message>, context: NewDocumentDialogMessageContext<'a>) {
 		match message {
-			NewDocumentDialogMessage::Name(name) => self.name = name,
-			NewDocumentDialogMessage::Infinite(infinite) => self.infinite = infinite,
-			NewDocumentDialogMessage::DimensionsX(x) => self.dimensions.x = x as u32,
-			NewDocumentDialogMessage::DimensionsY(y) => self.dimensions.y = y as u32,
+			NewDocumentDialogMessage::Name { name } => self.name = name,
+			NewDocumentDialogMessage::Infinite { infinite } => self.infinite = infinite,
+			NewDocumentDialogMessage::DimensionsX { width } => self.dimensions.x = width as u32,
+			NewDocumentDialogMessage::DimensionsY { height } => self.dimensions.y = height as u32,
 			NewDocumentDialogMessage::Submit => {
 				responses.add(PortfolioMessage::NewDocumentWithName { name: self.name.clone() });
 
@@ -82,7 +82,7 @@ impl LayoutHolder for NewDocumentDialogMessageHandler {
 			TextLabel::new("Name").table_align(true).min_width(90).widget_holder(),
 			Separator::new(SeparatorType::Unrelated).widget_holder(),
 			TextInput::new(&self.name)
-				.on_update(|text_input: &TextInput| NewDocumentDialogMessage::Name(text_input.value.clone()).into())
+				.on_update(|text_input: &TextInput| NewDocumentDialogMessage::Name { name: text_input.value.clone() }.into())
 				.min_width(204) // Matches the 100px of both NumberInputs below + the 4px of the Unrelated-type separator
 				.widget_holder(),
 		];
@@ -92,7 +92,7 @@ impl LayoutHolder for NewDocumentDialogMessageHandler {
 			TextLabel::new("Infinite Canvas").table_align(true).min_width(90).for_checkbox(checkbox_id).widget_holder(),
 			Separator::new(SeparatorType::Unrelated).widget_holder(),
 			CheckboxInput::new(self.infinite)
-				.on_update(|checkbox_input: &CheckboxInput| NewDocumentDialogMessage::Infinite(checkbox_input.checked).into())
+				.on_update(|checkbox_input: &CheckboxInput| NewDocumentDialogMessage::Infinite { infinite: checkbox_input.checked }.into())
 				.for_label(checkbox_id)
 				.widget_holder(),
 		];
@@ -108,7 +108,7 @@ impl LayoutHolder for NewDocumentDialogMessageHandler {
 				.is_integer(true)
 				.disabled(self.infinite)
 				.min_width(100)
-				.on_update(|number_input: &NumberInput| NewDocumentDialogMessage::DimensionsX(number_input.value.unwrap()).into())
+				.on_update(|number_input: &NumberInput| NewDocumentDialogMessage::DimensionsX { width: number_input.value.unwrap() }.into())
 				.widget_holder(),
 			Separator::new(SeparatorType::Related).widget_holder(),
 			NumberInput::new(Some(self.dimensions.y as f64))
@@ -119,7 +119,7 @@ impl LayoutHolder for NewDocumentDialogMessageHandler {
 				.is_integer(true)
 				.disabled(self.infinite)
 				.min_width(100)
-				.on_update(|number_input: &NumberInput| NewDocumentDialogMessage::DimensionsY(number_input.value.unwrap()).into())
+				.on_update(|number_input: &NumberInput| NewDocumentDialogMessage::DimensionsY { height: number_input.value.unwrap() }.into())
 				.widget_holder(),
 		];
 

editor/src/messages/dialog/simple_dialogs/close_document_dialog.rs

@@ -1,4 +1,4 @@
-use crate::messages::broadcast::broadcast_event::BroadcastEvent;
+use crate::messages::broadcast::event::EventMessage;
 use crate::messages::layout::utility_types::widget_prelude::*;
 use crate::messages::prelude::*;
 
@@ -27,7 +27,7 @@ impl DialogLayoutHolder for CloseDocumentDialog {
 			TextButton::new("Discard")
 				.on_update(move |_| {
 					DialogMessage::CloseDialogAndThen {
-						followups: vec![BroadcastEvent::ToolAbort.into(), PortfolioMessage::CloseDocument { document_id }.into()],
+						followups: vec![EventMessage::ToolAbort.into(), PortfolioMessage::CloseDocument { document_id }.into()],
 					}
 					.into()
 				})

editor/src/messages/frontend/frontend_message.rs

@@ -335,9 +335,9 @@ pub enum FrontendMessage {
 		active: bool,
 	},
 	#[cfg(not(target_family = "wasm"))]
-	RenderOverlays(
+	RenderOverlays {
 		#[serde(skip, default = "OverlayContext::default")]
 		#[derivative(Debug = "ignore", PartialEq = "ignore")]
-		OverlayContext,
-	),
+		context: OverlayContext,
+	},
 }

editor/src/messages/input_mapper/input_mappings.rs

@@ -96,7 +96,7 @@ pub fn input_mappings() -> Mapping {
 		entry!(PointerMove; refresh_keys=[Control, Shift], action_dispatch=TransformLayerMessage::PointerMove { slow_key: Shift, increments_key: Control }),
 		//
 		// SelectToolMessage
-		entry!(PointerMove; refresh_keys=[Control, Alt, Shift], action_dispatch=SelectToolMessage::PointerMove(SelectToolPointerKeys { axis_align: Shift, snap_angle: Shift, center: Alt, duplicate: Alt })),
+		entry!(PointerMove; refresh_keys=[Control, Alt, Shift], action_dispatch=SelectToolMessage::PointerMove { modifier_keys: SelectToolPointerKeys { axis_align: Shift, snap_angle: Shift, center: Alt, duplicate: Alt } }),
 		entry!(KeyDown(MouseLeft); action_dispatch=SelectToolMessage::DragStart { extend_selection: Shift, remove_from_selection: Alt, select_deepest: Accel, lasso_select: Control, skew: Control }),
 		entry!(KeyUp(MouseLeft); action_dispatch=SelectToolMessage::DragStop { remove_from_selection: Alt }),
 		entry!(KeyDown(Enter); action_dispatch=SelectToolMessage::Enter),
@@ -178,7 +178,7 @@ pub fn input_mappings() -> Mapping {
 		entry!(KeyDown(Escape); action_dispatch=ShapeToolMessage::Abort),
 		entry!(KeyDown(BracketLeft); action_dispatch=ShapeToolMessage::DecreaseSides),
 		entry!(KeyDown(BracketRight); action_dispatch=ShapeToolMessage::IncreaseSides),
-		entry!(PointerMove; refresh_keys=[Alt, Shift, Control], action_dispatch=ShapeToolMessage::PointerMove([Alt, Shift, Control])),
+		entry!(PointerMove; refresh_keys=[Alt, Shift, Control], action_dispatch=ShapeToolMessage::PointerMove { modifier: [Alt, Shift, Control] }),
 		entry!(KeyDown(ArrowUp); modifiers=[Shift, ArrowLeft], action_dispatch=ShapeToolMessage::NudgeSelectedLayers { delta_x: -BIG_NUDGE_AMOUNT, delta_y: -BIG_NUDGE_AMOUNT, resize: Alt, resize_opposite_corner: Control }),
 		entry!(KeyDown(ArrowUp); modifiers=[Shift, ArrowRight], action_dispatch=ShapeToolMessage::NudgeSelectedLayers { delta_x: BIG_NUDGE_AMOUNT, delta_y: -BIG_NUDGE_AMOUNT, resize: Alt, resize_opposite_corner: Control }),
 		entry!(KeyDown(ArrowUp); modifiers=[Shift], action_dispatch=ShapeToolMessage::NudgeSelectedLayers { delta_x: 0., delta_y: -BIG_NUDGE_AMOUNT, resize: Alt, resize_opposite_corner: Control }),
@@ -297,8 +297,8 @@ pub fn input_mappings() -> Mapping {
 		entry!(PointerMove; action_dispatch=BrushToolMessage::PointerMove),
 		entry!(KeyDown(MouseLeft); action_dispatch=BrushToolMessage::DragStart),
 		entry!(KeyUp(MouseLeft); action_dispatch=BrushToolMessage::DragStop),
-		entry!(KeyDown(BracketLeft); action_dispatch=BrushToolMessage::UpdateOptions(BrushToolMessageOptionsUpdate::ChangeDiameter(-BRUSH_SIZE_CHANGE_KEYBOARD))),
-		entry!(KeyDown(BracketRight); action_dispatch=BrushToolMessage::UpdateOptions(BrushToolMessageOptionsUpdate::ChangeDiameter(BRUSH_SIZE_CHANGE_KEYBOARD))),
+		entry!(KeyDown(BracketLeft); action_dispatch=BrushToolMessage::UpdateOptions { options: BrushToolMessageOptionsUpdate::ChangeDiameter(-BRUSH_SIZE_CHANGE_KEYBOARD) }),
+		entry!(KeyDown(BracketRight); action_dispatch=BrushToolMessage::UpdateOptions { options: BrushToolMessageOptionsUpdate::ChangeDiameter(BRUSH_SIZE_CHANGE_KEYBOARD) }),
 		entry!(KeyDown(MouseRight); action_dispatch=BrushToolMessage::Abort),
 		entry!(KeyDown(Escape); action_dispatch=BrushToolMessage::Abort),
 		//

editor/src/messages/input_mapper/key_mapping/key_mapping_message.rs

@@ -3,13 +3,16 @@ use crate::messages::prelude::*;
 #[impl_message(Message, KeyMapping)]
 #[derive(PartialEq, Eq, Clone, Debug, Hash, serde::Serialize, serde::Deserialize)]
 pub enum KeyMappingMessage {
+	// Sub-messages
 	#[child]
 	Lookup(InputMapperMessage),
-	#[child]
-	ModifyMapping(MappingVariant),
+
+	// Messages
+	ModifyMapping {
+		mapping: MappingVariant,
+	},
 }
 
-#[impl_message(Message, KeyMappingMessage, ModifyMapping)]
 #[derive(PartialEq, Eq, Clone, Debug, Default, Hash, serde::Serialize, serde::Deserialize)]
 pub enum MappingVariant {
 	#[default]

editor/src/messages/input_mapper/key_mapping/key_mapping_message_handler.rs

@@ -19,8 +19,11 @@ impl MessageHandler<KeyMappingMessage, KeyMappingMessageContext<'_>> for KeyMapp
 		let KeyMappingMessageContext { input, actions } = context;
 
 		match message {
+			// Sub-messages
 			KeyMappingMessage::Lookup(input_message) => self.mapping_handler.process_message(input_message, responses, InputMapperMessageContext { input, actions }),
-			KeyMappingMessage::ModifyMapping(new_layout) => self.mapping_handler.set_mapping(new_layout.into()),
+
+			// Messages
+			KeyMappingMessage::ModifyMapping { mapping } => self.mapping_handler.set_mapping(mapping.into()),
 		}
 	}
 	advertise_actions!();

editor/src/messages/input_mapper/key_mapping/mod.rs

@@ -2,6 +2,6 @@ mod key_mapping_message;
 mod key_mapping_message_handler;
 
 #[doc(inline)]
-pub use key_mapping_message::{KeyMappingMessage, KeyMappingMessageDiscriminant, MappingVariant, MappingVariantDiscriminant};
+pub use key_mapping_message::{KeyMappingMessage, KeyMappingMessageDiscriminant, MappingVariant};
 #[doc(inline)]
 pub use key_mapping_message_handler::{KeyMappingMessageContext, KeyMappingMessageHandler};