Refactor editor api to allow for future timeouts and side effect messages

Author: adamgerhant

desktop/wrapper/src/message_dispatcher.rs

@@ -65,9 +65,9 @@ impl<'a> DesktopWrapperMessageDispatcher<'a> {
 				.editor
 				.handle_message(EditorMessage::Batched {
 					messages: std::mem::take(&mut self.editor_message_queue).into_boxed_slice(),
-				})
-				.into_iter()
-				.filter_map(|m| intercept_frontend_message(self, m));
+				});
+				// .into_iter()
+				// .filter_map(|m| intercept_frontend_message(self, m));
 			frontend_messages.extend(current_frontend_messages);
 		}
 

editor/src/application.rs

@@ -1,8 +1,6 @@
 use crate::dispatcher::Dispatcher;
-use crate::messages::portfolio::document::node_graph::generate_node_graph_overlay::generate_node_graph_overlay;
+use crate::dispatcher::EditorOutput;
 use crate::messages::prelude::*;
-use graph_craft::document::{NodeInput, NodeNetwork};
-use graphene_std::node_graph_overlay::types::NodeGraphOverlayData;
 pub use graphene_std::uuid::*;
 
 // TODO: serialize with serde to save the current editor state
@@ -24,41 +22,13 @@ impl Editor {
 		(Self { dispatcher }, runtime)
 	}
 
-	pub fn handle_message<T: Into<Message>>(&mut self, message: T) -> Vec<FrontendMessage> {
-		self.dispatcher.handle_message(message, true);
-
-		std::mem::take(&mut self.dispatcher.responses)
+	pub fn handle_message<T: Into<Message>>(&mut self, message: T) -> Vec<EditorOutput> {
+		self.dispatcher.handle_message(message, true)
 	}
 
 	pub fn poll_node_graph_evaluation(&mut self, responses: &mut VecDeque<Message>) -> Result<(), String> {
 		self.dispatcher.poll_node_graph_evaluation(responses)
 	}
-
-	pub fn generate_node_graph_overlay_network(&mut self) -> Option<NodeNetwork> {
-		let Some(active_document) = self.dispatcher.message_handlers.portfolio_message_handler.active_document_mut() else {
-			return None;
-		};
-		let breadcrumb_network_path = &active_document.breadcrumb_network_path;
-		let nodes_to_render = active_document.network_interface.collect_nodes(
-			&active_document.node_graph_handler.node_graph_errors,
-			self.dispatcher.message_handlers.preferences_message_handler.graph_wire_style,
-			breadcrumb_network_path,
-		);
-		let previewed_node = active_document.network_interface.previewed_node(breadcrumb_network_path);
-		let node_graph_render_data = NodeGraphOverlayData {
-			nodes_to_render,
-			open: active_document.graph_view_overlay_open,
-			in_selected_network: &active_document.selection_network_path == breadcrumb_network_path,
-			previewed_node,
-		};
-		let opacity = active_document.graph_fade_artwork_percentage;
-		let node_graph_overlay_node = generate_node_graph_overlay(node_graph_render_data, opacity);
-		Some(NodeNetwork {
-			exports: vec![NodeInput::node(NodeId(0), 0)],
-			nodes: vec![(NodeId(0), node_graph_overlay_node)].into_iter().collect(),
-			..Default::default()
-		})
-	}
 }
 
 impl Default for Editor {

editor/src/dispatcher.rs

@@ -1,3 +1,7 @@
+use std::time::Duration;
+
+use interpreted_executor::ui_runtime::CompilationRequest;
+
 use crate::messages::debug::utility_types::MessageLoggingVerbosity;
 use crate::messages::defer::DeferMessageContext;
 use crate::messages::dialog::DialogMessageContext;
@@ -7,7 +11,6 @@ use crate::messages::prelude::*;
 #[derive(Debug, Default)]
 pub struct Dispatcher {
 	message_queues: Vec<VecDeque<Message>>,
-	pub responses: Vec<FrontendMessage>,
 	pub message_handlers: DispatcherMessageHandlers,
 }
 
@@ -28,6 +31,15 @@ pub struct DispatcherMessageHandlers {
 	tool_message_handler: ToolMessageHandler,
 }
 
+// Output messages are what the editor returns after processing Messages. It is handled by the scope outside the editor,
+// which has access to the node graph executor, frontend, etc
+pub enum EditorOutput {
+	// These messages perform some side effect other than updating the frontend, but outside the scope of the editor
+	RequestNativeNodeGraphRender { compilation_request: CompilationRequest },
+	RequestDeferredMessage { message: Box<Message>, timeout: Duration },
+	FrontendMessage { frontend_message: FrontendMessage },
+}
+
 impl DispatcherMessageHandlers {
 	pub fn with_executor(executor: crate::node_graph_executor::NodeGraphExecutor) -> Self {
 		Self {
@@ -41,7 +53,6 @@ impl DispatcherMessageHandlers {
 /// The last occurrence of the message in the message queue is sufficient to ensure correct behavior.
 /// In addition, these messages do not change any state in the backend (aside from caches).
 const SIDE_EFFECT_FREE_MESSAGES: &[MessageDiscriminant] = &[
-	MessageDiscriminant::Portfolio(PortfolioMessageDiscriminant::Document(DocumentMessageDiscriminant::NodeGraph(NodeGraphMessageDiscriminant::SendGraph))),
 	MessageDiscriminant::Portfolio(PortfolioMessageDiscriminant::Document(DocumentMessageDiscriminant::PropertiesPanel(
 		PropertiesPanelMessageDiscriminant::Refresh,
 	))),
@@ -93,12 +104,14 @@ impl Dispatcher {
 		}
 	}
 
-	pub fn handle_message<T: Into<Message>>(&mut self, message: T, process_after_all_current: bool) {
+	pub fn handle_message<T: Into<Message>>(&mut self, message: T, process_after_all_current: bool) -> Vec<EditorOutput> {
 		let message = message.into();
-
 		// If we are not maintaining the buffer, simply add to the current queue
 		Self::schedule_execution(&mut self.message_queues, process_after_all_current, [message]);
 
+		let mut side_effects = Vec::new();
+		let mut output_messages = Vec::new();
+
 		while let Some(message) = self.message_queues.last_mut().and_then(VecDeque::pop_front) {
 			// Skip processing of this message if it will be processed later (at the end of the shallowest level queue)
 			if SIDE_EFFECT_FREE_MESSAGES.contains(&message.to_discriminant()) {
@@ -148,20 +161,8 @@ impl Dispatcher {
 					self.message_handlers.dialog_message_handler.process_message(message, &mut queue, context);
 				}
 				Message::Frontend(message) => {
-					// Handle these messages immediately by returning early
-					if let FrontendMessage::TriggerFontLoad { .. } = message {
-						self.responses.push(message);
-						self.cleanup_queues(false);
-
-						// Return early to avoid running the code after the match block
-						return;
-					} else {
-						// `FrontendMessage`s are saved and will be sent to the frontend after the message queue is done being processed
-						// Deduplicate the render native node graph messages. TODO: Replace responses with hashset
-						if !(message == FrontendMessage::RequestNativeNodeGraphRender && self.responses.contains(&FrontendMessage::RequestNativeNodeGraphRender)) {
-							self.responses.push(message);
-						}
-					}
+					// `FrontendMessage`s are saved and will be sent to the frontend after the message queue is done being processed
+					output_messages.push(EditorOutput::FrontendMessage { frontend_message: message });
 				}
 				Message::Globals(message) => {
 					self.message_handlers.globals_message_handler.process_message(message, &mut queue, ());
@@ -213,14 +214,19 @@ impl Dispatcher {
 				Message::Preferences(message) => {
 					self.message_handlers.preferences_message_handler.process_message(message, &mut queue, ());
 				}
+				Message::SideEffect(message) => {
+					if !side_effects.contains(&message) {
+						side_effects.push(message);
+					}
+				}
 				Message::Tool(message) => {
 					let Some(document_id) = self.message_handlers.portfolio_message_handler.active_document_id() else {
 						warn!("Called ToolMessage without an active document.\nGot {message:?}");
-						return;
+						return Vec::new();
 					};
 					let Some(document) = self.message_handlers.portfolio_message_handler.documents.get_mut(&document_id) else {
 						warn!("Called ToolMessage with an invalid active document.\nGot {message:?}");
-						return;
+						return Vec::new();
 					};
 
 					let context = ToolMessageContext {
@@ -236,7 +242,9 @@ impl Dispatcher {
 				}
 				Message::NoOp => {}
 				Message::Batched { messages } => {
-					messages.iter().for_each(|message| self.handle_message(message.to_owned(), false));
+					for nested_outputs in messages.into_iter().map(|message| self.handle_message(message, false)) {
+						output_messages.extend(nested_outputs);
+					}
 				}
 			}
 
@@ -247,6 +255,12 @@ impl Dispatcher {
 
 			self.cleanup_queues(false);
 		}
+
+		// The full message tree has been processed, so the side effects can be processed
+		for message in side_effects {
+			output_messages.extend(self.handle_side_effect(message));
+		}
+		output_messages
 	}
 
 	pub fn collect_actions(&self) -> ActionList {
@@ -314,6 +328,7 @@ impl Dispatcher {
 
 #[cfg(test)]
 mod test {
+	use crate::messages::side_effects::EditorOutputMessage;
 	pub use crate::test_utils::test_prelude::*;
 
 	/// Create an editor with three layers
@@ -513,7 +528,10 @@ mod test {
 
 			for response in responses {
 				// Check for the existence of the file format incompatibility warning dialog after opening the test file
-				if let FrontendMessage::UpdateDialogColumn1 { layout_target: _, diff } = response {
+				if let EditorOutputMessage::FrontendMessage {
+					frontend_message: FrontendMessage::UpdateDialogColumn1 { layout_target: _, diff },
+				} = response
+				{
 					if let DiffUpdate::SubLayout(sub_layout) = &diff[0].new_value {
 						if let LayoutGroup::Row { widgets } = &sub_layout[0] {
 							if let Widget::TextLabel(TextLabel { value, .. }) = &widgets[0].widget {

editor/src/messages/frontend/frontend_message.rs

@@ -267,7 +267,6 @@ pub enum FrontendMessage {
 	UpdateMouseCursor {
 		cursor: MouseCursorIcon,
 	},
-	RequestNativeNodeGraphRender,
 	UpdateNativeNodeGraphSVG {
 		#[serde(rename = "svgString")]
 		svg_string: String,
@@ -293,6 +292,10 @@ pub enum FrontendMessage {
 		layout_target: LayoutTarget,
 		diff: Vec<WidgetDiff>,
 	},
+	UpdateTooltip {
+		position: Option<FrontendXY>,
+		text: String,
+	},
 	UpdateToolOptionsLayout {
 		#[serde(rename = "layoutTarget")]
 		layout_target: LayoutTarget,

editor/src/messages/message.rs

@@ -1,4 +1,4 @@
-use crate::messages::prelude::*;
+use crate::messages::{prelude::*, side_effects::{SideEffectMessage}};
 use graphite_proc_macros::*;
 
 #[impl_message]
@@ -18,6 +18,8 @@ pub enum Message {
 	#[child]
 	Dialog(DialogMessage),
 	#[child]
+	SideEffect(SideEffectMessage),
+	#[child]
 	Frontend(FrontendMessage),
 	#[child]
 	Globals(GlobalsMessage),

editor/src/messages/mod.rs

@@ -15,4 +15,5 @@ pub mod message;
 pub mod portfolio;
 pub mod preferences;
 pub mod prelude;
+pub mod side_effects;
 pub mod tool;

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

@@ -1481,7 +1481,8 @@ impl MessageHandler<DocumentMessage, DocumentMessageContext<'_>> for DocumentMes
 							x: transform.translation.x,
 							y: transform.translation.y,
 						},
-					})
+					});
+					responses.add(NodeGraphMessage::PointerMove { shift: Key::Shift });
 				}
 			}
 			DocumentMessage::SelectionStepBack => {

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

@@ -214,6 +214,7 @@ pub enum NodeGraphMessage {
 	SetLockedOrVisibilitySideEffects {
 		node_ids: Vec<NodeId>,
 	},
+	TryDisplayTooltip,
 	UpdateBoxSelection,
 	UpdateImportsExports,
 	UpdateLayerPanel,

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

@@ -15,6 +15,7 @@ use crate::messages::portfolio::document::utility_types::network_interface::{
 use crate::messages::portfolio::document::utility_types::nodes::{CollapsedLayers, LayerPanelEntry};
 use crate::messages::portfolio::document::utility_types::wires::{GraphWireStyle, WirePathInProgress, build_vector_wire};
 use crate::messages::prelude::*;
+use crate::messages::side_effects::SideEffectMessage;
 use crate::messages::tool::common_functionality::auto_panning::AutoPanning;
 use crate::messages::tool::common_functionality::graph_modification_utils::get_clip_mode;
 use crate::messages::tool::common_functionality::utility_functions::make_path_editable_is_allowed;
@@ -30,6 +31,7 @@ use graphene_std::*;
 use kurbo::{DEFAULT_ACCURACY, Shape};
 use renderer::Quad;
 use std::cmp::Ordering;
+use std::time::Duration;
 
 #[derive(Debug, ExtractField)]
 pub struct NodeGraphMessageContext<'a> {
@@ -92,6 +94,10 @@ pub struct NodeGraphMessageHandler {
 	reordering_export: Option<usize>,
 	/// The end index of the moved connector
 	end_index: Option<usize>,
+	// If an input is being hovered. Used for tooltip
+	hovering_input: bool,
+	// If an output is being hovered. Used for tooltip
+	hovering_output: bool,
 }
 
 /// NodeGraphMessageHandler always modifies the network which the selected nodes are in. No GraphOperationMessages should be added here, since those messages will always affect the document network.
@@ -1141,6 +1147,31 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphMessageContext<'a>> for NodeG
 							.unwrap_or_else(|| modify_import_export.reorder_imports_exports.input_ports().count() + 1),
 					);
 					responses.add(FrontendMessage::UpdateExportReorderIndex { index: self.end_index });
+				} else if !self.hovering_input && !self.hovering_output {
+					if network_interface.input_connector_from_click(ipp.mouse.position, breadcrumb_network_path).is_some() {
+						self.hovering_input = true;
+						responses.add(SideEffectMessage::RequestDeferredMessage {
+							message: Box::new(NodeGraphMessage::TryDisplayTooltip.into()),
+							timeout: Duration::from_millis(800),
+						});
+					}
+					if network_interface.output_connector_from_click(ipp.mouse.position, breadcrumb_network_path).is_some() {
+						self.hovering_output = true;
+						responses.add(SideEffectMessage::RequestDeferredMessage {
+							message: Box::new(NodeGraphMessage::TryDisplayTooltip.into()),
+							timeout: Duration::from_millis(800),
+						})
+					}
+				} else if self.hovering_input {
+					if !network_interface.input_connector_from_click(ipp.mouse.position, breadcrumb_network_path).is_some() {
+						self.hovering_input = false;
+						responses.add(FrontendMessage::UpdateTooltip { position: None, text: String::new() });
+					}
+				} else if self.hovering_output {
+					if !network_interface.output_connector_from_click(ipp.mouse.position, breadcrumb_network_path).is_some() {
+						self.hovering_output = false;
+						responses.add(FrontendMessage::UpdateTooltip { position: None, text: String::new() });
+					}
 				}
 			}
 			NodeGraphMessage::PointerUp => {
@@ -1594,7 +1625,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphMessageContext<'a>> for NodeG
 				responses.add(PropertiesPanelMessage::Refresh);
 				responses.add(NodeGraphMessage::UpdateActionButtons);
 
-				responses.add(FrontendMessage::RequestNativeNodeGraphRender);
+				responses.add(SideEffectMessage::RenderNodeGraph);
 				responses.add(NodeGraphMessage::UpdateImportsExports);
 				self.update_node_graph_hints(responses);
 			}
@@ -1820,6 +1851,36 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphMessageContext<'a>> for NodeG
 
 				responses.add(PropertiesPanelMessage::Refresh);
 			}
+			NodeGraphMessage::TryDisplayTooltip => {
+				if let Some(input) = network_interface.input_connector_from_click(ipp.mouse.position, breadcrumb_network_path) {
+					let text = network_interface.input_tooltip_text(&input, breadcrumb_network_path);
+					if let Some(position) = network_interface.input_position(&input, breadcrumb_network_path) {
+						let Some(network_metadata) = network_interface.network_metadata(breadcrumb_network_path) else {
+							return;
+						};
+						let position = network_metadata.persistent_metadata.navigation_metadata.node_graph_to_viewport.transform_point2(position);
+						let xy = FrontendXY {
+							x: position.x as i32,
+							y: position.y as i32,
+						};
+						responses.add(FrontendMessage::UpdateTooltip { position: Some(xy), text });
+					}
+				} else if let Some(output) = network_interface.output_connector_from_click(ipp.mouse.position, breadcrumb_network_path) {
+					let text = network_interface.output_tooltip_text(&output, breadcrumb_network_path);
+					if let Some(position) = network_interface.output_position(&output, breadcrumb_network_path) {
+						let Some(network_metadata) = network_interface.network_metadata(breadcrumb_network_path) else {
+							return;
+						};
+						let position = network_metadata.persistent_metadata.navigation_metadata.node_graph_to_viewport.transform_point2(position);
+
+						let xy = FrontendXY {
+							x: position.x as i32,
+							y: position.y as i32,
+						};
+						responses.add(FrontendMessage::UpdateTooltip { position: Some(xy), text });
+					}
+				}
+			}
 			NodeGraphMessage::UpdateBoxSelection => {
 				if let Some((box_selection_start, _)) = self.box_selection_start {
 					// The mouse button was released but we missed the pointer up event
@@ -2559,6 +2620,8 @@ impl Default for NodeGraphMessageHandler {
 			reordering_export: None,
 			reordering_import: None,
 			end_index: None,
+			hovering_input: false,
+			hovering_output: false,
 		}
 	}
 }

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

@@ -1024,13 +1024,6 @@ pub fn get_document_node<'a>(node_id: NodeId, context: &'a NodePropertiesContext
 	network.nodes.get(&node_id).ok_or(format!("node {node_id} not found in get_document_node"))
 }
 
-pub fn query_node_and_input_info<'a>(node_id: NodeId, input_index: usize, context: &'a mut NodePropertiesContext<'a>) -> Result<(&'a DocumentNode, String, String), String> {
-	let (name, description) = context.network_interface.displayed_input_name_and_description(&node_id, input_index, context.selection_network_path);
-	let document_node = get_document_node(node_id, context)?;
-
-	Ok((document_node, name, description))
-}
-
 pub fn query_noise_pattern_state(node_id: NodeId, context: &NodePropertiesContext) -> Result<(bool, bool, bool, bool, bool, bool), String> {
 	let document_node = get_document_node(node_id, context)?;
 	let current_noise_type = document_node.inputs.iter().find_map(|input| match input.as_value() {