winit-core: move monitor handle

src/platform_impl/apple/appkit/monitor.rs

@@ -79,14 +79,14 @@ impl VideoModeHandle {
                 unimplemented!()
             };
 
-            let mode = VideoMode {
-                size: PhysicalSize::new(
+            let mode = VideoMode::new(
+                PhysicalSize::new(
                     CGDisplayMode::pixel_width(Some(&native_mode.0)) as u32,
                     CGDisplayMode::pixel_height(Some(&native_mode.0)) as u32,
                 ),
+                NonZeroU16::new(bit_depth),
                 refresh_rate_millihertz,
-                bit_depth: NonZeroU16::new(bit_depth),
-            };
+            );
 
             VideoModeHandle { mode, monitor: monitor.clone(), native_mode }
         }

src/platform_impl/apple/uikit/monitor.rs

@@ -55,11 +55,11 @@ impl VideoModeHandle {
     ) -> VideoModeHandle {
         let refresh_rate_millihertz = refresh_rate_millihertz(&uiscreen);
         let size = screen_mode.size();
-        let mode = VideoMode {
-            size: (size.width as u32, size.height as u32).into(),
-            bit_depth: None,
+        let mode = VideoMode::new(
+            (size.width as u32, size.height as u32).into(),
+            None,
             refresh_rate_millihertz,
-        };
+        );
 
         VideoModeHandle {
             mode,

src/platform_impl/linux/wayland/output.rs

@@ -83,9 +83,9 @@ impl Eq for MonitorHandle {}
 
 /// Convert the 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),
-    }
+    VideoMode::new(
+        (mode.dimensions.0, mode.dimensions.1).into(),
+        None,
+        NonZeroU32::new(mode.refresh_rate as u32),
+    )
 }

src/platform_impl/linux/x11/util/randr.rs

@@ -85,11 +85,11 @@ impl XConnection {
             .filter(|x| output_modes.iter().any(|id| x.id == *id))
             .map(|mode| VideoModeHandle {
                 current: mode.id == current_mode,
-                mode: VideoMode {
-                    size: (mode.width as u32, mode.height as u32).into(),
-                    refresh_rate_millihertz: monitor::mode_refresh_rate_millihertz(mode),
-                    bit_depth: NonZeroU16::new(bit_depth as u16),
-                },
+                mode: VideoMode::new(
+                    (mode.width as u32, mode.height as u32).into(),
+                    NonZeroU16::new(bit_depth as u16),
+                    monitor::mode_refresh_rate_millihertz(mode),
+                ),
                 native_mode: mode.id,
             })
             .collect();

src/platform_impl/web/monitor.rs

@@ -141,11 +141,11 @@ impl MonitorHandleProvider for MonitorHandle {
     }
 
     fn current_video_mode(&self) -> Option<VideoMode> {
-        Some(VideoMode {
-            size: self.inner.queue(|inner| inner.size()),
-            bit_depth: self.inner.queue(|inner| inner.bit_depth()),
-            refresh_rate_millihertz: None,
-        })
+        Some(VideoMode::new(
+            self.inner.queue(|inner| inner.size()),
+            self.inner.queue(|inner| inner.bit_depth()),
+            None,
+        ))
     }
 
     fn video_modes(&self) -> Box<dyn Iterator<Item = VideoMode>> {

src/platform_impl/windows/monitor.rs

@@ -50,11 +50,11 @@ impl VideoModeHandle {
             DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY;
         assert!(has_flag(native_video_mode.dmFields, REQUIRED_FIELDS));
 
-        let mode = VideoMode {
-            size: (native_video_mode.dmPelsWidth, native_video_mode.dmPelsHeight).into(),
-            bit_depth: NonZeroU16::new(native_video_mode.dmBitsPerPel as u16),
-            refresh_rate_millihertz: NonZeroU32::new(native_video_mode.dmDisplayFrequency * 1000),
-        };
+        let mode = VideoMode::new(
+            (native_video_mode.dmPelsWidth, native_video_mode.dmPelsHeight).into(),
+            NonZeroU16::new(native_video_mode.dmBitsPerPel as u16),
+            NonZeroU32::new(native_video_mode.dmDisplayFrequency * 1000),
+        );
 
         VideoModeHandle { mode, native_video_mode: Box::new(native_video_mode) }
     }