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/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;