Merge branch 'master' into x11-fix-mods

Author: Quant1um

.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;
 
@@ -91,7 +95,6 @@ impl GlContext {
 
         view.setWantsBestResolutionOpenGLSurface_(YES);
 
-        let () = msg_send![view, retain];
         NSOpenGLView::display_(view);
         parent_view.addSubview_(view);
 

src/gl/win.rs

@@ -160,6 +160,7 @@ impl GlContext {
             let symbol = CString::new("wglCreateContextAttribsARB").unwrap();
             let addr = wglGetProcAddress(symbol.as_ptr());
             if !addr.is_null() {
+                #[allow(clippy::missing_transmute_annotations)]
                 Some(std::mem::transmute(addr))
             } else {
                 None
@@ -171,6 +172,7 @@ impl GlContext {
             let symbol = CString::new("wglChoosePixelFormatARB").unwrap();
             let addr = wglGetProcAddress(symbol.as_ptr());
             if !addr.is_null() {
+                #[allow(clippy::missing_transmute_annotations)]
                 Some(std::mem::transmute(addr))
             } else {
                 None
@@ -182,13 +184,15 @@ impl GlContext {
             let symbol = CString::new("wglSwapIntervalEXT").unwrap();
             let addr = wglGetProcAddress(symbol.as_ptr());
             if !addr.is_null() {
+                #[allow(clippy::missing_transmute_annotations)]
                 Some(std::mem::transmute(addr))
             } else {
                 None
             }
         };
 
         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/gl/x11.rs

@@ -91,6 +91,7 @@ impl GlContext {
                 if addr.is_null() {
                     return Err(GlError::CreationFailed(CreationFailedError::GetProcAddressFailed));
                 } else {
+                    #[allow(clippy::missing_transmute_annotations)]
                     std::mem::transmute(addr)
                 }
             };
@@ -101,6 +102,7 @@ impl GlContext {
                 if addr.is_null() {
                     return Err(GlError::CreationFailed(CreationFailedError::GetProcAddressFailed));
                 } else {
+                    #[allow(clippy::missing_transmute_annotations)]
                     std::mem::transmute(addr)
                 }
             };

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
 }
 
@@ -347,8 +351,6 @@ extern "C" fn view_will_move_to_window(this: &Object, _self: Sel, new_window: id
         let tracking_areas: *mut Object = msg_send![this, trackingAreas];
         let tracking_area_count = NSArray::count(tracking_areas);
 
-        let _: () = msg_send![class!(NSEvent), setMouseCoalescingEnabled: NO];
-
         if new_window == nil {
             if tracking_area_count != 0 {
                 let tracking_area = NSArray::objectAtIndex(tracking_areas, 0);

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;
@@ -71,7 +72,6 @@ impl WindowInner {
     pub(super) fn close(&self) {
         if self.open.get() {
             self.open.set(false);
-
             unsafe {
                 // Take back ownership of the NSView's Rc<WindowState>
                 let state_ptr: *const c_void = *(*self.ns_view).get_ivar(BASEVIEW_STATE_IVAR);
@@ -267,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));
@@ -360,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 {
@@ -378,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 {
@@ -419,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> {

src/win/drop_target.rs

@@ -7,7 +7,7 @@ use std::rc::{Rc, Weak};
 use winapi::shared::guiddef::{IsEqualIID, REFIID};
 use winapi::shared::minwindef::{DWORD, WPARAM};
 use winapi::shared::ntdef::{HRESULT, ULONG};
-use winapi::shared::windef::POINTL;
+use winapi::shared::windef::{POINT, POINTL};
 use winapi::shared::winerror::{E_NOINTERFACE, E_UNEXPECTED, S_OK};
 use winapi::shared::wtypes::DVASPECT_CONTENT;
 use winapi::um::objidl::{IDataObject, FORMATETC, STGMEDIUM, TYMED_HGLOBAL};
@@ -17,7 +17,7 @@ use winapi::um::oleidl::{
 };
 use winapi::um::shellapi::{DragQueryFileW, HDROP};
 use winapi::um::unknwnbase::{IUnknown, IUnknownVtbl};
-use winapi::um::winuser::CF_HDROP;
+use winapi::um::winuser::{ScreenToClient, CF_HDROP};
 use winapi::Interface;
 
 use crate::{DropData, DropEffect, Event, EventStatus, MouseEvent, PhyPoint, Point};
@@ -47,6 +47,8 @@ const DROP_PTR: unsafe extern "system" fn(
     pt: POINTL,
     pdwEffect: *mut DWORD,
 ) -> HRESULT = DropTarget::drop;
+
+#[allow(clippy::missing_transmute_annotations)]
 const DROP_TARGET_VTBL: IDropTargetVtbl = IDropTargetVtbl {
     parent: IUnknownVtbl {
         QueryInterface: DropTarget::query_interface,
@@ -112,7 +114,8 @@ impl DropTarget {
         let Some(window_state) = self.window_state.upgrade() else {
             return;
         };
-
+        let mut pt = POINT { x: pt.x, y: pt.y };
+        unsafe { ScreenToClient(window_state.hwnd, &mut pt as *mut POINT) };
         let phy_point = PhyPoint::new(pt.x, pt.y);
         self.drag_position = phy_point.to_logical(&window_state.window_info());
     }