api: make VideoModeHandle into VideoMode

The video mode is generally a static data and not a reference to some
video mode. This changes the exclusive fullscreen API to match that an
accept a monitor now.

src/platform_impl/linux/wayland/mod.rs

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

src/platform_impl/linux/wayland/output.rs

@@ -1,11 +1,11 @@
-use std::num::{NonZeroU16, NonZeroU32};
+use std::num::NonZeroU32;
 
 use sctk::output::{Mode, OutputData};
 use sctk::reexports::client::protocol::wl_output::WlOutput;
 use sctk::reexports::client::Proxy;
 
-use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
-use crate::platform_impl::platform::VideoModeHandle as PlatformVideoModeHandle;
+use crate::dpi::{LogicalPosition, PhysicalPosition};
+use crate::monitor::VideoMode;
 
 #[derive(Clone, Debug)]
 pub struct MonitorHandle {
@@ -54,27 +54,19 @@ impl MonitorHandle {
     }
 
     #[inline]
-    pub fn current_video_mode(&self) -> Option<PlatformVideoModeHandle> {
+    pub fn current_video_mode(&self) -> Option<VideoMode> {
         let output_data = self.proxy.data::<OutputData>().unwrap();
         output_data.with_output_info(|info| {
             let mode = info.modes.iter().find(|mode| mode.current).cloned();
-
-            mode.map(|mode| {
-                PlatformVideoModeHandle::Wayland(VideoModeHandle::new(self.clone(), mode))
-            })
+            mode.map(wayland_mode_to_core_mode)
         })
     }
 
     #[inline]
-    pub fn video_modes(&self) -> impl Iterator<Item = PlatformVideoModeHandle> {
+    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
         let output_data = self.proxy.data::<OutputData>().unwrap();
         let modes = output_data.with_output_info(|info| info.modes.clone());
-
-        let monitor = self.clone();
-
-        modes.into_iter().map(move |mode| {
-            PlatformVideoModeHandle::Wayland(VideoModeHandle::new(monitor.clone(), mode))
-        })
+        modes.into_iter().map(wayland_mode_to_core_mode)
     }
 }
 
@@ -104,38 +96,11 @@ impl std::hash::Hash for MonitorHandle {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct VideoModeHandle {
-    pub(crate) size: PhysicalSize<u32>,
-    pub(crate) refresh_rate_millihertz: Option<NonZeroU32>,
-    pub(crate) monitor: MonitorHandle,
-}
-
-impl VideoModeHandle {
-    fn new(monitor: MonitorHandle, mode: Mode) -> Self {
-        VideoModeHandle {
-            size: (mode.dimensions.0 as u32, mode.dimensions.1 as u32).into(),
-            refresh_rate_millihertz: NonZeroU32::new(mode.refresh_rate as u32),
-            monitor: monitor.clone(),
-        }
-    }
-
-    #[inline]
-    pub fn size(&self) -> PhysicalSize<u32> {
-        self.size
-    }
-
-    #[inline]
-    pub fn bit_depth(&self) -> Option<NonZeroU16> {
-        None
-    }
-
-    #[inline]
-    pub fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
-        self.refresh_rate_millihertz
-    }
-
-    pub fn monitor(&self) -> MonitorHandle {
-        self.monitor.clone()
+/// Convert Wayland's [`Mode`] to winit's [`VideoMode`].
+fn wayland_mode_to_core_mode(mode: Mode) -> VideoMode {
+    VideoMode {
+        size: (mode.dimensions.0, mode.dimensions.1).into(),
+        bit_depth: None,
+        refresh_rate_millihertz: NonZeroU32::new(mode.refresh_rate as u32),
     }
 }

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

@@ -139,7 +139,7 @@ impl Window {
 
         // Set startup mode.
         match attributes.fullscreen.map(Into::into) {
-            Some(Fullscreen::Exclusive(_)) => {
+            Some(Fullscreen::Exclusive(..)) => {
                 warn!("`Fullscreen::Exclusive` is ignored on Wayland");
             },
             #[cfg_attr(not(x11_platform), allow(clippy::bind_instead_of_map))]
@@ -438,7 +438,7 @@ impl CoreWindow for Window {
 
     fn set_fullscreen(&self, fullscreen: Option<CoreFullscreen>) {
         match fullscreen {
-            Some(CoreFullscreen::Exclusive(_)) => {
+            Some(CoreFullscreen::Exclusive(..)) => {
                 warn!("`Fullscreen::Exclusive` is ignored on Wayland");
             },
             #[cfg_attr(not(x11_platform), allow(clippy::bind_instead_of_map))]