Add exclusive fullscreen mode (#925)

* Add exclusive fullscreen mode

* Add `WindowExtMacOS::set_fullscreen_presentation_options`

* Capture display for exclusive fullscreen on macOS

* Fix applying video mode on macOS after a fullscreen cycle

* Fix compilation on iOS

* Set monitor appropriately for fullscreen on macOS

* Fix exclusive to borderless fullscreen transitions on macOS

* Fix borderless to exclusive fullscreen transition on macOS

* Sort video modes on Windows

* Fix fullscreen issues on Windows

* Fix video mode changes during exclusive fullscreen on Windows

* Add video mode sorting for macOS and iOS

* Fix monitor `ns_screen` returning `None` after video mode change

* Fix "multithreaded" example on macOS

* Restore video mode upon closing an exclusive fullscreen window

* Fix "multithreaded" example closing multiple windows at once

* Fix compilation on Linux

* Update FEATURES.md

* Don't care about logical monitor groups on X11

* Add exclusive fullscreen for X11

* Update FEATURES.md

* Fix transitions between exclusive and borderless fullscreen on X11

* Update CHANGELOG.md

* Document that Wayland doesn't support exclusive fullscreen

* Replace core-graphics display mode bindings on macOS

* Use `panic!()` instead of `unreachable!()` in "fullscreen" example

* Fix fullscreen "always on top" flag on Windows

* Track current monitor for fullscreen in "multithreaded" example

* Fix exclusive fullscreen sometimes not positioning window properly

* Format

* More formatting and fix CI issues

* Fix formatting

* Fix changelog formatting

src/monitor.rs

@@ -52,17 +52,41 @@ impl Iterator for AvailableMonitorsIter {
 /// - [`MonitorHandle::video_modes`][monitor_get].
 ///
 /// [monitor_get]: ../monitor/struct.MonitorHandle.html#method.video_modes
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+#[derive(Derivative)]
+#[derivative(Clone, Debug = "transparent", PartialEq, Eq, Hash)]
 pub struct VideoMode {
-    pub(crate) size: (u32, u32),
-    pub(crate) bit_depth: u16,
-    pub(crate) refresh_rate: u16,
+    pub(crate) video_mode: platform_impl::VideoMode,
+}
+
+impl PartialOrd for VideoMode {
+    fn partial_cmp(&self, other: &VideoMode) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for VideoMode {
+    fn cmp(&self, other: &VideoMode) -> std::cmp::Ordering {
+        // TODO: we can impl `Ord` for `PhysicalSize` once we switch from `f32`
+        // to `u32` there
+        let size: (u32, u32) = self.size().into();
+        let other_size: (u32, u32) = other.size().into();
+        self.monitor().cmp(&other.monitor()).then(
+            size.cmp(&other_size)
+                .then(
+                    self.refresh_rate()
+                        .cmp(&other.refresh_rate())
+                        .then(self.bit_depth().cmp(&other.bit_depth())),
+                )
+                .reverse(),
+        )
+    }
 }
 
 impl VideoMode {
     /// Returns the resolution of this video mode.
+    #[inline]
     pub fn size(&self) -> PhysicalSize {
-        self.size.into()
+        self.video_mode.size()
     }
 
     /// Returns the bit depth of this video mode, as in how many bits you have
@@ -73,15 +97,37 @@ impl VideoMode {
     ///
     /// - **Wayland:** Always returns 32.
     /// - **iOS:** Always returns 32.
+    #[inline]
     pub fn bit_depth(&self) -> u16 {
-        self.bit_depth
+        self.video_mode.bit_depth()
     }
 
     /// Returns the refresh rate of this video mode. **Note**: the returned
     /// refresh rate is an integer approximation, and you shouldn't rely on this
     /// value to be exact.
+    #[inline]
     pub fn refresh_rate(&self) -> u16 {
-        self.refresh_rate
+        self.video_mode.refresh_rate()
+    }
+
+    /// Returns the monitor that this video mode is valid for. Each monitor has
+    /// a separate set of valid video modes.
+    #[inline]
+    pub fn monitor(&self) -> MonitorHandle {
+        self.video_mode.monitor()
+    }
+}
+
+impl std::fmt::Display for VideoMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}x{} @ {} Hz ({} bpp)",
+            self.size().width,
+            self.size().height,
+            self.refresh_rate(),
+            self.bit_depth()
+        )
     }
 }
 
@@ -90,7 +136,7 @@ impl VideoMode {
 /// Allows you to retrieve information about a given monitor and can be used in [`Window`] creation.
 ///
 /// [`Window`]: ../window/struct.Window.html
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct MonitorHandle {
     pub(crate) inner: platform_impl::MonitorHandle,
 }