macOS: Call ApplicationHandler directly instead of using Event (#…

…3753)

Additionally, always queue events in `handle_scale_factor_changed`.

These events were intentionally not queued before, since they are
executed inside `handle_scale_factor_changed`, which is itself queued.
Though that's a bit too subtle, so let's just take the minuscule perf
hit of redundantly checking whether we need to queue again.

Co-authored-by: Kirill Chibisov <contact@kchibisov.com>

src/platform_impl/macos/app.rs

@@ -5,6 +5,7 @@ use objc2_app_kit::{NSApplication, NSEvent, NSEventModifierFlags, NSEventType, N
 use objc2_foundation::{MainThreadMarker, NSObject};
 
 use super::app_state::ApplicationDelegate;
+use super::DEVICE_ID;
 use crate::event::{DeviceEvent, ElementState};
 
 declare_class!(
@@ -57,29 +58,47 @@ fn maybe_dispatch_device_event(delegate: &ApplicationDelegate, event: &NSEvent)
             let delta_y = unsafe { event.deltaY() } as f64;
 
             if delta_x != 0.0 {
-                delegate.maybe_queue_device_event(DeviceEvent::Motion { axis: 0, value: delta_x });
+                delegate.maybe_queue_with_handler(move |app, event_loop| {
+                    app.device_event(event_loop, DEVICE_ID, DeviceEvent::Motion {
+                        axis: 0,
+                        value: delta_x,
+                    });
+                });
             }
 
             if delta_y != 0.0 {
-                delegate.maybe_queue_device_event(DeviceEvent::Motion { axis: 1, value: delta_y })
+                delegate.maybe_queue_with_handler(move |app, event_loop| {
+                    app.device_event(event_loop, DEVICE_ID, DeviceEvent::Motion {
+                        axis: 1,
+                        value: delta_y,
+                    });
+                })
             }
 
             if delta_x != 0.0 || delta_y != 0.0 {
-                delegate.maybe_queue_device_event(DeviceEvent::MouseMotion {
-                    delta: (delta_x, delta_y),
+                delegate.maybe_queue_with_handler(move |app, event_loop| {
+                    app.device_event(event_loop, DEVICE_ID, DeviceEvent::MouseMotion {
+                        delta: (delta_x, delta_y),
+                    });
                 });
             }
         },
         NSEventType::LeftMouseDown | NSEventType::RightMouseDown | NSEventType::OtherMouseDown => {
-            delegate.maybe_queue_device_event(DeviceEvent::Button {
-                button: unsafe { event.buttonNumber() } as u32,
-                state: ElementState::Pressed,
+            let button = unsafe { event.buttonNumber() } as u32;
+            delegate.maybe_queue_with_handler(move |app, event_loop| {
+                app.device_event(event_loop, DEVICE_ID, DeviceEvent::Button {
+                    button,
+                    state: ElementState::Pressed,
+                });
             });
         },
         NSEventType::LeftMouseUp | NSEventType::RightMouseUp | NSEventType::OtherMouseUp => {
-            delegate.maybe_queue_device_event(DeviceEvent::Button {
-                button: unsafe { event.buttonNumber() } as u32,
-                state: ElementState::Released,
+            let button = unsafe { event.buttonNumber() } as u32;
+            delegate.maybe_queue_with_handler(move |app, event_loop| {
+                app.device_event(event_loop, DEVICE_ID, DeviceEvent::Button {
+                    button,
+                    state: ElementState::Released,
+                });
             });
         },
         _ => (),

src/platform_impl/macos/app_state.rs

@@ -8,13 +8,15 @@ use objc2::{declare_class, msg_send_id, mutability, ClassType, DeclaredClass};
 use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy, NSApplicationDelegate};
 use objc2_foundation::{MainThreadMarker, NSNotification, NSObject, NSObjectProtocol};
 
+use crate::application::ApplicationHandler;
+use crate::event::{StartCause, WindowEvent};
+use crate::event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow};
+use crate::window::WindowId as RootWindowId;
+
 use super::event_handler::EventHandler;
 use super::event_loop::{stop_app_immediately, ActiveEventLoop, PanicInfo};
 use super::observer::{EventLoopWaker, RunLoop};
-use super::{menu, WindowId, DEVICE_ID};
-use crate::event::{DeviceEvent, Event, StartCause, WindowEvent};
-use crate::event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow};
-use crate::window::WindowId as RootWindowId;
+use super::{menu, WindowId};
 
 #[derive(Debug)]
 pub(super) struct AppState {
@@ -166,7 +168,7 @@ impl ApplicationDelegate {
     /// of the given closure.
     pub fn set_event_handler<R>(
         &self,
-        handler: impl FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop),
+        handler: &mut dyn ApplicationHandler<HandlePendingUserEvents>,
         closure: impl FnOnce() -> R,
     ) -> R {
         self.ivars().event_handler.set(handler, closure)
@@ -200,7 +202,9 @@ impl ApplicationDelegate {
     /// NOTE: that if the `NSApplication` has been launched then that state is preserved,
     /// and we won't need to re-launch the app if subsequent EventLoops are run.
     pub fn internal_exit(&self) {
-        self.handle_event(Event::LoopExiting);
+        self.with_handler(|app, event_loop| {
+            app.exiting(event_loop);
+        });
 
         self.set_is_running(false);
         self.set_stop_on_redraw(false);
@@ -241,26 +245,13 @@ impl ApplicationDelegate {
         self.ivars().control_flow.get()
     }
 
-    pub fn maybe_queue_window_event(&self, window_id: WindowId, event: WindowEvent) {
-        self.maybe_queue_event(Event::WindowEvent { window_id: RootWindowId(window_id), event });
-    }
-
-    pub fn handle_window_event(&self, window_id: WindowId, event: WindowEvent) {
-        self.handle_event(Event::WindowEvent { window_id: RootWindowId(window_id), event });
-    }
-
-    pub fn maybe_queue_device_event(&self, event: DeviceEvent) {
-        self.maybe_queue_event(Event::DeviceEvent { device_id: DEVICE_ID, event });
-    }
-
     pub fn handle_redraw(&self, window_id: WindowId) {
         let mtm = MainThreadMarker::from(self);
         // Redraw request might come out of order from the OS.
         // -> Don't go back into the event handler when our callstack originates from there
         if !self.ivars().event_handler.in_use() {
-            self.handle_event(Event::WindowEvent {
-                window_id: RootWindowId(window_id),
-                event: WindowEvent::RedrawRequested,
+            self.with_handler(|app, event_loop| {
+                app.window_event(event_loop, RootWindowId(window_id), WindowEvent::RedrawRequested);
             });
 
             // `pump_events` will request to stop immediately _after_ dispatching RedrawRequested
@@ -282,33 +273,45 @@ impl ApplicationDelegate {
     }
 
     #[track_caller]
-    fn maybe_queue_event(&self, event: Event<HandlePendingUserEvents>) {
+    pub fn maybe_queue_with_handler(
+        &self,
+        callback: impl FnOnce(&mut dyn ApplicationHandler<HandlePendingUserEvents>, &RootActiveEventLoop)
+            + 'static,
+    ) {
         // Most programmer actions in AppKit (e.g. change window fullscreen, set focused, etc.)
         // result in an event being queued, and applied at a later point.
         //
         // However, it is not documented which actions do this, and which ones are done immediately,
         // so to make sure that we don't encounter re-entrancy issues, we first check if we're
         // currently handling another event, and if we are, we queue the event instead.
         if !self.ivars().event_handler.in_use() {
-            self.handle_event(event);
+            self.with_handler(callback);
         } else {
-            tracing::debug!(?event, "had to queue event since another is currently being handled");
+            tracing::debug!("had to queue event since another is currently being handled");
             let this = self.retain();
-            self.ivars().run_loop.queue_closure(move || this.handle_event(event));
+            self.ivars().run_loop.queue_closure(move || {
+                this.with_handler(callback);
+            });
         }
     }
 
     #[track_caller]
-    fn handle_event(&self, event: Event<HandlePendingUserEvents>) {
-        self.ivars().event_handler.handle_event(event, &ActiveEventLoop::new_root(self.retain()))
+    fn with_handler<
+        F: FnOnce(&mut dyn ApplicationHandler<HandlePendingUserEvents>, &RootActiveEventLoop),
+    >(
+        &self,
+        callback: F,
+    ) {
+        let event_loop = ActiveEventLoop::new_root(self.retain());
+        self.ivars().event_handler.handle(callback, &event_loop);
     }
 
     /// dispatch `NewEvents(Init)` + `Resumed`
     pub fn dispatch_init_events(&self) {
-        self.handle_event(Event::NewEvents(StartCause::Init));
+        self.with_handler(|app, event_loop| app.new_events(event_loop, StartCause::Init));
         // NB: For consistency all platforms must emit a 'resumed' event even though macOS
         // applications don't themselves have a formal suspend/resume lifecycle.
-        self.handle_event(Event::Resumed);
+        self.with_handler(|app, event_loop| app.resumed(event_loop));
     }
 
     // Called by RunLoopObserver after finishing waiting for new events
@@ -341,7 +344,7 @@ impl ApplicationDelegate {
             },
         };
 
-        self.handle_event(Event::NewEvents(cause));
+        self.with_handler(|app, event_loop| app.new_events(event_loop, cause));
     }
 
     // Called by RunLoopObserver before waiting for new events
@@ -358,17 +361,17 @@ impl ApplicationDelegate {
             return;
         }
 
-        self.handle_event(Event::UserEvent(HandlePendingUserEvents));
+        self.with_handler(|app, event_loop| app.user_event(event_loop, HandlePendingUserEvents));
 
         let redraw = mem::take(&mut *self.ivars().pending_redraw.borrow_mut());
         for window_id in redraw {
-            self.handle_event(Event::WindowEvent {
-                window_id: RootWindowId(window_id),
-                event: WindowEvent::RedrawRequested,
+            self.with_handler(|app, event_loop| {
+                app.window_event(event_loop, RootWindowId(window_id), WindowEvent::RedrawRequested);
             });
         }
-
-        self.handle_event(Event::AboutToWait);
+        self.with_handler(|app, event_loop| {
+            app.about_to_wait(event_loop);
+        });
 
         if self.exiting() {
             let app = NSApplication::sharedApplication(mtm);

src/platform_impl/macos/event_handler.rs

@@ -2,31 +2,31 @@ use std::cell::RefCell;
 use std::{fmt, mem};
 
 use super::app_state::HandlePendingUserEvents;
-use crate::event::Event;
+use crate::application::ApplicationHandler;
 use crate::event_loop::ActiveEventLoop as RootActiveEventLoop;
 
-struct EventHandlerData {
-    #[allow(clippy::type_complexity)]
-    handler: Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'static>,
-}
-
-impl fmt::Debug for EventHandlerData {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("EventHandlerData").finish_non_exhaustive()
-    }
-}
-
-#[derive(Debug)]
+#[derive(Default)]
 pub(crate) struct EventHandler {
     /// This can be in the following states:
     /// - Not registered by the event loop (None).
     /// - Present (Some(handler)).
     /// - Currently executing the handler / in use (RefCell borrowed).
-    inner: RefCell<Option<EventHandlerData>>,
+    inner: RefCell<Option<&'static mut dyn ApplicationHandler<HandlePendingUserEvents>>>,
+}
+
+impl fmt::Debug for EventHandler {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let state = match self.inner.try_borrow().as_deref() {
+            Ok(Some(_)) => "<available>",
+            Ok(None) => "<not set>",
+            Err(_) => "<in use>",
+        };
+        f.debug_struct("EventHandler").field("state", &state).finish_non_exhaustive()
+    }
 }
 
 impl EventHandler {
-    pub(crate) const fn new() -> Self {
+    pub(crate) fn new() -> Self {
         Self { inner: RefCell::new(None) }
     }
 
@@ -37,7 +37,7 @@ impl EventHandler {
     /// from within the closure.
     pub(crate) fn set<'handler, R>(
         &self,
-        handler: impl FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'handler,
+        app: &'handler mut dyn ApplicationHandler<HandlePendingUserEvents>,
         closure: impl FnOnce() -> R,
     ) -> R {
         // SAFETY: We extend the lifetime of the handler here so that we can
@@ -48,17 +48,17 @@ impl EventHandler {
         // extended beyond `'handler`.
         let handler = unsafe {
             mem::transmute::<
-                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'handler>,
-                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'static>,
-            >(Box::new(handler))
+                &'handler mut dyn ApplicationHandler<HandlePendingUserEvents>,
+                &'static mut dyn ApplicationHandler<HandlePendingUserEvents>,
+            >(app)
         };
 
         match self.inner.try_borrow_mut().as_deref_mut() {
             Ok(Some(_)) => {
                 unreachable!("tried to set handler while another was already set");
             },
             Ok(data @ None) => {
-                *data = Some(EventHandlerData { handler });
+                *data = Some(handler);
             },
             Err(_) => {
                 unreachable!("tried to set handler that is currently in use");
@@ -109,20 +109,22 @@ impl EventHandler {
         matches!(self.inner.try_borrow().as_deref(), Ok(Some(_)))
     }
 
-    pub(crate) fn handle_event(
+    pub(crate) fn handle<
+        F: FnOnce(&mut dyn ApplicationHandler<HandlePendingUserEvents>, &RootActiveEventLoop),
+    >(
         &self,
-        event: Event<HandlePendingUserEvents>,
+        callback: F,
         event_loop: &RootActiveEventLoop,
     ) {
         match self.inner.try_borrow_mut().as_deref_mut() {
-            Ok(Some(EventHandlerData { handler })) => {
+            Ok(Some(user_app)) => {
                 // It is important that we keep the reference borrowed here,
                 // so that `in_use` can properly detect that the handler is
                 // still in use.
                 //
                 // If the handler unwinds, the `RefMut` will ensure that the
                 // handler is no longer borrowed.
-                (handler)(event, event_loop);
+                callback(*user_app, event_loop);
             },
             Ok(None) => {
                 // `NSApplication`, our app delegate and this handler are all