Merge branch into master

Author: micahrj

.github/workflows/rust.yml

@@ -31,7 +31,5 @@ jobs:
       run: cargo test --workspace --all-targets --all-features --verbose
     - name: Check docs
       run: cargo doc --examples --all-features --no-deps
-    - name: Clippy
-      run: cargo clippy --workspace --all-targets --all-features -- -D warnings
     - name: Check Formatting (rustfmt)
       run: cargo fmt --all -- --check

src/gl/macos.rs

@@ -1,3 +1,7 @@
+// This is required because the objc crate is causing a lot of warnings: https://github.com/SSheldon/rust-objc/issues/125
+// Eventually we should migrate to the objc2 crate and remove this.
+#![allow(unexpected_cfgs)]
+
 use std::ffi::c_void;
 use std::str::FromStr;
 

src/gl/win.rs

@@ -192,6 +192,7 @@ impl GlContext {
         };
 
         wglMakeCurrent(hdc_tmp, std::ptr::null_mut());
+        wglDeleteContext(hglrc_tmp);
         ReleaseDC(hwnd_tmp, hdc_tmp);
         UnregisterClassW(class as *const WCHAR, hinstance);
         DestroyWindow(hwnd_tmp);

src/macos/mod.rs

@@ -1,3 +1,7 @@
+// This is required because the objc crate is causing a lot of warnings: https://github.com/SSheldon/rust-objc/issues/125
+// Eventually we should migrate to the objc2 crate and remove this.
+#![allow(unexpected_cfgs)]
+
 mod keyboard;
 mod view;
 mod window;

src/macos/view.rs

@@ -245,18 +245,22 @@ extern "C" fn become_first_responder(this: &Object, _sel: Sel) -> BOOL {
     let state = unsafe { WindowState::from_view(this) };
     let is_key_window = unsafe {
         let window: id = msg_send![this, window];
-        let is_key_window: BOOL = msg_send![window, isKeyWindow];
-        is_key_window == YES
+        if window != nil {
+            let is_key_window: BOOL = msg_send![window, isKeyWindow];
+            is_key_window == YES
+        } else {
+            false
+        }
     };
     if is_key_window {
-        state.trigger_event(Event::Window(WindowEvent::Focused));
+        state.trigger_deferrable_event(Event::Window(WindowEvent::Focused));
     }
     YES
 }
 
 extern "C" fn resign_first_responder(this: &Object, _sel: Sel) -> BOOL {
     let state = unsafe { WindowState::from_view(this) };
-    state.trigger_event(Event::Window(WindowEvent::Unfocused));
+    state.trigger_deferrable_event(Event::Window(WindowEvent::Unfocused));
     YES
 }
 

src/macos/window.rs

@@ -1,4 +1,5 @@
 use std::cell::{Cell, RefCell};
+use std::collections::VecDeque;
 use std::ffi::c_void;
 use std::ptr;
 use std::rc::Rc;
@@ -266,6 +267,7 @@ impl<'a> Window<'a> {
             keyboard_state: KeyboardState::new(),
             frame_timer: Cell::new(None),
             window_info: Cell::new(window_info),
+            deferred_events: RefCell::default(),
         });
 
         let window_state_ptr = Rc::into_raw(Rc::clone(&window_state));
@@ -359,6 +361,9 @@ pub(super) struct WindowState {
     frame_timer: Cell<Option<CFRunLoopTimer>>,
     /// The last known window info for this window.
     pub window_info: Cell<WindowInfo>,
+
+    /// Events that will be triggered at the end of `window_handler`'s borrow.
+    deferred_events: RefCell<VecDeque<Event>>,
 }
 
 impl WindowState {
@@ -377,14 +382,34 @@ impl WindowState {
         state
     }
 
+    /// Trigger the event immediately and return the event status.
+    /// Will panic if `window_handler` is already borrowed (see `trigger_deferrable_event`).
     pub(super) fn trigger_event(&self, event: Event) -> EventStatus {
         let mut window = crate::Window::new(Window { inner: &self.window_inner });
-        self.window_handler.borrow_mut().on_event(&mut window, event)
+        let mut window_handler = self.window_handler.borrow_mut();
+        let status = window_handler.on_event(&mut window, event);
+        self.send_deferred_events(window_handler.as_mut());
+        status
+    }
+
+    /// Trigger the event immediately if `window_handler` can be borrowed mutably,
+    /// otherwise add the event to a queue that will be cleared once `window_handler`'s mutable borrow ends.
+    /// As this method might result in the event triggering asynchronously, it can't reliably return the event status.
+    pub(super) fn trigger_deferrable_event(&self, event: Event) {
+        if let Ok(mut window_handler) = self.window_handler.try_borrow_mut() {
+            let mut window = crate::Window::new(Window { inner: &self.window_inner });
+            window_handler.on_event(&mut window, event);
+            self.send_deferred_events(window_handler.as_mut());
+        } else {
+            self.deferred_events.borrow_mut().push_back(event);
+        }
     }
 
     pub(super) fn trigger_frame(&self) {
         let mut window = crate::Window::new(Window { inner: &self.window_inner });
-        self.window_handler.borrow_mut().on_frame(&mut window);
+        let mut window_handler = self.window_handler.borrow_mut();
+        window_handler.on_frame(&mut window);
+        self.send_deferred_events(window_handler.as_mut());
     }
 
     pub(super) fn keyboard_state(&self) -> &KeyboardState {
@@ -418,6 +443,18 @@ impl WindowState {
 
         (*window_state_ptr).frame_timer.set(Some(timer));
     }
+
+    fn send_deferred_events(&self, window_handler: &mut dyn WindowHandler) {
+        let mut window = crate::Window::new(Window { inner: &self.window_inner });
+        loop {
+            let next_event = self.deferred_events.borrow_mut().pop_front();
+            if let Some(event) = next_event {
+                window_handler.on_event(&mut window, event);
+            } else {
+                break;
+            }
+        }
+    }
 }
 
 unsafe impl<'a> HasRawWindowHandle for Window<'a> {