Improve editor api

Author: adamgerhant

frontend/wasm/src/editor_api.rs

@@ -137,11 +137,34 @@ pub struct EditorHandle {
 	frontend_message_handler_callback: js_sys::Function,
 }
 
-// Defined separately from the `impl` block below since this `impl` block lacks the `#[wasm_bindgen]` attribute.
-// Quirks in wasm-bindgen prevent functions in `#[wasm_bindgen]` `impl` blocks from being made publicly accessible from Rust.
 impl EditorHandle {
-	pub fn send_frontend_message_to_js_rust_proxy(&self, message: FrontendMessage) {
-		self.send_frontend_message_to_js(message);
+	// Sends a FrontendMessage to JavaScript
+	pub fn send_frontend_message_to_js(&self, mut message: FrontendMessage) {
+		if let FrontendMessage::UpdateImageData { ref image_data } = message {
+			let new_hash = calculate_hash(image_data);
+			let prev_hash = IMAGE_DATA_HASH.load(Ordering::Relaxed);
+
+			if new_hash != prev_hash {
+				render_image_data_to_canvases(image_data.as_slice());
+				IMAGE_DATA_HASH.store(new_hash, Ordering::Relaxed);
+			}
+			return;
+		}
+
+		if let FrontendMessage::UpdateDocumentLayerStructure { data_buffer } = message {
+			message = FrontendMessage::UpdateDocumentLayerStructureJs { data_buffer: data_buffer.into() };
+		}
+
+		let message_type = message.to_discriminant().local_name();
+
+		let serializer = serde_wasm_bindgen::Serializer::new().serialize_large_number_types_as_bigints(true);
+		let message_data = message.serialize(&serializer).expect("Failed to serialize FrontendMessage");
+
+		let js_return_value = self.frontend_message_handler_callback.call2(&JsValue::null(), &JsValue::from(message_type), &message_data);
+
+		if let Err(error) = js_return_value {
+			error!("While handling FrontendMessage {:?}, JavaScript threw an error:\n{:?}", message.to_discriminant().local_name(), error,)
+		}
 	}
 }
 
@@ -179,28 +202,12 @@ impl EditorHandle {
 	#[cfg(not(feature = "native"))]
 	fn dispatch<T: Into<Message>>(&self, message: T) {
 		// Process no further messages after a crash to avoid spamming the console
-
-		use crate::MESSAGE_BUFFER;
 		if EDITOR_HAS_CRASHED.load(Ordering::SeqCst) {
 			return;
 		}
-
-		// Get the editor, dispatch the message, and store the `FrontendMessage` queue response
-		let frontend_messages = EDITOR.with(|editor| {
-			let mut guard = editor.try_lock();
-			let Ok(Some(editor)) = guard.as_deref_mut() else {
-				// Enqueue messages which can't be procssed currently
-				MESSAGE_BUFFER.with_borrow_mut(|buffer| buffer.push(message.into()));
-				return vec![];
-			};
-
-			editor.handle_message(message)
+		let _ = editor(|editor| {
+			self.process_messages(std::iter::once(message.into()), editor);
 		});
-
-		// Send each `FrontendMessage` to the JavaScript frontend
-		for message in frontend_messages.into_iter() {
-			self.send_frontend_message_to_js(message);
-		}
 	}
 
 	#[cfg(feature = "native")]
@@ -213,43 +220,22 @@ impl EditorHandle {
 		crate::native_communcation::send_message_to_cef(serialized_message)
 	}
 
-	// Sends a FrontendMessage to JavaScript
-	fn send_frontend_message_to_js(&self, mut message: FrontendMessage) {
-		// Intercept any requests to render the node graph overlay
-		if message == FrontendMessage::RequestNativeNodeGraphRender {
-			executor_editor_and_handle(|executor, editor, _handle| {
+	// Messages can come from the runtime, browser, or a timed callback. This processes them in the editor and does all the side effects
+	// Like updating the frontend and node graph ui network.
+	fn process_messages(&self, messages: impl IntoIterator<Item = Message>, editor: &mut Editor) {
+		// Get the editor, dispatch the message, and store the `FrontendMessage` queue response
+		for side_effect in messages.into_iter().flat_map(|message| editor.handle_message(message)).collect::<Vec<_>>() {
+			if side_effect == FrontendMessage::RequestNativeNodeGraphRender {
 				if let Some(node_graph_overlay_network) = editor.generate_node_graph_overlay_network() {
 					let compilation_request = CompilationRequest { network: node_graph_overlay_network };
-					executor.compilation_request(compilation_request);
+					let res = executor(|executor| executor.compilation_request(compilation_request));
+					if let Err(_) = res {
+						log::error!("Could not borrow executor in process_messages_in_editor");
+					}
 				}
-			});
-			return;
-		}
-
-		if let FrontendMessage::UpdateImageData { ref image_data } = message {
-			let new_hash = calculate_hash(image_data);
-			let prev_hash = IMAGE_DATA_HASH.load(Ordering::Relaxed);
-
-			if new_hash != prev_hash {
-				render_image_data_to_canvases(image_data.as_slice());
-				IMAGE_DATA_HASH.store(new_hash, Ordering::Relaxed);
+			} else {
+				self.send_frontend_message_to_js(side_effect);
 			}
-			return;
-		}
-
-		if let FrontendMessage::UpdateDocumentLayerStructure { data_buffer } = message {
-			message = FrontendMessage::UpdateDocumentLayerStructureJs { data_buffer: data_buffer.into() };
-		}
-
-		let message_type = message.to_discriminant().local_name();
-
-		let serializer = serde_wasm_bindgen::Serializer::new().serialize_large_number_types_as_bigints(true);
-		let message_data = message.serialize(&serializer).expect("Failed to serialize FrontendMessage");
-
-		let js_return_value = self.frontend_message_handler_callback.call2(&JsValue::null(), &JsValue::from(message_type), &message_data);
-
-		if let Err(error) = js_return_value {
-			error!("While handling FrontendMessage {:?}, JavaScript threw an error:\n{:?}", message.to_discriminant().local_name(), error,)
 		}
 	}
 
@@ -284,16 +270,18 @@ impl EditorHandle {
 
 				// Poll the UI node graph
 				#[cfg(not(feature = "native"))]
-				executor_editor_and_handle(|executor, editor, handle| {
-					for frontend_message in executor
-						.poll_node_graph_ui_evaluation(editor)
-						.into_iter()
-						.flat_map(|runtime_response| editor.handle_message(runtime_response))
-					{
-						handle.send_frontend_message_to_js(frontend_message);
+				let result = editor(|editor| {
+					let node_graph_response = executor(|executor| executor.poll_node_graph_ui_evaluation(editor));
+
+					match node_graph_response {
+						Ok(node_graph_ui_messages) => handle(|handle| handle.process_messages(node_graph_ui_messages, editor)),
+						Err(_) => log::error!("Could not get executor in frame loop"),
 					}
 				});
 
+				if let Err(_) = result {
+					log::error!("Could not get editor in frame loop");
+				}
 				if !EDITOR_HAS_CRASHED.load(Ordering::SeqCst) {
 					handle(|handle| {
 						// Process all messages that have been queued up
@@ -1000,64 +988,49 @@ fn set_timeout(f: &Closure<dyn FnMut()>, delay: Duration) {
 
 /// Provides access to the `Editor` by calling the given closure with it as an argument.
 #[cfg(not(feature = "native"))]
-fn editor<T: Default>(callback: impl FnOnce(&mut editor::application::Editor) -> T) -> T {
+fn editor<T>(callback: impl FnOnce(&mut editor::application::Editor) -> T) -> Result<T, ()> {
 	EDITOR.with(|editor| {
 		let mut guard = editor.try_lock();
 		let Ok(Some(editor)) = guard.as_deref_mut() else {
-			log::error!("Failed to borrow editor");
-			return T::default();
+			return Err(());
 		};
-
-		callback(editor)
+		Ok(callback(editor))
 	})
 }
 
 #[cfg(not(feature = "native"))]
-fn executor<T: Default>(callback: impl FnOnce(&mut WasmNodeGraphUIExecutor) -> T) -> T {
+fn executor<T>(callback: impl FnOnce(&mut WasmNodeGraphUIExecutor) -> T) -> Result<T, ()> {
 	WASM_NODE_GRAPH_EXECUTOR.with(|executor| {
 		let mut guard = executor.try_lock();
 		let Ok(Some(executor)) = guard.as_deref_mut() else {
-			log::error!("Failed to borrow editor");
-			return T::default();
+			return Err(());
 		};
 
-		callback(executor)
+		Ok(callback(executor))
 	})
 }
 
-#[cfg(not(feature = "native"))]
-pub(crate) fn executor_editor_and_handle(callback: impl FnOnce(&mut WasmNodeGraphUIExecutor, &mut Editor, &mut EditorHandle)) {
-	executor(|executor| {
-		handle(|editor_handle| {
-			editor(|editor| {
-				// Call the closure with the editor and its handle
-				callback(executor, editor, editor_handle);
-			})
-		});
-	})
-}
-
-/// Provides access to the `Editor` and its `EditorHandle` by calling the given closure with them as arguments.
-#[cfg(not(feature = "native"))]
-pub(crate) fn editor_and_handle(callback: impl FnOnce(&mut Editor, &mut EditorHandle)) {
-	handle(|editor_handle| {
-		editor(|editor| {
-			// Call the closure with the editor and its handle
-			callback(editor, editor_handle);
-		})
-	});
-}
 /// Provides access to the `EditorHandle` by calling the given closure with them as arguments.
 pub(crate) fn handle(callback: impl FnOnce(&mut EditorHandle)) {
 	EDITOR_HANDLE.with(|editor_handle| {
 		let mut guard = editor_handle.try_lock();
 		let Ok(Some(editor_handle)) = guard.as_deref_mut() else {
-			log::error!("Failed to borrow editor handle");
-			return;
+			return log::error!("Failed to borrow handle");
 		};
 
 		// Call the closure with the editor and its handle
-		callback(editor_handle);
+		callback(editor_handle)
+	})
+}
+
+/// Provides access to the `Editor` and its `EditorHandle` by calling the given closure with them as arguments.
+#[cfg(not(feature = "native"))]
+pub(crate) fn editor_and_handle(callback: impl FnOnce(&mut Editor, &mut EditorHandle)) {
+	let _ = handle(|editor_handle| {
+		let _ = editor(|editor| {
+			// Call the closure with the editor and its handle
+			callback(editor, editor_handle);
+		});
 	});
 }
 
@@ -1086,10 +1059,7 @@ async fn poll_node_graph_evaluation() {
 			crate::NODE_GRAPH_ERROR_DISPLAYED.store(false, Ordering::SeqCst);
 		}
 
-		// Send each `FrontendMessage` to the JavaScript frontend
-		for response in messages.into_iter().flat_map(|message| editor.handle_message(message)) {
-			handle.send_frontend_message_to_js(response);
-		}
+		handle.process_messages(messages, editor);
 
 		// If the editor cannot be borrowed then it has encountered a panic - we should just ignore new dispatches
 	});

frontend/wasm/src/lib.rs

@@ -66,7 +66,7 @@ pub fn panic_hook(info: &panic::PanicHookInfo) {
 				/text>"#
 				// It's a mystery why the `/text>` tag above needs to be missing its `<`, but when it exists it prints the `<` character in the text. However this works with it removed.
 				.to_string();
-				handle.send_frontend_message_to_js_rust_proxy(FrontendMessage::UpdateDocumentArtwork { svg: error });
+				handle.send_frontend_message_to_js(FrontendMessage::UpdateDocumentArtwork { svg: error });
 			});
 		}
 
@@ -77,11 +77,8 @@ pub fn panic_hook(info: &panic::PanicHookInfo) {
 
 	log::error!("{info}");
 
-	EDITOR_HANDLE.with(|editor_handle| {
-		let mut guard = editor_handle.lock();
-		if let Ok(Some(handle)) = guard.as_deref_mut() {
-			handle.send_frontend_message_to_js_rust_proxy(FrontendMessage::DisplayDialogPanic { panic_info: info.to_string() });
-		}
+	editor_api::handle(|editor_handle| {
+		editor_handle.send_frontend_message_to_js(FrontendMessage::DisplayDialogPanic { panic_info: info.to_string() });
 	});
 }
 

frontend/wasm/src/native_communcation.rs

@@ -11,7 +11,7 @@ pub fn receive_native_message(buffer: ArrayBuffer) {
 		Ok(messages) => {
 			let callback = move |handle: &mut EditorHandle| {
 				for message in messages {
-					handle.send_frontend_message_to_js_rust_proxy(message);
+					handle.send_frontend_message_to_js(message);
 				}
 			};
 			editor_api::handle(callback);