api: make EventLoopProxy wrap an opaque type

The proxy is intended to be Clone, thus use `Arc` for it internally and
don't require backends for it to be `Clone`. Use `EventLoopProxyProvider`
to hide the backend's proxy implementation details.

Co-authored-by: daxpedda <daxpedda@gmail.com>

src/platform_impl/linux/mod.rs

@@ -277,14 +277,6 @@ pub enum EventLoop {
     X(x11::EventLoop),
 }
 
-#[derive(Clone)]
-pub enum EventLoopProxy {
-    #[cfg(x11_platform)]
-    X(x11::EventLoopProxy),
-    #[cfg(wayland_platform)]
-    Wayland(wayland::EventLoopProxy),
-}
-
 impl EventLoop {
     pub(crate) fn new(
         attributes: &PlatformSpecificEventLoopAttributes,
@@ -404,12 +396,6 @@ impl AsRawFd for EventLoop {
     }
 }
 
-impl EventLoopProxy {
-    pub fn wake_up(&self) {
-        x11_or_wayland!(match self; EventLoopProxy(proxy) => proxy.wake_up())
-    }
-}
-
 #[derive(Clone)]
 #[allow(dead_code)]
 pub(crate) enum OwnedDisplayHandle {

src/platform_impl/linux/wayland/event_loop/mod.rs

@@ -25,12 +25,13 @@ use crate::window::{CustomCursor as RootCustomCursor, CustomCursorSource, Theme}
 mod proxy;
 pub mod sink;
 
-pub use proxy::EventLoopProxy;
+use proxy::EventLoopProxy;
 use sink::EventSink;
 
 use super::state::{WindowCompositorUpdate, WinitState};
 use super::window::state::FrameCallbackState;
 use super::{logical_to_physical_rounded, WindowId};
+pub use crate::event_loop::EventLoopProxy as CoreEventLoopProxy;
 
 type WaylandDispatcher = calloop::Dispatcher<'static, WaylandSource<WinitState>, WinitState>;
 
@@ -120,7 +121,7 @@ impl EventLoop {
             connection: connection.clone(),
             wayland_dispatcher: wayland_dispatcher.clone(),
             event_loop_awakener,
-            event_loop_proxy: EventLoopProxy::new(ping),
+            event_loop_proxy: EventLoopProxy::new(ping).into(),
             queue_handle,
             control_flow: Cell::new(ControlFlow::default()),
             exit: Cell::new(None),
@@ -539,7 +540,7 @@ impl AsRawFd for EventLoop {
 
 pub struct ActiveEventLoop {
     /// Event loop proxy
-    event_loop_proxy: EventLoopProxy,
+    event_loop_proxy: CoreEventLoopProxy,
 
     /// The event loop wakeup source.
     pub event_loop_awakener: calloop::ping::Ping,
@@ -565,12 +566,8 @@ pub struct ActiveEventLoop {
 }
 
 impl RootActiveEventLoop for ActiveEventLoop {
-    fn create_proxy(&self) -> crate::event_loop::EventLoopProxy {
-        crate::event_loop::EventLoopProxy {
-            event_loop_proxy: crate::platform_impl::EventLoopProxy::Wayland(
-                self.event_loop_proxy.clone(),
-            ),
-        }
+    fn create_proxy(&self) -> CoreEventLoopProxy {
+        self.event_loop_proxy.clone()
     }
 
     fn set_control_flow(&self, control_flow: ControlFlow) {

src/platform_impl/linux/wayland/event_loop/proxy.rs

@@ -1,19 +1,30 @@
 //! An event loop proxy.
 
+use std::sync::Arc;
+
 use sctk::reexports::calloop::ping::Ping;
 
+use crate::event_loop::{EventLoopProxy as CoreEventLoopProxy, EventLoopProxyProvider};
+
 /// A handle that can be sent across the threads and used to wake up the `EventLoop`.
-#[derive(Clone)]
 pub struct EventLoopProxy {
     ping: Ping,
 }
 
+impl EventLoopProxyProvider for EventLoopProxy {
+    fn wake_up(&self) {
+        self.ping.ping();
+    }
+}
+
 impl EventLoopProxy {
     pub fn new(ping: Ping) -> Self {
         Self { ping }
     }
+}
 
-    pub fn wake_up(&self) {
-        self.ping.ping();
+impl From<EventLoopProxy> for CoreEventLoopProxy {
+    fn from(value: EventLoopProxy) -> Self {
+        CoreEventLoopProxy::new(Arc::new(value))
     }
 }

src/platform_impl/linux/wayland/mod.rs

@@ -1,6 +1,6 @@
 //! Winit's Wayland backend.
 
-pub use event_loop::{ActiveEventLoop, EventLoop, EventLoopProxy};
+pub use event_loop::{ActiveEventLoop, EventLoop};
 pub use output::{MonitorHandle, VideoModeHandle};
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
 use sctk::reexports::client::Proxy;

src/platform_impl/linux/x11/mod.rs

@@ -27,6 +27,7 @@ use crate::error::{EventLoopError, RequestError};
 use crate::event::{DeviceId, Event, StartCause, WindowEvent};
 use crate::event_loop::{
     ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
+    EventLoopProxy as CoreEventLoopProxy, EventLoopProxyProvider,
     OwnedDisplayHandle as RootOwnedDisplayHandle,
 };
 use crate::platform::pump_events::PumpStatus;
@@ -139,7 +140,7 @@ pub struct ActiveEventLoop {
     windows: RefCell<HashMap<WindowId, Weak<UnownedWindow>>>,
     redraw_sender: WakeSender<WindowId>,
     activation_sender: WakeSender<ActivationToken>,
-    event_loop_proxy: EventLoopProxy,
+    event_loop_proxy: CoreEventLoopProxy,
     device_events: Cell<DeviceEvents>,
 }
 
@@ -306,7 +307,7 @@ impl EventLoop {
                 sender: activation_token_sender, // not used again so no clone
                 waker: waker.clone(),
             },
-            event_loop_proxy,
+            event_loop_proxy: event_loop_proxy.into(),
             device_events: Default::default(),
         };
 
@@ -675,12 +676,8 @@ impl ActiveEventLoop {
 }
 
 impl RootActiveEventLoop for ActiveEventLoop {
-    fn create_proxy(&self) -> crate::event_loop::EventLoopProxy {
-        crate::event_loop::EventLoopProxy {
-            event_loop_proxy: crate::platform_impl::EventLoopProxy::X(
-                self.event_loop_proxy.clone(),
-            ),
-        }
+    fn create_proxy(&self) -> CoreEventLoopProxy {
+        self.event_loop_proxy.clone()
     }
 
     fn create_window(
@@ -759,12 +756,6 @@ impl rwh_06::HasDisplayHandle for ActiveEventLoop {
     }
 }
 
-impl EventLoopProxy {
-    pub fn wake_up(&self) {
-        self.ping.ping();
-    }
-}
-
 struct DeviceInfo<'a> {
     xconn: &'a XConnection,
     info: *const ffi::XIDeviceInfo,
@@ -807,12 +798,24 @@ pub struct EventLoopProxy {
     ping: Ping,
 }
 
+impl EventLoopProxyProvider for EventLoopProxy {
+    fn wake_up(&self) {
+        self.ping.ping();
+    }
+}
+
 impl EventLoopProxy {
     fn new(ping: Ping) -> Self {
         Self { ping }
     }
 }
 
+impl From<EventLoopProxy> for CoreEventLoopProxy {
+    fn from(value: EventLoopProxy) -> Self {
+        CoreEventLoopProxy::new(Arc::new(value))
+    }
+}
+
 /// Generic sum error type for X11 errors.
 #[derive(Debug)]
 pub enum X11Error {