api: refactor ActiveEventLoop into trait

This should help with further extensions because the backend event
loops are used directly now.

src/platform/android.rs

@@ -109,9 +109,11 @@ impl WindowExtAndroid for Window {
     }
 }
 
-impl ActiveEventLoopExtAndroid for ActiveEventLoop {
+impl ActiveEventLoopExtAndroid for &dyn ActiveEventLoop {
     fn android_app(&self) -> &AndroidApp {
-        &self.p.app
+        let event_loop =
+            self.as_any().downcast_ref::<crate::platform_impl::ActiveEventLoop>().unwrap();
+        &event_loop.app
     }
 }
 

src/platform/macos.rs

@@ -395,21 +395,37 @@ pub trait ActiveEventLoopExtMacOS {
     fn allows_automatic_window_tabbing(&self) -> bool;
 }
 
-impl ActiveEventLoopExtMacOS for ActiveEventLoop {
+impl ActiveEventLoopExtMacOS for &dyn ActiveEventLoop {
     fn hide_application(&self) {
-        self.p.hide_application()
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non macOS event loop on macOS");
+        event_loop.hide_application()
     }
 
     fn hide_other_applications(&self) {
-        self.p.hide_other_applications()
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non macOS event loop on macOS");
+        event_loop.hide_other_applications()
     }
 
     fn set_allows_automatic_window_tabbing(&self, enabled: bool) {
-        self.p.set_allows_automatic_window_tabbing(enabled);
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non macOS event loop on macOS");
+        event_loop.set_allows_automatic_window_tabbing(enabled);
     }
 
     fn allows_automatic_window_tabbing(&self) -> bool {
-        self.p.allows_automatic_window_tabbing()
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non macOS event loop on macOS");
+        event_loop.allows_automatic_window_tabbing()
     }
 }
 

src/platform/startup_notify.rs

@@ -25,6 +25,8 @@ use std::env;
 
 use crate::error::NotSupportedError;
 use crate::event_loop::{ActiveEventLoop, AsyncRequestSerial};
+#[cfg(wayland_platform)]
+use crate::platform::wayland::ActiveEventLoopExtWayland;
 use crate::window::{ActivationToken, Window, WindowAttributes};
 
 /// The variable which is used mostly on X11.
@@ -55,16 +57,18 @@ pub trait WindowAttributesExtStartupNotify {
     fn with_activation_token(self, token: ActivationToken) -> Self;
 }
 
-impl EventLoopExtStartupNotify for ActiveEventLoop {
+impl EventLoopExtStartupNotify for &dyn ActiveEventLoop {
     fn read_token_from_env(&self) -> Option<ActivationToken> {
-        match self.p {
-            #[cfg(wayland_platform)]
-            crate::platform_impl::ActiveEventLoop::Wayland(_) => env::var(WAYLAND_VAR),
-            #[cfg(x11_platform)]
-            crate::platform_impl::ActiveEventLoop::X(_) => env::var(X11_VAR),
+        #[cfg(x11_platform)]
+        let _is_wayland = false;
+        #[cfg(wayland_platform)]
+        let _is_wayland = self.is_wayland();
+
+        if _is_wayland {
+            env::var(WAYLAND_VAR).ok().map(ActivationToken::_new)
+        } else {
+            env::var(X11_VAR).ok().map(ActivationToken::_new)
         }
-        .ok()
-        .map(ActivationToken::_new)
     }
 }
 

src/platform/wayland.rs

@@ -24,10 +24,10 @@ pub trait ActiveEventLoopExtWayland {
     fn is_wayland(&self) -> bool;
 }
 
-impl ActiveEventLoopExtWayland for ActiveEventLoop {
+impl ActiveEventLoopExtWayland for &dyn ActiveEventLoop {
     #[inline]
     fn is_wayland(&self) -> bool {
-        self.p.is_wayland()
+        self.as_any().downcast_ref::<crate::platform_impl::wayland::ActiveEventLoop>().is_some()
     }
 }
 

src/platform/web.rs

@@ -94,7 +94,7 @@ pub trait WindowExtWeb {
 
     /// Returns whether using [`CursorGrabMode::Locked`] returns raw, un-accelerated mouse input.
     ///
-    /// This is the same as [`ActiveEventLoop::is_cursor_lock_raw()`], and is provided for
+    /// This is the same as [`ActiveEventLoopExtWeb::is_cursor_lock_raw()`], and is provided for
     /// convenience.
     ///
     /// [`CursorGrabMode::Locked`]: crate::window::CursorGrabMode::Locked
@@ -344,50 +344,86 @@ pub trait ActiveEventLoopExtWeb {
     fn has_detailed_monitor_permission(&self) -> bool;
 }
 
-impl ActiveEventLoopExtWeb for ActiveEventLoop {
+impl ActiveEventLoopExtWeb for &dyn ActiveEventLoop {
     #[inline]
     fn create_custom_cursor_async(&self, source: CustomCursorSource) -> CustomCursorFuture {
-        self.p.create_custom_cursor_async(source)
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non Web event loop on Web");
+        event_loop.create_custom_cursor_async(source)
     }
 
     #[inline]
     fn set_poll_strategy(&self, strategy: PollStrategy) {
-        self.p.set_poll_strategy(strategy);
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non Web event loop on Web");
+        event_loop.set_poll_strategy(strategy);
     }
 
     #[inline]
     fn poll_strategy(&self) -> PollStrategy {
-        self.p.poll_strategy()
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non Web event loop on Web");
+        event_loop.poll_strategy()
     }
 
     #[inline]
     fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy) {
-        self.p.set_wait_until_strategy(strategy);
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non Web event loop on Web");
+        event_loop.set_wait_until_strategy(strategy);
     }
 
     #[inline]
     fn wait_until_strategy(&self) -> WaitUntilStrategy {
-        self.p.wait_until_strategy()
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non Web event loop on Web");
+        event_loop.wait_until_strategy()
     }
 
     #[inline]
     fn is_cursor_lock_raw(&self) -> bool {
-        self.p.is_cursor_lock_raw()
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non Web event loop on Web");
+        event_loop.is_cursor_lock_raw()
     }
 
     #[inline]
     fn has_multiple_screens(&self) -> Result<bool, NotSupportedError> {
-        self.p.has_multiple_screens()
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non Web event loop on Web");
+        event_loop.has_multiple_screens()
     }
 
     #[inline]
     fn request_detailed_monitor_permission(&self) -> MonitorPermissionFuture {
-        MonitorPermissionFuture(self.p.request_detailed_monitor_permission())
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non Web event loop on Web");
+        MonitorPermissionFuture(event_loop.request_detailed_monitor_permission())
     }
 
     #[inline]
     fn has_detailed_monitor_permission(&self) -> bool {
-        self.p.has_detailed_monitor_permission()
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non Web event loop on Web");
+        event_loop.has_detailed_monitor_permission()
     }
 }
 
@@ -623,7 +659,7 @@ pub trait MonitorHandleExtWeb {
     /// [`false`] will always represent the current monitor the browser window is in instead of a
     /// specific monitor.
     ///
-    /// See [`ActiveEventLoop::request_detailed_monitor_permission()`].
+    /// See [`ActiveEventLoopExtWeb::request_detailed_monitor_permission()`].
     fn is_detailed(&self) -> bool;
 }
 

src/platform/x11.rs

@@ -91,10 +91,10 @@ pub trait ActiveEventLoopExtX11 {
     fn is_x11(&self) -> bool;
 }
 
-impl ActiveEventLoopExtX11 for ActiveEventLoop {
+impl ActiveEventLoopExtX11 for &dyn ActiveEventLoop {
     #[inline]
     fn is_x11(&self) -> bool {
-        !self.p.is_wayland()
+        self.as_any().downcast_ref::<crate::platform_impl::x11::ActiveEventLoop>().is_some()
     }
 }
 
@@ -187,7 +187,7 @@ pub trait WindowAttributesExtX11 {
     /// use winit::window::Window;
     /// use winit::event_loop::ActiveEventLoop;
     /// use winit::platform::x11::{XWindow, WindowAttributesExtX11};
-    /// # fn create_window(event_loop: &ActiveEventLoop) -> Result<(), Box<dyn std::error::Error>> {
+    /// # fn create_window(event_loop: &dyn ActiveEventLoop) -> Result<(), Box<dyn std::error::Error>> {
     /// let parent_window_id = std::env::args().nth(1).unwrap().parse::<XWindow>()?;
     /// let window_attributes = Window::default_attributes().with_embed_parent_window(parent_window_id);
     /// let window = event_loop.create_window(window_attributes)?;