Desktop: Switch to the latest unreleased version of Winit (#3177)

* Use unstable winit

* Improve

* Remove unnecessary heap indirection

Author: timon-schelling

Cargo.lock

@@ -132,7 +132,7 @@ web-sys = { version = "=0.3.77", features = [
 	"HtmlImageElement",
 	"ImageBitmapRenderingContext",
 ] }
-winit = { version = "0.30", features = ["wayland", "rwh_06"] }
+winit = { git = "https://github.com/rust-windowing/winit.git", rev = "66283a79bddd034c45fb0e72c84fa5cd4e5f82fb" }
 url = "2.5"
 tokio = { version = "1.29", features = ["fs", "macros", "io-std", "rt"] }
 vello = { git = "https://github.com/linebender/vello.git", rev = "87cc5bee6d3a34d15017dbbb58634ddc7f33ff9b" } # TODO switch back to stable when a release is made

Cargo.toml

@@ -26,15 +26,15 @@ graphite-desktop-wrapper = { path = "wrapper" }
 graphite-desktop-embedded-resources = { path = "embedded-resources", optional = true }
 
 wgpu = { workspace = true }
-winit = { workspace = true, features = ["serde"] }
+winit = { workspace = true, features = [ "serde" ] }
 thiserror = { workspace = true }
 futures = { workspace = true }
 cef = { workspace = true }
 cef-dll-sys = { workspace = true }
 tracing-subscriber = { workspace = true }
 tracing = { workspace = true }
 dirs = { workspace = true }
-ron = { workspace = true}
+ron = { workspace = true }
 bytemuck = { workspace = true }
 glam = { workspace = true }
 vello = { workspace = true }

desktop/Cargo.toml

@@ -1,39 +1,37 @@
-use crate::CustomEvent;
-use crate::cef::WindowSize;
-use crate::consts::{APP_NAME, CEF_MESSAGE_LOOP_MAX_ITERATIONS};
-use crate::persist::PersistentData;
-use crate::render::GraphicsState;
-use graphite_desktop_wrapper::messages::{DesktopFrontendMessage, DesktopWrapperMessage, Platform};
-use graphite_desktop_wrapper::{DesktopWrapper, NodeGraphExecutionResult, WgpuContext, serialize_frontend_messages};
-
 use rfd::AsyncFileDialog;
 use std::sync::Arc;
+use std::sync::mpsc::Receiver;
 use std::sync::mpsc::Sender;
 use std::sync::mpsc::SyncSender;
 use std::thread;
 use std::time::Duration;
 use std::time::Instant;
 use winit::application::ApplicationHandler;
-use winit::dpi::PhysicalSize;
 use winit::event::WindowEvent;
 use winit::event_loop::ActiveEventLoop;
 use winit::event_loop::ControlFlow;
-use winit::event_loop::EventLoopProxy;
 use winit::window::Window;
 use winit::window::WindowId;
 
 use crate::cef;
+use crate::consts::CEF_MESSAGE_LOOP_MAX_ITERATIONS;
+use crate::event::{AppEvent, AppEventScheduler};
 use crate::native_window;
+use crate::persist::PersistentData;
+use crate::render::GraphicsState;
+use graphite_desktop_wrapper::messages::{DesktopFrontendMessage, DesktopWrapperMessage, Platform};
+use graphite_desktop_wrapper::{DesktopWrapper, NodeGraphExecutionResult, WgpuContext, serialize_frontend_messages};
 
-pub(crate) struct WinitApp {
+pub(crate) struct App {
 	cef_context: Box<dyn cef::CefContext>,
-	window: Option<Arc<Window>>,
+	window: Option<Arc<dyn Window>>,
 	native_window: native_window::NativeWindowHandle,
 	cef_schedule: Option<Instant>,
-	window_size_sender: Sender<WindowSize>,
+	cef_window_size_sender: Sender<cef::WindowSize>,
 	graphics_state: Option<GraphicsState>,
 	wgpu_context: WgpuContext,
-	event_loop_proxy: EventLoopProxy<CustomEvent>,
+	app_event_receiver: Receiver<AppEvent>,
+	app_event_scheduler: AppEventScheduler,
 	desktop_wrapper: DesktopWrapper,
 	last_ui_update: Instant,
 	avg_frame_time: f32,
@@ -43,14 +41,20 @@ pub(crate) struct WinitApp {
 	persistent_data: PersistentData,
 }
 
-impl WinitApp {
-	pub(crate) fn new(cef_context: Box<dyn cef::CefContext>, window_size_sender: Sender<WindowSize>, wgpu_context: WgpuContext, event_loop_proxy: EventLoopProxy<CustomEvent>) -> Self {
-		let rendering_loop_proxy = event_loop_proxy.clone();
+impl App {
+	pub(crate) fn new(
+		cef_context: Box<dyn cef::CefContext>,
+		window_size_sender: Sender<cef::WindowSize>,
+		wgpu_context: WgpuContext,
+		app_event_receiver: Receiver<AppEvent>,
+		app_event_scheduler: AppEventScheduler,
+	) -> Self {
+		let rendering_app_event_scheduler = app_event_scheduler.clone();
 		let (start_render_sender, start_render_receiver) = std::sync::mpsc::sync_channel(1);
 		std::thread::spawn(move || {
 			loop {
 				let result = futures::executor::block_on(DesktopWrapper::execute_node_graph());
-				let _ = rendering_loop_proxy.send_event(CustomEvent::NodeGraphExecutionResult(result));
+				rendering_app_event_scheduler.schedule(AppEvent::NodeGraphExecutionResult(result));
 				let _ = start_render_receiver.recv();
 			}
 		});
@@ -63,9 +67,10 @@ impl WinitApp {
 			window: None,
 			cef_schedule: Some(Instant::now()),
 			graphics_state: None,
-			window_size_sender,
+			cef_window_size_sender: window_size_sender,
 			wgpu_context,
-			event_loop_proxy,
+			app_event_receiver,
+			app_event_scheduler,
 			desktop_wrapper: DesktopWrapper::new(),
 			last_ui_update: Instant::now(),
 			avg_frame_time: 0.,
@@ -87,7 +92,7 @@ impl WinitApp {
 				self.send_or_queue_web_message(bytes);
 			}
 			DesktopFrontendMessage::OpenFileDialog { title, filters, context } => {
-				let event_loop_proxy = self.event_loop_proxy.clone();
+				let app_event_scheduler = self.app_event_scheduler.clone();
 				let _ = thread::spawn(move || {
 					let mut dialog = AsyncFileDialog::new().set_title(title);
 					for filter in filters {
@@ -100,7 +105,7 @@ impl WinitApp {
 						&& let Ok(content) = std::fs::read(&path)
 					{
 						let message = DesktopWrapperMessage::OpenFileDialogResult { path, content, context };
-						let _ = event_loop_proxy.send_event(CustomEvent::DesktopWrapperMessage(message));
+						app_event_scheduler.schedule(AppEvent::DesktopWrapperMessage(message));
 					}
 				});
 			}
@@ -111,7 +116,7 @@ impl WinitApp {
 				filters,
 				context,
 			} => {
-				let event_loop_proxy = self.event_loop_proxy.clone();
+				let app_event_scheduler = self.app_event_scheduler.clone();
 				let _ = thread::spawn(move || {
 					let mut dialog = AsyncFileDialog::new().set_title(title).set_file_name(default_filename);
 					if let Some(folder) = default_folder {
@@ -125,7 +130,7 @@ impl WinitApp {
 
 					if let Some(path) = futures::executor::block_on(show_dialog) {
 						let message = DesktopWrapperMessage::SaveFileDialogResult { path, context };
-						let _ = event_loop_proxy.send_event(CustomEvent::DesktopWrapperMessage(message));
+						app_event_scheduler.schedule(AppEvent::DesktopWrapperMessage(message));
 					}
 				});
 			}
@@ -145,7 +150,7 @@ impl WinitApp {
 				if let Some(graphics_state) = &mut self.graphics_state
 					&& let Some(window) = &self.window
 				{
-					let window_size = window.inner_size();
+					let window_size = window.surface_size();
 
 					let viewport_offset_x = x / window_size.width as f32;
 					let viewport_offset_y = y / window_size.height as f32;
@@ -173,7 +178,7 @@ impl WinitApp {
 				}
 			}
 			DesktopFrontendMessage::CloseWindow => {
-				let _ = self.event_loop_proxy.send_event(CustomEvent::CloseWindow);
+				self.app_event_scheduler.schedule(AppEvent::CloseWindow);
 			}
 			DesktopFrontendMessage::PersistenceWriteDocument { id, document } => {
 				self.persistent_data.write_document(id, document);
@@ -252,71 +257,17 @@ impl WinitApp {
 			self.web_communication_startup_buffer.push(message);
 		}
 	}
-}
-
-impl ApplicationHandler<CustomEvent> for WinitApp {
-	fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
-		// Set a timeout in case we miss any cef schedule requests
-		let timeout = Instant::now() + Duration::from_millis(10);
-		let wait_until = timeout.min(self.cef_schedule.unwrap_or(timeout));
-		if let Some(schedule) = self.cef_schedule
-			&& schedule < Instant::now()
-		{
-			self.cef_schedule = None;
-			// Poll cef message loop multiple times to avoid message loop starvation
-			for _ in 0..CEF_MESSAGE_LOOP_MAX_ITERATIONS {
-				self.cef_context.work();
-			}
-		}
-		if let Some(window) = &self.window.as_ref() {
-			window.request_redraw();
-		}
-
-		event_loop.set_control_flow(ControlFlow::WaitUntil(wait_until));
-	}
-
-	fn resumed(&mut self, event_loop: &ActiveEventLoop) {
-		let mut window = Window::default_attributes()
-			.with_title(APP_NAME)
-			.with_min_inner_size(winit::dpi::LogicalSize::new(400, 300))
-			.with_inner_size(winit::dpi::LogicalSize::new(1200, 800))
-			.with_resizable(true);
-
-		window = self.native_window.build(window, event_loop);
-
-		let window = event_loop.create_window(window).unwrap();
-
-		self.native_window.setup(&window);
-
-		let window = Arc::new(window);
-		let graphics_state = GraphicsState::new(window.clone(), self.wgpu_context.clone());
-
-		self.window = Some(window);
-		self.graphics_state = Some(graphics_state);
-
-		tracing::info!("Winit window created and ready");
-
-		self.desktop_wrapper.init(self.wgpu_context.clone());
-
-		#[cfg(target_os = "windows")]
-		let platform = Platform::Windows;
-		#[cfg(target_os = "macos")]
-		let platform = Platform::Mac;
-		#[cfg(target_os = "linux")]
-		let platform = Platform::Linux;
-		self.dispatch_desktop_wrapper_message(DesktopWrapperMessage::UpdatePlatform(platform));
-	}
 
-	fn user_event(&mut self, event_loop: &ActiveEventLoop, event: CustomEvent) {
+	fn user_event(&mut self, event_loop: &dyn ActiveEventLoop, event: AppEvent) {
 		match event {
-			CustomEvent::WebCommunicationInitialized => {
+			AppEvent::WebCommunicationInitialized => {
 				self.web_communication_initialized = true;
 				for message in self.web_communication_startup_buffer.drain(..) {
 					self.cef_context.send_web_message(message);
 				}
 			}
-			CustomEvent::DesktopWrapperMessage(message) => self.dispatch_desktop_wrapper_message(message),
-			CustomEvent::NodeGraphExecutionResult(result) => match result {
+			AppEvent::DesktopWrapperMessage(message) => self.dispatch_desktop_wrapper_message(message),
+			AppEvent::NodeGraphExecutionResult(result) => match result {
 				NodeGraphExecutionResult::HasRun(texture) => {
 					self.dispatch_desktop_wrapper_message(DesktopWrapperMessage::PollNodeGraphEvaluation);
 					if let Some(texture) = texture
@@ -329,7 +280,7 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 				}
 				NodeGraphExecutionResult::NotRun => {}
 			},
-			CustomEvent::UiUpdate(texture) => {
+			AppEvent::UiUpdate(texture) => {
 				if let Some(graphics_state) = self.graphics_state.as_mut() {
 					graphics_state.resize(texture.width(), texture.height());
 					graphics_state.bind_ui_texture(texture);
@@ -343,31 +294,63 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 					window.request_redraw();
 				}
 			}
-			CustomEvent::ScheduleBrowserWork(instant) => {
+			AppEvent::ScheduleBrowserWork(instant) => {
 				if instant <= Instant::now() {
 					self.cef_context.work();
 				} else {
 					self.cef_schedule = Some(instant);
 				}
 			}
-			CustomEvent::CloseWindow => {
+			AppEvent::CloseWindow => {
 				// TODO: Implement graceful shutdown
 
 				tracing::info!("Exiting main event loop");
 				event_loop.exit();
 			}
 		}
 	}
+}
+impl ApplicationHandler for App {
+	fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
+		let window_attributes = self.native_window.build(event_loop);
+
+		let window: Arc<dyn Window> = Arc::from(event_loop.create_window(window_attributes).unwrap());
 
-	fn window_event(&mut self, event_loop: &ActiveEventLoop, _window_id: WindowId, event: WindowEvent) {
+		self.native_window.setup(window.as_ref());
+
+		let graphics_state = GraphicsState::new(window.clone(), self.wgpu_context.clone());
+
+		self.window = Some(window);
+		self.graphics_state = Some(graphics_state);
+
+		tracing::info!("Winit window created and ready");
+
+		self.desktop_wrapper.init(self.wgpu_context.clone());
+
+		#[cfg(target_os = "windows")]
+		let platform = Platform::Windows;
+		#[cfg(target_os = "macos")]
+		let platform = Platform::Mac;
+		#[cfg(target_os = "linux")]
+		let platform = Platform::Linux;
+		self.dispatch_desktop_wrapper_message(DesktopWrapperMessage::UpdatePlatform(platform));
+	}
+
+	fn proxy_wake_up(&mut self, event_loop: &dyn ActiveEventLoop) {
+		while let Ok(event) = self.app_event_receiver.try_recv() {
+			self.user_event(event_loop, event);
+		}
+	}
+
+	fn window_event(&mut self, event_loop: &dyn ActiveEventLoop, _window_id: WindowId, event: WindowEvent) {
 		self.cef_context.handle_window_event(&event);
 
 		match event {
 			WindowEvent::CloseRequested => {
-				let _ = self.event_loop_proxy.send_event(CustomEvent::CloseWindow);
+				self.app_event_scheduler.schedule(AppEvent::CloseWindow);
 			}
-			WindowEvent::Resized(PhysicalSize { width, height }) => {
-				let _ = self.window_size_sender.send(WindowSize::new(width as usize, height as usize));
+			WindowEvent::SurfaceResized(size) => {
+				let _ = self.cef_window_size_sender.send(size.into());
 				self.cef_context.notify_of_resize();
 			}
 			WindowEvent::RedrawRequested => {
@@ -387,23 +370,44 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 					let _ = self.start_render_sender.try_send(());
 				}
 			}
-			// Currently not supported on wayland see https://github.com/rust-windowing/winit/issues/1881
-			WindowEvent::DroppedFile(path) => {
-				match std::fs::read(&path) {
-					Ok(content) => {
-						let message = DesktopWrapperMessage::OpenFile { path, content };
-						let _ = self.event_loop_proxy.send_event(CustomEvent::DesktopWrapperMessage(message));
-					}
-					Err(e) => {
-						tracing::error!("Failed to read dropped file {}: {}", path.display(), e);
-						return;
-					}
-				};
+			WindowEvent::DragDropped { paths, .. } => {
+				for path in paths {
+					match std::fs::read(&path) {
+						Ok(content) => {
+							let message = DesktopWrapperMessage::OpenFile { path, content };
+							self.app_event_scheduler.schedule(AppEvent::DesktopWrapperMessage(message));
+						}
+						Err(e) => {
+							tracing::error!("Failed to read dropped file {}: {}", path.display(), e);
+							return;
+						}
+					};
+				}
 			}
 			_ => {}
 		}
 
 		// Notify cef of possible input events
 		self.cef_context.work();
 	}
+
+	fn about_to_wait(&mut self, event_loop: &dyn ActiveEventLoop) {
+		// Set a timeout in case we miss any cef schedule requests
+		let timeout = Instant::now() + Duration::from_millis(10);
+		let wait_until = timeout.min(self.cef_schedule.unwrap_or(timeout));
+		if let Some(schedule) = self.cef_schedule
+			&& schedule < Instant::now()
+		{
+			self.cef_schedule = None;
+			// Poll cef message loop multiple times to avoid message loop starvation
+			for _ in 0..CEF_MESSAGE_LOOP_MAX_ITERATIONS {
+				self.cef_context.work();
+			}
+		}
+		if let Some(window) = &self.window.as_ref() {
+			window.request_redraw();
+		}
+
+		event_loop.set_control_flow(ControlFlow::WaitUntil(wait_until));
+	}
 }