Context nullification, cached monitor nodes

Author: adamgerhant

editor/src/dispatcher.rs

@@ -5,8 +5,10 @@ use crate::messages::prelude::*;
 
 #[derive(Debug, Default)]
 pub struct Dispatcher {
-	buffered_queue: Vec<Message>,
-	queueing_messages: bool,
+	evaluation_queue: Vec<Message>,
+	introspection_queue: Vec<Message>,
+	queueing_evaluation_messages: bool,
+	queueing_introspection_messages: bool,
 	message_queues: Vec<VecDeque<Message>>,
 	pub responses: Vec<FrontendMessage>,
 	pub message_handlers: DispatcherMessageHandlers,
@@ -41,6 +43,9 @@ 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::CompileActiveDocument),
+	MessageDiscriminant::Portfolio(PortfolioMessageDiscriminant::EvaluateActiveDocument),
+	MessageDiscriminant::Portfolio(PortfolioMessageDiscriminant::IntrospectActiveDocument),
 	MessageDiscriminant::Portfolio(PortfolioMessageDiscriminant::Document(DocumentMessageDiscriminant::PropertiesPanel(
 		PropertiesPanelMessageDiscriminant::Refresh,
 	))),
@@ -91,13 +96,6 @@ 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 queue if it exists (except from the end queue message)
-		if !matches!(message, Message::EndQueue) {
-			if self.queueing_messages {
-				self.buffered_queue.push(message);
-				return;
-			}
-		}
 
 		// 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]);
@@ -117,7 +115,21 @@ impl Dispatcher {
 					continue;
 				}
 			}
+			// Add all messages to the queue if queuing messages (except from the end queue message)
+			if !matches!(message, Message::EndEvaluationQueue) {
+				if self.queueing_evaluation_messages {
+					self.evaluation_queue.push(message);
+					return;
+				}
+			}
 
+			// Add all messages to the queue if queuing messages (except from the end queue message)
+			if !matches!(message, Message::EndIntrospectionQueue) {
+				if self.queueing_introspection_messages {
+					self.introspection_queue.push(message);
+					return;
+				}
+			}
 			// Print the message at a verbosity level of `info`
 			self.log_message(&message, &self.message_queues, self.message_handlers.debug_message_handler.message_logging_verbosity);
 
@@ -126,22 +138,40 @@ 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::StartQueue => {
-					self.queueing_messages = true;
+				Message::StartEvaluationQueue => {
+					self.queueing_evaluation_messages = true;
 				}
-				Message::EndQueue => {
-					self.queueing_messages = false;
+				Message::EndEvaluationQueue => {
+					self.queueing_evaluation_messages = false;
 				}
-				Message::ProcessQueue((render_output_metadata, introspected_inputs)) => {
-					let message = PortfolioMessage::ProcessEvaluationResponse {
+				Message::ProcessEvaluationQueue(render_output_metadata) => {
+					let update_message = PortfolioMessage::ProcessEvaluationResponse {
 						evaluation_metadata: render_output_metadata,
-						introspected_inputs,
-					};
-					// Add the message to update the state with the render output
-					Self::schedule_execution(&mut self.message_queues, true, [message]);
+					}
+					.into();
+					// Update the state with the render output and introspected inputs
+					Self::schedule_execution(&mut self.message_queues, true, [update_message]);
+
+					// Schedule all queued messages to be run, which use the introspected inputs (in the order they were added)
+					Self::schedule_execution(&mut self.message_queues, true, std::mem::take(&mut self.evaluation_queue));
+				}
+				Message::StartIntrospectionQueue => {
+					self.queueing_introspection_messages = true;
+				}
+				Message::EndIntrospectionQueue => {
+					self.queueing_introspection_messages = false;
+				}
+				Message::ProcessIntrospectionQueue(introspected_inputs) => {
+					let update_message = PortfolioMessage::ProcessIntrospectionResponse { introspected_inputs }.into();
+					// Update the state with the render output and introspected inputs
+					Self::schedule_execution(&mut self.message_queues, true, [update_message]);
+
+					// Schedule all queued messages to be run, which use the introspected inputs (in the order they were added)
+					Self::schedule_execution(&mut self.message_queues, true, std::mem::take(&mut self.introspection_queue));
 
-					// Schedule all queued messages to be run (in the order they were added)
-					Self::schedule_execution(&mut self.message_queues, true, std::mem::take(&mut self.buffered_queue));
+					let clear_message = PortfolioMessage::ClearIntrospectedData.into();
+					// Clear the introspected inputs since they are no longer required, and will cause a memory leak if not removed
+					Self::schedule_execution(&mut self.message_queues, true, [clear_message]);
 				}
 				Message::NoOp => {}
 				Message::Init => {

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

@@ -43,7 +43,7 @@ impl MessageHandler<ExportDialogMessage, ExportDialogMessageContext<'_>> for Exp
 			ExportDialogMessage::TransparentBackground(transparent_background) => self.transparent_background = transparent_background,
 			ExportDialogMessage::ExportBounds(export_area) => self.bounds = export_area,
 
-			ExportDialogMessage::Submit => responses.add_front(PortfolioMessage::ActiveDocumentExport {
+			ExportDialogMessage::Submit => responses.add_front(PortfolioMessage::ExportActiveDocument {
 				file_name: portfolio.active_document().map(|document| document.name.clone()).unwrap_or_default(),
 				file_type: self.file_type,
 				scale_factor: self.scale_factor,

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

@@ -1,7 +1,7 @@
 use crate::messages::layout::utility_types::widget_prelude::*;
 use crate::messages::prelude::*;
 use glam::{IVec2, UVec2};
-use graph_craft::document::NodeId;
+use graphene_std::uuid::NodeId;
 
 /// A dialog to allow users to set some initial options about a new document.
 #[derive(Debug, Clone, Default, ExtractField)]
@@ -24,17 +24,14 @@ impl MessageHandler<NewDocumentDialogMessage, ()> for NewDocumentDialogMessageHa
 
 				let create_artboard = !self.infinite && self.dimensions.x > 0 && self.dimensions.y > 0;
 				if create_artboard {
-					responses.add(Message::StartQueue);
 					responses.add(GraphOperationMessage::NewArtboard {
 						id: NodeId::new(),
 						artboard: graphene_std::Artboard::new(IVec2::ZERO, self.dimensions.as_ivec2()),
 					});
 				}
-
-				// TODO: Figure out how to get StartBuffer to work here so we can delete this and use `DocumentMessage::ZoomCanvasToFitAll` instead
-				// Currently, it is necessary to use `FrontendMessage::TriggerDelayedZoomCanvasToFitAll` rather than `DocumentMessage::ZoomCanvasToFitAll` because the size of the viewport is not yet populated
-				responses.add(Message::StartQueue);
-				responses.add(FrontendMessage::TriggerDelayedZoomCanvasToFitAll);
+				responses.add(Message::StartEvaluationQueue);
+				responses.add(DocumentMessage::ZoomCanvasToFitAll);
+				responses.add(Message::EndEvaluationQueue);
 				responses.add(DocumentMessage::DeselectAllLayers);
 			}
 		}

editor/src/messages/frontend/frontend_message.rs

@@ -7,7 +7,7 @@ use crate::messages::portfolio::document::utility_types::nodes::{JsRawBuffer, La
 use crate::messages::portfolio::document::utility_types::wires::{WirePath, WirePathUpdate};
 use crate::messages::prelude::*;
 use crate::messages::tool::utility_types::HintData;
-use graph_craft::document::NodeId;
+use graphene_std::uuid::NodeId;
 use graphene_std::raster::color::Color;
 use graphene_std::text::Font;
 

editor/src/messages/input_preprocessor/input_preprocessor_message_handler.rs

@@ -3,8 +3,7 @@ use crate::messages::input_mapper::utility_types::input_mouse::{MouseButton, Mou
 use crate::messages::input_mapper::utility_types::misc::FrameTimeInfo;
 use crate::messages::portfolio::utility_types::KeyboardPlatformLayout;
 use crate::messages::prelude::*;
-use glam::DVec2;
-use std::time::Duration;
+use glam::{DAffine2, DVec2};
 
 #[derive(ExtractField)]
 pub struct InputPreprocessorMessageContext {

editor/src/messages/message.rs

@@ -1,27 +1,24 @@
-use std::sync::Arc;
-
-use crate::messages::prelude::*;
-use graphene_std::{IntrospectMode, uuid::CompiledProtonodeInput};
+use crate::{messages::prelude::*, node_graph_executor::IntrospectionResponse};
 use graphite_proc_macros::*;
 
 #[impl_message]
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
 pub enum Message {
 	NoOp,
 	Init,
 	Batched(Box<[Message]>),
 	// Adds any subsequent messages to the queue
-	StartQueue,
+	StartEvaluationQueue,
 	// Stop adding messages to the queue.
-	EndQueue,
-	// Processes all messages that are queued, which occurs on the evaluation response. This allows a message to be run with data from after the evaluation is complete
-	ProcessQueue(
-		(
-			graphene_std::renderer::RenderMetadata,
-			Vec<(CompiledProtonodeInput, IntrospectMode, Box<dyn std::any::Any + Send + Sync>)>,
-		),
-	),
-
+	EndEvaluationQueue,
+	// Processes all messages that are queued to be run after evaluation, which occurs on the evaluation response. This allows a message to be run with data from after the evaluation is complete
+	#[serde(skip)]
+	ProcessEvaluationQueue(graphene_std::renderer::RenderMetadata),
+	StartIntrospectionQueue,
+	EndIntrospectionQueue,
+	// Processes all messages that are queued to be run after introspection, which occurs on the evaluation response. This allows a message to be run with data from after the evaluation is complete
+	#[serde(skip)]
+	ProcessIntrospectionQueue(IntrospectionResponse),
 	#[child]
 	Animation(AnimationMessage),
 	#[child]

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

@@ -7,11 +7,10 @@ use crate::messages::portfolio::document::utility_types::misc::{AlignAggregate,
 use crate::messages::portfolio::utility_types::PanelType;
 use crate::messages::prelude::*;
 use glam::DAffine2;
-use graphene_std::uuid::CompiledProtonodeInput;
+use graphene_std::vector::click_target::ClickTarget;
 use graphene_std::Color;
 use graphene_std::raster::BlendMode;
 use graphene_std::raster::Image;
-use graphene_std::renderer::ClickTarget;
 use graphene_std::transform::Footprint;
 use graphene_std::uuid::NodeId;
 use graphene_std::vector::style::ViewMode;

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

@@ -3,7 +3,7 @@ use super::node_graph::utility_types::Transform;
 use super::overlays::utility_types::Pivot;
 use super::utility_types::error::EditorError;
 use super::utility_types::misc::{GroupFolderType, SNAP_FUNCTIONS_FOR_BOUNDING_BOXES, SNAP_FUNCTIONS_FOR_PATHS, SnappingOptions, SnappingState};
-use super::utility_types::network_interface::{self, NodeNetworkInterface, TransactionStatus};
+use super::utility_types::network_interface::{NodeNetworkInterface, TransactionStatus};
 use super::utility_types::nodes::{CollapsedLayers, SelectedNodes};
 use crate::application::{GRAPHITE_GIT_COMMIT_HASH, generate_uuid};
 use crate::consts::{ASYMPTOTIC_EFFECT, COLOR_OVERLAY_GRAY, DEFAULT_DOCUMENT_NAME, FILE_SAVE_SUFFIX, SCALE_EFFECT, SCROLLBAR_SPACING, VIEWPORT_ROTATE_SNAP_INTERVAL};
@@ -13,22 +13,20 @@ use crate::messages::portfolio::document::graph_operation::utility_types::Transf
 use crate::messages::portfolio::document::node_graph::NodeGraphMessageContext;
 use crate::messages::portfolio::document::overlays::grid_overlays::{grid_overlay, overlay_options};
 use crate::messages::portfolio::document::overlays::utility_types::{OverlaysType, OverlaysVisibilitySettings};
-use crate::messages::portfolio::document::properties_panel::properties_panel_message_handler::PropertiesPanelMessageContext;
 use crate::messages::portfolio::document::utility_types::document_metadata::{DocumentMetadata, LayerNodeIdentifier};
 use crate::messages::portfolio::document::utility_types::misc::{AlignAggregate, AlignAxis, DocumentMode, FlipAxis, PTZ};
-use crate::messages::portfolio::document::utility_types::network_interface::{FlowType, InputConnector, NodeTemplate};
+use crate::messages::portfolio::document::utility_types::network_interface::{FlowType, NodeTemplate};
 use crate::messages::portfolio::document::utility_types::nodes::RawBuffer;
 use crate::messages::portfolio::utility_types::PersistentData;
 use crate::messages::prelude::*;
 use crate::messages::tool::common_functionality::graph_modification_utils::{self, get_blend_mode, get_fill, get_opacity};
 use crate::messages::tool::tool_messages::select_tool::SelectToolPointerKeys;
 use crate::messages::tool::tool_messages::tool_prelude::Key;
 use crate::messages::tool::utility_types::ToolType;
-use crate::node_graph_executor::NodeGraphExecutor;
 use bezier_rs::Subpath;
 use glam::{DAffine2, DVec2, IVec2};
 use graph_craft::document::value::TaggedValue;
-use graph_craft::document::{NodeId, NodeInput, NodeNetwork, OldNodeNetwork};
+use graph_craft::document::{InputConnector, NodeInput, NodeNetwork, OldNodeNetwork};
 use graphene_std::math::quad::Quad;
 use graphene_std::path_bool::{boolean_intersect, path_bool_lib};
 use graphene_std::raster::BlendMode;
@@ -37,18 +35,16 @@ use graphene_std::uuid::NodeId;
 use graphene_std::vector::PointId;
 use graphene_std::vector::click_target::{ClickTarget, ClickTargetType};
 use graphene_std::vector::style::ViewMode;
-use std::sync::Arc;
 use std::time::Duration;
 
 #[derive(ExtractField)]
-pub struct DocumentMessageContext<'a> {
-	pub document_id: DocumentId,
+pub struct DocumentMessageData<'a> {
 	pub ipp: &'a InputPreprocessorMessageHandler,
 	pub persistent_data: &'a PersistentData,
 	pub current_tool: &'a ToolType,
 	pub preferences: &'a PreferencesMessageHandler,
 	pub device_pixel_ratio: f64,
-	// pub introspected_inputs: &HashMap<CompiledProtonodeInput, Box<dyn std::any::Any + Send + Sync>>,
+	// pub introspected_inputs: &HashMap<CompiledProtonodeInput, Arc<dyn std::any::Any + Send + Sync>>,
 	// pub downcasted_inputs: &mut HashMap<CompiledProtonodeInput, TaggedValue>,
 }
 
@@ -173,10 +169,9 @@ impl Default for DocumentMessageHandler {
 }
 
 #[message_handler_data]
-impl MessageHandler<DocumentMessage, DocumentMessageContext<'_>> for DocumentMessageHandler {
-	fn process_message(&mut self, message: DocumentMessage, responses: &mut VecDeque<Message>, context: DocumentMessageContext) {
-		let DocumentMessageContext {
-			document_id,
+impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessageHandler {
+	fn process_message(&mut self, message: DocumentMessage, responses: &mut VecDeque<Message>, data: DocumentMessageData) {
+		let DocumentMessageData {
 			ipp,
 			persistent_data,
 			current_tool,
@@ -222,12 +217,10 @@ impl MessageHandler<DocumentMessage, DocumentMessageContext<'_>> for DocumentMes
 				);
 			}
 			DocumentMessage::PropertiesPanel(message) => {
-				let context = PropertiesPanelMessageContext {
+				let properties_panel_message_handler_data = super::properties_panel::PropertiesPanelMessageHandlerData {
 					network_interface: &mut self.network_interface,
 					selection_network_path: &self.selection_network_path,
 					document_name: self.name.as_str(),
-					executor,
-					persistent_data,
 				};
 				self.properties_panel_message_handler.process_message(message, responses, context);
 			}
@@ -239,7 +232,6 @@ impl MessageHandler<DocumentMessage, DocumentMessageContext<'_>> for DocumentMes
 						network_interface: &mut self.network_interface,
 						selection_network_path: &self.selection_network_path,
 						breadcrumb_network_path: &self.breadcrumb_network_path,
-						document_id,
 						collapsed: &mut self.collapsed,
 						ipp,
 						graph_view_overlay_open: self.graph_view_overlay_open,
@@ -1432,7 +1424,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageContext<'_>> for DocumentMes
 						center: Key::Alt,
 						duplicate: Key::Alt,
 					}));
-					responses.add(PortfolioMessage::CompileActiveDocument);
+					responses.add(PortfolioMessage::EvaluateActiveDocument);
 				} else {
 					let Some(network_metadata) = self.network_interface.network_metadata(&self.breadcrumb_network_path) else {
 						return;
@@ -1492,7 +1484,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageContext<'_>> for DocumentMes
 				// Connect the current output data to the artboard's input data, and the artboard's output to the document output
 				responses.add(NodeGraphMessage::InsertNodeBetween {
 					node_id,
-					input_connector: network_interface::InputConnector::Export(0),
+					input_connector: InputConnector::Export(0),
 					insert_node_input_index: 1,
 				});
 
@@ -1914,13 +1906,14 @@ impl DocumentMessageHandler {
 		let previous_network = std::mem::replace(&mut self.network_interface, network_interface);
 
 		// Push the UpdateOpenDocumentsList message to the bus in order to update the save status of the open documents
+		responses.add(PortfolioMessage::CompileActiveDocument);
+		responses.add(Message::StartEvaluationQueue);
 		responses.add(PortfolioMessage::UpdateOpenDocumentsList);
 		responses.add(NodeGraphMessage::SelectedNodesUpdated);
-		// TODO: Remove once the footprint is used to load the imports/export distances from the edge
-		responses.add(NodeGraphMessage::UnloadWires);
 		responses.add(NodeGraphMessage::SetGridAlignedEdges);
-		responses.add(PortfolioMessage::CompileActiveDocument);
-		responses.add(Message::StartQueue);
+		responses.add(NodeGraphMessage::UnloadWires);
+		responses.add(NodeGraphMessage::SendWires);
+		responses.add(Message::EndEvaluationQueue);
 		Some(previous_network)
 	}
 	pub fn redo_with_history(&mut self, ipp: &InputPreprocessorMessageHandler, responses: &mut VecDeque<Message>) {
@@ -1946,12 +1939,14 @@ impl DocumentMessageHandler {
 		network_interface.set_document_to_viewport_transform(transform);
 
 		let previous_network = std::mem::replace(&mut self.network_interface, network_interface);
+		responses.add(PortfolioMessage::CompileActiveDocument);
+		responses.add(Message::StartEvaluationQueue);
 		// Push the UpdateOpenDocumentsList message to the bus in order to update the save status of the open documents
 		responses.add(PortfolioMessage::UpdateOpenDocumentsList);
 		responses.add(NodeGraphMessage::SelectedNodesUpdated);
-		responses.add(PortfolioMessage::CompileActiveDocument);
 		responses.add(NodeGraphMessage::UnloadWires);
 		responses.add(NodeGraphMessage::SendWires);
+		responses.add(Message::EndEvaluationQueue);
 		Some(previous_network)
 	}
 
@@ -2108,7 +2103,7 @@ impl DocumentMessageHandler {
 	/// Loads all of the fonts in the document.
 	pub fn load_layer_resources(&self, responses: &mut VecDeque<Message>) {
 		let mut fonts = HashSet::new();
-		for (_node_id, node, _) in self.document_network().recursive_nodes() {
+		for (_node_path, node) in self.document_network().recursive_nodes() {
 			for input in &node.inputs {
 				if let Some(TaggedValue::Font(font)) = input.as_value() {
 					fonts.insert(font.clone());
@@ -2581,7 +2576,7 @@ impl DocumentMessageHandler {
 			layout: Layout::WidgetLayout(document_bar_layout),
 			layout_target: LayoutTarget::DocumentBar,
 		});
-		responses.add(NodeGraphMessage::ForceRunDocumentGraph);
+		responses.add(PortfolioMessage::EvaluateActiveDocument);
 	}
 
 	pub fn update_layers_panel_control_bar_widgets(&self, responses: &mut VecDeque<Message>) {

editor/src/messages/portfolio/document/graph_operation/graph_operation_message.rs

@@ -4,12 +4,12 @@ use crate::messages::portfolio::document::utility_types::network_interface::Node
 use crate::messages::prelude::*;
 use bezier_rs::Subpath;
 use glam::{DAffine2, IVec2};
-use graph_craft::document::NodeId;
 use graphene_std::Artboard;
 use graphene_std::brush::brush_stroke::BrushStroke;
 use graphene_std::raster::BlendMode;
 use graphene_std::raster_types::{CPU, RasterDataTable};
 use graphene_std::text::{Font, TypesettingConfig};
+use graphene_std::uuid::NodeId;
 use graphene_std::vector::PointId;
 use graphene_std::vector::VectorModificationType;
 use graphene_std::vector::style::{Fill, Stroke};