Generate a visualization of the editor's hierarchical message system tree

editor/src/messages/animation/animation_message_handler.rs

@@ -24,7 +24,7 @@ enum AnimationState {
 	},
 }
 
-#[derive(Default, Debug, Clone, PartialEq)]
+#[derive(Default, Debug, Clone, PartialEq, ExtractField)]
 pub struct AnimationMessageHandler {
 	/// Used to re-send the UI on the next frame after playback starts
 	live_preview_recently_zero: bool,
@@ -57,6 +57,7 @@ impl AnimationMessageHandler {
 	}
 }
 
+#[message_handler_data]
 impl MessageHandler<AnimationMessage, ()> for AnimationMessageHandler {
 	fn process_message(&mut self, message: AnimationMessage, responses: &mut VecDeque<Message>, _data: ()) {
 		match message {

editor/src/messages/broadcast/broadcast_message_handler.rs

@@ -1,10 +1,11 @@
 use crate::messages::prelude::*;
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, ExtractField)]
 pub struct BroadcastMessageHandler {
 	listeners: HashMap<BroadcastEvent, Vec<Message>>,
 }
 
+#[message_handler_data]
 impl MessageHandler<BroadcastMessage, ()> for BroadcastMessageHandler {
 	fn process_message(&mut self, message: BroadcastMessage, responses: &mut VecDeque<Message>, _data: ()) {
 		match message {

editor/src/messages/debug/debug_message_handler.rs

@@ -1,11 +1,12 @@
 use super::utility_types::MessageLoggingVerbosity;
 use crate::messages::prelude::*;
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, ExtractField)]
 pub struct DebugMessageHandler {
 	pub message_logging_verbosity: MessageLoggingVerbosity,
 }
 
+#[message_handler_data]
 impl MessageHandler<DebugMessage, ()> for DebugMessageHandler {
 	fn process_message(&mut self, message: DebugMessage, responses: &mut VecDeque<Message>, _data: ()) {
 		match message {

editor/src/messages/debug/mod.rs

@@ -3,6 +3,8 @@ mod debug_message_handler;
 
 pub mod utility_types;
 
+pub use utility_types::DebugMessageTree;
+
 #[doc(inline)]
 pub use debug_message::{DebugMessage, DebugMessageDiscriminant};
 #[doc(inline)]

editor/src/messages/debug/utility_types.rs

@@ -5,3 +5,84 @@ pub enum MessageLoggingVerbosity {
 	Names,
 	Contents,
 }
+
+#[derive(Debug)]
+pub struct MessageData {
+	name: String,
+	fields: Vec<String>,
+}
+
+impl MessageData {
+	pub fn name(&self) -> &str {
+		&self.name
+	}
+
+	pub fn fields(&self) -> &Vec<String> {
+		&self.fields
+	}
+}
+
+#[derive(Debug)]
+pub struct DebugMessageTree {
+	name: String,
+	variants: Option<Vec<DebugMessageTree>>,
+	message_handler: Option<MessageData>,
+	message_handler_data: Option<MessageData>,
+}
+
+impl DebugMessageTree {
+	pub fn new(name: &str) -> DebugMessageTree {
+		DebugMessageTree {
+			name: name.to_string(),
+			variants: None,
+			message_handler: None,
+			message_handler_data: None,
+		}
+	}
+
+	pub fn add_variant(&mut self, variant: DebugMessageTree) {
+		if let Some(variants) = &mut self.variants {
+			variants.push(variant);
+		} else {
+			self.variants = Some(vec![variant]);
+		}
+	}
+
+	pub fn add_message_handler_data_field(&mut self, name: String, fields: Vec<String>) {
+		self.message_handler_data = Some(MessageData { name, fields });
+	}
+
+	pub fn add_message_handler_field(&mut self, name: String, fields: Vec<String>) {
+		self.message_handler = Some(MessageData { name, fields });
+	}
+
+	pub fn name(&self) -> &str {
+		&self.name
+	}
+
+	pub fn variants(&self) -> Option<&Vec<DebugMessageTree>> {
+		self.variants.as_ref()
+	}
+
+	pub fn message_handler_data_fields(&self) -> Option<&MessageData> {
+		self.message_handler_data.as_ref()
+	}
+
+	pub fn message_handler_fields(&self) -> Option<&MessageData> {
+		self.message_handler.as_ref()
+	}
+
+	pub fn has_message_handler_data_fields(&self) -> bool {
+		match self.message_handler_data_fields() {
+			Some(_) => true,
+			None => false,
+		}
+	}
+
+	pub fn has_message_handler_fields(&self) -> bool {
+		match self.message_handler_fields() {
+			Some(_) => true,
+			None => false,
+		}
+	}
+}

editor/src/messages/dialog/dialog_message_handler.rs

@@ -2,19 +2,21 @@ use super::simple_dialogs::{self, AboutGraphiteDialog, ComingSoonDialog, DemoArt
 use crate::messages::layout::utility_types::widget_prelude::*;
 use crate::messages::prelude::*;
 
+#[derive(ExtractField)]
 pub struct DialogMessageData<'a> {
 	pub portfolio: &'a PortfolioMessageHandler,
 	pub preferences: &'a PreferencesMessageHandler,
 }
 
 /// Stores the dialogs which require state. These are the ones that have their own message handlers, and are not the ones defined in `simple_dialogs`.
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Default, Clone, ExtractField)]
 pub struct DialogMessageHandler {
 	export_dialog: ExportDialogMessageHandler,
 	new_document_dialog: NewDocumentDialogMessageHandler,
 	preferences_dialog: PreferencesDialogMessageHandler,
 }
 
+#[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;

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

@@ -3,12 +3,13 @@ use crate::messages::layout::utility_types::widget_prelude::*;
 use crate::messages::portfolio::document::utility_types::document_metadata::LayerNodeIdentifier;
 use crate::messages::prelude::*;
 
+#[derive(ExtractField)]
 pub struct ExportDialogMessageData<'a> {
 	pub portfolio: &'a PortfolioMessageHandler,
 }
 
 /// A dialog to allow users to customize their file export.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, ExtractField)]
 pub struct ExportDialogMessageHandler {
 	pub file_type: FileType,
 	pub scale_factor: f64,
@@ -31,6 +32,7 @@ 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;

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

@@ -4,13 +4,14 @@ use glam::{IVec2, UVec2};
 use graph_craft::document::NodeId;
 
 /// A dialog to allow users to set some initial options about a new document.
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, ExtractField)]
 pub struct NewDocumentDialogMessageHandler {
 	pub name: String,
 	pub infinite: bool,
 	pub dimensions: UVec2,
 }
 
+#[message_handler_data]
 impl MessageHandler<NewDocumentDialogMessage, ()> for NewDocumentDialogMessageHandler {
 	fn process_message(&mut self, message: NewDocumentDialogMessage, responses: &mut VecDeque<Message>, _data: ()) {
 		match message {

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

@@ -4,14 +4,16 @@ use crate::messages::portfolio::document::node_graph::utility_types::GraphWireSt
 use crate::messages::preferences::SelectionMode;
 use crate::messages::prelude::*;
 
+#[derive(ExtractField)]
 pub struct PreferencesDialogMessageData<'a> {
 	pub preferences: &'a PreferencesMessageHandler,
 }
 
 /// A dialog to allow users to customize Graphite editor options
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, ExtractField)]
 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;

editor/src/messages/globals/globals_message_handler.rs

@@ -1,8 +1,9 @@
 use crate::messages::prelude::*;
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, ExtractField)]
 pub struct GlobalsMessageHandler {}
 
+#[message_handler_data]
 impl MessageHandler<GlobalsMessage, ()> for GlobalsMessageHandler {
 	fn process_message(&mut self, message: GlobalsMessage, _responses: &mut VecDeque<Message>, _data: ()) {
 		match message {

editor/src/messages/input_mapper/input_mapper_message_handler.rs

@@ -5,16 +5,18 @@ use crate::messages::portfolio::utility_types::KeyboardPlatformLayout;
 use crate::messages::prelude::*;
 use std::fmt::Write;
 
+#[derive(ExtractField)]
 pub struct InputMapperMessageData<'a> {
 	pub input: &'a InputPreprocessorMessageHandler,
 	pub actions: ActionList,
 }
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, ExtractField)]
 pub struct InputMapperMessageHandler {
 	mapping: Mapping,
 }
 
+#[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;

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

@@ -2,16 +2,18 @@ use crate::messages::input_mapper::input_mapper_message_handler::InputMapperMess
 use crate::messages::input_mapper::utility_types::input_keyboard::KeysGroup;
 use crate::messages::prelude::*;
 
+#[derive(ExtractField)]
 pub struct KeyMappingMessageData<'a> {
 	pub input: &'a InputPreprocessorMessageHandler,
 	pub actions: ActionList,
 }
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, ExtractField)]
 pub struct KeyMappingMessageHandler {
 	mapping_handler: InputMapperMessageHandler,
 }
 
+#[message_handler_data]
 impl MessageHandler<KeyMappingMessage, KeyMappingMessageData<'_>> for KeyMappingMessageHandler {
 	fn process_message(&mut self, message: KeyMappingMessage, responses: &mut VecDeque<Message>, data: KeyMappingMessageData) {
 		let KeyMappingMessageData { input, actions } = data;

editor/src/messages/input_preprocessor/input_preprocessor_message_handler.rs

@@ -6,11 +6,12 @@ use crate::messages::prelude::*;
 use glam::DVec2;
 use std::time::Duration;
 
+#[derive(ExtractField)]
 pub struct InputPreprocessorMessageData {
 	pub keyboard_platform: KeyboardPlatformLayout,
 }
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, ExtractField)]
 pub struct InputPreprocessorMessageHandler {
 	pub frame_time: FrameTimeInfo,
 	pub time: u64,
@@ -19,6 +20,7 @@ pub struct InputPreprocessorMessageHandler {
 	pub viewport_bounds: ViewportBounds,
 }
 
+#[message_handler_data]
 impl MessageHandler<InputPreprocessorMessage, InputPreprocessorMessageData> for InputPreprocessorMessageHandler {
 	fn process_message(&mut self, message: InputPreprocessorMessage, responses: &mut VecDeque<Message>, data: InputPreprocessorMessageData) {
 		let InputPreprocessorMessageData { keyboard_platform } = data;

editor/src/messages/layout/layout_message_handler.rs

@@ -6,7 +6,7 @@ use graphene_core::text::Font;
 use graphene_std::vector::style::{FillChoice, GradientStops};
 use serde_json::Value;
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, ExtractField)]
 pub struct LayoutMessageHandler {
 	layouts: [Layout; LayoutTarget::LayoutTargetLength as usize],
 }
@@ -338,6 +338,7 @@ impl LayoutMessageHandler {
 	}
 }
 
+#[message_handler_data(CustomData)]
 impl<F: Fn(&MessageDiscriminant) -> Vec<KeysGroup>> MessageHandler<LayoutMessage, F> for LayoutMessageHandler {
 	fn process_message(&mut self, message: LayoutMessage, responses: &mut std::collections::VecDeque<Message>, action_input_mapping: F) {
 		match message {
@@ -438,3 +439,7 @@ impl LayoutMessageHandler {
 		responses.add(message);
 	}
 }
+
+pub fn custom_data() -> Vec<String> {
+	vec![String::from("Fn(&MessageDiscriminant) -> Vec<KeysGroup>")]
+}

editor/src/messages/message.rs

@@ -45,3 +45,71 @@ impl specta::Type for MessageDiscriminant {
 		specta::DataType::Any
 	}
 }
+
+#[cfg(test)]
+mod test {
+	use super::*;
+
+	#[test]
+	fn generate_message_tree() {
+		let res = Message::build_message_tree();
+		println!("{}", res.name());
+		if let Some(variants) = res.variants() {
+			for (i, variant) in variants.iter().enumerate() {
+				let is_last = i == variants.len() - 1;
+				print_tree_node(variant, "", is_last);
+			}
+		}
+	}
+
+	fn print_tree_node(tree: &DebugMessageTree, prefix: &str, is_last: bool) {
+		// Print the current node
+		let (branch, child_prefix) = if tree.has_message_handler_data_fields() || tree.has_message_handler_fields() {
+			("├── ", format!("{}│   ", prefix))
+		} else {
+			if is_last {
+				("└── ", format!("{}    ", prefix))
+			} else {
+				("├── ", format!("{}│   ", prefix))
+			}
+		};
+
+		println!("{}{}{}", prefix, branch, tree.name());
+
+		// Print children if any
+		if let Some(variants) = tree.variants() {
+			let len = variants.len();
+			for (i, variant) in variants.iter().enumerate() {
+				let is_last_child = i == len - 1;
+				print_tree_node(variant, &child_prefix, is_last_child);
+			}
+		}
+
+		// Print handler field if any
+		if let Some(data) = tree.message_handler_fields() {
+			let len = data.fields().len();
+			let (branch, child_prefix) = if tree.has_message_handler_data_fields() {
+				("├── ", format!("{}│   ", prefix))
+			} else {
+				("└── ", format!("{}    ", prefix))
+			};
+			println!("{}{}{}", prefix, branch, data.name());
+			for (i, field) in data.fields().iter().enumerate() {
+				let is_last_field = i == len - 1;
+				let branch = if is_last_field { "└── " } else { "├── " };
+				println!("{}{}{}", child_prefix, branch, field);
+			}
+		}
+
+		// Print data field if any
+		if let Some(data) = tree.message_handler_data_fields() {
+			let len = data.fields().len();
+			println!("{}{}{}", prefix, "└── ", data.name());
+			for (i, field) in data.fields().iter().enumerate() {
+				let is_last_field = i == len - 1;
+				let branch = if is_last_field { "└── " } else { "├── " };
+				println!("{}{}{}", format!("{}    ", prefix), branch, field);
+			}
+		}
+	}
+}