Implement editor level future message handler (#4182)

* Implement proper editor level async message handler

* Take application_io and wake callback as Editor::new arguments

* Rename AsyncMessage -> FutureMessage

* add DesktopWrapperMessage::Wake

---------

Co-authored-by: Timon <me@timon.zip>

Author: TrueDoctor

Cargo.lock

@@ -93,7 +93,13 @@ impl App {
 		});
 
 		let resource_storage = MmapResourceStorage::new(dirs::app_resources_dir()).expect("Failed to initialize on-disk resource storage");
-		let desktop_wrapper = DesktopWrapper::new(rand::rng().random(), Box::new(resource_storage));
+
+		// Wake the winit event loop when an editor future completes.
+		let wake_scheduler = app_event_scheduler.clone();
+		let wake = std::sync::Arc::new(move || {
+			wake_scheduler.schedule(AppEvent::DesktopWrapperMessage(DesktopWrapperMessage::Wake));
+		});
+		let desktop_wrapper = DesktopWrapper::new(rand::rng().random(), Box::new(resource_storage), wgpu_context.clone(), wake);
 
 		Self {
 			render_state: None,
@@ -528,8 +534,6 @@ impl ApplicationHandler for App {
 
 		self.resize();
 
-		self.desktop_wrapper.init(self.wgpu_context.clone());
-
 		self.startup_time = Some(Instant::now());
 	}
 

desktop/src/app.rs

@@ -20,7 +20,6 @@ wgpu-executor = { workspace = true }
 
 wgpu = { workspace = true }
 thiserror = { workspace = true }
-futures = { workspace = true }
 tracing = { workspace = true }
 dirs = { workspace = true }
 ron = { workspace = true}

desktop/wrapper/Cargo.toml

@@ -9,6 +9,9 @@ pub(super) fn handle_desktop_wrapper_message(dispatcher: &mut DesktopWrapperMess
 		DesktopWrapperMessage::FromWeb(message) => {
 			dispatcher.queue_editor_message(*message);
 		}
+		DesktopWrapperMessage::Wake => {
+			dispatcher.queue_editor_message(EditorMessage::Future(FutureMessage::Wake));
+		}
 		DesktopWrapperMessage::Input(message) => {
 			dispatcher.queue_editor_message(EditorMessage::InputPreprocessor(message));
 		}

desktop/wrapper/src/handle_desktop_wrapper_message.rs

@@ -7,10 +7,6 @@ use super::messages::{DesktopFrontendMessage, FileFilter, OpenFileDialogContext,
 
 pub(super) fn intercept_frontend_message(dispatcher: &mut DesktopWrapperMessageDispatcher, message: FrontendMessage) -> Option<FrontendMessage> {
 	match message {
-		FrontendMessage::Await { future } => {
-			let message = futures::executor::block_on(async move { future.await });
-			return intercept_frontend_message(dispatcher, message);
-		}
 		FrontendMessage::RenderOverlays { context } => {
 			dispatcher.respond(DesktopFrontendMessage::UpdateOverlays(context.take_scene()));
 		}

desktop/wrapper/src/intercept_frontend_message.rs

@@ -1,7 +1,7 @@
 use graph_craft::application_io::PlatformApplicationIo;
 use graph_craft::application_io::resource::ResourceStorage;
 use graphite_editor::application::{Editor, Environment, Host, Platform};
-use graphite_editor::messages::prelude::{FrontendMessage, Message};
+use graphite_editor::messages::prelude::{FrontendMessage, Message, Wake};
 use message_dispatcher::DesktopWrapperMessageDispatcher;
 use messages::{DesktopFrontendMessage, DesktopWrapperMessage};
 
@@ -24,25 +24,21 @@ pub struct DesktopWrapper {
 }
 
 impl DesktopWrapper {
-	pub fn new(uuid_random_seed: u64, resource_storage: Box<dyn ResourceStorage>) -> Self {
+	pub fn new(uuid_random_seed: u64, resource_storage: Box<dyn ResourceStorage>, wgpu_context: WgpuContext, schedule_wake: Wake) -> Self {
 		#[cfg(target_os = "windows")]
 		let host = Host::Windows;
 		#[cfg(target_os = "macos")]
 		let host = Host::Mac;
 		#[cfg(target_os = "linux")]
 		let host = Host::Linux;
 		let env = Environment { platform: Platform::Desktop, host };
+		let application_io = PlatformApplicationIo::new_with_context(wgpu_context);
 
 		Self {
-			editor: Editor::new(env, uuid_random_seed, resource_storage),
+			editor: Editor::new(env, uuid_random_seed, resource_storage, application_io, schedule_wake),
 		}
 	}
 
-	pub fn init(&mut self, wgpu_context: WgpuContext) {
-		let application_io = PlatformApplicationIo::new_with_context(wgpu_context);
-		self.editor.replace_application_io(application_io);
-	}
-
 	pub fn dispatch(&mut self, message: DesktopWrapperMessage) -> Vec<DesktopFrontendMessage> {
 		let mut executor = DesktopWrapperMessageDispatcher::new(&mut self.editor);
 		executor.queue_desktop_wrapper_message(message);

desktop/wrapper/src/lib.rs

@@ -82,6 +82,7 @@ pub enum DesktopFrontendMessage {
 
 pub enum DesktopWrapperMessage {
 	FromWeb(Box<EditorMessage>),
+	Wake,
 	Input(InputMessage),
 	FileDialogResult { path: PathBuf, content: Vec<u8>, context: OpenFileDialogContext },
 	SaveFileDialogResult { path: PathBuf, context: SaveFileDialogContext },

desktop/wrapper/src/messages.rs

@@ -55,8 +55,13 @@ wgpu-executor = { workspace = true, optional = true }
 # Optional workspace dependencies
 wasm-bindgen = { workspace = true, optional = true }
 
+[target.'cfg(not(target_family = "wasm"))'.dependencies]
+tokio = { workspace = true }
+
+[target.'cfg(target_family = "wasm")'.dependencies]
+wasm-bindgen-futures = { workspace = true }
+
 [dev-dependencies]
 # Workspace dependencies
 env_logger = { workspace = true }
 futures = { workspace = true }
-tokio = { workspace = true }

editor/Cargo.toml

@@ -10,13 +10,16 @@ pub struct Editor {
 }
 
 impl Editor {
-	pub fn new(environment: Environment, uuid_random_seed: u64, resource_storage: Box<dyn ResourceStorage>) -> Self {
+	pub fn new(environment: Environment, uuid_random_seed: u64, resource_storage: Box<dyn ResourceStorage>, mut application_io: PlatformApplicationIo, wake: Wake) -> Self {
 		ENVIRONMENT.set(environment).expect("Editor shoud only be initialized once");
 		graphene_std::uuid::set_uuid_seed(uuid_random_seed);
 
-		Self {
-			dispatcher: Dispatcher::new(resource_storage),
-		}
+		let mut dispatcher = Dispatcher::new(resource_storage);
+		dispatcher.message_handlers.async_message_handler.set_wake(wake);
+		application_io.inject_resource_proxy(dispatcher.message_handlers.resource_storage_message_handler.resources());
+		crate::node_graph_executor::replace_application_io(application_io);
+
+		Self { dispatcher }
 	}
 
 	#[cfg(test)]
@@ -45,11 +48,6 @@ impl Editor {
 	pub fn poll_node_graph_evaluation(&mut self, responses: &mut VecDeque<Message>) -> Result<(), String> {
 		self.dispatcher.poll_node_graph_evaluation(responses)
 	}
-
-	pub fn replace_application_io(&mut self, mut application_io: PlatformApplicationIo) {
-		application_io.inject_resource_proxy(self.dispatcher.message_handlers.resource_storage_message_handler.resources());
-		crate::node_graph_executor::replace_application_io(application_io)
-	}
 }
 
 static ENVIRONMENT: OnceLock<Environment> = OnceLock::new();

editor/src/application.rs

@@ -20,6 +20,7 @@ pub struct Dispatcher {
 pub struct DispatcherMessageHandlers {
 	animation_message_handler: AnimationMessageHandler,
 	app_window_message_handler: AppWindowMessageHandler,
+	pub(crate) async_message_handler: FutureMessageHandler,
 	broadcast_message_handler: BroadcastMessageHandler,
 	clipboard_message_handler: ClipboardMessageHandler,
 	color_picker_message_handler: ColorPickerMessageHandler,
@@ -124,6 +125,13 @@ impl Dispatcher {
 	pub fn handle_message<T: Into<Message>>(&mut self, message: T, process_after_all_current: bool) {
 		let message = message.into();
 
+		// Drain async results into the queue before processing the new message.
+		let mut async_results = VecDeque::new();
+		self.message_handlers.async_message_handler.drain_results(&mut async_results);
+		if !async_results.is_empty() {
+			Self::schedule_execution(&mut self.message_queues, true, async_results);
+		}
+
 		// 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]);
 
@@ -173,6 +181,9 @@ impl Dispatcher {
 				Message::AppWindow(message) => {
 					self.message_handlers.app_window_message_handler.process_message(message, &mut queue, ());
 				}
+				Message::Future(message) => {
+					self.message_handlers.async_message_handler.process_message(message, &mut queue, FutureMessageContext {});
+				}
 				Message::Broadcast(message) => self.message_handlers.broadcast_message_handler.process_message(message, &mut queue, ()),
 				Message::Clipboard(message) => self.message_handlers.clipboard_message_handler.process_message(message, &mut queue, ()),
 				Message::ColorPicker(message) => self.message_handlers.color_picker_message_handler.process_message(message, &mut queue, ()),