event_loop: remove generic user event

Let the users wake up the event loop and then they could poll their
user sources.

Co-authored-by: Mads Marquart <mads@marquart.dk>
Co-authored-by: daxpedda <daxpedda@gmail.com>

src/platform_impl/windows/drop_handler.rs

@@ -25,7 +25,7 @@ pub struct FileDropHandlerData {
     pub interface: IDropTarget,
     refcount: AtomicUsize,
     window: HWND,
-    send_event: Box<dyn Fn(Event<()>)>,
+    send_event: Box<dyn Fn(Event)>,
     cursor_effect: u32,
     hovered_is_valid: bool, /* If the currently hovered item is not valid there must not be any
                              * `HoveredFileCancelled` emitted */
@@ -37,7 +37,7 @@ pub struct FileDropHandler {
 
 #[allow(non_snake_case)]
 impl FileDropHandler {
-    pub fn new(window: HWND, send_event: Box<dyn Fn(Event<()>)>) -> FileDropHandler {
+    pub(crate) fn new(window: HWND, send_event: Box<dyn Fn(Event)>) -> FileDropHandler {
         let data = Box::new(FileDropHandlerData {
             interface: IDropTarget { lpVtbl: &DROP_TARGET_VTBL as *const IDropTargetVtbl },
             refcount: AtomicUsize::new(1),
@@ -211,7 +211,7 @@ impl FileDropHandler {
 }
 
 impl FileDropHandlerData {
-    fn send_event(&self, event: Event<()>) {
+    fn send_event(&self, event: Event) {
         (self.send_event)(event);
     }
 }

src/platform_impl/windows/event_loop.rs

@@ -8,7 +8,6 @@ use std::ffi::c_void;
 use std::marker::PhantomData;
 use std::rc::Rc;
 use std::sync::atomic::{AtomicU32, Ordering};
-use std::sync::mpsc::{self, Receiver, Sender};
 use std::sync::{Arc, Mutex, MutexGuard};
 use std::time::{Duration, Instant};
 use std::{mem, panic, ptr};
@@ -63,7 +62,7 @@ use crate::error::EventLoopError;
 use crate::event::{
     DeviceEvent, Event, Force, Ime, InnerSizeWriter, RawKeyEvent, Touch, TouchPhase, WindowEvent,
 };
-use crate::event_loop::{ActiveEventLoop as RootAEL, ControlFlow, DeviceEvents, EventLoopClosed};
+use crate::event_loop::{ActiveEventLoop as RootAEL, ControlFlow, DeviceEvents};
 use crate::keyboard::ModifiersState;
 use crate::platform::pump_events::PumpStatus;
 use crate::platform_impl::platform::dark_mode::try_theme;
@@ -84,35 +83,14 @@ use crate::platform_impl::platform::{
 use crate::window::{
     CustomCursor as RootCustomCursor, CustomCursorSource, WindowId as RootWindowId,
 };
-use runner::{EventLoopRunner, EventLoopRunnerShared};
+use runner::EventLoopRunner;
 
 use super::window::set_skip_taskbar;
 use super::SelectedCursor;
 
-/// some backends like macos uses an uninhabited `Never` type,
-/// on windows, `UserEvent`s are also dispatched through the
-/// WNDPROC callback, and due to the re-entrant nature of the
-/// callback, recursively delivered events must be queued in a
-/// buffer, the current implementation put this queue in
-/// `EventLoopRunner`, which is shared between the event pumping
-/// loop and the callback. because it's hard to decide from the
-/// outside whether a event needs to be buffered, I decided not
-/// use `Event<Never>` for the shared runner state, but use unit
-/// as a placeholder so user events can be buffered as usual,
-/// the real `UserEvent` is pulled from the mpsc channel directly
-/// when the placeholder event is delivered to the event handler
-pub(crate) struct UserEventPlaceholder;
-
-// here below, the generic `EventLoopRunnerShared<T>` is replaced with
-// `EventLoopRunnerShared<UserEventPlaceholder>` so we can get rid
-// of the generic parameter T in types which don't depend on T.
-// this is the approach which requires minimum changes to current
-// backend implementation. it should be considered transitional
-// and should be refactored and cleaned up eventually, I hope.
-
 pub(crate) struct WindowData {
     pub window_state: Arc<Mutex<WindowState>>,
-    pub event_loop_runner: EventLoopRunnerShared<UserEventPlaceholder>,
+    pub event_loop_runner: Rc<EventLoopRunner>,
     pub key_event_builder: KeyEventBuilder,
     pub _file_drop_handler: Option<FileDropHandler>,
     pub userdata_removed: Cell<bool>,
@@ -120,7 +98,7 @@ pub(crate) struct WindowData {
 }
 
 impl WindowData {
-    fn send_event(&self, event: Event<UserEventPlaceholder>) {
+    fn send_event(&self, event: Event) {
         self.event_loop_runner.send_event(event);
     }
 
@@ -130,11 +108,11 @@ impl WindowData {
 }
 
 struct ThreadMsgTargetData {
-    event_loop_runner: EventLoopRunnerShared<UserEventPlaceholder>,
+    event_loop_runner: Rc<EventLoopRunner>,
 }
 
 impl ThreadMsgTargetData {
-    fn send_event(&self, event: Event<UserEventPlaceholder>) {
+    fn send_event(&self, event: Event) {
         self.event_loop_runner.send_event(event);
     }
 }
@@ -146,9 +124,7 @@ pub(crate) enum ProcResult {
     Value(isize),
 }
 
-pub struct EventLoop<T: 'static> {
-    user_event_sender: Sender<T>,
-    user_event_receiver: Receiver<T>,
+pub struct EventLoop {
     window_target: RootAEL,
     msg_hook: Option<Box<dyn FnMut(*const c_void) -> bool + 'static>>,
 }
@@ -168,10 +144,10 @@ impl Default for PlatformSpecificEventLoopAttributes {
 pub struct ActiveEventLoop {
     thread_id: u32,
     thread_msg_target: HWND,
-    pub(crate) runner_shared: EventLoopRunnerShared<UserEventPlaceholder>,
+    pub(crate) runner_shared: Rc<EventLoopRunner>,
 }
 
-impl<T: 'static> EventLoop<T> {
+impl EventLoop {
     pub(crate) fn new(
         attributes: &mut PlatformSpecificEventLoopAttributes,
     ) -> Result<Self, EventLoopError> {
@@ -194,7 +170,6 @@ impl<T: 'static> EventLoop<T> {
 
         let runner_shared = Rc::new(EventLoopRunner::new(thread_msg_target));
 
-        let (user_event_sender, user_event_receiver) = mpsc::channel();
         insert_event_target_window_data(thread_msg_target, runner_shared.clone());
         raw_input::register_all_mice_and_keyboards_for_raw_input(
             thread_msg_target,
@@ -202,8 +177,6 @@ impl<T: 'static> EventLoop<T> {
         );
 
         Ok(EventLoop {
-            user_event_sender,
-            user_event_receiver,
             window_target: RootAEL {
                 p: ActiveEventLoop { thread_id, thread_msg_target, runner_shared },
                 _marker: PhantomData,
@@ -216,11 +189,11 @@ impl<T: 'static> EventLoop<T> {
         &self.window_target
     }
 
-    pub fn run_app<A: ApplicationHandler<T>>(mut self, app: &mut A) -> Result<(), EventLoopError> {
+    pub fn run_app<A: ApplicationHandler>(mut self, app: &mut A) -> Result<(), EventLoopError> {
         self.run_app_on_demand(app)
     }
 
-    pub fn run_app_on_demand<A: ApplicationHandler<T>>(
+    pub fn run_app_on_demand<A: ApplicationHandler>(
         &mut self,
         app: &mut A,
     ) -> Result<(), EventLoopError> {
@@ -228,38 +201,24 @@ impl<T: 'static> EventLoop<T> {
             let runner = &self.window_target.p.runner_shared;
 
             let event_loop_windows_ref = &self.window_target;
-            let user_event_receiver = &self.user_event_receiver;
             // # Safety
             // We make sure to call runner.clear_event_handler() before
             // returning
             unsafe {
-                runner.set_event_handler(move |event| {
-                    match event {
-                        Event::NewEvents(cause) => app.new_events(event_loop_windows_ref, cause),
-                        Event::WindowEvent { window_id, event } => {
-                            app.window_event(event_loop_windows_ref, window_id, event)
-                        },
-                        Event::DeviceEvent { device_id, event } => {
-                            app.device_event(event_loop_windows_ref, device_id, event)
-                        },
-                        // The shared `EventLoopRunner` is not parameterized
-                        // `EventLoopProxy::send_event()` calls `PostMessage`
-                        // to wakeup and dispatch a placeholder `UserEvent`,
-                        // when we received the placeholder event here, the
-                        // real UserEvent(T) should already be put in the
-                        // mpsc channel and ready to be pulled
-                        Event::UserEvent(_) => {
-                            let event = user_event_receiver
-                                .try_recv()
-                                .expect("user event signaled but not received");
-                            app.user_event(event_loop_windows_ref, event);
-                        },
-                        Event::Suspended => app.suspended(event_loop_windows_ref),
-                        Event::Resumed => app.resumed(event_loop_windows_ref),
-                        Event::AboutToWait => app.about_to_wait(event_loop_windows_ref),
-                        Event::LoopExiting => app.exiting(event_loop_windows_ref),
-                        Event::MemoryWarning => app.memory_warning(event_loop_windows_ref),
-                    }
+                runner.set_event_handler(move |event| match event {
+                    Event::NewEvents(cause) => app.new_events(event_loop_windows_ref, cause),
+                    Event::WindowEvent { window_id, event } => {
+                        app.window_event(event_loop_windows_ref, window_id, event)
+                    },
+                    Event::DeviceEvent { device_id, event } => {
+                        app.device_event(event_loop_windows_ref, device_id, event)
+                    },
+                    Event::UserWakeUp => app.proxy_wake_up(event_loop_windows_ref),
+                    Event::Suspended => app.suspended(event_loop_windows_ref),
+                    Event::Resumed => app.resumed(event_loop_windows_ref),
+                    Event::AboutToWait => app.about_to_wait(event_loop_windows_ref),
+                    Event::LoopExiting => app.exiting(event_loop_windows_ref),
+                    Event::MemoryWarning => app.memory_warning(event_loop_windows_ref),
                 });
             }
         }
@@ -293,7 +252,7 @@ impl<T: 'static> EventLoop<T> {
         }
     }
 
-    pub fn pump_app_events<A: ApplicationHandler<T>>(
+    pub fn pump_app_events<A: ApplicationHandler>(
         &mut self,
         timeout: Option<Duration>,
         app: &mut A,
@@ -301,7 +260,7 @@ impl<T: 'static> EventLoop<T> {
         {
             let runner = &self.window_target.p.runner_shared;
             let event_loop_windows_ref = &self.window_target;
-            let user_event_receiver = &self.user_event_receiver;
+            // let user_event_receiver = &self.user_event_receiver;
 
             // # Safety
             // We make sure to call runner.clear_event_handler() before
@@ -311,33 +270,20 @@ impl<T: 'static> EventLoop<T> {
             // to leave the runner in an unsound state with an associated
             // event handler.
             unsafe {
-                runner.set_event_handler(move |event| {
-                    match event {
-                        Event::NewEvents(cause) => app.new_events(event_loop_windows_ref, cause),
-                        Event::WindowEvent { window_id, event } => {
-                            app.window_event(event_loop_windows_ref, window_id, event)
-                        },
-                        Event::DeviceEvent { device_id, event } => {
-                            app.device_event(event_loop_windows_ref, device_id, event)
-                        },
-                        // The shared `EventLoopRunner` is not parameterized
-                        // `EventLoopProxy::send_event()` calls `PostMessage`
-                        // to wakeup and dispatch a placeholder `UserEvent`,
-                        // when we received the placeholder event here, the
-                        // real UserEvent(T) should already be put in the
-                        // mpsc channel and ready to be pulled
-                        Event::UserEvent(_) => {
-                            let event = user_event_receiver
-                                .try_recv()
-                                .expect("user event signaled but not received");
-                            app.user_event(event_loop_windows_ref, event);
-                        },
-                        Event::Suspended => app.suspended(event_loop_windows_ref),
-                        Event::Resumed => app.resumed(event_loop_windows_ref),
-                        Event::AboutToWait => app.about_to_wait(event_loop_windows_ref),
-                        Event::LoopExiting => app.exiting(event_loop_windows_ref),
-                        Event::MemoryWarning => app.memory_warning(event_loop_windows_ref),
-                    }
+                runner.set_event_handler(move |event| match event {
+                    Event::NewEvents(cause) => app.new_events(event_loop_windows_ref, cause),
+                    Event::WindowEvent { window_id, event } => {
+                        app.window_event(event_loop_windows_ref, window_id, event)
+                    },
+                    Event::DeviceEvent { device_id, event } => {
+                        app.device_event(event_loop_windows_ref, device_id, event)
+                    },
+                    Event::UserWakeUp => app.proxy_wake_up(event_loop_windows_ref),
+                    Event::Suspended => app.suspended(event_loop_windows_ref),
+                    Event::Resumed => app.resumed(event_loop_windows_ref),
+                    Event::AboutToWait => app.about_to_wait(event_loop_windows_ref),
+                    Event::LoopExiting => app.exiting(event_loop_windows_ref),
+                    Event::MemoryWarning => app.memory_warning(event_loop_windows_ref),
                 });
 
                 runner.wakeup();
@@ -522,11 +468,8 @@ impl<T: 'static> EventLoop<T> {
         }
     }
 
-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
-        EventLoopProxy {
-            target_window: self.window_target.p.thread_msg_target,
-            event_send: self.user_event_sender.clone(),
-        }
+    pub fn create_proxy(&self) -> EventLoopProxy {
+        EventLoopProxy { target_window: self.window_target.p.thread_msg_target }
     }
 
     fn exit_code(&self) -> Option<i32> {
@@ -698,7 +641,7 @@ fn dur2timeout(dur: Duration) -> u32 {
         .unwrap_or(INFINITE)
 }
 
-impl<T> Drop for EventLoop<T> {
+impl Drop for EventLoop {
     fn drop(&mut self) {
         unsafe {
             DestroyWindow(self.window_target.p.thread_msg_target);
@@ -756,27 +699,16 @@ impl EventLoopThreadExecutor {
 
 type ThreadExecFn = Box<Box<dyn FnMut()>>;
 
-pub struct EventLoopProxy<T: 'static> {
+#[derive(Clone)]
+pub struct EventLoopProxy {
     target_window: HWND,
-    event_send: Sender<T>,
-}
-unsafe impl<T: Send + 'static> Send for EventLoopProxy<T> {}
-
-impl<T: 'static> Clone for EventLoopProxy<T> {
-    fn clone(&self) -> Self {
-        Self { target_window: self.target_window, event_send: self.event_send.clone() }
-    }
 }
 
-impl<T: 'static> EventLoopProxy<T> {
-    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        self.event_send
-            .send(event)
-            .map(|result| {
-                unsafe { PostMessageW(self.target_window, USER_EVENT_MSG_ID.get(), 0, 0) };
-                result
-            })
-            .map_err(|e| EventLoopClosed(e.0))
+unsafe impl Send for EventLoopProxy {}
+
+impl EventLoopProxy {
+    pub fn wake_up(&self) {
+        unsafe { PostMessageW(self.target_window, USER_EVENT_MSG_ID.get(), 0, 0) };
     }
 }
 
@@ -908,7 +840,7 @@ fn create_event_target_window() -> HWND {
 
 fn insert_event_target_window_data(
     thread_msg_target: HWND,
-    event_loop_runner: EventLoopRunnerShared<UserEventPlaceholder>,
+    event_loop_runner: Rc<EventLoopRunner>,
 ) {
     let userdata = ThreadMsgTargetData { event_loop_runner };
     let input_ptr = Box::into_raw(Box::new(userdata));
@@ -2454,7 +2386,7 @@ unsafe extern "system" fn thread_event_target_callback(
             // user event is still in the mpsc channel and will be pulled
             // once the placeholder event is delivered to the wrapper
             // `event_handler`
-            userdata.send_event(Event::UserEvent(UserEventPlaceholder));
+            userdata.send_event(Event::UserWakeUp);
             0
         },
         _ if msg == EXEC_MSG_ID.get() => {

src/platform_impl/windows/event_loop/runner.rs

@@ -1,7 +1,6 @@
 use std::any::Any;
 use std::cell::{Cell, RefCell};
 use std::collections::VecDeque;
-use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 use std::time::Instant;
 use std::{mem, panic};
@@ -16,11 +15,9 @@ use crate::window::WindowId;
 
 use super::ControlFlow;
 
-pub(crate) type EventLoopRunnerShared<T> = Rc<EventLoopRunner<T>>;
+type EventHandler = Cell<Option<Box<dyn FnMut(Event)>>>;
 
-type EventHandler<T> = Cell<Option<Box<dyn FnMut(Event<T>)>>>;
-
-pub(crate) struct EventLoopRunner<T: 'static> {
+pub(crate) struct EventLoopRunner {
     // The event loop's win32 handles
     pub(super) thread_msg_target: HWND,
 
@@ -33,8 +30,8 @@ pub(crate) struct EventLoopRunner<T: 'static> {
     exit: Cell<Option<i32>>,
     runner_state: Cell<RunnerState>,
     last_events_cleared: Cell<Instant>,
-    event_handler: EventHandler<T>,
-    event_buffer: RefCell<VecDeque<BufferedEvent<T>>>,
+    event_handler: EventHandler,
+    event_buffer: RefCell<VecDeque<BufferedEvent>>,
 
     panic_error: Cell<Option<PanicError>>,
 }
@@ -55,13 +52,13 @@ pub(crate) enum RunnerState {
     Destroyed,
 }
 
-enum BufferedEvent<T: 'static> {
-    Event(Event<T>),
+enum BufferedEvent {
+    Event(Event),
     ScaleFactorChanged(WindowId, f64, PhysicalSize<u32>),
 }
 
-impl<T> EventLoopRunner<T> {
-    pub(crate) fn new(thread_msg_target: HWND) -> EventLoopRunner<T> {
+impl EventLoopRunner {
+    pub(crate) fn new(thread_msg_target: HWND) -> EventLoopRunner {
         EventLoopRunner {
             thread_msg_target,
             interrupt_msg_dispatch: Cell::new(false),
@@ -88,13 +85,12 @@ impl<T> EventLoopRunner<T> {
     /// undefined behaviour.
     pub(crate) unsafe fn set_event_handler<F>(&self, f: F)
     where
-        F: FnMut(Event<T>),
+        F: FnMut(Event),
     {
         // Erase closure lifetime.
         // SAFETY: Caller upholds that the lifetime of the closure is upheld.
-        let f = unsafe {
-            mem::transmute::<Box<dyn FnMut(Event<T>)>, Box<dyn FnMut(Event<T>)>>(Box::new(f))
-        };
+        let f =
+            unsafe { mem::transmute::<Box<dyn FnMut(Event)>, Box<dyn FnMut(Event)>>(Box::new(f)) };
         let old_event_handler = self.event_handler.replace(Some(f));
         assert!(old_event_handler.is_none());
     }
@@ -124,7 +120,7 @@ impl<T> EventLoopRunner<T> {
 }
 
 /// State retrieval functions.
-impl<T> EventLoopRunner<T> {
+impl EventLoopRunner {
     #[allow(unused)]
     pub fn thread_msg_target(&self) -> HWND {
         self.thread_msg_target
@@ -166,7 +162,7 @@ impl<T> EventLoopRunner<T> {
 }
 
 /// Misc. functions
-impl<T> EventLoopRunner<T> {
+impl EventLoopRunner {
     pub fn catch_unwind<R>(&self, f: impl FnOnce() -> R) -> Option<R> {
         let panic_error = self.panic_error.take();
         if panic_error.is_none() {
@@ -196,7 +192,7 @@ impl<T> EventLoopRunner<T> {
 }
 
 /// Event dispatch functions.
-impl<T> EventLoopRunner<T> {
+impl EventLoopRunner {
     pub(crate) fn prepare_wait(&self) {
         self.move_state_to(RunnerState::Idle);
     }
@@ -205,7 +201,7 @@ impl<T> EventLoopRunner<T> {
         self.move_state_to(RunnerState::HandlingMainEvents);
     }
 
-    pub(crate) fn send_event(&self, event: Event<T>) {
+    pub(crate) fn send_event(&self, event: Event) {
         if let Event::WindowEvent { event: WindowEvent::RedrawRequested, .. } = event {
             self.call_event_handler(event);
             // As a rule, to ensure that `pump_events` can't block an external event loop
@@ -226,7 +222,7 @@ impl<T> EventLoopRunner<T> {
         self.move_state_to(RunnerState::Destroyed);
     }
 
-    fn call_event_handler(&self, event: Event<T>) {
+    fn call_event_handler(&self, event: Event) {
         self.catch_unwind(|| {
             let mut event_handler = self.event_handler.take().expect(
                 "either event handler is re-entrant (likely), or no event handler is registered \
@@ -358,8 +354,8 @@ impl<T> EventLoopRunner<T> {
     }
 }
 
-impl<T> BufferedEvent<T> {
-    pub fn from_event(event: Event<T>) -> BufferedEvent<T> {
+impl BufferedEvent {
+    pub fn from_event(event: Event) -> BufferedEvent {
         match event {
             Event::WindowEvent {
                 event: WindowEvent::ScaleFactorChanged { scale_factor, inner_size_writer },
@@ -373,7 +369,7 @@ impl<T> BufferedEvent<T> {
         }
     }
 
-    pub fn dispatch_event(self, dispatch: impl FnOnce(Event<T>)) {
+    pub fn dispatch_event(self, dispatch: impl FnOnce(Event)) {
         match self {
             Self::Event(event) => dispatch(event),
             Self::ScaleFactorChanged(window_id, scale_factor, new_inner_size) => {

src/platform_impl/windows/window.rs

@@ -1186,11 +1186,7 @@ impl<'a> InitData<'a> {
             let file_drop_runner = self.event_loop.runner_shared.clone();
             let file_drop_handler = FileDropHandler::new(
                 win.window,
-                Box::new(move |event| {
-                    if let Ok(e) = event.map_nonuser_event() {
-                        file_drop_runner.send_event(e)
-                    }
-                }),
+                Box::new(move |event| file_drop_runner.send_event(event)),
             );
 
             let handler_interface_ptr =