feat(WR): fix C-g on Unix

Tested on wayland/x11 Unix.

Author: declantsien

Cargo.lock

@@ -26,6 +26,7 @@ tokio = { version = "1.23", features = ["rt-multi-thread", "sync", "net", "macro
 futures = "0.3.25"
 winit = { version = "0.27.5", default-features = false }
 fontdb = "0.12"
+raw-window-handle = "0.5"
 errno = "0.2"
 spin_sleep = { version = "1.1", optional = true }
 surfman = "0.4.4"
@@ -51,13 +52,19 @@ cfg_aliases = "0.1"
 
 [target.'cfg(all(unix, not(target_os = "macos")))'.dependencies]
 font-loader = "0.11"
+wayland-sys = {version = "0.30", features = ["client", "dlopen"]}
+
+[target.'cfg(all(unix, not(target_os = "macos")))'.dependencies.x11]
+features = ["xlib"]
+version = "2.20"
+optional = true
 
 [target.'cfg(target_os = "macos")'.dependencies]
 core-foundation = "0.9.2"
 
 [features]
 default = ["wayland", @WEBRENDER_DEFAULT_FEATURES@]
-x11 = ["copypasta/x11", "surfman/sm-x11", "winit/x11"]
+x11 = ["dep:x11", "copypasta/x11", "surfman/sm-x11", "winit/x11"]
 wayland = ["copypasta/wayland", "winit/wayland"]
 capture=["webrender/capture", "webrender/serialize_program"]
 sw_compositor=["webrender/sw_compositor"]

rust_src/crates/webrender/Cargo.in

@@ -5,6 +5,8 @@ use ng_bindgen::{generate_crate_exports, BuildError};
 
 fn main() {
     println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-changed=src/wrterm.rs");
+    println!("cargo:rerun-if-changed=src/event_loop.rs");
     // TODO watch relevent files to re rerun, rs files under src?
 
     let path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));

rust_src/crates/webrender/build.rs

@@ -1,4 +1,5 @@
 use libc;
+use raw_window_handle::RawDisplayHandle;
 use std::{collections::HashMap, ptr};
 use winit::window::WindowId;
 
@@ -21,6 +22,10 @@ pub struct DisplayInfoInner {
     pub scratch_cursor_gc: Box<Emacs_GC>,
 
     pub fringe_bitmap_caches: HashMap<i32, FringeBitmap>,
+
+    pub connection: Option<surfman::Connection>,
+
+    pub raw_display_handle: Option<RawDisplayHandle>,
 }
 
 impl Default for DisplayInfoInner {
@@ -36,6 +41,8 @@ impl Default for DisplayInfoInner {
             }),
 
             fringe_bitmap_caches: HashMap::new(),
+            connection: None,
+            raw_display_handle: None,
         }
     }
 }

rust_src/crates/webrender/src/display_info.rs

@@ -1,6 +1,8 @@
 use crate::select::handle_select;
+use raw_window_handle::{HasRawDisplayHandle, RawDisplayHandle};
 use std::{
-    sync::Mutex,
+    cell::RefCell,
+    sync::{Arc, Mutex},
     time::{Duration, Instant},
 };
 
@@ -17,7 +19,7 @@ use copypasta::{
 
 use libc::{c_void, fd_set, pselect, sigset_t, timespec};
 use once_cell::sync::Lazy;
-#[cfg(wayland_platform)]
+#[cfg(free_unix)]
 use winit::platform::wayland::EventLoopWindowTargetExtWayland;
 use winit::{
     event::{Event, StartCause, WindowEvent},
@@ -49,7 +51,7 @@ unsafe impl Send for Platform {}
 
 pub struct WrEventLoop {
     clipboard: Box<dyn ClipboardProvider>,
-    pub el: EventLoop<i32>,
+    el: EventLoop<i32>,
     pub connection: Option<Connection>,
 }
 
@@ -61,19 +63,16 @@ impl WrEventLoop {
         &self.el
     }
 
-    pub fn connection(&mut self) -> &Connection {
-        if self.connection.is_none() {
-            self.open_native_display();
-        }
-        self.connection.as_ref().unwrap()
-    }
-
     pub fn create_proxy(&self) -> EventLoopProxy<i32> {
         self.el.create_proxy()
     }
 
-    pub fn new_webrender_surfman(&mut self, window: &Window) -> WebrenderSurfman {
-        let connection = self.connection();
+    pub fn new_webrender_surfman(
+        &mut self,
+        window: &Window,
+        connection: Option<&Connection>,
+    ) -> WebrenderSurfman {
+        let connection = connection.expect("device not open");
         let adapter = connection
             .create_adapter()
             .expect("Failed to create adapter");
@@ -87,17 +86,16 @@ impl WrEventLoop {
         webrender_surfman
     }
 
-    pub fn open_native_display(&mut self) -> &Option<Connection> {
+    pub fn open_native_display(&mut self) -> (Connection, RawDisplayHandle) {
         let window_builder = winit::window::WindowBuilder::new().with_visible(false);
         let window = window_builder.build(&self.el).unwrap();
+        let rwh = window.raw_display_handle();
 
         // Initialize surfman
         let connection =
             Connection::from_winit_window(&window).expect("Failed to create connection");
 
-        self.connection = Some(connection);
-
-        &self.connection
+        (connection, rwh)
     }
 
     pub fn wait_for_window_resize(&mut self, target_window_id: WindowId) {
@@ -160,16 +158,16 @@ fn build_clipboard(_event_loop: &EventLoop<i32>) -> Box<dyn ClipboardProvider> {
     }
 }
 
-pub static EVENT_LOOP: Lazy<Mutex<WrEventLoop>> = Lazy::new(|| {
+pub static EVENT_LOOP: Lazy<Arc<Mutex<WrEventLoop>>> = Lazy::new(|| {
     let el = winit::event_loop::EventLoopBuilder::<i32>::with_user_event().build();
     let clipboard = build_clipboard(&el);
     let connection = None;
 
-    Mutex::new(WrEventLoop {
+    Arc::new(Mutex::new(WrEventLoop {
         clipboard,
         el,
         connection,
-    })
+    }))
 });
 
 pub static EVENT_BUFFER: Lazy<Mutex<Vec<GUIEvent>>> = Lazy::new(|| Mutex::new(Vec::new()));
@@ -183,7 +181,13 @@ pub extern "C" fn wr_select(
     timeout: *mut timespec,
     _sigmask: *mut sigset_t,
 ) -> i32 {
-    if unsafe { inhibit_window_system } {
+    let lock_result = EVENT_LOOP.try_lock();
+
+    if lock_result.is_err() || unsafe { inhibit_window_system } {
+        if lock_result.is_err() {
+            log::debug!("Failed to grab a lock {:?}", lock_result.err());
+        }
+
         return unsafe {
             thread_select(
                 Some(pselect),
@@ -197,5 +201,58 @@ pub extern "C" fn wr_select(
         };
     }
 
-    handle_select(nfds, readfds, writefds, _exceptfds, timeout, _sigmask)
+    let mut event_loop = lock_result.unwrap();
+
+    handle_select(
+        &mut event_loop.el,
+        nfds,
+        readfds,
+        writefds,
+        _exceptfds,
+        timeout,
+        _sigmask,
+    )
+}
+
+// Polling C-g when emacs is blocked
+pub fn poll_a_event(timeout: Duration) -> Option<GUIEvent> {
+    log::trace!("poll a event {:?}", timeout);
+    let result = EVENT_LOOP.try_lock();
+    if result.is_err() {
+        log::trace!("failed to grab a EVENT_LOOP lock");
+        return None;
+    }
+    let mut event_loop = result.unwrap();
+    let deadline = Instant::now() + timeout;
+    let result = RefCell::new(None);
+    event_loop.el.run_return(|e, _target, control_flow| {
+        control_flow.set_wait_until(deadline);
+
+        if let Event::WindowEvent { event, .. } = &e {
+            log::trace!("{:?}", event);
+        }
+
+        match e {
+            Event::WindowEvent { ref event, .. } => match event {
+                WindowEvent::Resized(_)
+                | WindowEvent::KeyboardInput { .. }
+                | WindowEvent::ReceivedCharacter(_)
+                | WindowEvent::ModifiersChanged(_)
+                | WindowEvent::MouseInput { .. }
+                | WindowEvent::CursorMoved { .. }
+                | WindowEvent::Focused(_)
+                | WindowEvent::MouseWheel { .. }
+                | WindowEvent::CloseRequested => {
+                    result.replace(Some(e.to_static().unwrap()));
+                    control_flow.set_exit();
+                }
+                _ => {}
+            },
+            Event::RedrawEventsCleared => {
+                control_flow.set_exit();
+            }
+            _ => {}
+        };
+    });
+    result.into_inner()
 }

rust_src/crates/webrender/src/event_loop.rs

@@ -36,7 +36,7 @@ pub fn create_frame(
     frame.set_output_method(output_method::output_wr);
 
     let mut event_loop = EVENT_LOOP.lock().unwrap();
-    let mut output = Box::new(Output::build(&mut event_loop, frame));
+    let mut output = Box::new(Output::build(&mut event_loop, dpyinfo, frame));
 
     let window_id = output.get_window().id();
 

rust_src/crates/webrender/src/frame.rs

@@ -88,7 +88,11 @@ pub struct Output {
 }
 
 impl Output {
-    pub fn build(event_loop: &mut WrEventLoop, frame: LispFrameRef) -> Self {
+    pub fn build(
+        event_loop: &mut WrEventLoop,
+        dpyinfo: DisplayInfoRef,
+        frame: LispFrameRef,
+    ) -> Self {
         let window_builder = winit::window::WindowBuilder::new().with_visible(true);
 
         #[cfg(wayland_platform)]
@@ -99,7 +103,9 @@ impl Output {
         };
 
         let window = window_builder.build(&event_loop.el()).unwrap();
-        let webrender_surfman = event_loop.new_webrender_surfman(&window);
+        let dpyinfo_ref = dpyinfo.get_inner();
+        let connection = dpyinfo_ref.connection.as_ref();
+        let webrender_surfman = event_loop.new_webrender_surfman(&window, connection);
 
         // Get GL bindings
         let gl = match webrender_surfman.connection().gl_api() {