Vendor things

third-party/vendor/winit/src/dpi.rs

@@ -0,0 +1,583 @@
+//! UI scaling is important, so read the docs for this module if you don't want to be confused.
+//!
+//! ## Why should I care about UI scaling?
+//!
+//! Modern computer screens don't have a consistent relationship between resolution and size.
+//! 1920x1080 is a common resolution for both desktop and mobile screens, despite mobile screens
+//! normally being less than a quarter the size of their desktop counterparts. What's more, neither
+//! desktop nor mobile screens are consistent resolutions within their own size classes - common
+//! mobile screens range from below 720p to above 1440p, and desktop screens range from 720p to 5K
+//! and beyond.
+//!
+//! Given that, it's a mistake to assume that 2D content will only be displayed on screens with
+//! a consistent pixel density. If you were to render a 96-pixel-square image on a 1080p screen,
+//! then render the same image on a similarly-sized 4K screen, the 4K rendition would only take up
+//! about a quarter of the physical space as it did on the 1080p screen. That issue is especially
+//! problematic with text rendering, where quarter-sized text becomes a significant legibility
+//! problem.
+//!
+//! Failure to account for the scale factor can create a significantly degraded user experience.
+//! Most notably, it can make users feel like they have bad eyesight, which will potentially cause
+//! them to think about growing elderly, resulting in them having an existential crisis. Once users
+//! enter that state, they will no longer be focused on your application.
+//!
+//! ## How should I handle it?
+//!
+//! The solution to this problem is to account for the device's *scale factor*. The scale factor is
+//! the factor UI elements should be scaled by to be consistent with the rest of the user's system -
+//! for example, a button that's normally 50 pixels across would be 100 pixels across on a device
+//! with a scale factor of `2.0`, or 75 pixels across with a scale factor of `1.5`.
+//!
+//! Many UI systems, such as CSS, expose DPI-dependent units like [points] or [picas]. That's
+//! usually a mistake, since there's no consistent mapping between the scale factor and the screen's
+//! actual DPI. Unless you're printing to a physical medium, you should work in scaled pixels rather
+//! than any DPI-dependent units.
+//!
+//! ### Position and Size types
+//!
+//! Winit's [`PhysicalPosition`] / [`PhysicalSize`] types correspond with the actual pixels on the
+//! device, and the [`LogicalPosition`] / [`LogicalSize`] types correspond to the physical pixels
+//! divided by the scale factor.
+//! All of Winit's functions return physical types, but can take either logical or physical
+//! coordinates as input, allowing you to use the most convenient coordinate system for your
+//! particular application.
+//!
+//! Winit's position and size types types are generic over their exact pixel type, `P`, to allow the
+//! API to have integer precision where appropriate (e.g. most window manipulation functions) and
+//! floating precision when necessary (e.g. logical sizes for fractional scale factors and touch
+//! input). If `P` is a floating-point type, please do not cast the values with `as {int}`. Doing so
+//! will truncate the fractional part of the float, rather than properly round to the nearest
+//! integer. Use the provided `cast` function or [`From`]/[`Into`] conversions, which handle the
+//! rounding properly. Note that precision loss will still occur when rounding from a float to an
+//! int, although rounding lessens the problem.
+//!
+//! ### Events
+//!
+//! Winit will dispatch a [`ScaleFactorChanged`] event whenever a window's scale factor has changed.
+//! This can happen if the user drags their window from a standard-resolution monitor to a high-DPI
+//! monitor, or if the user changes their DPI settings. This gives you a chance to rescale your
+//! application's UI elements and adjust how the platform changes the window's size to reflect the new
+//! scale factor. If a window hasn't received a [`ScaleFactorChanged`] event,  then its scale factor
+//! can be found by calling [`window.scale_factor()`].
+//!
+//! ## How is the scale factor calculated?
+//!
+//! Scale factor is calculated differently on different platforms:
+//!
+//! - **Windows:** On Windows 8 and 10, per-monitor scaling is readily configured by users from the
+//!   display settings. While users are free to select any option they want, they're only given a
+//!   selection of "nice" scale factors, i.e. 1.0, 1.25, 1.5... on Windows 7, the scale factor is
+//!   global and changing it requires logging out. See [this article][windows_1] for technical
+//!   details.
+//! - **macOS:** Recent versions of macOS allow the user to change the scaling factor for certain
+//!   displays. When this is available, the user may pick a per-monitor scaling factor from a set
+//!   of pre-defined settings. All "retina displays" have a scaling factor above 1.0 by default but
+//!   the specific value varies across devices.
+//! - **X11:** Many man-hours have been spent trying to figure out how to handle DPI in X11. Winit
+//!   currently uses a three-pronged approach:
+//!   + Use the value in the `WINIT_X11_SCALE_FACTOR` environment variable, if present.
+//!   + If not present, use the value set in `Xft.dpi` in Xresources.
+//!   + Otherwise, calculate the scale factor based on the millimeter monitor dimensions provided by XRandR.
+//!
+//!   If `WINIT_X11_SCALE_FACTOR` is set to `randr`, it'll ignore the `Xft.dpi` field and use the
+//!   XRandR scaling method. Generally speaking, you should try to configure the standard system
+//!   variables to do what you want before resorting to `WINIT_X11_SCALE_FACTOR`.
+//! - **Wayland:** On Wayland, scale factors are set per-screen by the server, and are always
+//!   integers (most often 1 or 2).
+//! - **iOS:** Scale factors are set by Apple to the value that best suits the device, and range
+//!   from `1.0` to `3.0`. See [this article][apple_1] and [this article][apple_2] for more
+//!   information.
+//! - **Android:** Scale factors are set by the manufacturer to the value that best suits the
+//!   device, and range from `1.0` to `4.0`. See [this article][android_1] for more information.
+//! - **Web:** The scale factor is the ratio between CSS pixels and the physical device pixels.
+//!   In other words, it is the value of [`window.devicePixelRatio`][web_1]. It is affected by
+//!   both the screen scaling and the browser zoom level and can go below `1.0`.
+//!
+//!
+//! [points]: https://en.wikipedia.org/wiki/Point_(typography)
+//! [picas]: https://en.wikipedia.org/wiki/Pica_(typography)
+//! [`ScaleFactorChanged`]: crate::event::WindowEvent::ScaleFactorChanged
+//! [`window.scale_factor()`]: crate::window::Window::scale_factor
+//! [windows_1]: https://docs.microsoft.com/en-us/windows/win32/hidpi/high-dpi-desktop-application-development-on-windows
+//! [apple_1]: https://developer.apple.com/library/archive/documentation/DeviceInformation/Reference/iOSDeviceCompatibility/Displays/Displays.html
+//! [apple_2]: https://developer.apple.com/design/human-interface-guidelines/macos/icons-and-images/image-size-and-resolution/
+//! [android_1]: https://developer.android.com/training/multiscreen/screendensities
+//! [web_1]: https://developer.mozilla.org/en-US/docs/Web/API/Window/devicePixelRatio
+
+pub trait Pixel: Copy + Into<f64> {
+    fn from_f64(f: f64) -> Self;
+    fn cast<P: Pixel>(self) -> P {
+        P::from_f64(self.into())
+    }
+}
+
+impl Pixel for u8 {
+    fn from_f64(f: f64) -> Self {
+        f.round() as u8
+    }
+}
+impl Pixel for u16 {
+    fn from_f64(f: f64) -> Self {
+        f.round() as u16
+    }
+}
+impl Pixel for u32 {
+    fn from_f64(f: f64) -> Self {
+        f.round() as u32
+    }
+}
+impl Pixel for i8 {
+    fn from_f64(f: f64) -> Self {
+        f.round() as i8
+    }
+}
+impl Pixel for i16 {
+    fn from_f64(f: f64) -> Self {
+        f.round() as i16
+    }
+}
+impl Pixel for i32 {
+    fn from_f64(f: f64) -> Self {
+        f.round() as i32
+    }
+}
+impl Pixel for f32 {
+    fn from_f64(f: f64) -> Self {
+        f as f32
+    }
+}
+impl Pixel for f64 {
+    fn from_f64(f: f64) -> Self {
+        f
+    }
+}
+
+/// Checks that the scale factor is a normal positive `f64`.
+///
+/// All functions that take a scale factor assert that this will return `true`. If you're sourcing scale factors from
+/// anywhere other than winit, it's recommended to validate them using this function before passing them to winit;
+/// otherwise, you risk panics.
+#[inline]
+pub fn validate_scale_factor(scale_factor: f64) -> bool {
+    scale_factor.is_sign_positive() && scale_factor.is_normal()
+}
+
+/// A position represented in logical pixels.
+///
+/// The position is stored as floats, so please be careful. Casting floats to integers truncates the
+/// fractional part, which can cause noticable issues. To help with that, an `Into<(i32, i32)>`
+/// implementation is provided which does the rounding for you.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct LogicalPosition<P> {
+    pub x: P,
+    pub y: P,
+}
+
+impl<P> LogicalPosition<P> {
+    #[inline]
+    pub const fn new(x: P, y: P) -> Self {
+        LogicalPosition { x, y }
+    }
+}
+
+impl<P: Pixel> LogicalPosition<P> {
+    #[inline]
+    pub fn from_physical<T: Into<PhysicalPosition<X>>, X: Pixel>(
+        physical: T,
+        scale_factor: f64,
+    ) -> Self {
+        physical.into().to_logical(scale_factor)
+    }
+
+    #[inline]
+    pub fn to_physical<X: Pixel>(&self, scale_factor: f64) -> PhysicalPosition<X> {
+        assert!(validate_scale_factor(scale_factor));
+        let x = self.x.into() * scale_factor;
+        let y = self.y.into() * scale_factor;
+        PhysicalPosition::new(x, y).cast()
+    }
+
+    #[inline]
+    pub fn cast<X: Pixel>(&self) -> LogicalPosition<X> {
+        LogicalPosition {
+            x: self.x.cast(),
+            y: self.y.cast(),
+        }
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<(X, X)> for LogicalPosition<P> {
+    fn from((x, y): (X, X)) -> LogicalPosition<P> {
+        LogicalPosition::new(x.cast(), y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<LogicalPosition<P>> for (X, X) {
+    fn from(p: LogicalPosition<P>) -> (X, X) {
+        (p.x.cast(), p.y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<[X; 2]> for LogicalPosition<P> {
+    fn from([x, y]: [X; 2]) -> LogicalPosition<P> {
+        LogicalPosition::new(x.cast(), y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<LogicalPosition<P>> for [X; 2] {
+    fn from(p: LogicalPosition<P>) -> [X; 2] {
+        [p.x.cast(), p.y.cast()]
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<mint::Point2<P>> for LogicalPosition<P> {
+    fn from(p: mint::Point2<P>) -> Self {
+        Self::new(p.x, p.y)
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<LogicalPosition<P>> for mint::Point2<P> {
+    fn from(p: LogicalPosition<P>) -> Self {
+        mint::Point2 { x: p.x, y: p.y }
+    }
+}
+
+/// A position represented in physical pixels.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct PhysicalPosition<P> {
+    pub x: P,
+    pub y: P,
+}
+
+impl<P> PhysicalPosition<P> {
+    #[inline]
+    pub const fn new(x: P, y: P) -> Self {
+        PhysicalPosition { x, y }
+    }
+}
+
+impl<P: Pixel> PhysicalPosition<P> {
+    #[inline]
+    pub fn from_logical<T: Into<LogicalPosition<X>>, X: Pixel>(
+        logical: T,
+        scale_factor: f64,
+    ) -> Self {
+        logical.into().to_physical(scale_factor)
+    }
+
+    #[inline]
+    pub fn to_logical<X: Pixel>(&self, scale_factor: f64) -> LogicalPosition<X> {
+        assert!(validate_scale_factor(scale_factor));
+        let x = self.x.into() / scale_factor;
+        let y = self.y.into() / scale_factor;
+        LogicalPosition::new(x, y).cast()
+    }
+
+    #[inline]
+    pub fn cast<X: Pixel>(&self) -> PhysicalPosition<X> {
+        PhysicalPosition {
+            x: self.x.cast(),
+            y: self.y.cast(),
+        }
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<(X, X)> for PhysicalPosition<P> {
+    fn from((x, y): (X, X)) -> PhysicalPosition<P> {
+        PhysicalPosition::new(x.cast(), y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<PhysicalPosition<P>> for (X, X) {
+    fn from(p: PhysicalPosition<P>) -> (X, X) {
+        (p.x.cast(), p.y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<[X; 2]> for PhysicalPosition<P> {
+    fn from([x, y]: [X; 2]) -> PhysicalPosition<P> {
+        PhysicalPosition::new(x.cast(), y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<PhysicalPosition<P>> for [X; 2] {
+    fn from(p: PhysicalPosition<P>) -> [X; 2] {
+        [p.x.cast(), p.y.cast()]
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<mint::Point2<P>> for PhysicalPosition<P> {
+    fn from(p: mint::Point2<P>) -> Self {
+        Self::new(p.x, p.y)
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<PhysicalPosition<P>> for mint::Point2<P> {
+    fn from(p: PhysicalPosition<P>) -> Self {
+        mint::Point2 { x: p.x, y: p.y }
+    }
+}
+
+/// A size represented in logical pixels.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct LogicalSize<P> {
+    pub width: P,
+    pub height: P,
+}
+
+impl<P> LogicalSize<P> {
+    #[inline]
+    pub const fn new(width: P, height: P) -> Self {
+        LogicalSize { width, height }
+    }
+}
+
+impl<P: Pixel> LogicalSize<P> {
+    #[inline]
+    pub fn from_physical<T: Into<PhysicalSize<X>>, X: Pixel>(
+        physical: T,
+        scale_factor: f64,
+    ) -> Self {
+        physical.into().to_logical(scale_factor)
+    }
+
+    #[inline]
+    pub fn to_physical<X: Pixel>(&self, scale_factor: f64) -> PhysicalSize<X> {
+        assert!(validate_scale_factor(scale_factor));
+        let width = self.width.into() * scale_factor;
+        let height = self.height.into() * scale_factor;
+        PhysicalSize::new(width, height).cast()
+    }
+
+    #[inline]
+    pub fn cast<X: Pixel>(&self) -> LogicalSize<X> {
+        LogicalSize {
+            width: self.width.cast(),
+            height: self.height.cast(),
+        }
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<(X, X)> for LogicalSize<P> {
+    fn from((x, y): (X, X)) -> LogicalSize<P> {
+        LogicalSize::new(x.cast(), y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<LogicalSize<P>> for (X, X) {
+    fn from(s: LogicalSize<P>) -> (X, X) {
+        (s.width.cast(), s.height.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<[X; 2]> for LogicalSize<P> {
+    fn from([x, y]: [X; 2]) -> LogicalSize<P> {
+        LogicalSize::new(x.cast(), y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<LogicalSize<P>> for [X; 2] {
+    fn from(s: LogicalSize<P>) -> [X; 2] {
+        [s.width.cast(), s.height.cast()]
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<mint::Vector2<P>> for LogicalSize<P> {
+    fn from(v: mint::Vector2<P>) -> Self {
+        Self::new(v.x, v.y)
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<LogicalSize<P>> for mint::Vector2<P> {
+    fn from(s: LogicalSize<P>) -> Self {
+        mint::Vector2 {
+            x: s.width,
+            y: s.height,
+        }
+    }
+}
+
+/// A size represented in physical pixels.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct PhysicalSize<P> {
+    pub width: P,
+    pub height: P,
+}
+
+impl<P> PhysicalSize<P> {
+    #[inline]
+    pub const fn new(width: P, height: P) -> Self {
+        PhysicalSize { width, height }
+    }
+}
+
+impl<P: Pixel> PhysicalSize<P> {
+    #[inline]
+    pub fn from_logical<T: Into<LogicalSize<X>>, X: Pixel>(logical: T, scale_factor: f64) -> Self {
+        logical.into().to_physical(scale_factor)
+    }
+
+    #[inline]
+    pub fn to_logical<X: Pixel>(&self, scale_factor: f64) -> LogicalSize<X> {
+        assert!(validate_scale_factor(scale_factor));
+        let width = self.width.into() / scale_factor;
+        let height = self.height.into() / scale_factor;
+        LogicalSize::new(width, height).cast()
+    }
+
+    #[inline]
+    pub fn cast<X: Pixel>(&self) -> PhysicalSize<X> {
+        PhysicalSize {
+            width: self.width.cast(),
+            height: self.height.cast(),
+        }
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<(X, X)> for PhysicalSize<P> {
+    fn from((x, y): (X, X)) -> PhysicalSize<P> {
+        PhysicalSize::new(x.cast(), y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<PhysicalSize<P>> for (X, X) {
+    fn from(s: PhysicalSize<P>) -> (X, X) {
+        (s.width.cast(), s.height.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<[X; 2]> for PhysicalSize<P> {
+    fn from([x, y]: [X; 2]) -> PhysicalSize<P> {
+        PhysicalSize::new(x.cast(), y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<PhysicalSize<P>> for [X; 2] {
+    fn from(s: PhysicalSize<P>) -> [X; 2] {
+        [s.width.cast(), s.height.cast()]
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<mint::Vector2<P>> for PhysicalSize<P> {
+    fn from(v: mint::Vector2<P>) -> Self {
+        Self::new(v.x, v.y)
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<PhysicalSize<P>> for mint::Vector2<P> {
+    fn from(s: PhysicalSize<P>) -> Self {
+        mint::Vector2 {
+            x: s.width,
+            y: s.height,
+        }
+    }
+}
+
+/// A size that's either physical or logical.
+#[derive(Debug, Copy, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum Size {
+    Physical(PhysicalSize<u32>),
+    Logical(LogicalSize<f64>),
+}
+
+impl Size {
+    pub fn new<S: Into<Size>>(size: S) -> Size {
+        size.into()
+    }
+
+    pub fn to_logical<P: Pixel>(&self, scale_factor: f64) -> LogicalSize<P> {
+        match *self {
+            Size::Physical(size) => size.to_logical(scale_factor),
+            Size::Logical(size) => size.cast(),
+        }
+    }
+
+    pub fn to_physical<P: Pixel>(&self, scale_factor: f64) -> PhysicalSize<P> {
+        match *self {
+            Size::Physical(size) => size.cast(),
+            Size::Logical(size) => size.to_physical(scale_factor),
+        }
+    }
+
+    pub fn clamp<S: Into<Size>>(input: S, min: S, max: S, scale_factor: f64) -> Size {
+        let (input, min, max) = (
+            input.into().to_physical::<f64>(scale_factor),
+            min.into().to_physical::<f64>(scale_factor),
+            max.into().to_physical::<f64>(scale_factor),
+        );
+
+        let width = input.width.clamp(min.width, max.width);
+        let height = input.height.clamp(min.height, max.height);
+
+        PhysicalSize::new(width, height).into()
+    }
+}
+
+impl<P: Pixel> From<PhysicalSize<P>> for Size {
+    #[inline]
+    fn from(size: PhysicalSize<P>) -> Size {
+        Size::Physical(size.cast())
+    }
+}
+
+impl<P: Pixel> From<LogicalSize<P>> for Size {
+    #[inline]
+    fn from(size: LogicalSize<P>) -> Size {
+        Size::Logical(size.cast())
+    }
+}
+
+/// A position that's either physical or logical.
+#[derive(Debug, Copy, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum Position {
+    Physical(PhysicalPosition<i32>),
+    Logical(LogicalPosition<f64>),
+}
+
+impl Position {
+    pub fn new<S: Into<Position>>(position: S) -> Position {
+        position.into()
+    }
+
+    pub fn to_logical<P: Pixel>(&self, scale_factor: f64) -> LogicalPosition<P> {
+        match *self {
+            Position::Physical(position) => position.to_logical(scale_factor),
+            Position::Logical(position) => position.cast(),
+        }
+    }
+
+    pub fn to_physical<P: Pixel>(&self, scale_factor: f64) -> PhysicalPosition<P> {
+        match *self {
+            Position::Physical(position) => position.cast(),
+            Position::Logical(position) => position.to_physical(scale_factor),
+        }
+    }
+}
+
+impl<P: Pixel> From<PhysicalPosition<P>> for Position {
+    #[inline]
+    fn from(position: PhysicalPosition<P>) -> Position {
+        Position::Physical(position.cast())
+    }
+}
+
+impl<P: Pixel> From<LogicalPosition<P>> for Position {
+    #[inline]
+    fn from(position: LogicalPosition<P>) -> Position {
+        Position::Logical(position.cast())
+    }
+}

third-party/vendor/winit/src/error.rs

@@ -0,0 +1,82 @@
+use std::{error, fmt};
+
+use crate::platform_impl;
+
+/// An error whose cause it outside Winit's control.
+#[derive(Debug)]
+pub enum ExternalError {
+    /// The operation is not supported by the backend.
+    NotSupported(NotSupportedError),
+    /// The OS cannot perform the operation.
+    Os(OsError),
+}
+
+/// The error type for when the requested operation is not supported by the backend.
+#[derive(Clone)]
+pub struct NotSupportedError {
+    _marker: (),
+}
+
+/// The error type for when the OS cannot perform the requested operation.
+#[derive(Debug)]
+pub struct OsError {
+    line: u32,
+    file: &'static str,
+    error: platform_impl::OsError,
+}
+
+impl NotSupportedError {
+    #[inline]
+    #[allow(dead_code)]
+    pub(crate) fn new() -> NotSupportedError {
+        NotSupportedError { _marker: () }
+    }
+}
+
+impl OsError {
+    #[allow(dead_code)]
+    pub(crate) fn new(line: u32, file: &'static str, error: platform_impl::OsError) -> OsError {
+        OsError { line, file, error }
+    }
+}
+
+#[allow(unused_macros)]
+macro_rules! os_error {
+    ($error:expr) => {{
+        crate::error::OsError::new(line!(), file!(), $error)
+    }};
+}
+
+impl fmt::Display for OsError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        f.pad(&format!(
+            "os error at {}:{}: {}",
+            self.file, self.line, self.error
+        ))
+    }
+}
+
+impl fmt::Display for ExternalError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        match self {
+            ExternalError::NotSupported(e) => e.fmt(f),
+            ExternalError::Os(e) => e.fmt(f),
+        }
+    }
+}
+
+impl fmt::Debug for NotSupportedError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        f.debug_struct("NotSupportedError").finish()
+    }
+}
+
+impl fmt::Display for NotSupportedError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        f.pad("the requested operation is not supported by Winit")
+    }
+}
+
+impl error::Error for OsError {}
+impl error::Error for ExternalError {}
+impl error::Error for NotSupportedError {}

third-party/vendor/winit/src/event_loop.rs

@@ -0,0 +1,440 @@
+//! The [`EventLoop`] struct and assorted supporting types, including
+//! [`ControlFlow`].
+//!
+//! If you want to send custom events to the event loop, use
+//! [`EventLoop::create_proxy`] to acquire an [`EventLoopProxy`] and call its
+//! [`send_event`](`EventLoopProxy::send_event`) method.
+//!
+//! See the root-level documentation for information on how to create and use an event loop to
+//! handle events.
+use std::marker::PhantomData;
+use std::ops::Deref;
+use std::{error, fmt};
+
+use instant::{Duration, Instant};
+use once_cell::sync::OnceCell;
+use raw_window_handle::{HasRawDisplayHandle, RawDisplayHandle};
+
+use crate::{event::Event, monitor::MonitorHandle, platform_impl};
+
+/// Provides a way to retrieve events from the system and from the windows that were registered to
+/// the events loop.
+///
+/// An `EventLoop` can be seen more or less as a "context". Calling [`EventLoop::new`]
+/// initializes everything that will be required to create windows. For example on Linux creating
+/// an event loop opens a connection to the X or Wayland server.
+///
+/// To wake up an `EventLoop` from a another thread, see the [`EventLoopProxy`] docs.
+///
+/// Note that this cannot be shared across threads (due to platform-dependant logic
+/// forbidding it), as such it is neither [`Send`] nor [`Sync`]. If you need cross-thread access, the
+/// [`Window`] created from this _can_ be sent to an other thread, and the
+/// [`EventLoopProxy`] allows you to wake up an `EventLoop` from another thread.
+///
+/// [`Window`]: crate::window::Window
+pub struct EventLoop<T: 'static> {
+    pub(crate) event_loop: platform_impl::EventLoop<T>,
+    pub(crate) _marker: PhantomData<*mut ()>, // Not Send nor Sync
+}
+
+/// Target that associates windows with an [`EventLoop`].
+///
+/// This type exists to allow you to create new windows while Winit executes
+/// your callback. [`EventLoop`] will coerce into this type (`impl<T> Deref for
+/// EventLoop<T>`), so functions that take this as a parameter can also take
+/// `&EventLoop`.
+pub struct EventLoopWindowTarget<T: 'static> {
+    pub(crate) p: platform_impl::EventLoopWindowTarget<T>,
+    pub(crate) _marker: PhantomData<*mut ()>, // Not Send nor Sync
+}
+
+/// Object that allows building the event loop.
+///
+/// This is used to make specifying options that affect the whole application
+/// easier. But note that constructing multiple event loops is not supported.
+#[derive(Default)]
+pub struct EventLoopBuilder<T: 'static> {
+    pub(crate) platform_specific: platform_impl::PlatformSpecificEventLoopAttributes,
+    _p: PhantomData<T>,
+}
+
+impl EventLoopBuilder<()> {
+    /// Start building a new event loop.
+    #[inline]
+    pub fn new() -> Self {
+        Self::with_user_event()
+    }
+}
+
+impl<T> EventLoopBuilder<T> {
+    /// Start building a new event loop, with the given type as the user event
+    /// type.
+    #[inline]
+    pub fn with_user_event() -> Self {
+        Self {
+            platform_specific: Default::default(),
+            _p: PhantomData,
+        }
+    }
+
+    /// Builds a new event loop.
+    ///
+    /// ***For cross-platform compatibility, the [`EventLoop`] must be created on the main thread,
+    /// and only once per application.***
+    ///
+    /// Attempting to create the event loop on a different thread, or multiple event loops in
+    /// the same application, will panic. This restriction isn't
+    /// strictly necessary on all platforms, but is imposed to eliminate any nasty surprises when
+    /// porting to platforms that require it. `EventLoopBuilderExt::any_thread` functions are exposed
+    /// in the relevant [`platform`] module if the target platform supports creating an event loop on
+    /// any thread.
+    ///
+    /// Calling this function will result in display backend initialisation.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Linux:** Backend type can be controlled using an environment variable
+    ///   `WINIT_UNIX_BACKEND`. Legal values are `x11` and `wayland`.
+    ///   If it is not set, winit will try to connect to a Wayland connection, and if that fails,
+    ///   will fall back on X11. If this variable is set with any other value, winit will panic.
+    /// - **Android:** Must be configured with an `AndroidApp` from `android_main()` by calling
+    ///     [`.with_android_app(app)`] before calling `.build()`.
+    ///
+    /// [`platform`]: crate::platform
+    #[cfg_attr(
+        android,
+        doc = "[`.with_android_app(app)`]: crate::platform::android::EventLoopBuilderExtAndroid::with_android_app"
+    )]
+    #[cfg_attr(
+        not(android),
+        doc = "[`.with_android_app(app)`]: #only-available-on-android"
+    )]
+    #[inline]
+    pub fn build(&mut self) -> EventLoop<T> {
+        static EVENT_LOOP_CREATED: OnceCell<()> = OnceCell::new();
+        if EVENT_LOOP_CREATED.set(()).is_err() {
+            panic!("Creating EventLoop multiple times is not supported.");
+        }
+        // Certain platforms accept a mutable reference in their API.
+        #[allow(clippy::unnecessary_mut_passed)]
+        EventLoop {
+            event_loop: platform_impl::EventLoop::new(&mut self.platform_specific),
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<T> fmt::Debug for EventLoop<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad("EventLoop { .. }")
+    }
+}
+
+impl<T> fmt::Debug for EventLoopWindowTarget<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad("EventLoopWindowTarget { .. }")
+    }
+}
+
+/// Set by the user callback given to the [`EventLoop::run`] method.
+///
+/// Indicates the desired behavior of the event loop after [`Event::RedrawEventsCleared`] is emitted.
+///
+/// Defaults to [`Poll`].
+///
+/// ## Persistency
+///
+/// Almost every change is persistent between multiple calls to the event loop closure within a
+/// given run loop. The only exception to this is [`ExitWithCode`] which, once set, cannot be unset.
+/// Changes are **not** persistent between multiple calls to `run_return` - issuing a new call will
+/// reset the control flow to [`Poll`].
+///
+/// [`ExitWithCode`]: Self::ExitWithCode
+/// [`Poll`]: Self::Poll
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum ControlFlow {
+    /// When the current loop iteration finishes, immediately begin a new iteration regardless of
+    /// whether or not new events are available to process.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Web:** Events are queued and usually sent when `requestAnimationFrame` fires but sometimes
+    ///   the events in the queue may be sent before the next `requestAnimationFrame` callback, for
+    ///   example when the scaling of the page has changed. This should be treated as an implementation
+    ///   detail which should not be relied on.
+    Poll,
+
+    /// When the current loop iteration finishes, suspend the thread until another event arrives.
+    Wait,
+
+    /// When the current loop iteration finishes, suspend the thread until either another event
+    /// arrives or the given time is reached.
+    ///
+    /// Useful for implementing efficient timers. Applications which want to render at the display's
+    /// native refresh rate should instead use [`Poll`] and the VSync functionality of a graphics API
+    /// to reduce odds of missed frames.
+    ///
+    /// [`Poll`]: Self::Poll
+    WaitUntil(Instant),
+
+    /// Send a [`LoopDestroyed`] event and stop the event loop. This variant is *sticky* - once set,
+    /// `control_flow` cannot be changed from `ExitWithCode`, and any future attempts to do so will
+    /// result in the `control_flow` parameter being reset to `ExitWithCode`.
+    ///
+    /// The contained number will be used as exit code. The [`Exit`] constant is a shortcut for this
+    /// with exit code 0.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Android / iOS / WASM:** The supplied exit code is unused.
+    /// - **Unix:** On most Unix-like platforms, only the 8 least significant bits will be used,
+    ///   which can cause surprises with negative exit values (`-42` would end up as `214`). See
+    ///   [`std::process::exit`].
+    ///
+    /// [`LoopDestroyed`]: Event::LoopDestroyed
+    /// [`Exit`]: ControlFlow::Exit
+    ExitWithCode(i32),
+}
+
+impl ControlFlow {
+    /// Alias for [`ExitWithCode`]`(0)`.
+    ///
+    /// [`ExitWithCode`]: Self::ExitWithCode
+    #[allow(non_upper_case_globals)]
+    pub const Exit: Self = Self::ExitWithCode(0);
+
+    /// Sets this to [`Poll`].
+    ///
+    /// [`Poll`]: Self::Poll
+    pub fn set_poll(&mut self) {
+        *self = Self::Poll;
+    }
+
+    /// Sets this to [`Wait`].
+    ///
+    /// [`Wait`]: Self::Wait
+    pub fn set_wait(&mut self) {
+        *self = Self::Wait;
+    }
+
+    /// Sets this to [`WaitUntil`]`(instant)`.
+    ///
+    /// [`WaitUntil`]: Self::WaitUntil
+    pub fn set_wait_until(&mut self, instant: Instant) {
+        *self = Self::WaitUntil(instant);
+    }
+
+    /// Sets this to wait until a timeout has expired.
+    ///
+    /// In most cases, this is set to [`WaitUntil`]. However, if the timeout overflows, it is
+    /// instead set to [`Wait`].
+    ///
+    /// [`WaitUntil`]: Self::WaitUntil
+    /// [`Wait`]: Self::Wait
+    pub fn set_wait_timeout(&mut self, timeout: Duration) {
+        match Instant::now().checked_add(timeout) {
+            Some(instant) => self.set_wait_until(instant),
+            None => self.set_wait(),
+        }
+    }
+
+    /// Sets this to [`ExitWithCode`]`(code)`.
+    ///
+    /// [`ExitWithCode`]: Self::ExitWithCode
+    pub fn set_exit_with_code(&mut self, code: i32) {
+        *self = Self::ExitWithCode(code);
+    }
+
+    /// Sets this to [`Exit`].
+    ///
+    /// [`Exit`]: Self::Exit
+    pub fn set_exit(&mut self) {
+        *self = Self::Exit;
+    }
+}
+
+impl Default for ControlFlow {
+    #[inline(always)]
+    fn default() -> Self {
+        Self::Poll
+    }
+}
+
+impl EventLoop<()> {
+    /// Alias for [`EventLoopBuilder::new().build()`].
+    ///
+    /// [`EventLoopBuilder::new().build()`]: EventLoopBuilder::build
+    #[inline]
+    pub fn new() -> EventLoop<()> {
+        EventLoopBuilder::new().build()
+    }
+}
+
+impl Default for EventLoop<()> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T> EventLoop<T> {
+    #[deprecated = "Use `EventLoopBuilder::<T>::with_user_event().build()` instead."]
+    pub fn with_user_event() -> EventLoop<T> {
+        EventLoopBuilder::<T>::with_user_event().build()
+    }
+
+    /// Hijacks the calling thread and initializes the winit event loop with the provided
+    /// closure. Since the closure is `'static`, it must be a `move` closure if it needs to
+    /// access any data from the calling context.
+    ///
+    /// See the [`ControlFlow`] docs for information on how changes to `&mut ControlFlow` impact the
+    /// event loop's behavior.
+    ///
+    /// Any values not passed to this function will *not* be dropped.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **X11 / Wayland:** The program terminates with exit code 1 if the display server
+    ///   disconnects.
+    ///
+    /// [`ControlFlow`]: crate::event_loop::ControlFlow
+    #[inline]
+    pub fn run<F>(self, event_handler: F) -> !
+    where
+        F: 'static + FnMut(Event<'_, T>, &EventLoopWindowTarget<T>, &mut ControlFlow),
+    {
+        self.event_loop.run(event_handler)
+    }
+
+    /// Creates an [`EventLoopProxy`] that can be used to dispatch user events to the main event loop.
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+        EventLoopProxy {
+            event_loop_proxy: self.event_loop.create_proxy(),
+        }
+    }
+}
+
+unsafe impl<T> HasRawDisplayHandle for EventLoop<T> {
+    /// Returns a [`raw_window_handle::RawDisplayHandle`] for the event loop.
+    fn raw_display_handle(&self) -> RawDisplayHandle {
+        self.event_loop.window_target().p.raw_display_handle()
+    }
+}
+
+impl<T> Deref for EventLoop<T> {
+    type Target = EventLoopWindowTarget<T>;
+    fn deref(&self) -> &EventLoopWindowTarget<T> {
+        self.event_loop.window_target()
+    }
+}
+
+impl<T> EventLoopWindowTarget<T> {
+    /// Returns the list of all the monitors available on the system.
+    #[inline]
+    pub fn available_monitors(&self) -> impl Iterator<Item = MonitorHandle> {
+        self.p
+            .available_monitors()
+            .into_iter()
+            .map(|inner| MonitorHandle { inner })
+    }
+
+    /// Returns the primary monitor of the system.
+    ///
+    /// Returns `None` if it can't identify any monitor as a primary one.
+    ///
+    /// ## Platform-specific
+    ///
+    /// **Wayland:** Always returns `None`.
+    #[inline]
+    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
+        self.p
+            .primary_monitor()
+            .map(|inner| MonitorHandle { inner })
+    }
+
+    /// Change [`DeviceEvent`] filter mode.
+    ///
+    /// Since the [`DeviceEvent`] capture can lead to high CPU usage for unfocused windows, winit
+    /// will ignore them by default for unfocused windows on Linux/BSD. This method allows changing
+    /// this filter at runtime to explicitly capture them again.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Wayland / macOS / iOS / Android / Web / Orbital:** Unsupported.
+    ///
+    /// [`DeviceEvent`]: crate::event::DeviceEvent
+    pub fn set_device_event_filter(&self, _filter: DeviceEventFilter) {
+        #[cfg(any(x11_platform, wayland_platform, windows))]
+        self.p.set_device_event_filter(_filter);
+    }
+}
+
+unsafe impl<T> HasRawDisplayHandle for EventLoopWindowTarget<T> {
+    /// Returns a [`raw_window_handle::RawDisplayHandle`] for the event loop.
+    fn raw_display_handle(&self) -> RawDisplayHandle {
+        self.p.raw_display_handle()
+    }
+}
+
+/// Used to send custom events to [`EventLoop`].
+pub struct EventLoopProxy<T: 'static> {
+    event_loop_proxy: platform_impl::EventLoopProxy<T>,
+}
+
+impl<T: 'static> Clone for EventLoopProxy<T> {
+    fn clone(&self) -> Self {
+        Self {
+            event_loop_proxy: self.event_loop_proxy.clone(),
+        }
+    }
+}
+
+impl<T: 'static> EventLoopProxy<T> {
+    /// Send an event to the [`EventLoop`] from which this proxy was created. This emits a
+    /// `UserEvent(event)` event in the event loop, where `event` is the value passed to this
+    /// function.
+    ///
+    /// Returns an `Err` if the associated [`EventLoop`] no longer exists.
+    ///
+    /// [`UserEvent(event)`]: Event::UserEvent
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+        self.event_loop_proxy.send_event(event)
+    }
+}
+
+impl<T: 'static> fmt::Debug for EventLoopProxy<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad("EventLoopProxy { .. }")
+    }
+}
+
+/// The error that is returned when an [`EventLoopProxy`] attempts to wake up an [`EventLoop`] that
+/// no longer exists.
+///
+/// Contains the original event given to [`EventLoopProxy::send_event`].
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct EventLoopClosed<T>(pub T);
+
+impl<T> fmt::Display for EventLoopClosed<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("Tried to wake up a closed `EventLoop`")
+    }
+}
+
+impl<T: fmt::Debug> error::Error for EventLoopClosed<T> {}
+
+/// Filter controlling the propagation of device events.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub enum DeviceEventFilter {
+    /// Always filter out device events.
+    Always,
+    /// Filter out device events while the window is not focused.
+    Unfocused,
+    /// Report all device events regardless of window focus.
+    Never,
+}
+
+impl Default for DeviceEventFilter {
+    fn default() -> Self {
+        Self::Unfocused
+    }
+}

third-party/vendor/winit/src/icon.rs

@@ -0,0 +1,129 @@
+use crate::platform_impl::PlatformIcon;
+use std::{error::Error, fmt, io, mem};
+
+#[repr(C)]
+#[derive(Debug)]
+pub(crate) struct Pixel {
+    pub(crate) r: u8,
+    pub(crate) g: u8,
+    pub(crate) b: u8,
+    pub(crate) a: u8,
+}
+
+pub(crate) const PIXEL_SIZE: usize = mem::size_of::<Pixel>();
+
+#[derive(Debug)]
+/// An error produced when using [`Icon::from_rgba`] with invalid arguments.
+pub enum BadIcon {
+    /// Produced when the length of the `rgba` argument isn't divisible by 4, thus `rgba` can't be
+    /// safely interpreted as 32bpp RGBA pixels.
+    ByteCountNotDivisibleBy4 { byte_count: usize },
+    /// Produced when the number of pixels (`rgba.len() / 4`) isn't equal to `width * height`.
+    /// At least one of your arguments is incorrect.
+    DimensionsVsPixelCount {
+        width: u32,
+        height: u32,
+        width_x_height: usize,
+        pixel_count: usize,
+    },
+    /// Produced when underlying OS functionality failed to create the icon
+    OsError(io::Error),
+}
+
+impl fmt::Display for BadIcon {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            BadIcon::ByteCountNotDivisibleBy4 { byte_count } => write!(f,
+                "The length of the `rgba` argument ({byte_count:?}) isn't divisible by 4, making it impossible to interpret as 32bpp RGBA pixels.",
+            ),
+            BadIcon::DimensionsVsPixelCount {
+                width,
+                height,
+                width_x_height,
+                pixel_count,
+            } => write!(f,
+                "The specified dimensions ({width:?}x{height:?}) don't match the number of pixels supplied by the `rgba` argument ({pixel_count:?}). For those dimensions, the expected pixel count is {width_x_height:?}.",
+            ),
+            BadIcon::OsError(e) => write!(f, "OS error when instantiating the icon: {e:?}"),
+        }
+    }
+}
+
+impl Error for BadIcon {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        Some(self)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct RgbaIcon {
+    pub(crate) rgba: Vec<u8>,
+    pub(crate) width: u32,
+    pub(crate) height: u32,
+}
+
+/// For platforms which don't have window icons (e.g. web)
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct NoIcon;
+
+#[allow(dead_code)] // These are not used on every platform
+mod constructors {
+    use super::*;
+
+    impl RgbaIcon {
+        pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
+            if rgba.len() % PIXEL_SIZE != 0 {
+                return Err(BadIcon::ByteCountNotDivisibleBy4 {
+                    byte_count: rgba.len(),
+                });
+            }
+            let pixel_count = rgba.len() / PIXEL_SIZE;
+            if pixel_count != (width * height) as usize {
+                Err(BadIcon::DimensionsVsPixelCount {
+                    width,
+                    height,
+                    width_x_height: (width * height) as usize,
+                    pixel_count,
+                })
+            } else {
+                Ok(RgbaIcon {
+                    rgba,
+                    width,
+                    height,
+                })
+            }
+        }
+    }
+
+    impl NoIcon {
+        pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
+            // Create the rgba icon anyway to validate the input
+            let _ = RgbaIcon::from_rgba(rgba, width, height)?;
+            Ok(NoIcon)
+        }
+    }
+}
+
+/// An icon used for the window titlebar, taskbar, etc.
+#[derive(Clone)]
+pub struct Icon {
+    pub(crate) inner: PlatformIcon,
+}
+
+impl fmt::Debug for Icon {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        fmt::Debug::fmt(&self.inner, formatter)
+    }
+}
+
+impl Icon {
+    /// Creates an icon from 32bpp RGBA data.
+    ///
+    /// The length of `rgba` must be divisible by 4, and `width * height` must equal
+    /// `rgba.len() / 4`. Otherwise, this will return a `BadIcon` error.
+    pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
+        Ok(Icon {
+            inner: PlatformIcon::from_rgba(rgba, width, height)?,
+        })
+    }
+}

third-party/vendor/winit/src/lib.rs

@@ -0,0 +1,161 @@
+//! Winit is a cross-platform window creation and event loop management library.
+//!
+//! # Building windows
+//!
+//! Before you can build a [`Window`], you first need to build an [`EventLoop`]. This is done with the
+//! [`EventLoop::new()`] function.
+//!
+//! ```no_run
+//! use winit::event_loop::EventLoop;
+//! let event_loop = EventLoop::new();
+//! ```
+//!
+//! Once this is done there are two ways to create a [`Window`]:
+//!
+//!  - Calling [`Window::new(&event_loop)`][window_new].
+//!  - Calling [`let builder = WindowBuilder::new()`][window_builder_new] then [`builder.build(&event_loop)`][window_builder_build].
+//!
+//! The first method is the simplest, and will give you default values for everything. The second
+//! method allows you to customize the way your [`Window`] will look and behave by modifying the
+//! fields of the [`WindowBuilder`] object before you create the [`Window`].
+//!
+//! # Event handling
+//!
+//! Once a [`Window`] has been created, it will generate different *events*. A [`Window`] object can
+//! generate [`WindowEvent`]s when certain input events occur, such as a cursor moving over the
+//! window or a key getting pressed while the window is focused. Devices can generate
+//! [`DeviceEvent`]s, which contain unfiltered event data that isn't specific to a certain window.
+//! Some user activity, like mouse movement, can generate both a [`WindowEvent`] *and* a
+//! [`DeviceEvent`]. You can also create and handle your own custom [`UserEvent`]s, if desired.
+//!
+//! You can retrieve events by calling [`EventLoop::run`][event_loop_run]. This function will
+//! dispatch events for every [`Window`] that was created with that particular [`EventLoop`], and
+//! will run until the `control_flow` argument given to the closure is set to
+//! [`ControlFlow`]`::`[`ExitWithCode`] (which [`ControlFlow`]`::`[`Exit`] aliases to), at which
+//! point [`Event`]`::`[`LoopDestroyed`] is emitted and the entire program terminates.
+//!
+//! Winit no longer uses a `EventLoop::poll_events() -> impl Iterator<Event>`-based event loop
+//! model, since that can't be implemented properly on some platforms (e.g web, iOS) and works poorly on
+//! most other platforms. However, this model can be re-implemented to an extent with
+//! [`EventLoopExtRunReturn::run_return`]. See that method's documentation for more reasons about why
+//! it's discouraged, beyond compatibility reasons.
+//!
+//!
+//! ```no_run
+//! use winit::{
+//!     event::{Event, WindowEvent},
+//!     event_loop::EventLoop,
+//!     window::WindowBuilder,
+//! };
+//!
+//! let event_loop = EventLoop::new();
+//! let window = WindowBuilder::new().build(&event_loop).unwrap();
+//!
+//! event_loop.run(move |event, _, control_flow| {
+//!     // ControlFlow::Poll continuously runs the event loop, even if the OS hasn't
+//!     // dispatched any events. This is ideal for games and similar applications.
+//!     control_flow.set_poll();
+//!
+//!     // ControlFlow::Wait pauses the event loop if no events are available to process.
+//!     // This is ideal for non-game applications that only update in response to user
+//!     // input, and uses significantly less power/CPU time than ControlFlow::Poll.
+//!     control_flow.set_wait();
+//!
+//!     match event {
+//!         Event::WindowEvent {
+//!             event: WindowEvent::CloseRequested,
+//!             ..
+//!         } => {
+//!             println!("The close button was pressed; stopping");
+//!             control_flow.set_exit();
+//!         },
+//!         Event::MainEventsCleared => {
+//!             // Application update code.
+//!
+//!             // Queue a RedrawRequested event.
+//!             //
+//!             // You only need to call this if you've determined that you need to redraw, in
+//!             // applications which do not always need to. Applications that redraw continuously
+//!             // can just render here instead.
+//!             window.request_redraw();
+//!         },
+//!         Event::RedrawRequested(_) => {
+//!             // Redraw the application.
+//!             //
+//!             // It's preferable for applications that do not render continuously to render in
+//!             // this event rather than in MainEventsCleared, since rendering in here allows
+//!             // the program to gracefully handle redraws requested by the OS.
+//!         },
+//!         _ => ()
+//!     }
+//! });
+//! ```
+//!
+//! [`Event`]`::`[`WindowEvent`] has a [`WindowId`] member. In multi-window environments, it should be
+//! compared to the value returned by [`Window::id()`][window_id_fn] to determine which [`Window`]
+//! dispatched the event.
+//!
+//! # Drawing on the window
+//!
+//! Winit doesn't directly provide any methods for drawing on a [`Window`]. However it allows you to
+//! retrieve the raw handle of the window and display (see the [`platform`] module and/or the
+//! [`raw_window_handle`] and [`raw_display_handle`] methods), which in turn allows
+//!  you to create an OpenGL/Vulkan/DirectX/Metal/etc. context that can be used to render graphics.
+//!
+//! Note that many platforms will display garbage data in the window's client area if the
+//! application doesn't render anything to the window by the time the desktop compositor is ready to
+//! display the window to the user. If you notice this happening, you should create the window with
+//! [`visible` set to `false`](crate::window::WindowBuilder::with_visible) and explicitly make the
+//! window visible only once you're ready to render into it.
+//!
+//! [`EventLoop`]: event_loop::EventLoop
+//! [`EventLoopExtRunReturn::run_return`]: ./platform/run_return/trait.EventLoopExtRunReturn.html#tymethod.run_return
+//! [`EventLoop::new()`]: event_loop::EventLoop::new
+//! [event_loop_run]: event_loop::EventLoop::run
+//! [`ControlFlow`]: event_loop::ControlFlow
+//! [`Exit`]: event_loop::ControlFlow::Exit
+//! [`ExitWithCode`]: event_loop::ControlFlow::ExitWithCode
+//! [`Window`]: window::Window
+//! [`WindowId`]: window::WindowId
+//! [`WindowBuilder`]: window::WindowBuilder
+//! [window_new]: window::Window::new
+//! [window_builder_new]: window::WindowBuilder::new
+//! [window_builder_build]: window::WindowBuilder::build
+//! [window_id_fn]: window::Window::id
+//! [`Event`]: event::Event
+//! [`WindowEvent`]: event::WindowEvent
+//! [`DeviceEvent`]: event::DeviceEvent
+//! [`UserEvent`]: event::Event::UserEvent
+//! [`LoopDestroyed`]: event::Event::LoopDestroyed
+//! [`platform`]: platform
+//! [`raw_window_handle`]: ./window/struct.Window.html#method.raw_window_handle
+//! [`raw_display_handle`]: ./window/struct.Window.html#method.raw_display_handle
+
+#![deny(rust_2018_idioms)]
+#![deny(rustdoc::broken_intra_doc_links)]
+#![deny(clippy::all)]
+#![cfg_attr(feature = "cargo-clippy", deny(warnings))]
+// Doc feature labels can be tested locally by running RUSTDOCFLAGS="--cfg=docsrs" cargo +nightly doc
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![allow(clippy::missing_safety_doc)]
+
+#[allow(unused_imports)]
+#[macro_use]
+extern crate log;
+#[cfg(feature = "serde")]
+#[macro_use]
+extern crate serde;
+#[macro_use]
+extern crate bitflags;
+
+pub mod dpi;
+#[macro_use]
+pub mod error;
+pub mod event;
+pub mod event_loop;
+mod icon;
+pub mod monitor;
+mod platform_impl;
+pub mod window;
+
+pub mod platform;

third-party/vendor/winit/src/monitor.rs

@@ -0,0 +1,181 @@
+//! Types useful for interacting with a user's monitors.
+//!
+//! If you want to get basic information about a monitor, you can use the
+//! [`MonitorHandle`] type. This is retrieved from one of the following
+//! methods, which return an iterator of [`MonitorHandle`]:
+//! - [`EventLoopWindowTarget::available_monitors`](crate::event_loop::EventLoopWindowTarget::available_monitors).
+//! - [`Window::available_monitors`](crate::window::Window::available_monitors).
+use crate::{
+    dpi::{PhysicalPosition, PhysicalSize},
+    platform_impl,
+};
+
+/// Describes a fullscreen video mode of a monitor.
+///
+/// Can be acquired with [`MonitorHandle::video_modes`].
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct VideoMode {
+    pub(crate) video_mode: platform_impl::VideoMode,
+}
+
+impl std::fmt::Debug for VideoMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.video_mode.fmt(f)
+    }
+}
+
+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_millihertz()
+                        .cmp(&other.refresh_rate_millihertz())
+                        .then(self.bit_depth().cmp(&other.bit_depth())),
+                )
+                .reverse(),
+        )
+    }
+}
+
+impl VideoMode {
+    /// Returns the resolution of this video mode.
+    #[inline]
+    pub fn size(&self) -> PhysicalSize<u32> {
+        self.video_mode.size()
+    }
+
+    /// Returns the bit depth of this video mode, as in how many bits you have
+    /// available per color. This is generally 24 bits or 32 bits on modern
+    /// systems, depending on whether the alpha channel is counted or not.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Wayland / Orbital:** Always returns 32.
+    /// - **iOS:** Always returns 32.
+    #[inline]
+    pub fn bit_depth(&self) -> u16 {
+        self.video_mode.bit_depth()
+    }
+
+    /// Returns the refresh rate of this video mode in mHz.
+    #[inline]
+    pub fn refresh_rate_millihertz(&self) -> u32 {
+        self.video_mode.refresh_rate_millihertz()
+    }
+
+    /// 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 {
+        MonitorHandle {
+            inner: self.video_mode.monitor(),
+        }
+    }
+}
+
+impl std::fmt::Display for VideoMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}x{} @ {} mHz ({} bpp)",
+            self.size().width,
+            self.size().height,
+            self.refresh_rate_millihertz(),
+            self.bit_depth()
+        )
+    }
+}
+
+/// Handle to a monitor.
+///
+/// Allows you to retrieve information about a given monitor and can be used in [`Window`] creation.
+///
+/// [`Window`]: crate::window::Window
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct MonitorHandle {
+    pub(crate) inner: platform_impl::MonitorHandle,
+}
+
+impl MonitorHandle {
+    /// Returns a human-readable name of the monitor.
+    ///
+    /// Returns `None` if the monitor doesn't exist anymore.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Web:** Always returns None
+    #[inline]
+    pub fn name(&self) -> Option<String> {
+        self.inner.name()
+    }
+
+    /// Returns the monitor's resolution.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Web:** Always returns (0,0)
+    #[inline]
+    pub fn size(&self) -> PhysicalSize<u32> {
+        self.inner.size()
+    }
+
+    /// Returns the top-left corner position of the monitor relative to the larger full
+    /// screen area.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Web:** Always returns (0,0)
+    #[inline]
+    pub fn position(&self) -> PhysicalPosition<i32> {
+        self.inner.position()
+    }
+
+    /// The monitor refresh rate used by the system.
+    ///
+    /// Return `Some` if succeed, or `None` if failed, which usually happens when the monitor
+    /// the window is on is removed.
+    ///
+    /// When using exclusive fullscreen, the refresh rate of the [`VideoMode`] that was used to
+    /// enter fullscreen should be used instead.
+    #[inline]
+    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
+        self.inner.refresh_rate_millihertz()
+    }
+
+    /// Returns the scale factor that can be used to map logical pixels to physical pixels, and vice versa.
+    ///
+    /// See the [`dpi`](crate::dpi) module for more information.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **X11:** Can be overridden using the `WINIT_X11_SCALE_FACTOR` environment variable.
+    /// - **Android:** Always returns 1.0.
+    /// - **Web:** Always returns 1.0
+    #[inline]
+    pub fn scale_factor(&self) -> f64 {
+        self.inner.scale_factor()
+    }
+
+    /// Returns all fullscreen video modes supported by this monitor.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Web:** Always returns an empty iterator
+    #[inline]
+    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
+        self.inner
+            .video_modes()
+            .map(|video_mode| VideoMode { video_mode })
+    }
+}

third-party/vendor/winit/src/platform/android.rs

@@ -0,0 +1,78 @@
+use crate::{
+    event_loop::{EventLoop, EventLoopBuilder, EventLoopWindowTarget},
+    window::{Window, WindowBuilder},
+};
+
+use android_activity::{AndroidApp, ConfigurationRef, Rect};
+
+/// Additional methods on [`EventLoop`] that are specific to Android.
+pub trait EventLoopExtAndroid {}
+
+impl<T> EventLoopExtAndroid for EventLoop<T> {}
+
+/// Additional methods on [`EventLoopWindowTarget`] that are specific to Android.
+pub trait EventLoopWindowTargetExtAndroid {}
+
+/// Additional methods on [`Window`] that are specific to Android.
+pub trait WindowExtAndroid {
+    fn content_rect(&self) -> Rect;
+
+    fn config(&self) -> ConfigurationRef;
+}
+
+impl WindowExtAndroid for Window {
+    fn content_rect(&self) -> Rect {
+        self.window.content_rect()
+    }
+
+    fn config(&self) -> ConfigurationRef {
+        self.window.config()
+    }
+}
+
+impl<T> EventLoopWindowTargetExtAndroid for EventLoopWindowTarget<T> {}
+
+/// Additional methods on [`WindowBuilder`] that are specific to Android.
+pub trait WindowBuilderExtAndroid {}
+
+impl WindowBuilderExtAndroid for WindowBuilder {}
+
+pub trait EventLoopBuilderExtAndroid {
+    /// Associates the `AndroidApp` that was passed to `android_main()` with the event loop
+    ///
+    /// This must be called on Android since the `AndroidApp` is not global state.
+    fn with_android_app(&mut self, app: AndroidApp) -> &mut Self;
+}
+
+impl<T> EventLoopBuilderExtAndroid for EventLoopBuilder<T> {
+    fn with_android_app(&mut self, app: AndroidApp) -> &mut Self {
+        self.platform_specific.android_app = Some(app);
+        self
+    }
+}
+
+/// Re-export of the `android_activity` API
+///
+/// Winit re-exports the `android_activity` API for convenience so that most
+/// applications can rely on the Winit crate to resolve the required version of
+/// `android_activity` and avoid any chance of a conflict between Winit and the
+/// application crate.
+///
+/// Unlike most libraries there can only be a single implementation
+/// of the `android_activity` glue crate linked with an application because
+/// it is responsible for the application's `android_main()` entry point.
+///
+/// Since Winit depends on a specific version of `android_activity` the simplest
+/// way to avoid creating a conflict is for applications to avoid explicitly
+/// depending on the `android_activity` crate, and instead consume the API that
+/// is re-exported by Winit.
+///
+/// For compatibility applications should then import the `AndroidApp` type for
+/// their `android_main(app: AndroidApp)` function like:
+/// ```rust
+/// #[cfg(target_os="android")]
+/// use winit::platform::android::activity::AndroidApp;
+/// ```
+pub mod activity {
+    pub use android_activity::*;
+}

third-party/vendor/winit/src/platform/ios.rs

@@ -0,0 +1,306 @@
+use std::os::raw::c_void;
+
+use objc2::rc::Id;
+
+use crate::{
+    event_loop::EventLoop,
+    monitor::{MonitorHandle, VideoMode},
+    window::{Window, WindowBuilder},
+};
+
+/// Additional methods on [`EventLoop`] that are specific to iOS.
+pub trait EventLoopExtIOS {
+    /// Returns the [`Idiom`] (phone/tablet/tv/etc) for the current device.
+    fn idiom(&self) -> Idiom;
+}
+
+impl<T: 'static> EventLoopExtIOS for EventLoop<T> {
+    fn idiom(&self) -> Idiom {
+        self.event_loop.idiom()
+    }
+}
+
+/// Additional methods on [`Window`] that are specific to iOS.
+pub trait WindowExtIOS {
+    /// Returns a pointer to the [`UIWindow`] that is used by this window.
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    ///
+    /// [`UIWindow`]: https://developer.apple.com/documentation/uikit/uiwindow?language=objc
+    fn ui_window(&self) -> *mut c_void;
+
+    /// Returns a pointer to the [`UIViewController`] that is used by this window.
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    ///
+    /// [`UIViewController`]: https://developer.apple.com/documentation/uikit/uiviewcontroller?language=objc
+    fn ui_view_controller(&self) -> *mut c_void;
+
+    /// Returns a pointer to the [`UIView`] that is used by this window.
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    ///
+    /// [`UIView`]: https://developer.apple.com/documentation/uikit/uiview?language=objc
+    fn ui_view(&self) -> *mut c_void;
+
+    /// Sets the [`contentScaleFactor`] of the underlying [`UIWindow`] to `scale_factor`.
+    ///
+    /// The default value is device dependent, and it's recommended GLES or Metal applications set
+    /// this to [`MonitorHandle::scale_factor()`].
+    ///
+    /// [`UIWindow`]: https://developer.apple.com/documentation/uikit/uiwindow?language=objc
+    /// [`contentScaleFactor`]: https://developer.apple.com/documentation/uikit/uiview/1622657-contentscalefactor?language=objc
+    fn set_scale_factor(&self, scale_factor: f64);
+
+    /// Sets the valid orientations for the [`Window`].
+    ///
+    /// The default value is [`ValidOrientations::LandscapeAndPortrait`].
+    ///
+    /// This changes the value returned by
+    /// [`-[UIViewController supportedInterfaceOrientations]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621435-supportedinterfaceorientations?language=objc),
+    /// and then calls
+    /// [`-[UIViewController attemptRotationToDeviceOrientation]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621400-attemptrotationtodeviceorientati?language=objc).
+    fn set_valid_orientations(&self, valid_orientations: ValidOrientations);
+
+    /// Sets whether the [`Window`] prefers the home indicator hidden.
+    ///
+    /// The default is to prefer showing the home indicator.
+    ///
+    /// This changes the value returned by
+    /// [`-[UIViewController prefersHomeIndicatorAutoHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887510-prefershomeindicatorautohidden?language=objc),
+    /// and then calls
+    /// [`-[UIViewController setNeedsUpdateOfHomeIndicatorAutoHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887509-setneedsupdateofhomeindicatoraut?language=objc).
+    ///
+    /// This only has an effect on iOS 11.0+.
+    fn set_prefers_home_indicator_hidden(&self, hidden: bool);
+
+    /// Sets the screen edges for which the system gestures will take a lower priority than the
+    /// application's touch handling.
+    ///
+    /// This changes the value returned by
+    /// [`-[UIViewController preferredScreenEdgesDeferringSystemGestures]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887512-preferredscreenedgesdeferringsys?language=objc),
+    /// and then calls
+    /// [`-[UIViewController setNeedsUpdateOfScreenEdgesDeferringSystemGestures]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887507-setneedsupdateofscreenedgesdefer?language=objc).
+    ///
+    /// This only has an effect on iOS 11.0+.
+    fn set_preferred_screen_edges_deferring_system_gestures(&self, edges: ScreenEdge);
+
+    /// Sets whether the [`Window`] prefers the status bar hidden.
+    ///
+    /// The default is to prefer showing the status bar.
+    ///
+    /// This changes the value returned by
+    /// [`-[UIViewController prefersStatusBarHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621440-prefersstatusbarhidden?language=objc),
+    /// and then calls
+    /// [`-[UIViewController setNeedsStatusBarAppearanceUpdate]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621354-setneedsstatusbarappearanceupdat?language=objc).
+    fn set_prefers_status_bar_hidden(&self, hidden: bool);
+}
+
+impl WindowExtIOS for Window {
+    #[inline]
+    fn ui_window(&self) -> *mut c_void {
+        self.window.ui_window()
+    }
+
+    #[inline]
+    fn ui_view_controller(&self) -> *mut c_void {
+        self.window.ui_view_controller()
+    }
+
+    #[inline]
+    fn ui_view(&self) -> *mut c_void {
+        self.window.ui_view()
+    }
+
+    #[inline]
+    fn set_scale_factor(&self, scale_factor: f64) {
+        self.window.set_scale_factor(scale_factor)
+    }
+
+    #[inline]
+    fn set_valid_orientations(&self, valid_orientations: ValidOrientations) {
+        self.window.set_valid_orientations(valid_orientations)
+    }
+
+    #[inline]
+    fn set_prefers_home_indicator_hidden(&self, hidden: bool) {
+        self.window.set_prefers_home_indicator_hidden(hidden)
+    }
+
+    #[inline]
+    fn set_preferred_screen_edges_deferring_system_gestures(&self, edges: ScreenEdge) {
+        self.window
+            .set_preferred_screen_edges_deferring_system_gestures(edges)
+    }
+
+    #[inline]
+    fn set_prefers_status_bar_hidden(&self, hidden: bool) {
+        self.window.set_prefers_status_bar_hidden(hidden)
+    }
+}
+
+/// Additional methods on [`WindowBuilder`] that are specific to iOS.
+pub trait WindowBuilderExtIOS {
+    /// Sets the [`contentScaleFactor`] of the underlying [`UIWindow`] to `scale_factor`.
+    ///
+    /// The default value is device dependent, and it's recommended GLES or Metal applications set
+    /// this to [`MonitorHandle::scale_factor()`].
+    ///
+    /// [`UIWindow`]: https://developer.apple.com/documentation/uikit/uiwindow?language=objc
+    /// [`contentScaleFactor`]: https://developer.apple.com/documentation/uikit/uiview/1622657-contentscalefactor?language=objc
+    fn with_scale_factor(self, scale_factor: f64) -> WindowBuilder;
+
+    /// Sets the valid orientations for the [`Window`].
+    ///
+    /// The default value is [`ValidOrientations::LandscapeAndPortrait`].
+    ///
+    /// This sets the initial value returned by
+    /// [`-[UIViewController supportedInterfaceOrientations]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621435-supportedinterfaceorientations?language=objc).
+    fn with_valid_orientations(self, valid_orientations: ValidOrientations) -> WindowBuilder;
+
+    /// Sets whether the [`Window`] prefers the home indicator hidden.
+    ///
+    /// The default is to prefer showing the home indicator.
+    ///
+    /// This sets the initial value returned by
+    /// [`-[UIViewController prefersHomeIndicatorAutoHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887510-prefershomeindicatorautohidden?language=objc).
+    ///
+    /// This only has an effect on iOS 11.0+.
+    fn with_prefers_home_indicator_hidden(self, hidden: bool) -> WindowBuilder;
+
+    /// Sets the screen edges for which the system gestures will take a lower priority than the
+    /// application's touch handling.
+    ///
+    /// This sets the initial value returned by
+    /// [`-[UIViewController preferredScreenEdgesDeferringSystemGestures]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887512-preferredscreenedgesdeferringsys?language=objc).
+    ///
+    /// This only has an effect on iOS 11.0+.
+    fn with_preferred_screen_edges_deferring_system_gestures(
+        self,
+        edges: ScreenEdge,
+    ) -> WindowBuilder;
+
+    /// Sets whether the [`Window`] prefers the status bar hidden.
+    ///
+    /// The default is to prefer showing the status bar.
+    ///
+    /// This sets the initial value returned by
+    /// [`-[UIViewController prefersStatusBarHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621440-prefersstatusbarhidden?language=objc).
+    fn with_prefers_status_bar_hidden(self, hidden: bool) -> WindowBuilder;
+}
+
+impl WindowBuilderExtIOS for WindowBuilder {
+    #[inline]
+    fn with_scale_factor(mut self, scale_factor: f64) -> WindowBuilder {
+        self.platform_specific.scale_factor = Some(scale_factor);
+        self
+    }
+
+    #[inline]
+    fn with_valid_orientations(mut self, valid_orientations: ValidOrientations) -> WindowBuilder {
+        self.platform_specific.valid_orientations = valid_orientations;
+        self
+    }
+
+    #[inline]
+    fn with_prefers_home_indicator_hidden(mut self, hidden: bool) -> WindowBuilder {
+        self.platform_specific.prefers_home_indicator_hidden = hidden;
+        self
+    }
+
+    #[inline]
+    fn with_preferred_screen_edges_deferring_system_gestures(
+        mut self,
+        edges: ScreenEdge,
+    ) -> WindowBuilder {
+        self.platform_specific
+            .preferred_screen_edges_deferring_system_gestures = edges;
+        self
+    }
+
+    #[inline]
+    fn with_prefers_status_bar_hidden(mut self, hidden: bool) -> WindowBuilder {
+        self.platform_specific.prefers_status_bar_hidden = hidden;
+        self
+    }
+}
+
+/// Additional methods on [`MonitorHandle`] that are specific to iOS.
+pub trait MonitorHandleExtIOS {
+    /// Returns a pointer to the [`UIScreen`] that is used by this monitor.
+    ///
+    /// [`UIScreen`]: https://developer.apple.com/documentation/uikit/uiscreen?language=objc
+    fn ui_screen(&self) -> *mut c_void;
+
+    /// Returns the preferred [`VideoMode`] for this monitor.
+    ///
+    /// This translates to a call to [`-[UIScreen preferredMode]`](https://developer.apple.com/documentation/uikit/uiscreen/1617823-preferredmode?language=objc).
+    fn preferred_video_mode(&self) -> VideoMode;
+}
+
+impl MonitorHandleExtIOS for MonitorHandle {
+    #[inline]
+    fn ui_screen(&self) -> *mut c_void {
+        Id::as_ptr(self.inner.ui_screen()) as *mut c_void
+    }
+
+    #[inline]
+    fn preferred_video_mode(&self) -> VideoMode {
+        VideoMode {
+            video_mode: self.inner.preferred_video_mode(),
+        }
+    }
+}
+
+/// Valid orientations for a particular [`Window`].
+#[derive(Clone, Copy, Debug)]
+pub enum ValidOrientations {
+    /// Excludes `PortraitUpsideDown` on iphone
+    LandscapeAndPortrait,
+
+    Landscape,
+
+    /// Excludes `PortraitUpsideDown` on iphone
+    Portrait,
+}
+
+impl Default for ValidOrientations {
+    #[inline]
+    fn default() -> ValidOrientations {
+        ValidOrientations::LandscapeAndPortrait
+    }
+}
+
+/// The device [idiom].
+///
+/// [idiom]: https://developer.apple.com/documentation/uikit/uidevice/1620037-userinterfaceidiom?language=objc
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Idiom {
+    Unspecified,
+
+    /// iPhone and iPod touch.
+    Phone,
+
+    /// iPad.
+    Pad,
+
+    /// tvOS and Apple TV.
+    TV,
+    CarPlay,
+}
+
+bitflags! {
+    /// The [edges] of a screen.
+    ///
+    /// [edges]: https://developer.apple.com/documentation/uikit/uirectedge?language=objc
+    #[derive(Default)]
+    pub struct ScreenEdge: u8 {
+        const NONE   = 0;
+        const TOP    = 1 << 0;
+        const LEFT   = 1 << 1;
+        const BOTTOM = 1 << 2;
+        const RIGHT  = 1 << 3;
+        const ALL = ScreenEdge::TOP.bits | ScreenEdge::LEFT.bits
+            | ScreenEdge::BOTTOM.bits | ScreenEdge::RIGHT.bits;
+    }
+}

third-party/vendor/winit/src/platform/macos.rs

@@ -0,0 +1,371 @@
+use std::os::raw::c_void;
+
+use objc2::rc::Id;
+
+use crate::{
+    event_loop::{EventLoopBuilder, EventLoopWindowTarget},
+    monitor::MonitorHandle,
+    window::{Window, WindowBuilder},
+};
+
+/// Additional methods on [`Window`] that are specific to MacOS.
+pub trait WindowExtMacOS {
+    /// Returns a pointer to the cocoa `NSWindow` that is used by this window.
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    fn ns_window(&self) -> *mut c_void;
+
+    /// Returns a pointer to the cocoa `NSView` that is used by this window.
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    fn ns_view(&self) -> *mut c_void;
+
+    /// Returns whether or not the window is in simple fullscreen mode.
+    fn simple_fullscreen(&self) -> bool;
+
+    /// Toggles a fullscreen mode that doesn't require a new macOS space.
+    /// Returns a boolean indicating whether the transition was successful (this
+    /// won't work if the window was already in the native fullscreen).
+    ///
+    /// This is how fullscreen used to work on macOS in versions before Lion.
+    /// And allows the user to have a fullscreen window without using another
+    /// space or taking control over the entire monitor.
+    fn set_simple_fullscreen(&self, fullscreen: bool) -> bool;
+
+    /// Returns whether or not the window has shadow.
+    fn has_shadow(&self) -> bool;
+
+    /// Sets whether or not the window has shadow.
+    fn set_has_shadow(&self, has_shadow: bool);
+
+    /// Get the window's edit state.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// WindowEvent::CloseRequested => {
+    ///     if window.is_document_edited() {
+    ///         // Show the user a save pop-up or similar
+    ///     } else {
+    ///         // Close the window
+    ///         drop(window);
+    ///     }
+    /// }
+    /// ```
+    fn is_document_edited(&self) -> bool;
+
+    /// Put the window in a state which indicates a file save is required.
+    fn set_document_edited(&self, edited: bool);
+
+    /// Set option as alt behavior as described in [`OptionAsAlt`].
+    ///
+    /// This will ignore diacritical marks and accent characters from
+    /// being processed as received characters. Instead, the input
+    /// device's raw character will be placed in event queues with the
+    /// Alt modifier set.
+    fn set_option_as_alt(&self, option_as_alt: OptionAsAlt);
+
+    /// Getter for the [`WindowExtMacOS::set_option_as_alt`].
+    fn option_as_alt(&self) -> OptionAsAlt;
+}
+
+impl WindowExtMacOS for Window {
+    #[inline]
+    fn ns_window(&self) -> *mut c_void {
+        self.window.ns_window()
+    }
+
+    #[inline]
+    fn ns_view(&self) -> *mut c_void {
+        self.window.ns_view()
+    }
+
+    #[inline]
+    fn simple_fullscreen(&self) -> bool {
+        self.window.simple_fullscreen()
+    }
+
+    #[inline]
+    fn set_simple_fullscreen(&self, fullscreen: bool) -> bool {
+        self.window.set_simple_fullscreen(fullscreen)
+    }
+
+    #[inline]
+    fn has_shadow(&self) -> bool {
+        self.window.has_shadow()
+    }
+
+    #[inline]
+    fn set_has_shadow(&self, has_shadow: bool) {
+        self.window.set_has_shadow(has_shadow)
+    }
+
+    #[inline]
+    fn is_document_edited(&self) -> bool {
+        self.window.is_document_edited()
+    }
+
+    #[inline]
+    fn set_document_edited(&self, edited: bool) {
+        self.window.set_document_edited(edited)
+    }
+
+    #[inline]
+    fn set_option_as_alt(&self, option_as_alt: OptionAsAlt) {
+        self.window.set_option_as_alt(option_as_alt)
+    }
+
+    #[inline]
+    fn option_as_alt(&self) -> OptionAsAlt {
+        self.window.option_as_alt()
+    }
+}
+
+/// Corresponds to `NSApplicationActivationPolicy`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ActivationPolicy {
+    /// Corresponds to `NSApplicationActivationPolicyRegular`.
+    Regular,
+    /// Corresponds to `NSApplicationActivationPolicyAccessory`.
+    Accessory,
+    /// Corresponds to `NSApplicationActivationPolicyProhibited`.
+    Prohibited,
+}
+
+impl Default for ActivationPolicy {
+    fn default() -> Self {
+        ActivationPolicy::Regular
+    }
+}
+
+/// Additional methods on [`WindowBuilder`] that are specific to MacOS.
+///
+/// **Note:** Properties dealing with the titlebar will be overwritten by the [`WindowBuilder::with_decorations`] method:
+/// - `with_titlebar_transparent`
+/// - `with_title_hidden`
+/// - `with_titlebar_hidden`
+/// - `with_titlebar_buttons_hidden`
+/// - `with_fullsize_content_view`
+pub trait WindowBuilderExtMacOS {
+    /// Enables click-and-drag behavior for the entire window, not just the titlebar.
+    fn with_movable_by_window_background(self, movable_by_window_background: bool)
+        -> WindowBuilder;
+    /// Makes the titlebar transparent and allows the content to appear behind it.
+    fn with_titlebar_transparent(self, titlebar_transparent: bool) -> WindowBuilder;
+    /// Hides the window title.
+    fn with_title_hidden(self, title_hidden: bool) -> WindowBuilder;
+    /// Hides the window titlebar.
+    fn with_titlebar_hidden(self, titlebar_hidden: bool) -> WindowBuilder;
+    /// Hides the window titlebar buttons.
+    fn with_titlebar_buttons_hidden(self, titlebar_buttons_hidden: bool) -> WindowBuilder;
+    /// Makes the window content appear behind the titlebar.
+    fn with_fullsize_content_view(self, fullsize_content_view: bool) -> WindowBuilder;
+    fn with_disallow_hidpi(self, disallow_hidpi: bool) -> WindowBuilder;
+    fn with_has_shadow(self, has_shadow: bool) -> WindowBuilder;
+    /// Window accepts click-through mouse events.
+    fn with_accepts_first_mouse(self, accepts_first_mouse: bool) -> WindowBuilder;
+
+    /// Set whether the `OptionAsAlt` key is interpreted as the `Alt` modifier.
+    ///
+    /// See [`WindowExtMacOS::set_option_as_alt`] for details on what this means if set.
+    fn with_option_as_alt(self, option_as_alt: OptionAsAlt) -> WindowBuilder;
+}
+
+impl WindowBuilderExtMacOS for WindowBuilder {
+    #[inline]
+    fn with_movable_by_window_background(
+        mut self,
+        movable_by_window_background: bool,
+    ) -> WindowBuilder {
+        self.platform_specific.movable_by_window_background = movable_by_window_background;
+        self
+    }
+
+    #[inline]
+    fn with_titlebar_transparent(mut self, titlebar_transparent: bool) -> WindowBuilder {
+        self.platform_specific.titlebar_transparent = titlebar_transparent;
+        self
+    }
+
+    #[inline]
+    fn with_titlebar_hidden(mut self, titlebar_hidden: bool) -> WindowBuilder {
+        self.platform_specific.titlebar_hidden = titlebar_hidden;
+        self
+    }
+
+    #[inline]
+    fn with_titlebar_buttons_hidden(mut self, titlebar_buttons_hidden: bool) -> WindowBuilder {
+        self.platform_specific.titlebar_buttons_hidden = titlebar_buttons_hidden;
+        self
+    }
+
+    #[inline]
+    fn with_title_hidden(mut self, title_hidden: bool) -> WindowBuilder {
+        self.platform_specific.title_hidden = title_hidden;
+        self
+    }
+
+    #[inline]
+    fn with_fullsize_content_view(mut self, fullsize_content_view: bool) -> WindowBuilder {
+        self.platform_specific.fullsize_content_view = fullsize_content_view;
+        self
+    }
+
+    #[inline]
+    fn with_disallow_hidpi(mut self, disallow_hidpi: bool) -> WindowBuilder {
+        self.platform_specific.disallow_hidpi = disallow_hidpi;
+        self
+    }
+
+    #[inline]
+    fn with_has_shadow(mut self, has_shadow: bool) -> WindowBuilder {
+        self.platform_specific.has_shadow = has_shadow;
+        self
+    }
+
+    #[inline]
+    fn with_accepts_first_mouse(mut self, accepts_first_mouse: bool) -> WindowBuilder {
+        self.platform_specific.accepts_first_mouse = accepts_first_mouse;
+        self
+    }
+
+    #[inline]
+    fn with_option_as_alt(mut self, option_as_alt: OptionAsAlt) -> WindowBuilder {
+        self.platform_specific.option_as_alt = option_as_alt;
+        self
+    }
+}
+
+pub trait EventLoopBuilderExtMacOS {
+    /// Sets the activation policy for the application.
+    ///
+    /// It is set to [`ActivationPolicy::Regular`] by default.
+    ///
+    /// # Example
+    ///
+    /// Set the activation policy to "accessory".
+    ///
+    /// ```
+    /// use winit::event_loop::EventLoopBuilder;
+    /// #[cfg(target_os = "macos")]
+    /// use winit::platform::macos::{EventLoopBuilderExtMacOS, ActivationPolicy};
+    ///
+    /// let mut builder = EventLoopBuilder::new();
+    /// #[cfg(target_os = "macos")]
+    /// builder.with_activation_policy(ActivationPolicy::Accessory);
+    /// # if false { // We can't test this part
+    /// let event_loop = builder.build();
+    /// # }
+    /// ```
+    fn with_activation_policy(&mut self, activation_policy: ActivationPolicy) -> &mut Self;
+
+    /// Used to control whether a default menubar menu is created.
+    ///
+    /// Menu creation is enabled by default.
+    ///
+    /// # Example
+    ///
+    /// Disable creating a default menubar.
+    ///
+    /// ```
+    /// use winit::event_loop::EventLoopBuilder;
+    /// #[cfg(target_os = "macos")]
+    /// use winit::platform::macos::EventLoopBuilderExtMacOS;
+    ///
+    /// let mut builder = EventLoopBuilder::new();
+    /// #[cfg(target_os = "macos")]
+    /// builder.with_default_menu(false);
+    /// # if false { // We can't test this part
+    /// let event_loop = builder.build();
+    /// # }
+    /// ```
+    fn with_default_menu(&mut self, enable: bool) -> &mut Self;
+
+    /// Used to prevent the application from automatically activating when launched if
+    /// another application is already active.
+    ///
+    /// The default behavior is to ignore other applications and activate when launched.
+    fn with_activate_ignoring_other_apps(&mut self, ignore: bool) -> &mut Self;
+}
+
+impl<T> EventLoopBuilderExtMacOS for EventLoopBuilder<T> {
+    #[inline]
+    fn with_activation_policy(&mut self, activation_policy: ActivationPolicy) -> &mut Self {
+        self.platform_specific.activation_policy = activation_policy;
+        self
+    }
+
+    #[inline]
+    fn with_default_menu(&mut self, enable: bool) -> &mut Self {
+        self.platform_specific.default_menu = enable;
+        self
+    }
+
+    #[inline]
+    fn with_activate_ignoring_other_apps(&mut self, ignore: bool) -> &mut Self {
+        self.platform_specific.activate_ignoring_other_apps = ignore;
+        self
+    }
+}
+
+/// Additional methods on [`MonitorHandle`] that are specific to MacOS.
+pub trait MonitorHandleExtMacOS {
+    /// Returns the identifier of the monitor for Cocoa.
+    fn native_id(&self) -> u32;
+    /// Returns a pointer to the NSScreen representing this monitor.
+    fn ns_screen(&self) -> Option<*mut c_void>;
+}
+
+impl MonitorHandleExtMacOS for MonitorHandle {
+    #[inline]
+    fn native_id(&self) -> u32 {
+        self.inner.native_identifier()
+    }
+
+    fn ns_screen(&self) -> Option<*mut c_void> {
+        self.inner.ns_screen().map(|s| Id::as_ptr(&s) as _)
+    }
+}
+
+/// Additional methods on [`EventLoopWindowTarget`] that are specific to macOS.
+pub trait EventLoopWindowTargetExtMacOS {
+    /// Hide the entire application. In most applications this is typically triggered with Command-H.
+    fn hide_application(&self);
+    /// Hide the other applications. In most applications this is typically triggered with Command+Option-H.
+    fn hide_other_applications(&self);
+}
+
+impl<T> EventLoopWindowTargetExtMacOS for EventLoopWindowTarget<T> {
+    fn hide_application(&self) {
+        self.p.hide_application()
+    }
+
+    fn hide_other_applications(&self) {
+        self.p.hide_other_applications()
+    }
+}
+
+/// Option as alt behavior.
+///
+/// The default is `None`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum OptionAsAlt {
+    /// The left `Option` key is treated as `Alt`.
+    OnlyLeft,
+
+    /// The right `Option` key is treated as `Alt`.
+    OnlyRight,
+
+    /// Both `Option` keys are treated as `Alt`.
+    Both,
+
+    /// No special handling is applied for `Option` key.
+    None,
+}
+
+impl Default for OptionAsAlt {
+    fn default() -> Self {
+        OptionAsAlt::None
+    }
+}

third-party/vendor/winit/src/platform/mod.rs

@@ -0,0 +1,43 @@
+//! Contains traits with platform-specific methods in them.
+//!
+//! Contains the follow OS-specific modules:
+//!
+//!  - `android`
+//!  - `ios`
+//!  - `macos`
+//!  - `unix`
+//!  - `windows`
+//!  - `web`
+//!
+//! And the following platform-specific module:
+//!
+//! - `run_return` (available on `windows`, `unix`, `macos`, and `android`)
+//!
+//! However only the module corresponding to the platform you're compiling to will be available.
+
+#[cfg(android_platform)]
+pub mod android;
+#[cfg(ios_platform)]
+pub mod ios;
+#[cfg(macos_platform)]
+pub mod macos;
+#[cfg(orbital_platform)]
+pub mod orbital;
+#[cfg(wayland_platform)]
+pub mod wayland;
+#[cfg(wasm_platform)]
+pub mod web;
+#[cfg(windows_platform)]
+pub mod windows;
+#[cfg(x11_platform)]
+pub mod x11;
+
+#[cfg(any(
+    windows_platform,
+    macos_platform,
+    android_platform,
+    x11_platform,
+    wayland_platform,
+    orbital_platform
+))]
+pub mod run_return;

third-party/vendor/winit/src/platform/orbital.rs

@@ -0,0 +1 @@
+// There are no Orbital specific traits yet.

third-party/vendor/winit/src/platform/run_return.rs

@@ -0,0 +1,53 @@
+use crate::{
+    event::Event,
+    event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
+};
+
+/// Additional methods on [`EventLoop`] to return control flow to the caller.
+pub trait EventLoopExtRunReturn {
+    /// A type provided by the user that can be passed through [`Event::UserEvent`].
+    type UserEvent;
+
+    /// Initializes the `winit` event loop.
+    ///
+    /// Unlike [`EventLoop::run`], this function accepts non-`'static` (i.e. non-`move`) closures
+    /// and returns control flow to the caller when `control_flow` is set to [`ControlFlow::Exit`].
+    ///
+    /// # Caveats
+    ///
+    /// Despite its appearance at first glance, this is *not* a perfect replacement for
+    /// `poll_events`. For example, this function will not return on Windows or macOS while a
+    /// window is getting resized, resulting in all application logic outside of the
+    /// `event_handler` closure not running until the resize operation ends. Other OS operations
+    /// may also result in such freezes. This behavior is caused by fundamental limitations in the
+    /// underlying OS APIs, which cannot be hidden by `winit` without severe stability repercussions.
+    ///
+    /// You are strongly encouraged to use `run`, unless the use of this is absolutely necessary.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **X11 / Wayland:** This function returns `1` upon disconnection from
+    ///   the display server.
+    fn run_return<F>(&mut self, event_handler: F) -> i32
+    where
+        F: FnMut(
+            Event<'_, Self::UserEvent>,
+            &EventLoopWindowTarget<Self::UserEvent>,
+            &mut ControlFlow,
+        );
+}
+
+impl<T> EventLoopExtRunReturn for EventLoop<T> {
+    type UserEvent = T;
+
+    fn run_return<F>(&mut self, event_handler: F) -> i32
+    where
+        F: FnMut(
+            Event<'_, Self::UserEvent>,
+            &EventLoopWindowTarget<Self::UserEvent>,
+            &mut ControlFlow,
+        ),
+    {
+        self.event_loop.run_return(event_handler)
+    }
+}

third-party/vendor/winit/src/platform/wayland.rs

@@ -0,0 +1,144 @@
+use std::os::raw;
+
+use crate::{
+    event_loop::{EventLoopBuilder, EventLoopWindowTarget},
+    monitor::MonitorHandle,
+    window::{Window, WindowBuilder},
+};
+
+use crate::platform_impl::{
+    ApplicationName, Backend, EventLoopWindowTarget as LinuxEventLoopWindowTarget,
+    Window as LinuxWindow,
+};
+
+pub use crate::window::Theme;
+
+/// Additional methods on [`EventLoopWindowTarget`] that are specific to Wayland.
+pub trait EventLoopWindowTargetExtWayland {
+    /// True if the [`EventLoopWindowTarget`] uses Wayland.
+    fn is_wayland(&self) -> bool;
+
+    /// Returns a pointer to the `wl_display` object of wayland that is used by this
+    /// [`EventLoopWindowTarget`].
+    ///
+    /// Returns `None` if the [`EventLoop`] doesn't use wayland (if it uses xlib for example).
+    ///
+    /// The pointer will become invalid when the winit [`EventLoop`] is destroyed.
+    ///
+    /// [`EventLoop`]: crate::event_loop::EventLoop
+    fn wayland_display(&self) -> Option<*mut raw::c_void>;
+}
+
+impl<T> EventLoopWindowTargetExtWayland for EventLoopWindowTarget<T> {
+    #[inline]
+    fn is_wayland(&self) -> bool {
+        self.p.is_wayland()
+    }
+
+    #[inline]
+    fn wayland_display(&self) -> Option<*mut raw::c_void> {
+        match self.p {
+            LinuxEventLoopWindowTarget::Wayland(ref p) => {
+                Some(p.display().get_display_ptr() as *mut _)
+            }
+            #[cfg(x11_platform)]
+            _ => None,
+        }
+    }
+}
+
+/// Additional methods on [`EventLoopBuilder`] that are specific to Wayland.
+pub trait EventLoopBuilderExtWayland {
+    /// Force using Wayland.
+    fn with_wayland(&mut self) -> &mut Self;
+
+    /// Whether to allow the event loop to be created off of the main thread.
+    ///
+    /// By default, the window is only allowed to be created on the main
+    /// thread, to make platform compatibility easier.
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self;
+}
+
+impl<T> EventLoopBuilderExtWayland for EventLoopBuilder<T> {
+    #[inline]
+    fn with_wayland(&mut self) -> &mut Self {
+        self.platform_specific.forced_backend = Some(Backend::Wayland);
+        self
+    }
+
+    #[inline]
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self {
+        self.platform_specific.any_thread = any_thread;
+        self
+    }
+}
+
+/// Additional methods on [`Window`] that are specific to Wayland.
+pub trait WindowExtWayland {
+    /// Returns a pointer to the `wl_surface` object of wayland that is used by this window.
+    ///
+    /// Returns `None` if the window doesn't use wayland (if it uses xlib for example).
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    fn wayland_surface(&self) -> Option<*mut raw::c_void>;
+
+    /// Returns a pointer to the `wl_display` object of wayland that is used by this window.
+    ///
+    /// Returns `None` if the window doesn't use wayland (if it uses xlib for example).
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    fn wayland_display(&self) -> Option<*mut raw::c_void>;
+}
+
+impl WindowExtWayland for Window {
+    #[inline]
+    fn wayland_surface(&self) -> Option<*mut raw::c_void> {
+        match self.window {
+            LinuxWindow::Wayland(ref w) => Some(w.surface().as_ref().c_ptr() as *mut _),
+            #[cfg(x11_platform)]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    fn wayland_display(&self) -> Option<*mut raw::c_void> {
+        match self.window {
+            LinuxWindow::Wayland(ref w) => Some(w.display().get_display_ptr() as *mut _),
+            #[cfg(x11_platform)]
+            _ => None,
+        }
+    }
+}
+
+/// Additional methods on [`WindowBuilder`] that are specific to Wayland.
+pub trait WindowBuilderExtWayland {
+    /// Build window with the given name.
+    ///
+    /// The `general` name sets an application ID, which should match the `.desktop`
+    /// file destributed with your program. The `instance` is a `no-op`.
+    ///
+    /// For details about application ID conventions, see the
+    /// [Desktop Entry Spec](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#desktop-file-id)
+    fn with_name(self, general: impl Into<String>, instance: impl Into<String>) -> Self;
+}
+
+impl WindowBuilderExtWayland for WindowBuilder {
+    #[inline]
+    fn with_name(mut self, general: impl Into<String>, instance: impl Into<String>) -> Self {
+        self.platform_specific.name = Some(ApplicationName::new(general.into(), instance.into()));
+        self
+    }
+}
+
+/// Additional methods on `MonitorHandle` that are specific to Wayland.
+pub trait MonitorHandleExtWayland {
+    /// Returns the inner identifier of the monitor.
+    fn native_id(&self) -> u32;
+}
+
+impl MonitorHandleExtWayland for MonitorHandle {
+    #[inline]
+    fn native_id(&self) -> u32 {
+        self.inner.native_identifier()
+    }
+}

third-party/vendor/winit/src/platform/web.rs

@@ -0,0 +1,89 @@
+//! The web target does not automatically insert the canvas element object into the web page, to
+//! allow end users to determine how the page should be laid out. Use the [`WindowExtWebSys`] trait
+//! to retrieve the canvas from the Window. Alternatively, use the [`WindowBuilderExtWebSys`] trait
+//! to provide your own canvas.
+
+use crate::event::Event;
+use crate::event_loop::ControlFlow;
+use crate::event_loop::EventLoop;
+use crate::event_loop::EventLoopWindowTarget;
+use crate::window::WindowBuilder;
+
+use web_sys::HtmlCanvasElement;
+
+pub trait WindowExtWebSys {
+    fn canvas(&self) -> HtmlCanvasElement;
+
+    /// Whether the browser reports the preferred color scheme to be "dark".
+    fn is_dark_mode(&self) -> bool;
+}
+
+pub trait WindowBuilderExtWebSys {
+    fn with_canvas(self, canvas: Option<HtmlCanvasElement>) -> Self;
+
+    /// Whether `event.preventDefault` should be automatically called to prevent event propagation
+    /// when appropriate.
+    ///
+    /// For example, mouse wheel events are only handled by the canvas by default. This avoids
+    /// the default behavior of scrolling the page.
+    fn with_prevent_default(self, prevent_default: bool) -> Self;
+
+    /// Whether the canvas should be focusable using the tab key. This is necessary to capture
+    /// canvas keyboard events.
+    fn with_focusable(self, focusable: bool) -> Self;
+}
+
+impl WindowBuilderExtWebSys for WindowBuilder {
+    fn with_canvas(mut self, canvas: Option<HtmlCanvasElement>) -> Self {
+        self.platform_specific.canvas = canvas;
+
+        self
+    }
+
+    fn with_prevent_default(mut self, prevent_default: bool) -> Self {
+        self.platform_specific.prevent_default = prevent_default;
+
+        self
+    }
+
+    fn with_focusable(mut self, focusable: bool) -> Self {
+        self.platform_specific.focusable = focusable;
+
+        self
+    }
+}
+
+/// Additional methods on `EventLoop` that are specific to the web.
+pub trait EventLoopExtWebSys {
+    /// A type provided by the user that can be passed through `Event::UserEvent`.
+    type UserEvent;
+
+    /// Initializes the winit event loop.
+    ///
+    /// Unlike `run`, this returns immediately, and doesn't throw an exception in order to
+    /// satisfy its `!` return type.
+    fn spawn<F>(self, event_handler: F)
+    where
+        F: 'static
+            + FnMut(
+                Event<'_, Self::UserEvent>,
+                &EventLoopWindowTarget<Self::UserEvent>,
+                &mut ControlFlow,
+            );
+}
+
+impl<T> EventLoopExtWebSys for EventLoop<T> {
+    type UserEvent = T;
+
+    fn spawn<F>(self, event_handler: F)
+    where
+        F: 'static
+            + FnMut(
+                Event<'_, Self::UserEvent>,
+                &EventLoopWindowTarget<Self::UserEvent>,
+                &mut ControlFlow,
+            ),
+    {
+        self.event_loop.spawn(event_handler)
+    }
+}

third-party/vendor/winit/src/platform/windows.rs

@@ -0,0 +1,346 @@
+use std::{ffi::c_void, path::Path};
+
+use crate::{
+    dpi::PhysicalSize,
+    event::DeviceId,
+    event_loop::EventLoopBuilder,
+    monitor::MonitorHandle,
+    platform_impl::WinIcon,
+    window::{BadIcon, Icon, Window, WindowBuilder},
+};
+
+/// Window Handle type used by Win32 API
+pub type HWND = isize;
+/// Menu Handle type used by Win32 API
+pub type HMENU = isize;
+/// Monitor Handle type used by Win32 API
+pub type HMONITOR = isize;
+/// Instance Handle type used by Win32 API
+pub type HINSTANCE = isize;
+
+/// Additional methods on `EventLoop` that are specific to Windows.
+pub trait EventLoopBuilderExtWindows {
+    /// Whether to allow the event loop to be created off of the main thread.
+    ///
+    /// By default, the window is only allowed to be created on the main
+    /// thread, to make platform compatibility easier.
+    ///
+    /// # `Window` caveats
+    ///
+    /// Note that any `Window` created on the new thread will be destroyed when the thread
+    /// terminates. Attempting to use a `Window` after its parent thread terminates has
+    /// unspecified, although explicitly not undefined, behavior.
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self;
+
+    /// Whether to enable process-wide DPI awareness.
+    ///
+    /// By default, `winit` will attempt to enable process-wide DPI awareness. If
+    /// that's undesirable, you can disable it with this function.
+    ///
+    /// # Example
+    ///
+    /// Disable process-wide DPI awareness.
+    ///
+    /// ```
+    /// use winit::event_loop::EventLoopBuilder;
+    /// #[cfg(target_os = "windows")]
+    /// use winit::platform::windows::EventLoopBuilderExtWindows;
+    ///
+    /// let mut builder = EventLoopBuilder::new();
+    /// #[cfg(target_os = "windows")]
+    /// builder.with_dpi_aware(false);
+    /// # if false { // We can't test this part
+    /// let event_loop = builder.build();
+    /// # }
+    /// ```
+    fn with_dpi_aware(&mut self, dpi_aware: bool) -> &mut Self;
+
+    /// A callback to be executed before dispatching a win32 message to the window procedure.
+    /// Return true to disable winit's internal message dispatching.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use windows_sys::Win32::UI::WindowsAndMessaging::{ACCEL, CreateAcceleratorTableW, TranslateAcceleratorW, DispatchMessageW, TranslateMessage, MSG};
+    /// use winit::event_loop::EventLoopBuilder;
+    /// #[cfg(target_os = "windows")]
+    /// use winit::platform::windows::EventLoopBuilderExtWindows;
+    ///
+    /// let mut builder = EventLoopBuilder::new();
+    /// #[cfg(target_os = "windows")]
+    /// builder.with_msg_hook(|msg|{
+    ///     let msg = msg as *const MSG;
+    /// #   let accels: Vec<ACCEL> = Vec::new();
+    ///     let translated = unsafe {
+    ///         TranslateAcceleratorW(
+    ///             (*msg).hwnd,
+    ///             CreateAcceleratorTableW(accels.as_ptr() as _, 1),
+    ///             msg,
+    ///         ) == 1
+    ///     };
+    ///     translated
+    /// });
+    /// ```
+    fn with_msg_hook<F>(&mut self, callback: F) -> &mut Self
+    where
+        F: FnMut(*const c_void) -> bool + 'static;
+}
+
+impl<T> EventLoopBuilderExtWindows for EventLoopBuilder<T> {
+    #[inline]
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self {
+        self.platform_specific.any_thread = any_thread;
+        self
+    }
+
+    #[inline]
+    fn with_dpi_aware(&mut self, dpi_aware: bool) -> &mut Self {
+        self.platform_specific.dpi_aware = dpi_aware;
+        self
+    }
+
+    #[inline]
+    fn with_msg_hook<F>(&mut self, callback: F) -> &mut Self
+    where
+        F: FnMut(*const c_void) -> bool + 'static,
+    {
+        self.platform_specific.msg_hook = Some(Box::new(callback));
+        self
+    }
+}
+
+/// Additional methods on `Window` that are specific to Windows.
+pub trait WindowExtWindows {
+    /// Returns the HINSTANCE of the window
+    fn hinstance(&self) -> HINSTANCE;
+    /// Returns the native handle that is used by this window.
+    ///
+    /// The pointer will become invalid when the native window was destroyed.
+    fn hwnd(&self) -> HWND;
+
+    /// Enables or disables mouse and keyboard input to the specified window.
+    ///
+    /// A window must be enabled before it can be activated.
+    /// If an application has create a modal dialog box by disabling its owner window
+    /// (as described in [`WindowBuilderExtWindows::with_owner_window`]), the application must enable
+    /// the owner window before destroying the dialog box.
+    /// Otherwise, another window will receive the keyboard focus and be activated.
+    ///
+    /// If a child window is disabled, it is ignored when the system tries to determine which
+    /// window should receive mouse messages.
+    ///
+    /// For more information, see <https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-enablewindow#remarks>
+    /// and <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#disabled-windows>
+    fn set_enable(&self, enabled: bool);
+
+    /// This sets `ICON_BIG`. A good ceiling here is 256x256.
+    fn set_taskbar_icon(&self, taskbar_icon: Option<Icon>);
+
+    /// Whether to show or hide the window icon in the taskbar.
+    fn set_skip_taskbar(&self, skip: bool);
+
+    /// Shows or hides the background drop shadow for undecorated windows.
+    ///
+    /// Enabling the shadow causes a thin 1px line to appear on the top of the window.
+    fn set_undecorated_shadow(&self, shadow: bool);
+}
+
+impl WindowExtWindows for Window {
+    #[inline]
+    fn hinstance(&self) -> HINSTANCE {
+        self.window.hinstance()
+    }
+
+    #[inline]
+    fn hwnd(&self) -> HWND {
+        self.window.hwnd()
+    }
+
+    #[inline]
+    fn set_enable(&self, enabled: bool) {
+        self.window.set_enable(enabled)
+    }
+
+    #[inline]
+    fn set_taskbar_icon(&self, taskbar_icon: Option<Icon>) {
+        self.window.set_taskbar_icon(taskbar_icon)
+    }
+
+    #[inline]
+    fn set_skip_taskbar(&self, skip: bool) {
+        self.window.set_skip_taskbar(skip)
+    }
+
+    #[inline]
+    fn set_undecorated_shadow(&self, shadow: bool) {
+        self.window.set_undecorated_shadow(shadow)
+    }
+}
+
+/// Additional methods on `WindowBuilder` that are specific to Windows.
+pub trait WindowBuilderExtWindows {
+    /// Set an owner to the window to be created. Can be used to create a dialog box, for example.
+    /// This only works when [`WindowBuilder::with_parent_window`] isn't called or set to `None`.
+    /// Can be used in combination with [`WindowExtWindows::set_enable(false)`](WindowExtWindows::set_enable)
+    /// on the owner window to create a modal dialog box.
+    ///
+    /// From MSDN:
+    /// - An owned window is always above its owner in the z-order.
+    /// - The system automatically destroys an owned window when its owner is destroyed.
+    /// - An owned window is hidden when its owner is minimized.
+    ///
+    /// For more information, see <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#owned-windows>
+    fn with_owner_window(self, parent: HWND) -> WindowBuilder;
+
+    /// Sets a menu on the window to be created.
+    ///
+    /// Parent and menu are mutually exclusive; a child window cannot have a menu!
+    ///
+    /// The menu must have been manually created beforehand with [`CreateMenu`] or similar.
+    ///
+    /// Note: Dark mode cannot be supported for win32 menus, it's simply not possible to change how the menus look.
+    /// If you use this, it is recommended that you combine it with `with_theme(Some(Theme::Light))` to avoid a jarring effect.
+    ///
+    /// [`CreateMenu`]: windows_sys::Win32::UI::WindowsAndMessaging::CreateMenu
+    fn with_menu(self, menu: HMENU) -> WindowBuilder;
+
+    /// This sets `ICON_BIG`. A good ceiling here is 256x256.
+    fn with_taskbar_icon(self, taskbar_icon: Option<Icon>) -> WindowBuilder;
+
+    /// This sets `WS_EX_NOREDIRECTIONBITMAP`.
+    fn with_no_redirection_bitmap(self, flag: bool) -> WindowBuilder;
+
+    /// Enables or disables drag and drop support (enabled by default). Will interfere with other crates
+    /// that use multi-threaded COM API (`CoInitializeEx` with `COINIT_MULTITHREADED` instead of
+    /// `COINIT_APARTMENTTHREADED`) on the same thread. Note that winit may still attempt to initialize
+    /// COM API regardless of this option. Currently only fullscreen mode does that, but there may be more in the future.
+    /// If you need COM API with `COINIT_MULTITHREADED` you must initialize it before calling any winit functions.
+    /// See <https://docs.microsoft.com/en-us/windows/win32/api/objbase/nf-objbase-coinitialize#remarks> for more information.
+    fn with_drag_and_drop(self, flag: bool) -> WindowBuilder;
+
+    /// Whether show or hide the window icon in the taskbar.
+    fn with_skip_taskbar(self, skip: bool) -> WindowBuilder;
+
+    /// Shows or hides the background drop shadow for undecorated windows.
+    ///
+    /// The shadow is hidden by default.
+    /// Enabling the shadow causes a thin 1px line to appear on the top of the window.
+    fn with_undecorated_shadow(self, shadow: bool) -> WindowBuilder;
+}
+
+impl WindowBuilderExtWindows for WindowBuilder {
+    #[inline]
+    fn with_owner_window(mut self, parent: HWND) -> WindowBuilder {
+        self.platform_specific.owner = Some(parent);
+        self
+    }
+
+    #[inline]
+    fn with_menu(mut self, menu: HMENU) -> WindowBuilder {
+        self.platform_specific.menu = Some(menu);
+        self
+    }
+
+    #[inline]
+    fn with_taskbar_icon(mut self, taskbar_icon: Option<Icon>) -> WindowBuilder {
+        self.platform_specific.taskbar_icon = taskbar_icon;
+        self
+    }
+
+    #[inline]
+    fn with_no_redirection_bitmap(mut self, flag: bool) -> WindowBuilder {
+        self.platform_specific.no_redirection_bitmap = flag;
+        self
+    }
+
+    #[inline]
+    fn with_drag_and_drop(mut self, flag: bool) -> WindowBuilder {
+        self.platform_specific.drag_and_drop = flag;
+        self
+    }
+
+    #[inline]
+    fn with_skip_taskbar(mut self, skip: bool) -> WindowBuilder {
+        self.platform_specific.skip_taskbar = skip;
+        self
+    }
+
+    #[inline]
+    fn with_undecorated_shadow(mut self, shadow: bool) -> WindowBuilder {
+        self.platform_specific.decoration_shadow = shadow;
+        self
+    }
+}
+
+/// Additional methods on `MonitorHandle` that are specific to Windows.
+pub trait MonitorHandleExtWindows {
+    /// Returns the name of the monitor adapter specific to the Win32 API.
+    fn native_id(&self) -> String;
+
+    /// Returns the handle of the monitor - `HMONITOR`.
+    fn hmonitor(&self) -> HMONITOR;
+}
+
+impl MonitorHandleExtWindows for MonitorHandle {
+    #[inline]
+    fn native_id(&self) -> String {
+        self.inner.native_identifier()
+    }
+
+    #[inline]
+    fn hmonitor(&self) -> HMONITOR {
+        self.inner.hmonitor()
+    }
+}
+
+/// Additional methods on `DeviceId` that are specific to Windows.
+pub trait DeviceIdExtWindows {
+    /// Returns an identifier that persistently refers to this specific device.
+    ///
+    /// Will return `None` if the device is no longer available.
+    fn persistent_identifier(&self) -> Option<String>;
+}
+
+impl DeviceIdExtWindows for DeviceId {
+    #[inline]
+    fn persistent_identifier(&self) -> Option<String> {
+        self.0.persistent_identifier()
+    }
+}
+
+/// Additional methods on `Icon` that are specific to Windows.
+pub trait IconExtWindows: Sized {
+    /// Create an icon from a file path.
+    ///
+    /// Specify `size` to load a specific icon size from the file, or `None` to load the default
+    /// icon size from the file.
+    ///
+    /// In cases where the specified size does not exist in the file, Windows may perform scaling
+    /// to get an icon of the desired size.
+    fn from_path<P: AsRef<Path>>(path: P, size: Option<PhysicalSize<u32>>)
+        -> Result<Self, BadIcon>;
+
+    /// Create an icon from a resource embedded in this executable or library.
+    ///
+    /// Specify `size` to load a specific icon size from the file, or `None` to load the default
+    /// icon size from the file.
+    ///
+    /// In cases where the specified size does not exist in the file, Windows may perform scaling
+    /// to get an icon of the desired size.
+    fn from_resource(ordinal: u16, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon>;
+}
+
+impl IconExtWindows for Icon {
+    fn from_path<P: AsRef<Path>>(
+        path: P,
+        size: Option<PhysicalSize<u32>>,
+    ) -> Result<Self, BadIcon> {
+        let win_icon = WinIcon::from_path(path, size)?;
+        Ok(Icon { inner: win_icon })
+    }
+
+    fn from_resource(ordinal: u16, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon> {
+        let win_icon = WinIcon::from_resource(ordinal, size)?;
+        Ok(Icon { inner: win_icon })
+    }
+}

third-party/vendor/winit/src/platform/x11.rs

@@ -0,0 +1,233 @@
+use std::os::raw;
+use std::ptr;
+
+use crate::{
+    event_loop::{EventLoopBuilder, EventLoopWindowTarget},
+    monitor::MonitorHandle,
+    window::{Window, WindowBuilder},
+};
+
+use crate::dpi::Size;
+use crate::platform_impl::{
+    x11::ffi::XVisualInfo, ApplicationName, Backend, Window as LinuxWindow, XLIB_ERROR_HOOKS,
+};
+
+pub use crate::platform_impl::{x11::util::WindowType as XWindowType, XNotSupported};
+
+/// The first argument in the provided hook will be the pointer to `XDisplay`
+/// and the second one the pointer to [`XErrorEvent`]. The returned `bool` is an
+/// indicator whether the error was handled by the callback.
+///
+/// [`XErrorEvent`]: https://linux.die.net/man/3/xerrorevent
+pub type XlibErrorHook =
+    Box<dyn Fn(*mut std::ffi::c_void, *mut std::ffi::c_void) -> bool + Send + Sync>;
+
+/// Hook to winit's xlib error handling callback.
+///
+/// This method is provided as a safe way to handle the errors comming from X11
+/// when using xlib in external crates, like glutin for GLX access. Trying to
+/// handle errors by speculating with `XSetErrorHandler` is [`unsafe`].
+///
+/// **Be aware that your hook is always invoked and returning `true` from it will
+/// prevent `winit` from getting the error itself. It's wise to always return
+/// `false` if you're not initiated the `Sync`.**
+///
+/// [`unsafe`]: https://www.remlab.net/op/xlib.shtml
+#[inline]
+pub fn register_xlib_error_hook(hook: XlibErrorHook) {
+    // Append new hook.
+    unsafe {
+        XLIB_ERROR_HOOKS.lock().unwrap().push(hook);
+    }
+}
+
+/// Additional methods on [`EventLoopWindowTarget`] that are specific to X11.
+pub trait EventLoopWindowTargetExtX11 {
+    /// True if the [`EventLoopWindowTarget`] uses X11.
+    fn is_x11(&self) -> bool;
+}
+
+impl<T> EventLoopWindowTargetExtX11 for EventLoopWindowTarget<T> {
+    #[inline]
+    fn is_x11(&self) -> bool {
+        !self.p.is_wayland()
+    }
+}
+
+/// Additional methods on [`EventLoopBuilder`] that are specific to X11.
+pub trait EventLoopBuilderExtX11 {
+    /// Force using X11.
+    fn with_x11(&mut self) -> &mut Self;
+
+    /// Whether to allow the event loop to be created off of the main thread.
+    ///
+    /// By default, the window is only allowed to be created on the main
+    /// thread, to make platform compatibility easier.
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self;
+}
+
+impl<T> EventLoopBuilderExtX11 for EventLoopBuilder<T> {
+    #[inline]
+    fn with_x11(&mut self) -> &mut Self {
+        self.platform_specific.forced_backend = Some(Backend::X);
+        self
+    }
+
+    #[inline]
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self {
+        self.platform_specific.any_thread = any_thread;
+        self
+    }
+}
+
+/// Additional methods on [`Window`] that are specific to X11.
+pub trait WindowExtX11 {
+    /// Returns the ID of the [`Window`] xlib object that is used by this window.
+    ///
+    /// Returns `None` if the window doesn't use xlib (if it uses wayland for example).
+    fn xlib_window(&self) -> Option<raw::c_ulong>;
+
+    /// Returns a pointer to the `Display` object of xlib that is used by this window.
+    ///
+    /// Returns `None` if the window doesn't use xlib (if it uses wayland for example).
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    fn xlib_display(&self) -> Option<*mut raw::c_void>;
+
+    fn xlib_screen_id(&self) -> Option<raw::c_int>;
+
+    /// This function returns the underlying `xcb_connection_t` of an xlib `Display`.
+    ///
+    /// Returns `None` if the window doesn't use xlib (if it uses wayland for example).
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    fn xcb_connection(&self) -> Option<*mut raw::c_void>;
+}
+
+impl WindowExtX11 for Window {
+    #[inline]
+    fn xlib_window(&self) -> Option<raw::c_ulong> {
+        match self.window {
+            LinuxWindow::X(ref w) => Some(w.xlib_window()),
+            #[cfg(wayland_platform)]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    fn xlib_display(&self) -> Option<*mut raw::c_void> {
+        match self.window {
+            LinuxWindow::X(ref w) => Some(w.xlib_display()),
+            #[cfg(wayland_platform)]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    fn xlib_screen_id(&self) -> Option<raw::c_int> {
+        match self.window {
+            LinuxWindow::X(ref w) => Some(w.xlib_screen_id()),
+            #[cfg(wayland_platform)]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    fn xcb_connection(&self) -> Option<*mut raw::c_void> {
+        match self.window {
+            LinuxWindow::X(ref w) => Some(w.xcb_connection()),
+            #[cfg(wayland_platform)]
+            _ => None,
+        }
+    }
+}
+
+/// Additional methods on [`WindowBuilder`] that are specific to X11.
+pub trait WindowBuilderExtX11 {
+    fn with_x11_visual<T>(self, visual_infos: *const T) -> Self;
+
+    fn with_x11_screen(self, screen_id: i32) -> Self;
+
+    /// Build window with the given `general` and `instance` names.
+    ///
+    /// The `general` sets general class of `WM_CLASS(STRING)`, while `instance` set the
+    /// instance part of it. The resulted property looks like `WM_CLASS(STRING) = "general", "instance"`.
+    ///
+    /// For details about application ID conventions, see the
+    /// [Desktop Entry Spec](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#desktop-file-id)
+    fn with_name(self, general: impl Into<String>, instance: impl Into<String>) -> Self;
+
+    /// Build window with override-redirect flag; defaults to false. Only relevant on X11.
+    fn with_override_redirect(self, override_redirect: bool) -> Self;
+
+    /// Build window with `_NET_WM_WINDOW_TYPE` hints; defaults to `Normal`. Only relevant on X11.
+    fn with_x11_window_type(self, x11_window_type: Vec<XWindowType>) -> Self;
+
+    /// Build window with base size hint. Only implemented on X11.
+    ///
+    /// ```
+    /// # use winit::dpi::{LogicalSize, PhysicalSize};
+    /// # use winit::window::WindowBuilder;
+    /// # use winit::platform::x11::WindowBuilderExtX11;
+    /// // Specify the size in logical dimensions like this:
+    /// WindowBuilder::new().with_base_size(LogicalSize::new(400.0, 200.0));
+    ///
+    /// // Or specify the size in physical dimensions like this:
+    /// WindowBuilder::new().with_base_size(PhysicalSize::new(400, 200));
+    /// ```
+    fn with_base_size<S: Into<Size>>(self, base_size: S) -> Self;
+}
+
+impl WindowBuilderExtX11 for WindowBuilder {
+    #[inline]
+    fn with_x11_visual<T>(mut self, visual_infos: *const T) -> Self {
+        {
+            self.platform_specific.visual_infos =
+                Some(unsafe { ptr::read(visual_infos as *const XVisualInfo) });
+        }
+        self
+    }
+
+    #[inline]
+    fn with_x11_screen(mut self, screen_id: i32) -> Self {
+        self.platform_specific.screen_id = Some(screen_id);
+        self
+    }
+
+    #[inline]
+    fn with_name(mut self, general: impl Into<String>, instance: impl Into<String>) -> Self {
+        self.platform_specific.name = Some(ApplicationName::new(general.into(), instance.into()));
+        self
+    }
+
+    #[inline]
+    fn with_override_redirect(mut self, override_redirect: bool) -> Self {
+        self.platform_specific.override_redirect = override_redirect;
+        self
+    }
+
+    #[inline]
+    fn with_x11_window_type(mut self, x11_window_types: Vec<XWindowType>) -> Self {
+        self.platform_specific.x11_window_types = x11_window_types;
+        self
+    }
+
+    #[inline]
+    fn with_base_size<S: Into<Size>>(mut self, base_size: S) -> Self {
+        self.platform_specific.base_size = Some(base_size.into());
+        self
+    }
+}
+
+/// Additional methods on `MonitorHandle` that are specific to X11.
+pub trait MonitorHandleExtX11 {
+    /// Returns the inner identifier of the monitor.
+    fn native_id(&self) -> u32;
+}
+
+impl MonitorHandleExtX11 for MonitorHandle {
+    #[inline]
+    fn native_id(&self) -> u32 {
+        self.inner.native_identifier()
+    }
+}

third-party/vendor/winit/src/platform_impl/ios/app_state.rs

@@ -0,0 +1,992 @@
+#![deny(unused_results)]
+
+use std::{
+    cell::{RefCell, RefMut},
+    collections::HashSet,
+    mem,
+    os::raw::c_void,
+    ptr,
+    time::Instant,
+};
+
+use core_foundation::base::CFRelease;
+use core_foundation::date::CFAbsoluteTimeGetCurrent;
+use core_foundation::runloop::{
+    kCFRunLoopCommonModes, CFRunLoopAddTimer, CFRunLoopGetMain, CFRunLoopRef, CFRunLoopTimerCreate,
+    CFRunLoopTimerInvalidate, CFRunLoopTimerRef, CFRunLoopTimerSetNextFireDate,
+};
+use objc2::foundation::{CGRect, CGSize, NSInteger, NSProcessInfo};
+use objc2::rc::{Id, Shared};
+use objc2::runtime::Object;
+use objc2::{msg_send, sel};
+use once_cell::sync::Lazy;
+
+use super::uikit::UIView;
+use super::view::WinitUIWindow;
+use crate::{
+    dpi::LogicalSize,
+    event::{Event, StartCause, WindowEvent},
+    event_loop::ControlFlow,
+    platform_impl::platform::{
+        event_loop::{EventHandler, EventProxy, EventWrapper, Never},
+        ffi::NSOperatingSystemVersion,
+    },
+    window::WindowId as RootWindowId,
+};
+
+macro_rules! bug {
+    ($($msg:tt)*) => {
+        panic!("winit iOS bug, file an issue: {}", format!($($msg)*))
+    };
+}
+
+macro_rules! bug_assert {
+    ($test:expr, $($msg:tt)*) => {
+        assert!($test, "winit iOS bug, file an issue: {}", format!($($msg)*))
+    };
+}
+
+enum UserCallbackTransitionResult<'a> {
+    Success {
+        event_handler: Box<dyn EventHandler>,
+        active_control_flow: ControlFlow,
+        processing_redraws: bool,
+    },
+    ReentrancyPrevented {
+        queued_events: &'a mut Vec<EventWrapper>,
+    },
+}
+
+impl Event<'static, Never> {
+    fn is_redraw(&self) -> bool {
+        matches!(self, Event::RedrawRequested(_))
+    }
+}
+
+// this is the state machine for the app lifecycle
+#[derive(Debug)]
+#[must_use = "dropping `AppStateImpl` without inspecting it is probably a bug"]
+enum AppStateImpl {
+    NotLaunched {
+        queued_windows: Vec<Id<WinitUIWindow, Shared>>,
+        queued_events: Vec<EventWrapper>,
+        queued_gpu_redraws: HashSet<Id<WinitUIWindow, Shared>>,
+    },
+    Launching {
+        queued_windows: Vec<Id<WinitUIWindow, Shared>>,
+        queued_events: Vec<EventWrapper>,
+        queued_event_handler: Box<dyn EventHandler>,
+        queued_gpu_redraws: HashSet<Id<WinitUIWindow, Shared>>,
+    },
+    ProcessingEvents {
+        event_handler: Box<dyn EventHandler>,
+        queued_gpu_redraws: HashSet<Id<WinitUIWindow, Shared>>,
+        active_control_flow: ControlFlow,
+    },
+    // special state to deal with reentrancy and prevent mutable aliasing.
+    InUserCallback {
+        queued_events: Vec<EventWrapper>,
+        queued_gpu_redraws: HashSet<Id<WinitUIWindow, Shared>>,
+    },
+    ProcessingRedraws {
+        event_handler: Box<dyn EventHandler>,
+        active_control_flow: ControlFlow,
+    },
+    Waiting {
+        waiting_event_handler: Box<dyn EventHandler>,
+        start: Instant,
+    },
+    PollFinished {
+        waiting_event_handler: Box<dyn EventHandler>,
+    },
+    Terminated,
+}
+
+struct AppState {
+    // This should never be `None`, except for briefly during a state transition.
+    app_state: Option<AppStateImpl>,
+    control_flow: ControlFlow,
+    waker: EventLoopWaker,
+}
+
+impl AppState {
+    // requires main thread
+    unsafe fn get_mut() -> RefMut<'static, AppState> {
+        // basically everything in UIKit requires the main thread, so it's pointless to use the
+        // std::sync APIs.
+        // must be mut because plain `static` requires `Sync`
+        static mut APP_STATE: RefCell<Option<AppState>> = RefCell::new(None);
+
+        if cfg!(debug_assertions) {
+            assert_main_thread!(
+                "bug in winit: `AppState::get_mut()` can only be called on the main thread"
+            );
+        }
+        let mut guard = APP_STATE.borrow_mut();
+        if guard.is_none() {
+            #[inline(never)]
+            #[cold]
+            unsafe fn init_guard(guard: &mut RefMut<'static, Option<AppState>>) {
+                let waker = EventLoopWaker::new(CFRunLoopGetMain());
+                **guard = Some(AppState {
+                    app_state: Some(AppStateImpl::NotLaunched {
+                        queued_windows: Vec::new(),
+                        queued_events: Vec::new(),
+                        queued_gpu_redraws: HashSet::new(),
+                    }),
+                    control_flow: ControlFlow::default(),
+                    waker,
+                });
+            }
+            init_guard(&mut guard)
+        }
+        RefMut::map(guard, |state| state.as_mut().unwrap())
+    }
+
+    fn state(&self) -> &AppStateImpl {
+        match &self.app_state {
+            Some(ref state) => state,
+            None => bug!("`AppState` previously failed a state transition"),
+        }
+    }
+
+    fn state_mut(&mut self) -> &mut AppStateImpl {
+        match &mut self.app_state {
+            Some(ref mut state) => state,
+            None => bug!("`AppState` previously failed a state transition"),
+        }
+    }
+
+    fn take_state(&mut self) -> AppStateImpl {
+        match self.app_state.take() {
+            Some(state) => state,
+            None => bug!("`AppState` previously failed a state transition"),
+        }
+    }
+
+    fn set_state(&mut self, new_state: AppStateImpl) {
+        bug_assert!(
+            self.app_state.is_none(),
+            "attempted to set an `AppState` without calling `take_state` first {:?}",
+            self.app_state
+        );
+        self.app_state = Some(new_state)
+    }
+
+    fn replace_state(&mut self, new_state: AppStateImpl) -> AppStateImpl {
+        match &mut self.app_state {
+            Some(ref mut state) => mem::replace(state, new_state),
+            None => bug!("`AppState` previously failed a state transition"),
+        }
+    }
+
+    fn has_launched(&self) -> bool {
+        !matches!(
+            self.state(),
+            AppStateImpl::NotLaunched { .. } | AppStateImpl::Launching { .. }
+        )
+    }
+
+    fn will_launch_transition(&mut self, queued_event_handler: Box<dyn EventHandler>) {
+        let (queued_windows, queued_events, queued_gpu_redraws) = match self.take_state() {
+            AppStateImpl::NotLaunched {
+                queued_windows,
+                queued_events,
+                queued_gpu_redraws,
+            } => (queued_windows, queued_events, queued_gpu_redraws),
+            s => bug!("unexpected state {:?}", s),
+        };
+        self.set_state(AppStateImpl::Launching {
+            queued_windows,
+            queued_events,
+            queued_event_handler,
+            queued_gpu_redraws,
+        });
+    }
+
+    fn did_finish_launching_transition(
+        &mut self,
+    ) -> (Vec<Id<WinitUIWindow, Shared>>, Vec<EventWrapper>) {
+        let (windows, events, event_handler, queued_gpu_redraws) = match self.take_state() {
+            AppStateImpl::Launching {
+                queued_windows,
+                queued_events,
+                queued_event_handler,
+                queued_gpu_redraws,
+            } => (
+                queued_windows,
+                queued_events,
+                queued_event_handler,
+                queued_gpu_redraws,
+            ),
+            s => bug!("unexpected state {:?}", s),
+        };
+        self.set_state(AppStateImpl::ProcessingEvents {
+            event_handler,
+            active_control_flow: ControlFlow::Poll,
+            queued_gpu_redraws,
+        });
+        (windows, events)
+    }
+
+    fn wakeup_transition(&mut self) -> Option<EventWrapper> {
+        // before `AppState::did_finish_launching` is called, pretend there is no running
+        // event loop.
+        if !self.has_launched() {
+            return None;
+        }
+
+        let (event_handler, event) = match (self.control_flow, self.take_state()) {
+            (
+                ControlFlow::Poll,
+                AppStateImpl::PollFinished {
+                    waiting_event_handler,
+                },
+            ) => (
+                waiting_event_handler,
+                EventWrapper::StaticEvent(Event::NewEvents(StartCause::Poll)),
+            ),
+            (
+                ControlFlow::Wait,
+                AppStateImpl::Waiting {
+                    waiting_event_handler,
+                    start,
+                },
+            ) => (
+                waiting_event_handler,
+                EventWrapper::StaticEvent(Event::NewEvents(StartCause::WaitCancelled {
+                    start,
+                    requested_resume: None,
+                })),
+            ),
+            (
+                ControlFlow::WaitUntil(requested_resume),
+                AppStateImpl::Waiting {
+                    waiting_event_handler,
+                    start,
+                },
+            ) => {
+                let event = if Instant::now() >= requested_resume {
+                    EventWrapper::StaticEvent(Event::NewEvents(StartCause::ResumeTimeReached {
+                        start,
+                        requested_resume,
+                    }))
+                } else {
+                    EventWrapper::StaticEvent(Event::NewEvents(StartCause::WaitCancelled {
+                        start,
+                        requested_resume: Some(requested_resume),
+                    }))
+                };
+                (waiting_event_handler, event)
+            }
+            (ControlFlow::ExitWithCode(_), _) => bug!("unexpected `ControlFlow` `Exit`"),
+            s => bug!("`EventHandler` unexpectedly woke up {:?}", s),
+        };
+
+        self.set_state(AppStateImpl::ProcessingEvents {
+            event_handler,
+            queued_gpu_redraws: Default::default(),
+            active_control_flow: self.control_flow,
+        });
+        Some(event)
+    }
+
+    fn try_user_callback_transition(&mut self) -> UserCallbackTransitionResult<'_> {
+        // If we're not able to process an event due to recursion or `Init` not having been sent out
+        // yet, then queue the events up.
+        match self.state_mut() {
+            &mut AppStateImpl::Launching {
+                ref mut queued_events,
+                ..
+            }
+            | &mut AppStateImpl::NotLaunched {
+                ref mut queued_events,
+                ..
+            }
+            | &mut AppStateImpl::InUserCallback {
+                ref mut queued_events,
+                ..
+            } => {
+                // A lifetime cast: early returns are not currently handled well with NLL, but
+                // polonius handles them well. This transmute is a safe workaround.
+                return unsafe {
+                    mem::transmute::<
+                        UserCallbackTransitionResult<'_>,
+                        UserCallbackTransitionResult<'_>,
+                    >(UserCallbackTransitionResult::ReentrancyPrevented {
+                        queued_events,
+                    })
+                };
+            }
+
+            &mut AppStateImpl::ProcessingEvents { .. }
+            | &mut AppStateImpl::ProcessingRedraws { .. } => {}
+
+            s @ &mut AppStateImpl::PollFinished { .. }
+            | s @ &mut AppStateImpl::Waiting { .. }
+            | s @ &mut AppStateImpl::Terminated => {
+                bug!("unexpected attempted to process an event {:?}", s)
+            }
+        }
+
+        let (event_handler, queued_gpu_redraws, active_control_flow, processing_redraws) =
+            match self.take_state() {
+                AppStateImpl::Launching { .. }
+                | AppStateImpl::NotLaunched { .. }
+                | AppStateImpl::InUserCallback { .. } => unreachable!(),
+                AppStateImpl::ProcessingEvents {
+                    event_handler,
+                    queued_gpu_redraws,
+                    active_control_flow,
+                } => (
+                    event_handler,
+                    queued_gpu_redraws,
+                    active_control_flow,
+                    false,
+                ),
+                AppStateImpl::ProcessingRedraws {
+                    event_handler,
+                    active_control_flow,
+                } => (event_handler, Default::default(), active_control_flow, true),
+                AppStateImpl::PollFinished { .. }
+                | AppStateImpl::Waiting { .. }
+                | AppStateImpl::Terminated => unreachable!(),
+            };
+        self.set_state(AppStateImpl::InUserCallback {
+            queued_events: Vec::new(),
+            queued_gpu_redraws,
+        });
+        UserCallbackTransitionResult::Success {
+            event_handler,
+            active_control_flow,
+            processing_redraws,
+        }
+    }
+
+    fn main_events_cleared_transition(&mut self) -> HashSet<Id<WinitUIWindow, Shared>> {
+        let (event_handler, queued_gpu_redraws, active_control_flow) = match self.take_state() {
+            AppStateImpl::ProcessingEvents {
+                event_handler,
+                queued_gpu_redraws,
+                active_control_flow,
+            } => (event_handler, queued_gpu_redraws, active_control_flow),
+            s => bug!("unexpected state {:?}", s),
+        };
+        self.set_state(AppStateImpl::ProcessingRedraws {
+            event_handler,
+            active_control_flow,
+        });
+        queued_gpu_redraws
+    }
+
+    fn events_cleared_transition(&mut self) {
+        if !self.has_launched() {
+            return;
+        }
+        let (waiting_event_handler, old) = match self.take_state() {
+            AppStateImpl::ProcessingRedraws {
+                event_handler,
+                active_control_flow,
+            } => (event_handler, active_control_flow),
+            s => bug!("unexpected state {:?}", s),
+        };
+
+        let new = self.control_flow;
+        match (old, new) {
+            (ControlFlow::Poll, ControlFlow::Poll) => self.set_state(AppStateImpl::PollFinished {
+                waiting_event_handler,
+            }),
+            (ControlFlow::Wait, ControlFlow::Wait) => {
+                let start = Instant::now();
+                self.set_state(AppStateImpl::Waiting {
+                    waiting_event_handler,
+                    start,
+                });
+            }
+            (ControlFlow::WaitUntil(old_instant), ControlFlow::WaitUntil(new_instant))
+                if old_instant == new_instant =>
+            {
+                let start = Instant::now();
+                self.set_state(AppStateImpl::Waiting {
+                    waiting_event_handler,
+                    start,
+                });
+            }
+            (_, ControlFlow::Wait) => {
+                let start = Instant::now();
+                self.set_state(AppStateImpl::Waiting {
+                    waiting_event_handler,
+                    start,
+                });
+                self.waker.stop()
+            }
+            (_, ControlFlow::WaitUntil(new_instant)) => {
+                let start = Instant::now();
+                self.set_state(AppStateImpl::Waiting {
+                    waiting_event_handler,
+                    start,
+                });
+                self.waker.start_at(new_instant)
+            }
+            (_, ControlFlow::Poll) => {
+                self.set_state(AppStateImpl::PollFinished {
+                    waiting_event_handler,
+                });
+                self.waker.start()
+            }
+            (_, ControlFlow::ExitWithCode(_)) => {
+                // https://developer.apple.com/library/archive/qa/qa1561/_index.html
+                // it is not possible to quit an iOS app gracefully and programatically
+                warn!("`ControlFlow::Exit` ignored on iOS");
+                self.control_flow = old
+            }
+        }
+    }
+
+    fn terminated_transition(&mut self) -> Box<dyn EventHandler> {
+        match self.replace_state(AppStateImpl::Terminated) {
+            AppStateImpl::ProcessingEvents { event_handler, .. } => event_handler,
+            s => bug!(
+                "`LoopDestroyed` happened while not processing events {:?}",
+                s
+            ),
+        }
+    }
+}
+
+// requires main thread and window is a UIWindow
+// retains window
+pub(crate) unsafe fn set_key_window(window: &Id<WinitUIWindow, Shared>) {
+    let mut this = AppState::get_mut();
+    match this.state_mut() {
+        &mut AppStateImpl::NotLaunched {
+            ref mut queued_windows,
+            ..
+        } => return queued_windows.push(window.clone()),
+        &mut AppStateImpl::ProcessingEvents { .. }
+        | &mut AppStateImpl::InUserCallback { .. }
+        | &mut AppStateImpl::ProcessingRedraws { .. } => {}
+        s @ &mut AppStateImpl::Launching { .. }
+        | s @ &mut AppStateImpl::Waiting { .. }
+        | s @ &mut AppStateImpl::PollFinished { .. } => bug!("unexpected state {:?}", s),
+        &mut AppStateImpl::Terminated => {
+            panic!("Attempt to create a `Window` after the app has terminated")
+        }
+    }
+    drop(this);
+    window.makeKeyAndVisible();
+}
+
+// requires main thread and window is a UIWindow
+// retains window
+pub(crate) unsafe fn queue_gl_or_metal_redraw(window: Id<WinitUIWindow, Shared>) {
+    let mut this = AppState::get_mut();
+    match this.state_mut() {
+        &mut AppStateImpl::NotLaunched {
+            ref mut queued_gpu_redraws,
+            ..
+        }
+        | &mut AppStateImpl::Launching {
+            ref mut queued_gpu_redraws,
+            ..
+        }
+        | &mut AppStateImpl::ProcessingEvents {
+            ref mut queued_gpu_redraws,
+            ..
+        }
+        | &mut AppStateImpl::InUserCallback {
+            ref mut queued_gpu_redraws,
+            ..
+        } => {
+            let _ = queued_gpu_redraws.insert(window);
+        }
+        s @ &mut AppStateImpl::ProcessingRedraws { .. }
+        | s @ &mut AppStateImpl::Waiting { .. }
+        | s @ &mut AppStateImpl::PollFinished { .. } => bug!("unexpected state {:?}", s),
+        &mut AppStateImpl::Terminated => {
+            panic!("Attempt to create a `Window` after the app has terminated")
+        }
+    }
+}
+
+// requires main thread
+pub unsafe fn will_launch(queued_event_handler: Box<dyn EventHandler>) {
+    AppState::get_mut().will_launch_transition(queued_event_handler)
+}
+
+// requires main thread
+pub unsafe fn did_finish_launching() {
+    let mut this = AppState::get_mut();
+    let windows = match this.state_mut() {
+        AppStateImpl::Launching { queued_windows, .. } => mem::take(queued_windows),
+        s => bug!("unexpected state {:?}", s),
+    };
+
+    // start waking up the event loop now!
+    bug_assert!(
+        this.control_flow == ControlFlow::Poll,
+        "unexpectedly not setup to `Poll` on launch!"
+    );
+    this.waker.start();
+
+    // have to drop RefMut because the window setup code below can trigger new events
+    drop(this);
+
+    for window in windows {
+        // Do a little screen dance here to account for windows being created before
+        // `UIApplicationMain` is called. This fixes visual issues such as being
+        // offcenter and sized incorrectly. Additionally, to fix orientation issues, we
+        // gotta reset the `rootViewController`.
+        //
+        // relevant iOS log:
+        // ```
+        // [ApplicationLifecycle] Windows were created before application initialzation
+        // completed. This may result in incorrect visual appearance.
+        // ```
+        let screen = window.screen();
+        let _: () = msg_send![&window, setScreen: ptr::null::<Object>()];
+        window.setScreen(&screen);
+
+        let controller = window.rootViewController();
+        window.setRootViewController(None);
+        window.setRootViewController(controller.as_deref());
+
+        window.makeKeyAndVisible();
+    }
+
+    let (windows, events) = AppState::get_mut().did_finish_launching_transition();
+
+    let events = std::iter::once(EventWrapper::StaticEvent(Event::NewEvents(
+        StartCause::Init,
+    )))
+    .chain(events);
+    handle_nonuser_events(events);
+
+    // the above window dance hack, could possibly trigger new windows to be created.
+    // we can just set those windows up normally, as they were created after didFinishLaunching
+    for window in windows {
+        window.makeKeyAndVisible();
+    }
+}
+
+// requires main thread
+// AppState::did_finish_launching handles the special transition `Init`
+pub unsafe fn handle_wakeup_transition() {
+    let mut this = AppState::get_mut();
+    let wakeup_event = match this.wakeup_transition() {
+        None => return,
+        Some(wakeup_event) => wakeup_event,
+    };
+    drop(this);
+
+    handle_nonuser_event(wakeup_event)
+}
+
+// requires main thread
+pub(crate) unsafe fn handle_nonuser_event(event: EventWrapper) {
+    handle_nonuser_events(std::iter::once(event))
+}
+
+// requires main thread
+pub(crate) unsafe fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(events: I) {
+    let mut this = AppState::get_mut();
+    let (mut event_handler, active_control_flow, processing_redraws) =
+        match this.try_user_callback_transition() {
+            UserCallbackTransitionResult::ReentrancyPrevented { queued_events } => {
+                queued_events.extend(events);
+                return;
+            }
+            UserCallbackTransitionResult::Success {
+                event_handler,
+                active_control_flow,
+                processing_redraws,
+            } => (event_handler, active_control_flow, processing_redraws),
+        };
+    let mut control_flow = this.control_flow;
+    drop(this);
+
+    for wrapper in events {
+        match wrapper {
+            EventWrapper::StaticEvent(event) => {
+                if !processing_redraws && event.is_redraw() {
+                    log::info!("processing `RedrawRequested` during the main event loop");
+                } else if processing_redraws && !event.is_redraw() {
+                    log::warn!(
+                        "processing non `RedrawRequested` event after the main event loop: {:#?}",
+                        event
+                    );
+                }
+                event_handler.handle_nonuser_event(event, &mut control_flow)
+            }
+            EventWrapper::EventProxy(proxy) => {
+                handle_event_proxy(&mut event_handler, control_flow, proxy)
+            }
+        }
+    }
+
+    loop {
+        let mut this = AppState::get_mut();
+        let queued_events = match this.state_mut() {
+            &mut AppStateImpl::InUserCallback {
+                ref mut queued_events,
+                queued_gpu_redraws: _,
+            } => mem::take(queued_events),
+            s => bug!("unexpected state {:?}", s),
+        };
+        if queued_events.is_empty() {
+            let queued_gpu_redraws = match this.take_state() {
+                AppStateImpl::InUserCallback {
+                    queued_events: _,
+                    queued_gpu_redraws,
+                } => queued_gpu_redraws,
+                _ => unreachable!(),
+            };
+            this.app_state = Some(if processing_redraws {
+                bug_assert!(
+                    queued_gpu_redraws.is_empty(),
+                    "redraw queued while processing redraws"
+                );
+                AppStateImpl::ProcessingRedraws {
+                    event_handler,
+                    active_control_flow,
+                }
+            } else {
+                AppStateImpl::ProcessingEvents {
+                    event_handler,
+                    queued_gpu_redraws,
+                    active_control_flow,
+                }
+            });
+            this.control_flow = control_flow;
+            break;
+        }
+        drop(this);
+
+        for wrapper in queued_events {
+            match wrapper {
+                EventWrapper::StaticEvent(event) => {
+                    if !processing_redraws && event.is_redraw() {
+                        log::info!("processing `RedrawRequested` during the main event loop");
+                    } else if processing_redraws && !event.is_redraw() {
+                        log::warn!(
+                            "processing non-`RedrawRequested` event after the main event loop: {:#?}",
+                            event
+                        );
+                    }
+                    event_handler.handle_nonuser_event(event, &mut control_flow)
+                }
+                EventWrapper::EventProxy(proxy) => {
+                    handle_event_proxy(&mut event_handler, control_flow, proxy)
+                }
+            }
+        }
+    }
+}
+
+// requires main thread
+unsafe fn handle_user_events() {
+    let mut this = AppState::get_mut();
+    let mut control_flow = this.control_flow;
+    let (mut event_handler, active_control_flow, processing_redraws) =
+        match this.try_user_callback_transition() {
+            UserCallbackTransitionResult::ReentrancyPrevented { .. } => {
+                bug!("unexpected attempted to process an event")
+            }
+            UserCallbackTransitionResult::Success {
+                event_handler,
+                active_control_flow,
+                processing_redraws,
+            } => (event_handler, active_control_flow, processing_redraws),
+        };
+    if processing_redraws {
+        bug!("user events attempted to be sent out while `ProcessingRedraws`");
+    }
+    drop(this);
+
+    event_handler.handle_user_events(&mut control_flow);
+
+    loop {
+        let mut this = AppState::get_mut();
+        let queued_events = match this.state_mut() {
+            &mut AppStateImpl::InUserCallback {
+                ref mut queued_events,
+                queued_gpu_redraws: _,
+            } => mem::take(queued_events),
+            s => bug!("unexpected state {:?}", s),
+        };
+        if queued_events.is_empty() {
+            let queued_gpu_redraws = match this.take_state() {
+                AppStateImpl::InUserCallback {
+                    queued_events: _,
+                    queued_gpu_redraws,
+                } => queued_gpu_redraws,
+                _ => unreachable!(),
+            };
+            this.app_state = Some(AppStateImpl::ProcessingEvents {
+                event_handler,
+                queued_gpu_redraws,
+                active_control_flow,
+            });
+            this.control_flow = control_flow;
+            break;
+        }
+        drop(this);
+
+        for wrapper in queued_events {
+            match wrapper {
+                EventWrapper::StaticEvent(event) => {
+                    event_handler.handle_nonuser_event(event, &mut control_flow)
+                }
+                EventWrapper::EventProxy(proxy) => {
+                    handle_event_proxy(&mut event_handler, control_flow, proxy)
+                }
+            }
+        }
+        event_handler.handle_user_events(&mut control_flow);
+    }
+}
+
+// requires main thread
+pub unsafe fn handle_main_events_cleared() {
+    let mut this = AppState::get_mut();
+    if !this.has_launched() {
+        return;
+    }
+    match this.state_mut() {
+        AppStateImpl::ProcessingEvents { .. } => {}
+        _ => bug!("`ProcessingRedraws` happened unexpectedly"),
+    };
+    drop(this);
+
+    // User events are always sent out at the end of the "MainEventLoop"
+    handle_user_events();
+    handle_nonuser_event(EventWrapper::StaticEvent(Event::MainEventsCleared));
+
+    let mut this = AppState::get_mut();
+    let mut redraw_events: Vec<EventWrapper> = this
+        .main_events_cleared_transition()
+        .into_iter()
+        .map(|window| EventWrapper::StaticEvent(Event::RedrawRequested(RootWindowId(window.id()))))
+        .collect();
+
+    redraw_events.push(EventWrapper::StaticEvent(Event::RedrawEventsCleared));
+    drop(this);
+
+    handle_nonuser_events(redraw_events);
+}
+
+// requires main thread
+pub unsafe fn handle_events_cleared() {
+    AppState::get_mut().events_cleared_transition();
+}
+
+// requires main thread
+pub unsafe fn terminated() {
+    let mut this = AppState::get_mut();
+    let mut event_handler = this.terminated_transition();
+    let mut control_flow = this.control_flow;
+    drop(this);
+
+    event_handler.handle_nonuser_event(Event::LoopDestroyed, &mut control_flow)
+}
+
+fn handle_event_proxy(
+    event_handler: &mut Box<dyn EventHandler>,
+    control_flow: ControlFlow,
+    proxy: EventProxy,
+) {
+    match proxy {
+        EventProxy::DpiChangedProxy {
+            suggested_size,
+            scale_factor,
+            window,
+        } => handle_hidpi_proxy(
+            event_handler,
+            control_flow,
+            suggested_size,
+            scale_factor,
+            window,
+        ),
+    }
+}
+
+fn handle_hidpi_proxy(
+    event_handler: &mut Box<dyn EventHandler>,
+    mut control_flow: ControlFlow,
+    suggested_size: LogicalSize<f64>,
+    scale_factor: f64,
+    window: Id<WinitUIWindow, Shared>,
+) {
+    let mut size = suggested_size.to_physical(scale_factor);
+    let new_inner_size = &mut size;
+    let event = Event::WindowEvent {
+        window_id: RootWindowId(window.id()),
+        event: WindowEvent::ScaleFactorChanged {
+            scale_factor,
+            new_inner_size,
+        },
+    };
+    event_handler.handle_nonuser_event(event, &mut control_flow);
+    let (view, screen_frame) = get_view_and_screen_frame(&window);
+    let physical_size = *new_inner_size;
+    let logical_size = physical_size.to_logical(scale_factor);
+    let size = CGSize::new(logical_size.width, logical_size.height);
+    let new_frame: CGRect = CGRect::new(screen_frame.origin, size);
+    view.setFrame(new_frame);
+}
+
+fn get_view_and_screen_frame(window: &WinitUIWindow) -> (Id<UIView, Shared>, CGRect) {
+    let view_controller = window.rootViewController().unwrap();
+    let view = view_controller.view().unwrap();
+    let bounds = window.bounds();
+    let screen = window.screen();
+    let screen_space = screen.coordinateSpace();
+    let screen_frame = window.convertRect_toCoordinateSpace(bounds, &screen_space);
+    (view, screen_frame)
+}
+
+struct EventLoopWaker {
+    timer: CFRunLoopTimerRef,
+}
+
+impl Drop for EventLoopWaker {
+    fn drop(&mut self) {
+        unsafe {
+            CFRunLoopTimerInvalidate(self.timer);
+            CFRelease(self.timer as _);
+        }
+    }
+}
+
+impl EventLoopWaker {
+    fn new(rl: CFRunLoopRef) -> EventLoopWaker {
+        extern "C" fn wakeup_main_loop(_timer: CFRunLoopTimerRef, _info: *mut c_void) {}
+        unsafe {
+            // Create a timer with a 0.1µs interval (1ns does not work) to mimic polling.
+            // It is initially setup with a first fire time really far into the
+            // future, but that gets changed to fire immediately in did_finish_launching
+            let timer = CFRunLoopTimerCreate(
+                ptr::null_mut(),
+                std::f64::MAX,
+                0.000_000_1,
+                0,
+                0,
+                wakeup_main_loop,
+                ptr::null_mut(),
+            );
+            CFRunLoopAddTimer(rl, timer, kCFRunLoopCommonModes);
+
+            EventLoopWaker { timer }
+        }
+    }
+
+    fn stop(&mut self) {
+        unsafe { CFRunLoopTimerSetNextFireDate(self.timer, std::f64::MAX) }
+    }
+
+    fn start(&mut self) {
+        unsafe { CFRunLoopTimerSetNextFireDate(self.timer, std::f64::MIN) }
+    }
+
+    fn start_at(&mut self, instant: Instant) {
+        let now = Instant::now();
+        if now >= instant {
+            self.start();
+        } else {
+            unsafe {
+                let current = CFAbsoluteTimeGetCurrent();
+                let duration = instant - now;
+                let fsecs =
+                    duration.subsec_nanos() as f64 / 1_000_000_000.0 + duration.as_secs() as f64;
+                CFRunLoopTimerSetNextFireDate(self.timer, current + fsecs)
+            }
+        }
+    }
+}
+
+macro_rules! os_capabilities {
+    (
+        $(
+            $(#[$attr:meta])*
+            $error_name:ident: $objc_call:literal,
+            $name:ident: $major:literal-$minor:literal
+        ),*
+        $(,)*
+    ) => {
+        #[derive(Clone, Debug)]
+        pub struct OSCapabilities {
+            $(
+                pub $name: bool,
+            )*
+
+            os_version: NSOperatingSystemVersion,
+        }
+
+        impl From<NSOperatingSystemVersion> for OSCapabilities {
+            fn from(os_version: NSOperatingSystemVersion) -> OSCapabilities {
+                $(let $name = os_version.meets_requirements($major, $minor);)*
+                OSCapabilities { $($name,)* os_version, }
+            }
+        }
+
+        impl OSCapabilities {$(
+            $(#[$attr])*
+            pub fn $error_name(&self, extra_msg: &str) {
+                log::warn!(
+                    concat!("`", $objc_call, "` requires iOS {}.{}+. This device is running iOS {}.{}.{}. {}"),
+                    $major, $minor, self.os_version.major, self.os_version.minor, self.os_version.patch,
+                    extra_msg
+                )
+            }
+        )*}
+    };
+}
+
+os_capabilities! {
+    /// <https://developer.apple.com/documentation/uikit/uiview/2891103-safeareainsets?language=objc>
+    #[allow(unused)] // error message unused
+    safe_area_err_msg: "-[UIView safeAreaInsets]",
+    safe_area: 11-0,
+    /// <https://developer.apple.com/documentation/uikit/uiviewcontroller/2887509-setneedsupdateofhomeindicatoraut?language=objc>
+    home_indicator_hidden_err_msg: "-[UIViewController setNeedsUpdateOfHomeIndicatorAutoHidden]",
+    home_indicator_hidden: 11-0,
+    /// <https://developer.apple.com/documentation/uikit/uiviewcontroller/2887507-setneedsupdateofscreenedgesdefer?language=objc>
+    defer_system_gestures_err_msg: "-[UIViewController setNeedsUpdateOfScreenEdgesDeferringSystem]",
+    defer_system_gestures: 11-0,
+    /// <https://developer.apple.com/documentation/uikit/uiscreen/2806814-maximumframespersecond?language=objc>
+    maximum_frames_per_second_err_msg: "-[UIScreen maximumFramesPerSecond]",
+    maximum_frames_per_second: 10-3,
+    /// <https://developer.apple.com/documentation/uikit/uitouch/1618110-force?language=objc>
+    #[allow(unused)] // error message unused
+    force_touch_err_msg: "-[UITouch force]",
+    force_touch: 9-0,
+}
+
+impl NSOperatingSystemVersion {
+    fn meets_requirements(&self, required_major: NSInteger, required_minor: NSInteger) -> bool {
+        (self.major, self.minor) >= (required_major, required_minor)
+    }
+}
+
+pub fn os_capabilities() -> OSCapabilities {
+    static OS_CAPABILITIES: Lazy<OSCapabilities> = Lazy::new(|| {
+        let version: NSOperatingSystemVersion = unsafe {
+            let process_info = NSProcessInfo::process_info();
+            let atleast_ios_8: bool = msg_send![
+                &process_info,
+                respondsToSelector: sel!(operatingSystemVersion)
+            ];
+            // winit requires atleast iOS 8 because no one has put the time into supporting earlier os versions.
+            // Older iOS versions are increasingly difficult to test. For example, Xcode 11 does not support
+            // debugging on devices with an iOS version of less than 8. Another example, in order to use an iOS
+            // simulator older than iOS 8, you must download an older version of Xcode (<9), and at least Xcode 7
+            // has been tested to not even run on macOS 10.15 - Xcode 8 might?
+            //
+            // The minimum required iOS version is likely to grow in the future.
+            assert!(atleast_ios_8, "`winit` requires iOS version 8 or greater");
+            msg_send![&process_info, operatingSystemVersion]
+        };
+        version.into()
+    });
+    OS_CAPABILITIES.clone()
+}

third-party/vendor/winit/src/platform_impl/ios/event_loop.rs

@@ -0,0 +1,353 @@
+use std::{
+    collections::VecDeque,
+    ffi::c_void,
+    fmt::{self, Debug},
+    marker::PhantomData,
+    ptr,
+    sync::mpsc::{self, Receiver, Sender},
+};
+
+use core_foundation::base::{CFIndex, CFRelease};
+use core_foundation::runloop::{
+    kCFRunLoopAfterWaiting, kCFRunLoopBeforeWaiting, kCFRunLoopCommonModes, kCFRunLoopDefaultMode,
+    kCFRunLoopExit, CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopAddSource, CFRunLoopGetMain,
+    CFRunLoopObserverCreate, CFRunLoopObserverRef, CFRunLoopSourceContext, CFRunLoopSourceCreate,
+    CFRunLoopSourceInvalidate, CFRunLoopSourceRef, CFRunLoopSourceSignal, CFRunLoopWakeUp,
+};
+use objc2::foundation::{MainThreadMarker, NSString};
+use objc2::rc::{Id, Shared};
+use objc2::ClassType;
+use raw_window_handle::{RawDisplayHandle, UiKitDisplayHandle};
+
+use super::uikit::{UIApplication, UIApplicationMain, UIDevice, UIScreen};
+use super::view::WinitUIWindow;
+use super::{app_state, monitor, view, MonitorHandle};
+use crate::{
+    dpi::LogicalSize,
+    event::Event,
+    event_loop::{
+        ControlFlow, EventLoopClosed, EventLoopWindowTarget as RootEventLoopWindowTarget,
+    },
+    platform::ios::Idiom,
+};
+
+#[derive(Debug)]
+pub(crate) enum EventWrapper {
+    StaticEvent(Event<'static, Never>),
+    EventProxy(EventProxy),
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) enum EventProxy {
+    DpiChangedProxy {
+        window: Id<WinitUIWindow, Shared>,
+        suggested_size: LogicalSize<f64>,
+        scale_factor: f64,
+    },
+}
+
+pub struct EventLoopWindowTarget<T: 'static> {
+    receiver: Receiver<T>,
+    sender_to_clone: Sender<T>,
+}
+
+impl<T: 'static> EventLoopWindowTarget<T> {
+    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
+        monitor::uiscreens(MainThreadMarker::new().unwrap())
+    }
+
+    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
+        Some(MonitorHandle::new(UIScreen::main(
+            MainThreadMarker::new().unwrap(),
+        )))
+    }
+
+    pub fn raw_display_handle(&self) -> RawDisplayHandle {
+        RawDisplayHandle::UiKit(UiKitDisplayHandle::empty())
+    }
+}
+
+pub struct EventLoop<T: 'static> {
+    window_target: RootEventLoopWindowTarget<T>,
+}
+
+#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub(crate) struct PlatformSpecificEventLoopAttributes {}
+
+impl<T: 'static> EventLoop<T> {
+    pub(crate) fn new(_: &PlatformSpecificEventLoopAttributes) -> EventLoop<T> {
+        assert_main_thread!("`EventLoop` can only be created on the main thread on iOS");
+
+        static mut SINGLETON_INIT: bool = false;
+        unsafe {
+            assert!(
+                !SINGLETON_INIT,
+                "Only one `EventLoop` is supported on iOS. \
+                 `EventLoopProxy` might be helpful"
+            );
+            SINGLETON_INIT = true;
+        }
+
+        let (sender_to_clone, receiver) = mpsc::channel();
+
+        // this line sets up the main run loop before `UIApplicationMain`
+        setup_control_flow_observers();
+
+        EventLoop {
+            window_target: RootEventLoopWindowTarget {
+                p: EventLoopWindowTarget {
+                    receiver,
+                    sender_to_clone,
+                },
+                _marker: PhantomData,
+            },
+        }
+    }
+
+    pub fn run<F>(self, event_handler: F) -> !
+    where
+        F: 'static + FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
+    {
+        unsafe {
+            let application = UIApplication::shared(MainThreadMarker::new().unwrap());
+            assert!(
+                application.is_none(),
+                "\
+                `EventLoop` cannot be `run` after a call to `UIApplicationMain` on iOS\n\
+                 Note: `EventLoop::run` calls `UIApplicationMain` on iOS",
+            );
+            app_state::will_launch(Box::new(EventLoopHandler {
+                f: event_handler,
+                event_loop: self.window_target,
+            }));
+
+            // Ensure application delegate is initialized
+            view::WinitApplicationDelegate::class();
+
+            UIApplicationMain(
+                0,
+                ptr::null(),
+                None,
+                Some(&NSString::from_str("WinitApplicationDelegate")),
+            );
+            unreachable!()
+        }
+    }
+
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+        EventLoopProxy::new(self.window_target.p.sender_to_clone.clone())
+    }
+
+    pub fn window_target(&self) -> &RootEventLoopWindowTarget<T> {
+        &self.window_target
+    }
+}
+
+// EventLoopExtIOS
+impl<T: 'static> EventLoop<T> {
+    pub fn idiom(&self) -> Idiom {
+        UIDevice::current(MainThreadMarker::new().unwrap())
+            .userInterfaceIdiom()
+            .into()
+    }
+}
+
+pub struct EventLoopProxy<T> {
+    sender: Sender<T>,
+    source: CFRunLoopSourceRef,
+}
+
+unsafe impl<T: Send> Send for EventLoopProxy<T> {}
+
+impl<T> Clone for EventLoopProxy<T> {
+    fn clone(&self) -> EventLoopProxy<T> {
+        EventLoopProxy::new(self.sender.clone())
+    }
+}
+
+impl<T> Drop for EventLoopProxy<T> {
+    fn drop(&mut self) {
+        unsafe {
+            CFRunLoopSourceInvalidate(self.source);
+            CFRelease(self.source as _);
+        }
+    }
+}
+
+impl<T> EventLoopProxy<T> {
+    fn new(sender: Sender<T>) -> EventLoopProxy<T> {
+        unsafe {
+            // just wake up the eventloop
+            extern "C" fn event_loop_proxy_handler(_: *const c_void) {}
+
+            // adding a Source to the main CFRunLoop lets us wake it up and
+            // process user events through the normal OS EventLoop mechanisms.
+            let rl = CFRunLoopGetMain();
+            let mut context = CFRunLoopSourceContext {
+                version: 0,
+                info: ptr::null_mut(),
+                retain: None,
+                release: None,
+                copyDescription: None,
+                equal: None,
+                hash: None,
+                schedule: None,
+                cancel: None,
+                perform: event_loop_proxy_handler,
+            };
+            let source =
+                CFRunLoopSourceCreate(ptr::null_mut(), CFIndex::max_value() - 1, &mut context);
+            CFRunLoopAddSource(rl, source, kCFRunLoopCommonModes);
+            CFRunLoopWakeUp(rl);
+
+            EventLoopProxy { sender, source }
+        }
+    }
+
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+        self.sender
+            .send(event)
+            .map_err(|::std::sync::mpsc::SendError(x)| EventLoopClosed(x))?;
+        unsafe {
+            // let the main thread know there's a new event
+            CFRunLoopSourceSignal(self.source);
+            let rl = CFRunLoopGetMain();
+            CFRunLoopWakeUp(rl);
+        }
+        Ok(())
+    }
+}
+
+fn setup_control_flow_observers() {
+    unsafe {
+        // begin is queued with the highest priority to ensure it is processed before other observers
+        extern "C" fn control_flow_begin_handler(
+            _: CFRunLoopObserverRef,
+            activity: CFRunLoopActivity,
+            _: *mut c_void,
+        ) {
+            unsafe {
+                #[allow(non_upper_case_globals)]
+                match activity {
+                    kCFRunLoopAfterWaiting => app_state::handle_wakeup_transition(),
+                    _ => unreachable!(),
+                }
+            }
+        }
+
+        // Core Animation registers its `CFRunLoopObserver` that performs drawing operations in
+        // `CA::Transaction::ensure_implicit` with a priority of `0x1e8480`. We set the main_end
+        // priority to be 0, in order to send MainEventsCleared before RedrawRequested. This value was
+        // chosen conservatively to guard against apple using different priorities for their redraw
+        // observers in different OS's or on different devices. If it so happens that it's too
+        // conservative, the main symptom would be non-redraw events coming in after `MainEventsCleared`.
+        //
+        // The value of `0x1e8480` was determined by inspecting stack traces and the associated
+        // registers for every `CFRunLoopAddObserver` call on an iPad Air 2 running iOS 11.4.
+        //
+        // Also tested to be `0x1e8480` on iPhone 8, iOS 13 beta 4.
+        extern "C" fn control_flow_main_end_handler(
+            _: CFRunLoopObserverRef,
+            activity: CFRunLoopActivity,
+            _: *mut c_void,
+        ) {
+            unsafe {
+                #[allow(non_upper_case_globals)]
+                match activity {
+                    kCFRunLoopBeforeWaiting => app_state::handle_main_events_cleared(),
+                    kCFRunLoopExit => unimplemented!(), // not expected to ever happen
+                    _ => unreachable!(),
+                }
+            }
+        }
+
+        // end is queued with the lowest priority to ensure it is processed after other observers
+        extern "C" fn control_flow_end_handler(
+            _: CFRunLoopObserverRef,
+            activity: CFRunLoopActivity,
+            _: *mut c_void,
+        ) {
+            unsafe {
+                #[allow(non_upper_case_globals)]
+                match activity {
+                    kCFRunLoopBeforeWaiting => app_state::handle_events_cleared(),
+                    kCFRunLoopExit => unimplemented!(), // not expected to ever happen
+                    _ => unreachable!(),
+                }
+            }
+        }
+
+        let main_loop = CFRunLoopGetMain();
+
+        let begin_observer = CFRunLoopObserverCreate(
+            ptr::null_mut(),
+            kCFRunLoopAfterWaiting,
+            1, // repeat = true
+            CFIndex::min_value(),
+            control_flow_begin_handler,
+            ptr::null_mut(),
+        );
+        CFRunLoopAddObserver(main_loop, begin_observer, kCFRunLoopDefaultMode);
+
+        let main_end_observer = CFRunLoopObserverCreate(
+            ptr::null_mut(),
+            kCFRunLoopExit | kCFRunLoopBeforeWaiting,
+            1, // repeat = true
+            0, // see comment on `control_flow_main_end_handler`
+            control_flow_main_end_handler,
+            ptr::null_mut(),
+        );
+        CFRunLoopAddObserver(main_loop, main_end_observer, kCFRunLoopDefaultMode);
+
+        let end_observer = CFRunLoopObserverCreate(
+            ptr::null_mut(),
+            kCFRunLoopExit | kCFRunLoopBeforeWaiting,
+            1, // repeat = true
+            CFIndex::max_value(),
+            control_flow_end_handler,
+            ptr::null_mut(),
+        );
+        CFRunLoopAddObserver(main_loop, end_observer, kCFRunLoopDefaultMode);
+    }
+}
+
+#[derive(Debug)]
+pub enum Never {}
+
+pub trait EventHandler: Debug {
+    fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow);
+    fn handle_user_events(&mut self, control_flow: &mut ControlFlow);
+}
+
+struct EventLoopHandler<F, T: 'static> {
+    f: F,
+    event_loop: RootEventLoopWindowTarget<T>,
+}
+
+impl<F, T: 'static> Debug for EventLoopHandler<F, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("EventLoopHandler")
+            .field("event_loop", &self.event_loop)
+            .finish()
+    }
+}
+
+impl<F, T> EventHandler for EventLoopHandler<F, T>
+where
+    F: 'static + FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
+    T: 'static,
+{
+    fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow) {
+        (self.f)(
+            event.map_nonuser_event().unwrap(),
+            &self.event_loop,
+            control_flow,
+        );
+    }
+
+    fn handle_user_events(&mut self, control_flow: &mut ControlFlow) {
+        for event in self.event_loop.p.receiver.try_iter() {
+            (self.f)(Event::UserEvent(event), &self.event_loop, control_flow);
+        }
+    }
+}

third-party/vendor/winit/src/platform_impl/ios/ffi.rs

@@ -0,0 +1,93 @@
+#![allow(non_camel_case_types, non_snake_case, non_upper_case_globals)]
+
+use std::convert::TryInto;
+
+use objc2::encode::{Encode, Encoding};
+use objc2::foundation::{NSInteger, NSUInteger};
+
+use crate::platform::ios::{Idiom, ScreenEdge};
+
+#[repr(C)]
+#[derive(Clone, Debug)]
+pub struct NSOperatingSystemVersion {
+    pub major: NSInteger,
+    pub minor: NSInteger,
+    pub patch: NSInteger,
+}
+
+unsafe impl Encode for NSOperatingSystemVersion {
+    const ENCODING: Encoding = Encoding::Struct(
+        "NSOperatingSystemVersion",
+        &[
+            NSInteger::ENCODING,
+            NSInteger::ENCODING,
+            NSInteger::ENCODING,
+        ],
+    );
+}
+
+#[repr(transparent)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct UIUserInterfaceIdiom(NSInteger);
+
+unsafe impl Encode for UIUserInterfaceIdiom {
+    const ENCODING: Encoding = NSInteger::ENCODING;
+}
+
+impl UIUserInterfaceIdiom {
+    pub const Unspecified: UIUserInterfaceIdiom = UIUserInterfaceIdiom(-1);
+    pub const Phone: UIUserInterfaceIdiom = UIUserInterfaceIdiom(0);
+    pub const Pad: UIUserInterfaceIdiom = UIUserInterfaceIdiom(1);
+    pub const TV: UIUserInterfaceIdiom = UIUserInterfaceIdiom(2);
+    pub const CarPlay: UIUserInterfaceIdiom = UIUserInterfaceIdiom(3);
+}
+
+impl From<Idiom> for UIUserInterfaceIdiom {
+    fn from(idiom: Idiom) -> UIUserInterfaceIdiom {
+        match idiom {
+            Idiom::Unspecified => UIUserInterfaceIdiom::Unspecified,
+            Idiom::Phone => UIUserInterfaceIdiom::Phone,
+            Idiom::Pad => UIUserInterfaceIdiom::Pad,
+            Idiom::TV => UIUserInterfaceIdiom::TV,
+            Idiom::CarPlay => UIUserInterfaceIdiom::CarPlay,
+        }
+    }
+}
+impl From<UIUserInterfaceIdiom> for Idiom {
+    fn from(ui_idiom: UIUserInterfaceIdiom) -> Idiom {
+        match ui_idiom {
+            UIUserInterfaceIdiom::Unspecified => Idiom::Unspecified,
+            UIUserInterfaceIdiom::Phone => Idiom::Phone,
+            UIUserInterfaceIdiom::Pad => Idiom::Pad,
+            UIUserInterfaceIdiom::TV => Idiom::TV,
+            UIUserInterfaceIdiom::CarPlay => Idiom::CarPlay,
+            _ => unreachable!(),
+        }
+    }
+}
+
+#[repr(transparent)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct UIRectEdge(NSUInteger);
+
+unsafe impl Encode for UIRectEdge {
+    const ENCODING: Encoding = NSUInteger::ENCODING;
+}
+
+impl From<ScreenEdge> for UIRectEdge {
+    fn from(screen_edge: ScreenEdge) -> UIRectEdge {
+        assert_eq!(
+            screen_edge.bits() & !ScreenEdge::ALL.bits(),
+            0,
+            "invalid `ScreenEdge`"
+        );
+        UIRectEdge(screen_edge.bits().into())
+    }
+}
+
+impl From<UIRectEdge> for ScreenEdge {
+    fn from(ui_rect_edge: UIRectEdge) -> ScreenEdge {
+        let bits: u8 = ui_rect_edge.0.try_into().expect("invalid `UIRectEdge`");
+        ScreenEdge::from_bits(bits).expect("invalid `ScreenEdge`")
+    }
+}

third-party/vendor/winit/src/platform_impl/ios/mod.rs

@@ -0,0 +1,117 @@
+//! iOS support
+//!
+//! # Building app
+//! To build ios app you will need rustc built for this targets:
+//!
+//!  - armv7-apple-ios
+//!  - armv7s-apple-ios
+//!  - i386-apple-ios
+//!  - aarch64-apple-ios
+//!  - x86_64-apple-ios
+//!
+//! Then
+//!
+//! ```
+//! cargo build --target=...
+//! ```
+//! The simplest way to integrate your app into xcode environment is to build it
+//! as a static library. Wrap your main function and export it.
+//!
+//! ```rust, ignore
+//! #[no_mangle]
+//! pub extern fn start_winit_app() {
+//!     start_inner()
+//! }
+//!
+//! fn start_inner() {
+//!    ...
+//! }
+//! ```
+//!
+//! Compile project and then drag resulting .a into Xcode project. Add winit.h to xcode.
+//!
+//! ```ignore
+//! void start_winit_app();
+//! ```
+//!
+//! Use start_winit_app inside your xcode's main function.
+//!
+//!
+//! # App lifecycle and events
+//!
+//! iOS environment is very different from other platforms and you must be very
+//! careful with it's events. Familiarize yourself with
+//! [app lifecycle](https://developer.apple.com/library/ios/documentation/UIKit/Reference/UIApplicationDelegate_Protocol/).
+//!
+//!
+//! This is how those event are represented in winit:
+//!
+//!  - applicationDidBecomeActive is Resumed
+//!  - applicationWillResignActive is Suspended
+//!  - applicationWillTerminate is LoopDestroyed
+//!
+//! Keep in mind that after LoopDestroyed event is received every attempt to draw with
+//! opengl will result in segfault.
+//!
+//! Also note that app may not receive the LoopDestroyed event if suspended; it might be SIGKILL'ed.
+
+#![cfg(ios_platform)]
+#![allow(clippy::let_unit_value)]
+
+// TODO: (mtak-) UIKit requires main thread for virtually all function/method calls. This could be
+// worked around in the future by using GCD (grand central dispatch) and/or caching of values like
+// window size/position.
+macro_rules! assert_main_thread {
+    ($($t:tt)*) => {
+        if !::objc2::foundation::is_main_thread() {
+            panic!($($t)*);
+        }
+    };
+}
+
+mod app_state;
+mod event_loop;
+mod ffi;
+mod monitor;
+mod uikit;
+mod view;
+mod window;
+
+use std::fmt;
+
+pub(crate) use self::{
+    event_loop::{
+        EventLoop, EventLoopProxy, EventLoopWindowTarget, PlatformSpecificEventLoopAttributes,
+    },
+    monitor::{MonitorHandle, VideoMode},
+    window::{PlatformSpecificWindowBuilderAttributes, Window, WindowId},
+};
+
+use self::uikit::UIScreen;
+pub(crate) use crate::icon::NoIcon as PlatformIcon;
+pub(self) use crate::platform_impl::Fullscreen;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct DeviceId {
+    uiscreen: *const UIScreen,
+}
+
+impl DeviceId {
+    pub const unsafe fn dummy() -> Self {
+        DeviceId {
+            uiscreen: std::ptr::null(),
+        }
+    }
+}
+
+unsafe impl Send for DeviceId {}
+unsafe impl Sync for DeviceId {}
+
+#[derive(Debug)]
+pub enum OsError {}
+
+impl fmt::Display for OsError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "os error")
+    }
+}

third-party/vendor/winit/src/platform_impl/ios/monitor.rs

@@ -0,0 +1,246 @@
+#![allow(clippy::unnecessary_cast)]
+
+use std::{
+    collections::{BTreeSet, VecDeque},
+    fmt,
+    ops::{Deref, DerefMut},
+};
+
+use objc2::foundation::{MainThreadMarker, NSInteger};
+use objc2::rc::{Id, Shared};
+
+use super::uikit::{UIScreen, UIScreenMode};
+use crate::{
+    dpi::{PhysicalPosition, PhysicalSize},
+    monitor::VideoMode as RootVideoMode,
+    platform_impl::platform::app_state,
+};
+
+// TODO(madsmtm): Remove or refactor this
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+pub(crate) struct ScreenModeSendSync(pub(crate) Id<UIScreenMode, Shared>);
+
+unsafe impl Send for ScreenModeSendSync {}
+unsafe impl Sync for ScreenModeSendSync {}
+
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+pub struct VideoMode {
+    pub(crate) size: (u32, u32),
+    pub(crate) bit_depth: u16,
+    pub(crate) refresh_rate_millihertz: u32,
+    pub(crate) screen_mode: ScreenModeSendSync,
+    pub(crate) monitor: MonitorHandle,
+}
+
+impl VideoMode {
+    fn new(uiscreen: Id<UIScreen, Shared>, screen_mode: Id<UIScreenMode, Shared>) -> VideoMode {
+        assert_main_thread!("`VideoMode` can only be created on the main thread on iOS");
+        let refresh_rate_millihertz = refresh_rate_millihertz(&uiscreen);
+        let size = screen_mode.size();
+        VideoMode {
+            size: (size.width as u32, size.height as u32),
+            bit_depth: 32,
+            refresh_rate_millihertz,
+            screen_mode: ScreenModeSendSync(screen_mode),
+            monitor: MonitorHandle::new(uiscreen),
+        }
+    }
+
+    pub fn size(&self) -> PhysicalSize<u32> {
+        self.size.into()
+    }
+
+    pub fn bit_depth(&self) -> u16 {
+        self.bit_depth
+    }
+
+    pub fn refresh_rate_millihertz(&self) -> u32 {
+        self.refresh_rate_millihertz
+    }
+
+    pub fn monitor(&self) -> MonitorHandle {
+        self.monitor.clone()
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct Inner {
+    uiscreen: Id<UIScreen, Shared>,
+}
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct MonitorHandle {
+    inner: Inner,
+}
+
+impl PartialOrd for MonitorHandle {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for MonitorHandle {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        // TODO: Make a better ordering
+        (self as *const Self).cmp(&(other as *const Self))
+    }
+}
+
+impl Deref for MonitorHandle {
+    type Target = Inner;
+
+    fn deref(&self) -> &Inner {
+        assert_main_thread!("`MonitorHandle` methods can only be run on the main thread on iOS");
+        &self.inner
+    }
+}
+
+impl DerefMut for MonitorHandle {
+    fn deref_mut(&mut self) -> &mut Inner {
+        assert_main_thread!("`MonitorHandle` methods can only be run on the main thread on iOS");
+        &mut self.inner
+    }
+}
+
+unsafe impl Send for MonitorHandle {}
+unsafe impl Sync for MonitorHandle {}
+
+impl Drop for MonitorHandle {
+    fn drop(&mut self) {
+        assert_main_thread!("`MonitorHandle` can only be dropped on the main thread on iOS");
+    }
+}
+
+impl fmt::Debug for MonitorHandle {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // TODO: Do this using the proper fmt API
+        #[derive(Debug)]
+        #[allow(dead_code)]
+        struct MonitorHandle {
+            name: Option<String>,
+            size: PhysicalSize<u32>,
+            position: PhysicalPosition<i32>,
+            scale_factor: f64,
+        }
+
+        let monitor_id_proxy = MonitorHandle {
+            name: self.name(),
+            size: self.size(),
+            position: self.position(),
+            scale_factor: self.scale_factor(),
+        };
+
+        monitor_id_proxy.fmt(f)
+    }
+}
+
+impl MonitorHandle {
+    pub(crate) fn new(uiscreen: Id<UIScreen, Shared>) -> Self {
+        assert_main_thread!("`MonitorHandle` can only be created on the main thread on iOS");
+        Self {
+            inner: Inner { uiscreen },
+        }
+    }
+}
+
+impl Inner {
+    pub fn name(&self) -> Option<String> {
+        let main = UIScreen::main(MainThreadMarker::new().unwrap());
+        if self.uiscreen == main {
+            Some("Primary".to_string())
+        } else if self.uiscreen == main.mirroredScreen() {
+            Some("Mirrored".to_string())
+        } else {
+            UIScreen::screens(MainThreadMarker::new().unwrap())
+                .iter()
+                .position(|rhs| rhs == &*self.uiscreen)
+                .map(|idx| idx.to_string())
+        }
+    }
+
+    pub fn size(&self) -> PhysicalSize<u32> {
+        let bounds = self.uiscreen.nativeBounds();
+        PhysicalSize::new(bounds.size.width as u32, bounds.size.height as u32)
+    }
+
+    pub fn position(&self) -> PhysicalPosition<i32> {
+        let bounds = self.uiscreen.nativeBounds();
+        (bounds.origin.x as f64, bounds.origin.y as f64).into()
+    }
+
+    pub fn scale_factor(&self) -> f64 {
+        self.uiscreen.nativeScale() as f64
+    }
+
+    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
+        Some(refresh_rate_millihertz(&self.uiscreen))
+    }
+
+    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
+        // Use Ord impl of RootVideoMode
+        let modes: BTreeSet<_> = self
+            .uiscreen
+            .availableModes()
+            .into_iter()
+            .map(|mode| {
+                let mode: *const UIScreenMode = mode;
+                let mode = unsafe { Id::retain(mode as *mut UIScreenMode).unwrap() };
+
+                RootVideoMode {
+                    video_mode: VideoMode::new(self.uiscreen.clone(), mode),
+                }
+            })
+            .collect();
+
+        modes.into_iter().map(|mode| mode.video_mode)
+    }
+}
+
+fn refresh_rate_millihertz(uiscreen: &UIScreen) -> u32 {
+    let refresh_rate_millihertz: NSInteger = {
+        let os_capabilities = app_state::os_capabilities();
+        if os_capabilities.maximum_frames_per_second {
+            uiscreen.maximumFramesPerSecond()
+        } else {
+            // https://developer.apple.com/library/archive/technotes/tn2460/_index.html
+            // https://en.wikipedia.org/wiki/IPad_Pro#Model_comparison
+            //
+            // All iOS devices support 60 fps, and on devices where `maximumFramesPerSecond` is not
+            // supported, they are all guaranteed to have 60hz refresh rates. This does not
+            // correctly handle external displays. ProMotion displays support 120fps, but they were
+            // introduced at the same time as the `maximumFramesPerSecond` API.
+            //
+            // FIXME: earlier OSs could calculate the refresh rate using
+            // `-[CADisplayLink duration]`.
+            os_capabilities.maximum_frames_per_second_err_msg("defaulting to 60 fps");
+            60
+        }
+    };
+
+    refresh_rate_millihertz as u32 * 1000
+}
+
+// MonitorHandleExtIOS
+impl Inner {
+    pub(crate) fn ui_screen(&self) -> &Id<UIScreen, Shared> {
+        &self.uiscreen
+    }
+
+    pub fn preferred_video_mode(&self) -> VideoMode {
+        VideoMode::new(
+            self.uiscreen.clone(),
+            self.uiscreen.preferredMode().unwrap(),
+        )
+    }
+}
+
+pub fn uiscreens(mtm: MainThreadMarker) -> VecDeque<MonitorHandle> {
+    UIScreen::screens(mtm)
+        .into_iter()
+        .map(|screen| {
+            let screen: *const UIScreen = screen;
+            let screen = unsafe { Id::retain(screen as *mut UIScreen).unwrap() };
+            MonitorHandle::new(screen)
+        })
+        .collect()
+}

third-party/vendor/winit/src/platform_impl/ios/uikit/application.rs

@@ -0,0 +1,30 @@
+use objc2::foundation::{CGRect, MainThreadMarker, NSArray, NSObject};
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
+
+use super::{UIResponder, UIWindow};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct UIApplication;
+
+    unsafe impl ClassType for UIApplication {
+        #[inherits(NSObject)]
+        type Super = UIResponder;
+    }
+);
+
+extern_methods!(
+    unsafe impl UIApplication {
+        pub fn shared(_mtm: MainThreadMarker) -> Option<Id<Self, Shared>> {
+            unsafe { msg_send_id![Self::class(), sharedApplication] }
+        }
+
+        pub fn windows(&self) -> Id<NSArray<UIWindow, Shared>, Shared> {
+            unsafe { msg_send_id![self, windows] }
+        }
+
+        #[sel(statusBarFrame)]
+        pub fn statusBarFrame(&self) -> CGRect;
+    }
+);

third-party/vendor/winit/src/platform_impl/ios/uikit/coordinate_space.rs

@@ -0,0 +1,11 @@
+use objc2::foundation::NSObject;
+use objc2::{extern_class, ClassType};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct UICoordinateSpace;
+
+    unsafe impl ClassType for UICoordinateSpace {
+        type Super = NSObject;
+    }
+);

third-party/vendor/winit/src/platform_impl/ios/uikit/device.rs

@@ -0,0 +1,25 @@
+use objc2::foundation::{MainThreadMarker, NSObject};
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
+
+use super::super::ffi::UIUserInterfaceIdiom;
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct UIDevice;
+
+    unsafe impl ClassType for UIDevice {
+        type Super = NSObject;
+    }
+);
+
+extern_methods!(
+    unsafe impl UIDevice {
+        pub fn current(_mtm: MainThreadMarker) -> Id<Self, Shared> {
+            unsafe { msg_send_id![Self::class(), currentDevice] }
+        }
+
+        #[sel(userInterfaceIdiom)]
+        pub fn userInterfaceIdiom(&self) -> UIUserInterfaceIdiom;
+    }
+);

third-party/vendor/winit/src/platform_impl/ios/uikit/event.rs

@@ -0,0 +1,11 @@
+use objc2::foundation::NSObject;
+use objc2::{extern_class, ClassType};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct UIEvent;
+
+    unsafe impl ClassType for UIEvent {
+        type Super = NSObject;
+    }
+);

third-party/vendor/winit/src/platform_impl/ios/uikit/mod.rs

@@ -0,0 +1,44 @@
+#![deny(unsafe_op_in_unsafe_fn)]
+#![allow(non_snake_case)]
+#![allow(non_upper_case_globals)]
+
+use std::os::raw::{c_char, c_int};
+
+use objc2::foundation::NSString;
+
+mod application;
+mod coordinate_space;
+mod device;
+mod event;
+mod responder;
+mod screen;
+mod screen_mode;
+mod touch;
+mod trait_collection;
+mod view;
+mod view_controller;
+mod window;
+
+pub(crate) use self::application::UIApplication;
+pub(crate) use self::coordinate_space::UICoordinateSpace;
+pub(crate) use self::device::UIDevice;
+pub(crate) use self::event::UIEvent;
+pub(crate) use self::responder::UIResponder;
+pub(crate) use self::screen::{UIScreen, UIScreenOverscanCompensation};
+pub(crate) use self::screen_mode::UIScreenMode;
+pub(crate) use self::touch::{UITouch, UITouchPhase, UITouchType};
+pub(crate) use self::trait_collection::{UIForceTouchCapability, UITraitCollection};
+#[allow(unused_imports)]
+pub(crate) use self::view::{UIEdgeInsets, UIView};
+pub(crate) use self::view_controller::{UIInterfaceOrientationMask, UIViewController};
+pub(crate) use self::window::UIWindow;
+
+#[link(name = "UIKit", kind = "framework")]
+extern "C" {
+    pub fn UIApplicationMain(
+        argc: c_int,
+        argv: *const c_char,
+        principalClassName: Option<&NSString>,
+        delegateClassName: Option<&NSString>,
+    ) -> c_int;
+}

third-party/vendor/winit/src/platform_impl/ios/uikit/responder.rs

@@ -0,0 +1,11 @@
+use objc2::foundation::NSObject;
+use objc2::{extern_class, ClassType};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct UIResponder;
+
+    unsafe impl ClassType for UIResponder {
+        type Super = NSObject;
+    }
+);

third-party/vendor/winit/src/platform_impl/ios/uikit/screen.rs

@@ -0,0 +1,79 @@
+use objc2::encode::{Encode, Encoding};
+use objc2::foundation::{CGFloat, CGRect, MainThreadMarker, NSArray, NSInteger, NSObject};
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
+
+use super::{UICoordinateSpace, UIScreenMode};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct UIScreen;
+
+    unsafe impl ClassType for UIScreen {
+        type Super = NSObject;
+    }
+);
+
+extern_methods!(
+    unsafe impl UIScreen {
+        pub fn main(_mtm: MainThreadMarker) -> Id<Self, Shared> {
+            unsafe { msg_send_id![Self::class(), mainScreen] }
+        }
+
+        pub fn screens(_mtm: MainThreadMarker) -> Id<NSArray<Self, Shared>, Shared> {
+            unsafe { msg_send_id![Self::class(), screens] }
+        }
+
+        #[sel(bounds)]
+        pub fn bounds(&self) -> CGRect;
+
+        #[sel(scale)]
+        pub fn scale(&self) -> CGFloat;
+
+        #[sel(nativeBounds)]
+        pub fn nativeBounds(&self) -> CGRect;
+
+        #[sel(nativeScale)]
+        pub fn nativeScale(&self) -> CGFloat;
+
+        #[sel(maximumFramesPerSecond)]
+        pub fn maximumFramesPerSecond(&self) -> NSInteger;
+
+        pub fn mirroredScreen(&self) -> Id<Self, Shared> {
+            unsafe { msg_send_id![Self::class(), mirroredScreen] }
+        }
+
+        pub fn preferredMode(&self) -> Option<Id<UIScreenMode, Shared>> {
+            unsafe { msg_send_id![self, preferredMode] }
+        }
+
+        #[sel(setCurrentMode:)]
+        pub fn setCurrentMode(&self, mode: Option<&UIScreenMode>);
+
+        pub fn availableModes(&self) -> Id<NSArray<UIScreenMode, Shared>, Shared> {
+            unsafe { msg_send_id![self, availableModes] }
+        }
+
+        #[sel(setOverscanCompensation:)]
+        pub fn setOverscanCompensation(&self, overscanCompensation: UIScreenOverscanCompensation);
+
+        pub fn coordinateSpace(&self) -> Id<UICoordinateSpace, Shared> {
+            unsafe { msg_send_id![self, coordinateSpace] }
+        }
+    }
+);
+
+#[repr(transparent)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct UIScreenOverscanCompensation(NSInteger);
+
+unsafe impl Encode for UIScreenOverscanCompensation {
+    const ENCODING: Encoding = NSInteger::ENCODING;
+}
+
+#[allow(dead_code)]
+impl UIScreenOverscanCompensation {
+    pub const Scale: Self = Self(0);
+    pub const InsetBounds: Self = Self(1);
+    pub const None: Self = Self(2);
+}

third-party/vendor/winit/src/platform_impl/ios/uikit/screen_mode.rs

@@ -0,0 +1,18 @@
+use objc2::foundation::{CGSize, NSObject};
+use objc2::{extern_class, extern_methods, ClassType};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct UIScreenMode;
+
+    unsafe impl ClassType for UIScreenMode {
+        type Super = NSObject;
+    }
+);
+
+extern_methods!(
+    unsafe impl UIScreenMode {
+        #[sel(size)]
+        pub fn size(&self) -> CGSize;
+    }
+);

third-party/vendor/winit/src/platform_impl/ios/uikit/touch.rs

@@ -0,0 +1,64 @@
+use objc2::encode::{Encode, Encoding};
+use objc2::foundation::{CGFloat, CGPoint, NSInteger, NSObject};
+use objc2::{extern_class, extern_methods, ClassType};
+
+use super::UIView;
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct UITouch;
+
+    unsafe impl ClassType for UITouch {
+        type Super = NSObject;
+    }
+);
+
+extern_methods!(
+    unsafe impl UITouch {
+        #[sel(locationInView:)]
+        pub fn locationInView(&self, view: Option<&UIView>) -> CGPoint;
+
+        #[sel(type)]
+        pub fn type_(&self) -> UITouchType;
+
+        #[sel(force)]
+        pub fn force(&self) -> CGFloat;
+
+        #[sel(maximumPossibleForce)]
+        pub fn maximumPossibleForce(&self) -> CGFloat;
+
+        #[sel(altitudeAngle)]
+        pub fn altitudeAngle(&self) -> CGFloat;
+
+        #[sel(phase)]
+        pub fn phase(&self) -> UITouchPhase;
+    }
+);
+
+#[derive(Debug, PartialEq, Eq)]
+#[allow(dead_code)]
+#[repr(isize)]
+pub enum UITouchType {
+    Direct = 0,
+    Indirect,
+    Pencil,
+}
+
+unsafe impl Encode for UITouchType {
+    const ENCODING: Encoding = NSInteger::ENCODING;
+}
+
+#[derive(Debug)]
+#[allow(dead_code)]
+#[repr(isize)]
+pub enum UITouchPhase {
+    Began = 0,
+    Moved,
+    Stationary,
+    Ended,
+    Cancelled,
+}
+
+unsafe impl Encode for UITouchPhase {
+    const ENCODING: Encoding = NSInteger::ENCODING;
+}

third-party/vendor/winit/src/platform_impl/ios/uikit/trait_collection.rs

@@ -0,0 +1,32 @@
+use objc2::encode::{Encode, Encoding};
+use objc2::foundation::{NSInteger, NSObject};
+use objc2::{extern_class, extern_methods, ClassType};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct UITraitCollection;
+
+    unsafe impl ClassType for UITraitCollection {
+        type Super = NSObject;
+    }
+);
+
+extern_methods!(
+    unsafe impl UITraitCollection {
+        #[sel(forceTouchCapability)]
+        pub fn forceTouchCapability(&self) -> UIForceTouchCapability;
+    }
+);
+
+#[derive(Debug, PartialEq, Eq)]
+#[allow(dead_code)]
+#[repr(isize)]
+pub enum UIForceTouchCapability {
+    Unknown = 0,
+    Unavailable,
+    Available,
+}
+
+unsafe impl Encode for UIForceTouchCapability {
+    const ENCODING: Encoding = NSInteger::ENCODING;
+}

third-party/vendor/winit/src/platform_impl/ios/uikit/view.rs

@@ -0,0 +1,89 @@
+use objc2::encode::{Encode, Encoding};
+use objc2::foundation::{CGFloat, CGRect, NSObject};
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
+
+use super::{UICoordinateSpace, UIResponder, UIViewController};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct UIView;
+
+    unsafe impl ClassType for UIView {
+        #[inherits(NSObject)]
+        type Super = UIResponder;
+    }
+);
+
+extern_methods!(
+    unsafe impl UIView {
+        #[sel(bounds)]
+        pub fn bounds(&self) -> CGRect;
+
+        #[sel(setBounds:)]
+        pub fn setBounds(&self, value: CGRect);
+
+        #[sel(frame)]
+        pub fn frame(&self) -> CGRect;
+
+        #[sel(setFrame:)]
+        pub fn setFrame(&self, value: CGRect);
+
+        #[sel(contentScaleFactor)]
+        pub fn contentScaleFactor(&self) -> CGFloat;
+
+        #[sel(setContentScaleFactor:)]
+        pub fn setContentScaleFactor(&self, val: CGFloat);
+
+        #[sel(setMultipleTouchEnabled:)]
+        pub fn setMultipleTouchEnabled(&self, val: bool);
+
+        pub fn rootViewController(&self) -> Option<Id<UIViewController, Shared>> {
+            unsafe { msg_send_id![self, rootViewController] }
+        }
+
+        #[sel(setRootViewController:)]
+        pub fn setRootViewController(&self, rootViewController: Option<&UIViewController>);
+
+        #[sel(convertRect:toCoordinateSpace:)]
+        pub fn convertRect_toCoordinateSpace(
+            &self,
+            rect: CGRect,
+            coordinateSpace: &UICoordinateSpace,
+        ) -> CGRect;
+
+        #[sel(convertRect:fromCoordinateSpace:)]
+        pub fn convertRect_fromCoordinateSpace(
+            &self,
+            rect: CGRect,
+            coordinateSpace: &UICoordinateSpace,
+        ) -> CGRect;
+
+        #[sel(safeAreaInsets)]
+        pub fn safeAreaInsets(&self) -> UIEdgeInsets;
+
+        #[sel(setNeedsDisplay)]
+        pub fn setNeedsDisplay(&self);
+    }
+);
+
+#[repr(C)]
+#[derive(Debug, Clone)]
+pub struct UIEdgeInsets {
+    pub top: CGFloat,
+    pub left: CGFloat,
+    pub bottom: CGFloat,
+    pub right: CGFloat,
+}
+
+unsafe impl Encode for UIEdgeInsets {
+    const ENCODING: Encoding = Encoding::Struct(
+        "UIEdgeInsets",
+        &[
+            CGFloat::ENCODING,
+            CGFloat::ENCODING,
+            CGFloat::ENCODING,
+            CGFloat::ENCODING,
+        ],
+    );
+}

third-party/vendor/winit/src/platform_impl/ios/uikit/view_controller.rs

@@ -0,0 +1,55 @@
+use objc2::encode::{Encode, Encoding};
+use objc2::foundation::{NSObject, NSUInteger};
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
+
+use super::{UIResponder, UIView};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct UIViewController;
+
+    unsafe impl ClassType for UIViewController {
+        #[inherits(NSObject)]
+        type Super = UIResponder;
+    }
+);
+
+extern_methods!(
+    unsafe impl UIViewController {
+        #[sel(attemptRotationToDeviceOrientation)]
+        pub fn attemptRotationToDeviceOrientation();
+
+        #[sel(setNeedsStatusBarAppearanceUpdate)]
+        pub fn setNeedsStatusBarAppearanceUpdate(&self);
+
+        #[sel(setNeedsUpdateOfHomeIndicatorAutoHidden)]
+        pub fn setNeedsUpdateOfHomeIndicatorAutoHidden(&self);
+
+        #[sel(setNeedsUpdateOfScreenEdgesDeferringSystemGestures)]
+        pub fn setNeedsUpdateOfScreenEdgesDeferringSystemGestures(&self);
+
+        pub fn view(&self) -> Option<Id<UIView, Shared>> {
+            unsafe { msg_send_id![self, view] }
+        }
+
+        #[sel(setView:)]
+        pub fn setView(&self, view: Option<&UIView>);
+    }
+);
+
+bitflags! {
+    pub struct UIInterfaceOrientationMask: NSUInteger {
+        const Portrait = 1 << 1;
+        const PortraitUpsideDown = 1 << 2;
+        const LandscapeRight = 1 << 3;
+        const LandscapeLeft = 1 << 4;
+        const Landscape = Self::LandscapeLeft.bits() | Self::LandscapeRight.bits();
+        const AllButUpsideDown = Self::Landscape.bits() | Self::Portrait.bits();
+        const All = Self::AllButUpsideDown.bits() | Self::PortraitUpsideDown.bits();
+    }
+}
+
+unsafe impl Encode for UIInterfaceOrientationMask {
+    const ENCODING: Encoding = NSUInteger::ENCODING;
+}

third-party/vendor/winit/src/platform_impl/ios/uikit/window.rs

@@ -0,0 +1,35 @@
+use objc2::foundation::NSObject;
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
+
+use super::{UIResponder, UIScreen, UIView};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct UIWindow;
+
+    unsafe impl ClassType for UIWindow {
+        #[inherits(UIResponder, NSObject)]
+        type Super = UIView;
+    }
+);
+
+extern_methods!(
+    unsafe impl UIWindow {
+        pub fn screen(&self) -> Id<UIScreen, Shared> {
+            unsafe { msg_send_id![self, screen] }
+        }
+
+        #[sel(setScreen:)]
+        pub fn setScreen(&self, screen: &UIScreen);
+
+        #[sel(setHidden:)]
+        pub fn setHidden(&self, flag: bool);
+
+        #[sel(makeKeyAndVisible)]
+        pub fn makeKeyAndVisible(&self);
+
+        #[sel(isKeyWindow)]
+        pub fn isKeyWindow(&self) -> bool;
+    }
+);

third-party/vendor/winit/src/platform_impl/ios/view.rs

@@ -0,0 +1,535 @@
+#![allow(clippy::unnecessary_cast)]
+
+use objc2::foundation::{CGFloat, CGRect, MainThreadMarker, NSObject, NSSet};
+use objc2::rc::{Id, Shared};
+use objc2::runtime::Class;
+use objc2::{declare_class, extern_methods, msg_send, msg_send_id, ClassType};
+
+use super::uikit::{
+    UIApplication, UIDevice, UIEvent, UIForceTouchCapability, UIInterfaceOrientationMask,
+    UIResponder, UITouch, UITouchPhase, UITouchType, UITraitCollection, UIView, UIViewController,
+    UIWindow,
+};
+use super::window::WindowId;
+use crate::{
+    dpi::PhysicalPosition,
+    event::{DeviceId as RootDeviceId, Event, Force, Touch, TouchPhase, WindowEvent},
+    platform::ios::ValidOrientations,
+    platform_impl::platform::{
+        app_state,
+        event_loop::{EventProxy, EventWrapper},
+        ffi::{UIRectEdge, UIUserInterfaceIdiom},
+        window::PlatformSpecificWindowBuilderAttributes,
+        DeviceId, Fullscreen,
+    },
+    window::{WindowAttributes, WindowId as RootWindowId},
+};
+
+declare_class!(
+    pub(crate) struct WinitView {}
+
+    unsafe impl ClassType for WinitView {
+        #[inherits(UIResponder, NSObject)]
+        type Super = UIView;
+        const NAME: &'static str = "WinitUIView";
+    }
+
+    unsafe impl WinitView {
+        #[sel(drawRect:)]
+        fn draw_rect(&self, rect: CGRect) {
+            let window = self.window().unwrap();
+            unsafe {
+                app_state::handle_nonuser_events(
+                    std::iter::once(EventWrapper::StaticEvent(Event::RedrawRequested(
+                        RootWindowId(window.id()),
+                    )))
+                    .chain(std::iter::once(EventWrapper::StaticEvent(
+                        Event::RedrawEventsCleared,
+                    ))),
+                );
+            }
+            let _: () = unsafe { msg_send![super(self), drawRect: rect] };
+        }
+
+        #[sel(layoutSubviews)]
+        fn layout_subviews(&self) {
+            let _: () = unsafe { msg_send![super(self), layoutSubviews] };
+
+            let window = self.window().unwrap();
+            let window_bounds = window.bounds();
+            let screen = window.screen();
+            let screen_space = screen.coordinateSpace();
+            let screen_frame = self.convertRect_toCoordinateSpace(window_bounds, &screen_space);
+            let scale_factor = screen.scale();
+            let size = crate::dpi::LogicalSize {
+                width: screen_frame.size.width as f64,
+                height: screen_frame.size.height as f64,
+            }
+            .to_physical(scale_factor as f64);
+
+            // If the app is started in landscape, the view frame and window bounds can be mismatched.
+            // The view frame will be in portrait and the window bounds in landscape. So apply the
+            // window bounds to the view frame to make it consistent.
+            let view_frame = self.frame();
+            if view_frame != window_bounds {
+                self.setFrame(window_bounds);
+            }
+
+            unsafe {
+                app_state::handle_nonuser_event(EventWrapper::StaticEvent(Event::WindowEvent {
+                    window_id: RootWindowId(window.id()),
+                    event: WindowEvent::Resized(size),
+                }));
+            }
+        }
+
+        #[sel(setContentScaleFactor:)]
+        fn set_content_scale_factor(&self, untrusted_scale_factor: CGFloat) {
+            let _: () =
+                unsafe { msg_send![super(self), setContentScaleFactor: untrusted_scale_factor] };
+
+            // `window` is null when `setContentScaleFactor` is invoked prior to `[UIWindow
+            // makeKeyAndVisible]` at window creation time (either manually or internally by
+            // UIKit when the `UIView` is first created), in which case we send no events here
+            let window = match self.window() {
+                Some(window) => window,
+                None => return,
+            };
+            // `setContentScaleFactor` may be called with a value of 0, which means "reset the
+            // content scale factor to a device-specific default value", so we can't use the
+            // parameter here. We can query the actual factor using the getter
+            let scale_factor = self.contentScaleFactor();
+            assert!(
+                !scale_factor.is_nan()
+                    && scale_factor.is_finite()
+                    && scale_factor.is_sign_positive()
+                    && scale_factor > 0.0,
+                "invalid scale_factor set on UIView",
+            );
+            let scale_factor = scale_factor as f64;
+            let bounds = self.bounds();
+            let screen = window.screen();
+            let screen_space = screen.coordinateSpace();
+            let screen_frame = self.convertRect_toCoordinateSpace(bounds, &screen_space);
+            let size = crate::dpi::LogicalSize {
+                width: screen_frame.size.width as _,
+                height: screen_frame.size.height as _,
+            };
+            let window_id = RootWindowId(window.id());
+            unsafe {
+                app_state::handle_nonuser_events(
+                    std::iter::once(EventWrapper::EventProxy(EventProxy::DpiChangedProxy {
+                        window,
+                        scale_factor,
+                        suggested_size: size,
+                    }))
+                    .chain(std::iter::once(EventWrapper::StaticEvent(
+                        Event::WindowEvent {
+                            window_id,
+                            event: WindowEvent::Resized(size.to_physical(scale_factor)),
+                        },
+                    ))),
+                );
+            }
+        }
+
+        #[sel(touchesBegan:withEvent:)]
+        fn touches_began(&self, touches: &NSSet<UITouch>, _event: Option<&UIEvent>) {
+            self.handle_touches(touches)
+        }
+
+        #[sel(touchesMoved:withEvent:)]
+        fn touches_moved(&self, touches: &NSSet<UITouch>, _event: Option<&UIEvent>) {
+            self.handle_touches(touches)
+        }
+
+        #[sel(touchesEnded:withEvent:)]
+        fn touches_ended(&self, touches: &NSSet<UITouch>, _event: Option<&UIEvent>) {
+            self.handle_touches(touches)
+        }
+
+        #[sel(touchesCancelled:withEvent:)]
+        fn touches_cancelled(&self, touches: &NSSet<UITouch>, _event: Option<&UIEvent>) {
+            self.handle_touches(touches)
+        }
+    }
+);
+
+extern_methods!(
+    #[allow(non_snake_case)]
+    unsafe impl WinitView {
+        fn window(&self) -> Option<Id<WinitUIWindow, Shared>> {
+            unsafe { msg_send_id![self, window] }
+        }
+
+        unsafe fn traitCollection(&self) -> Id<UITraitCollection, Shared> {
+            msg_send_id![self, traitCollection]
+        }
+
+        // TODO: Allow the user to customize this
+        #[sel(layerClass)]
+        pub(crate) fn layerClass() -> &'static Class;
+    }
+);
+
+impl WinitView {
+    pub(crate) fn new(
+        _mtm: MainThreadMarker,
+        _window_attributes: &WindowAttributes,
+        platform_attributes: &PlatformSpecificWindowBuilderAttributes,
+        frame: CGRect,
+    ) -> Id<Self, Shared> {
+        let this: Id<Self, Shared> =
+            unsafe { msg_send_id![msg_send_id![Self::class(), alloc], initWithFrame: frame] };
+
+        this.setMultipleTouchEnabled(true);
+
+        if let Some(scale_factor) = platform_attributes.scale_factor {
+            this.setContentScaleFactor(scale_factor as _);
+        }
+
+        this
+    }
+
+    fn handle_touches(&self, touches: &NSSet<UITouch>) {
+        let window = self.window().unwrap();
+        let uiscreen = window.screen();
+        let mut touch_events = Vec::new();
+        let os_supports_force = app_state::os_capabilities().force_touch;
+        for touch in touches {
+            let logical_location = touch.locationInView(None);
+            let touch_type = touch.type_();
+            let force = if os_supports_force {
+                let trait_collection = unsafe { self.traitCollection() };
+                let touch_capability = trait_collection.forceTouchCapability();
+                // Both the OS _and_ the device need to be checked for force touch support.
+                if touch_capability == UIForceTouchCapability::Available {
+                    let force = touch.force();
+                    let max_possible_force = touch.maximumPossibleForce();
+                    let altitude_angle: Option<f64> = if touch_type == UITouchType::Pencil {
+                        let angle = touch.altitudeAngle();
+                        Some(angle as _)
+                    } else {
+                        None
+                    };
+                    Some(Force::Calibrated {
+                        force: force as _,
+                        max_possible_force: max_possible_force as _,
+                        altitude_angle,
+                    })
+                } else {
+                    None
+                }
+            } else {
+                None
+            };
+            let touch_id = touch as *const UITouch as u64;
+            let phase = touch.phase();
+            let phase = match phase {
+                UITouchPhase::Began => TouchPhase::Started,
+                UITouchPhase::Moved => TouchPhase::Moved,
+                // 2 is UITouchPhase::Stationary and is not expected here
+                UITouchPhase::Ended => TouchPhase::Ended,
+                UITouchPhase::Cancelled => TouchPhase::Cancelled,
+                _ => panic!("unexpected touch phase: {:?}", phase as i32),
+            };
+
+            let physical_location = {
+                let scale_factor = self.contentScaleFactor();
+                PhysicalPosition::from_logical::<(f64, f64), f64>(
+                    (logical_location.x as _, logical_location.y as _),
+                    scale_factor as f64,
+                )
+            };
+            touch_events.push(EventWrapper::StaticEvent(Event::WindowEvent {
+                window_id: RootWindowId(window.id()),
+                event: WindowEvent::Touch(Touch {
+                    device_id: RootDeviceId(DeviceId {
+                        uiscreen: Id::as_ptr(&uiscreen),
+                    }),
+                    id: touch_id,
+                    location: physical_location,
+                    force,
+                    phase,
+                }),
+            }));
+        }
+        unsafe {
+            app_state::handle_nonuser_events(touch_events);
+        }
+    }
+}
+
+declare_class!(
+    pub(crate) struct WinitViewController {
+        _prefers_status_bar_hidden: bool,
+        _prefers_home_indicator_auto_hidden: bool,
+        _supported_orientations: UIInterfaceOrientationMask,
+        _preferred_screen_edges_deferring_system_gestures: UIRectEdge,
+    }
+
+    unsafe impl ClassType for WinitViewController {
+        #[inherits(UIResponder, NSObject)]
+        type Super = UIViewController;
+        const NAME: &'static str = "WinitUIViewController";
+    }
+
+    unsafe impl WinitViewController {
+        #[sel(shouldAutorotate)]
+        fn should_autorotate(&self) -> bool {
+            true
+        }
+    }
+
+    unsafe impl WinitViewController {
+        #[sel(prefersStatusBarHidden)]
+        fn prefers_status_bar_hidden(&self) -> bool {
+            *self._prefers_status_bar_hidden
+        }
+
+        #[sel(setPrefersStatusBarHidden:)]
+        fn set_prefers_status_bar_hidden(&mut self, val: bool) {
+            *self._prefers_status_bar_hidden = val;
+            self.setNeedsStatusBarAppearanceUpdate();
+        }
+
+        #[sel(prefersHomeIndicatorAutoHidden)]
+        fn prefers_home_indicator_auto_hidden(&self) -> bool {
+            *self._prefers_home_indicator_auto_hidden
+        }
+
+        #[sel(setPrefersHomeIndicatorAutoHidden:)]
+        fn set_prefers_home_indicator_auto_hidden(&mut self, val: bool) {
+            *self._prefers_home_indicator_auto_hidden = val;
+            let os_capabilities = app_state::os_capabilities();
+            if os_capabilities.home_indicator_hidden {
+                self.setNeedsUpdateOfHomeIndicatorAutoHidden();
+            } else {
+                os_capabilities.home_indicator_hidden_err_msg("ignoring")
+            }
+        }
+
+        #[sel(supportedInterfaceOrientations)]
+        fn supported_orientations(&self) -> UIInterfaceOrientationMask {
+            *self._supported_orientations
+        }
+
+        #[sel(setSupportedInterfaceOrientations:)]
+        fn set_supported_orientations(&mut self, val: UIInterfaceOrientationMask) {
+            *self._supported_orientations = val;
+            UIViewController::attemptRotationToDeviceOrientation();
+        }
+
+        #[sel(preferredScreenEdgesDeferringSystemGestures)]
+        fn preferred_screen_edges_deferring_system_gestures(&self) -> UIRectEdge {
+            *self._preferred_screen_edges_deferring_system_gestures
+        }
+
+        #[sel(setPreferredScreenEdgesDeferringSystemGestures:)]
+        fn set_preferred_screen_edges_deferring_system_gestures(&mut self, val: UIRectEdge) {
+            *self._preferred_screen_edges_deferring_system_gestures = val;
+            let os_capabilities = app_state::os_capabilities();
+            if os_capabilities.defer_system_gestures {
+                self.setNeedsUpdateOfScreenEdgesDeferringSystemGestures();
+            } else {
+                os_capabilities.defer_system_gestures_err_msg("ignoring")
+            }
+        }
+    }
+);
+
+extern_methods!(
+    #[allow(non_snake_case)]
+    unsafe impl WinitViewController {
+        #[sel(setPrefersStatusBarHidden:)]
+        pub(crate) fn setPrefersStatusBarHidden(&self, flag: bool);
+
+        #[sel(setSupportedInterfaceOrientations:)]
+        pub(crate) fn setSupportedInterfaceOrientations(&self, val: UIInterfaceOrientationMask);
+
+        #[sel(setPrefersHomeIndicatorAutoHidden:)]
+        pub(crate) fn setPrefersHomeIndicatorAutoHidden(&self, val: bool);
+
+        #[sel(setPreferredScreenEdgesDeferringSystemGestures:)]
+        pub(crate) fn setPreferredScreenEdgesDeferringSystemGestures(&self, val: UIRectEdge);
+    }
+);
+
+impl WinitViewController {
+    pub(crate) fn set_supported_interface_orientations(
+        &self,
+        mtm: MainThreadMarker,
+        valid_orientations: ValidOrientations,
+    ) {
+        let mask = match (
+            valid_orientations,
+            UIDevice::current(mtm).userInterfaceIdiom(),
+        ) {
+            (ValidOrientations::LandscapeAndPortrait, UIUserInterfaceIdiom::Phone) => {
+                UIInterfaceOrientationMask::AllButUpsideDown
+            }
+            (ValidOrientations::LandscapeAndPortrait, _) => UIInterfaceOrientationMask::All,
+            (ValidOrientations::Landscape, _) => UIInterfaceOrientationMask::Landscape,
+            (ValidOrientations::Portrait, UIUserInterfaceIdiom::Phone) => {
+                UIInterfaceOrientationMask::Portrait
+            }
+            (ValidOrientations::Portrait, _) => {
+                UIInterfaceOrientationMask::Portrait
+                    | UIInterfaceOrientationMask::PortraitUpsideDown
+            }
+        };
+        self.setSupportedInterfaceOrientations(mask);
+    }
+
+    pub(crate) fn new(
+        mtm: MainThreadMarker,
+        _window_attributes: &WindowAttributes,
+        platform_attributes: &PlatformSpecificWindowBuilderAttributes,
+        view: &UIView,
+    ) -> Id<Self, Shared> {
+        let this: Id<Self, Shared> =
+            unsafe { msg_send_id![msg_send_id![Self::class(), alloc], init] };
+
+        this.setPrefersStatusBarHidden(platform_attributes.prefers_status_bar_hidden);
+
+        this.set_supported_interface_orientations(mtm, platform_attributes.valid_orientations);
+
+        this.setPrefersHomeIndicatorAutoHidden(platform_attributes.prefers_home_indicator_hidden);
+
+        this.setPreferredScreenEdgesDeferringSystemGestures(
+            platform_attributes
+                .preferred_screen_edges_deferring_system_gestures
+                .into(),
+        );
+
+        this.setView(Some(view));
+
+        this
+    }
+}
+
+declare_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct WinitUIWindow {}
+
+    unsafe impl ClassType for WinitUIWindow {
+        #[inherits(UIResponder, NSObject)]
+        type Super = UIWindow;
+    }
+
+    unsafe impl WinitUIWindow {
+        #[sel(becomeKeyWindow)]
+        fn become_key_window(&self) {
+            unsafe {
+                app_state::handle_nonuser_event(EventWrapper::StaticEvent(Event::WindowEvent {
+                    window_id: RootWindowId(self.id()),
+                    event: WindowEvent::Focused(true),
+                }));
+            }
+            let _: () = unsafe { msg_send![super(self), becomeKeyWindow] };
+        }
+
+        #[sel(resignKeyWindow)]
+        fn resign_key_window(&self) {
+            unsafe {
+                app_state::handle_nonuser_event(EventWrapper::StaticEvent(Event::WindowEvent {
+                    window_id: RootWindowId(self.id()),
+                    event: WindowEvent::Focused(false),
+                }));
+            }
+            let _: () = unsafe { msg_send![super(self), resignKeyWindow] };
+        }
+    }
+);
+
+impl WinitUIWindow {
+    pub(crate) fn new(
+        _mtm: MainThreadMarker,
+        window_attributes: &WindowAttributes,
+        _platform_attributes: &PlatformSpecificWindowBuilderAttributes,
+        frame: CGRect,
+        view_controller: &UIViewController,
+    ) -> Id<Self, Shared> {
+        let this: Id<Self, Shared> =
+            unsafe { msg_send_id![msg_send_id![Self::class(), alloc], initWithFrame: frame] };
+
+        this.setRootViewController(Some(view_controller));
+
+        match window_attributes.fullscreen.clone().map(Into::into) {
+            Some(Fullscreen::Exclusive(ref video_mode)) => {
+                let monitor = video_mode.monitor();
+                let screen = monitor.ui_screen();
+                screen.setCurrentMode(Some(&video_mode.screen_mode.0));
+                this.setScreen(screen);
+            }
+            Some(Fullscreen::Borderless(Some(ref monitor))) => {
+                let screen = monitor.ui_screen();
+                this.setScreen(screen);
+            }
+            _ => (),
+        }
+
+        this
+    }
+
+    pub(crate) fn id(&self) -> WindowId {
+        (self as *const Self as usize as u64).into()
+    }
+}
+
+declare_class!(
+    pub struct WinitApplicationDelegate {}
+
+    unsafe impl ClassType for WinitApplicationDelegate {
+        type Super = NSObject;
+    }
+
+    // UIApplicationDelegate protocol
+    unsafe impl WinitApplicationDelegate {
+        #[sel(application:didFinishLaunchingWithOptions:)]
+        fn did_finish_launching(&self, _application: &UIApplication, _: *mut NSObject) -> bool {
+            unsafe {
+                app_state::did_finish_launching();
+            }
+            true
+        }
+
+        #[sel(applicationDidBecomeActive:)]
+        fn did_become_active(&self, _application: &UIApplication) {
+            unsafe { app_state::handle_nonuser_event(EventWrapper::StaticEvent(Event::Resumed)) }
+        }
+
+        #[sel(applicationWillResignActive:)]
+        fn will_resign_active(&self, _application: &UIApplication) {
+            unsafe { app_state::handle_nonuser_event(EventWrapper::StaticEvent(Event::Suspended)) }
+        }
+
+        #[sel(applicationWillEnterForeground:)]
+        fn will_enter_foreground(&self, _application: &UIApplication) {}
+        #[sel(applicationDidEnterBackground:)]
+        fn did_enter_background(&self, _application: &UIApplication) {}
+
+        #[sel(applicationWillTerminate:)]
+        fn will_terminate(&self, application: &UIApplication) {
+            let mut events = Vec::new();
+            for window in application.windows().iter() {
+                if window.is_kind_of::<WinitUIWindow>() {
+                    // SAFETY: We just checked that the window is a `winit` window
+                    let window = unsafe {
+                        let ptr: *const UIWindow = window;
+                        let ptr: *const WinitUIWindow = ptr.cast();
+                        &*ptr
+                    };
+                    events.push(EventWrapper::StaticEvent(Event::WindowEvent {
+                        window_id: RootWindowId(window.id()),
+                        event: WindowEvent::Destroyed,
+                    }));
+                }
+            }
+            unsafe {
+                app_state::handle_nonuser_events(events);
+                app_state::terminated();
+            }
+        }
+    }
+);

third-party/vendor/winit/src/platform_impl/ios/window.rs

@@ -0,0 +1,662 @@
+#![allow(clippy::unnecessary_cast)]
+
+use std::{
+    collections::VecDeque,
+    ffi::c_void,
+    ops::{Deref, DerefMut},
+};
+
+use objc2::foundation::{CGFloat, CGPoint, CGRect, CGSize, MainThreadMarker};
+use objc2::rc::{Id, Shared};
+use objc2::runtime::Object;
+use objc2::{class, msg_send};
+use raw_window_handle::{RawDisplayHandle, RawWindowHandle, UiKitDisplayHandle, UiKitWindowHandle};
+
+use super::uikit::{UIApplication, UIScreen, UIScreenOverscanCompensation};
+use super::view::{WinitUIWindow, WinitView, WinitViewController};
+use crate::{
+    dpi::{self, LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size},
+    error::{ExternalError, NotSupportedError, OsError as RootOsError},
+    event::{Event, WindowEvent},
+    icon::Icon,
+    platform::ios::{ScreenEdge, ValidOrientations},
+    platform_impl::platform::{
+        app_state,
+        event_loop::{EventProxy, EventWrapper},
+        ffi::UIRectEdge,
+        monitor, EventLoopWindowTarget, Fullscreen, MonitorHandle,
+    },
+    window::{
+        CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
+        WindowAttributes, WindowButtons, WindowId as RootWindowId, WindowLevel,
+    },
+};
+
+pub struct Inner {
+    pub(crate) window: Id<WinitUIWindow, Shared>,
+    pub(crate) view_controller: Id<WinitViewController, Shared>,
+    pub(crate) view: Id<WinitView, Shared>,
+    gl_or_metal_backed: bool,
+}
+
+impl Inner {
+    pub fn set_title(&self, _title: &str) {
+        debug!("`Window::set_title` is ignored on iOS")
+    }
+
+    pub fn set_transparent(&self, _transparent: bool) {
+        debug!("`Window::set_transparent` is ignored on iOS")
+    }
+
+    pub fn set_visible(&self, visible: bool) {
+        self.window.setHidden(!visible)
+    }
+
+    pub fn is_visible(&self) -> Option<bool> {
+        warn!("`Window::is_visible` is ignored on iOS");
+        None
+    }
+
+    pub fn request_redraw(&self) {
+        unsafe {
+            if self.gl_or_metal_backed {
+                // `setNeedsDisplay` does nothing on UIViews which are directly backed by CAEAGLLayer or CAMetalLayer.
+                // Ordinarily the OS sets up a bunch of UIKit state before calling drawRect: on a UIView, but when using
+                // raw or gl/metal for drawing this work is completely avoided.
+                //
+                // The docs for `setNeedsDisplay` don't mention `CAMetalLayer`; however, this has been confirmed via
+                // testing.
+                //
+                // https://developer.apple.com/documentation/uikit/uiview/1622437-setneedsdisplay?language=objc
+                app_state::queue_gl_or_metal_redraw(self.window.clone());
+            } else {
+                self.view.setNeedsDisplay();
+            }
+        }
+    }
+
+    pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
+        unsafe {
+            let safe_area = self.safe_area_screen_space();
+            let position = LogicalPosition {
+                x: safe_area.origin.x as f64,
+                y: safe_area.origin.y as f64,
+            };
+            let scale_factor = self.scale_factor();
+            Ok(position.to_physical(scale_factor))
+        }
+    }
+
+    pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
+        unsafe {
+            let screen_frame = self.screen_frame();
+            let position = LogicalPosition {
+                x: screen_frame.origin.x as f64,
+                y: screen_frame.origin.y as f64,
+            };
+            let scale_factor = self.scale_factor();
+            Ok(position.to_physical(scale_factor))
+        }
+    }
+
+    pub fn set_outer_position(&self, physical_position: Position) {
+        unsafe {
+            let scale_factor = self.scale_factor();
+            let position = physical_position.to_logical::<f64>(scale_factor);
+            let screen_frame = self.screen_frame();
+            let new_screen_frame = CGRect {
+                origin: CGPoint {
+                    x: position.x as _,
+                    y: position.y as _,
+                },
+                size: screen_frame.size,
+            };
+            let bounds = self.rect_from_screen_space(new_screen_frame);
+            self.window.setBounds(bounds);
+        }
+    }
+
+    pub fn inner_size(&self) -> PhysicalSize<u32> {
+        unsafe {
+            let scale_factor = self.scale_factor();
+            let safe_area = self.safe_area_screen_space();
+            let size = LogicalSize {
+                width: safe_area.size.width as f64,
+                height: safe_area.size.height as f64,
+            };
+            size.to_physical(scale_factor)
+        }
+    }
+
+    pub fn outer_size(&self) -> PhysicalSize<u32> {
+        unsafe {
+            let scale_factor = self.scale_factor();
+            let screen_frame = self.screen_frame();
+            let size = LogicalSize {
+                width: screen_frame.size.width as f64,
+                height: screen_frame.size.height as f64,
+            };
+            size.to_physical(scale_factor)
+        }
+    }
+
+    pub fn set_inner_size(&self, _size: Size) {
+        warn!("not clear what `Window::set_inner_size` means on iOS");
+    }
+
+    pub fn set_min_inner_size(&self, _dimensions: Option<Size>) {
+        warn!("`Window::set_min_inner_size` is ignored on iOS")
+    }
+
+    pub fn set_max_inner_size(&self, _dimensions: Option<Size>) {
+        warn!("`Window::set_max_inner_size` is ignored on iOS")
+    }
+
+    pub fn resize_increments(&self) -> Option<PhysicalSize<u32>> {
+        None
+    }
+
+    #[inline]
+    pub fn set_resize_increments(&self, _increments: Option<Size>) {
+        warn!("`Window::set_resize_increments` is ignored on iOS")
+    }
+
+    pub fn set_resizable(&self, _resizable: bool) {
+        warn!("`Window::set_resizable` is ignored on iOS")
+    }
+
+    pub fn is_resizable(&self) -> bool {
+        warn!("`Window::is_resizable` is ignored on iOS");
+        false
+    }
+
+    #[inline]
+    pub fn set_enabled_buttons(&self, _buttons: WindowButtons) {
+        warn!("`Window::set_enabled_buttons` is ignored on iOS");
+    }
+
+    #[inline]
+    pub fn enabled_buttons(&self) -> WindowButtons {
+        warn!("`Window::enabled_buttons` is ignored on iOS");
+        WindowButtons::all()
+    }
+
+    pub fn scale_factor(&self) -> f64 {
+        self.view.contentScaleFactor() as _
+    }
+
+    pub fn set_cursor_icon(&self, _cursor: CursorIcon) {
+        debug!("`Window::set_cursor_icon` ignored on iOS")
+    }
+
+    pub fn set_cursor_position(&self, _position: Position) -> Result<(), ExternalError> {
+        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    }
+
+    pub fn set_cursor_grab(&self, _: CursorGrabMode) -> Result<(), ExternalError> {
+        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    }
+
+    pub fn set_cursor_visible(&self, _visible: bool) {
+        debug!("`Window::set_cursor_visible` is ignored on iOS")
+    }
+
+    pub fn drag_window(&self) -> Result<(), ExternalError> {
+        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    }
+
+    pub fn drag_resize_window(&self, _direction: ResizeDirection) -> Result<(), ExternalError> {
+        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    }
+
+    pub fn set_cursor_hittest(&self, _hittest: bool) -> Result<(), ExternalError> {
+        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    }
+
+    pub fn set_minimized(&self, _minimized: bool) {
+        warn!("`Window::set_minimized` is ignored on iOS")
+    }
+
+    pub fn is_minimized(&self) -> Option<bool> {
+        warn!("`Window::is_minimized` is ignored on iOS");
+        None
+    }
+
+    pub fn set_maximized(&self, _maximized: bool) {
+        warn!("`Window::set_maximized` is ignored on iOS")
+    }
+
+    pub fn is_maximized(&self) -> bool {
+        warn!("`Window::is_maximized` is ignored on iOS");
+        false
+    }
+
+    pub(crate) fn set_fullscreen(&self, monitor: Option<Fullscreen>) {
+        let uiscreen = match &monitor {
+            Some(Fullscreen::Exclusive(video_mode)) => {
+                let uiscreen = video_mode.monitor.ui_screen();
+                uiscreen.setCurrentMode(Some(&video_mode.screen_mode.0));
+                uiscreen.clone()
+            }
+            Some(Fullscreen::Borderless(Some(monitor))) => monitor.ui_screen().clone(),
+            Some(Fullscreen::Borderless(None)) => self.current_monitor_inner().ui_screen().clone(),
+            None => {
+                warn!("`Window::set_fullscreen(None)` ignored on iOS");
+                return;
+            }
+        };
+
+        // this is pretty slow on iOS, so avoid doing it if we can
+        let current = self.window.screen();
+        if uiscreen != current {
+            self.window.setScreen(&uiscreen);
+        }
+
+        let bounds = uiscreen.bounds();
+        self.window.setFrame(bounds);
+
+        // For external displays, we must disable overscan compensation or
+        // the displayed image will have giant black bars surrounding it on
+        // each side
+        uiscreen.setOverscanCompensation(UIScreenOverscanCompensation::None);
+    }
+
+    pub(crate) fn fullscreen(&self) -> Option<Fullscreen> {
+        unsafe {
+            let monitor = self.current_monitor_inner();
+            let uiscreen = monitor.ui_screen();
+            let screen_space_bounds = self.screen_frame();
+            let screen_bounds = uiscreen.bounds();
+
+            // TODO: track fullscreen instead of relying on brittle float comparisons
+            if screen_space_bounds.origin.x == screen_bounds.origin.x
+                && screen_space_bounds.origin.y == screen_bounds.origin.y
+                && screen_space_bounds.size.width == screen_bounds.size.width
+                && screen_space_bounds.size.height == screen_bounds.size.height
+            {
+                Some(Fullscreen::Borderless(Some(monitor)))
+            } else {
+                None
+            }
+        }
+    }
+
+    pub fn set_decorations(&self, _decorations: bool) {}
+
+    pub fn is_decorated(&self) -> bool {
+        true
+    }
+
+    pub fn set_window_level(&self, _level: WindowLevel) {
+        warn!("`Window::set_window_level` is ignored on iOS")
+    }
+
+    pub fn set_window_icon(&self, _icon: Option<Icon>) {
+        warn!("`Window::set_window_icon` is ignored on iOS")
+    }
+
+    pub fn set_ime_position(&self, _position: Position) {
+        warn!("`Window::set_ime_position` is ignored on iOS")
+    }
+
+    pub fn set_ime_allowed(&self, _allowed: bool) {
+        warn!("`Window::set_ime_allowed` is ignored on iOS")
+    }
+
+    pub fn set_ime_purpose(&self, _purpose: ImePurpose) {
+        warn!("`Window::set_ime_allowed` is ignored on iOS")
+    }
+
+    pub fn focus_window(&self) {
+        warn!("`Window::set_focus` is ignored on iOS")
+    }
+
+    pub fn request_user_attention(&self, _request_type: Option<UserAttentionType>) {
+        warn!("`Window::request_user_attention` is ignored on iOS")
+    }
+
+    // Allow directly accessing the current monitor internally without unwrapping.
+    fn current_monitor_inner(&self) -> MonitorHandle {
+        MonitorHandle::new(self.window.screen())
+    }
+
+    pub fn current_monitor(&self) -> Option<MonitorHandle> {
+        Some(self.current_monitor_inner())
+    }
+
+    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
+        monitor::uiscreens(MainThreadMarker::new().unwrap())
+    }
+
+    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
+        Some(MonitorHandle::new(UIScreen::main(
+            MainThreadMarker::new().unwrap(),
+        )))
+    }
+
+    pub fn id(&self) -> WindowId {
+        self.window.id()
+    }
+
+    pub fn raw_window_handle(&self) -> RawWindowHandle {
+        let mut window_handle = UiKitWindowHandle::empty();
+        window_handle.ui_window = Id::as_ptr(&self.window) as _;
+        window_handle.ui_view = Id::as_ptr(&self.view) as _;
+        window_handle.ui_view_controller = Id::as_ptr(&self.view_controller) as _;
+        RawWindowHandle::UiKit(window_handle)
+    }
+
+    pub fn raw_display_handle(&self) -> RawDisplayHandle {
+        RawDisplayHandle::UiKit(UiKitDisplayHandle::empty())
+    }
+
+    pub fn theme(&self) -> Option<Theme> {
+        warn!("`Window::theme` is ignored on iOS");
+        None
+    }
+
+    pub fn has_focus(&self) -> bool {
+        self.window.isKeyWindow()
+    }
+
+    #[inline]
+    pub fn set_theme(&self, _theme: Option<Theme>) {
+        warn!("`Window::set_theme` is ignored on iOS");
+    }
+
+    pub fn title(&self) -> String {
+        warn!("`Window::title` is ignored on iOS");
+        String::new()
+    }
+}
+
+pub struct Window {
+    pub inner: Inner,
+}
+
+impl Drop for Window {
+    fn drop(&mut self) {
+        assert_main_thread!("`Window::drop` can only be run on the main thread on iOS");
+    }
+}
+
+unsafe impl Send for Window {}
+unsafe impl Sync for Window {}
+
+impl Deref for Window {
+    type Target = Inner;
+
+    fn deref(&self) -> &Inner {
+        assert_main_thread!("`Window` methods can only be run on the main thread on iOS");
+        &self.inner
+    }
+}
+
+impl DerefMut for Window {
+    fn deref_mut(&mut self) -> &mut Inner {
+        assert_main_thread!("`Window` methods can only be run on the main thread on iOS");
+        &mut self.inner
+    }
+}
+
+impl Window {
+    pub(crate) fn new<T>(
+        _event_loop: &EventLoopWindowTarget<T>,
+        window_attributes: WindowAttributes,
+        platform_attributes: PlatformSpecificWindowBuilderAttributes,
+    ) -> Result<Window, RootOsError> {
+        let mtm = MainThreadMarker::new().unwrap();
+
+        if window_attributes.min_inner_size.is_some() {
+            warn!("`WindowAttributes::min_inner_size` is ignored on iOS");
+        }
+        if window_attributes.max_inner_size.is_some() {
+            warn!("`WindowAttributes::max_inner_size` is ignored on iOS");
+        }
+
+        // TODO: transparency, visible
+
+        let main_screen = UIScreen::main(mtm);
+        let fullscreen = window_attributes.fullscreen.clone().map(Into::into);
+        let screen = match fullscreen {
+            Some(Fullscreen::Exclusive(ref video_mode)) => video_mode.monitor.ui_screen(),
+            Some(Fullscreen::Borderless(Some(ref monitor))) => monitor.ui_screen(),
+            Some(Fullscreen::Borderless(None)) | None => &main_screen,
+        };
+
+        let screen_bounds = screen.bounds();
+
+        let frame = match window_attributes.inner_size {
+            Some(dim) => {
+                let scale_factor = screen.scale();
+                let size = dim.to_logical::<f64>(scale_factor as f64);
+                CGRect {
+                    origin: screen_bounds.origin,
+                    size: CGSize {
+                        width: size.width as _,
+                        height: size.height as _,
+                    },
+                }
+            }
+            None => screen_bounds,
+        };
+
+        let view = WinitView::new(mtm, &window_attributes, &platform_attributes, frame);
+
+        let gl_or_metal_backed = unsafe {
+            let layer_class = WinitView::layerClass();
+            let is_metal = msg_send![layer_class, isSubclassOfClass: class!(CAMetalLayer)];
+            let is_gl = msg_send![layer_class, isSubclassOfClass: class!(CAEAGLLayer)];
+            is_metal || is_gl
+        };
+
+        let view_controller =
+            WinitViewController::new(mtm, &window_attributes, &platform_attributes, &view);
+        let window = WinitUIWindow::new(
+            mtm,
+            &window_attributes,
+            &platform_attributes,
+            frame,
+            &view_controller,
+        );
+
+        unsafe { app_state::set_key_window(&window) };
+
+        // Like the Windows and macOS backends, we send a `ScaleFactorChanged` and `Resized`
+        // event on window creation if the DPI factor != 1.0
+        let scale_factor = view.contentScaleFactor();
+        let scale_factor = scale_factor as f64;
+        if scale_factor != 1.0 {
+            let bounds = view.bounds();
+            let screen = window.screen();
+            let screen_space = screen.coordinateSpace();
+            let screen_frame = view.convertRect_toCoordinateSpace(bounds, &screen_space);
+            let size = crate::dpi::LogicalSize {
+                width: screen_frame.size.width as _,
+                height: screen_frame.size.height as _,
+            };
+            let window_id = RootWindowId(window.id());
+            unsafe {
+                app_state::handle_nonuser_events(
+                    std::iter::once(EventWrapper::EventProxy(EventProxy::DpiChangedProxy {
+                        window: window.clone(),
+                        scale_factor,
+                        suggested_size: size,
+                    }))
+                    .chain(std::iter::once(EventWrapper::StaticEvent(
+                        Event::WindowEvent {
+                            window_id,
+                            event: WindowEvent::Resized(size.to_physical(scale_factor)),
+                        },
+                    ))),
+                );
+            }
+        }
+
+        Ok(Window {
+            inner: Inner {
+                window,
+                view_controller,
+                view,
+                gl_or_metal_backed,
+            },
+        })
+    }
+}
+
+// WindowExtIOS
+impl Inner {
+    pub fn ui_window(&self) -> *mut c_void {
+        Id::as_ptr(&self.window) as *mut c_void
+    }
+    pub fn ui_view_controller(&self) -> *mut c_void {
+        Id::as_ptr(&self.view_controller) as *mut c_void
+    }
+    pub fn ui_view(&self) -> *mut c_void {
+        Id::as_ptr(&self.view) as *mut c_void
+    }
+
+    pub fn set_scale_factor(&self, scale_factor: f64) {
+        assert!(
+            dpi::validate_scale_factor(scale_factor),
+            "`WindowExtIOS::set_scale_factor` received an invalid hidpi factor"
+        );
+        let scale_factor = scale_factor as CGFloat;
+        self.view.setContentScaleFactor(scale_factor);
+    }
+
+    pub fn set_valid_orientations(&self, valid_orientations: ValidOrientations) {
+        self.view_controller.set_supported_interface_orientations(
+            MainThreadMarker::new().unwrap(),
+            valid_orientations,
+        );
+    }
+
+    pub fn set_prefers_home_indicator_hidden(&self, hidden: bool) {
+        self.view_controller
+            .setPrefersHomeIndicatorAutoHidden(hidden);
+    }
+
+    pub fn set_preferred_screen_edges_deferring_system_gestures(&self, edges: ScreenEdge) {
+        let edges: UIRectEdge = edges.into();
+        self.view_controller
+            .setPreferredScreenEdgesDeferringSystemGestures(edges);
+    }
+
+    pub fn set_prefers_status_bar_hidden(&self, hidden: bool) {
+        self.view_controller.setPrefersStatusBarHidden(hidden);
+    }
+}
+
+impl Inner {
+    // requires main thread
+    unsafe fn screen_frame(&self) -> CGRect {
+        self.rect_to_screen_space(self.window.bounds())
+    }
+
+    // requires main thread
+    unsafe fn rect_to_screen_space(&self, rect: CGRect) -> CGRect {
+        let screen_space = self.window.screen().coordinateSpace();
+        self.window
+            .convertRect_toCoordinateSpace(rect, &screen_space)
+    }
+
+    // requires main thread
+    unsafe fn rect_from_screen_space(&self, rect: CGRect) -> CGRect {
+        let screen_space = self.window.screen().coordinateSpace();
+        self.window
+            .convertRect_fromCoordinateSpace(rect, &screen_space)
+    }
+
+    // requires main thread
+    unsafe fn safe_area_screen_space(&self) -> CGRect {
+        let bounds = self.window.bounds();
+        if app_state::os_capabilities().safe_area {
+            let safe_area = self.window.safeAreaInsets();
+            let safe_bounds = CGRect {
+                origin: CGPoint {
+                    x: bounds.origin.x + safe_area.left,
+                    y: bounds.origin.y + safe_area.top,
+                },
+                size: CGSize {
+                    width: bounds.size.width - safe_area.left - safe_area.right,
+                    height: bounds.size.height - safe_area.top - safe_area.bottom,
+                },
+            };
+            self.rect_to_screen_space(safe_bounds)
+        } else {
+            let screen_frame = self.rect_to_screen_space(bounds);
+            let status_bar_frame = {
+                let app = UIApplication::shared(MainThreadMarker::new().unwrap_unchecked()).expect(
+                    "`Window::get_inner_position` cannot be called before `EventLoop::run` on iOS",
+                );
+                app.statusBarFrame()
+            };
+            let (y, height) = if screen_frame.origin.y > status_bar_frame.size.height {
+                (screen_frame.origin.y, screen_frame.size.height)
+            } else {
+                let y = status_bar_frame.size.height;
+                let height = screen_frame.size.height
+                    - (status_bar_frame.size.height - screen_frame.origin.y);
+                (y, height)
+            };
+            CGRect {
+                origin: CGPoint {
+                    x: screen_frame.origin.x,
+                    y,
+                },
+                size: CGSize {
+                    width: screen_frame.size.width,
+                    height,
+                },
+            }
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct WindowId {
+    window: *mut WinitUIWindow,
+}
+
+impl WindowId {
+    pub const unsafe fn dummy() -> Self {
+        WindowId {
+            window: std::ptr::null_mut(),
+        }
+    }
+}
+
+impl From<WindowId> for u64 {
+    fn from(window_id: WindowId) -> Self {
+        window_id.window as u64
+    }
+}
+
+impl From<u64> for WindowId {
+    fn from(raw_id: u64) -> Self {
+        Self {
+            window: raw_id as _,
+        }
+    }
+}
+
+unsafe impl Send for WindowId {}
+unsafe impl Sync for WindowId {}
+
+impl From<&Object> for WindowId {
+    fn from(window: &Object) -> WindowId {
+        WindowId {
+            window: window as *const _ as _,
+        }
+    }
+}
+
+#[derive(Clone, Default)]
+pub struct PlatformSpecificWindowBuilderAttributes {
+    pub scale_factor: Option<f64>,
+    pub valid_orientations: ValidOrientations,
+    pub prefers_home_indicator_hidden: bool,
+    pub prefers_status_bar_hidden: bool,
+    pub preferred_screen_edges_deferring_system_gestures: ScreenEdge,
+}

third-party/vendor/winit/src/platform_impl/linux/mod.rs

@@ -0,0 +1,905 @@
+#![cfg(free_unix)]
+
+#[cfg(all(not(x11_platform), not(wayland_platform)))]
+compile_error!("Please select a feature to build for unix: `x11`, `wayland`");
+
+#[cfg(wayland_platform)]
+use std::error::Error;
+
+use std::{collections::VecDeque, env, fmt};
+#[cfg(x11_platform)]
+use std::{
+    ffi::CStr,
+    mem::MaybeUninit,
+    os::raw::*,
+    sync::{Arc, Mutex},
+};
+
+#[cfg(x11_platform)]
+use once_cell::sync::Lazy;
+use raw_window_handle::{RawDisplayHandle, RawWindowHandle};
+
+#[cfg(x11_platform)]
+pub use self::x11::XNotSupported;
+#[cfg(x11_platform)]
+use self::x11::{ffi::XVisualInfo, util::WindowType as XWindowType, XConnection, XError};
+#[cfg(x11_platform)]
+use crate::platform::x11::XlibErrorHook;
+use crate::{
+    dpi::{PhysicalPosition, PhysicalSize, Position, Size},
+    error::{ExternalError, NotSupportedError, OsError as RootOsError},
+    event::Event,
+    event_loop::{
+        ControlFlow, DeviceEventFilter, EventLoopClosed, EventLoopWindowTarget as RootELW,
+    },
+    icon::Icon,
+    window::{
+        CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
+        WindowAttributes, WindowButtons, WindowLevel,
+    },
+};
+
+pub(crate) use crate::icon::RgbaIcon as PlatformIcon;
+pub(self) use crate::platform_impl::Fullscreen;
+
+#[cfg(wayland_platform)]
+pub mod wayland;
+#[cfg(x11_platform)]
+pub mod x11;
+
+/// Environment variable specifying which backend should be used on unix platform.
+///
+/// Legal values are x11 and wayland. If this variable is set only the named backend
+/// will be tried by winit. If it is not set, winit will try to connect to a wayland connection,
+/// and if it fails will fallback on x11.
+///
+/// If this variable is set with any other value, winit will panic.
+const BACKEND_PREFERENCE_ENV_VAR: &str = "WINIT_UNIX_BACKEND";
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub(crate) enum Backend {
+    #[cfg(x11_platform)]
+    X,
+    #[cfg(wayland_platform)]
+    Wayland,
+}
+
+#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Hash)]
+pub(crate) struct PlatformSpecificEventLoopAttributes {
+    pub(crate) forced_backend: Option<Backend>,
+    pub(crate) any_thread: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ApplicationName {
+    pub general: String,
+    pub instance: String,
+}
+
+impl ApplicationName {
+    pub fn new(general: String, instance: String) -> Self {
+        Self { general, instance }
+    }
+}
+
+#[derive(Clone)]
+pub struct PlatformSpecificWindowBuilderAttributes {
+    pub name: Option<ApplicationName>,
+    #[cfg(x11_platform)]
+    pub visual_infos: Option<XVisualInfo>,
+    #[cfg(x11_platform)]
+    pub screen_id: Option<i32>,
+    #[cfg(x11_platform)]
+    pub base_size: Option<Size>,
+    #[cfg(x11_platform)]
+    pub override_redirect: bool,
+    #[cfg(x11_platform)]
+    pub x11_window_types: Vec<XWindowType>,
+}
+
+impl Default for PlatformSpecificWindowBuilderAttributes {
+    fn default() -> Self {
+        Self {
+            name: None,
+            #[cfg(x11_platform)]
+            visual_infos: None,
+            #[cfg(x11_platform)]
+            screen_id: None,
+            #[cfg(x11_platform)]
+            base_size: None,
+            #[cfg(x11_platform)]
+            override_redirect: false,
+            #[cfg(x11_platform)]
+            x11_window_types: vec![XWindowType::Normal],
+        }
+    }
+}
+
+#[cfg(x11_platform)]
+pub(crate) static X11_BACKEND: Lazy<Mutex<Result<Arc<XConnection>, XNotSupported>>> =
+    Lazy::new(|| Mutex::new(XConnection::new(Some(x_error_callback)).map(Arc::new)));
+
+#[derive(Debug, Clone)]
+pub enum OsError {
+    #[cfg(x11_platform)]
+    XError(XError),
+    #[cfg(x11_platform)]
+    XMisc(&'static str),
+    #[cfg(wayland_platform)]
+    WaylandMisc(&'static str),
+}
+
+impl fmt::Display for OsError {
+    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        match *self {
+            #[cfg(x11_platform)]
+            OsError::XError(ref e) => _f.pad(&e.description),
+            #[cfg(x11_platform)]
+            OsError::XMisc(e) => _f.pad(e),
+            #[cfg(wayland_platform)]
+            OsError::WaylandMisc(e) => _f.pad(e),
+        }
+    }
+}
+
+pub(crate) enum Window {
+    #[cfg(x11_platform)]
+    X(x11::Window),
+    #[cfg(wayland_platform)]
+    Wayland(wayland::Window),
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct WindowId(u64);
+
+impl From<WindowId> for u64 {
+    fn from(window_id: WindowId) -> Self {
+        window_id.0
+    }
+}
+
+impl From<u64> for WindowId {
+    fn from(raw_id: u64) -> Self {
+        Self(raw_id)
+    }
+}
+
+impl WindowId {
+    pub const unsafe fn dummy() -> Self {
+        Self(0)
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum DeviceId {
+    #[cfg(x11_platform)]
+    X(x11::DeviceId),
+    #[cfg(wayland_platform)]
+    Wayland(wayland::DeviceId),
+}
+
+impl DeviceId {
+    pub const unsafe fn dummy() -> Self {
+        #[cfg(wayland_platform)]
+        return DeviceId::Wayland(wayland::DeviceId::dummy());
+        #[cfg(all(not(wayland_platform), x11_platform))]
+        return DeviceId::X(x11::DeviceId::dummy());
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum MonitorHandle {
+    #[cfg(x11_platform)]
+    X(x11::MonitorHandle),
+    #[cfg(wayland_platform)]
+    Wayland(wayland::MonitorHandle),
+}
+
+/// `x11_or_wayland!(match expr; Enum(foo) => foo.something())`
+/// expands to the equivalent of
+/// ```ignore
+/// match self {
+///    Enum::X(foo) => foo.something(),
+///    Enum::Wayland(foo) => foo.something(),
+/// }
+/// ```
+/// The result can be converted to another enum by adding `; as AnotherEnum`
+macro_rules! x11_or_wayland {
+    (match $what:expr; $enum:ident ( $($c1:tt)* ) => $x:expr; as $enum2:ident ) => {
+        match $what {
+            #[cfg(x11_platform)]
+            $enum::X($($c1)*) => $enum2::X($x),
+            #[cfg(wayland_platform)]
+            $enum::Wayland($($c1)*) => $enum2::Wayland($x),
+        }
+    };
+    (match $what:expr; $enum:ident ( $($c1:tt)* ) => $x:expr) => {
+        match $what {
+            #[cfg(x11_platform)]
+            $enum::X($($c1)*) => $x,
+            #[cfg(wayland_platform)]
+            $enum::Wayland($($c1)*) => $x,
+        }
+    };
+}
+
+impl MonitorHandle {
+    #[inline]
+    pub fn name(&self) -> Option<String> {
+        x11_or_wayland!(match self; MonitorHandle(m) => m.name())
+    }
+
+    #[inline]
+    pub fn native_identifier(&self) -> u32 {
+        x11_or_wayland!(match self; MonitorHandle(m) => m.native_identifier())
+    }
+
+    #[inline]
+    pub fn size(&self) -> PhysicalSize<u32> {
+        x11_or_wayland!(match self; MonitorHandle(m) => m.size())
+    }
+
+    #[inline]
+    pub fn position(&self) -> PhysicalPosition<i32> {
+        x11_or_wayland!(match self; MonitorHandle(m) => m.position())
+    }
+
+    #[inline]
+    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
+        x11_or_wayland!(match self; MonitorHandle(m) => m.refresh_rate_millihertz())
+    }
+
+    #[inline]
+    pub fn scale_factor(&self) -> f64 {
+        x11_or_wayland!(match self; MonitorHandle(m) => m.scale_factor() as _)
+    }
+
+    #[inline]
+    pub fn video_modes(&self) -> Box<dyn Iterator<Item = VideoMode>> {
+        x11_or_wayland!(match self; MonitorHandle(m) => Box::new(m.video_modes()))
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum VideoMode {
+    #[cfg(x11_platform)]
+    X(x11::VideoMode),
+    #[cfg(wayland_platform)]
+    Wayland(wayland::VideoMode),
+}
+
+impl VideoMode {
+    #[inline]
+    pub fn size(&self) -> PhysicalSize<u32> {
+        x11_or_wayland!(match self; VideoMode(m) => m.size())
+    }
+
+    #[inline]
+    pub fn bit_depth(&self) -> u16 {
+        x11_or_wayland!(match self; VideoMode(m) => m.bit_depth())
+    }
+
+    #[inline]
+    pub fn refresh_rate_millihertz(&self) -> u32 {
+        x11_or_wayland!(match self; VideoMode(m) => m.refresh_rate_millihertz())
+    }
+
+    #[inline]
+    pub fn monitor(&self) -> MonitorHandle {
+        x11_or_wayland!(match self; VideoMode(m) => m.monitor())
+    }
+}
+
+impl Window {
+    #[inline]
+    pub(crate) fn new<T>(
+        window_target: &EventLoopWindowTarget<T>,
+        attribs: WindowAttributes,
+        pl_attribs: PlatformSpecificWindowBuilderAttributes,
+    ) -> Result<Self, RootOsError> {
+        match *window_target {
+            #[cfg(wayland_platform)]
+            EventLoopWindowTarget::Wayland(ref window_target) => {
+                wayland::Window::new(window_target, attribs, pl_attribs).map(Window::Wayland)
+            }
+            #[cfg(x11_platform)]
+            EventLoopWindowTarget::X(ref window_target) => {
+                x11::Window::new(window_target, attribs, pl_attribs).map(Window::X)
+            }
+        }
+    }
+
+    #[inline]
+    pub fn id(&self) -> WindowId {
+        match self {
+            #[cfg(wayland_platform)]
+            Self::Wayland(window) => window.id(),
+            #[cfg(x11_platform)]
+            Self::X(window) => window.id(),
+        }
+    }
+
+    #[inline]
+    pub fn set_title(&self, title: &str) {
+        x11_or_wayland!(match self; Window(w) => w.set_title(title));
+    }
+
+    #[inline]
+    pub fn set_transparent(&self, transparent: bool) {
+        x11_or_wayland!(match self; Window(w) => w.set_transparent(transparent));
+    }
+
+    #[inline]
+    pub fn set_visible(&self, visible: bool) {
+        x11_or_wayland!(match self; Window(w) => w.set_visible(visible))
+    }
+
+    #[inline]
+    pub fn is_visible(&self) -> Option<bool> {
+        x11_or_wayland!(match self; Window(w) => w.is_visible())
+    }
+
+    #[inline]
+    pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
+        x11_or_wayland!(match self; Window(w) => w.outer_position())
+    }
+
+    #[inline]
+    pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
+        x11_or_wayland!(match self; Window(w) => w.inner_position())
+    }
+
+    #[inline]
+    pub fn set_outer_position(&self, position: Position) {
+        x11_or_wayland!(match self; Window(w) => w.set_outer_position(position))
+    }
+
+    #[inline]
+    pub fn inner_size(&self) -> PhysicalSize<u32> {
+        x11_or_wayland!(match self; Window(w) => w.inner_size())
+    }
+
+    #[inline]
+    pub fn outer_size(&self) -> PhysicalSize<u32> {
+        x11_or_wayland!(match self; Window(w) => w.outer_size())
+    }
+
+    #[inline]
+    pub fn set_inner_size(&self, size: Size) {
+        x11_or_wayland!(match self; Window(w) => w.set_inner_size(size))
+    }
+
+    #[inline]
+    pub fn set_min_inner_size(&self, dimensions: Option<Size>) {
+        x11_or_wayland!(match self; Window(w) => w.set_min_inner_size(dimensions))
+    }
+
+    #[inline]
+    pub fn set_max_inner_size(&self, dimensions: Option<Size>) {
+        x11_or_wayland!(match self; Window(w) => w.set_max_inner_size(dimensions))
+    }
+
+    #[inline]
+    pub fn resize_increments(&self) -> Option<PhysicalSize<u32>> {
+        x11_or_wayland!(match self; Window(w) => w.resize_increments())
+    }
+
+    #[inline]
+    pub fn set_resize_increments(&self, increments: Option<Size>) {
+        x11_or_wayland!(match self; Window(w) => w.set_resize_increments(increments))
+    }
+
+    #[inline]
+    pub fn set_resizable(&self, resizable: bool) {
+        x11_or_wayland!(match self; Window(w) => w.set_resizable(resizable))
+    }
+
+    #[inline]
+    pub fn is_resizable(&self) -> bool {
+        x11_or_wayland!(match self; Window(w) => w.is_resizable())
+    }
+
+    #[inline]
+    pub fn set_enabled_buttons(&self, buttons: WindowButtons) {
+        x11_or_wayland!(match self; Window(w) => w.set_enabled_buttons(buttons))
+    }
+
+    #[inline]
+    pub fn enabled_buttons(&self) -> WindowButtons {
+        x11_or_wayland!(match self; Window(w) => w.enabled_buttons())
+    }
+
+    #[inline]
+    pub fn set_cursor_icon(&self, cursor: CursorIcon) {
+        x11_or_wayland!(match self; Window(w) => w.set_cursor_icon(cursor))
+    }
+
+    #[inline]
+    pub fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), ExternalError> {
+        x11_or_wayland!(match self; Window(window) => window.set_cursor_grab(mode))
+    }
+
+    #[inline]
+    pub fn set_cursor_visible(&self, visible: bool) {
+        x11_or_wayland!(match self; Window(window) => window.set_cursor_visible(visible))
+    }
+
+    #[inline]
+    pub fn drag_window(&self) -> Result<(), ExternalError> {
+        x11_or_wayland!(match self; Window(window) => window.drag_window())
+    }
+
+    #[inline]
+    pub fn drag_resize_window(&self, direction: ResizeDirection) -> Result<(), ExternalError> {
+        x11_or_wayland!(match self; Window(window) => window.drag_resize_window(direction))
+    }
+
+    #[inline]
+    pub fn set_cursor_hittest(&self, hittest: bool) -> Result<(), ExternalError> {
+        x11_or_wayland!(match self; Window(w) => w.set_cursor_hittest(hittest))
+    }
+
+    #[inline]
+    pub fn scale_factor(&self) -> f64 {
+        x11_or_wayland!(match self; Window(w) => w.scale_factor())
+    }
+
+    #[inline]
+    pub fn set_cursor_position(&self, position: Position) -> Result<(), ExternalError> {
+        x11_or_wayland!(match self; Window(w) => w.set_cursor_position(position))
+    }
+
+    #[inline]
+    pub fn set_maximized(&self, maximized: bool) {
+        x11_or_wayland!(match self; Window(w) => w.set_maximized(maximized))
+    }
+
+    #[inline]
+    pub fn is_maximized(&self) -> bool {
+        x11_or_wayland!(match self; Window(w) => w.is_maximized())
+    }
+
+    #[inline]
+    pub fn set_minimized(&self, minimized: bool) {
+        x11_or_wayland!(match self; Window(w) => w.set_minimized(minimized))
+    }
+
+    #[inline]
+    pub fn is_minimized(&self) -> Option<bool> {
+        x11_or_wayland!(match self; Window(w) => w.is_minimized())
+    }
+
+    #[inline]
+    pub(crate) fn fullscreen(&self) -> Option<Fullscreen> {
+        x11_or_wayland!(match self; Window(w) => w.fullscreen())
+    }
+
+    #[inline]
+    pub(crate) fn set_fullscreen(&self, monitor: Option<Fullscreen>) {
+        x11_or_wayland!(match self; Window(w) => w.set_fullscreen(monitor))
+    }
+
+    #[inline]
+    pub fn set_decorations(&self, decorations: bool) {
+        x11_or_wayland!(match self; Window(w) => w.set_decorations(decorations))
+    }
+
+    #[inline]
+    pub fn is_decorated(&self) -> bool {
+        x11_or_wayland!(match self; Window(w) => w.is_decorated())
+    }
+
+    #[inline]
+    pub fn set_window_level(&self, _level: WindowLevel) {
+        match self {
+            #[cfg(x11_platform)]
+            Window::X(ref w) => w.set_window_level(_level),
+            #[cfg(wayland_platform)]
+            Window::Wayland(_) => (),
+        }
+    }
+
+    #[inline]
+    pub fn set_window_icon(&self, _window_icon: Option<Icon>) {
+        match self {
+            #[cfg(x11_platform)]
+            Window::X(ref w) => w.set_window_icon(_window_icon),
+            #[cfg(wayland_platform)]
+            Window::Wayland(_) => (),
+        }
+    }
+
+    #[inline]
+    pub fn set_ime_position(&self, position: Position) {
+        x11_or_wayland!(match self; Window(w) => w.set_ime_position(position))
+    }
+
+    #[inline]
+    pub fn set_ime_allowed(&self, allowed: bool) {
+        x11_or_wayland!(match self; Window(w) => w.set_ime_allowed(allowed))
+    }
+
+    #[inline]
+    pub fn set_ime_purpose(&self, purpose: ImePurpose) {
+        x11_or_wayland!(match self; Window(w) => w.set_ime_purpose(purpose))
+    }
+
+    #[inline]
+    pub fn focus_window(&self) {
+        match self {
+            #[cfg(x11_platform)]
+            Window::X(ref w) => w.focus_window(),
+            #[cfg(wayland_platform)]
+            Window::Wayland(_) => (),
+        }
+    }
+    pub fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
+        match self {
+            #[cfg(x11_platform)]
+            Window::X(ref w) => w.request_user_attention(request_type),
+            #[cfg(wayland_platform)]
+            Window::Wayland(ref w) => w.request_user_attention(request_type),
+        }
+    }
+
+    #[inline]
+    pub fn request_redraw(&self) {
+        x11_or_wayland!(match self; Window(w) => w.request_redraw())
+    }
+
+    #[inline]
+    pub fn current_monitor(&self) -> Option<MonitorHandle> {
+        match self {
+            #[cfg(x11_platform)]
+            Window::X(ref window) => {
+                let current_monitor = MonitorHandle::X(window.current_monitor());
+                Some(current_monitor)
+            }
+            #[cfg(wayland_platform)]
+            Window::Wayland(ref window) => {
+                let current_monitor = MonitorHandle::Wayland(window.current_monitor()?);
+                Some(current_monitor)
+            }
+        }
+    }
+
+    #[inline]
+    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
+        match self {
+            #[cfg(x11_platform)]
+            Window::X(ref window) => window
+                .available_monitors()
+                .into_iter()
+                .map(MonitorHandle::X)
+                .collect(),
+            #[cfg(wayland_platform)]
+            Window::Wayland(ref window) => window
+                .available_monitors()
+                .into_iter()
+                .map(MonitorHandle::Wayland)
+                .collect(),
+        }
+    }
+
+    #[inline]
+    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
+        match self {
+            #[cfg(x11_platform)]
+            Window::X(ref window) => {
+                let primary_monitor = MonitorHandle::X(window.primary_monitor());
+                Some(primary_monitor)
+            }
+            #[cfg(wayland_platform)]
+            Window::Wayland(ref window) => window.primary_monitor(),
+        }
+    }
+
+    #[inline]
+    pub fn raw_window_handle(&self) -> RawWindowHandle {
+        x11_or_wayland!(match self; Window(window) => window.raw_window_handle())
+    }
+
+    #[inline]
+    pub fn raw_display_handle(&self) -> RawDisplayHandle {
+        x11_or_wayland!(match self; Window(window) => window.raw_display_handle())
+    }
+
+    #[inline]
+    pub fn set_theme(&self, theme: Option<Theme>) {
+        x11_or_wayland!(match self; Window(window) => window.set_theme(theme))
+    }
+
+    #[inline]
+    pub fn theme(&self) -> Option<Theme> {
+        x11_or_wayland!(match self; Window(window) => window.theme())
+    }
+
+    #[inline]
+    pub fn has_focus(&self) -> bool {
+        x11_or_wayland!(match self; Window(window) => window.has_focus())
+    }
+
+    pub fn title(&self) -> String {
+        x11_or_wayland!(match self; Window(window) => window.title())
+    }
+}
+
+/// Hooks for X11 errors.
+#[cfg(x11_platform)]
+pub(crate) static mut XLIB_ERROR_HOOKS: Lazy<Mutex<Vec<XlibErrorHook>>> =
+    Lazy::new(|| Mutex::new(Vec::new()));
+
+#[cfg(x11_platform)]
+unsafe extern "C" fn x_error_callback(
+    display: *mut x11::ffi::Display,
+    event: *mut x11::ffi::XErrorEvent,
+) -> c_int {
+    let xconn_lock = X11_BACKEND.lock().unwrap();
+    if let Ok(ref xconn) = *xconn_lock {
+        // Call all the hooks.
+        let mut error_handled = false;
+        for hook in XLIB_ERROR_HOOKS.lock().unwrap().iter() {
+            error_handled |= hook(display as *mut _, event as *mut _);
+        }
+
+        // `assume_init` is safe here because the array consists of `MaybeUninit` values,
+        // which do not require initialization.
+        let mut buf: [MaybeUninit<c_char>; 1024] = MaybeUninit::uninit().assume_init();
+        (xconn.xlib.XGetErrorText)(
+            display,
+            (*event).error_code as c_int,
+            buf.as_mut_ptr() as *mut c_char,
+            buf.len() as c_int,
+        );
+        let description = CStr::from_ptr(buf.as_ptr() as *const c_char).to_string_lossy();
+
+        let error = XError {
+            description: description.into_owned(),
+            error_code: (*event).error_code,
+            request_code: (*event).request_code,
+            minor_code: (*event).minor_code,
+        };
+
+        // Don't log error.
+        if !error_handled {
+            error!("X11 error: {:#?}", error);
+            // XXX only update the error, if it wasn't handled by any of the hooks.
+            *xconn.latest_error.lock().unwrap() = Some(error);
+        }
+    }
+    // Fun fact: this return value is completely ignored.
+    0
+}
+
+pub enum EventLoop<T: 'static> {
+    #[cfg(wayland_platform)]
+    Wayland(Box<wayland::EventLoop<T>>),
+    #[cfg(x11_platform)]
+    X(x11::EventLoop<T>),
+}
+
+pub enum EventLoopProxy<T: 'static> {
+    #[cfg(x11_platform)]
+    X(x11::EventLoopProxy<T>),
+    #[cfg(wayland_platform)]
+    Wayland(wayland::EventLoopProxy<T>),
+}
+
+impl<T: 'static> Clone for EventLoopProxy<T> {
+    fn clone(&self) -> Self {
+        x11_or_wayland!(match self; EventLoopProxy(proxy) => proxy.clone(); as EventLoopProxy)
+    }
+}
+
+impl<T: 'static> EventLoop<T> {
+    pub(crate) fn new(attributes: &PlatformSpecificEventLoopAttributes) -> Self {
+        if !attributes.any_thread && !is_main_thread() {
+            panic!(
+                "Initializing the event loop outside of the main thread is a significant \
+                 cross-platform compatibility hazard. If you absolutely need to create an \
+                 EventLoop on a different thread, you can use the \
+                 `EventLoopBuilderExtUnix::any_thread` function."
+            );
+        }
+
+        #[cfg(x11_platform)]
+        if attributes.forced_backend == Some(Backend::X) {
+            // TODO: Propagate
+            return EventLoop::new_x11_any_thread().unwrap();
+        }
+
+        #[cfg(wayland_platform)]
+        if attributes.forced_backend == Some(Backend::Wayland) {
+            // TODO: Propagate
+            return EventLoop::new_wayland_any_thread().expect("failed to open Wayland connection");
+        }
+
+        if let Ok(env_var) = env::var(BACKEND_PREFERENCE_ENV_VAR) {
+            match env_var.as_str() {
+                "x11" => {
+                    // TODO: propagate
+                    #[cfg(x11_platform)]
+                    return EventLoop::new_x11_any_thread()
+                        .expect("Failed to initialize X11 backend");
+                    #[cfg(not(x11_platform))]
+                    panic!("x11 feature is not enabled")
+                }
+                "wayland" => {
+                    #[cfg(wayland_platform)]
+                    return EventLoop::new_wayland_any_thread()
+                        .expect("Failed to initialize Wayland backend");
+                    #[cfg(not(wayland_platform))]
+                    panic!("wayland feature is not enabled");
+                }
+                _ => panic!(
+                    "Unknown environment variable value for {BACKEND_PREFERENCE_ENV_VAR}, try one of `x11`,`wayland`",
+                ),
+            }
+        }
+
+        #[cfg(wayland_platform)]
+        let wayland_err = match EventLoop::new_wayland_any_thread() {
+            Ok(event_loop) => return event_loop,
+            Err(err) => err,
+        };
+
+        #[cfg(x11_platform)]
+        let x11_err = match EventLoop::new_x11_any_thread() {
+            Ok(event_loop) => return event_loop,
+            Err(err) => err,
+        };
+
+        #[cfg(not(wayland_platform))]
+        let wayland_err = "backend disabled";
+        #[cfg(not(x11_platform))]
+        let x11_err = "backend disabled";
+
+        panic!(
+            "Failed to initialize any backend! Wayland status: {wayland_err:?} X11 status: {x11_err:?}",
+        );
+    }
+
+    #[cfg(wayland_platform)]
+    fn new_wayland_any_thread() -> Result<EventLoop<T>, Box<dyn Error>> {
+        wayland::EventLoop::new().map(|evlp| EventLoop::Wayland(Box::new(evlp)))
+    }
+
+    #[cfg(x11_platform)]
+    fn new_x11_any_thread() -> Result<EventLoop<T>, XNotSupported> {
+        let xconn = match X11_BACKEND.lock().unwrap().as_ref() {
+            Ok(xconn) => xconn.clone(),
+            Err(err) => return Err(err.clone()),
+        };
+
+        Ok(EventLoop::X(x11::EventLoop::new(xconn)))
+    }
+
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+        x11_or_wayland!(match self; EventLoop(evlp) => evlp.create_proxy(); as EventLoopProxy)
+    }
+
+    pub fn run_return<F>(&mut self, callback: F) -> i32
+    where
+        F: FnMut(crate::event::Event<'_, T>, &RootELW<T>, &mut ControlFlow),
+    {
+        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_return(callback))
+    }
+
+    pub fn run<F>(self, callback: F) -> !
+    where
+        F: 'static + FnMut(crate::event::Event<'_, T>, &RootELW<T>, &mut ControlFlow),
+    {
+        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run(callback))
+    }
+
+    pub fn window_target(&self) -> &crate::event_loop::EventLoopWindowTarget<T> {
+        x11_or_wayland!(match self; EventLoop(evlp) => evlp.window_target())
+    }
+}
+
+impl<T: 'static> EventLoopProxy<T> {
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+        x11_or_wayland!(match self; EventLoopProxy(proxy) => proxy.send_event(event))
+    }
+}
+
+pub enum EventLoopWindowTarget<T> {
+    #[cfg(wayland_platform)]
+    Wayland(wayland::EventLoopWindowTarget<T>),
+    #[cfg(x11_platform)]
+    X(x11::EventLoopWindowTarget<T>),
+}
+
+impl<T> EventLoopWindowTarget<T> {
+    #[inline]
+    pub fn is_wayland(&self) -> bool {
+        match *self {
+            #[cfg(wayland_platform)]
+            EventLoopWindowTarget::Wayland(_) => true,
+            #[cfg(x11_platform)]
+            _ => false,
+        }
+    }
+
+    #[inline]
+    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
+        match *self {
+            #[cfg(wayland_platform)]
+            EventLoopWindowTarget::Wayland(ref evlp) => evlp
+                .available_monitors()
+                .into_iter()
+                .map(MonitorHandle::Wayland)
+                .collect(),
+            #[cfg(x11_platform)]
+            EventLoopWindowTarget::X(ref evlp) => evlp
+                .x_connection()
+                .available_monitors()
+                .into_iter()
+                .map(MonitorHandle::X)
+                .collect(),
+        }
+    }
+
+    #[inline]
+    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
+        match *self {
+            #[cfg(wayland_platform)]
+            EventLoopWindowTarget::Wayland(ref evlp) => evlp.primary_monitor(),
+            #[cfg(x11_platform)]
+            EventLoopWindowTarget::X(ref evlp) => {
+                let primary_monitor = MonitorHandle::X(evlp.x_connection().primary_monitor());
+                Some(primary_monitor)
+            }
+        }
+    }
+
+    #[inline]
+    pub fn set_device_event_filter(&self, _filter: DeviceEventFilter) {
+        match *self {
+            #[cfg(wayland_platform)]
+            EventLoopWindowTarget::Wayland(_) => (),
+            #[cfg(x11_platform)]
+            EventLoopWindowTarget::X(ref evlp) => evlp.set_device_event_filter(_filter),
+        }
+    }
+
+    pub fn raw_display_handle(&self) -> raw_window_handle::RawDisplayHandle {
+        x11_or_wayland!(match self; Self(evlp) => evlp.raw_display_handle())
+    }
+}
+
+fn sticky_exit_callback<T, F>(
+    evt: Event<'_, T>,
+    target: &RootELW<T>,
+    control_flow: &mut ControlFlow,
+    callback: &mut F,
+) where
+    F: FnMut(Event<'_, T>, &RootELW<T>, &mut ControlFlow),
+{
+    // make ControlFlow::ExitWithCode sticky by providing a dummy
+    // control flow reference if it is already ExitWithCode.
+    if let ControlFlow::ExitWithCode(code) = *control_flow {
+        callback(evt, target, &mut ControlFlow::ExitWithCode(code))
+    } else {
+        callback(evt, target, control_flow)
+    }
+}
+
+#[cfg(target_os = "linux")]
+fn is_main_thread() -> bool {
+    use libc::{c_long, getpid, syscall, SYS_gettid};
+
+    unsafe { syscall(SYS_gettid) == getpid() as c_long }
+}
+
+#[cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
+fn is_main_thread() -> bool {
+    use libc::pthread_main_np;
+
+    unsafe { pthread_main_np() == 1 }
+}
+
+#[cfg(target_os = "netbsd")]
+fn is_main_thread() -> bool {
+    std::thread::current().name() == Some("main")
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/env.rs

@@ -0,0 +1,183 @@
+//! SCTK environment setup.
+
+use sctk::reexports::client::protocol::wl_compositor::WlCompositor;
+use sctk::reexports::client::protocol::wl_output::WlOutput;
+use sctk::reexports::protocols::unstable::xdg_shell::v6::client::zxdg_shell_v6::ZxdgShellV6;
+use sctk::reexports::client::protocol::wl_seat::WlSeat;
+use sctk::reexports::protocols::unstable::xdg_decoration::v1::client::zxdg_decoration_manager_v1::ZxdgDecorationManagerV1;
+use sctk::reexports::client::protocol::wl_shell::WlShell;
+use sctk::reexports::client::protocol::wl_subcompositor::WlSubcompositor;
+use sctk::reexports::client::{Attached, DispatchData};
+use sctk::reexports::client::protocol::wl_shm::WlShm;
+use sctk::reexports::protocols::xdg_shell::client::xdg_wm_base::XdgWmBase;
+use sctk::reexports::protocols::unstable::relative_pointer::v1::client::zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1;
+use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_pointer_constraints_v1::ZwpPointerConstraintsV1;
+use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input_manager_v3::ZwpTextInputManagerV3;
+use sctk::reexports::protocols::staging::xdg_activation::v1::client::xdg_activation_v1::XdgActivationV1;
+use sctk::reexports::protocols::viewporter::client::wp_viewporter::WpViewporter;
+
+use sctk::environment::{Environment, SimpleGlobal};
+use sctk::output::{OutputHandler, OutputHandling, OutputInfo, OutputStatusListener};
+use sctk::seat::{SeatData, SeatHandler, SeatHandling, SeatListener};
+use sctk::shell::{Shell, ShellHandler, ShellHandling};
+use sctk::shm::ShmHandler;
+
+use crate::platform_impl::wayland::protocols::wp_fractional_scale_manager_v1::WpFractionalScaleManagerV1;
+
+/// Set of extra features that are supported by the compositor.
+#[derive(Debug, Clone, Copy)]
+pub struct WindowingFeatures {
+    pointer_constraints: bool,
+    xdg_activation: bool,
+}
+
+impl WindowingFeatures {
+    /// Create `WindowingFeatures` based on the presented interfaces.
+    pub fn new(env: &Environment<WinitEnv>) -> Self {
+        let pointer_constraints = env.get_global::<ZwpPointerConstraintsV1>().is_some();
+        let xdg_activation = env.get_global::<XdgActivationV1>().is_some();
+        Self {
+            pointer_constraints,
+            xdg_activation,
+        }
+    }
+
+    pub fn pointer_constraints(&self) -> bool {
+        self.pointer_constraints
+    }
+
+    pub fn xdg_activation(&self) -> bool {
+        self.xdg_activation
+    }
+}
+
+sctk::environment!(WinitEnv,
+    singles = [
+        WlShm => shm,
+        WlCompositor => compositor,
+        WlSubcompositor => subcompositor,
+        WlShell => shell,
+        XdgWmBase => shell,
+        ZxdgShellV6 => shell,
+        ZxdgDecorationManagerV1 => decoration_manager,
+        ZwpRelativePointerManagerV1 => relative_pointer_manager,
+        ZwpPointerConstraintsV1 => pointer_constraints,
+        ZwpTextInputManagerV3 => text_input_manager,
+        XdgActivationV1 => xdg_activation,
+        WpFractionalScaleManagerV1 => fractional_scale_manager,
+        WpViewporter => viewporter,
+    ],
+    multis = [
+        WlSeat => seats,
+        WlOutput => outputs,
+    ]
+);
+
+/// The environment that we utilize.
+pub struct WinitEnv {
+    seats: SeatHandler,
+
+    outputs: OutputHandler,
+
+    shm: ShmHandler,
+
+    compositor: SimpleGlobal<WlCompositor>,
+
+    subcompositor: SimpleGlobal<WlSubcompositor>,
+
+    shell: ShellHandler,
+
+    relative_pointer_manager: SimpleGlobal<ZwpRelativePointerManagerV1>,
+
+    pointer_constraints: SimpleGlobal<ZwpPointerConstraintsV1>,
+
+    text_input_manager: SimpleGlobal<ZwpTextInputManagerV3>,
+
+    decoration_manager: SimpleGlobal<ZxdgDecorationManagerV1>,
+
+    xdg_activation: SimpleGlobal<XdgActivationV1>,
+
+    fractional_scale_manager: SimpleGlobal<WpFractionalScaleManagerV1>,
+
+    viewporter: SimpleGlobal<WpViewporter>,
+}
+
+impl WinitEnv {
+    pub fn new() -> Self {
+        // Output tracking for available_monitors, etc.
+        let outputs = OutputHandler::new();
+
+        // Keyboard/Pointer/Touch input.
+        let seats = SeatHandler::new();
+
+        // Essential globals.
+        let shm = ShmHandler::new();
+        let compositor = SimpleGlobal::new();
+        let subcompositor = SimpleGlobal::new();
+
+        // Gracefully handle shell picking, since SCTK automatically supports multiple
+        // backends.
+        let shell = ShellHandler::new();
+
+        // Server side decorations.
+        let decoration_manager = SimpleGlobal::new();
+
+        // Device events for pointer.
+        let relative_pointer_manager = SimpleGlobal::new();
+
+        // Pointer grab functionality.
+        let pointer_constraints = SimpleGlobal::new();
+
+        // IME handling.
+        let text_input_manager = SimpleGlobal::new();
+
+        // Surface activation.
+        let xdg_activation = SimpleGlobal::new();
+
+        // Fractional surface scaling.
+        let fractional_scale_manager = SimpleGlobal::new();
+
+        // Surface resizing (used for fractional scaling).
+        let viewporter = SimpleGlobal::new();
+
+        Self {
+            seats,
+            outputs,
+            shm,
+            compositor,
+            subcompositor,
+            shell,
+            decoration_manager,
+            relative_pointer_manager,
+            pointer_constraints,
+            text_input_manager,
+            xdg_activation,
+            fractional_scale_manager,
+            viewporter,
+        }
+    }
+}
+
+impl ShellHandling for WinitEnv {
+    fn get_shell(&self) -> Option<Shell> {
+        self.shell.get_shell()
+    }
+}
+
+impl SeatHandling for WinitEnv {
+    fn listen<F: FnMut(Attached<WlSeat>, &SeatData, DispatchData<'_>) + 'static>(
+        &mut self,
+        f: F,
+    ) -> SeatListener {
+        self.seats.listen(f)
+    }
+}
+
+impl OutputHandling for WinitEnv {
+    fn listen<F: FnMut(WlOutput, &OutputInfo, DispatchData<'_>) + 'static>(
+        &mut self,
+        f: F,
+    ) -> OutputStatusListener {
+        self.outputs.listen(f)
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/event_loop/mod.rs

@@ -0,0 +1,609 @@
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::error::Error;
+use std::io::Result as IOResult;
+use std::mem;
+use std::process;
+use std::rc::Rc;
+use std::time::{Duration, Instant};
+
+use raw_window_handle::{RawDisplayHandle, WaylandDisplayHandle};
+
+use sctk::reexports::client::protocol::wl_compositor::WlCompositor;
+use sctk::reexports::client::protocol::wl_shm::WlShm;
+use sctk::reexports::client::Display;
+
+use sctk::reexports::calloop;
+
+use sctk::environment::Environment;
+use sctk::seat::pointer::{ThemeManager, ThemeSpec};
+use sctk::WaylandSource;
+
+use crate::dpi::{LogicalSize, PhysicalSize};
+use crate::event::{Event, StartCause, WindowEvent};
+use crate::event_loop::{ControlFlow, EventLoopWindowTarget as RootEventLoopWindowTarget};
+use crate::platform_impl::platform::sticky_exit_callback;
+use crate::platform_impl::EventLoopWindowTarget as PlatformEventLoopWindowTarget;
+
+use super::env::{WindowingFeatures, WinitEnv};
+use super::output::OutputManager;
+use super::seat::SeatManager;
+use super::window::shim::{self, WindowCompositorUpdate, WindowUserRequest};
+use super::{DeviceId, WindowId};
+
+mod proxy;
+mod sink;
+mod state;
+
+pub use proxy::EventLoopProxy;
+pub use sink::EventSink;
+pub use state::WinitState;
+
+type WinitDispatcher = calloop::Dispatcher<'static, WaylandSource, WinitState>;
+
+pub struct EventLoopWindowTarget<T> {
+    /// Wayland display.
+    pub display: Display,
+
+    /// Environment to handle object creation, etc.
+    pub env: Environment<WinitEnv>,
+
+    /// Event loop handle.
+    pub event_loop_handle: calloop::LoopHandle<'static, WinitState>,
+
+    /// Output manager.
+    pub output_manager: OutputManager,
+
+    /// State that we share across callbacks.
+    pub state: RefCell<WinitState>,
+
+    /// Dispatcher of Wayland events.
+    pub wayland_dispatcher: WinitDispatcher,
+
+    /// A proxy to wake up event loop.
+    pub event_loop_awakener: calloop::ping::Ping,
+
+    /// The available windowing features.
+    pub windowing_features: WindowingFeatures,
+
+    /// Theme manager to manage cursors.
+    ///
+    /// It's being shared between all windows to avoid loading
+    /// multiple similar themes.
+    pub theme_manager: ThemeManager,
+
+    _marker: std::marker::PhantomData<T>,
+}
+
+impl<T> EventLoopWindowTarget<T> {
+    pub fn raw_display_handle(&self) -> RawDisplayHandle {
+        let mut display_handle = WaylandDisplayHandle::empty();
+        display_handle.display = self.display.get_display_ptr() as *mut _;
+        RawDisplayHandle::Wayland(display_handle)
+    }
+}
+
+pub struct EventLoop<T: 'static> {
+    /// Dispatcher of Wayland events.
+    pub wayland_dispatcher: WinitDispatcher,
+
+    /// Event loop.
+    event_loop: calloop::EventLoop<'static, WinitState>,
+
+    /// Wayland display.
+    display: Display,
+
+    /// Pending user events.
+    pending_user_events: Rc<RefCell<Vec<T>>>,
+
+    /// Sender of user events.
+    user_events_sender: calloop::channel::Sender<T>,
+
+    /// Window target.
+    window_target: RootEventLoopWindowTarget<T>,
+
+    /// Output manager.
+    _seat_manager: SeatManager,
+}
+
+impl<T: 'static> EventLoop<T> {
+    pub fn new() -> Result<EventLoop<T>, Box<dyn Error>> {
+        // Connect to wayland server and setup event queue.
+        let display = Display::connect_to_env()?;
+        let mut event_queue = display.create_event_queue();
+        let display_proxy = display.attach(event_queue.token());
+
+        // Setup environment.
+        let env = Environment::new(&display_proxy, &mut event_queue, WinitEnv::new())?;
+
+        // Create event loop.
+        let event_loop = calloop::EventLoop::<'static, WinitState>::try_new()?;
+        // Build windowing features.
+        let windowing_features = WindowingFeatures::new(&env);
+
+        // Create a theme manager.
+        let compositor = env.require_global::<WlCompositor>();
+        let shm = env.require_global::<WlShm>();
+        let theme_manager = ThemeManager::init(ThemeSpec::System, compositor, shm);
+
+        // Setup theme seat and output managers.
+        let seat_manager = SeatManager::new(&env, event_loop.handle(), theme_manager.clone());
+        let output_manager = OutputManager::new(&env);
+
+        // A source of events that we plug into our event loop.
+        let wayland_source = WaylandSource::new(event_queue);
+        let wayland_dispatcher =
+            calloop::Dispatcher::new(wayland_source, |_, queue, winit_state| {
+                queue.dispatch_pending(winit_state, |event, object, _| {
+                    panic!(
+                        "[calloop] Encountered an orphan event: {}@{} : {}",
+                        event.interface,
+                        object.as_ref().id(),
+                        event.name
+                    );
+                })
+            });
+
+        let _wayland_source_dispatcher = event_loop
+            .handle()
+            .register_dispatcher(wayland_dispatcher.clone())?;
+
+        // A source of user events.
+        let pending_user_events = Rc::new(RefCell::new(Vec::new()));
+        let pending_user_events_clone = pending_user_events.clone();
+        let (user_events_sender, user_events_channel) = calloop::channel::channel();
+
+        // User events channel.
+        event_loop
+            .handle()
+            .insert_source(user_events_channel, move |event, _, _| {
+                if let calloop::channel::Event::Msg(msg) = event {
+                    pending_user_events_clone.borrow_mut().push(msg);
+                }
+            })?;
+
+        // An event's loop awakener to wake up for window events from winit's windows.
+        let (event_loop_awakener, event_loop_awakener_source) = calloop::ping::make_ping()?;
+
+        // Handler of window requests.
+        event_loop
+            .handle()
+            .insert_source(event_loop_awakener_source, move |_, _, state| {
+                // Drain events here as well to account for application doing batch event processing
+                // on RedrawEventsCleared.
+                shim::handle_window_requests(state);
+            })?;
+
+        let event_loop_handle = event_loop.handle();
+        let window_map = HashMap::new();
+        let event_sink = EventSink::new();
+        let window_user_requests = HashMap::new();
+        let window_compositor_updates = HashMap::new();
+
+        // Create event loop window target.
+        let event_loop_window_target = EventLoopWindowTarget {
+            display: display.clone(),
+            env,
+            state: RefCell::new(WinitState {
+                window_map,
+                event_sink,
+                window_user_requests,
+                window_compositor_updates,
+            }),
+            event_loop_handle,
+            output_manager,
+            event_loop_awakener,
+            wayland_dispatcher: wayland_dispatcher.clone(),
+            windowing_features,
+            theme_manager,
+            _marker: std::marker::PhantomData,
+        };
+
+        // Create event loop itself.
+        let event_loop = Self {
+            event_loop,
+            display,
+            pending_user_events,
+            wayland_dispatcher,
+            _seat_manager: seat_manager,
+            user_events_sender,
+            window_target: RootEventLoopWindowTarget {
+                p: PlatformEventLoopWindowTarget::Wayland(event_loop_window_target),
+                _marker: std::marker::PhantomData,
+            },
+        };
+
+        Ok(event_loop)
+    }
+
+    pub fn run<F>(mut self, callback: F) -> !
+    where
+        F: FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow) + 'static,
+    {
+        let exit_code = self.run_return(callback);
+        process::exit(exit_code);
+    }
+
+    pub fn run_return<F>(&mut self, mut callback: F) -> i32
+    where
+        F: FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
+    {
+        let mut control_flow = ControlFlow::Poll;
+        let pending_user_events = self.pending_user_events.clone();
+
+        callback(
+            Event::NewEvents(StartCause::Init),
+            &self.window_target,
+            &mut control_flow,
+        );
+
+        // NB: For consistency all platforms must emit a 'resumed' event even though Wayland
+        // applications don't themselves have a formal suspend/resume lifecycle.
+        callback(Event::Resumed, &self.window_target, &mut control_flow);
+
+        let mut window_compositor_updates: Vec<(WindowId, WindowCompositorUpdate)> = Vec::new();
+        let mut window_user_requests: Vec<(WindowId, WindowUserRequest)> = Vec::new();
+        let mut event_sink_back_buffer = Vec::new();
+
+        // NOTE We break on errors from dispatches, since if we've got protocol error
+        // libwayland-client/wayland-rs will inform us anyway, but crashing downstream is not
+        // really an option. Instead we inform that the event loop got destroyed. We may
+        // communicate an error that something was terminated, but winit doesn't provide us
+        // with an API to do that via some event.
+        // Still, we set the exit code to the error's OS error code, or to 1 if not possible.
+        let exit_code = loop {
+            // Send pending events to the server.
+            let _ = self.display.flush();
+
+            // During the run of the user callback, some other code monitoring and reading the
+            // Wayland socket may have been run (mesa for example does this with vsync), if that
+            // is the case, some events may have been enqueued in our event queue.
+            //
+            // If some messages are there, the event loop needs to behave as if it was instantly
+            // woken up by messages arriving from the Wayland socket, to avoid delaying the
+            // dispatch of these events until we're woken up again.
+            let instant_wakeup = {
+                let mut wayland_source = self.wayland_dispatcher.as_source_mut();
+                let queue = wayland_source.queue();
+                let state = match &mut self.window_target.p {
+                    PlatformEventLoopWindowTarget::Wayland(window_target) => {
+                        window_target.state.get_mut()
+                    }
+                    #[cfg(x11_platform)]
+                    _ => unreachable!(),
+                };
+
+                match queue.dispatch_pending(state, |_, _, _| unimplemented!()) {
+                    Ok(dispatched) => dispatched > 0,
+                    Err(error) => break error.raw_os_error().unwrap_or(1),
+                }
+            };
+
+            match control_flow {
+                ControlFlow::ExitWithCode(code) => break code,
+                ControlFlow::Poll => {
+                    // Non-blocking dispatch.
+                    let timeout = Duration::from_millis(0);
+                    if let Err(error) = self.loop_dispatch(Some(timeout)) {
+                        break error.raw_os_error().unwrap_or(1);
+                    }
+
+                    callback(
+                        Event::NewEvents(StartCause::Poll),
+                        &self.window_target,
+                        &mut control_flow,
+                    );
+                }
+                ControlFlow::Wait => {
+                    let timeout = if instant_wakeup {
+                        Some(Duration::from_millis(0))
+                    } else {
+                        None
+                    };
+
+                    if let Err(error) = self.loop_dispatch(timeout) {
+                        break error.raw_os_error().unwrap_or(1);
+                    }
+
+                    callback(
+                        Event::NewEvents(StartCause::WaitCancelled {
+                            start: Instant::now(),
+                            requested_resume: None,
+                        }),
+                        &self.window_target,
+                        &mut control_flow,
+                    );
+                }
+                ControlFlow::WaitUntil(deadline) => {
+                    let start = Instant::now();
+
+                    // Compute the amount of time we'll block for.
+                    let duration = if deadline > start && !instant_wakeup {
+                        deadline - start
+                    } else {
+                        Duration::from_millis(0)
+                    };
+
+                    if let Err(error) = self.loop_dispatch(Some(duration)) {
+                        break error.raw_os_error().unwrap_or(1);
+                    }
+
+                    let now = Instant::now();
+
+                    if now < deadline {
+                        callback(
+                            Event::NewEvents(StartCause::WaitCancelled {
+                                start,
+                                requested_resume: Some(deadline),
+                            }),
+                            &self.window_target,
+                            &mut control_flow,
+                        )
+                    } else {
+                        callback(
+                            Event::NewEvents(StartCause::ResumeTimeReached {
+                                start,
+                                requested_resume: deadline,
+                            }),
+                            &self.window_target,
+                            &mut control_flow,
+                        )
+                    }
+                }
+            }
+
+            // Handle pending user events. We don't need back buffer, since we can't dispatch
+            // user events indirectly via callback to the user.
+            for user_event in pending_user_events.borrow_mut().drain(..) {
+                sticky_exit_callback(
+                    Event::UserEvent(user_event),
+                    &self.window_target,
+                    &mut control_flow,
+                    &mut callback,
+                );
+            }
+
+            // Process 'new' pending updates from compositor.
+            self.with_state(|state| {
+                window_compositor_updates.clear();
+                window_compositor_updates.extend(
+                    state
+                        .window_compositor_updates
+                        .iter_mut()
+                        .map(|(wid, window_update)| (*wid, mem::take(window_update))),
+                );
+            });
+
+            for (window_id, window_compositor_update) in window_compositor_updates.iter_mut() {
+                if let Some(scale_factor) = window_compositor_update.scale_factor {
+                    let mut physical_size = self.with_state(|state| {
+                        let window_handle = state.window_map.get(window_id).unwrap();
+                        *window_handle.scale_factor.lock().unwrap() = scale_factor;
+
+                        let mut size = window_handle.size.lock().unwrap();
+
+                        // Update the new logical size if it was changed.
+                        let window_size = window_compositor_update.size.unwrap_or(*size);
+                        *size = window_size;
+
+                        logical_to_physical_rounded(window_size, scale_factor)
+                    });
+
+                    sticky_exit_callback(
+                        Event::WindowEvent {
+                            window_id: crate::window::WindowId(*window_id),
+                            event: WindowEvent::ScaleFactorChanged {
+                                scale_factor,
+                                new_inner_size: &mut physical_size,
+                            },
+                        },
+                        &self.window_target,
+                        &mut control_flow,
+                        &mut callback,
+                    );
+
+                    // We don't update size on a window handle since we'll do that later
+                    // when handling size update.
+                    let new_logical_size = physical_size.to_logical(scale_factor);
+                    window_compositor_update.size = Some(new_logical_size);
+                }
+
+                if let Some(size) = window_compositor_update.size.take() {
+                    let physical_size = self.with_state(|state| {
+                        let window_handle = state.window_map.get_mut(window_id).unwrap();
+
+                        if let Some(fs_state) = window_handle.fractional_scaling_state.as_ref() {
+                            // If we have a viewport then we support fractional scaling. As per the
+                            // protocol, we have to set the viewport size of the size prior scaling.
+                            fs_state
+                                .viewport
+                                .set_destination(size.width as _, size.height as _);
+                        }
+
+                        let mut window_size = window_handle.size.lock().unwrap();
+
+                        // Always issue resize event on scale factor change.
+                        let physical_size = if window_compositor_update.scale_factor.is_none()
+                            && *window_size == size
+                        {
+                            // The size hasn't changed, don't inform downstream about that.
+                            None
+                        } else {
+                            *window_size = size;
+                            let scale_factor = window_handle.scale_factor();
+                            let physical_size = logical_to_physical_rounded(size, scale_factor);
+                            Some(physical_size)
+                        };
+
+                        // We still perform all of those resize related logic even if the size
+                        // hasn't changed, since GNOME relies on `set_geometry` calls after
+                        // configures.
+                        window_handle.window.resize(size.width, size.height);
+                        window_handle.window.refresh();
+
+                        // Update the opaque region.
+                        window_handle.set_transparent(window_handle.transparent.get());
+
+                        // Mark that refresh isn't required, since we've done it right now.
+                        state
+                            .window_user_requests
+                            .get_mut(window_id)
+                            .unwrap()
+                            .refresh_frame = false;
+
+                        // Queue redraw requested.
+                        state
+                            .window_user_requests
+                            .get_mut(window_id)
+                            .unwrap()
+                            .redraw_requested = true;
+
+                        physical_size
+                    });
+
+                    if let Some(physical_size) = physical_size {
+                        sticky_exit_callback(
+                            Event::WindowEvent {
+                                window_id: crate::window::WindowId(*window_id),
+                                event: WindowEvent::Resized(physical_size),
+                            },
+                            &self.window_target,
+                            &mut control_flow,
+                            &mut callback,
+                        );
+                    }
+                }
+
+                // If the close is requested, send it here.
+                if window_compositor_update.close_window {
+                    sticky_exit_callback(
+                        Event::WindowEvent {
+                            window_id: crate::window::WindowId(*window_id),
+                            event: WindowEvent::CloseRequested,
+                        },
+                        &self.window_target,
+                        &mut control_flow,
+                        &mut callback,
+                    );
+                }
+            }
+
+            // The purpose of the back buffer and that swap is to not hold borrow_mut when
+            // we're doing callback to the user, since we can double borrow if the user decides
+            // to create a window in one of those callbacks.
+            self.with_state(|state| {
+                std::mem::swap(
+                    &mut event_sink_back_buffer,
+                    &mut state.event_sink.window_events,
+                )
+            });
+
+            // Handle pending window events.
+            for event in event_sink_back_buffer.drain(..) {
+                let event = event.map_nonuser_event().unwrap();
+                sticky_exit_callback(event, &self.window_target, &mut control_flow, &mut callback);
+            }
+
+            // Send events cleared.
+            sticky_exit_callback(
+                Event::MainEventsCleared,
+                &self.window_target,
+                &mut control_flow,
+                &mut callback,
+            );
+
+            // Apply user requests, so every event required resize and latter surface commit will
+            // be applied right before drawing. This will also ensure that every `RedrawRequested`
+            // event will be delivered in time.
+            self.with_state(|state| {
+                shim::handle_window_requests(state);
+            });
+
+            // Process 'new' pending updates from compositor.
+            self.with_state(|state| {
+                window_user_requests.clear();
+                window_user_requests.extend(
+                    state
+                        .window_user_requests
+                        .iter_mut()
+                        .map(|(wid, window_request)| (*wid, mem::take(window_request))),
+                );
+            });
+
+            // Handle RedrawRequested events.
+            for (window_id, mut window_request) in window_user_requests.iter() {
+                // Handle refresh of the frame.
+                if window_request.refresh_frame {
+                    self.with_state(|state| {
+                        let window_handle = state.window_map.get_mut(window_id).unwrap();
+                        window_handle.window.refresh();
+                    });
+
+                    // In general refreshing the frame requires surface commit, those force user
+                    // to redraw.
+                    window_request.redraw_requested = true;
+                }
+
+                // Handle redraw request.
+                if window_request.redraw_requested {
+                    sticky_exit_callback(
+                        Event::RedrawRequested(crate::window::WindowId(*window_id)),
+                        &self.window_target,
+                        &mut control_flow,
+                        &mut callback,
+                    );
+                }
+            }
+
+            // Send RedrawEventCleared.
+            sticky_exit_callback(
+                Event::RedrawEventsCleared,
+                &self.window_target,
+                &mut control_flow,
+                &mut callback,
+            );
+        };
+
+        callback(Event::LoopDestroyed, &self.window_target, &mut control_flow);
+        exit_code
+    }
+
+    #[inline]
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+        EventLoopProxy::new(self.user_events_sender.clone())
+    }
+
+    #[inline]
+    pub fn window_target(&self) -> &RootEventLoopWindowTarget<T> {
+        &self.window_target
+    }
+
+    fn with_state<U, F: FnOnce(&mut WinitState) -> U>(&mut self, f: F) -> U {
+        let state = match &mut self.window_target.p {
+            PlatformEventLoopWindowTarget::Wayland(window_target) => window_target.state.get_mut(),
+            #[cfg(x11_platform)]
+            _ => unreachable!(),
+        };
+
+        f(state)
+    }
+
+    fn loop_dispatch<D: Into<Option<std::time::Duration>>>(&mut self, timeout: D) -> IOResult<()> {
+        let state = match &mut self.window_target.p {
+            PlatformEventLoopWindowTarget::Wayland(window_target) => window_target.state.get_mut(),
+            #[cfg(x11_platform)]
+            _ => unreachable!(),
+        };
+
+        self.event_loop
+            .dispatch(timeout, state)
+            .map_err(|error| error.into())
+    }
+}
+
+// The default routine does floor, but we need round on Wayland.
+fn logical_to_physical_rounded(size: LogicalSize<u32>, scale_factor: f64) -> PhysicalSize<u32> {
+    let width = size.width as f64 * scale_factor;
+    let height = size.height as f64 * scale_factor;
+    (width.round(), height.round()).into()
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/event_loop/proxy.rs

@@ -0,0 +1,32 @@
+//! An event loop proxy.
+
+use std::sync::mpsc::SendError;
+
+use sctk::reexports::calloop::channel::Sender;
+
+use crate::event_loop::EventLoopClosed;
+
+/// A handle that can be sent across the threads and used to wake up the `EventLoop`.
+pub struct EventLoopProxy<T: 'static> {
+    user_events_sender: Sender<T>,
+}
+
+impl<T: 'static> Clone for EventLoopProxy<T> {
+    fn clone(&self) -> Self {
+        EventLoopProxy {
+            user_events_sender: self.user_events_sender.clone(),
+        }
+    }
+}
+
+impl<T: 'static> EventLoopProxy<T> {
+    pub fn new(user_events_sender: Sender<T>) -> Self {
+        Self { user_events_sender }
+    }
+
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+        self.user_events_sender
+            .send(event)
+            .map_err(|SendError(error)| EventLoopClosed(error))
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/event_loop/sink.rs

@@ -0,0 +1,36 @@
+//! An event loop's sink to deliver events from the Wayland event callbacks.
+
+use crate::event::{DeviceEvent, DeviceId as RootDeviceId, Event, WindowEvent};
+use crate::platform_impl::platform::DeviceId as PlatformDeviceId;
+use crate::window::WindowId as RootWindowId;
+
+use super::{DeviceId, WindowId};
+
+/// An event loop's sink to deliver events from the Wayland event callbacks
+/// to the winit's user.
+#[derive(Default)]
+pub struct EventSink {
+    pub window_events: Vec<Event<'static, ()>>,
+}
+
+impl EventSink {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Add new device event to a queue.
+    pub fn push_device_event(&mut self, event: DeviceEvent, device_id: DeviceId) {
+        self.window_events.push(Event::DeviceEvent {
+            event,
+            device_id: RootDeviceId(PlatformDeviceId::Wayland(device_id)),
+        });
+    }
+
+    /// Add new window event to a queue.
+    pub fn push_window_event(&mut self, event: WindowEvent<'static>, window_id: WindowId) {
+        self.window_events.push(Event::WindowEvent {
+            event,
+            window_id: RootWindowId(window_id),
+        });
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/event_loop/state.rs

@@ -0,0 +1,31 @@
+//! A state that we pass around in a dispatch.
+
+use std::collections::HashMap;
+
+use super::EventSink;
+use crate::platform_impl::wayland::window::shim::{
+    WindowCompositorUpdate, WindowHandle, WindowUserRequest,
+};
+use crate::platform_impl::wayland::WindowId;
+
+/// Wrapper to carry winit's state.
+pub struct WinitState {
+    /// A sink for window and device events that is being filled during dispatching
+    /// event loop and forwarded downstream afterwards.
+    pub event_sink: EventSink,
+
+    /// Window updates comming from the user requests. Those are separatelly dispatched right after
+    /// `MainEventsCleared`.
+    pub window_user_requests: HashMap<WindowId, WindowUserRequest>,
+
+    /// Window updates, which are coming from SCTK or the compositor, which require
+    /// calling back to the winit's downstream. They are handled right in the event loop,
+    /// unlike the ones coming from buffers on the `WindowHandle`'s.
+    pub window_compositor_updates: HashMap<WindowId, WindowCompositorUpdate>,
+
+    /// Window map containing all SCTK windows. Since those windows aren't allowed
+    /// to be sent to other threads, they live on the event loop's thread
+    /// and requests from winit's windows are being forwarded to them either via
+    /// `WindowUpdate` or buffer on the associated with it `WindowHandle`.
+    pub window_map: HashMap<WindowId, WindowHandle>,
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/mod.rs

@@ -0,0 +1,29 @@
+#![cfg(wayland_platform)]
+
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+
+pub use crate::platform_impl::platform::WindowId;
+pub use event_loop::{EventLoop, EventLoopProxy, EventLoopWindowTarget};
+pub use output::{MonitorHandle, VideoMode};
+pub use window::Window;
+
+mod env;
+mod event_loop;
+mod output;
+mod protocols;
+mod seat;
+mod window;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct DeviceId;
+
+impl DeviceId {
+    pub const unsafe fn dummy() -> Self {
+        DeviceId
+    }
+}
+
+#[inline]
+fn make_wid(surface: &WlSurface) -> WindowId {
+    WindowId(surface.as_ref().c_ptr() as u64)
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/output.rs

@@ -0,0 +1,247 @@
+use std::collections::VecDeque;
+use std::sync::{Arc, Mutex};
+
+use sctk::reexports::client::protocol::wl_output::WlOutput;
+use sctk::reexports::client::Display;
+
+use sctk::environment::Environment;
+use sctk::output::OutputStatusListener;
+
+use crate::dpi::{PhysicalPosition, PhysicalSize};
+use crate::platform_impl::platform::{
+    MonitorHandle as PlatformMonitorHandle, VideoMode as PlatformVideoMode,
+};
+
+use super::env::WinitEnv;
+use super::event_loop::EventLoopWindowTarget;
+
+/// Output manager.
+pub struct OutputManager {
+    /// A handle that actually performs all operations on outputs.
+    handle: OutputManagerHandle,
+
+    _output_listener: OutputStatusListener,
+}
+
+impl OutputManager {
+    pub fn new(env: &Environment<WinitEnv>) -> Self {
+        let handle = OutputManagerHandle::new();
+
+        // Handle existing outputs.
+        for output in env.get_all_outputs() {
+            match sctk::output::with_output_info(&output, |info| info.obsolete) {
+                Some(false) => (),
+                // The output is obsolete or we've failed to access its data, skipping.
+                _ => continue,
+            }
+
+            // The output is present and unusable, add it to the output manager manager.
+            handle.add_output(output);
+        }
+
+        let handle_for_listener = handle.clone();
+
+        let output_listener = env.listen_for_outputs(move |output, info, _| {
+            if info.obsolete {
+                handle_for_listener.remove_output(output)
+            } else {
+                handle_for_listener.add_output(output)
+            }
+        });
+
+        Self {
+            handle,
+            _output_listener: output_listener,
+        }
+    }
+
+    pub fn handle(&self) -> OutputManagerHandle {
+        self.handle.clone()
+    }
+}
+
+/// A handle to output manager.
+#[derive(Debug, Clone)]
+pub struct OutputManagerHandle {
+    outputs: Arc<Mutex<VecDeque<MonitorHandle>>>,
+}
+
+impl OutputManagerHandle {
+    fn new() -> Self {
+        let outputs = Arc::new(Mutex::new(VecDeque::new()));
+        Self { outputs }
+    }
+
+    /// Handle addition of the output.
+    fn add_output(&self, output: WlOutput) {
+        let mut outputs = self.outputs.lock().unwrap();
+        let position = outputs.iter().position(|handle| handle.proxy == output);
+        if position.is_none() {
+            outputs.push_back(MonitorHandle::new(output));
+        }
+    }
+
+    /// Handle removal of the output.
+    fn remove_output(&self, output: WlOutput) {
+        let mut outputs = self.outputs.lock().unwrap();
+        let position = outputs.iter().position(|handle| handle.proxy == output);
+        if let Some(position) = position {
+            outputs.remove(position);
+        }
+    }
+
+    /// Get all observed outputs.
+    pub fn available_outputs(&self) -> VecDeque<MonitorHandle> {
+        self.outputs.lock().unwrap().clone()
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct MonitorHandle {
+    pub(crate) proxy: WlOutput,
+}
+
+impl PartialEq for MonitorHandle {
+    fn eq(&self, other: &Self) -> bool {
+        self.native_identifier() == other.native_identifier()
+    }
+}
+
+impl Eq for MonitorHandle {}
+
+impl PartialOrd for MonitorHandle {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for MonitorHandle {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.native_identifier().cmp(&other.native_identifier())
+    }
+}
+
+impl std::hash::Hash for MonitorHandle {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.native_identifier().hash(state);
+    }
+}
+
+impl MonitorHandle {
+    #[inline]
+    pub(crate) fn new(proxy: WlOutput) -> Self {
+        Self { proxy }
+    }
+
+    #[inline]
+    pub fn name(&self) -> Option<String> {
+        sctk::output::with_output_info(&self.proxy, |info| {
+            format!("{} ({})", info.model, info.make)
+        })
+    }
+
+    #[inline]
+    pub fn native_identifier(&self) -> u32 {
+        sctk::output::with_output_info(&self.proxy, |info| info.id).unwrap_or(0)
+    }
+
+    #[inline]
+    pub fn size(&self) -> PhysicalSize<u32> {
+        match sctk::output::with_output_info(&self.proxy, |info| {
+            info.modes
+                .iter()
+                .find(|mode| mode.is_current)
+                .map(|mode| mode.dimensions)
+        }) {
+            Some(Some((w, h))) => (w as u32, h as u32),
+            _ => (0, 0),
+        }
+        .into()
+    }
+
+    #[inline]
+    pub fn position(&self) -> PhysicalPosition<i32> {
+        sctk::output::with_output_info(&self.proxy, |info| info.location)
+            .unwrap_or((0, 0))
+            .into()
+    }
+
+    #[inline]
+    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
+        sctk::output::with_output_info(&self.proxy, |info| {
+            info.modes
+                .iter()
+                .find_map(|mode| mode.is_current.then(|| mode.refresh_rate as u32))
+        })
+        .flatten()
+    }
+
+    #[inline]
+    pub fn scale_factor(&self) -> i32 {
+        sctk::output::with_output_info(&self.proxy, |info| info.scale_factor).unwrap_or(1)
+    }
+
+    #[inline]
+    pub fn video_modes(&self) -> impl Iterator<Item = PlatformVideoMode> {
+        let modes = sctk::output::with_output_info(&self.proxy, |info| info.modes.clone())
+            .unwrap_or_default();
+
+        let monitor = self.clone();
+
+        modes.into_iter().map(move |mode| {
+            PlatformVideoMode::Wayland(VideoMode {
+                size: (mode.dimensions.0 as u32, mode.dimensions.1 as u32).into(),
+                refresh_rate_millihertz: mode.refresh_rate as u32,
+                bit_depth: 32,
+                monitor: monitor.clone(),
+            })
+        })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct VideoMode {
+    pub(crate) size: PhysicalSize<u32>,
+    pub(crate) bit_depth: u16,
+    pub(crate) refresh_rate_millihertz: u32,
+    pub(crate) monitor: MonitorHandle,
+}
+
+impl VideoMode {
+    #[inline]
+    pub fn size(&self) -> PhysicalSize<u32> {
+        self.size
+    }
+
+    #[inline]
+    pub fn bit_depth(&self) -> u16 {
+        self.bit_depth
+    }
+
+    #[inline]
+    pub fn refresh_rate_millihertz(&self) -> u32 {
+        self.refresh_rate_millihertz
+    }
+
+    pub fn monitor(&self) -> PlatformMonitorHandle {
+        PlatformMonitorHandle::Wayland(self.monitor.clone())
+    }
+}
+
+impl<T> EventLoopWindowTarget<T> {
+    #[inline]
+    pub fn display(&self) -> &Display {
+        &self.display
+    }
+
+    #[inline]
+    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
+        self.output_manager.handle.available_outputs()
+    }
+
+    #[inline]
+    pub fn primary_monitor(&self) -> Option<PlatformMonitorHandle> {
+        // There's no primary monitor on Wayland.
+        None
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/protocols.rs

@@ -0,0 +1,13 @@
+#![allow(dead_code, non_camel_case_types, unused_unsafe, unused_variables)]
+#![allow(non_upper_case_globals, non_snake_case, unused_imports)]
+#![allow(missing_docs, clippy::all)]
+
+use wayland_client::protocol::wl_surface;
+use wayland_client::sys;
+use wayland_client::{AnonymousObject, Attached, Main, Proxy, ProxyMap};
+use wayland_commons::map::{Object, ObjectMetadata};
+use wayland_commons::smallvec;
+use wayland_commons::wire::{Argument, ArgumentType, Message, MessageDesc};
+use wayland_commons::{Interface, MessageGroup};
+
+include!(concat!(env!("OUT_DIR"), "/fractional_scale_v1.rs"));

third-party/vendor/winit/src/platform_impl/linux/wayland/seat/keyboard/handlers.rs

@@ -0,0 +1,165 @@
+//! Handling of various keyboard events.
+
+use std::sync::atomic::Ordering;
+
+use sctk::reexports::client::protocol::wl_keyboard::KeyState;
+
+use sctk::seat::keyboard::Event as KeyboardEvent;
+
+use crate::event::{ElementState, KeyboardInput, ModifiersState, WindowEvent};
+use crate::platform_impl::wayland::event_loop::WinitState;
+use crate::platform_impl::wayland::{self, DeviceId};
+
+use super::keymap;
+use super::KeyboardInner;
+
+#[inline]
+pub(super) fn handle_keyboard(
+    event: KeyboardEvent<'_>,
+    inner: &mut KeyboardInner,
+    winit_state: &mut WinitState,
+) {
+    let event_sink = &mut winit_state.event_sink;
+    match event {
+        KeyboardEvent::Enter { surface, .. } => {
+            let window_id = wayland::make_wid(&surface);
+
+            let window_handle = match winit_state.window_map.get_mut(&window_id) {
+                Some(window_handle) => window_handle,
+                None => return,
+            };
+            window_handle.has_focus.store(true, Ordering::Relaxed);
+
+            // Window gained focus.
+            event_sink.push_window_event(WindowEvent::Focused(true), window_id);
+
+            // Dispatch modifers changes that we've received before getting `Enter` event.
+            if let Some(modifiers) = inner.pending_modifers_state.take() {
+                *inner.modifiers_state.borrow_mut() = modifiers;
+                event_sink.push_window_event(WindowEvent::ModifiersChanged(modifiers), window_id);
+            }
+
+            inner.target_window_id = Some(window_id);
+        }
+        KeyboardEvent::Leave { surface, .. } => {
+            // Reset the id.
+            inner.target_window_id = None;
+
+            let window_id = wayland::make_wid(&surface);
+            let window_handle = match winit_state.window_map.get_mut(&window_id) {
+                Some(window_handle) => window_handle,
+                None => return,
+            };
+
+            // Notify that no modifiers are being pressed.
+            if !inner.modifiers_state.borrow().is_empty() {
+                event_sink.push_window_event(
+                    WindowEvent::ModifiersChanged(ModifiersState::empty()),
+                    window_id,
+                );
+            }
+
+            window_handle.has_focus.store(false, Ordering::Relaxed);
+
+            // Window lost focus.
+            event_sink.push_window_event(WindowEvent::Focused(false), window_id);
+        }
+        KeyboardEvent::Key {
+            rawkey,
+            keysym,
+            state,
+            utf8,
+            ..
+        } => {
+            let window_id = match inner.target_window_id {
+                Some(window_id) => window_id,
+                None => return,
+            };
+
+            let state = match state {
+                KeyState::Pressed => ElementState::Pressed,
+                KeyState::Released => ElementState::Released,
+                _ => unreachable!(),
+            };
+
+            let virtual_keycode = keymap::keysym_to_vkey(keysym);
+
+            event_sink.push_window_event(
+                #[allow(deprecated)]
+                WindowEvent::KeyboardInput {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                    input: KeyboardInput {
+                        state,
+                        scancode: rawkey,
+                        virtual_keycode,
+                        modifiers: *inner.modifiers_state.borrow(),
+                    },
+                    is_synthetic: false,
+                },
+                window_id,
+            );
+
+            // Send ReceivedCharacter event only on ElementState::Pressed.
+            if ElementState::Released == state {
+                return;
+            }
+
+            if let Some(txt) = utf8 {
+                for ch in txt.chars() {
+                    event_sink.push_window_event(WindowEvent::ReceivedCharacter(ch), window_id);
+                }
+            }
+        }
+        KeyboardEvent::Repeat {
+            rawkey,
+            keysym,
+            utf8,
+            ..
+        } => {
+            let window_id = match inner.target_window_id {
+                Some(window_id) => window_id,
+                None => return,
+            };
+
+            let virtual_keycode = keymap::keysym_to_vkey(keysym);
+
+            event_sink.push_window_event(
+                #[allow(deprecated)]
+                WindowEvent::KeyboardInput {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                    input: KeyboardInput {
+                        state: ElementState::Pressed,
+                        scancode: rawkey,
+                        virtual_keycode,
+                        modifiers: *inner.modifiers_state.borrow(),
+                    },
+                    is_synthetic: false,
+                },
+                window_id,
+            );
+
+            if let Some(txt) = utf8 {
+                for ch in txt.chars() {
+                    event_sink.push_window_event(WindowEvent::ReceivedCharacter(ch), window_id);
+                }
+            }
+        }
+        KeyboardEvent::Modifiers { modifiers } => {
+            let modifiers = ModifiersState::from(modifiers);
+            if let Some(window_id) = inner.target_window_id {
+                *inner.modifiers_state.borrow_mut() = modifiers;
+
+                event_sink.push_window_event(WindowEvent::ModifiersChanged(modifiers), window_id);
+            } else {
+                // Compositor must send modifiers after wl_keyboard::enter, however certain
+                // compositors are still sending it before, so stash such events and send
+                // them on wl_keyboard::enter.
+                inner.pending_modifers_state = Some(modifiers);
+            }
+        }
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/seat/keyboard/keymap.rs

@@ -0,0 +1,192 @@
+//! Convert Wayland keys to winit keys.
+
+use crate::event::VirtualKeyCode;
+
+pub fn keysym_to_vkey(keysym: u32) -> Option<VirtualKeyCode> {
+    use sctk::seat::keyboard::keysyms;
+    match keysym {
+        // Numbers.
+        keysyms::XKB_KEY_1 => Some(VirtualKeyCode::Key1),
+        keysyms::XKB_KEY_2 => Some(VirtualKeyCode::Key2),
+        keysyms::XKB_KEY_3 => Some(VirtualKeyCode::Key3),
+        keysyms::XKB_KEY_4 => Some(VirtualKeyCode::Key4),
+        keysyms::XKB_KEY_5 => Some(VirtualKeyCode::Key5),
+        keysyms::XKB_KEY_6 => Some(VirtualKeyCode::Key6),
+        keysyms::XKB_KEY_7 => Some(VirtualKeyCode::Key7),
+        keysyms::XKB_KEY_8 => Some(VirtualKeyCode::Key8),
+        keysyms::XKB_KEY_9 => Some(VirtualKeyCode::Key9),
+        keysyms::XKB_KEY_0 => Some(VirtualKeyCode::Key0),
+        // Letters.
+        keysyms::XKB_KEY_A | keysyms::XKB_KEY_a => Some(VirtualKeyCode::A),
+        keysyms::XKB_KEY_B | keysyms::XKB_KEY_b => Some(VirtualKeyCode::B),
+        keysyms::XKB_KEY_C | keysyms::XKB_KEY_c => Some(VirtualKeyCode::C),
+        keysyms::XKB_KEY_D | keysyms::XKB_KEY_d => Some(VirtualKeyCode::D),
+        keysyms::XKB_KEY_E | keysyms::XKB_KEY_e => Some(VirtualKeyCode::E),
+        keysyms::XKB_KEY_F | keysyms::XKB_KEY_f => Some(VirtualKeyCode::F),
+        keysyms::XKB_KEY_G | keysyms::XKB_KEY_g => Some(VirtualKeyCode::G),
+        keysyms::XKB_KEY_H | keysyms::XKB_KEY_h => Some(VirtualKeyCode::H),
+        keysyms::XKB_KEY_I | keysyms::XKB_KEY_i => Some(VirtualKeyCode::I),
+        keysyms::XKB_KEY_J | keysyms::XKB_KEY_j => Some(VirtualKeyCode::J),
+        keysyms::XKB_KEY_K | keysyms::XKB_KEY_k => Some(VirtualKeyCode::K),
+        keysyms::XKB_KEY_L | keysyms::XKB_KEY_l => Some(VirtualKeyCode::L),
+        keysyms::XKB_KEY_M | keysyms::XKB_KEY_m => Some(VirtualKeyCode::M),
+        keysyms::XKB_KEY_N | keysyms::XKB_KEY_n => Some(VirtualKeyCode::N),
+        keysyms::XKB_KEY_O | keysyms::XKB_KEY_o => Some(VirtualKeyCode::O),
+        keysyms::XKB_KEY_P | keysyms::XKB_KEY_p => Some(VirtualKeyCode::P),
+        keysyms::XKB_KEY_Q | keysyms::XKB_KEY_q => Some(VirtualKeyCode::Q),
+        keysyms::XKB_KEY_R | keysyms::XKB_KEY_r => Some(VirtualKeyCode::R),
+        keysyms::XKB_KEY_S | keysyms::XKB_KEY_s => Some(VirtualKeyCode::S),
+        keysyms::XKB_KEY_T | keysyms::XKB_KEY_t => Some(VirtualKeyCode::T),
+        keysyms::XKB_KEY_U | keysyms::XKB_KEY_u => Some(VirtualKeyCode::U),
+        keysyms::XKB_KEY_V | keysyms::XKB_KEY_v => Some(VirtualKeyCode::V),
+        keysyms::XKB_KEY_W | keysyms::XKB_KEY_w => Some(VirtualKeyCode::W),
+        keysyms::XKB_KEY_X | keysyms::XKB_KEY_x => Some(VirtualKeyCode::X),
+        keysyms::XKB_KEY_Y | keysyms::XKB_KEY_y => Some(VirtualKeyCode::Y),
+        keysyms::XKB_KEY_Z | keysyms::XKB_KEY_z => Some(VirtualKeyCode::Z),
+        // Escape.
+        keysyms::XKB_KEY_Escape => Some(VirtualKeyCode::Escape),
+        // Function keys.
+        keysyms::XKB_KEY_F1 => Some(VirtualKeyCode::F1),
+        keysyms::XKB_KEY_F2 => Some(VirtualKeyCode::F2),
+        keysyms::XKB_KEY_F3 => Some(VirtualKeyCode::F3),
+        keysyms::XKB_KEY_F4 => Some(VirtualKeyCode::F4),
+        keysyms::XKB_KEY_F5 => Some(VirtualKeyCode::F5),
+        keysyms::XKB_KEY_F6 => Some(VirtualKeyCode::F6),
+        keysyms::XKB_KEY_F7 => Some(VirtualKeyCode::F7),
+        keysyms::XKB_KEY_F8 => Some(VirtualKeyCode::F8),
+        keysyms::XKB_KEY_F9 => Some(VirtualKeyCode::F9),
+        keysyms::XKB_KEY_F10 => Some(VirtualKeyCode::F10),
+        keysyms::XKB_KEY_F11 => Some(VirtualKeyCode::F11),
+        keysyms::XKB_KEY_F12 => Some(VirtualKeyCode::F12),
+        keysyms::XKB_KEY_F13 => Some(VirtualKeyCode::F13),
+        keysyms::XKB_KEY_F14 => Some(VirtualKeyCode::F14),
+        keysyms::XKB_KEY_F15 => Some(VirtualKeyCode::F15),
+        keysyms::XKB_KEY_F16 => Some(VirtualKeyCode::F16),
+        keysyms::XKB_KEY_F17 => Some(VirtualKeyCode::F17),
+        keysyms::XKB_KEY_F18 => Some(VirtualKeyCode::F18),
+        keysyms::XKB_KEY_F19 => Some(VirtualKeyCode::F19),
+        keysyms::XKB_KEY_F20 => Some(VirtualKeyCode::F20),
+        keysyms::XKB_KEY_F21 => Some(VirtualKeyCode::F21),
+        keysyms::XKB_KEY_F22 => Some(VirtualKeyCode::F22),
+        keysyms::XKB_KEY_F23 => Some(VirtualKeyCode::F23),
+        keysyms::XKB_KEY_F24 => Some(VirtualKeyCode::F24),
+        // Flow control.
+        keysyms::XKB_KEY_Print => Some(VirtualKeyCode::Snapshot),
+        keysyms::XKB_KEY_Scroll_Lock => Some(VirtualKeyCode::Scroll),
+        keysyms::XKB_KEY_Pause => Some(VirtualKeyCode::Pause),
+        keysyms::XKB_KEY_Insert => Some(VirtualKeyCode::Insert),
+        keysyms::XKB_KEY_Home => Some(VirtualKeyCode::Home),
+        keysyms::XKB_KEY_Delete => Some(VirtualKeyCode::Delete),
+        keysyms::XKB_KEY_End => Some(VirtualKeyCode::End),
+        keysyms::XKB_KEY_Page_Down => Some(VirtualKeyCode::PageDown),
+        keysyms::XKB_KEY_Page_Up => Some(VirtualKeyCode::PageUp),
+        // Arrows.
+        keysyms::XKB_KEY_Left => Some(VirtualKeyCode::Left),
+        keysyms::XKB_KEY_Up => Some(VirtualKeyCode::Up),
+        keysyms::XKB_KEY_Right => Some(VirtualKeyCode::Right),
+        keysyms::XKB_KEY_Down => Some(VirtualKeyCode::Down),
+
+        keysyms::XKB_KEY_BackSpace => Some(VirtualKeyCode::Back),
+        keysyms::XKB_KEY_Return => Some(VirtualKeyCode::Return),
+        keysyms::XKB_KEY_space => Some(VirtualKeyCode::Space),
+
+        keysyms::XKB_KEY_Multi_key => Some(VirtualKeyCode::Compose),
+        keysyms::XKB_KEY_caret => Some(VirtualKeyCode::Caret),
+
+        // Keypad.
+        keysyms::XKB_KEY_Num_Lock => Some(VirtualKeyCode::Numlock),
+        keysyms::XKB_KEY_KP_0 => Some(VirtualKeyCode::Numpad0),
+        keysyms::XKB_KEY_KP_1 => Some(VirtualKeyCode::Numpad1),
+        keysyms::XKB_KEY_KP_2 => Some(VirtualKeyCode::Numpad2),
+        keysyms::XKB_KEY_KP_3 => Some(VirtualKeyCode::Numpad3),
+        keysyms::XKB_KEY_KP_4 => Some(VirtualKeyCode::Numpad4),
+        keysyms::XKB_KEY_KP_5 => Some(VirtualKeyCode::Numpad5),
+        keysyms::XKB_KEY_KP_6 => Some(VirtualKeyCode::Numpad6),
+        keysyms::XKB_KEY_KP_7 => Some(VirtualKeyCode::Numpad7),
+        keysyms::XKB_KEY_KP_8 => Some(VirtualKeyCode::Numpad8),
+        keysyms::XKB_KEY_KP_9 => Some(VirtualKeyCode::Numpad9),
+        // Misc.
+        // => Some(VirtualKeyCode::AbntC1),
+        // => Some(VirtualKeyCode::AbntC2),
+        keysyms::XKB_KEY_plus => Some(VirtualKeyCode::Plus),
+        keysyms::XKB_KEY_apostrophe => Some(VirtualKeyCode::Apostrophe),
+        // => Some(VirtualKeyCode::Apps),
+        keysyms::XKB_KEY_at => Some(VirtualKeyCode::At),
+        // => Some(VirtualKeyCode::Ax),
+        keysyms::XKB_KEY_backslash => Some(VirtualKeyCode::Backslash),
+        keysyms::XKB_KEY_XF86Calculator => Some(VirtualKeyCode::Calculator),
+        // => Some(VirtualKeyCode::Capital),
+        keysyms::XKB_KEY_colon => Some(VirtualKeyCode::Colon),
+        keysyms::XKB_KEY_comma => Some(VirtualKeyCode::Comma),
+        // => Some(VirtualKeyCode::Convert),
+        keysyms::XKB_KEY_equal => Some(VirtualKeyCode::Equals),
+        keysyms::XKB_KEY_grave => Some(VirtualKeyCode::Grave),
+        // => Some(VirtualKeyCode::Kana),
+        keysyms::XKB_KEY_Kanji => Some(VirtualKeyCode::Kanji),
+        keysyms::XKB_KEY_Alt_L => Some(VirtualKeyCode::LAlt),
+        keysyms::XKB_KEY_bracketleft => Some(VirtualKeyCode::LBracket),
+        keysyms::XKB_KEY_Control_L => Some(VirtualKeyCode::LControl),
+        keysyms::XKB_KEY_Shift_L => Some(VirtualKeyCode::LShift),
+        keysyms::XKB_KEY_Super_L => Some(VirtualKeyCode::LWin),
+        keysyms::XKB_KEY_XF86Mail => Some(VirtualKeyCode::Mail),
+        // => Some(VirtualKeyCode::MediaSelect),
+        // => Some(VirtualKeyCode::MediaStop),
+        keysyms::XKB_KEY_minus => Some(VirtualKeyCode::Minus),
+        keysyms::XKB_KEY_asterisk => Some(VirtualKeyCode::Asterisk),
+        keysyms::XKB_KEY_XF86AudioMute => Some(VirtualKeyCode::Mute),
+        // => Some(VirtualKeyCode::MyComputer),
+        keysyms::XKB_KEY_XF86AudioNext => Some(VirtualKeyCode::NextTrack),
+        // => Some(VirtualKeyCode::NoConvert),
+        keysyms::XKB_KEY_KP_Separator => Some(VirtualKeyCode::NumpadComma),
+        keysyms::XKB_KEY_KP_Enter => Some(VirtualKeyCode::NumpadEnter),
+        keysyms::XKB_KEY_KP_Equal => Some(VirtualKeyCode::NumpadEquals),
+        keysyms::XKB_KEY_KP_Add => Some(VirtualKeyCode::NumpadAdd),
+        keysyms::XKB_KEY_KP_Subtract => Some(VirtualKeyCode::NumpadSubtract),
+        keysyms::XKB_KEY_KP_Multiply => Some(VirtualKeyCode::NumpadMultiply),
+        keysyms::XKB_KEY_KP_Divide => Some(VirtualKeyCode::NumpadDivide),
+        keysyms::XKB_KEY_KP_Decimal => Some(VirtualKeyCode::NumpadDecimal),
+        keysyms::XKB_KEY_KP_Page_Up => Some(VirtualKeyCode::PageUp),
+        keysyms::XKB_KEY_KP_Page_Down => Some(VirtualKeyCode::PageDown),
+        keysyms::XKB_KEY_KP_Home => Some(VirtualKeyCode::Home),
+        keysyms::XKB_KEY_KP_End => Some(VirtualKeyCode::End),
+        keysyms::XKB_KEY_KP_Left => Some(VirtualKeyCode::Left),
+        keysyms::XKB_KEY_KP_Up => Some(VirtualKeyCode::Up),
+        keysyms::XKB_KEY_KP_Right => Some(VirtualKeyCode::Right),
+        keysyms::XKB_KEY_KP_Down => Some(VirtualKeyCode::Down),
+        // => Some(VirtualKeyCode::OEM102),
+        keysyms::XKB_KEY_period => Some(VirtualKeyCode::Period),
+        // => Some(VirtualKeyCode::Playpause),
+        keysyms::XKB_KEY_XF86PowerOff => Some(VirtualKeyCode::Power),
+        keysyms::XKB_KEY_XF86AudioPrev => Some(VirtualKeyCode::PrevTrack),
+        keysyms::XKB_KEY_Alt_R => Some(VirtualKeyCode::RAlt),
+        keysyms::XKB_KEY_bracketright => Some(VirtualKeyCode::RBracket),
+        keysyms::XKB_KEY_Control_R => Some(VirtualKeyCode::RControl),
+        keysyms::XKB_KEY_Shift_R => Some(VirtualKeyCode::RShift),
+        keysyms::XKB_KEY_Super_R => Some(VirtualKeyCode::RWin),
+        keysyms::XKB_KEY_semicolon => Some(VirtualKeyCode::Semicolon),
+        keysyms::XKB_KEY_slash => Some(VirtualKeyCode::Slash),
+        keysyms::XKB_KEY_XF86Sleep => Some(VirtualKeyCode::Sleep),
+        // => Some(VirtualKeyCode::Stop),
+        // => Some(VirtualKeyCode::Sysrq),
+        keysyms::XKB_KEY_Tab => Some(VirtualKeyCode::Tab),
+        keysyms::XKB_KEY_ISO_Left_Tab => Some(VirtualKeyCode::Tab),
+        keysyms::XKB_KEY_underscore => Some(VirtualKeyCode::Underline),
+        // => Some(VirtualKeyCode::Unlabeled),
+        keysyms::XKB_KEY_XF86AudioLowerVolume => Some(VirtualKeyCode::VolumeDown),
+        keysyms::XKB_KEY_XF86AudioRaiseVolume => Some(VirtualKeyCode::VolumeUp),
+        // => Some(VirtualKeyCode::Wake),
+        // => Some(VirtualKeyCode::Webback),
+        // => Some(VirtualKeyCode::WebFavorites),
+        // => Some(VirtualKeyCode::WebForward),
+        // => Some(VirtualKeyCode::WebHome),
+        // => Some(VirtualKeyCode::WebRefresh),
+        // => Some(VirtualKeyCode::WebSearch),
+        // => Some(VirtualKeyCode::WebStop),
+        keysyms::XKB_KEY_yen => Some(VirtualKeyCode::Yen),
+        keysyms::XKB_KEY_XF86Copy => Some(VirtualKeyCode::Copy),
+        keysyms::XKB_KEY_XF86Paste => Some(VirtualKeyCode::Paste),
+        keysyms::XKB_KEY_XF86Cut => Some(VirtualKeyCode::Cut),
+        // Fallback.
+        _ => None,
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/seat/keyboard/mod.rs

@@ -0,0 +1,90 @@
+//! Wayland keyboard handling.
+
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use sctk::reexports::client::protocol::wl_keyboard::WlKeyboard;
+use sctk::reexports::client::protocol::wl_seat::WlSeat;
+use sctk::reexports::client::Attached;
+
+use sctk::reexports::calloop::LoopHandle;
+
+use sctk::seat::keyboard;
+
+use crate::event::ModifiersState;
+use crate::platform_impl::wayland::event_loop::WinitState;
+use crate::platform_impl::wayland::WindowId;
+
+mod handlers;
+mod keymap;
+
+pub(crate) struct Keyboard {
+    pub keyboard: WlKeyboard,
+}
+
+impl Keyboard {
+    pub fn new(
+        seat: &Attached<WlSeat>,
+        loop_handle: LoopHandle<'static, WinitState>,
+        modifiers_state: Rc<RefCell<ModifiersState>>,
+    ) -> Option<Self> {
+        let mut inner = KeyboardInner::new(modifiers_state);
+        let keyboard = keyboard::map_keyboard_repeat(
+            loop_handle.clone(),
+            seat,
+            None,
+            keyboard::RepeatKind::System,
+            move |event, _, mut dispatch_data| {
+                let winit_state = dispatch_data.get::<WinitState>().unwrap();
+                handlers::handle_keyboard(event, &mut inner, winit_state);
+            },
+        )
+        .ok()?;
+
+        Some(Self { keyboard })
+    }
+}
+
+impl Drop for Keyboard {
+    fn drop(&mut self) {
+        if self.keyboard.as_ref().version() >= 3 {
+            self.keyboard.release();
+        }
+    }
+}
+
+struct KeyboardInner {
+    /// Currently focused surface.
+    target_window_id: Option<WindowId>,
+
+    /// A pending state of modifiers.
+    ///
+    /// This state is getting set if we've got a modifiers update
+    /// before `Enter` event, which shouldn't happen in general, however
+    /// some compositors are still doing so.
+    pending_modifers_state: Option<ModifiersState>,
+
+    /// Current state of modifiers keys.
+    modifiers_state: Rc<RefCell<ModifiersState>>,
+}
+
+impl KeyboardInner {
+    fn new(modifiers_state: Rc<RefCell<ModifiersState>>) -> Self {
+        Self {
+            target_window_id: None,
+            pending_modifers_state: None,
+            modifiers_state,
+        }
+    }
+}
+
+impl From<keyboard::ModifiersState> for ModifiersState {
+    fn from(mods: keyboard::ModifiersState) -> ModifiersState {
+        let mut wl_mods = ModifiersState::empty();
+        wl_mods.set(ModifiersState::SHIFT, mods.shift);
+        wl_mods.set(ModifiersState::CTRL, mods.ctrl);
+        wl_mods.set(ModifiersState::ALT, mods.alt);
+        wl_mods.set(ModifiersState::LOGO, mods.logo);
+        wl_mods
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/seat/mod.rs

@@ -0,0 +1,208 @@
+//! Seat handling and managing.
+
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use sctk::reexports::protocols::unstable::relative_pointer::v1::client::zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1;
+use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_pointer_constraints_v1::ZwpPointerConstraintsV1;
+use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input_manager_v3::ZwpTextInputManagerV3;
+
+use sctk::reexports::client::protocol::wl_seat::WlSeat;
+use sctk::reexports::client::Attached;
+
+use sctk::environment::Environment;
+use sctk::reexports::calloop::LoopHandle;
+use sctk::seat::pointer::ThemeManager;
+use sctk::seat::{SeatData, SeatListener};
+
+use super::env::WinitEnv;
+use super::event_loop::WinitState;
+use crate::event::ModifiersState;
+
+mod keyboard;
+pub mod pointer;
+pub mod text_input;
+mod touch;
+
+use keyboard::Keyboard;
+use pointer::Pointers;
+use text_input::TextInput;
+use touch::Touch;
+
+pub struct SeatManager {
+    /// Listener for seats.
+    _seat_listener: SeatListener,
+}
+
+impl SeatManager {
+    pub fn new(
+        env: &Environment<WinitEnv>,
+        loop_handle: LoopHandle<'static, WinitState>,
+        theme_manager: ThemeManager,
+    ) -> Self {
+        let relative_pointer_manager = env.get_global::<ZwpRelativePointerManagerV1>();
+        let pointer_constraints = env.get_global::<ZwpPointerConstraintsV1>();
+        let text_input_manager = env.get_global::<ZwpTextInputManagerV3>();
+
+        let mut inner = SeatManagerInner::new(
+            theme_manager,
+            relative_pointer_manager,
+            pointer_constraints,
+            text_input_manager,
+            loop_handle,
+        );
+
+        // Handle existing seats.
+        for seat in env.get_all_seats() {
+            let seat_data = match sctk::seat::clone_seat_data(&seat) {
+                Some(seat_data) => seat_data,
+                None => continue,
+            };
+
+            inner.process_seat_update(&seat, &seat_data);
+        }
+
+        let seat_listener = env.listen_for_seats(move |seat, seat_data, _| {
+            inner.process_seat_update(&seat, seat_data);
+        });
+
+        Self {
+            _seat_listener: seat_listener,
+        }
+    }
+}
+
+/// Inner state of the seat manager.
+struct SeatManagerInner {
+    /// Currently observed seats.
+    seats: Vec<SeatInfo>,
+
+    /// Loop handle.
+    loop_handle: LoopHandle<'static, WinitState>,
+
+    /// Relative pointer manager.
+    relative_pointer_manager: Option<Attached<ZwpRelativePointerManagerV1>>,
+
+    /// Pointer constraints.
+    pointer_constraints: Option<Attached<ZwpPointerConstraintsV1>>,
+
+    /// Text input manager.
+    text_input_manager: Option<Attached<ZwpTextInputManagerV3>>,
+
+    /// A theme manager.
+    theme_manager: ThemeManager,
+}
+
+impl SeatManagerInner {
+    fn new(
+        theme_manager: ThemeManager,
+        relative_pointer_manager: Option<Attached<ZwpRelativePointerManagerV1>>,
+        pointer_constraints: Option<Attached<ZwpPointerConstraintsV1>>,
+        text_input_manager: Option<Attached<ZwpTextInputManagerV3>>,
+        loop_handle: LoopHandle<'static, WinitState>,
+    ) -> Self {
+        Self {
+            seats: Vec::new(),
+            loop_handle,
+            relative_pointer_manager,
+            pointer_constraints,
+            text_input_manager,
+            theme_manager,
+        }
+    }
+
+    /// Handle seats update from the `SeatListener`.
+    pub fn process_seat_update(&mut self, seat: &Attached<WlSeat>, seat_data: &SeatData) {
+        let detached_seat = seat.detach();
+
+        let position = self.seats.iter().position(|si| si.seat == detached_seat);
+        let index = position.unwrap_or_else(|| {
+            self.seats.push(SeatInfo::new(detached_seat));
+            self.seats.len() - 1
+        });
+
+        let seat_info = &mut self.seats[index];
+
+        // Pointer handling.
+        if seat_data.has_pointer && !seat_data.defunct {
+            if seat_info.pointer.is_none() {
+                seat_info.pointer = Some(Pointers::new(
+                    seat,
+                    &self.theme_manager,
+                    &self.relative_pointer_manager,
+                    &self.pointer_constraints,
+                    seat_info.modifiers_state.clone(),
+                ));
+            }
+        } else {
+            seat_info.pointer = None;
+        }
+
+        // Handle keyboard.
+        if seat_data.has_keyboard && !seat_data.defunct {
+            if seat_info.keyboard.is_none() {
+                seat_info.keyboard = Keyboard::new(
+                    seat,
+                    self.loop_handle.clone(),
+                    seat_info.modifiers_state.clone(),
+                );
+            }
+        } else {
+            seat_info.keyboard = None;
+        }
+
+        // Handle touch.
+        if seat_data.has_touch && !seat_data.defunct {
+            if seat_info.touch.is_none() {
+                seat_info.touch = Some(Touch::new(seat));
+            }
+        } else {
+            seat_info.touch = None;
+        }
+
+        // Handle text input.
+        if let Some(text_input_manager) = self.text_input_manager.as_ref() {
+            if seat_data.defunct {
+                seat_info.text_input = None;
+            } else if seat_info.text_input.is_none() {
+                seat_info.text_input = Some(TextInput::new(seat, text_input_manager));
+            }
+        }
+    }
+}
+
+/// Resources associtated with a given seat.
+struct SeatInfo {
+    /// Seat to which this `SeatInfo` belongs.
+    seat: WlSeat,
+
+    /// A keyboard handle with its repeat rate handling.
+    keyboard: Option<Keyboard>,
+
+    /// All pointers we're using on a seat.
+    pointer: Option<Pointers>,
+
+    /// Touch handling.
+    touch: Option<Touch>,
+
+    /// Text input handling aka IME.
+    text_input: Option<TextInput>,
+
+    /// The current state of modifiers observed in keyboard handler.
+    ///
+    /// We keep modifiers state on a seat, since it's being used by pointer events as well.
+    modifiers_state: Rc<RefCell<ModifiersState>>,
+}
+
+impl SeatInfo {
+    pub fn new(seat: WlSeat) -> Self {
+        Self {
+            seat,
+            keyboard: None,
+            pointer: None,
+            touch: None,
+            text_input: None,
+            modifiers_state: Rc::new(RefCell::new(ModifiersState::default())),
+        }
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/seat/pointer/data.rs

@@ -0,0 +1,82 @@
+//! Data which is used in pointer callbacks.
+
+use std::cell::{Cell, RefCell};
+use std::rc::Rc;
+
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::Attached;
+use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_pointer_constraints_v1::ZwpPointerConstraintsV1;
+use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_confined_pointer_v1::ZwpConfinedPointerV1;
+use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_locked_pointer_v1::ZwpLockedPointerV1;
+
+use crate::event::{ModifiersState, TouchPhase};
+
+/// A data being used by pointer handlers.
+pub(super) struct PointerData {
+    /// Winit's surface the pointer is currently over.
+    pub surface: Option<WlSurface>,
+
+    /// Current modifiers state.
+    ///
+    /// This refers a state of modifiers from `WlKeyboard` on
+    /// the given seat.
+    pub modifiers_state: Rc<RefCell<ModifiersState>>,
+
+    /// Pointer constraints.
+    pub pointer_constraints: Option<Attached<ZwpPointerConstraintsV1>>,
+
+    pub confined_pointer: Rc<RefCell<Option<ZwpConfinedPointerV1>>>,
+    pub locked_pointer: Rc<RefCell<Option<ZwpLockedPointerV1>>>,
+
+    /// Latest observed serial in pointer events.
+    pub latest_serial: Rc<Cell<u32>>,
+
+    /// Latest observed serial in pointer enter events.
+    pub latest_enter_serial: Rc<Cell<u32>>,
+
+    /// The currently accumulated axis data on a pointer.
+    pub axis_data: AxisData,
+}
+
+impl PointerData {
+    pub fn new(
+        confined_pointer: Rc<RefCell<Option<ZwpConfinedPointerV1>>>,
+        locked_pointer: Rc<RefCell<Option<ZwpLockedPointerV1>>>,
+        pointer_constraints: Option<Attached<ZwpPointerConstraintsV1>>,
+        modifiers_state: Rc<RefCell<ModifiersState>>,
+    ) -> Self {
+        Self {
+            surface: None,
+            latest_serial: Rc::new(Cell::new(0)),
+            latest_enter_serial: Rc::new(Cell::new(0)),
+            confined_pointer,
+            locked_pointer,
+            modifiers_state,
+            pointer_constraints,
+            axis_data: AxisData::new(),
+        }
+    }
+}
+
+/// Axis data.
+#[derive(Clone, Copy)]
+pub(super) struct AxisData {
+    /// Current state of the axis.
+    pub axis_state: TouchPhase,
+
+    /// A buffer for `PixelDelta` event.
+    pub axis_buffer: Option<(f32, f32)>,
+
+    /// A buffer for `LineDelta` event.
+    pub axis_discrete_buffer: Option<(f32, f32)>,
+}
+
+impl AxisData {
+    pub fn new() -> Self {
+        Self {
+            axis_state: TouchPhase::Ended,
+            axis_buffer: None,
+            axis_discrete_buffer: None,
+        }
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/seat/pointer/handlers.rs

@@ -0,0 +1,327 @@
+//! Handlers for the pointers we're using.
+
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use sctk::reexports::client::protocol::wl_pointer::{self, Event as PointerEvent};
+use sctk::reexports::client::protocol::wl_seat::WlSeat;
+use sctk::reexports::protocols::unstable::relative_pointer::v1::client::zwp_relative_pointer_v1::Event as RelativePointerEvent;
+
+use sctk::seat::pointer::ThemedPointer;
+
+use crate::dpi::LogicalPosition;
+use crate::event::{
+    DeviceEvent, ElementState, MouseButton, MouseScrollDelta, TouchPhase, WindowEvent,
+};
+use crate::platform_impl::wayland::event_loop::WinitState;
+use crate::platform_impl::wayland::{self, DeviceId};
+
+use super::{PointerData, WinitPointer};
+
+// These values are comming from <linux/input-event-codes.h>.
+const BTN_LEFT: u32 = 0x110;
+const BTN_RIGHT: u32 = 0x111;
+const BTN_MIDDLE: u32 = 0x112;
+
+#[inline]
+pub(super) fn handle_pointer(
+    pointer: ThemedPointer,
+    event: PointerEvent,
+    pointer_data: &Rc<RefCell<PointerData>>,
+    winit_state: &mut WinitState,
+    seat: WlSeat,
+) {
+    let event_sink = &mut winit_state.event_sink;
+    let mut pointer_data = pointer_data.borrow_mut();
+    match event {
+        PointerEvent::Enter {
+            surface,
+            surface_x,
+            surface_y,
+            serial,
+            ..
+        } => {
+            pointer_data.latest_serial.replace(serial);
+            pointer_data.latest_enter_serial.replace(serial);
+
+            let window_id = wayland::make_wid(&surface);
+            let window_handle = match winit_state.window_map.get_mut(&window_id) {
+                Some(window_handle) => window_handle,
+                None => return,
+            };
+
+            let scale_factor = window_handle.scale_factor();
+            pointer_data.surface = Some(surface);
+
+            // Notify window that pointer entered the surface.
+            let winit_pointer = WinitPointer {
+                pointer,
+                confined_pointer: Rc::downgrade(&pointer_data.confined_pointer),
+                locked_pointer: Rc::downgrade(&pointer_data.locked_pointer),
+                pointer_constraints: pointer_data.pointer_constraints.clone(),
+                latest_serial: pointer_data.latest_serial.clone(),
+                latest_enter_serial: pointer_data.latest_enter_serial.clone(),
+                seat,
+            };
+            window_handle.pointer_entered(winit_pointer);
+
+            event_sink.push_window_event(
+                WindowEvent::CursorEntered {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                },
+                window_id,
+            );
+
+            let position = LogicalPosition::new(surface_x, surface_y).to_physical(scale_factor);
+
+            event_sink.push_window_event(
+                WindowEvent::CursorMoved {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                    position,
+                    modifiers: *pointer_data.modifiers_state.borrow(),
+                },
+                window_id,
+            );
+        }
+        PointerEvent::Leave { surface, serial } => {
+            pointer_data.surface = None;
+            pointer_data.latest_serial.replace(serial);
+
+            let window_id = wayland::make_wid(&surface);
+
+            let window_handle = match winit_state.window_map.get_mut(&window_id) {
+                Some(window_handle) => window_handle,
+                None => return,
+            };
+
+            // Notify a window that pointer is no longer observing it.
+            let winit_pointer = WinitPointer {
+                pointer,
+                confined_pointer: Rc::downgrade(&pointer_data.confined_pointer),
+                locked_pointer: Rc::downgrade(&pointer_data.locked_pointer),
+                pointer_constraints: pointer_data.pointer_constraints.clone(),
+                latest_serial: pointer_data.latest_serial.clone(),
+                latest_enter_serial: pointer_data.latest_enter_serial.clone(),
+                seat,
+            };
+            window_handle.pointer_left(winit_pointer);
+
+            event_sink.push_window_event(
+                WindowEvent::CursorLeft {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                },
+                window_id,
+            );
+        }
+        PointerEvent::Motion {
+            surface_x,
+            surface_y,
+            ..
+        } => {
+            let surface = match pointer_data.surface.as_ref() {
+                Some(surface) => surface,
+                None => return,
+            };
+
+            let window_id = wayland::make_wid(surface);
+            let window_handle = match winit_state.window_map.get(&window_id) {
+                Some(w) => w,
+                _ => return,
+            };
+
+            let scale_factor = window_handle.scale_factor();
+            let position = LogicalPosition::new(surface_x, surface_y).to_physical(scale_factor);
+
+            event_sink.push_window_event(
+                WindowEvent::CursorMoved {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                    position,
+                    modifiers: *pointer_data.modifiers_state.borrow(),
+                },
+                window_id,
+            );
+        }
+        PointerEvent::Button {
+            button,
+            state,
+            serial,
+            ..
+        } => {
+            pointer_data.latest_serial.replace(serial);
+            let window_id = match pointer_data.surface.as_ref().map(wayland::make_wid) {
+                Some(window_id) => window_id,
+                None => return,
+            };
+
+            let state = match state {
+                wl_pointer::ButtonState::Pressed => ElementState::Pressed,
+                wl_pointer::ButtonState::Released => ElementState::Released,
+                _ => unreachable!(),
+            };
+
+            let button = match button {
+                BTN_LEFT => MouseButton::Left,
+                BTN_RIGHT => MouseButton::Right,
+                BTN_MIDDLE => MouseButton::Middle,
+                button => MouseButton::Other(button as u16),
+            };
+
+            event_sink.push_window_event(
+                WindowEvent::MouseInput {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                    state,
+                    button,
+                    modifiers: *pointer_data.modifiers_state.borrow(),
+                },
+                window_id,
+            );
+        }
+        PointerEvent::Axis { axis, value, .. } => {
+            let surface = match pointer_data.surface.as_ref() {
+                Some(surface) => surface,
+                None => return,
+            };
+
+            let window_id = wayland::make_wid(surface);
+            let window_handle = match winit_state.window_map.get(&window_id) {
+                Some(w) => w,
+                _ => return,
+            };
+
+            if pointer.as_ref().version() < 5 {
+                let (mut x, mut y) = (0.0, 0.0);
+
+                // Old seat compatibility.
+                match axis {
+                    // Wayland sign convention is the inverse of winit.
+                    wl_pointer::Axis::VerticalScroll => y -= value as f32,
+                    wl_pointer::Axis::HorizontalScroll => x -= value as f32,
+                    _ => unreachable!(),
+                }
+
+                let scale_factor = window_handle.scale_factor();
+                let delta = LogicalPosition::new(x as f64, y as f64).to_physical(scale_factor);
+
+                event_sink.push_window_event(
+                    WindowEvent::MouseWheel {
+                        device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                            DeviceId,
+                        )),
+                        delta: MouseScrollDelta::PixelDelta(delta),
+                        phase: TouchPhase::Moved,
+                        modifiers: *pointer_data.modifiers_state.borrow(),
+                    },
+                    window_id,
+                );
+            } else {
+                let (mut x, mut y) = pointer_data.axis_data.axis_buffer.unwrap_or((0.0, 0.0));
+                match axis {
+                    // Wayland sign convention is the inverse of winit.
+                    wl_pointer::Axis::VerticalScroll => y -= value as f32,
+                    wl_pointer::Axis::HorizontalScroll => x -= value as f32,
+                    _ => unreachable!(),
+                }
+
+                pointer_data.axis_data.axis_buffer = Some((x, y));
+
+                pointer_data.axis_data.axis_state = match pointer_data.axis_data.axis_state {
+                    TouchPhase::Started | TouchPhase::Moved => TouchPhase::Moved,
+                    _ => TouchPhase::Started,
+                }
+            }
+        }
+        PointerEvent::AxisDiscrete { axis, discrete } => {
+            let (mut x, mut y) = pointer_data
+                .axis_data
+                .axis_discrete_buffer
+                .unwrap_or((0., 0.));
+
+            match axis {
+                // Wayland sign convention is the inverse of winit.
+                wl_pointer::Axis::VerticalScroll => y -= discrete as f32,
+                wl_pointer::Axis::HorizontalScroll => x -= discrete as f32,
+                _ => unreachable!(),
+            }
+
+            pointer_data.axis_data.axis_discrete_buffer = Some((x, y));
+
+            pointer_data.axis_data.axis_state = match pointer_data.axis_data.axis_state {
+                TouchPhase::Started | TouchPhase::Moved => TouchPhase::Moved,
+                _ => TouchPhase::Started,
+            }
+        }
+        PointerEvent::AxisSource { .. } => (),
+        PointerEvent::AxisStop { .. } => {
+            pointer_data.axis_data.axis_state = TouchPhase::Ended;
+        }
+        PointerEvent::Frame => {
+            let axis_buffer = pointer_data.axis_data.axis_buffer.take();
+            let axis_discrete_buffer = pointer_data.axis_data.axis_discrete_buffer.take();
+
+            let surface = match pointer_data.surface.as_ref() {
+                Some(surface) => surface,
+                None => return,
+            };
+            let window_id = wayland::make_wid(surface);
+            let window_handle = match winit_state.window_map.get(&window_id) {
+                Some(w) => w,
+                _ => return,
+            };
+
+            let window_event = if let Some((x, y)) = axis_discrete_buffer {
+                WindowEvent::MouseWheel {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                    delta: MouseScrollDelta::LineDelta(x, y),
+                    phase: pointer_data.axis_data.axis_state,
+                    modifiers: *pointer_data.modifiers_state.borrow(),
+                }
+            } else if let Some((x, y)) = axis_buffer {
+                let scale_factor = window_handle.scale_factor();
+                let delta = LogicalPosition::new(x, y).to_physical(scale_factor);
+
+                WindowEvent::MouseWheel {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                    delta: MouseScrollDelta::PixelDelta(delta),
+                    phase: pointer_data.axis_data.axis_state,
+                    modifiers: *pointer_data.modifiers_state.borrow(),
+                }
+            } else {
+                return;
+            };
+
+            event_sink.push_window_event(window_event, window_id);
+        }
+        _ => (),
+    }
+}
+
+#[inline]
+pub(super) fn handle_relative_pointer(event: RelativePointerEvent, winit_state: &mut WinitState) {
+    if let RelativePointerEvent::RelativeMotion {
+        dx_unaccel,
+        dy_unaccel,
+        ..
+    } = event
+    {
+        winit_state.event_sink.push_device_event(
+            DeviceEvent::MouseMotion {
+                delta: (dx_unaccel, dy_unaccel),
+            },
+            DeviceId,
+        )
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/seat/pointer/mod.rs

@@ -0,0 +1,343 @@
+//! All pointer related handling.
+
+use std::cell::{Cell, RefCell};
+use std::rc::{Rc, Weak};
+
+use sctk::reexports::client::protocol::wl_pointer::WlPointer;
+use sctk::reexports::client::protocol::wl_seat::WlSeat;
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::Attached;
+use sctk::reexports::protocols::unstable::relative_pointer::v1::client::zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1;
+use sctk::reexports::protocols::unstable::relative_pointer::v1::client::zwp_relative_pointer_v1::ZwpRelativePointerV1;
+use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_pointer_constraints_v1::{ZwpPointerConstraintsV1, Lifetime};
+use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_confined_pointer_v1::ZwpConfinedPointerV1;
+use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_locked_pointer_v1::ZwpLockedPointerV1;
+
+use sctk::seat::pointer::{ThemeManager, ThemedPointer};
+use sctk::window::Window;
+
+use crate::event::ModifiersState;
+use crate::platform_impl::wayland::event_loop::WinitState;
+use crate::platform_impl::wayland::window::WinitFrame;
+use crate::window::CursorIcon;
+
+mod data;
+mod handlers;
+
+use data::PointerData;
+
+/// A proxy to Wayland pointer, which serves requests from a `WindowHandle`.
+pub struct WinitPointer {
+    pointer: ThemedPointer,
+
+    /// Create confined pointers.
+    pointer_constraints: Option<Attached<ZwpPointerConstraintsV1>>,
+
+    /// Cursor to handle confine requests.
+    confined_pointer: Weak<RefCell<Option<ZwpConfinedPointerV1>>>,
+
+    /// Cursor to handle locked requests.
+    locked_pointer: Weak<RefCell<Option<ZwpLockedPointerV1>>>,
+
+    /// Latest observed serial in pointer events.
+    /// used by Window::start_interactive_move()
+    latest_serial: Rc<Cell<u32>>,
+
+    /// Latest observed serial in pointer enter events.
+    /// used by Window::set_cursor()
+    latest_enter_serial: Rc<Cell<u32>>,
+
+    /// Seat.
+    seat: WlSeat,
+}
+
+impl PartialEq for WinitPointer {
+    fn eq(&self, other: &Self) -> bool {
+        *self.pointer == *other.pointer
+    }
+}
+
+impl Eq for WinitPointer {}
+
+impl WinitPointer {
+    /// Set the cursor icon.
+    ///
+    /// Providing `None` will hide the cursor.
+    pub fn set_cursor(&self, cursor_icon: Option<CursorIcon>) {
+        let cursor_icon = match cursor_icon {
+            Some(cursor_icon) => cursor_icon,
+            None => {
+                // Hide the cursor.
+                // WlPointer::set_cursor() expects the serial of the last *enter*
+                // event (compare to to start_interactive_move()).
+                (*self.pointer).set_cursor(self.latest_enter_serial.get(), None, 0, 0);
+                return;
+            }
+        };
+
+        let cursors: &[&str] = match cursor_icon {
+            CursorIcon::Alias => &["link"],
+            CursorIcon::Arrow => &["arrow"],
+            CursorIcon::Cell => &["plus"],
+            CursorIcon::Copy => &["copy"],
+            CursorIcon::Crosshair => &["crosshair"],
+            CursorIcon::Default => &["left_ptr"],
+            CursorIcon::Hand => &["hand2", "hand1"],
+            CursorIcon::Help => &["question_arrow"],
+            CursorIcon::Move => &["move"],
+            CursorIcon::Grab => &["openhand", "grab"],
+            CursorIcon::Grabbing => &["closedhand", "grabbing"],
+            CursorIcon::Progress => &["progress"],
+            CursorIcon::AllScroll => &["all-scroll"],
+            CursorIcon::ContextMenu => &["context-menu"],
+
+            CursorIcon::NoDrop => &["no-drop", "circle"],
+            CursorIcon::NotAllowed => &["crossed_circle"],
+
+            // Resize cursors
+            CursorIcon::EResize => &["right_side"],
+            CursorIcon::NResize => &["top_side"],
+            CursorIcon::NeResize => &["top_right_corner"],
+            CursorIcon::NwResize => &["top_left_corner"],
+            CursorIcon::SResize => &["bottom_side"],
+            CursorIcon::SeResize => &["bottom_right_corner"],
+            CursorIcon::SwResize => &["bottom_left_corner"],
+            CursorIcon::WResize => &["left_side"],
+            CursorIcon::EwResize => &["h_double_arrow"],
+            CursorIcon::NsResize => &["v_double_arrow"],
+            CursorIcon::NwseResize => &["bd_double_arrow", "size_fdiag"],
+            CursorIcon::NeswResize => &["fd_double_arrow", "size_bdiag"],
+            CursorIcon::ColResize => &["split_h", "h_double_arrow"],
+            CursorIcon::RowResize => &["split_v", "v_double_arrow"],
+            CursorIcon::Text => &["text", "xterm"],
+            CursorIcon::VerticalText => &["vertical-text"],
+
+            CursorIcon::Wait => &["watch"],
+
+            CursorIcon::ZoomIn => &["zoom-in"],
+            CursorIcon::ZoomOut => &["zoom-out"],
+        };
+
+        let serial = Some(self.latest_enter_serial.get());
+        for cursor in cursors {
+            if self.pointer.set_cursor(cursor, serial).is_ok() {
+                return;
+            }
+        }
+        warn!("Failed to set cursor to {:?}", cursor_icon);
+    }
+
+    /// Confine the pointer to a surface.
+    pub fn confine(&self, surface: &WlSurface) {
+        let pointer_constraints = match &self.pointer_constraints {
+            Some(pointer_constraints) => pointer_constraints,
+            None => return,
+        };
+
+        let confined_pointer = match self.confined_pointer.upgrade() {
+            Some(confined_pointer) => confined_pointer,
+            // A pointer is gone.
+            None => return,
+        };
+
+        *confined_pointer.borrow_mut() = Some(init_confined_pointer(
+            pointer_constraints,
+            surface,
+            &self.pointer,
+        ));
+    }
+
+    /// Tries to unconfine the pointer if the current pointer is confined.
+    pub fn unconfine(&self) {
+        let confined_pointer = match self.confined_pointer.upgrade() {
+            Some(confined_pointer) => confined_pointer,
+            // A pointer is gone.
+            None => return,
+        };
+
+        let mut confined_pointer = confined_pointer.borrow_mut();
+
+        if let Some(confined_pointer) = confined_pointer.take() {
+            confined_pointer.destroy();
+        }
+    }
+
+    pub fn lock(&self, surface: &WlSurface) {
+        let pointer_constraints = match &self.pointer_constraints {
+            Some(pointer_constraints) => pointer_constraints,
+            None => return,
+        };
+
+        let locked_pointer = match self.locked_pointer.upgrade() {
+            Some(locked_pointer) => locked_pointer,
+            // A pointer is gone.
+            None => return,
+        };
+
+        *locked_pointer.borrow_mut() = Some(init_locked_pointer(
+            pointer_constraints,
+            surface,
+            &self.pointer,
+        ));
+    }
+
+    pub fn unlock(&self) {
+        let locked_pointer = match self.locked_pointer.upgrade() {
+            Some(locked_pointer) => locked_pointer,
+            // A pointer is gone.
+            None => return,
+        };
+
+        let mut locked_pointer = locked_pointer.borrow_mut();
+
+        if let Some(locked_pointer) = locked_pointer.take() {
+            locked_pointer.destroy();
+        }
+    }
+
+    pub fn set_cursor_position(&self, surface_x: u32, surface_y: u32) {
+        let locked_pointer = match self.locked_pointer.upgrade() {
+            Some(locked_pointer) => locked_pointer,
+            // A pointer is gone.
+            None => return,
+        };
+
+        let locked_pointer = locked_pointer.borrow_mut();
+        if let Some(locked_pointer) = locked_pointer.as_ref() {
+            locked_pointer.set_cursor_position_hint(surface_x.into(), surface_y.into());
+        }
+    }
+
+    pub fn drag_window(&self, window: &Window<WinitFrame>) {
+        // WlPointer::setart_interactive_move() expects the last serial of *any*
+        // pointer event (compare to set_cursor()).
+        window.start_interactive_move(&self.seat, self.latest_serial.get());
+    }
+}
+
+/// A pointer wrapper for easy releasing and managing pointers.
+pub(super) struct Pointers {
+    /// A pointer itself.
+    pointer: ThemedPointer,
+
+    /// A relative pointer handler.
+    relative_pointer: Option<ZwpRelativePointerV1>,
+
+    /// Confined pointer.
+    confined_pointer: Rc<RefCell<Option<ZwpConfinedPointerV1>>>,
+
+    /// Locked pointer.
+    locked_pointer: Rc<RefCell<Option<ZwpLockedPointerV1>>>,
+}
+
+impl Pointers {
+    pub(super) fn new(
+        seat: &Attached<WlSeat>,
+        theme_manager: &ThemeManager,
+        relative_pointer_manager: &Option<Attached<ZwpRelativePointerManagerV1>>,
+        pointer_constraints: &Option<Attached<ZwpPointerConstraintsV1>>,
+        modifiers_state: Rc<RefCell<ModifiersState>>,
+    ) -> Self {
+        let confined_pointer = Rc::new(RefCell::new(None));
+        let locked_pointer = Rc::new(RefCell::new(None));
+
+        let pointer_data = Rc::new(RefCell::new(PointerData::new(
+            confined_pointer.clone(),
+            locked_pointer.clone(),
+            pointer_constraints.clone(),
+            modifiers_state,
+        )));
+
+        let pointer_seat = seat.detach();
+        let pointer = theme_manager.theme_pointer_with_impl(
+            seat,
+            move |event, pointer, mut dispatch_data| {
+                let winit_state = dispatch_data.get::<WinitState>().unwrap();
+                handlers::handle_pointer(
+                    pointer,
+                    event,
+                    &pointer_data,
+                    winit_state,
+                    pointer_seat.clone(),
+                );
+            },
+        );
+
+        // Setup relative_pointer if it's available.
+        let relative_pointer = relative_pointer_manager
+            .as_ref()
+            .map(|relative_pointer_manager| {
+                init_relative_pointer(relative_pointer_manager, &pointer)
+            });
+
+        Self {
+            pointer,
+            relative_pointer,
+            confined_pointer,
+            locked_pointer,
+        }
+    }
+}
+
+impl Drop for Pointers {
+    fn drop(&mut self) {
+        // Drop relative pointer.
+        if let Some(relative_pointer) = self.relative_pointer.take() {
+            relative_pointer.destroy();
+        }
+
+        // Drop confined pointer.
+        if let Some(confined_pointer) = self.confined_pointer.borrow_mut().take() {
+            confined_pointer.destroy();
+        }
+
+        // Drop lock ponter.
+        if let Some(locked_pointer) = self.locked_pointer.borrow_mut().take() {
+            locked_pointer.destroy();
+        }
+
+        // Drop the pointer itself in case it's possible.
+        if self.pointer.as_ref().version() >= 3 {
+            self.pointer.release();
+        }
+    }
+}
+
+pub(super) fn init_relative_pointer(
+    relative_pointer_manager: &ZwpRelativePointerManagerV1,
+    pointer: &WlPointer,
+) -> ZwpRelativePointerV1 {
+    let relative_pointer = relative_pointer_manager.get_relative_pointer(pointer);
+    relative_pointer.quick_assign(move |_, event, mut dispatch_data| {
+        let winit_state = dispatch_data.get::<WinitState>().unwrap();
+        handlers::handle_relative_pointer(event, winit_state);
+    });
+
+    relative_pointer.detach()
+}
+
+pub(super) fn init_confined_pointer(
+    pointer_constraints: &Attached<ZwpPointerConstraintsV1>,
+    surface: &WlSurface,
+    pointer: &WlPointer,
+) -> ZwpConfinedPointerV1 {
+    let confined_pointer =
+        pointer_constraints.confine_pointer(surface, pointer, None, Lifetime::Persistent);
+
+    confined_pointer.quick_assign(move |_, _, _| {});
+
+    confined_pointer.detach()
+}
+
+pub(super) fn init_locked_pointer(
+    pointer_constraints: &Attached<ZwpPointerConstraintsV1>,
+    surface: &WlSurface,
+    pointer: &WlPointer,
+) -> ZwpLockedPointerV1 {
+    let locked_pointer =
+        pointer_constraints.lock_pointer(surface, pointer, None, Lifetime::Persistent);
+
+    locked_pointer.quick_assign(move |_, _, _| {});
+
+    locked_pointer.detach()
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/seat/text_input/handlers.rs

@@ -0,0 +1,122 @@
+//! Handling of IME events.
+
+use sctk::reexports::client::Main;
+use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input_v3::{
+    Event as TextInputEvent, ZwpTextInputV3,
+};
+
+use crate::event::{Ime, WindowEvent};
+use crate::platform_impl::wayland;
+use crate::platform_impl::wayland::event_loop::WinitState;
+
+use super::{Preedit, TextInputHandler, TextInputInner, ZwpTextInputV3Ext};
+
+#[inline]
+pub(super) fn handle_text_input(
+    text_input: Main<ZwpTextInputV3>,
+    inner: &mut TextInputInner,
+    event: TextInputEvent,
+    winit_state: &mut WinitState,
+) {
+    let event_sink = &mut winit_state.event_sink;
+    match event {
+        TextInputEvent::Enter { surface } => {
+            let window_id = wayland::make_wid(&surface);
+
+            let window_handle = match winit_state.window_map.get_mut(&window_id) {
+                Some(window_handle) => window_handle,
+                None => return,
+            };
+            inner.target_window_id = Some(window_id);
+
+            // Enable text input on that surface.
+            if window_handle.ime_allowed.get() {
+                text_input.enable();
+                text_input.set_content_type_by_purpose(window_handle.ime_purpose.get());
+                text_input.commit();
+                event_sink.push_window_event(WindowEvent::Ime(Ime::Enabled), window_id);
+            }
+
+            // Notify a window we're currently over about text input handler.
+            let text_input_handler = TextInputHandler {
+                text_input: text_input.detach(),
+            };
+            window_handle.text_input_entered(text_input_handler);
+        }
+        TextInputEvent::Leave { surface } => {
+            // Always issue a disable.
+            text_input.disable();
+            text_input.commit();
+
+            let window_id = wayland::make_wid(&surface);
+
+            let window_handle = match winit_state.window_map.get_mut(&window_id) {
+                Some(window_handle) => window_handle,
+                None => return,
+            };
+
+            inner.target_window_id = None;
+
+            // Remove text input handler from the window we're leaving.
+            let text_input_handler = TextInputHandler {
+                text_input: text_input.detach(),
+            };
+            window_handle.text_input_left(text_input_handler);
+            event_sink.push_window_event(WindowEvent::Ime(Ime::Disabled), window_id);
+        }
+        TextInputEvent::PreeditString {
+            text,
+            cursor_begin,
+            cursor_end,
+        } => {
+            let text = text.unwrap_or_default();
+            let cursor_begin = usize::try_from(cursor_begin)
+                .ok()
+                .and_then(|idx| text.is_char_boundary(idx).then(|| idx));
+            let cursor_end = usize::try_from(cursor_end)
+                .ok()
+                .and_then(|idx| text.is_char_boundary(idx).then(|| idx));
+
+            inner.pending_preedit = Some(Preedit {
+                text,
+                cursor_begin,
+                cursor_end,
+            });
+        }
+        TextInputEvent::CommitString { text } => {
+            // Update currenly commited string and reset previous preedit.
+            inner.pending_preedit = None;
+            inner.pending_commit = Some(text.unwrap_or_default());
+        }
+        TextInputEvent::Done { .. } => {
+            let window_id = match inner.target_window_id {
+                Some(window_id) => window_id,
+                _ => return,
+            };
+
+            // Clear preedit at the start of `Done`.
+            event_sink.push_window_event(
+                WindowEvent::Ime(Ime::Preedit(String::new(), None)),
+                window_id,
+            );
+
+            // Send `Commit`.
+            if let Some(text) = inner.pending_commit.take() {
+                event_sink.push_window_event(WindowEvent::Ime(Ime::Commit(text)), window_id);
+            }
+
+            // Send preedit.
+            if let Some(preedit) = inner.pending_preedit.take() {
+                let cursor_range = preedit
+                    .cursor_begin
+                    .map(|b| (b, preedit.cursor_end.unwrap_or(b)));
+
+                event_sink.push_window_event(
+                    WindowEvent::Ime(Ime::Preedit(preedit.text, cursor_range)),
+                    window_id,
+                );
+            }
+        }
+        _ => (),
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/seat/text_input/mod.rs

@@ -0,0 +1,112 @@
+use sctk::reexports::client::protocol::wl_seat::WlSeat;
+use sctk::reexports::client::Attached;
+use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input_manager_v3::ZwpTextInputManagerV3;
+use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input_v3::{
+    ContentHint, ContentPurpose, ZwpTextInputV3,
+};
+
+use crate::platform_impl::wayland::event_loop::WinitState;
+use crate::platform_impl::wayland::WindowId;
+use crate::window::ImePurpose;
+
+mod handlers;
+
+/// A handler for text input that we're advertising for `WindowHandle`.
+#[derive(Eq, PartialEq)]
+pub struct TextInputHandler {
+    text_input: ZwpTextInputV3,
+}
+
+trait ZwpTextInputV3Ext {
+    fn set_content_type_by_purpose(&self, purpose: ImePurpose);
+}
+
+impl ZwpTextInputV3Ext for ZwpTextInputV3 {
+    fn set_content_type_by_purpose(&self, purpose: ImePurpose) {
+        let (hint, purpose) = match purpose {
+            ImePurpose::Normal => (ContentHint::None, ContentPurpose::Normal),
+            ImePurpose::Password => (ContentHint::SensitiveData, ContentPurpose::Password),
+            ImePurpose::Terminal => (ContentHint::None, ContentPurpose::Terminal),
+        };
+        self.set_content_type(hint, purpose);
+    }
+}
+
+impl TextInputHandler {
+    #[inline]
+    pub fn set_ime_position(&self, x: i32, y: i32) {
+        self.text_input.set_cursor_rectangle(x, y, 0, 0);
+        self.text_input.commit();
+    }
+
+    #[inline]
+    pub fn set_content_type_by_purpose(&self, purpose: ImePurpose) {
+        self.text_input.set_content_type_by_purpose(purpose);
+        self.text_input.commit();
+    }
+
+    #[inline]
+    pub fn set_input_allowed(&self, allowed: Option<ImePurpose>) {
+        if let Some(purpose) = allowed {
+            self.text_input.set_content_type_by_purpose(purpose);
+            self.text_input.enable();
+        } else {
+            self.text_input.disable();
+        }
+
+        self.text_input.commit();
+    }
+}
+
+/// A wrapper around text input to automatically destroy the object on `Drop`.
+pub struct TextInput {
+    text_input: Attached<ZwpTextInputV3>,
+}
+
+impl TextInput {
+    pub fn new(seat: &Attached<WlSeat>, text_input_manager: &ZwpTextInputManagerV3) -> Self {
+        let text_input = text_input_manager.get_text_input(seat);
+        let mut text_input_inner = TextInputInner::new();
+        text_input.quick_assign(move |text_input, event, mut dispatch_data| {
+            let winit_state = dispatch_data.get::<WinitState>().unwrap();
+            handlers::handle_text_input(text_input, &mut text_input_inner, event, winit_state);
+        });
+
+        let text_input: Attached<ZwpTextInputV3> = text_input.into();
+
+        Self { text_input }
+    }
+}
+
+impl Drop for TextInput {
+    fn drop(&mut self) {
+        self.text_input.destroy();
+    }
+}
+
+struct TextInputInner {
+    /// Currently focused surface.
+    target_window_id: Option<WindowId>,
+
+    /// Pending commit event which will be dispatched on `text_input_v3::Done`.
+    pending_commit: Option<String>,
+
+    /// Pending preedit event which will be dispatched on `text_input_v3::Done`.
+    pending_preedit: Option<Preedit>,
+}
+
+struct Preedit {
+    text: String,
+    cursor_begin: Option<usize>,
+    cursor_end: Option<usize>,
+}
+
+impl TextInputInner {
+    fn new() -> Self {
+        Self {
+            target_window_id: None,
+            pending_commit: None,
+            pending_preedit: None,
+        }
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/seat/touch/handlers.rs

@@ -0,0 +1,144 @@
+//! Various handlers for touch events.
+
+use sctk::reexports::client::protocol::wl_touch::Event as TouchEvent;
+
+use crate::dpi::LogicalPosition;
+use crate::event::{TouchPhase, WindowEvent};
+
+use crate::platform_impl::wayland::event_loop::WinitState;
+use crate::platform_impl::wayland::{self, DeviceId};
+
+use super::{TouchInner, TouchPoint};
+
+/// Handle WlTouch events.
+#[inline]
+pub(super) fn handle_touch(
+    event: TouchEvent,
+    inner: &mut TouchInner,
+    winit_state: &mut WinitState,
+) {
+    let event_sink = &mut winit_state.event_sink;
+
+    match event {
+        TouchEvent::Down {
+            surface, id, x, y, ..
+        } => {
+            let window_id = wayland::make_wid(&surface);
+            let window_handle = match winit_state.window_map.get(&window_id) {
+                Some(w) => w,
+                _ => return,
+            };
+
+            let scale_factor = window_handle.scale_factor();
+            let position = LogicalPosition::new(x, y);
+
+            event_sink.push_window_event(
+                WindowEvent::Touch(crate::event::Touch {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                    phase: TouchPhase::Started,
+                    location: position.to_physical(scale_factor),
+                    force: None, // TODO
+                    id: id as u64,
+                }),
+                window_id,
+            );
+
+            // For `TouchEvent::Up` we don't receive a position, so we're tracking active
+            // touch points. Update either a known touch id or register a new one.
+            if let Some(i) = inner.touch_points.iter().position(|p| p.id == id) {
+                inner.touch_points[i].position = position;
+            } else {
+                inner
+                    .touch_points
+                    .push(TouchPoint::new(surface, position, id));
+            }
+        }
+        TouchEvent::Up { id, .. } => {
+            let touch_point = match inner.touch_points.iter().find(|p| p.id == id) {
+                Some(touch_point) => touch_point,
+                None => return,
+            };
+
+            let window_id = wayland::make_wid(&touch_point.surface);
+            let window_handle = match winit_state.window_map.get(&window_id) {
+                Some(w) => w,
+                _ => return,
+            };
+            let scale_factor = window_handle.scale_factor();
+            let location = touch_point.position.to_physical(scale_factor);
+            let window_id = wayland::make_wid(&touch_point.surface);
+
+            event_sink.push_window_event(
+                WindowEvent::Touch(crate::event::Touch {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                    phase: TouchPhase::Ended,
+                    location,
+                    force: None, // TODO
+                    id: id as u64,
+                }),
+                window_id,
+            );
+        }
+        TouchEvent::Motion { id, x, y, .. } => {
+            let touch_point = match inner.touch_points.iter_mut().find(|p| p.id == id) {
+                Some(touch_point) => touch_point,
+                None => return,
+            };
+            let window_id = wayland::make_wid(&touch_point.surface);
+            let window_handle = match winit_state.window_map.get(&window_id) {
+                Some(w) => w,
+                _ => return,
+            };
+
+            touch_point.position = LogicalPosition::new(x, y);
+
+            let scale_factor = window_handle.scale_factor();
+            let location = touch_point.position.to_physical(scale_factor);
+            let window_id = wayland::make_wid(&touch_point.surface);
+
+            event_sink.push_window_event(
+                WindowEvent::Touch(crate::event::Touch {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                    phase: TouchPhase::Moved,
+                    location,
+                    force: None, // TODO
+                    id: id as u64,
+                }),
+                window_id,
+            );
+        }
+        TouchEvent::Frame => (),
+        TouchEvent::Cancel => {
+            for touch_point in inner.touch_points.drain(..) {
+                let window_id = wayland::make_wid(&touch_point.surface);
+                let window_handle = match winit_state.window_map.get(&window_id) {
+                    Some(w) => w,
+                    _ => return,
+                };
+
+                let scale_factor = window_handle.scale_factor();
+                let location = touch_point.position.to_physical(scale_factor);
+
+                event_sink.push_window_event(
+                    WindowEvent::Touch(crate::event::Touch {
+                        device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                            DeviceId,
+                        )),
+                        phase: TouchPhase::Cancelled,
+                        location,
+                        force: None, // TODO
+                        id: touch_point.id as u64,
+                    }),
+                    window_id,
+                );
+            }
+        }
+        _ => (),
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/seat/touch/mod.rs

@@ -0,0 +1,78 @@
+//! Touch handling.
+
+use sctk::reexports::client::protocol::wl_seat::WlSeat;
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::protocol::wl_touch::WlTouch;
+use sctk::reexports::client::Attached;
+
+use crate::dpi::LogicalPosition;
+
+use crate::platform_impl::wayland::event_loop::WinitState;
+
+mod handlers;
+
+/// Wrapper around touch to handle release.
+pub struct Touch {
+    /// Proxy to touch.
+    touch: WlTouch,
+}
+
+impl Touch {
+    pub fn new(seat: &Attached<WlSeat>) -> Self {
+        let touch = seat.get_touch();
+        let mut inner = TouchInner::new();
+
+        touch.quick_assign(move |_, event, mut dispatch_data| {
+            let winit_state = dispatch_data.get::<WinitState>().unwrap();
+            handlers::handle_touch(event, &mut inner, winit_state);
+        });
+
+        Self {
+            touch: touch.detach(),
+        }
+    }
+}
+
+impl Drop for Touch {
+    fn drop(&mut self) {
+        if self.touch.as_ref().version() >= 3 {
+            self.touch.release();
+        }
+    }
+}
+
+/// The data used by touch handlers.
+pub(super) struct TouchInner {
+    /// Current touch points.
+    touch_points: Vec<TouchPoint>,
+}
+
+impl TouchInner {
+    fn new() -> Self {
+        Self {
+            touch_points: Vec::new(),
+        }
+    }
+}
+
+/// Location of touch press.
+pub(super) struct TouchPoint {
+    /// A surface where the touch point is located.
+    surface: WlSurface,
+
+    /// Location of the touch point.
+    position: LogicalPosition<f64>,
+
+    /// Id.
+    id: i32,
+}
+
+impl TouchPoint {
+    pub fn new(surface: WlSurface, position: LogicalPosition<f64>, id: i32) -> Self {
+        Self {
+            surface,
+            position,
+            id,
+        }
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/window/mod.rs

@@ -0,0 +1,754 @@
+use std::collections::VecDeque;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::Display;
+
+use sctk::reexports::calloop;
+
+use raw_window_handle::{
+    RawDisplayHandle, RawWindowHandle, WaylandDisplayHandle, WaylandWindowHandle,
+};
+use sctk::window::Decorations;
+use wayland_protocols::viewporter::client::wp_viewporter::WpViewporter;
+
+use crate::dpi::{LogicalSize, PhysicalPosition, PhysicalSize, Position, Size};
+use crate::error::{ExternalError, NotSupportedError, OsError as RootOsError};
+use crate::platform_impl::{
+    wayland::protocols::wp_fractional_scale_manager_v1::WpFractionalScaleManagerV1,
+    wayland::protocols::wp_fractional_scale_v1, Fullscreen, MonitorHandle as PlatformMonitorHandle,
+    OsError, PlatformSpecificWindowBuilderAttributes as PlatformAttributes,
+};
+use crate::window::{
+    CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
+    WindowAttributes, WindowButtons,
+};
+
+use super::env::WindowingFeatures;
+use super::event_loop::WinitState;
+use super::output::{MonitorHandle, OutputManagerHandle};
+use super::{EventLoopWindowTarget, WindowId};
+
+pub mod shim;
+
+use shim::{
+    FractionalScalingState, WindowCompositorUpdate, WindowHandle, WindowRequest, WindowUserRequest,
+};
+
+#[cfg(feature = "sctk-adwaita")]
+pub type WinitFrame = sctk_adwaita::AdwaitaFrame;
+#[cfg(not(feature = "sctk-adwaita"))]
+pub type WinitFrame = sctk::window::FallbackFrame;
+
+#[cfg(feature = "sctk-adwaita")]
+const WAYLAND_CSD_THEME_ENV_VAR: &str = "WINIT_WAYLAND_CSD_THEME";
+
+pub struct Window {
+    /// Window id.
+    window_id: WindowId,
+
+    /// The Wayland display.
+    display: Display,
+
+    /// The underlying wl_surface.
+    surface: WlSurface,
+
+    /// The scale factor.
+    scale_factor: Arc<Mutex<f64>>,
+
+    /// The current window size.
+    size: Arc<Mutex<LogicalSize<u32>>>,
+
+    /// A handle to output manager.
+    output_manager_handle: OutputManagerHandle,
+
+    /// Event loop proxy to wake it up.
+    event_loop_awakener: calloop::ping::Ping,
+
+    /// Fullscreen state.
+    fullscreen: Arc<AtomicBool>,
+
+    /// Maximized state.
+    maximized: Arc<AtomicBool>,
+
+    /// Available windowing features.
+    windowing_features: WindowingFeatures,
+
+    /// Requests that SCTK window should perform.
+    window_requests: Arc<Mutex<Vec<WindowRequest>>>,
+
+    /// Whether the window is resizeable.
+    resizeable: AtomicBool,
+
+    /// Whether the window is decorated.
+    decorated: AtomicBool,
+
+    /// Grabbing mode.
+    cursor_grab_mode: Mutex<CursorGrabMode>,
+
+    /// Whether the window has keyboard focus.
+    has_focus: Arc<AtomicBool>,
+}
+
+impl Window {
+    pub(crate) fn new<T>(
+        event_loop_window_target: &EventLoopWindowTarget<T>,
+        attributes: WindowAttributes,
+        platform_attributes: PlatformAttributes,
+    ) -> Result<Self, RootOsError> {
+        let viewporter = event_loop_window_target.env.get_global::<WpViewporter>();
+        let fractional_scale_manager = event_loop_window_target
+            .env
+            .get_global::<WpFractionalScaleManagerV1>();
+
+        // Create surface and register callback for the scale factor changes.
+        let mut scale_factor = 1.;
+        let (surface, fractional_scaling_state) =
+            if let (Some(viewporter), Some(fractional_scale_manager)) =
+                (viewporter, fractional_scale_manager)
+            {
+                let surface = event_loop_window_target.env.create_surface().detach();
+                let fractional_scale = fractional_scale_manager.get_fractional_scale(&surface);
+
+                let window_id = super::make_wid(&surface);
+                fractional_scale.quick_assign(move |_, event, mut dispatch_data| {
+                    let wp_fractional_scale_v1::Event::PreferredScale { scale } = event;
+                    let winit_state = dispatch_data.get::<WinitState>().unwrap();
+                    apply_scale(window_id, scale as f64 / 120., winit_state);
+                });
+
+                let fractional_scale = fractional_scale.detach();
+                let viewport = viewporter.get_viewport(&surface).detach();
+                let fractional_scaling_state =
+                    FractionalScalingState::new(viewport, fractional_scale);
+
+                (surface, Some(fractional_scaling_state))
+            } else {
+                let surface = event_loop_window_target
+                    .env
+                    .create_surface_with_scale_callback(move |scale, surface, mut dispatch_data| {
+                        // While I'm not sure how this could happen, we can safely ignore it
+                        // for now as a quickfix.
+                        if !surface.as_ref().is_alive() {
+                            return;
+                        }
+
+                        let winit_state = dispatch_data.get::<WinitState>().unwrap();
+
+                        // Get the window that received the event.
+                        let window_id = super::make_wid(&surface);
+                        apply_scale(window_id, scale as f64, winit_state);
+                        surface.set_buffer_scale(scale);
+                    })
+                    .detach();
+
+                scale_factor = sctk::get_surface_scale_factor(&surface) as _;
+
+                (surface, None)
+            };
+
+        let window_id = super::make_wid(&surface);
+        let maximized = Arc::new(AtomicBool::new(false));
+        let maximized_clone = maximized.clone();
+        let fullscreen = Arc::new(AtomicBool::new(false));
+        let fullscreen_clone = fullscreen.clone();
+
+        let (width, height) = attributes
+            .inner_size
+            .map(|size| size.to_logical::<f64>(scale_factor).into())
+            .unwrap_or((800, 600));
+
+        let theme_manager = event_loop_window_target.theme_manager.clone();
+        let mut window = event_loop_window_target
+            .env
+            .create_window::<WinitFrame, _>(
+                surface.clone(),
+                Some(theme_manager),
+                (width, height),
+                move |event, mut dispatch_data| {
+                    use sctk::window::{Event, State};
+
+                    let winit_state = dispatch_data.get::<WinitState>().unwrap();
+                    let window_compositor_update = winit_state
+                        .window_compositor_updates
+                        .get_mut(&window_id)
+                        .unwrap();
+
+                    let window_user_requests = winit_state
+                        .window_user_requests
+                        .get_mut(&window_id)
+                        .unwrap();
+
+                    match event {
+                        Event::Refresh => {
+                            window_user_requests.refresh_frame = true;
+                        }
+                        Event::Configure { new_size, states } => {
+                            let is_maximized = states.contains(&State::Maximized);
+                            maximized_clone.store(is_maximized, Ordering::Relaxed);
+                            let is_fullscreen = states.contains(&State::Fullscreen);
+                            fullscreen_clone.store(is_fullscreen, Ordering::Relaxed);
+
+                            window_user_requests.refresh_frame = true;
+                            if let Some((w, h)) = new_size {
+                                window_compositor_update.size = Some(LogicalSize::new(w, h));
+                            }
+                        }
+                        Event::Close => {
+                            window_compositor_update.close_window = true;
+                        }
+                    }
+                },
+            )
+            .map_err(|_| os_error!(OsError::WaylandMisc("failed to create window.")))?;
+
+        // Set CSD frame config from theme if specified,
+        // otherwise use upstream automatic selection.
+        #[cfg(feature = "sctk-adwaita")]
+        if let Some(theme) = attributes.preferred_theme.or_else(|| {
+            std::env::var(WAYLAND_CSD_THEME_ENV_VAR)
+                .ok()
+                .and_then(|s| s.as_str().try_into().ok())
+        }) {
+            window.set_frame_config(theme.into());
+        }
+
+        // Set decorations.
+        if attributes.decorations {
+            window.set_decorate(Decorations::FollowServer);
+        } else {
+            window.set_decorate(Decorations::None);
+        }
+
+        // Min dimensions.
+        let min_size = attributes
+            .min_inner_size
+            .map(|size| size.to_logical::<f64>(scale_factor).into());
+        window.set_min_size(min_size);
+
+        // Max dimensions.
+        let max_size = attributes
+            .max_inner_size
+            .map(|size| size.to_logical::<f64>(scale_factor).into());
+        window.set_max_size(max_size);
+
+        // Set Wayland specific window attributes.
+        if let Some(name) = platform_attributes.name {
+            window.set_app_id(name.general);
+        }
+
+        // Set common window attributes.
+        //
+        // We set resizable after other attributes, since it touches min and max size under
+        // the hood.
+        window.set_resizable(attributes.resizable);
+        window.set_title(attributes.title);
+
+        // Set fullscreen/maximized if so was requested.
+        match attributes.fullscreen.map(Into::into) {
+            Some(Fullscreen::Exclusive(_)) => {
+                warn!("`Fullscreen::Exclusive` is ignored on Wayland")
+            }
+            Some(Fullscreen::Borderless(monitor)) => {
+                let monitor = monitor.and_then(|monitor| match monitor {
+                    PlatformMonitorHandle::Wayland(monitor) => Some(monitor.proxy),
+                    #[cfg(x11_platform)]
+                    PlatformMonitorHandle::X(_) => None,
+                });
+
+                window.set_fullscreen(monitor.as_ref());
+            }
+            None => {
+                if attributes.maximized {
+                    window.set_maximized();
+                }
+            }
+        }
+
+        // Without this commit here at least on kwin 5.23.3 the initial configure
+        // will have a size (1,1), the second configure including the decoration
+        // mode will have the min_size as its size. With this commit the initial
+        // configure will have no size, the application will draw it's content
+        // with the initial size and everything works as expected afterwards.
+        //
+        // The window commit must be after setting on top level properties, but right before any
+        // buffer attachments commits.
+        window.surface().commit();
+
+        let size = Arc::new(Mutex::new(LogicalSize::new(width, height)));
+        let has_focus = Arc::new(AtomicBool::new(true));
+
+        // We should trigger redraw and commit the surface for the newly created window.
+        let mut window_user_request = WindowUserRequest::new();
+        window_user_request.refresh_frame = true;
+        window_user_request.redraw_requested = true;
+
+        let window_id = super::make_wid(&surface);
+        let window_requests = Arc::new(Mutex::new(Vec::with_capacity(64)));
+
+        // Create a handle that performs all the requests on underlying sctk a window.
+        let window_handle = WindowHandle::new(
+            &event_loop_window_target.env,
+            window,
+            size.clone(),
+            has_focus.clone(),
+            fractional_scaling_state,
+            scale_factor,
+            window_requests.clone(),
+        );
+
+        // Set opaque region.
+        window_handle.set_transparent(attributes.transparent);
+
+        // Set resizable state, so we can determine how to handle `Window::set_inner_size`.
+        window_handle.is_resizable.set(attributes.resizable);
+
+        let mut winit_state = event_loop_window_target.state.borrow_mut();
+
+        winit_state.window_map.insert(window_id, window_handle);
+
+        // On Wayland window doesn't have Focus by default and it'll get it later on. So be
+        // explicit here.
+        winit_state
+            .event_sink
+            .push_window_event(crate::event::WindowEvent::Focused(false), window_id);
+
+        // Add state for the window.
+        winit_state
+            .window_user_requests
+            .insert(window_id, window_user_request);
+        winit_state
+            .window_compositor_updates
+            .insert(window_id, WindowCompositorUpdate::new());
+
+        let windowing_features = event_loop_window_target.windowing_features;
+
+        // To make our window usable for drawing right away we must `ack` a `configure`
+        // from the server, the acking part here is done by SCTK window frame, so we just
+        // need to sync with server so it'll be done automatically for us.
+        {
+            let mut wayland_source = event_loop_window_target.wayland_dispatcher.as_source_mut();
+            let event_queue = wayland_source.queue();
+            let _ = event_queue.sync_roundtrip(&mut *winit_state, |_, _, _| unreachable!());
+        }
+
+        // We all praise GNOME for these 3 lines of pure magic. If we don't do that,
+        // GNOME will shrink our window a bit for the size of the decorations. I guess it
+        // happens because we haven't committed them with buffers to the server.
+        let window_handle = winit_state.window_map.get_mut(&window_id).unwrap();
+        window_handle.window.refresh();
+
+        let output_manager_handle = event_loop_window_target.output_manager.handle();
+
+        let window = Self {
+            window_id,
+            surface,
+            display: event_loop_window_target.display.clone(),
+            output_manager_handle,
+            size,
+            window_requests,
+            event_loop_awakener: event_loop_window_target.event_loop_awakener.clone(),
+            fullscreen,
+            maximized,
+            windowing_features,
+            resizeable: AtomicBool::new(attributes.resizable),
+            decorated: AtomicBool::new(attributes.decorations),
+            cursor_grab_mode: Mutex::new(CursorGrabMode::None),
+            has_focus,
+            scale_factor: window_handle.scale_factor.clone(),
+        };
+
+        Ok(window)
+    }
+}
+
+impl Window {
+    #[inline]
+    pub fn id(&self) -> WindowId {
+        self.window_id
+    }
+
+    #[inline]
+    pub fn set_title(&self, title: &str) {
+        self.send_request(WindowRequest::Title(title.to_owned()));
+    }
+
+    #[inline]
+    pub fn set_transparent(&self, transparent: bool) {
+        self.send_request(WindowRequest::Transparent(transparent));
+    }
+
+    #[inline]
+    pub fn set_visible(&self, _visible: bool) {
+        // Not possible on Wayland.
+    }
+
+    #[inline]
+    pub fn is_visible(&self) -> Option<bool> {
+        None
+    }
+
+    #[inline]
+    pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
+        Err(NotSupportedError::new())
+    }
+
+    #[inline]
+    pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
+        Err(NotSupportedError::new())
+    }
+
+    #[inline]
+    pub fn set_outer_position(&self, _: Position) {
+        // Not possible on Wayland.
+    }
+
+    pub fn inner_size(&self) -> PhysicalSize<u32> {
+        self.size.lock().unwrap().to_physical(self.scale_factor())
+    }
+
+    #[inline]
+    pub fn request_redraw(&self) {
+        self.send_request(WindowRequest::Redraw);
+    }
+
+    #[inline]
+    pub fn outer_size(&self) -> PhysicalSize<u32> {
+        self.size.lock().unwrap().to_physical(self.scale_factor())
+    }
+
+    #[inline]
+    pub fn set_inner_size(&self, size: Size) {
+        let scale_factor = self.scale_factor();
+
+        let size = size.to_logical::<u32>(scale_factor);
+        *self.size.lock().unwrap() = size;
+
+        self.send_request(WindowRequest::FrameSize(size));
+    }
+
+    #[inline]
+    pub fn set_min_inner_size(&self, dimensions: Option<Size>) {
+        let scale_factor = self.scale_factor();
+        let size = dimensions.map(|size| size.to_logical::<u32>(scale_factor));
+
+        self.send_request(WindowRequest::MinSize(size));
+    }
+
+    #[inline]
+    pub fn set_max_inner_size(&self, dimensions: Option<Size>) {
+        let scale_factor = self.scale_factor();
+        let size = dimensions.map(|size| size.to_logical::<u32>(scale_factor));
+
+        self.send_request(WindowRequest::MaxSize(size));
+    }
+
+    #[inline]
+    pub fn resize_increments(&self) -> Option<PhysicalSize<u32>> {
+        None
+    }
+
+    #[inline]
+    pub fn set_resize_increments(&self, _increments: Option<Size>) {
+        warn!("`set_resize_increments` is not implemented for Wayland");
+    }
+
+    #[inline]
+    pub fn set_resizable(&self, resizable: bool) {
+        self.resizeable.store(resizable, Ordering::Relaxed);
+        self.send_request(WindowRequest::Resizeable(resizable));
+    }
+
+    #[inline]
+    pub fn is_resizable(&self) -> bool {
+        self.resizeable.load(Ordering::Relaxed)
+    }
+
+    #[inline]
+    pub fn set_enabled_buttons(&self, _buttons: WindowButtons) {}
+
+    #[inline]
+    pub fn enabled_buttons(&self) -> WindowButtons {
+        WindowButtons::all()
+    }
+
+    #[inline]
+    pub fn scale_factor(&self) -> f64 {
+        *self.scale_factor.lock().unwrap()
+    }
+
+    #[inline]
+    pub fn set_decorations(&self, decorate: bool) {
+        self.decorated.store(decorate, Ordering::Relaxed);
+        self.send_request(WindowRequest::Decorate(decorate));
+    }
+
+    #[inline]
+    pub fn is_decorated(&self) -> bool {
+        self.decorated.load(Ordering::Relaxed)
+    }
+
+    #[inline]
+    pub fn is_minimized(&self) -> Option<bool> {
+        None
+    }
+
+    #[inline]
+    pub fn set_minimized(&self, minimized: bool) {
+        // You can't unminimize the window on Wayland.
+        if !minimized {
+            return;
+        }
+
+        self.send_request(WindowRequest::Minimize);
+    }
+
+    #[inline]
+    pub fn is_maximized(&self) -> bool {
+        self.maximized.load(Ordering::Relaxed)
+    }
+
+    #[inline]
+    pub fn set_maximized(&self, maximized: bool) {
+        self.send_request(WindowRequest::Maximize(maximized));
+    }
+
+    #[inline]
+    pub(crate) fn fullscreen(&self) -> Option<Fullscreen> {
+        if self.fullscreen.load(Ordering::Relaxed) {
+            let current_monitor = self.current_monitor().map(PlatformMonitorHandle::Wayland);
+
+            Some(Fullscreen::Borderless(current_monitor))
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    pub(crate) fn set_fullscreen(&self, fullscreen: Option<Fullscreen>) {
+        let fullscreen_request = match fullscreen {
+            Some(Fullscreen::Exclusive(_)) => {
+                warn!("`Fullscreen::Exclusive` is ignored on Wayland");
+                return;
+            }
+            Some(Fullscreen::Borderless(monitor)) => {
+                let monitor = monitor.and_then(|monitor| match monitor {
+                    PlatformMonitorHandle::Wayland(monitor) => Some(monitor.proxy),
+                    #[cfg(x11_platform)]
+                    PlatformMonitorHandle::X(_) => None,
+                });
+
+                WindowRequest::Fullscreen(monitor)
+            }
+            None => WindowRequest::UnsetFullscreen,
+        };
+
+        self.send_request(fullscreen_request);
+    }
+
+    #[inline]
+    pub fn set_cursor_icon(&self, cursor: CursorIcon) {
+        self.send_request(WindowRequest::NewCursorIcon(cursor));
+    }
+
+    #[inline]
+    pub fn set_cursor_visible(&self, visible: bool) {
+        self.send_request(WindowRequest::ShowCursor(visible));
+    }
+
+    #[inline]
+    pub fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), ExternalError> {
+        if !self.windowing_features.pointer_constraints() {
+            if mode == CursorGrabMode::None {
+                return Ok(());
+            }
+
+            return Err(ExternalError::NotSupported(NotSupportedError::new()));
+        }
+
+        *self.cursor_grab_mode.lock().unwrap() = mode;
+        self.send_request(WindowRequest::SetCursorGrabMode(mode));
+
+        Ok(())
+    }
+
+    pub fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
+        if !self.windowing_features.xdg_activation() {
+            warn!("`request_user_attention` isn't supported");
+            return;
+        }
+
+        self.send_request(WindowRequest::Attention(request_type));
+    }
+
+    #[inline]
+    pub fn set_cursor_position(&self, position: Position) -> Result<(), ExternalError> {
+        // Positon can be set only for locked cursor.
+        if *self.cursor_grab_mode.lock().unwrap() != CursorGrabMode::Locked {
+            return Err(ExternalError::Os(os_error!(OsError::WaylandMisc(
+                "cursor position can be set only for locked cursor."
+            ))));
+        }
+
+        let scale_factor = self.scale_factor();
+        let position = position.to_logical(scale_factor);
+        self.send_request(WindowRequest::SetLockedCursorPosition(position));
+
+        Ok(())
+    }
+
+    #[inline]
+    pub fn drag_window(&self) -> Result<(), ExternalError> {
+        self.send_request(WindowRequest::DragWindow);
+
+        Ok(())
+    }
+
+    #[inline]
+    pub fn drag_resize_window(&self, _direction: ResizeDirection) -> Result<(), ExternalError> {
+        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    }
+
+    #[inline]
+    pub fn set_cursor_hittest(&self, hittest: bool) -> Result<(), ExternalError> {
+        self.send_request(WindowRequest::PassthroughMouseInput(!hittest));
+
+        Ok(())
+    }
+
+    #[inline]
+    pub fn set_ime_position(&self, position: Position) {
+        let scale_factor = self.scale_factor();
+        let position = position.to_logical(scale_factor);
+        self.send_request(WindowRequest::ImePosition(position));
+    }
+
+    #[inline]
+    pub fn set_ime_allowed(&self, allowed: bool) {
+        self.send_request(WindowRequest::AllowIme(allowed));
+    }
+
+    #[inline]
+    pub fn set_ime_purpose(&self, purpose: ImePurpose) {
+        self.send_request(WindowRequest::ImePurpose(purpose));
+    }
+
+    #[inline]
+    pub fn display(&self) -> &Display {
+        &self.display
+    }
+
+    #[inline]
+    pub fn surface(&self) -> &WlSurface {
+        &self.surface
+    }
+
+    #[inline]
+    pub fn current_monitor(&self) -> Option<MonitorHandle> {
+        let output = sctk::get_surface_outputs(&self.surface).last()?.clone();
+        Some(MonitorHandle::new(output))
+    }
+
+    #[inline]
+    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
+        self.output_manager_handle.available_outputs()
+    }
+
+    #[inline]
+    pub fn primary_monitor(&self) -> Option<PlatformMonitorHandle> {
+        None
+    }
+
+    #[inline]
+    pub fn raw_window_handle(&self) -> RawWindowHandle {
+        let mut window_handle = WaylandWindowHandle::empty();
+        window_handle.surface = self.surface.as_ref().c_ptr() as *mut _;
+        RawWindowHandle::Wayland(window_handle)
+    }
+
+    #[inline]
+    pub fn raw_display_handle(&self) -> RawDisplayHandle {
+        let mut display_handle = WaylandDisplayHandle::empty();
+        display_handle.display = self.display.get_display_ptr() as *mut _;
+        RawDisplayHandle::Wayland(display_handle)
+    }
+
+    #[inline]
+    fn send_request(&self, request: WindowRequest) {
+        self.window_requests.lock().unwrap().push(request);
+        self.event_loop_awakener.ping();
+    }
+
+    #[inline]
+    pub fn set_theme(&self, theme: Option<Theme>) {
+        self.send_request(WindowRequest::Theme(theme));
+    }
+
+    #[inline]
+    pub fn theme(&self) -> Option<Theme> {
+        None
+    }
+
+    #[inline]
+    pub fn has_focus(&self) -> bool {
+        self.has_focus.load(Ordering::Relaxed)
+    }
+
+    pub fn title(&self) -> String {
+        String::new()
+    }
+}
+
+impl Drop for Window {
+    fn drop(&mut self) {
+        self.send_request(WindowRequest::Close);
+    }
+}
+
+#[cfg(feature = "sctk-adwaita")]
+impl From<Theme> for sctk_adwaita::FrameConfig {
+    fn from(theme: Theme) -> Self {
+        match theme {
+            Theme::Light => sctk_adwaita::FrameConfig::light(),
+            Theme::Dark => sctk_adwaita::FrameConfig::dark(),
+        }
+    }
+}
+
+impl TryFrom<&str> for Theme {
+    type Error = ();
+
+    /// ```
+    /// use winit::window::Theme;
+    ///
+    /// assert_eq!("dark".try_into(), Ok(Theme::Dark));
+    /// assert_eq!("lIghT".try_into(), Ok(Theme::Light));
+    /// ```
+    fn try_from(theme: &str) -> Result<Self, Self::Error> {
+        if theme.eq_ignore_ascii_case("dark") {
+            Ok(Self::Dark)
+        } else if theme.eq_ignore_ascii_case("light") {
+            Ok(Self::Light)
+        } else {
+            Err(())
+        }
+    }
+}
+
+/// Set pending scale for the provided `window_id`.
+fn apply_scale(window_id: WindowId, scale: f64, winit_state: &mut WinitState) {
+    // Set pending scale factor.
+    winit_state
+        .window_compositor_updates
+        .get_mut(&window_id)
+        .unwrap()
+        .scale_factor = Some(scale);
+
+    // Mark that we need a frame refresh on the DPI change.
+    winit_state
+        .window_user_requests
+        .get_mut(&window_id)
+        .unwrap()
+        .refresh_frame = true;
+}

third-party/vendor/winit/src/platform_impl/linux/wayland/window/shim.rs

@@ -0,0 +1,666 @@
+use std::cell::Cell;
+use std::mem::ManuallyDrop;
+use std::sync::atomic::AtomicBool;
+use std::sync::{Arc, Mutex};
+
+use sctk::reexports::client::protocol::wl_compositor::WlCompositor;
+use sctk::reexports::client::protocol::wl_output::WlOutput;
+use sctk::reexports::client::Attached;
+use sctk::reexports::protocols::staging::xdg_activation::v1::client::xdg_activation_token_v1;
+use sctk::reexports::protocols::staging::xdg_activation::v1::client::xdg_activation_v1::XdgActivationV1;
+
+use sctk::environment::Environment;
+use sctk::window::{Decorations, Window};
+use wayland_protocols::viewporter::client::wp_viewport::WpViewport;
+
+use crate::dpi::{LogicalPosition, LogicalSize};
+
+use crate::event::{Ime, WindowEvent};
+use crate::platform_impl::wayland;
+use crate::platform_impl::wayland::env::WinitEnv;
+use crate::platform_impl::wayland::event_loop::{EventSink, WinitState};
+use crate::platform_impl::wayland::protocols::wp_fractional_scale_v1::WpFractionalScaleV1;
+use crate::platform_impl::wayland::seat::pointer::WinitPointer;
+use crate::platform_impl::wayland::seat::text_input::TextInputHandler;
+use crate::platform_impl::wayland::WindowId;
+use crate::window::{CursorGrabMode, CursorIcon, ImePurpose, Theme, UserAttentionType};
+
+use super::WinitFrame;
+
+/// A request to SCTK window from Winit window.
+#[derive(Debug, Clone)]
+pub enum WindowRequest {
+    /// Set fullscreen.
+    ///
+    /// Passing `None` will set it on the current monitor.
+    Fullscreen(Option<WlOutput>),
+
+    /// Unset fullscreen.
+    UnsetFullscreen,
+
+    /// Show cursor for the certain window or not.
+    ShowCursor(bool),
+
+    /// Change the cursor icon.
+    NewCursorIcon(CursorIcon),
+
+    /// Change cursor grabbing mode.
+    SetCursorGrabMode(CursorGrabMode),
+
+    /// Set cursor position.
+    SetLockedCursorPosition(LogicalPosition<u32>),
+
+    /// Drag window.
+    DragWindow,
+
+    /// Maximize the window.
+    Maximize(bool),
+
+    /// Minimize the window.
+    Minimize,
+
+    /// Request decorations change.
+    Decorate(bool),
+
+    /// Make the window resizeable.
+    Resizeable(bool),
+
+    /// Set the title for window.
+    Title(String),
+
+    /// Min size.
+    MinSize(Option<LogicalSize<u32>>),
+
+    /// Max size.
+    MaxSize(Option<LogicalSize<u32>>),
+
+    /// New frame size.
+    FrameSize(LogicalSize<u32>),
+
+    /// Set IME window position.
+    ImePosition(LogicalPosition<u32>),
+
+    /// Enable IME on the given window.
+    AllowIme(bool),
+
+    /// Set the IME purpose.
+    ImePurpose(ImePurpose),
+
+    /// Mark the window as opaque.
+    Transparent(bool),
+
+    /// Request Attention.
+    ///
+    /// `None` unsets the attention request.
+    Attention(Option<UserAttentionType>),
+
+    /// Passthrough mouse input to underlying windows.
+    PassthroughMouseInput(bool),
+
+    /// Redraw was requested.
+    Redraw,
+
+    /// Window should be closed.
+    Close,
+
+    /// Change window theme.
+    Theme(Option<Theme>),
+}
+
+// The window update comming from the compositor.
+#[derive(Default, Debug, Clone, Copy)]
+pub struct WindowCompositorUpdate {
+    /// New window size.
+    pub size: Option<LogicalSize<u32>>,
+
+    /// New scale factor.
+    pub scale_factor: Option<f64>,
+
+    /// Close the window.
+    pub close_window: bool,
+}
+
+impl WindowCompositorUpdate {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Pending update to a window requested by the user.
+#[derive(Default, Debug, Clone, Copy)]
+pub struct WindowUserRequest {
+    /// Whether `redraw` was requested.
+    pub redraw_requested: bool,
+
+    /// Wether the frame should be refreshed.
+    pub refresh_frame: bool,
+}
+
+impl WindowUserRequest {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// A handle to perform operations on SCTK window
+/// and react to events.
+pub struct WindowHandle {
+    /// An actual window.
+    pub window: ManuallyDrop<Window<WinitFrame>>,
+
+    /// The state of the fractional scaling handlers for the window.
+    pub fractional_scaling_state: Option<FractionalScalingState>,
+
+    /// The scale factor of the window.
+    pub scale_factor: Arc<Mutex<f64>>,
+
+    /// The current size of the window.
+    pub size: Arc<Mutex<LogicalSize<u32>>>,
+
+    /// A pending requests to SCTK window.
+    pub pending_window_requests: Arc<Mutex<Vec<WindowRequest>>>,
+
+    /// Current cursor icon.
+    pub cursor_icon: Cell<CursorIcon>,
+
+    /// Whether the window is resizable.
+    pub is_resizable: Cell<bool>,
+
+    /// Whether the window has keyboard focus.
+    pub has_focus: Arc<AtomicBool>,
+
+    /// Allow IME events for that window.
+    pub ime_allowed: Cell<bool>,
+
+    /// IME purpose for that window.
+    pub ime_purpose: Cell<ImePurpose>,
+
+    /// Wether the window is transparent.
+    pub transparent: Cell<bool>,
+
+    /// Visible cursor or not.
+    cursor_visible: Cell<bool>,
+
+    /// Cursor confined to the surface.
+    cursor_grab_mode: Cell<CursorGrabMode>,
+
+    /// Pointers over the current surface.
+    pointers: Vec<WinitPointer>,
+
+    /// Text inputs on the current surface.
+    text_inputs: Vec<TextInputHandler>,
+
+    /// XdgActivation object.
+    xdg_activation: Option<Attached<XdgActivationV1>>,
+
+    /// Indicator whether user attention is requested.
+    attention_requested: Cell<bool>,
+
+    /// Compositor
+    compositor: Attached<WlCompositor>,
+}
+
+impl WindowHandle {
+    pub fn new(
+        env: &Environment<WinitEnv>,
+        window: Window<WinitFrame>,
+        size: Arc<Mutex<LogicalSize<u32>>>,
+        has_focus: Arc<AtomicBool>,
+        fractional_scaling_state: Option<FractionalScalingState>,
+        scale_factor: f64,
+        pending_window_requests: Arc<Mutex<Vec<WindowRequest>>>,
+    ) -> Self {
+        let xdg_activation = env.get_global::<XdgActivationV1>();
+        // Unwrap is safe, since we can't create window without compositor anyway and won't be
+        // here.
+        let compositor = env.get_global::<WlCompositor>().unwrap();
+
+        Self {
+            window: ManuallyDrop::new(window),
+            fractional_scaling_state,
+            scale_factor: Arc::new(Mutex::new(scale_factor)),
+            size,
+            pending_window_requests,
+            cursor_icon: Cell::new(CursorIcon::Default),
+            is_resizable: Cell::new(true),
+            transparent: Cell::new(false),
+            cursor_grab_mode: Cell::new(CursorGrabMode::None),
+            cursor_visible: Cell::new(true),
+            pointers: Vec::new(),
+            text_inputs: Vec::new(),
+            xdg_activation,
+            attention_requested: Cell::new(false),
+            compositor,
+            ime_allowed: Cell::new(false),
+            ime_purpose: Cell::new(ImePurpose::default()),
+            has_focus,
+        }
+    }
+
+    pub fn scale_factor(&self) -> f64 {
+        *self.scale_factor.lock().unwrap()
+    }
+
+    pub fn set_cursor_grab(&self, mode: CursorGrabMode) {
+        // The new requested state matches the current confine status, return.
+        let old_mode = self.cursor_grab_mode.replace(mode);
+        if old_mode == mode {
+            return;
+        }
+
+        // Clear old pointer data.
+        match old_mode {
+            CursorGrabMode::None => (),
+            CursorGrabMode::Confined => self.pointers.iter().for_each(|p| p.unconfine()),
+            CursorGrabMode::Locked => self.pointers.iter().for_each(|p| p.unlock()),
+        }
+
+        let surface = self.window.surface();
+        match mode {
+            CursorGrabMode::Locked => self.pointers.iter().for_each(|p| p.lock(surface)),
+            CursorGrabMode::Confined => self.pointers.iter().for_each(|p| p.confine(surface)),
+            CursorGrabMode::None => {
+                // Current lock/confine was already removed.
+            }
+        }
+    }
+
+    pub fn set_locked_cursor_position(&self, position: LogicalPosition<u32>) {
+        // XXX the cursor locking is ensured inside `Window`.
+        self.pointers
+            .iter()
+            .for_each(|p| p.set_cursor_position(position.x, position.y));
+    }
+
+    pub fn set_user_attention(&self, request_type: Option<UserAttentionType>) {
+        let xdg_activation = match self.xdg_activation.as_ref() {
+            None => return,
+            Some(xdg_activation) => xdg_activation,
+        };
+
+        //  Urgency is only removed by the compositor and there's no need to raise urgency when it
+        //  was already raised.
+        if request_type.is_none() || self.attention_requested.get() {
+            return;
+        }
+
+        let xdg_activation_token = xdg_activation.get_activation_token();
+        let surface = self.window.surface();
+        let window_id = wayland::make_wid(surface);
+        let xdg_activation = xdg_activation.clone();
+
+        xdg_activation_token.quick_assign(move |xdg_token, event, mut dispatch_data| {
+            let token = match event {
+                xdg_activation_token_v1::Event::Done { token } => token,
+                _ => return,
+            };
+
+            let winit_state = dispatch_data.get::<WinitState>().unwrap();
+            let window_handle = match winit_state.window_map.get_mut(&window_id) {
+                Some(window_handle) => window_handle,
+                None => return,
+            };
+
+            let surface = window_handle.window.surface();
+            xdg_activation.activate(token, surface);
+
+            // Mark that attention request was done and drop the token.
+            window_handle.attention_requested.replace(false);
+            xdg_token.destroy();
+        });
+
+        xdg_activation_token.set_surface(surface);
+        xdg_activation_token.commit();
+        self.attention_requested.replace(true);
+    }
+
+    /// Pointer appeared over the window.
+    pub fn pointer_entered(&mut self, pointer: WinitPointer) {
+        let position = self.pointers.iter().position(|p| *p == pointer);
+
+        if position.is_none() {
+            let surface = self.window.surface();
+            match self.cursor_grab_mode.get() {
+                CursorGrabMode::None => (),
+                CursorGrabMode::Locked => pointer.lock(surface),
+                CursorGrabMode::Confined => pointer.confine(surface),
+            }
+
+            self.pointers.push(pointer);
+        }
+
+        // Apply the current cursor style.
+        self.set_cursor_visible(self.cursor_visible.get());
+    }
+
+    /// Pointer left the window.
+    pub fn pointer_left(&mut self, pointer: WinitPointer) {
+        let position = self.pointers.iter().position(|p| *p == pointer);
+
+        if let Some(position) = position {
+            let pointer = self.pointers.remove(position);
+
+            // Drop the grabbing mode.
+            match self.cursor_grab_mode.get() {
+                CursorGrabMode::None => (),
+                CursorGrabMode::Locked => pointer.unlock(),
+                CursorGrabMode::Confined => pointer.unconfine(),
+            }
+        }
+    }
+
+    pub fn text_input_entered(&mut self, text_input: TextInputHandler) {
+        if !self.text_inputs.iter().any(|t| *t == text_input) {
+            self.text_inputs.push(text_input);
+        }
+    }
+
+    pub fn text_input_left(&mut self, text_input: TextInputHandler) {
+        if let Some(position) = self.text_inputs.iter().position(|t| *t == text_input) {
+            self.text_inputs.remove(position);
+        }
+    }
+
+    pub fn set_ime_position(&self, position: LogicalPosition<u32>) {
+        // XXX This won't fly unless user will have a way to request IME window per seat, since
+        // the ime windows will be overlapping, but winit doesn't expose API to specify for
+        // which seat we're setting IME position.
+        let (x, y) = (position.x as i32, position.y as i32);
+        for text_input in self.text_inputs.iter() {
+            text_input.set_ime_position(x, y);
+        }
+    }
+
+    pub fn passthrough_mouse_input(&self, passthrough_mouse_input: bool) {
+        if passthrough_mouse_input {
+            let region = self.compositor.create_region();
+            region.add(0, 0, 0, 0);
+            self.window
+                .surface()
+                .set_input_region(Some(&region.detach()));
+            region.destroy();
+        } else {
+            // Using `None` results in the entire window being clickable.
+            self.window.surface().set_input_region(None);
+        }
+    }
+
+    pub fn set_transparent(&self, transparent: bool) {
+        self.transparent.set(transparent);
+        let surface = self.window.surface();
+        if transparent {
+            surface.set_opaque_region(None);
+        } else {
+            let region = self.compositor.create_region();
+            region.add(0, 0, i32::MAX, i32::MAX);
+            surface.set_opaque_region(Some(&region.detach()));
+            region.destroy();
+        }
+    }
+
+    pub fn set_ime_allowed(&self, allowed: bool, event_sink: &mut EventSink) {
+        if self.ime_allowed.get() == allowed {
+            return;
+        }
+
+        self.ime_allowed.replace(allowed);
+        let window_id = wayland::make_wid(self.window.surface());
+
+        let purpose = allowed.then(|| self.ime_purpose.get());
+        for text_input in self.text_inputs.iter() {
+            text_input.set_input_allowed(purpose);
+        }
+
+        let event = if allowed {
+            WindowEvent::Ime(Ime::Enabled)
+        } else {
+            WindowEvent::Ime(Ime::Disabled)
+        };
+
+        event_sink.push_window_event(event, window_id);
+    }
+
+    pub fn set_ime_purpose(&self, purpose: ImePurpose) {
+        if self.ime_purpose.get() == purpose {
+            return;
+        }
+
+        self.ime_purpose.replace(purpose);
+
+        if self.ime_allowed.get() {
+            for text_input in self.text_inputs.iter() {
+                text_input.set_content_type_by_purpose(purpose);
+            }
+        }
+    }
+
+    pub fn set_cursor_visible(&self, visible: bool) {
+        self.cursor_visible.replace(visible);
+        let cursor_icon = match visible {
+            true => Some(self.cursor_icon.get()),
+            false => None,
+        };
+
+        for pointer in self.pointers.iter() {
+            pointer.set_cursor(cursor_icon)
+        }
+    }
+
+    pub fn set_cursor_icon(&self, cursor_icon: CursorIcon) {
+        self.cursor_icon.replace(cursor_icon);
+
+        if !self.cursor_visible.get() {
+            return;
+        }
+
+        for pointer in self.pointers.iter() {
+            pointer.set_cursor(Some(cursor_icon));
+        }
+    }
+
+    pub fn drag_window(&self) {
+        for pointer in self.pointers.iter() {
+            pointer.drag_window(&self.window);
+        }
+    }
+}
+
+#[inline]
+pub fn handle_window_requests(winit_state: &mut WinitState) {
+    let window_map = &mut winit_state.window_map;
+    let window_user_requests = &mut winit_state.window_user_requests;
+    let window_compositor_updates = &mut winit_state.window_compositor_updates;
+    let mut windows_to_close: Vec<WindowId> = Vec::new();
+
+    // Process the rest of the events.
+    for (window_id, window_handle) in window_map.iter_mut() {
+        let mut requests = window_handle.pending_window_requests.lock().unwrap();
+        let requests = requests.drain(..);
+        for request in requests {
+            match request {
+                WindowRequest::Fullscreen(fullscreen) => {
+                    window_handle.window.set_fullscreen(fullscreen.as_ref());
+                }
+                WindowRequest::UnsetFullscreen => {
+                    window_handle.window.unset_fullscreen();
+                }
+                WindowRequest::ShowCursor(show_cursor) => {
+                    window_handle.set_cursor_visible(show_cursor);
+                }
+                WindowRequest::NewCursorIcon(cursor_icon) => {
+                    window_handle.set_cursor_icon(cursor_icon);
+                }
+                WindowRequest::ImePosition(position) => {
+                    window_handle.set_ime_position(position);
+                }
+                WindowRequest::AllowIme(allow) => {
+                    let event_sink = &mut winit_state.event_sink;
+                    window_handle.set_ime_allowed(allow, event_sink);
+                }
+                WindowRequest::ImePurpose(purpose) => {
+                    window_handle.set_ime_purpose(purpose);
+                }
+                WindowRequest::SetCursorGrabMode(mode) => {
+                    window_handle.set_cursor_grab(mode);
+                }
+                WindowRequest::SetLockedCursorPosition(position) => {
+                    window_handle.set_locked_cursor_position(position);
+                }
+                WindowRequest::DragWindow => {
+                    window_handle.drag_window();
+                }
+                WindowRequest::Maximize(maximize) => {
+                    if maximize {
+                        window_handle.window.set_maximized();
+                    } else {
+                        window_handle.window.unset_maximized();
+                    }
+                }
+                WindowRequest::Minimize => {
+                    window_handle.window.set_minimized();
+                }
+                WindowRequest::Transparent(transparent) => {
+                    window_handle.set_transparent(transparent);
+
+                    // This requires surface commit.
+                    let window_request = window_user_requests.get_mut(window_id).unwrap();
+                    window_request.redraw_requested = true;
+                }
+                WindowRequest::Decorate(decorate) => {
+                    let decorations = match decorate {
+                        true => Decorations::FollowServer,
+                        false => Decorations::None,
+                    };
+
+                    window_handle.window.set_decorate(decorations);
+
+                    // We should refresh the frame to apply decorations change.
+                    let window_request = window_user_requests.get_mut(window_id).unwrap();
+                    window_request.refresh_frame = true;
+                }
+                WindowRequest::Resizeable(resizeable) => {
+                    window_handle.window.set_resizable(resizeable);
+
+                    // We should refresh the frame to update button state.
+                    let window_request = window_user_requests.get_mut(window_id).unwrap();
+                    window_request.refresh_frame = true;
+                }
+                WindowRequest::Title(title) => {
+                    window_handle.window.set_title(title);
+
+                    // We should refresh the frame to draw new title.
+                    let window_request = window_user_requests.get_mut(window_id).unwrap();
+                    window_request.refresh_frame = true;
+                }
+                WindowRequest::MinSize(size) => {
+                    let size = size.map(|size| (size.width, size.height));
+                    window_handle.window.set_min_size(size);
+
+                    let window_request = window_user_requests.get_mut(window_id).unwrap();
+                    window_request.refresh_frame = true;
+                }
+                WindowRequest::MaxSize(size) => {
+                    let size = size.map(|size| (size.width, size.height));
+                    window_handle.window.set_max_size(size);
+
+                    let window_request = window_user_requests.get_mut(window_id).unwrap();
+                    window_request.refresh_frame = true;
+                }
+                WindowRequest::FrameSize(size) => {
+                    if !window_handle.is_resizable.get() {
+                        // On Wayland non-resizable window is achieved by setting both min and max
+                        // size of the window to the same value.
+                        let size = Some((size.width, size.height));
+                        window_handle.window.set_max_size(size);
+                        window_handle.window.set_min_size(size);
+                    }
+
+                    window_handle.window.resize(size.width, size.height);
+
+                    // We should refresh the frame after resize.
+                    let window_request = window_user_requests.get_mut(window_id).unwrap();
+                    window_request.refresh_frame = true;
+                }
+                WindowRequest::PassthroughMouseInput(passthrough) => {
+                    window_handle.passthrough_mouse_input(passthrough);
+
+                    let window_request = window_user_requests.get_mut(window_id).unwrap();
+                    window_request.refresh_frame = true;
+                }
+                WindowRequest::Attention(request_type) => {
+                    window_handle.set_user_attention(request_type);
+                }
+                WindowRequest::Redraw => {
+                    let window_request = window_user_requests.get_mut(window_id).unwrap();
+                    window_request.redraw_requested = true;
+                }
+                WindowRequest::Close => {
+                    // The window was requested to be closed.
+                    windows_to_close.push(*window_id);
+
+                    // Send event that the window was destroyed.
+                    let event_sink = &mut winit_state.event_sink;
+                    event_sink.push_window_event(WindowEvent::Destroyed, *window_id);
+                }
+                WindowRequest::Theme(_theme) => {
+                    #[cfg(feature = "sctk-adwaita")]
+                    {
+                        window_handle.window.set_frame_config(match _theme {
+                            Some(theme) => theme.into(),
+                            None => sctk_adwaita::FrameConfig::auto(),
+                        });
+
+                        let window_requst = window_user_requests.get_mut(window_id).unwrap();
+                        window_requst.refresh_frame = true;
+                    }
+                }
+            };
+        }
+    }
+
+    // Close the windows.
+    for window in windows_to_close {
+        let _ = window_map.remove(&window);
+        let _ = window_user_requests.remove(&window);
+        let _ = window_compositor_updates.remove(&window);
+    }
+}
+
+impl Drop for WindowHandle {
+    fn drop(&mut self) {
+        // Drop the fractional scaling before the surface.
+        let _ = self.fractional_scaling_state.take();
+
+        unsafe {
+            let surface = self.window.surface().clone();
+            // The window must be destroyed before wl_surface.
+            ManuallyDrop::drop(&mut self.window);
+            surface.destroy();
+        }
+    }
+}
+
+/// Fractional scaling objects.
+pub struct FractionalScalingState {
+    /// The wp-viewport of the window.
+    pub viewport: WpViewport,
+
+    /// The wp-fractional-scale of the window surface.
+    pub fractional_scale: WpFractionalScaleV1,
+}
+
+impl FractionalScalingState {
+    pub fn new(viewport: WpViewport, fractional_scale: WpFractionalScaleV1) -> Self {
+        Self {
+            viewport,
+            fractional_scale,
+        }
+    }
+}
+
+impl Drop for FractionalScalingState {
+    fn drop(&mut self) {
+        self.viewport.destroy();
+        self.fractional_scale.destroy();
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/dnd.rs

@@ -0,0 +1,216 @@
+use std::{
+    io,
+    os::raw::*,
+    path::{Path, PathBuf},
+    str::Utf8Error,
+    sync::Arc,
+};
+
+use percent_encoding::percent_decode;
+
+use super::{ffi, util, XConnection, XError};
+
+#[derive(Debug)]
+pub(crate) struct DndAtoms {
+    pub enter: ffi::Atom,
+    pub leave: ffi::Atom,
+    pub drop: ffi::Atom,
+    pub position: ffi::Atom,
+    pub status: ffi::Atom,
+    pub action_private: ffi::Atom,
+    pub selection: ffi::Atom,
+    pub finished: ffi::Atom,
+    pub type_list: ffi::Atom,
+    pub uri_list: ffi::Atom,
+    pub none: ffi::Atom,
+}
+
+impl DndAtoms {
+    pub fn new(xconn: &Arc<XConnection>) -> Result<Self, XError> {
+        let names = [
+            b"XdndEnter\0".as_ptr() as *mut c_char,
+            b"XdndLeave\0".as_ptr() as *mut c_char,
+            b"XdndDrop\0".as_ptr() as *mut c_char,
+            b"XdndPosition\0".as_ptr() as *mut c_char,
+            b"XdndStatus\0".as_ptr() as *mut c_char,
+            b"XdndActionPrivate\0".as_ptr() as *mut c_char,
+            b"XdndSelection\0".as_ptr() as *mut c_char,
+            b"XdndFinished\0".as_ptr() as *mut c_char,
+            b"XdndTypeList\0".as_ptr() as *mut c_char,
+            b"text/uri-list\0".as_ptr() as *mut c_char,
+            b"None\0".as_ptr() as *mut c_char,
+        ];
+        let atoms = unsafe { xconn.get_atoms(&names) }?;
+        Ok(DndAtoms {
+            enter: atoms[0],
+            leave: atoms[1],
+            drop: atoms[2],
+            position: atoms[3],
+            status: atoms[4],
+            action_private: atoms[5],
+            selection: atoms[6],
+            finished: atoms[7],
+            type_list: atoms[8],
+            uri_list: atoms[9],
+            none: atoms[10],
+        })
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum DndState {
+    Accepted,
+    Rejected,
+}
+
+#[derive(Debug)]
+pub enum DndDataParseError {
+    EmptyData,
+    InvalidUtf8(Utf8Error),
+    HostnameSpecified(String),
+    UnexpectedProtocol(String),
+    UnresolvablePath(io::Error),
+}
+
+impl From<Utf8Error> for DndDataParseError {
+    fn from(e: Utf8Error) -> Self {
+        DndDataParseError::InvalidUtf8(e)
+    }
+}
+
+impl From<io::Error> for DndDataParseError {
+    fn from(e: io::Error) -> Self {
+        DndDataParseError::UnresolvablePath(e)
+    }
+}
+
+pub(crate) struct Dnd {
+    xconn: Arc<XConnection>,
+    pub atoms: DndAtoms,
+    // Populated by XdndEnter event handler
+    pub version: Option<c_long>,
+    pub type_list: Option<Vec<c_ulong>>,
+    // Populated by XdndPosition event handler
+    pub source_window: Option<c_ulong>,
+    // Populated by SelectionNotify event handler (triggered by XdndPosition event handler)
+    pub result: Option<Result<Vec<PathBuf>, DndDataParseError>>,
+}
+
+impl Dnd {
+    pub fn new(xconn: Arc<XConnection>) -> Result<Self, XError> {
+        let atoms = DndAtoms::new(&xconn)?;
+        Ok(Dnd {
+            xconn,
+            atoms,
+            version: None,
+            type_list: None,
+            source_window: None,
+            result: None,
+        })
+    }
+
+    pub fn reset(&mut self) {
+        self.version = None;
+        self.type_list = None;
+        self.source_window = None;
+        self.result = None;
+    }
+
+    pub unsafe fn send_status(
+        &self,
+        this_window: c_ulong,
+        target_window: c_ulong,
+        state: DndState,
+    ) -> Result<(), XError> {
+        let (accepted, action) = match state {
+            DndState::Accepted => (1, self.atoms.action_private as c_long),
+            DndState::Rejected => (0, self.atoms.none as c_long),
+        };
+        self.xconn
+            .send_client_msg(
+                target_window,
+                target_window,
+                self.atoms.status,
+                None,
+                [this_window as c_long, accepted, 0, 0, action],
+            )
+            .flush()
+    }
+
+    pub unsafe fn send_finished(
+        &self,
+        this_window: c_ulong,
+        target_window: c_ulong,
+        state: DndState,
+    ) -> Result<(), XError> {
+        let (accepted, action) = match state {
+            DndState::Accepted => (1, self.atoms.action_private as c_long),
+            DndState::Rejected => (0, self.atoms.none as c_long),
+        };
+        self.xconn
+            .send_client_msg(
+                target_window,
+                target_window,
+                self.atoms.finished,
+                None,
+                [this_window as c_long, accepted, action, 0, 0],
+            )
+            .flush()
+    }
+
+    pub unsafe fn get_type_list(
+        &self,
+        source_window: c_ulong,
+    ) -> Result<Vec<ffi::Atom>, util::GetPropertyError> {
+        self.xconn
+            .get_property(source_window, self.atoms.type_list, ffi::XA_ATOM)
+    }
+
+    pub unsafe fn convert_selection(&self, window: c_ulong, time: c_ulong) {
+        (self.xconn.xlib.XConvertSelection)(
+            self.xconn.display,
+            self.atoms.selection,
+            self.atoms.uri_list,
+            self.atoms.selection,
+            window,
+            time,
+        );
+    }
+
+    pub unsafe fn read_data(
+        &self,
+        window: c_ulong,
+    ) -> Result<Vec<c_uchar>, util::GetPropertyError> {
+        self.xconn
+            .get_property(window, self.atoms.selection, self.atoms.uri_list)
+    }
+
+    pub fn parse_data(&self, data: &mut [c_uchar]) -> Result<Vec<PathBuf>, DndDataParseError> {
+        if !data.is_empty() {
+            let mut path_list = Vec::new();
+            let decoded = percent_decode(data).decode_utf8()?.into_owned();
+            for uri in decoded.split("\r\n").filter(|u| !u.is_empty()) {
+                // The format is specified as protocol://host/path
+                // However, it's typically simply protocol:///path
+                let path_str = if uri.starts_with("file://") {
+                    let path_str = uri.replace("file://", "");
+                    if !path_str.starts_with('/') {
+                        // A hostname is specified
+                        // Supporting this case is beyond the scope of my mental health
+                        return Err(DndDataParseError::HostnameSpecified(path_str));
+                    }
+                    path_str
+                } else {
+                    // Only the file protocol is supported
+                    return Err(DndDataParseError::UnexpectedProtocol(uri.to_owned()));
+                };
+
+                let path = Path::new(&path_str).canonicalize()?;
+                path_list.push(path);
+            }
+            Ok(path_list)
+        } else {
+            Err(DndDataParseError::EmptyData)
+        }
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/ffi.rs

@@ -0,0 +1,9 @@
+use x11_dl::xmd::CARD32;
+pub use x11_dl::{
+    error::OpenError, keysym::*, xcursor::*, xinput::*, xinput2::*, xlib::*, xlib_xcb::*,
+    xrandr::*, xrender::*,
+};
+
+// Isn't defined by x11_dl
+#[allow(non_upper_case_globals)]
+pub const IconicState: CARD32 = 3;

third-party/vendor/winit/src/platform_impl/linux/x11/ime/callbacks.rs

@@ -0,0 +1,203 @@
+use std::{collections::HashMap, os::raw::c_char, ptr, sync::Arc};
+
+use super::{ffi, XConnection, XError};
+
+use super::{
+    context::{ImeContext, ImeContextCreationError},
+    inner::{close_im, ImeInner},
+    input_method::PotentialInputMethods,
+};
+
+pub(crate) unsafe fn xim_set_callback(
+    xconn: &Arc<XConnection>,
+    xim: ffi::XIM,
+    field: *const c_char,
+    callback: *mut ffi::XIMCallback,
+) -> Result<(), XError> {
+    // It's advisable to wrap variadic FFI functions in our own functions, as we want to minimize
+    // access that isn't type-checked.
+    (xconn.xlib.XSetIMValues)(xim, field, callback, ptr::null_mut::<()>());
+    xconn.check_errors()
+}
+
+// Set a callback for when an input method matching the current locale modifiers becomes
+// available. Note that this has nothing to do with what input methods are open or able to be
+// opened, and simply uses the modifiers that are set when the callback is set.
+// * This is called per locale modifier, not per input method opened with that locale modifier.
+// * Trying to set this for multiple locale modifiers causes problems, i.e. one of the rebuilt
+//   input contexts would always silently fail to use the input method.
+pub(crate) unsafe fn set_instantiate_callback(
+    xconn: &Arc<XConnection>,
+    client_data: ffi::XPointer,
+) -> Result<(), XError> {
+    (xconn.xlib.XRegisterIMInstantiateCallback)(
+        xconn.display,
+        ptr::null_mut(),
+        ptr::null_mut(),
+        ptr::null_mut(),
+        Some(xim_instantiate_callback),
+        client_data,
+    );
+    xconn.check_errors()
+}
+
+pub(crate) unsafe fn unset_instantiate_callback(
+    xconn: &Arc<XConnection>,
+    client_data: ffi::XPointer,
+) -> Result<(), XError> {
+    (xconn.xlib.XUnregisterIMInstantiateCallback)(
+        xconn.display,
+        ptr::null_mut(),
+        ptr::null_mut(),
+        ptr::null_mut(),
+        Some(xim_instantiate_callback),
+        client_data,
+    );
+    xconn.check_errors()
+}
+
+pub(crate) unsafe fn set_destroy_callback(
+    xconn: &Arc<XConnection>,
+    im: ffi::XIM,
+    inner: &ImeInner,
+) -> Result<(), XError> {
+    xim_set_callback(
+        xconn,
+        im,
+        ffi::XNDestroyCallback_0.as_ptr() as *const _,
+        &inner.destroy_callback as *const _ as *mut _,
+    )
+}
+
+#[derive(Debug)]
+#[allow(clippy::enum_variant_names)]
+enum ReplaceImError {
+    // Boxed to prevent large error type
+    MethodOpenFailed(Box<PotentialInputMethods>),
+    ContextCreationFailed(ImeContextCreationError),
+    SetDestroyCallbackFailed(XError),
+}
+
+// Attempt to replace current IM (which may or may not be presently valid) with a new one. This
+// includes replacing all existing input contexts and free'ing resources as necessary. This only
+// modifies existing state if all operations succeed.
+unsafe fn replace_im(inner: *mut ImeInner) -> Result<(), ReplaceImError> {
+    let xconn = &(*inner).xconn;
+
+    let (new_im, is_fallback) = {
+        let new_im = (*inner).potential_input_methods.open_im(xconn, None);
+        let is_fallback = new_im.is_fallback();
+        (
+            new_im.ok().ok_or_else(|| {
+                ReplaceImError::MethodOpenFailed(Box::new((*inner).potential_input_methods.clone()))
+            })?,
+            is_fallback,
+        )
+    };
+
+    // It's important to always set a destroy callback, since there's otherwise potential for us
+    // to try to use or free a resource that's already been destroyed on the server.
+    {
+        let result = set_destroy_callback(xconn, new_im.im, &*inner);
+        if result.is_err() {
+            let _ = close_im(xconn, new_im.im);
+        }
+        result
+    }
+    .map_err(ReplaceImError::SetDestroyCallbackFailed)?;
+
+    let mut new_contexts = HashMap::new();
+    for (window, old_context) in (*inner).contexts.iter() {
+        let spot = old_context.as_ref().map(|old_context| old_context.ic_spot);
+
+        // Check if the IME was allowed on that context.
+        let is_allowed = old_context
+            .as_ref()
+            .map(|old_context| old_context.is_allowed())
+            .unwrap_or_default();
+
+        // We can't use the style from the old context here, since it may change on reload, so
+        // pick style from the new XIM based on the old state.
+        let style = if is_allowed {
+            new_im.preedit_style
+        } else {
+            new_im.none_style
+        };
+
+        let new_context = {
+            let result = ImeContext::new(
+                xconn,
+                new_im.im,
+                style,
+                *window,
+                spot,
+                (*inner).event_sender.clone(),
+            );
+            if result.is_err() {
+                let _ = close_im(xconn, new_im.im);
+            }
+            result.map_err(ReplaceImError::ContextCreationFailed)?
+        };
+        new_contexts.insert(*window, Some(new_context));
+    }
+
+    // If we've made it this far, everything succeeded.
+    let _ = (*inner).destroy_all_contexts_if_necessary();
+    let _ = (*inner).close_im_if_necessary();
+    (*inner).im = Some(new_im);
+    (*inner).contexts = new_contexts;
+    (*inner).is_destroyed = false;
+    (*inner).is_fallback = is_fallback;
+    Ok(())
+}
+
+pub unsafe extern "C" fn xim_instantiate_callback(
+    _display: *mut ffi::Display,
+    client_data: ffi::XPointer,
+    // This field is unsupplied.
+    _call_data: ffi::XPointer,
+) {
+    let inner: *mut ImeInner = client_data as _;
+    if !inner.is_null() {
+        let xconn = &(*inner).xconn;
+        match replace_im(inner) {
+            Ok(()) => {
+                let _ = unset_instantiate_callback(xconn, client_data);
+                (*inner).is_fallback = false;
+            }
+            Err(err) => {
+                if (*inner).is_destroyed {
+                    // We have no usable input methods!
+                    panic!("Failed to reopen input method: {err:?}");
+                }
+            }
+        }
+    }
+}
+
+// This callback is triggered when the input method is closed on the server end. When this
+// happens, XCloseIM/XDestroyIC doesn't need to be called, as the resources have already been
+// free'd (attempting to do so causes our connection to freeze).
+pub unsafe extern "C" fn xim_destroy_callback(
+    _xim: ffi::XIM,
+    client_data: ffi::XPointer,
+    // This field is unsupplied.
+    _call_data: ffi::XPointer,
+) {
+    let inner: *mut ImeInner = client_data as _;
+    if !inner.is_null() {
+        (*inner).is_destroyed = true;
+        let xconn = &(*inner).xconn;
+        if !(*inner).is_fallback {
+            let _ = set_instantiate_callback(xconn, client_data);
+            // Attempt to open fallback input method.
+            match replace_im(inner) {
+                Ok(()) => (*inner).is_fallback = true,
+                Err(err) => {
+                    // We have no usable input methods!
+                    panic!("Failed to open fallback input method: {err:?}");
+                }
+            }
+        }
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/ime/context.rs

@@ -0,0 +1,376 @@
+use std::ffi::CStr;
+use std::os::raw::c_short;
+use std::sync::Arc;
+use std::{mem, ptr};
+
+use x11_dl::xlib::{XIMCallback, XIMPreeditCaretCallbackStruct, XIMPreeditDrawCallbackStruct};
+
+use crate::platform_impl::platform::x11::ime::input_method::{Style, XIMStyle};
+use crate::platform_impl::platform::x11::ime::{ImeEvent, ImeEventSender};
+
+use super::{ffi, util, XConnection, XError};
+
+/// IME creation error.
+#[derive(Debug)]
+pub enum ImeContextCreationError {
+    /// Got the error from Xlib.
+    XError(XError),
+
+    /// Got null pointer from Xlib but without exact reason.
+    Null,
+}
+
+/// The callback used by XIM preedit functions.
+type XIMProcNonnull = unsafe extern "C" fn(ffi::XIM, ffi::XPointer, ffi::XPointer);
+
+/// Wrapper for creating XIM callbacks.
+#[inline]
+fn create_xim_callback(client_data: ffi::XPointer, callback: XIMProcNonnull) -> ffi::XIMCallback {
+    XIMCallback {
+        client_data,
+        callback: Some(callback),
+    }
+}
+
+/// The server started preedit.
+extern "C" fn preedit_start_callback(
+    _xim: ffi::XIM,
+    client_data: ffi::XPointer,
+    _call_data: ffi::XPointer,
+) -> i32 {
+    let client_data = unsafe { &mut *(client_data as *mut ImeContextClientData) };
+
+    client_data.text.clear();
+    client_data.cursor_pos = 0;
+    client_data
+        .event_sender
+        .send((client_data.window, ImeEvent::Start))
+        .expect("failed to send preedit start event");
+    -1
+}
+
+/// Done callback is used when the preedit should be hidden.
+extern "C" fn preedit_done_callback(
+    _xim: ffi::XIM,
+    client_data: ffi::XPointer,
+    _call_data: ffi::XPointer,
+) {
+    let client_data = unsafe { &mut *(client_data as *mut ImeContextClientData) };
+
+    // Drop text buffer and reset cursor position on done.
+    client_data.text = Vec::new();
+    client_data.cursor_pos = 0;
+
+    client_data
+        .event_sender
+        .send((client_data.window, ImeEvent::End))
+        .expect("failed to send preedit end event");
+}
+
+fn calc_byte_position(text: &[char], pos: usize) -> usize {
+    text.iter()
+        .take(pos)
+        .fold(0, |byte_pos, text| byte_pos + text.len_utf8())
+}
+
+/// Preedit text information to be drawn inline by the client.
+extern "C" fn preedit_draw_callback(
+    _xim: ffi::XIM,
+    client_data: ffi::XPointer,
+    call_data: ffi::XPointer,
+) {
+    let client_data = unsafe { &mut *(client_data as *mut ImeContextClientData) };
+    let call_data = unsafe { &mut *(call_data as *mut XIMPreeditDrawCallbackStruct) };
+    client_data.cursor_pos = call_data.caret as usize;
+
+    let chg_range =
+        call_data.chg_first as usize..(call_data.chg_first + call_data.chg_length) as usize;
+    if chg_range.start > client_data.text.len() || chg_range.end > client_data.text.len() {
+        warn!(
+            "invalid chg range: buffer length={}, but chg_first={} chg_lengthg={}",
+            client_data.text.len(),
+            call_data.chg_first,
+            call_data.chg_length
+        );
+        return;
+    }
+
+    // NULL indicate text deletion
+    let mut new_chars = if call_data.text.is_null() {
+        Vec::new()
+    } else {
+        let xim_text = unsafe { &mut *(call_data.text) };
+        if xim_text.encoding_is_wchar > 0 {
+            return;
+        }
+
+        let new_text = unsafe { xim_text.string.multi_byte };
+
+        if new_text.is_null() {
+            return;
+        }
+
+        let new_text = unsafe { CStr::from_ptr(new_text) };
+
+        String::from(new_text.to_str().expect("Invalid UTF-8 String from IME"))
+            .chars()
+            .collect()
+    };
+    let mut old_text_tail = client_data.text.split_off(chg_range.end);
+    client_data.text.truncate(chg_range.start);
+    client_data.text.append(&mut new_chars);
+    client_data.text.append(&mut old_text_tail);
+    let cursor_byte_pos = calc_byte_position(&client_data.text, client_data.cursor_pos);
+
+    client_data
+        .event_sender
+        .send((
+            client_data.window,
+            ImeEvent::Update(client_data.text.iter().collect(), cursor_byte_pos),
+        ))
+        .expect("failed to send preedit update event");
+}
+
+/// Handling of cursor movements in preedit text.
+extern "C" fn preedit_caret_callback(
+    _xim: ffi::XIM,
+    client_data: ffi::XPointer,
+    call_data: ffi::XPointer,
+) {
+    let client_data = unsafe { &mut *(client_data as *mut ImeContextClientData) };
+    let call_data = unsafe { &mut *(call_data as *mut XIMPreeditCaretCallbackStruct) };
+
+    if call_data.direction == ffi::XIMCaretDirection::XIMAbsolutePosition {
+        client_data.cursor_pos = call_data.position as usize;
+        let cursor_byte_pos = calc_byte_position(&client_data.text, client_data.cursor_pos);
+
+        client_data
+            .event_sender
+            .send((
+                client_data.window,
+                ImeEvent::Update(client_data.text.iter().collect(), cursor_byte_pos),
+            ))
+            .expect("failed to send preedit update event");
+    }
+}
+
+/// Struct to simplify callback creation and latter passing into Xlib XIM.
+struct PreeditCallbacks {
+    start_callback: ffi::XIMCallback,
+    done_callback: ffi::XIMCallback,
+    draw_callback: ffi::XIMCallback,
+    caret_callback: ffi::XIMCallback,
+}
+
+impl PreeditCallbacks {
+    pub fn new(client_data: ffi::XPointer) -> PreeditCallbacks {
+        let start_callback = create_xim_callback(client_data, unsafe {
+            mem::transmute(preedit_start_callback as usize)
+        });
+        let done_callback = create_xim_callback(client_data, preedit_done_callback);
+        let caret_callback = create_xim_callback(client_data, preedit_caret_callback);
+        let draw_callback = create_xim_callback(client_data, preedit_draw_callback);
+
+        PreeditCallbacks {
+            start_callback,
+            done_callback,
+            caret_callback,
+            draw_callback,
+        }
+    }
+}
+
+struct ImeContextClientData {
+    window: ffi::Window,
+    event_sender: ImeEventSender,
+    text: Vec<char>,
+    cursor_pos: usize,
+}
+
+// XXX: this struct doesn't destroy its XIC resource when dropped.
+// This is intentional, as it doesn't have enough information to know whether or not the context
+// still exists on the server. Since `ImeInner` has that awareness, destruction must be handled
+// through `ImeInner`.
+pub struct ImeContext {
+    pub(crate) ic: ffi::XIC,
+    pub(crate) ic_spot: ffi::XPoint,
+    pub(crate) style: Style,
+    // Since the data is passed shared between X11 XIM callbacks, but couldn't be direclty free from
+    // there we keep the pointer to automatically deallocate it.
+    _client_data: Box<ImeContextClientData>,
+}
+
+impl ImeContext {
+    pub(crate) unsafe fn new(
+        xconn: &Arc<XConnection>,
+        im: ffi::XIM,
+        style: Style,
+        window: ffi::Window,
+        ic_spot: Option<ffi::XPoint>,
+        event_sender: ImeEventSender,
+    ) -> Result<Self, ImeContextCreationError> {
+        let client_data = Box::into_raw(Box::new(ImeContextClientData {
+            window,
+            event_sender,
+            text: Vec::new(),
+            cursor_pos: 0,
+        }));
+
+        let ic = match style as _ {
+            Style::Preedit(style) => ImeContext::create_preedit_ic(
+                xconn,
+                im,
+                style,
+                window,
+                client_data as ffi::XPointer,
+            ),
+            Style::Nothing(style) => ImeContext::create_nothing_ic(xconn, im, style, window),
+            Style::None(style) => ImeContext::create_none_ic(xconn, im, style, window),
+        }
+        .ok_or(ImeContextCreationError::Null)?;
+
+        xconn
+            .check_errors()
+            .map_err(ImeContextCreationError::XError)?;
+
+        let mut context = ImeContext {
+            ic,
+            ic_spot: ffi::XPoint { x: 0, y: 0 },
+            style,
+            _client_data: Box::from_raw(client_data),
+        };
+
+        // Set the spot location, if it's present.
+        if let Some(ic_spot) = ic_spot {
+            context.set_spot(xconn, ic_spot.x, ic_spot.y)
+        }
+
+        Ok(context)
+    }
+
+    unsafe fn create_none_ic(
+        xconn: &Arc<XConnection>,
+        im: ffi::XIM,
+        style: XIMStyle,
+        window: ffi::Window,
+    ) -> Option<ffi::XIC> {
+        let ic = (xconn.xlib.XCreateIC)(
+            im,
+            ffi::XNInputStyle_0.as_ptr() as *const _,
+            style,
+            ffi::XNClientWindow_0.as_ptr() as *const _,
+            window,
+            ptr::null_mut::<()>(),
+        );
+
+        (!ic.is_null()).then(|| ic)
+    }
+
+    unsafe fn create_preedit_ic(
+        xconn: &Arc<XConnection>,
+        im: ffi::XIM,
+        style: XIMStyle,
+        window: ffi::Window,
+        client_data: ffi::XPointer,
+    ) -> Option<ffi::XIC> {
+        let preedit_callbacks = PreeditCallbacks::new(client_data);
+        let preedit_attr = util::XSmartPointer::new(
+            xconn,
+            (xconn.xlib.XVaCreateNestedList)(
+                0,
+                ffi::XNPreeditStartCallback_0.as_ptr() as *const _,
+                &(preedit_callbacks.start_callback) as *const _,
+                ffi::XNPreeditDoneCallback_0.as_ptr() as *const _,
+                &(preedit_callbacks.done_callback) as *const _,
+                ffi::XNPreeditCaretCallback_0.as_ptr() as *const _,
+                &(preedit_callbacks.caret_callback) as *const _,
+                ffi::XNPreeditDrawCallback_0.as_ptr() as *const _,
+                &(preedit_callbacks.draw_callback) as *const _,
+                ptr::null_mut::<()>(),
+            ),
+        )
+        .expect("XVaCreateNestedList returned NULL");
+
+        let ic = (xconn.xlib.XCreateIC)(
+            im,
+            ffi::XNInputStyle_0.as_ptr() as *const _,
+            style,
+            ffi::XNClientWindow_0.as_ptr() as *const _,
+            window,
+            ffi::XNPreeditAttributes_0.as_ptr() as *const _,
+            preedit_attr.ptr,
+            ptr::null_mut::<()>(),
+        );
+
+        (!ic.is_null()).then(|| ic)
+    }
+
+    unsafe fn create_nothing_ic(
+        xconn: &Arc<XConnection>,
+        im: ffi::XIM,
+        style: XIMStyle,
+        window: ffi::Window,
+    ) -> Option<ffi::XIC> {
+        let ic = (xconn.xlib.XCreateIC)(
+            im,
+            ffi::XNInputStyle_0.as_ptr() as *const _,
+            style,
+            ffi::XNClientWindow_0.as_ptr() as *const _,
+            window,
+            ptr::null_mut::<()>(),
+        );
+
+        (!ic.is_null()).then(|| ic)
+    }
+
+    pub(crate) fn focus(&self, xconn: &Arc<XConnection>) -> Result<(), XError> {
+        unsafe {
+            (xconn.xlib.XSetICFocus)(self.ic);
+        }
+        xconn.check_errors()
+    }
+
+    pub(crate) fn unfocus(&self, xconn: &Arc<XConnection>) -> Result<(), XError> {
+        unsafe {
+            (xconn.xlib.XUnsetICFocus)(self.ic);
+        }
+        xconn.check_errors()
+    }
+
+    pub fn is_allowed(&self) -> bool {
+        !matches!(self.style, Style::None(_))
+    }
+
+    // Set the spot for preedit text. Setting spot isn't working with libX11 when preedit callbacks
+    // are being used. Certain IMEs do show selection window, but it's placed in bottom left of the
+    // window and couldn't be changed.
+    //
+    // For me see: https://bugs.freedesktop.org/show_bug.cgi?id=1580.
+    pub(crate) fn set_spot(&mut self, xconn: &Arc<XConnection>, x: c_short, y: c_short) {
+        if !self.is_allowed() || self.ic_spot.x == x && self.ic_spot.y == y {
+            return;
+        }
+
+        self.ic_spot = ffi::XPoint { x, y };
+
+        unsafe {
+            let preedit_attr = util::XSmartPointer::new(
+                xconn,
+                (xconn.xlib.XVaCreateNestedList)(
+                    0,
+                    ffi::XNSpotLocation_0.as_ptr(),
+                    &self.ic_spot,
+                    ptr::null_mut::<()>(),
+                ),
+            )
+            .expect("XVaCreateNestedList returned NULL");
+
+            (xconn.xlib.XSetICValues)(
+                self.ic,
+                ffi::XNPreeditAttributes_0.as_ptr() as *const _,
+                preedit_attr.ptr,
+                ptr::null_mut::<()>(),
+            );
+        }
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/ime/inner.rs

@@ -0,0 +1,75 @@
+use std::{collections::HashMap, mem, sync::Arc};
+
+use super::{ffi, XConnection, XError};
+
+use super::{
+    context::ImeContext,
+    input_method::{InputMethod, PotentialInputMethods},
+};
+use crate::platform_impl::platform::x11::ime::ImeEventSender;
+
+pub(crate) unsafe fn close_im(xconn: &Arc<XConnection>, im: ffi::XIM) -> Result<(), XError> {
+    (xconn.xlib.XCloseIM)(im);
+    xconn.check_errors()
+}
+
+pub(crate) unsafe fn destroy_ic(xconn: &Arc<XConnection>, ic: ffi::XIC) -> Result<(), XError> {
+    (xconn.xlib.XDestroyIC)(ic);
+    xconn.check_errors()
+}
+
+pub(crate) struct ImeInner {
+    pub xconn: Arc<XConnection>,
+    pub im: Option<InputMethod>,
+    pub potential_input_methods: PotentialInputMethods,
+    pub contexts: HashMap<ffi::Window, Option<ImeContext>>,
+    // WARNING: this is initially zeroed!
+    pub destroy_callback: ffi::XIMCallback,
+    pub event_sender: ImeEventSender,
+    // Indicates whether or not the the input method was destroyed on the server end
+    // (i.e. if ibus/fcitx/etc. was terminated/restarted)
+    pub is_destroyed: bool,
+    pub is_fallback: bool,
+}
+
+impl ImeInner {
+    pub(crate) fn new(
+        xconn: Arc<XConnection>,
+        potential_input_methods: PotentialInputMethods,
+        event_sender: ImeEventSender,
+    ) -> Self {
+        ImeInner {
+            xconn,
+            im: None,
+            potential_input_methods,
+            contexts: HashMap::new(),
+            destroy_callback: unsafe { mem::zeroed() },
+            event_sender,
+            is_destroyed: false,
+            is_fallback: false,
+        }
+    }
+
+    pub unsafe fn close_im_if_necessary(&self) -> Result<bool, XError> {
+        if !self.is_destroyed && self.im.is_some() {
+            close_im(&self.xconn, self.im.as_ref().unwrap().im).map(|_| true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    pub unsafe fn destroy_ic_if_necessary(&self, ic: ffi::XIC) -> Result<bool, XError> {
+        if !self.is_destroyed {
+            destroy_ic(&self.xconn, ic).map(|_| true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    pub unsafe fn destroy_all_contexts_if_necessary(&self) -> Result<bool, XError> {
+        for context in self.contexts.values().flatten() {
+            self.destroy_ic_if_necessary(context.ic)?;
+        }
+        Ok(!self.is_destroyed)
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/ime/input_method.rs

@@ -0,0 +1,352 @@
+use std::{
+    env,
+    ffi::{CStr, CString, IntoStringError},
+    fmt,
+    os::raw::{c_char, c_ulong, c_ushort},
+    ptr,
+    sync::{Arc, Mutex},
+};
+
+use once_cell::sync::Lazy;
+
+use super::{ffi, util, XConnection, XError};
+
+static GLOBAL_LOCK: Lazy<Mutex<()>> = Lazy::new(Default::default);
+
+unsafe fn open_im(xconn: &Arc<XConnection>, locale_modifiers: &CStr) -> Option<ffi::XIM> {
+    let _lock = GLOBAL_LOCK.lock();
+
+    // XSetLocaleModifiers returns...
+    // * The current locale modifiers if it's given a NULL pointer.
+    // * The new locale modifiers if we succeeded in setting them.
+    // * NULL if the locale modifiers string is malformed or if the
+    //   current locale is not supported by Xlib.
+    (xconn.xlib.XSetLocaleModifiers)(locale_modifiers.as_ptr());
+
+    let im = (xconn.xlib.XOpenIM)(
+        xconn.display,
+        ptr::null_mut(),
+        ptr::null_mut(),
+        ptr::null_mut(),
+    );
+
+    if im.is_null() {
+        None
+    } else {
+        Some(im)
+    }
+}
+
+#[derive(Debug)]
+pub struct InputMethod {
+    pub im: ffi::XIM,
+    pub preedit_style: Style,
+    pub none_style: Style,
+    _name: String,
+}
+
+impl InputMethod {
+    fn new(xconn: &Arc<XConnection>, im: ffi::XIM, name: String) -> Option<Self> {
+        let mut styles: *mut XIMStyles = std::ptr::null_mut();
+
+        // Query the styles supported by the XIM.
+        unsafe {
+            if !(xconn.xlib.XGetIMValues)(
+                im,
+                ffi::XNQueryInputStyle_0.as_ptr() as *const _,
+                (&mut styles) as *mut _,
+                std::ptr::null_mut::<()>(),
+            )
+            .is_null()
+            {
+                return None;
+            }
+        }
+
+        let mut preedit_style = None;
+        let mut none_style = None;
+
+        unsafe {
+            std::slice::from_raw_parts((*styles).supported_styles, (*styles).count_styles as _)
+                .iter()
+                .for_each(|style| match *style {
+                    XIM_PREEDIT_STYLE => {
+                        preedit_style = Some(Style::Preedit(*style));
+                    }
+                    XIM_NOTHING_STYLE if preedit_style.is_none() => {
+                        preedit_style = Some(Style::Nothing(*style))
+                    }
+                    XIM_NONE_STYLE => none_style = Some(Style::None(*style)),
+                    _ => (),
+                });
+
+            (xconn.xlib.XFree)(styles.cast());
+        };
+
+        if preedit_style.is_none() && none_style.is_none() {
+            return None;
+        }
+
+        let preedit_style = preedit_style.unwrap_or_else(|| none_style.unwrap());
+        let none_style = none_style.unwrap_or(preedit_style);
+
+        Some(InputMethod {
+            im,
+            _name: name,
+            preedit_style,
+            none_style,
+        })
+    }
+}
+
+const XIM_PREEDIT_STYLE: XIMStyle = (ffi::XIMPreeditCallbacks | ffi::XIMStatusNothing) as XIMStyle;
+const XIM_NOTHING_STYLE: XIMStyle = (ffi::XIMPreeditNothing | ffi::XIMStatusNothing) as XIMStyle;
+const XIM_NONE_STYLE: XIMStyle = (ffi::XIMPreeditNone | ffi::XIMStatusNone) as XIMStyle;
+
+/// Style of the IME context.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Style {
+    /// Preedit callbacks.
+    Preedit(XIMStyle),
+
+    /// Nothing.
+    Nothing(XIMStyle),
+
+    /// No IME.
+    None(XIMStyle),
+}
+
+impl Default for Style {
+    fn default() -> Self {
+        Style::None(XIM_NONE_STYLE)
+    }
+}
+
+#[repr(C)]
+#[derive(Debug)]
+struct XIMStyles {
+    count_styles: c_ushort,
+    supported_styles: *const XIMStyle,
+}
+
+pub(crate) type XIMStyle = c_ulong;
+
+#[derive(Debug)]
+pub enum InputMethodResult {
+    /// Input method used locale modifier from `XMODIFIERS` environment variable.
+    XModifiers(InputMethod),
+    /// Input method used internal fallback locale modifier.
+    Fallback(InputMethod),
+    /// Input method could not be opened using any locale modifier tried.
+    Failure,
+}
+
+impl InputMethodResult {
+    pub fn is_fallback(&self) -> bool {
+        matches!(self, InputMethodResult::Fallback(_))
+    }
+
+    pub fn ok(self) -> Option<InputMethod> {
+        use self::InputMethodResult::*;
+        match self {
+            XModifiers(im) | Fallback(im) => Some(im),
+            Failure => None,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+enum GetXimServersError {
+    XError(XError),
+    GetPropertyError(util::GetPropertyError),
+    InvalidUtf8(IntoStringError),
+}
+
+// The root window has a property named XIM_SERVERS, which contains a list of atoms represeting
+// the availabile XIM servers. For instance, if you're using ibus, it would contain an atom named
+// "@server=ibus". It's possible for this property to contain multiple atoms, though presumably
+// rare. Note that we replace "@server=" with "@im=" in order to match the format of locale
+// modifiers, since we don't want a user who's looking at logs to ask "am I supposed to set
+// XMODIFIERS to `@server=ibus`?!?"
+unsafe fn get_xim_servers(xconn: &Arc<XConnection>) -> Result<Vec<String>, GetXimServersError> {
+    let servers_atom = xconn.get_atom_unchecked(b"XIM_SERVERS\0");
+
+    let root = (xconn.xlib.XDefaultRootWindow)(xconn.display);
+
+    let mut atoms: Vec<ffi::Atom> = xconn
+        .get_property(root, servers_atom, ffi::XA_ATOM)
+        .map_err(GetXimServersError::GetPropertyError)?;
+
+    let mut names: Vec<*const c_char> = Vec::with_capacity(atoms.len());
+    (xconn.xlib.XGetAtomNames)(
+        xconn.display,
+        atoms.as_mut_ptr(),
+        atoms.len() as _,
+        names.as_mut_ptr() as _,
+    );
+    names.set_len(atoms.len());
+
+    let mut formatted_names = Vec::with_capacity(names.len());
+    for name in names {
+        let string = CStr::from_ptr(name)
+            .to_owned()
+            .into_string()
+            .map_err(GetXimServersError::InvalidUtf8)?;
+        (xconn.xlib.XFree)(name as _);
+        formatted_names.push(string.replace("@server=", "@im="));
+    }
+    xconn.check_errors().map_err(GetXimServersError::XError)?;
+    Ok(formatted_names)
+}
+
+#[derive(Clone)]
+struct InputMethodName {
+    c_string: CString,
+    string: String,
+}
+
+impl InputMethodName {
+    pub fn from_string(string: String) -> Self {
+        let c_string = CString::new(string.clone())
+            .expect("String used to construct CString contained null byte");
+        InputMethodName { c_string, string }
+    }
+
+    pub fn from_str(string: &str) -> Self {
+        let c_string =
+            CString::new(string).expect("String used to construct CString contained null byte");
+        InputMethodName {
+            c_string,
+            string: string.to_owned(),
+        }
+    }
+}
+
+impl fmt::Debug for InputMethodName {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.string.fmt(f)
+    }
+}
+
+#[derive(Debug, Clone)]
+struct PotentialInputMethod {
+    name: InputMethodName,
+    successful: Option<bool>,
+}
+
+impl PotentialInputMethod {
+    pub fn from_string(string: String) -> Self {
+        PotentialInputMethod {
+            name: InputMethodName::from_string(string),
+            successful: None,
+        }
+    }
+
+    pub fn from_str(string: &str) -> Self {
+        PotentialInputMethod {
+            name: InputMethodName::from_str(string),
+            successful: None,
+        }
+    }
+
+    pub fn reset(&mut self) {
+        self.successful = None;
+    }
+
+    pub fn open_im(&mut self, xconn: &Arc<XConnection>) -> Option<InputMethod> {
+        let im = unsafe { open_im(xconn, &self.name.c_string) };
+        self.successful = Some(im.is_some());
+        im.and_then(|im| InputMethod::new(xconn, im, self.name.string.clone()))
+    }
+}
+
+// By logging this struct, you get a sequential listing of every locale modifier tried, where it
+// came from, and if it succeeded.
+#[derive(Debug, Clone)]
+pub(crate) struct PotentialInputMethods {
+    // On correctly configured systems, the XMODIFIERS environment variable tells us everything we
+    // need to know.
+    xmodifiers: Option<PotentialInputMethod>,
+    // We have some standard options at our disposal that should ostensibly always work. For users
+    // who only need compose sequences, this ensures that the program launches without a hitch
+    // For users who need more sophisticated IME features, this is more or less a silent failure.
+    // Logging features should be added in the future to allow both audiences to be effectively
+    // served.
+    fallbacks: [PotentialInputMethod; 2],
+    // For diagnostic purposes, we include the list of XIM servers that the server reports as
+    // being available.
+    _xim_servers: Result<Vec<String>, GetXimServersError>,
+}
+
+impl PotentialInputMethods {
+    pub fn new(xconn: &Arc<XConnection>) -> Self {
+        let xmodifiers = env::var("XMODIFIERS")
+            .ok()
+            .map(PotentialInputMethod::from_string);
+        PotentialInputMethods {
+            // Since passing "" to XSetLocaleModifiers results in it defaulting to the value of
+            // XMODIFIERS, it's worth noting what happens if XMODIFIERS is also "". If simply
+            // running the program with `XMODIFIERS="" cargo run`, then assuming XMODIFIERS is
+            // defined in the profile (or parent environment) then that parent XMODIFIERS is used.
+            // If that XMODIFIERS value is also "" (i.e. if you ran `export XMODIFIERS=""`), then
+            // XSetLocaleModifiers uses the default local input method. Note that defining
+            // XMODIFIERS as "" is different from XMODIFIERS not being defined at all, since in
+            // that case, we get `None` and end up skipping ahead to the next method.
+            xmodifiers,
+            fallbacks: [
+                // This is a standard input method that supports compose sequences, which should
+                // always be available. `@im=none` appears to mean the same thing.
+                PotentialInputMethod::from_str("@im=local"),
+                // This explicitly specifies to use the implementation-dependent default, though
+                // that seems to be equivalent to just using the local input method.
+                PotentialInputMethod::from_str("@im="),
+            ],
+            // The XIM_SERVERS property can have surprising values. For instance, when I exited
+            // ibus to run fcitx, it retained the value denoting ibus. Even more surprising is
+            // that the fcitx input method could only be successfully opened using "@im=ibus".
+            // Presumably due to this quirk, it's actually possible to alternate between ibus and
+            // fcitx in a running application.
+            _xim_servers: unsafe { get_xim_servers(xconn) },
+        }
+    }
+
+    // This resets the `successful` field of every potential input method, ensuring we have
+    // accurate information when this struct is re-used by the destruction/instantiation callbacks.
+    fn reset(&mut self) {
+        if let Some(ref mut input_method) = self.xmodifiers {
+            input_method.reset();
+        }
+
+        for input_method in &mut self.fallbacks {
+            input_method.reset();
+        }
+    }
+
+    pub fn open_im(
+        &mut self,
+        xconn: &Arc<XConnection>,
+        callback: Option<&dyn Fn()>,
+    ) -> InputMethodResult {
+        use self::InputMethodResult::*;
+
+        self.reset();
+
+        if let Some(ref mut input_method) = self.xmodifiers {
+            let im = input_method.open_im(xconn);
+            if let Some(im) = im {
+                return XModifiers(im);
+            } else if let Some(ref callback) = callback {
+                callback();
+            }
+        }
+
+        for input_method in &mut self.fallbacks {
+            let im = input_method.open_im(xconn);
+            if let Some(im) = im {
+                return Fallback(im);
+            }
+        }
+
+        Failure
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/ime/mod.rs

@@ -0,0 +1,249 @@
+// Important: all XIM calls need to happen from the same thread!
+
+mod callbacks;
+mod context;
+mod inner;
+mod input_method;
+
+use std::sync::{
+    mpsc::{Receiver, Sender},
+    Arc,
+};
+
+use super::{ffi, util, XConnection, XError};
+
+pub use self::context::ImeContextCreationError;
+use self::{
+    callbacks::*,
+    context::ImeContext,
+    inner::{close_im, ImeInner},
+    input_method::{PotentialInputMethods, Style},
+};
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum ImeEvent {
+    Enabled,
+    Start,
+    Update(String, usize),
+    End,
+    Disabled,
+}
+
+pub type ImeReceiver = Receiver<ImeRequest>;
+pub type ImeSender = Sender<ImeRequest>;
+pub type ImeEventReceiver = Receiver<(ffi::Window, ImeEvent)>;
+pub type ImeEventSender = Sender<(ffi::Window, ImeEvent)>;
+
+/// Request to control XIM handler from the window.
+pub enum ImeRequest {
+    /// Set IME spot position for given `window_id`.
+    Position(ffi::Window, i16, i16),
+
+    /// Allow IME input for the given `window_id`.
+    Allow(ffi::Window, bool),
+}
+
+#[derive(Debug)]
+pub(crate) enum ImeCreationError {
+    // Boxed to prevent large error type
+    OpenFailure(Box<PotentialInputMethods>),
+    SetDestroyCallbackFailed(XError),
+}
+
+pub(crate) struct Ime {
+    xconn: Arc<XConnection>,
+    // The actual meat of this struct is boxed away, since it needs to have a fixed location in
+    // memory so we can pass a pointer to it around.
+    inner: Box<ImeInner>,
+}
+
+impl Ime {
+    pub fn new(
+        xconn: Arc<XConnection>,
+        event_sender: ImeEventSender,
+    ) -> Result<Self, ImeCreationError> {
+        let potential_input_methods = PotentialInputMethods::new(&xconn);
+
+        let (mut inner, client_data) = {
+            let mut inner = Box::new(ImeInner::new(xconn, potential_input_methods, event_sender));
+            let inner_ptr = Box::into_raw(inner);
+            let client_data = inner_ptr as _;
+            let destroy_callback = ffi::XIMCallback {
+                client_data,
+                callback: Some(xim_destroy_callback),
+            };
+            inner = unsafe { Box::from_raw(inner_ptr) };
+            inner.destroy_callback = destroy_callback;
+            (inner, client_data)
+        };
+
+        let xconn = Arc::clone(&inner.xconn);
+
+        let input_method = inner.potential_input_methods.open_im(
+            &xconn,
+            Some(&|| {
+                let _ = unsafe { set_instantiate_callback(&xconn, client_data) };
+            }),
+        );
+
+        let is_fallback = input_method.is_fallback();
+        if let Some(input_method) = input_method.ok() {
+            inner.is_fallback = is_fallback;
+            unsafe {
+                let result = set_destroy_callback(&xconn, input_method.im, &inner)
+                    .map_err(ImeCreationError::SetDestroyCallbackFailed);
+                if result.is_err() {
+                    let _ = close_im(&xconn, input_method.im);
+                }
+                result?;
+            }
+            inner.im = Some(input_method);
+            Ok(Ime { xconn, inner })
+        } else {
+            Err(ImeCreationError::OpenFailure(Box::new(
+                inner.potential_input_methods,
+            )))
+        }
+    }
+
+    pub fn is_destroyed(&self) -> bool {
+        self.inner.is_destroyed
+    }
+
+    // This pattern is used for various methods here:
+    // Ok(_) indicates that nothing went wrong internally
+    // Ok(true) indicates that the action was actually performed
+    // Ok(false) indicates that the action is not presently applicable
+    pub fn create_context(
+        &mut self,
+        window: ffi::Window,
+        with_preedit: bool,
+    ) -> Result<bool, ImeContextCreationError> {
+        let context = if self.is_destroyed() {
+            // Create empty entry in map, so that when IME is rebuilt, this window has a context.
+            None
+        } else {
+            let im = self.inner.im.as_ref().unwrap();
+            let style = if with_preedit {
+                im.preedit_style
+            } else {
+                im.none_style
+            };
+
+            let context = unsafe {
+                ImeContext::new(
+                    &self.inner.xconn,
+                    im.im,
+                    style,
+                    window,
+                    None,
+                    self.inner.event_sender.clone(),
+                )?
+            };
+
+            // Check the state on the context, since it could fail to enable or disable preedit.
+            let event = if matches!(style, Style::None(_)) {
+                if with_preedit {
+                    debug!("failed to create IME context with preedit support.")
+                }
+                ImeEvent::Disabled
+            } else {
+                if !with_preedit {
+                    debug!("failed to create IME context without preedit support.")
+                }
+                ImeEvent::Enabled
+            };
+
+            self.inner
+                .event_sender
+                .send((window, event))
+                .expect("Failed to send enabled event");
+
+            Some(context)
+        };
+
+        self.inner.contexts.insert(window, context);
+        Ok(!self.is_destroyed())
+    }
+
+    pub fn get_context(&self, window: ffi::Window) -> Option<ffi::XIC> {
+        if self.is_destroyed() {
+            return None;
+        }
+        if let Some(Some(context)) = self.inner.contexts.get(&window) {
+            Some(context.ic)
+        } else {
+            None
+        }
+    }
+
+    pub fn remove_context(&mut self, window: ffi::Window) -> Result<bool, XError> {
+        if let Some(Some(context)) = self.inner.contexts.remove(&window) {
+            unsafe {
+                self.inner.destroy_ic_if_necessary(context.ic)?;
+            }
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    pub fn focus(&mut self, window: ffi::Window) -> Result<bool, XError> {
+        if self.is_destroyed() {
+            return Ok(false);
+        }
+        if let Some(&mut Some(ref mut context)) = self.inner.contexts.get_mut(&window) {
+            context.focus(&self.xconn).map(|_| true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    pub fn unfocus(&mut self, window: ffi::Window) -> Result<bool, XError> {
+        if self.is_destroyed() {
+            return Ok(false);
+        }
+        if let Some(&mut Some(ref mut context)) = self.inner.contexts.get_mut(&window) {
+            context.unfocus(&self.xconn).map(|_| true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    pub fn send_xim_spot(&mut self, window: ffi::Window, x: i16, y: i16) {
+        if self.is_destroyed() {
+            return;
+        }
+        if let Some(&mut Some(ref mut context)) = self.inner.contexts.get_mut(&window) {
+            context.set_spot(&self.xconn, x as _, y as _);
+        }
+    }
+
+    pub fn set_ime_allowed(&mut self, window: ffi::Window, allowed: bool) {
+        if self.is_destroyed() {
+            return;
+        }
+
+        if let Some(&mut Some(ref mut context)) = self.inner.contexts.get_mut(&window) {
+            if allowed == context.is_allowed() {
+                return;
+            }
+        }
+
+        // Remove context for that window.
+        let _ = self.remove_context(window);
+
+        // Create new context supporting IME input.
+        let _ = self.create_context(window, allowed);
+    }
+}
+
+impl Drop for Ime {
+    fn drop(&mut self) {
+        unsafe {
+            let _ = self.inner.destroy_all_contexts_if_necessary();
+            let _ = self.inner.close_im_if_necessary();
+        }
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/mod.rs

@@ -0,0 +1,812 @@
+#![cfg(x11_platform)]
+
+mod dnd;
+mod event_processor;
+mod events;
+pub mod ffi;
+mod ime;
+mod monitor;
+pub mod util;
+mod window;
+mod xdisplay;
+
+pub(crate) use self::{
+    monitor::{MonitorHandle, VideoMode},
+    window::UnownedWindow,
+    xdisplay::XConnection,
+};
+
+pub use self::xdisplay::{XError, XNotSupported};
+
+use std::{
+    cell::{Cell, RefCell},
+    collections::{HashMap, HashSet},
+    ffi::CStr,
+    mem::{self, MaybeUninit},
+    ops::Deref,
+    os::raw::*,
+    ptr,
+    rc::Rc,
+    slice,
+    sync::mpsc::{Receiver, Sender, TryRecvError},
+    sync::{mpsc, Arc, Weak},
+    time::{Duration, Instant},
+};
+
+use libc::{self, setlocale, LC_CTYPE};
+
+use mio::{unix::SourceFd, Events, Interest, Poll, Token, Waker};
+use raw_window_handle::{RawDisplayHandle, XlibDisplayHandle};
+
+use self::{
+    dnd::{Dnd, DndState},
+    event_processor::EventProcessor,
+    ime::{Ime, ImeCreationError, ImeReceiver, ImeRequest, ImeSender},
+    util::modifiers::ModifierKeymap,
+};
+use crate::{
+    error::OsError as RootOsError,
+    event::{Event, StartCause},
+    event_loop::{
+        ControlFlow, DeviceEventFilter, EventLoopClosed, EventLoopWindowTarget as RootELW,
+    },
+    platform_impl::{
+        platform::{sticky_exit_callback, WindowId},
+        PlatformSpecificWindowBuilderAttributes,
+    },
+    window::WindowAttributes,
+};
+
+const X_TOKEN: Token = Token(0);
+const USER_REDRAW_TOKEN: Token = Token(1);
+
+struct WakeSender<T> {
+    sender: Sender<T>,
+    waker: Arc<Waker>,
+}
+
+struct PeekableReceiver<T> {
+    recv: Receiver<T>,
+    first: Option<T>,
+}
+
+impl<T> PeekableReceiver<T> {
+    pub fn from_recv(recv: Receiver<T>) -> Self {
+        Self { recv, first: None }
+    }
+    pub fn has_incoming(&mut self) -> bool {
+        if self.first.is_some() {
+            return true;
+        }
+
+        match self.recv.try_recv() {
+            Ok(v) => {
+                self.first = Some(v);
+                true
+            }
+            Err(TryRecvError::Empty) => false,
+            Err(TryRecvError::Disconnected) => {
+                warn!("Channel was disconnected when checking incoming");
+                false
+            }
+        }
+    }
+    pub fn try_recv(&mut self) -> Result<T, TryRecvError> {
+        if let Some(first) = self.first.take() {
+            return Ok(first);
+        }
+        self.recv.try_recv()
+    }
+}
+
+pub struct EventLoopWindowTarget<T> {
+    xconn: Arc<XConnection>,
+    wm_delete_window: ffi::Atom,
+    net_wm_ping: ffi::Atom,
+    ime_sender: ImeSender,
+    root: ffi::Window,
+    ime: RefCell<Ime>,
+    windows: RefCell<HashMap<WindowId, Weak<UnownedWindow>>>,
+    redraw_sender: WakeSender<WindowId>,
+    device_event_filter: Cell<DeviceEventFilter>,
+    _marker: ::std::marker::PhantomData<T>,
+}
+
+pub struct EventLoop<T: 'static> {
+    poll: Poll,
+    waker: Arc<Waker>,
+    event_processor: EventProcessor<T>,
+    redraw_receiver: PeekableReceiver<WindowId>,
+    user_receiver: PeekableReceiver<T>, //waker.wake needs to be called whenever something gets sent
+    user_sender: Sender<T>,
+    target: Rc<RootELW<T>>,
+}
+
+pub struct EventLoopProxy<T: 'static> {
+    user_sender: Sender<T>,
+    waker: Arc<Waker>,
+}
+
+impl<T: 'static> Clone for EventLoopProxy<T> {
+    fn clone(&self) -> Self {
+        EventLoopProxy {
+            user_sender: self.user_sender.clone(),
+            waker: self.waker.clone(),
+        }
+    }
+}
+
+impl<T: 'static> EventLoop<T> {
+    pub(crate) fn new(xconn: Arc<XConnection>) -> EventLoop<T> {
+        let root = unsafe { (xconn.xlib.XDefaultRootWindow)(xconn.display) };
+
+        let wm_delete_window = unsafe { xconn.get_atom_unchecked(b"WM_DELETE_WINDOW\0") };
+
+        let net_wm_ping = unsafe { xconn.get_atom_unchecked(b"_NET_WM_PING\0") };
+
+        let dnd = Dnd::new(Arc::clone(&xconn))
+            .expect("Failed to call XInternAtoms when initializing drag and drop");
+
+        let (ime_sender, ime_receiver) = mpsc::channel();
+        let (ime_event_sender, ime_event_receiver) = mpsc::channel();
+        // Input methods will open successfully without setting the locale, but it won't be
+        // possible to actually commit pre-edit sequences.
+        unsafe {
+            // Remember default locale to restore it if target locale is unsupported
+            // by Xlib
+            let default_locale = setlocale(LC_CTYPE, ptr::null());
+            setlocale(LC_CTYPE, b"\0".as_ptr() as *const _);
+
+            // Check if set locale is supported by Xlib.
+            // If not, calls to some Xlib functions like `XSetLocaleModifiers`
+            // will fail.
+            let locale_supported = (xconn.xlib.XSupportsLocale)() == 1;
+            if !locale_supported {
+                let unsupported_locale = setlocale(LC_CTYPE, ptr::null());
+                warn!(
+                    "Unsupported locale \"{}\". Restoring default locale \"{}\".",
+                    CStr::from_ptr(unsupported_locale).to_string_lossy(),
+                    CStr::from_ptr(default_locale).to_string_lossy()
+                );
+                // Restore default locale
+                setlocale(LC_CTYPE, default_locale);
+            }
+        }
+        let ime = RefCell::new({
+            let result = Ime::new(Arc::clone(&xconn), ime_event_sender);
+            if let Err(ImeCreationError::OpenFailure(ref state)) = result {
+                panic!("Failed to open input method: {state:#?}");
+            }
+            result.expect("Failed to set input method destruction callback")
+        });
+
+        let randr_event_offset = xconn
+            .select_xrandr_input(root)
+            .expect("Failed to query XRandR extension");
+
+        let xi2ext = unsafe {
+            let mut ext = XExtension::default();
+
+            let res = (xconn.xlib.XQueryExtension)(
+                xconn.display,
+                b"XInputExtension\0".as_ptr() as *const c_char,
+                &mut ext.opcode,
+                &mut ext.first_event_id,
+                &mut ext.first_error_id,
+            );
+
+            if res == ffi::False {
+                panic!("X server missing XInput extension");
+            }
+
+            ext
+        };
+
+        unsafe {
+            let mut xinput_major_ver = ffi::XI_2_Major;
+            let mut xinput_minor_ver = ffi::XI_2_Minor;
+            if (xconn.xinput2.XIQueryVersion)(
+                xconn.display,
+                &mut xinput_major_ver,
+                &mut xinput_minor_ver,
+            ) != ffi::Success as libc::c_int
+            {
+                panic!(
+                    "X server has XInput extension {xinput_major_ver}.{xinput_minor_ver} but does not support XInput2",
+                );
+            }
+        }
+
+        xconn.update_cached_wm_info(root);
+
+        let mut mod_keymap = ModifierKeymap::new();
+        mod_keymap.reset_from_x_connection(&xconn);
+
+        let poll = Poll::new().unwrap();
+        let waker = Arc::new(Waker::new(poll.registry(), USER_REDRAW_TOKEN).unwrap());
+
+        poll.registry()
+            .register(&mut SourceFd(&xconn.x11_fd), X_TOKEN, Interest::READABLE)
+            .unwrap();
+
+        let (user_sender, user_channel) = std::sync::mpsc::channel();
+        let (redraw_sender, redraw_channel) = std::sync::mpsc::channel();
+
+        let window_target = EventLoopWindowTarget {
+            ime,
+            root,
+            windows: Default::default(),
+            _marker: ::std::marker::PhantomData,
+            ime_sender,
+            xconn,
+            wm_delete_window,
+            net_wm_ping,
+            redraw_sender: WakeSender {
+                sender: redraw_sender, // not used again so no clone
+                waker: waker.clone(),
+            },
+            device_event_filter: Default::default(),
+        };
+
+        // Set initial device event filter.
+        window_target.update_device_event_filter(true);
+
+        let target = Rc::new(RootELW {
+            p: super::EventLoopWindowTarget::X(window_target),
+            _marker: ::std::marker::PhantomData,
+        });
+
+        let event_processor = EventProcessor {
+            target: target.clone(),
+            dnd,
+            devices: Default::default(),
+            randr_event_offset,
+            ime_receiver,
+            ime_event_receiver,
+            xi2ext,
+            mod_keymap,
+            device_mod_state: Default::default(),
+            num_touch: 0,
+            first_touch: None,
+            active_window: None,
+            is_composing: false,
+        };
+
+        // Register for device hotplug events
+        // (The request buffer is flushed during `init_device`)
+        get_xtarget(&target)
+            .xconn
+            .select_xinput_events(root, ffi::XIAllDevices, ffi::XI_HierarchyChangedMask)
+            .queue();
+
+        event_processor.init_device(ffi::XIAllDevices);
+
+        EventLoop {
+            poll,
+            waker,
+            event_processor,
+            redraw_receiver: PeekableReceiver::from_recv(redraw_channel),
+            user_receiver: PeekableReceiver::from_recv(user_channel),
+            user_sender,
+            target,
+        }
+    }
+
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+        EventLoopProxy {
+            user_sender: self.user_sender.clone(),
+            waker: self.waker.clone(),
+        }
+    }
+
+    pub(crate) fn window_target(&self) -> &RootELW<T> {
+        &self.target
+    }
+
+    pub fn run_return<F>(&mut self, mut callback: F) -> i32
+    where
+        F: FnMut(Event<'_, T>, &RootELW<T>, &mut ControlFlow),
+    {
+        struct IterationResult {
+            deadline: Option<Instant>,
+            timeout: Option<Duration>,
+            wait_start: Instant,
+        }
+        fn single_iteration<T, F>(
+            this: &mut EventLoop<T>,
+            control_flow: &mut ControlFlow,
+            cause: &mut StartCause,
+            callback: &mut F,
+        ) -> IterationResult
+        where
+            F: FnMut(Event<'_, T>, &RootELW<T>, &mut ControlFlow),
+        {
+            sticky_exit_callback(
+                crate::event::Event::NewEvents(*cause),
+                &this.target,
+                control_flow,
+                callback,
+            );
+
+            // NB: For consistency all platforms must emit a 'resumed' event even though X11
+            // applications don't themselves have a formal suspend/resume lifecycle.
+            if *cause == StartCause::Init {
+                sticky_exit_callback(
+                    crate::event::Event::Resumed,
+                    &this.target,
+                    control_flow,
+                    callback,
+                );
+            }
+
+            // Process all pending events
+            this.drain_events(callback, control_flow);
+
+            // Empty the user event buffer
+            {
+                while let Ok(event) = this.user_receiver.try_recv() {
+                    sticky_exit_callback(
+                        crate::event::Event::UserEvent(event),
+                        &this.target,
+                        control_flow,
+                        callback,
+                    );
+                }
+            }
+            // send MainEventsCleared
+            {
+                sticky_exit_callback(
+                    crate::event::Event::MainEventsCleared,
+                    &this.target,
+                    control_flow,
+                    callback,
+                );
+            }
+            // Empty the redraw requests
+            {
+                let mut windows = HashSet::new();
+
+                while let Ok(window_id) = this.redraw_receiver.try_recv() {
+                    windows.insert(window_id);
+                }
+
+                for window_id in windows {
+                    let window_id = crate::window::WindowId(window_id);
+                    sticky_exit_callback(
+                        Event::RedrawRequested(window_id),
+                        &this.target,
+                        control_flow,
+                        callback,
+                    );
+                }
+            }
+            // send RedrawEventsCleared
+            {
+                sticky_exit_callback(
+                    crate::event::Event::RedrawEventsCleared,
+                    &this.target,
+                    control_flow,
+                    callback,
+                );
+            }
+
+            let start = Instant::now();
+            let (deadline, timeout);
+
+            match control_flow {
+                ControlFlow::ExitWithCode(_) => {
+                    return IterationResult {
+                        wait_start: start,
+                        deadline: None,
+                        timeout: None,
+                    };
+                }
+                ControlFlow::Poll => {
+                    *cause = StartCause::Poll;
+                    deadline = None;
+                    timeout = Some(Duration::from_millis(0));
+                }
+                ControlFlow::Wait => {
+                    *cause = StartCause::WaitCancelled {
+                        start,
+                        requested_resume: None,
+                    };
+                    deadline = None;
+                    timeout = None;
+                }
+                ControlFlow::WaitUntil(wait_deadline) => {
+                    *cause = StartCause::ResumeTimeReached {
+                        start,
+                        requested_resume: *wait_deadline,
+                    };
+                    timeout = if *wait_deadline > start {
+                        Some(*wait_deadline - start)
+                    } else {
+                        Some(Duration::from_millis(0))
+                    };
+                    deadline = Some(*wait_deadline);
+                }
+            }
+
+            IterationResult {
+                wait_start: start,
+                deadline,
+                timeout,
+            }
+        }
+
+        let mut control_flow = ControlFlow::default();
+        let mut events = Events::with_capacity(8);
+        let mut cause = StartCause::Init;
+
+        // run the initial loop iteration
+        let mut iter_result = single_iteration(self, &mut control_flow, &mut cause, &mut callback);
+
+        let exit_code = loop {
+            if let ControlFlow::ExitWithCode(code) = control_flow {
+                break code;
+            }
+            let has_pending = self.event_processor.poll()
+                || self.user_receiver.has_incoming()
+                || self.redraw_receiver.has_incoming();
+            if !has_pending {
+                // Wait until
+                if let Err(e) = self.poll.poll(&mut events, iter_result.timeout) {
+                    if e.raw_os_error() != Some(libc::EINTR) {
+                        panic!("epoll returned an error: {e:?}");
+                    }
+                }
+                events.clear();
+
+                if control_flow == ControlFlow::Wait {
+                    // We don't go straight into executing the event loop iteration, we instead go
+                    // to the start of this loop and check again if there's any pending event. We
+                    // must do this because during the execution of the iteration we sometimes wake
+                    // the mio waker, and if the waker is already awaken before we call poll(),
+                    // then poll doesn't block, but it returns immediately. This caused the event
+                    // loop to run continuously even if the control_flow was `Wait`
+                    continue;
+                }
+            }
+
+            let wait_cancelled = iter_result
+                .deadline
+                .map_or(false, |deadline| Instant::now() < deadline);
+
+            if wait_cancelled {
+                cause = StartCause::WaitCancelled {
+                    start: iter_result.wait_start,
+                    requested_resume: iter_result.deadline,
+                };
+            }
+
+            iter_result = single_iteration(self, &mut control_flow, &mut cause, &mut callback);
+        };
+
+        callback(
+            crate::event::Event::LoopDestroyed,
+            &self.target,
+            &mut control_flow,
+        );
+        exit_code
+    }
+
+    pub fn run<F>(mut self, callback: F) -> !
+    where
+        F: 'static + FnMut(Event<'_, T>, &RootELW<T>, &mut ControlFlow),
+    {
+        let exit_code = self.run_return(callback);
+        ::std::process::exit(exit_code);
+    }
+
+    fn drain_events<F>(&mut self, callback: &mut F, control_flow: &mut ControlFlow)
+    where
+        F: FnMut(Event<'_, T>, &RootELW<T>, &mut ControlFlow),
+    {
+        let target = &self.target;
+        let mut xev = MaybeUninit::uninit();
+        let wt = get_xtarget(&self.target);
+
+        while unsafe { self.event_processor.poll_one_event(xev.as_mut_ptr()) } {
+            let mut xev = unsafe { xev.assume_init() };
+            self.event_processor.process_event(&mut xev, |event| {
+                sticky_exit_callback(
+                    event,
+                    target,
+                    control_flow,
+                    &mut |event, window_target, control_flow| {
+                        if let Event::RedrawRequested(crate::window::WindowId(wid)) = event {
+                            wt.redraw_sender.sender.send(wid).unwrap();
+                            wt.redraw_sender.waker.wake().unwrap();
+                        } else {
+                            callback(event, window_target, control_flow);
+                        }
+                    },
+                );
+            });
+        }
+    }
+}
+
+pub(crate) fn get_xtarget<T>(target: &RootELW<T>) -> &EventLoopWindowTarget<T> {
+    match target.p {
+        super::EventLoopWindowTarget::X(ref target) => target,
+        #[cfg(wayland_platform)]
+        _ => unreachable!(),
+    }
+}
+
+impl<T> EventLoopWindowTarget<T> {
+    /// Returns the `XConnection` of this events loop.
+    #[inline]
+    pub(crate) fn x_connection(&self) -> &Arc<XConnection> {
+        &self.xconn
+    }
+
+    pub fn set_device_event_filter(&self, filter: DeviceEventFilter) {
+        self.device_event_filter.set(filter);
+    }
+
+    /// Update the device event filter based on window focus.
+    pub fn update_device_event_filter(&self, focus: bool) {
+        let filter_events = self.device_event_filter.get() == DeviceEventFilter::Never
+            || (self.device_event_filter.get() == DeviceEventFilter::Unfocused && !focus);
+
+        let mut mask = 0;
+        if !filter_events {
+            mask = ffi::XI_RawMotionMask
+                | ffi::XI_RawButtonPressMask
+                | ffi::XI_RawButtonReleaseMask
+                | ffi::XI_RawKeyPressMask
+                | ffi::XI_RawKeyReleaseMask;
+        }
+
+        self.xconn
+            .select_xinput_events(self.root, ffi::XIAllMasterDevices, mask)
+            .queue();
+    }
+
+    pub fn raw_display_handle(&self) -> raw_window_handle::RawDisplayHandle {
+        let mut display_handle = XlibDisplayHandle::empty();
+        display_handle.display = self.xconn.display as *mut _;
+        display_handle.screen =
+            unsafe { (self.xconn.xlib.XDefaultScreen)(self.xconn.display as *mut _) };
+        RawDisplayHandle::Xlib(display_handle)
+    }
+}
+
+impl<T: 'static> EventLoopProxy<T> {
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+        self.user_sender
+            .send(event)
+            .map_err(|e| EventLoopClosed(e.0))
+            .map(|_| self.waker.wake().unwrap())
+    }
+}
+
+struct DeviceInfo<'a> {
+    xconn: &'a XConnection,
+    info: *const ffi::XIDeviceInfo,
+    count: usize,
+}
+
+impl<'a> DeviceInfo<'a> {
+    fn get(xconn: &'a XConnection, device: c_int) -> Option<Self> {
+        unsafe {
+            let mut count = 0;
+            let info = (xconn.xinput2.XIQueryDevice)(xconn.display, device, &mut count);
+            xconn.check_errors().ok()?;
+
+            if info.is_null() || count == 0 {
+                None
+            } else {
+                Some(DeviceInfo {
+                    xconn,
+                    info,
+                    count: count as usize,
+                })
+            }
+        }
+    }
+}
+
+impl<'a> Drop for DeviceInfo<'a> {
+    fn drop(&mut self) {
+        assert!(!self.info.is_null());
+        unsafe { (self.xconn.xinput2.XIFreeDeviceInfo)(self.info as *mut _) };
+    }
+}
+
+impl<'a> Deref for DeviceInfo<'a> {
+    type Target = [ffi::XIDeviceInfo];
+    fn deref(&self) -> &Self::Target {
+        unsafe { slice::from_raw_parts(self.info, self.count) }
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct DeviceId(c_int);
+
+impl DeviceId {
+    #[allow(unused)]
+    pub const unsafe fn dummy() -> Self {
+        DeviceId(0)
+    }
+}
+
+pub(crate) struct Window(Arc<UnownedWindow>);
+
+impl Deref for Window {
+    type Target = UnownedWindow;
+    #[inline]
+    fn deref(&self) -> &UnownedWindow {
+        &self.0
+    }
+}
+
+impl Window {
+    pub(crate) fn new<T>(
+        event_loop: &EventLoopWindowTarget<T>,
+        attribs: WindowAttributes,
+        pl_attribs: PlatformSpecificWindowBuilderAttributes,
+    ) -> Result<Self, RootOsError> {
+        let window = Arc::new(UnownedWindow::new(event_loop, attribs, pl_attribs)?);
+        event_loop
+            .windows
+            .borrow_mut()
+            .insert(window.id(), Arc::downgrade(&window));
+        Ok(Window(window))
+    }
+}
+
+impl Drop for Window {
+    fn drop(&mut self) {
+        let window = self.deref();
+        let xconn = &window.xconn;
+        unsafe {
+            (xconn.xlib.XDestroyWindow)(xconn.display, window.id().0 as ffi::Window);
+            // If the window was somehow already destroyed, we'll get a `BadWindow` error, which we don't care about.
+            let _ = xconn.check_errors();
+        }
+    }
+}
+
+/// XEvents of type GenericEvent store their actual data in an XGenericEventCookie data structure. This is a wrapper to
+/// extract the cookie from a GenericEvent XEvent and release the cookie data once it has been processed
+struct GenericEventCookie<'a> {
+    xconn: &'a XConnection,
+    cookie: ffi::XGenericEventCookie,
+}
+
+impl<'a> GenericEventCookie<'a> {
+    fn from_event(xconn: &XConnection, event: ffi::XEvent) -> Option<GenericEventCookie<'_>> {
+        unsafe {
+            let mut cookie: ffi::XGenericEventCookie = From::from(event);
+            if (xconn.xlib.XGetEventData)(xconn.display, &mut cookie) == ffi::True {
+                Some(GenericEventCookie { xconn, cookie })
+            } else {
+                None
+            }
+        }
+    }
+}
+
+impl<'a> Drop for GenericEventCookie<'a> {
+    fn drop(&mut self) {
+        unsafe {
+            (self.xconn.xlib.XFreeEventData)(self.xconn.display, &mut self.cookie);
+        }
+    }
+}
+
+#[derive(Debug, Default, Copy, Clone)]
+struct XExtension {
+    opcode: c_int,
+    first_event_id: c_int,
+    first_error_id: c_int,
+}
+
+fn mkwid(w: ffi::Window) -> crate::window::WindowId {
+    crate::window::WindowId(crate::platform_impl::platform::WindowId(w as _))
+}
+fn mkdid(w: c_int) -> crate::event::DeviceId {
+    crate::event::DeviceId(crate::platform_impl::DeviceId::X(DeviceId(w)))
+}
+
+#[derive(Debug)]
+struct Device {
+    _name: String,
+    scroll_axes: Vec<(i32, ScrollAxis)>,
+    // For master devices, this is the paired device (pointer <-> keyboard).
+    // For slave devices, this is the master.
+    attachment: c_int,
+}
+
+#[derive(Debug, Copy, Clone)]
+struct ScrollAxis {
+    increment: f64,
+    orientation: ScrollOrientation,
+    position: f64,
+}
+
+#[derive(Debug, Copy, Clone)]
+enum ScrollOrientation {
+    Vertical,
+    Horizontal,
+}
+
+impl Device {
+    fn new(info: &ffi::XIDeviceInfo) -> Self {
+        let name = unsafe { CStr::from_ptr(info.name).to_string_lossy() };
+        let mut scroll_axes = Vec::new();
+
+        if Device::physical_device(info) {
+            // Identify scroll axes
+            for class_ptr in Device::classes(info) {
+                let class = unsafe { &**class_ptr };
+                if class._type == ffi::XIScrollClass {
+                    let info = unsafe {
+                        mem::transmute::<&ffi::XIAnyClassInfo, &ffi::XIScrollClassInfo>(class)
+                    };
+                    scroll_axes.push((
+                        info.number,
+                        ScrollAxis {
+                            increment: info.increment,
+                            orientation: match info.scroll_type {
+                                ffi::XIScrollTypeHorizontal => ScrollOrientation::Horizontal,
+                                ffi::XIScrollTypeVertical => ScrollOrientation::Vertical,
+                                _ => unreachable!(),
+                            },
+                            position: 0.0,
+                        },
+                    ));
+                }
+            }
+        }
+
+        let mut device = Device {
+            _name: name.into_owned(),
+            scroll_axes,
+            attachment: info.attachment,
+        };
+        device.reset_scroll_position(info);
+        device
+    }
+
+    fn reset_scroll_position(&mut self, info: &ffi::XIDeviceInfo) {
+        if Device::physical_device(info) {
+            for class_ptr in Device::classes(info) {
+                let class = unsafe { &**class_ptr };
+                if class._type == ffi::XIValuatorClass {
+                    let info = unsafe {
+                        mem::transmute::<&ffi::XIAnyClassInfo, &ffi::XIValuatorClassInfo>(class)
+                    };
+                    if let Some(&mut (_, ref mut axis)) = self
+                        .scroll_axes
+                        .iter_mut()
+                        .find(|&&mut (axis, _)| axis == info.number)
+                    {
+                        axis.position = info.value;
+                    }
+                }
+            }
+        }
+    }
+
+    #[inline]
+    fn physical_device(info: &ffi::XIDeviceInfo) -> bool {
+        info._use == ffi::XISlaveKeyboard
+            || info._use == ffi::XISlavePointer
+            || info._use == ffi::XIFloatingSlave
+    }
+
+    #[inline]
+    fn classes(info: &ffi::XIDeviceInfo) -> &[*const ffi::XIAnyClassInfo] {
+        unsafe {
+            slice::from_raw_parts(
+                info.classes as *const *const ffi::XIAnyClassInfo,
+                info.num_classes as usize,
+            )
+        }
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/monitor.rs

@@ -0,0 +1,341 @@
+use std::os::raw::*;
+use std::slice;
+use std::sync::Mutex;
+
+use once_cell::sync::Lazy;
+
+use super::{
+    ffi::{
+        RRCrtc, RRCrtcChangeNotifyMask, RRMode, RROutputPropertyNotifyMask,
+        RRScreenChangeNotifyMask, True, Window, XRRCrtcInfo, XRRModeInfo, XRRScreenResources,
+    },
+    util, XConnection, XError,
+};
+use crate::{
+    dpi::{PhysicalPosition, PhysicalSize},
+    platform_impl::{MonitorHandle as PlatformMonitorHandle, VideoMode as PlatformVideoMode},
+};
+
+// Used for testing. This should always be committed as false.
+const DISABLE_MONITOR_LIST_CACHING: bool = false;
+
+static MONITORS: Lazy<Mutex<Option<Vec<MonitorHandle>>>> = Lazy::new(Mutex::default);
+
+pub fn invalidate_cached_monitor_list() -> Option<Vec<MonitorHandle>> {
+    // We update this lazily.
+    (*MONITORS.lock().unwrap()).take()
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct VideoMode {
+    pub(crate) size: (u32, u32),
+    pub(crate) bit_depth: u16,
+    pub(crate) refresh_rate_millihertz: u32,
+    pub(crate) native_mode: RRMode,
+    pub(crate) monitor: Option<MonitorHandle>,
+}
+
+impl VideoMode {
+    #[inline]
+    pub fn size(&self) -> PhysicalSize<u32> {
+        self.size.into()
+    }
+
+    #[inline]
+    pub fn bit_depth(&self) -> u16 {
+        self.bit_depth
+    }
+
+    #[inline]
+    pub fn refresh_rate_millihertz(&self) -> u32 {
+        self.refresh_rate_millihertz
+    }
+
+    #[inline]
+    pub fn monitor(&self) -> PlatformMonitorHandle {
+        PlatformMonitorHandle::X(self.monitor.clone().unwrap())
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct MonitorHandle {
+    /// The actual id
+    pub(crate) id: RRCrtc,
+    /// The name of the monitor
+    pub(crate) name: String,
+    /// The size of the monitor
+    dimensions: (u32, u32),
+    /// The position of the monitor in the X screen
+    position: (i32, i32),
+    /// If the monitor is the primary one
+    primary: bool,
+    /// The refresh rate used by monitor.
+    refresh_rate_millihertz: Option<u32>,
+    /// The DPI scale factor
+    pub(crate) scale_factor: f64,
+    /// Used to determine which windows are on this monitor
+    pub(crate) rect: util::AaRect,
+    /// Supported video modes on this monitor
+    video_modes: Vec<VideoMode>,
+}
+
+impl PartialEq for MonitorHandle {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+impl Eq for MonitorHandle {}
+
+impl PartialOrd for MonitorHandle {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for MonitorHandle {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.id.cmp(&other.id)
+    }
+}
+
+impl std::hash::Hash for MonitorHandle {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.id.hash(state);
+    }
+}
+
+#[inline]
+pub fn mode_refresh_rate_millihertz(mode: &XRRModeInfo) -> Option<u32> {
+    if mode.dotClock > 0 && mode.hTotal > 0 && mode.vTotal > 0 {
+        #[allow(clippy::unnecessary_cast)]
+        Some((mode.dotClock as u64 * 1000 / (mode.hTotal as u64 * mode.vTotal as u64)) as u32)
+    } else {
+        None
+    }
+}
+
+impl MonitorHandle {
+    fn new(
+        xconn: &XConnection,
+        resources: *mut XRRScreenResources,
+        id: RRCrtc,
+        crtc: *mut XRRCrtcInfo,
+        primary: bool,
+    ) -> Option<Self> {
+        let (name, scale_factor, video_modes) = unsafe { xconn.get_output_info(resources, crtc)? };
+        let dimensions = unsafe { ((*crtc).width, (*crtc).height) };
+        let position = unsafe { ((*crtc).x, (*crtc).y) };
+
+        // Get the refresh rate of the current video mode.
+        let current_mode = unsafe { (*crtc).mode };
+        let screen_modes =
+            unsafe { slice::from_raw_parts((*resources).modes, (*resources).nmode as usize) };
+        let refresh_rate_millihertz = screen_modes
+            .iter()
+            .find(|mode| mode.id == current_mode)
+            .and_then(mode_refresh_rate_millihertz);
+
+        let rect = util::AaRect::new(position, dimensions);
+
+        Some(MonitorHandle {
+            id,
+            name,
+            refresh_rate_millihertz,
+            scale_factor,
+            dimensions,
+            position,
+            primary,
+            rect,
+            video_modes,
+        })
+    }
+
+    pub fn dummy() -> Self {
+        MonitorHandle {
+            id: 0,
+            name: "<dummy monitor>".into(),
+            scale_factor: 1.0,
+            dimensions: (1, 1),
+            position: (0, 0),
+            refresh_rate_millihertz: None,
+            primary: true,
+            rect: util::AaRect::new((0, 0), (1, 1)),
+            video_modes: Vec::new(),
+        }
+    }
+
+    pub(crate) fn is_dummy(&self) -> bool {
+        // Zero is an invalid XID value; no real monitor will have it
+        self.id == 0
+    }
+
+    pub fn name(&self) -> Option<String> {
+        Some(self.name.clone())
+    }
+
+    #[inline]
+    pub fn native_identifier(&self) -> u32 {
+        self.id as _
+    }
+
+    pub fn size(&self) -> PhysicalSize<u32> {
+        self.dimensions.into()
+    }
+
+    pub fn position(&self) -> PhysicalPosition<i32> {
+        self.position.into()
+    }
+
+    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
+        self.refresh_rate_millihertz
+    }
+
+    #[inline]
+    pub fn scale_factor(&self) -> f64 {
+        self.scale_factor
+    }
+
+    #[inline]
+    pub fn video_modes(&self) -> impl Iterator<Item = PlatformVideoMode> {
+        let monitor = self.clone();
+        self.video_modes.clone().into_iter().map(move |mut x| {
+            x.monitor = Some(monitor.clone());
+            PlatformVideoMode::X(x)
+        })
+    }
+}
+
+impl XConnection {
+    pub fn get_monitor_for_window(&self, window_rect: Option<util::AaRect>) -> MonitorHandle {
+        let monitors = self.available_monitors();
+
+        if monitors.is_empty() {
+            // Return a dummy monitor to avoid panicking
+            return MonitorHandle::dummy();
+        }
+
+        let default = monitors.get(0).unwrap();
+
+        let window_rect = match window_rect {
+            Some(rect) => rect,
+            None => return default.to_owned(),
+        };
+
+        let mut largest_overlap = 0;
+        let mut matched_monitor = default;
+        for monitor in &monitors {
+            let overlapping_area = window_rect.get_overlapping_area(&monitor.rect);
+            if overlapping_area > largest_overlap {
+                largest_overlap = overlapping_area;
+                matched_monitor = monitor;
+            }
+        }
+
+        matched_monitor.to_owned()
+    }
+
+    fn query_monitor_list(&self) -> Vec<MonitorHandle> {
+        unsafe {
+            let mut major = 0;
+            let mut minor = 0;
+            (self.xrandr.XRRQueryVersion)(self.display, &mut major, &mut minor);
+
+            let root = (self.xlib.XDefaultRootWindow)(self.display);
+            let resources = if (major == 1 && minor >= 3) || major > 1 {
+                (self.xrandr.XRRGetScreenResourcesCurrent)(self.display, root)
+            } else {
+                // WARNING: this function is supposedly very slow, on the order of hundreds of ms.
+                // Upon failure, `resources` will be null.
+                (self.xrandr.XRRGetScreenResources)(self.display, root)
+            };
+
+            if resources.is_null() {
+                panic!("[winit] `XRRGetScreenResources` returned NULL. That should only happen if the root window doesn't exist.");
+            }
+
+            let mut has_primary = false;
+
+            let primary = (self.xrandr.XRRGetOutputPrimary)(self.display, root);
+            let mut available = Vec::with_capacity((*resources).ncrtc as usize);
+
+            for crtc_index in 0..(*resources).ncrtc {
+                let crtc_id = *((*resources).crtcs.offset(crtc_index as isize));
+                let crtc = (self.xrandr.XRRGetCrtcInfo)(self.display, resources, crtc_id);
+                let is_active = (*crtc).width > 0 && (*crtc).height > 0 && (*crtc).noutput > 0;
+                if is_active {
+                    let is_primary = *(*crtc).outputs.offset(0) == primary;
+                    has_primary |= is_primary;
+                    if let Some(monitor_id) =
+                        MonitorHandle::new(self, resources, crtc_id, crtc, is_primary)
+                    {
+                        available.push(monitor_id)
+                    }
+                }
+                (self.xrandr.XRRFreeCrtcInfo)(crtc);
+            }
+
+            // If no monitors were detected as being primary, we just pick one ourselves!
+            if !has_primary {
+                if let Some(ref mut fallback) = available.first_mut() {
+                    // Setting this here will come in handy if we ever add an `is_primary` method.
+                    fallback.primary = true;
+                }
+            }
+
+            (self.xrandr.XRRFreeScreenResources)(resources);
+            available
+        }
+    }
+
+    pub fn available_monitors(&self) -> Vec<MonitorHandle> {
+        let mut monitors_lock = MONITORS.lock().unwrap();
+        (*monitors_lock)
+            .as_ref()
+            .cloned()
+            .or_else(|| {
+                let monitors = Some(self.query_monitor_list());
+                if !DISABLE_MONITOR_LIST_CACHING {
+                    (*monitors_lock) = monitors.clone();
+                }
+                monitors
+            })
+            .unwrap()
+    }
+
+    #[inline]
+    pub fn primary_monitor(&self) -> MonitorHandle {
+        self.available_monitors()
+            .into_iter()
+            .find(|monitor| monitor.primary)
+            .unwrap_or_else(MonitorHandle::dummy)
+    }
+
+    pub fn select_xrandr_input(&self, root: Window) -> Result<c_int, XError> {
+        let has_xrandr = unsafe {
+            let mut major = 0;
+            let mut minor = 0;
+            (self.xrandr.XRRQueryVersion)(self.display, &mut major, &mut minor)
+        };
+        assert!(
+            has_xrandr == True,
+            "[winit] XRandR extension not available."
+        );
+
+        let mut event_offset = 0;
+        let mut error_offset = 0;
+        let status = unsafe {
+            (self.xrandr.XRRQueryExtension)(self.display, &mut event_offset, &mut error_offset)
+        };
+
+        if status != True {
+            self.check_errors()?;
+            unreachable!("[winit] `XRRQueryExtension` failed but no error was received.");
+        }
+
+        let mask = RRCrtcChangeNotifyMask | RROutputPropertyNotifyMask | RRScreenChangeNotifyMask;
+        unsafe { (self.xrandr.XRRSelectInput)(self.display, root, mask) };
+
+        Ok(event_offset)
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/util/atom.rs

@@ -0,0 +1,70 @@
+use std::{
+    collections::HashMap,
+    ffi::{CStr, CString},
+    fmt::Debug,
+    os::raw::*,
+    sync::Mutex,
+};
+
+use once_cell::sync::Lazy;
+
+use super::*;
+
+type AtomCache = HashMap<CString, ffi::Atom>;
+
+static ATOM_CACHE: Lazy<Mutex<AtomCache>> = Lazy::new(|| Mutex::new(HashMap::with_capacity(2048)));
+
+impl XConnection {
+    pub fn get_atom<T: AsRef<CStr> + Debug>(&self, name: T) -> ffi::Atom {
+        let name = name.as_ref();
+        let mut atom_cache_lock = ATOM_CACHE.lock().unwrap();
+        let cached_atom = (*atom_cache_lock).get(name).cloned();
+        if let Some(atom) = cached_atom {
+            atom
+        } else {
+            let atom = unsafe {
+                (self.xlib.XInternAtom)(self.display, name.as_ptr() as *const c_char, ffi::False)
+            };
+            if atom == 0 {
+                panic!(
+                    "`XInternAtom` failed, which really shouldn't happen. Atom: {:?}, Error: {:#?}",
+                    name,
+                    self.check_errors(),
+                );
+            }
+            /*println!(
+                "XInternAtom name:{:?} atom:{:?}",
+                name,
+                atom,
+            );*/
+            (*atom_cache_lock).insert(name.to_owned(), atom);
+            atom
+        }
+    }
+
+    pub unsafe fn get_atom_unchecked(&self, name: &[u8]) -> ffi::Atom {
+        debug_assert!(CStr::from_bytes_with_nul(name).is_ok());
+        let name = CStr::from_bytes_with_nul_unchecked(name);
+        self.get_atom(name)
+    }
+
+    // Note: this doesn't use caching, for the sake of simplicity.
+    // If you're dealing with this many atoms, you'll usually want to cache them locally anyway.
+    pub unsafe fn get_atoms(&self, names: &[*mut c_char]) -> Result<Vec<ffi::Atom>, XError> {
+        let mut atoms = Vec::with_capacity(names.len());
+        (self.xlib.XInternAtoms)(
+            self.display,
+            names.as_ptr() as *mut _,
+            names.len() as c_int,
+            ffi::False,
+            atoms.as_mut_ptr(),
+        );
+        self.check_errors()?;
+        atoms.set_len(names.len());
+        /*println!(
+            "XInternAtoms atoms:{:?}",
+            atoms,
+        );*/
+        Ok(atoms)
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/util/client_msg.rs

@@ -0,0 +1,46 @@
+use super::*;
+
+pub type ClientMsgPayload = [c_long; 5];
+
+impl XConnection {
+    pub fn send_event<T: Into<ffi::XEvent>>(
+        &self,
+        target_window: c_ulong,
+        event_mask: Option<c_long>,
+        event: T,
+    ) -> Flusher<'_> {
+        let event_mask = event_mask.unwrap_or(ffi::NoEventMask);
+        unsafe {
+            (self.xlib.XSendEvent)(
+                self.display,
+                target_window,
+                ffi::False,
+                event_mask,
+                &mut event.into(),
+            );
+        }
+        Flusher::new(self)
+    }
+
+    pub fn send_client_msg(
+        &self,
+        window: c_ulong, // The window this is "about"; not necessarily this window
+        target_window: c_ulong, // The window we're sending to
+        message_type: ffi::Atom,
+        event_mask: Option<c_long>,
+        data: ClientMsgPayload,
+    ) -> Flusher<'_> {
+        let event = ffi::XClientMessageEvent {
+            type_: ffi::ClientMessage,
+            display: self.display,
+            window,
+            message_type,
+            format: c_long::FORMAT as c_int,
+            data: unsafe { mem::transmute(data) },
+            // These fields are ignored by `XSendEvent`
+            serial: 0,
+            send_event: 0,
+        };
+        self.send_event(target_window, event_mask, event)
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/util/cursor.rs

@@ -0,0 +1,130 @@
+use crate::window::CursorIcon;
+
+use super::*;
+
+impl XConnection {
+    pub fn set_cursor_icon(&self, window: ffi::Window, cursor: Option<CursorIcon>) {
+        let cursor = *self
+            .cursor_cache
+            .lock()
+            .unwrap()
+            .entry(cursor)
+            .or_insert_with(|| self.get_cursor(cursor));
+
+        self.update_cursor(window, cursor);
+    }
+
+    fn create_empty_cursor(&self) -> ffi::Cursor {
+        let data = 0;
+        let pixmap = unsafe {
+            let screen = (self.xlib.XDefaultScreen)(self.display);
+            let window = (self.xlib.XRootWindow)(self.display, screen);
+            (self.xlib.XCreateBitmapFromData)(self.display, window, &data, 1, 1)
+        };
+
+        if pixmap == 0 {
+            panic!("failed to allocate pixmap for cursor");
+        }
+
+        unsafe {
+            // We don't care about this color, since it only fills bytes
+            // in the pixmap which are not 0 in the mask.
+            let mut dummy_color = MaybeUninit::uninit();
+            let cursor = (self.xlib.XCreatePixmapCursor)(
+                self.display,
+                pixmap,
+                pixmap,
+                dummy_color.as_mut_ptr(),
+                dummy_color.as_mut_ptr(),
+                0,
+                0,
+            );
+            (self.xlib.XFreePixmap)(self.display, pixmap);
+
+            cursor
+        }
+    }
+
+    fn load_cursor(&self, name: &[u8]) -> ffi::Cursor {
+        unsafe {
+            (self.xcursor.XcursorLibraryLoadCursor)(self.display, name.as_ptr() as *const c_char)
+        }
+    }
+
+    fn load_first_existing_cursor(&self, names: &[&[u8]]) -> ffi::Cursor {
+        for name in names.iter() {
+            let xcursor = self.load_cursor(name);
+            if xcursor != 0 {
+                return xcursor;
+            }
+        }
+        0
+    }
+
+    fn get_cursor(&self, cursor: Option<CursorIcon>) -> ffi::Cursor {
+        let cursor = match cursor {
+            Some(cursor) => cursor,
+            None => return self.create_empty_cursor(),
+        };
+
+        let load = |name: &[u8]| self.load_cursor(name);
+
+        let loadn = |names: &[&[u8]]| self.load_first_existing_cursor(names);
+
+        // Try multiple names in some cases where the name
+        // differs on the desktop environments or themes.
+        //
+        // Try the better looking (or more suiting) names first.
+        match cursor {
+            CursorIcon::Alias => load(b"link\0"),
+            CursorIcon::Arrow => load(b"arrow\0"),
+            CursorIcon::Cell => load(b"plus\0"),
+            CursorIcon::Copy => load(b"copy\0"),
+            CursorIcon::Crosshair => load(b"crosshair\0"),
+            CursorIcon::Default => load(b"left_ptr\0"),
+            CursorIcon::Hand => loadn(&[b"hand2\0", b"hand1\0"]),
+            CursorIcon::Help => load(b"question_arrow\0"),
+            CursorIcon::Move => load(b"move\0"),
+            CursorIcon::Grab => loadn(&[b"openhand\0", b"grab\0"]),
+            CursorIcon::Grabbing => loadn(&[b"closedhand\0", b"grabbing\0"]),
+            CursorIcon::Progress => load(b"left_ptr_watch\0"),
+            CursorIcon::AllScroll => load(b"all-scroll\0"),
+            CursorIcon::ContextMenu => load(b"context-menu\0"),
+
+            CursorIcon::NoDrop => loadn(&[b"no-drop\0", b"circle\0"]),
+            CursorIcon::NotAllowed => load(b"crossed_circle\0"),
+
+            // Resize cursors
+            CursorIcon::EResize => load(b"right_side\0"),
+            CursorIcon::NResize => load(b"top_side\0"),
+            CursorIcon::NeResize => load(b"top_right_corner\0"),
+            CursorIcon::NwResize => load(b"top_left_corner\0"),
+            CursorIcon::SResize => load(b"bottom_side\0"),
+            CursorIcon::SeResize => load(b"bottom_right_corner\0"),
+            CursorIcon::SwResize => load(b"bottom_left_corner\0"),
+            CursorIcon::WResize => load(b"left_side\0"),
+            CursorIcon::EwResize => load(b"h_double_arrow\0"),
+            CursorIcon::NsResize => load(b"v_double_arrow\0"),
+            CursorIcon::NwseResize => loadn(&[b"bd_double_arrow\0", b"size_fdiag\0"]),
+            CursorIcon::NeswResize => loadn(&[b"fd_double_arrow\0", b"size_bdiag\0"]),
+            CursorIcon::ColResize => loadn(&[b"split_h\0", b"h_double_arrow\0"]),
+            CursorIcon::RowResize => loadn(&[b"split_v\0", b"v_double_arrow\0"]),
+
+            CursorIcon::Text => loadn(&[b"text\0", b"xterm\0"]),
+            CursorIcon::VerticalText => load(b"vertical-text\0"),
+
+            CursorIcon::Wait => load(b"watch\0"),
+
+            CursorIcon::ZoomIn => load(b"zoom-in\0"),
+            CursorIcon::ZoomOut => load(b"zoom-out\0"),
+        }
+    }
+
+    fn update_cursor(&self, window: ffi::Window, cursor: ffi::Cursor) {
+        unsafe {
+            (self.xlib.XDefineCursor)(self.display, window, cursor);
+
+            self.flush_requests().expect("Failed to set the cursor");
+        }
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/util/format.rs

@@ -0,0 +1,55 @@
+use std::{fmt::Debug, mem, os::raw::*};
+
+// This isn't actually the number of the bits in the format.
+// X11 does a match on this value to determine which type to call sizeof on.
+// Thus, we use 32 for c_long, since 32 maps to c_long which maps to 64.
+// ...if that sounds confusing, then you know why this enum is here.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Format {
+    Char = 8,
+    Short = 16,
+    Long = 32,
+}
+
+impl Format {
+    pub fn from_format(format: usize) -> Option<Self> {
+        match format {
+            8 => Some(Format::Char),
+            16 => Some(Format::Short),
+            32 => Some(Format::Long),
+            _ => None,
+        }
+    }
+
+    pub fn get_actual_size(&self) -> usize {
+        match self {
+            Format::Char => mem::size_of::<c_char>(),
+            Format::Short => mem::size_of::<c_short>(),
+            Format::Long => mem::size_of::<c_long>(),
+        }
+    }
+}
+
+pub trait Formattable: Debug + Clone + Copy + PartialEq + PartialOrd {
+    const FORMAT: Format;
+}
+
+// You might be surprised by the absence of c_int, but not as surprised as X11 would be by the presence of it.
+impl Formattable for c_schar {
+    const FORMAT: Format = Format::Char;
+}
+impl Formattable for c_uchar {
+    const FORMAT: Format = Format::Char;
+}
+impl Formattable for c_short {
+    const FORMAT: Format = Format::Short;
+}
+impl Formattable for c_ushort {
+    const FORMAT: Format = Format::Short;
+}
+impl Formattable for c_long {
+    const FORMAT: Format = Format::Long;
+}
+impl Formattable for c_ulong {
+    const FORMAT: Format = Format::Long;
+}

third-party/vendor/winit/src/platform_impl/linux/x11/util/geometry.rs

@@ -0,0 +1,393 @@
+use std::cmp;
+
+use super::*;
+
+// Friendly neighborhood axis-aligned rectangle
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AaRect {
+    x: i64,
+    y: i64,
+    width: i64,
+    height: i64,
+}
+
+impl AaRect {
+    pub fn new((x, y): (i32, i32), (width, height): (u32, u32)) -> Self {
+        let (x, y) = (x as i64, y as i64);
+        let (width, height) = (width as i64, height as i64);
+        AaRect {
+            x,
+            y,
+            width,
+            height,
+        }
+    }
+
+    pub fn contains_point(&self, x: i64, y: i64) -> bool {
+        x >= self.x && x <= self.x + self.width && y >= self.y && y <= self.y + self.height
+    }
+
+    pub fn get_overlapping_area(&self, other: &Self) -> i64 {
+        let x_overlap = cmp::max(
+            0,
+            cmp::min(self.x + self.width, other.x + other.width) - cmp::max(self.x, other.x),
+        );
+        let y_overlap = cmp::max(
+            0,
+            cmp::min(self.y + self.height, other.y + other.height) - cmp::max(self.y, other.y),
+        );
+        x_overlap * y_overlap
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct TranslatedCoords {
+    pub x_rel_root: c_int,
+    pub y_rel_root: c_int,
+    pub child: ffi::Window,
+}
+
+#[derive(Debug, Default)]
+pub struct Geometry {
+    pub root: ffi::Window,
+    // If you want positions relative to the root window, use translate_coords.
+    // Note that the overwhelming majority of window managers are reparenting WMs, thus the window
+    // ID we get from window creation is for a nested window used as the window's client area. If
+    // you call get_geometry with that window ID, then you'll get the position of that client area
+    // window relative to the parent it's nested in (the frame), which isn't helpful if you want
+    // to know the frame position.
+    pub x_rel_parent: c_int,
+    pub y_rel_parent: c_int,
+    // In that same case, this will give you client area size.
+    pub width: c_uint,
+    pub height: c_uint,
+    // xmonad and dwm were the only WMs tested that use the border return at all.
+    // The majority of WMs seem to simply fill it with 0 unconditionally.
+    pub border: c_uint,
+    pub depth: c_uint,
+}
+
+#[derive(Debug, Clone)]
+pub struct FrameExtents {
+    pub left: c_ulong,
+    pub right: c_ulong,
+    pub top: c_ulong,
+    pub bottom: c_ulong,
+}
+
+impl FrameExtents {
+    pub fn new(left: c_ulong, right: c_ulong, top: c_ulong, bottom: c_ulong) -> Self {
+        FrameExtents {
+            left,
+            right,
+            top,
+            bottom,
+        }
+    }
+
+    pub fn from_border(border: c_ulong) -> Self {
+        Self::new(border, border, border, border)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct LogicalFrameExtents {
+    pub left: f64,
+    pub right: f64,
+    pub top: f64,
+    pub bottom: f64,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum FrameExtentsHeuristicPath {
+    Supported,
+    UnsupportedNested,
+    UnsupportedBordered,
+}
+
+#[derive(Debug, Clone)]
+pub struct FrameExtentsHeuristic {
+    pub frame_extents: FrameExtents,
+    pub heuristic_path: FrameExtentsHeuristicPath,
+}
+
+impl FrameExtentsHeuristic {
+    pub fn inner_pos_to_outer(&self, x: i32, y: i32) -> (i32, i32) {
+        use self::FrameExtentsHeuristicPath::*;
+        if self.heuristic_path != UnsupportedBordered {
+            (
+                x - self.frame_extents.left as i32,
+                y - self.frame_extents.top as i32,
+            )
+        } else {
+            (x, y)
+        }
+    }
+
+    pub fn inner_size_to_outer(&self, width: u32, height: u32) -> (u32, u32) {
+        (
+            width.saturating_add(
+                self.frame_extents
+                    .left
+                    .saturating_add(self.frame_extents.right) as _,
+            ),
+            height.saturating_add(
+                self.frame_extents
+                    .top
+                    .saturating_add(self.frame_extents.bottom) as _,
+            ),
+        )
+    }
+}
+
+impl XConnection {
+    // This is adequate for inner_position
+    pub fn translate_coords(
+        &self,
+        window: ffi::Window,
+        root: ffi::Window,
+    ) -> Result<TranslatedCoords, XError> {
+        let mut coords = TranslatedCoords::default();
+
+        unsafe {
+            (self.xlib.XTranslateCoordinates)(
+                self.display,
+                window,
+                root,
+                0,
+                0,
+                &mut coords.x_rel_root,
+                &mut coords.y_rel_root,
+                &mut coords.child,
+            );
+        }
+
+        self.check_errors()?;
+        Ok(coords)
+    }
+
+    // This is adequate for inner_size
+    pub fn get_geometry(&self, window: ffi::Window) -> Result<Geometry, XError> {
+        let mut geometry = Geometry::default();
+
+        let _status = unsafe {
+            (self.xlib.XGetGeometry)(
+                self.display,
+                window,
+                &mut geometry.root,
+                &mut geometry.x_rel_parent,
+                &mut geometry.y_rel_parent,
+                &mut geometry.width,
+                &mut geometry.height,
+                &mut geometry.border,
+                &mut geometry.depth,
+            )
+        };
+
+        self.check_errors()?;
+        Ok(geometry)
+    }
+
+    fn get_frame_extents(&self, window: ffi::Window) -> Option<FrameExtents> {
+        let extents_atom = unsafe { self.get_atom_unchecked(b"_NET_FRAME_EXTENTS\0") };
+
+        if !hint_is_supported(extents_atom) {
+            return None;
+        }
+
+        // Of the WMs tested, xmonad, i3, dwm, IceWM (1.3.x and earlier), and blackbox don't
+        // support this. As this is part of EWMH (Extended Window Manager Hints), it's likely to
+        // be unsupported by many smaller WMs.
+        let extents: Option<Vec<c_ulong>> = self
+            .get_property(window, extents_atom, ffi::XA_CARDINAL)
+            .ok();
+
+        extents.and_then(|extents| {
+            if extents.len() >= 4 {
+                Some(FrameExtents {
+                    left: extents[0],
+                    right: extents[1],
+                    top: extents[2],
+                    bottom: extents[3],
+                })
+            } else {
+                None
+            }
+        })
+    }
+
+    pub fn is_top_level(&self, window: ffi::Window, root: ffi::Window) -> Option<bool> {
+        let client_list_atom = unsafe { self.get_atom_unchecked(b"_NET_CLIENT_LIST\0") };
+
+        if !hint_is_supported(client_list_atom) {
+            return None;
+        }
+
+        let client_list: Option<Vec<ffi::Window>> = self
+            .get_property(root, client_list_atom, ffi::XA_WINDOW)
+            .ok();
+
+        client_list.map(|client_list| client_list.contains(&window))
+    }
+
+    fn get_parent_window(&self, window: ffi::Window) -> Result<ffi::Window, XError> {
+        let parent = unsafe {
+            let mut root = 0;
+            let mut parent = 0;
+            let mut children: *mut ffi::Window = ptr::null_mut();
+            let mut nchildren = 0;
+
+            // What's filled into `parent` if `window` is the root window?
+            let _status = (self.xlib.XQueryTree)(
+                self.display,
+                window,
+                &mut root,
+                &mut parent,
+                &mut children,
+                &mut nchildren,
+            );
+
+            // The list of children isn't used
+            if !children.is_null() {
+                (self.xlib.XFree)(children as *mut _);
+            }
+
+            parent
+        };
+        self.check_errors().map(|_| parent)
+    }
+
+    fn climb_hierarchy(
+        &self,
+        window: ffi::Window,
+        root: ffi::Window,
+    ) -> Result<ffi::Window, XError> {
+        let mut outer_window = window;
+        loop {
+            let candidate = self.get_parent_window(outer_window)?;
+            if candidate == root {
+                break;
+            }
+            outer_window = candidate;
+        }
+        Ok(outer_window)
+    }
+
+    pub fn get_frame_extents_heuristic(
+        &self,
+        window: ffi::Window,
+        root: ffi::Window,
+    ) -> FrameExtentsHeuristic {
+        use self::FrameExtentsHeuristicPath::*;
+
+        // Position relative to root window.
+        // With rare exceptions, this is the position of a nested window. Cases where the window
+        // isn't nested are outlined in the comments throghout this function, but in addition to
+        // that, fullscreen windows often aren't nested.
+        let (inner_y_rel_root, child) = {
+            let coords = self
+                .translate_coords(window, root)
+                .expect("Failed to translate window coordinates");
+            (coords.y_rel_root, coords.child)
+        };
+
+        let (width, height, border) = {
+            let inner_geometry = self
+                .get_geometry(window)
+                .expect("Failed to get inner window geometry");
+            (
+                inner_geometry.width,
+                inner_geometry.height,
+                inner_geometry.border,
+            )
+        };
+
+        // The first condition is only false for un-nested windows, but isn't always false for
+        // un-nested windows. Mutter/Muffin/Budgie and Marco present a mysterious discrepancy:
+        // when y is on the range [0, 2] and if the window has been unfocused since being
+        // undecorated (or was undecorated upon construction), the first condition is true,
+        // requiring us to rely on the second condition.
+        let nested = !(window == child || self.is_top_level(child, root) == Some(true));
+
+        // Hopefully the WM supports EWMH, allowing us to get exact info on the window frames.
+        if let Some(mut frame_extents) = self.get_frame_extents(window) {
+            // Mutter/Muffin/Budgie and Marco preserve their decorated frame extents when
+            // decorations are disabled, but since the window becomes un-nested, it's easy to
+            // catch.
+            if !nested {
+                frame_extents = FrameExtents::new(0, 0, 0, 0);
+            }
+
+            // The difference between the nested window's position and the outermost window's
+            // position is equivalent to the frame size. In most scenarios, this is equivalent to
+            // manually climbing the hierarchy as is done in the case below. Here's a list of
+            // known discrepancies:
+            // * Mutter/Muffin/Budgie gives decorated windows a margin of 9px (only 7px on top) in
+            //   addition to a 1px semi-transparent border. The margin can be easily observed by
+            //   using a screenshot tool to get a screenshot of a selected window, and is
+            //   presumably used for drawing drop shadows. Getting window geometry information
+            //   via hierarchy-climbing results in this margin being included in both the
+            //   position and outer size, so a window positioned at (0, 0) would be reported as
+            //   having a position (-10, -8).
+            // * Compiz has a drop shadow margin just like Mutter/Muffin/Budgie, though it's 10px
+            //   on all sides, and there's no additional border.
+            // * Enlightenment otherwise gets a y position equivalent to inner_y_rel_root.
+            //   Without decorations, there's no difference. This is presumably related to
+            //   Enlightenment's fairly unique concept of window position; it interprets
+            //   positions given to XMoveWindow as a client area position rather than a position
+            //   of the overall window.
+
+            FrameExtentsHeuristic {
+                frame_extents,
+                heuristic_path: Supported,
+            }
+        } else if nested {
+            // If the position value we have is for a nested window used as the client area, we'll
+            // just climb up the hierarchy and get the geometry of the outermost window we're
+            // nested in.
+            let outer_window = self
+                .climb_hierarchy(window, root)
+                .expect("Failed to climb window hierarchy");
+            let (outer_y, outer_width, outer_height) = {
+                let outer_geometry = self
+                    .get_geometry(outer_window)
+                    .expect("Failed to get outer window geometry");
+                (
+                    outer_geometry.y_rel_parent,
+                    outer_geometry.width,
+                    outer_geometry.height,
+                )
+            };
+
+            // Since we have the geometry of the outermost window and the geometry of the client
+            // area, we can figure out what's in between.
+            let diff_x = outer_width.saturating_sub(width);
+            let diff_y = outer_height.saturating_sub(height);
+            let offset_y = inner_y_rel_root.saturating_sub(outer_y) as c_uint;
+
+            let left = diff_x / 2;
+            let right = left;
+            let top = offset_y;
+            let bottom = diff_y.saturating_sub(offset_y);
+
+            let frame_extents = FrameExtents::new(
+                left as c_ulong,
+                right as c_ulong,
+                top as c_ulong,
+                bottom as c_ulong,
+            );
+            FrameExtentsHeuristic {
+                frame_extents,
+                heuristic_path: UnsupportedNested,
+            }
+        } else {
+            // This is the case for xmonad and dwm, AKA the only WMs tested that supplied a
+            // border value. This is convenient, since we can use it to get an accurate frame.
+            let frame_extents = FrameExtents::from_border(border as c_ulong);
+            FrameExtentsHeuristic {
+                frame_extents,
+                heuristic_path: UnsupportedBordered,
+            }
+        }
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/util/hint.rs

@@ -0,0 +1,348 @@
+use std::slice;
+use std::sync::Arc;
+
+use super::*;
+
+#[derive(Debug)]
+#[allow(dead_code)]
+pub enum StateOperation {
+    Remove = 0, // _NET_WM_STATE_REMOVE
+    Add = 1,    // _NET_WM_STATE_ADD
+    Toggle = 2, // _NET_WM_STATE_TOGGLE
+}
+
+impl From<bool> for StateOperation {
+    fn from(op: bool) -> Self {
+        if op {
+            StateOperation::Add
+        } else {
+            StateOperation::Remove
+        }
+    }
+}
+
+/// X window type. Maps directly to
+/// [`_NET_WM_WINDOW_TYPE`](https://specifications.freedesktop.org/wm-spec/wm-spec-1.5.html).
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum WindowType {
+    /// A desktop feature. This can include a single window containing desktop icons with the same dimensions as the
+    /// screen, allowing the desktop environment to have full control of the desktop, without the need for proxying
+    /// root window clicks.
+    Desktop,
+    /// A dock or panel feature. Typically a Window Manager would keep such windows on top of all other windows.
+    Dock,
+    /// Toolbar windows. "Torn off" from the main application.
+    Toolbar,
+    /// Pinnable menu windows. "Torn off" from the main application.
+    Menu,
+    /// A small persistent utility window, such as a palette or toolbox.
+    Utility,
+    /// The window is a splash screen displayed as an application is starting up.
+    Splash,
+    /// This is a dialog window.
+    Dialog,
+    /// A dropdown menu that usually appears when the user clicks on an item in a menu bar.
+    /// This property is typically used on override-redirect windows.
+    DropdownMenu,
+    /// A popup menu that usually appears when the user right clicks on an object.
+    /// This property is typically used on override-redirect windows.
+    PopupMenu,
+    /// A tooltip window. Usually used to show additional information when hovering over an object with the cursor.
+    /// This property is typically used on override-redirect windows.
+    Tooltip,
+    /// The window is a notification.
+    /// This property is typically used on override-redirect windows.
+    Notification,
+    /// This should be used on the windows that are popped up by combo boxes.
+    /// This property is typically used on override-redirect windows.
+    Combo,
+    /// This indicates the the window is being dragged.
+    /// This property is typically used on override-redirect windows.
+    Dnd,
+    /// This is a normal, top-level window.
+    Normal,
+}
+
+impl Default for WindowType {
+    fn default() -> Self {
+        WindowType::Normal
+    }
+}
+
+impl WindowType {
+    pub(crate) fn as_atom(&self, xconn: &Arc<XConnection>) -> ffi::Atom {
+        use self::WindowType::*;
+        let atom_name: &[u8] = match *self {
+            Desktop => b"_NET_WM_WINDOW_TYPE_DESKTOP\0",
+            Dock => b"_NET_WM_WINDOW_TYPE_DOCK\0",
+            Toolbar => b"_NET_WM_WINDOW_TYPE_TOOLBAR\0",
+            Menu => b"_NET_WM_WINDOW_TYPE_MENU\0",
+            Utility => b"_NET_WM_WINDOW_TYPE_UTILITY\0",
+            Splash => b"_NET_WM_WINDOW_TYPE_SPLASH\0",
+            Dialog => b"_NET_WM_WINDOW_TYPE_DIALOG\0",
+            DropdownMenu => b"_NET_WM_WINDOW_TYPE_DROPDOWN_MENU\0",
+            PopupMenu => b"_NET_WM_WINDOW_TYPE_POPUP_MENU\0",
+            Tooltip => b"_NET_WM_WINDOW_TYPE_TOOLTIP\0",
+            Notification => b"_NET_WM_WINDOW_TYPE_NOTIFICATION\0",
+            Combo => b"_NET_WM_WINDOW_TYPE_COMBO\0",
+            Dnd => b"_NET_WM_WINDOW_TYPE_DND\0",
+            Normal => b"_NET_WM_WINDOW_TYPE_NORMAL\0",
+        };
+        unsafe { xconn.get_atom_unchecked(atom_name) }
+    }
+}
+
+pub struct MotifHints {
+    hints: MwmHints,
+}
+
+#[repr(C)]
+struct MwmHints {
+    flags: c_ulong,
+    functions: c_ulong,
+    decorations: c_ulong,
+    input_mode: c_long,
+    status: c_ulong,
+}
+
+#[allow(dead_code)]
+mod mwm {
+    use libc::c_ulong;
+
+    // Motif WM hints are obsolete, but still widely supported.
+    // https://stackoverflow.com/a/1909708
+    pub const MWM_HINTS_FUNCTIONS: c_ulong = 1 << 0;
+    pub const MWM_HINTS_DECORATIONS: c_ulong = 1 << 1;
+
+    pub const MWM_FUNC_ALL: c_ulong = 1 << 0;
+    pub const MWM_FUNC_RESIZE: c_ulong = 1 << 1;
+    pub const MWM_FUNC_MOVE: c_ulong = 1 << 2;
+    pub const MWM_FUNC_MINIMIZE: c_ulong = 1 << 3;
+    pub const MWM_FUNC_MAXIMIZE: c_ulong = 1 << 4;
+    pub const MWM_FUNC_CLOSE: c_ulong = 1 << 5;
+}
+
+impl MotifHints {
+    pub fn new() -> MotifHints {
+        MotifHints {
+            hints: MwmHints {
+                flags: 0,
+                functions: 0,
+                decorations: 0,
+                input_mode: 0,
+                status: 0,
+            },
+        }
+    }
+
+    pub fn set_decorations(&mut self, decorations: bool) {
+        self.hints.flags |= mwm::MWM_HINTS_DECORATIONS;
+        self.hints.decorations = decorations as c_ulong;
+    }
+
+    pub fn set_maximizable(&mut self, maximizable: bool) {
+        if maximizable {
+            self.add_func(mwm::MWM_FUNC_MAXIMIZE);
+        } else {
+            self.remove_func(mwm::MWM_FUNC_MAXIMIZE);
+        }
+    }
+
+    fn add_func(&mut self, func: c_ulong) {
+        if self.hints.flags & mwm::MWM_HINTS_FUNCTIONS != 0 {
+            if self.hints.functions & mwm::MWM_FUNC_ALL != 0 {
+                self.hints.functions &= !func;
+            } else {
+                self.hints.functions |= func;
+            }
+        }
+    }
+
+    fn remove_func(&mut self, func: c_ulong) {
+        if self.hints.flags & mwm::MWM_HINTS_FUNCTIONS == 0 {
+            self.hints.flags |= mwm::MWM_HINTS_FUNCTIONS;
+            self.hints.functions = mwm::MWM_FUNC_ALL;
+        }
+
+        if self.hints.functions & mwm::MWM_FUNC_ALL != 0 {
+            self.hints.functions |= func;
+        } else {
+            self.hints.functions &= !func;
+        }
+    }
+}
+
+impl Default for MotifHints {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl MwmHints {
+    fn as_slice(&self) -> &[c_ulong] {
+        unsafe { slice::from_raw_parts(self as *const _ as *const c_ulong, 5) }
+    }
+}
+
+pub(crate) struct NormalHints<'a> {
+    size_hints: XSmartPointer<'a, ffi::XSizeHints>,
+}
+
+impl<'a> NormalHints<'a> {
+    pub fn new(xconn: &'a XConnection) -> Self {
+        NormalHints {
+            size_hints: xconn.alloc_size_hints(),
+        }
+    }
+
+    pub fn get_resize_increments(&self) -> Option<(u32, u32)> {
+        has_flag(self.size_hints.flags, ffi::PResizeInc).then(|| {
+            (
+                self.size_hints.width_inc as u32,
+                self.size_hints.height_inc as u32,
+            )
+        })
+    }
+
+    pub fn set_position(&mut self, position: Option<(i32, i32)>) {
+        if let Some((x, y)) = position {
+            self.size_hints.flags |= ffi::PPosition;
+            self.size_hints.x = x as c_int;
+            self.size_hints.y = y as c_int;
+        } else {
+            self.size_hints.flags &= !ffi::PPosition;
+        }
+    }
+
+    // WARNING: This hint is obsolete
+    pub fn set_size(&mut self, size: Option<(u32, u32)>) {
+        if let Some((width, height)) = size {
+            self.size_hints.flags |= ffi::PSize;
+            self.size_hints.width = width as c_int;
+            self.size_hints.height = height as c_int;
+        } else {
+            self.size_hints.flags &= !ffi::PSize;
+        }
+    }
+
+    pub fn set_max_size(&mut self, max_size: Option<(u32, u32)>) {
+        if let Some((max_width, max_height)) = max_size {
+            self.size_hints.flags |= ffi::PMaxSize;
+            self.size_hints.max_width = max_width as c_int;
+            self.size_hints.max_height = max_height as c_int;
+        } else {
+            self.size_hints.flags &= !ffi::PMaxSize;
+        }
+    }
+
+    pub fn set_min_size(&mut self, min_size: Option<(u32, u32)>) {
+        if let Some((min_width, min_height)) = min_size {
+            self.size_hints.flags |= ffi::PMinSize;
+            self.size_hints.min_width = min_width as c_int;
+            self.size_hints.min_height = min_height as c_int;
+        } else {
+            self.size_hints.flags &= !ffi::PMinSize;
+        }
+    }
+
+    pub fn set_resize_increments(&mut self, resize_increments: Option<(u32, u32)>) {
+        if let Some((width_inc, height_inc)) = resize_increments {
+            self.size_hints.flags |= ffi::PResizeInc;
+            self.size_hints.width_inc = width_inc as c_int;
+            self.size_hints.height_inc = height_inc as c_int;
+        } else {
+            self.size_hints.flags &= !ffi::PResizeInc;
+        }
+    }
+
+    pub fn set_base_size(&mut self, base_size: Option<(u32, u32)>) {
+        if let Some((base_width, base_height)) = base_size {
+            self.size_hints.flags |= ffi::PBaseSize;
+            self.size_hints.base_width = base_width as c_int;
+            self.size_hints.base_height = base_height as c_int;
+        } else {
+            self.size_hints.flags &= !ffi::PBaseSize;
+        }
+    }
+}
+
+impl XConnection {
+    pub fn get_wm_hints(
+        &self,
+        window: ffi::Window,
+    ) -> Result<XSmartPointer<'_, ffi::XWMHints>, XError> {
+        let wm_hints = unsafe { (self.xlib.XGetWMHints)(self.display, window) };
+        self.check_errors()?;
+        let wm_hints = if wm_hints.is_null() {
+            self.alloc_wm_hints()
+        } else {
+            XSmartPointer::new(self, wm_hints).unwrap()
+        };
+        Ok(wm_hints)
+    }
+
+    pub fn set_wm_hints(
+        &self,
+        window: ffi::Window,
+        wm_hints: XSmartPointer<'_, ffi::XWMHints>,
+    ) -> Flusher<'_> {
+        unsafe {
+            (self.xlib.XSetWMHints)(self.display, window, wm_hints.ptr);
+        }
+        Flusher::new(self)
+    }
+
+    pub fn get_normal_hints(&self, window: ffi::Window) -> Result<NormalHints<'_>, XError> {
+        let size_hints = self.alloc_size_hints();
+        let mut supplied_by_user = MaybeUninit::uninit();
+        unsafe {
+            (self.xlib.XGetWMNormalHints)(
+                self.display,
+                window,
+                size_hints.ptr,
+                supplied_by_user.as_mut_ptr(),
+            );
+        }
+        self.check_errors().map(|_| NormalHints { size_hints })
+    }
+
+    pub fn set_normal_hints(
+        &self,
+        window: ffi::Window,
+        normal_hints: NormalHints<'_>,
+    ) -> Flusher<'_> {
+        unsafe {
+            (self.xlib.XSetWMNormalHints)(self.display, window, normal_hints.size_hints.ptr);
+        }
+        Flusher::new(self)
+    }
+
+    pub fn get_motif_hints(&self, window: ffi::Window) -> MotifHints {
+        let motif_hints = unsafe { self.get_atom_unchecked(b"_MOTIF_WM_HINTS\0") };
+
+        let mut hints = MotifHints::new();
+
+        if let Ok(props) = self.get_property::<c_ulong>(window, motif_hints, motif_hints) {
+            hints.hints.flags = props.first().cloned().unwrap_or(0);
+            hints.hints.functions = props.get(1).cloned().unwrap_or(0);
+            hints.hints.decorations = props.get(2).cloned().unwrap_or(0);
+            hints.hints.input_mode = props.get(3).cloned().unwrap_or(0) as c_long;
+            hints.hints.status = props.get(4).cloned().unwrap_or(0);
+        }
+
+        hints
+    }
+
+    pub fn set_motif_hints(&self, window: ffi::Window, hints: &MotifHints) -> Flusher<'_> {
+        let motif_hints = unsafe { self.get_atom_unchecked(b"_MOTIF_WM_HINTS\0") };
+
+        self.change_property(
+            window,
+            motif_hints,
+            motif_hints,
+            PropMode::Replace,
+            hints.hints.as_slice(),
+        )
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/util/icon.rs

@@ -0,0 +1,37 @@
+#![allow(clippy::assertions_on_constants)]
+
+use super::*;
+use crate::icon::{Icon, Pixel, PIXEL_SIZE};
+
+impl Pixel {
+    pub fn to_packed_argb(&self) -> Cardinal {
+        let mut cardinal = 0;
+        assert!(CARDINAL_SIZE >= PIXEL_SIZE);
+        let as_bytes = &mut cardinal as *mut _ as *mut u8;
+        unsafe {
+            *as_bytes.offset(0) = self.b;
+            *as_bytes.offset(1) = self.g;
+            *as_bytes.offset(2) = self.r;
+            *as_bytes.offset(3) = self.a;
+        }
+        cardinal
+    }
+}
+
+impl Icon {
+    pub(crate) fn to_cardinals(&self) -> Vec<Cardinal> {
+        let rgba_icon = &self.inner;
+        assert_eq!(rgba_icon.rgba.len() % PIXEL_SIZE, 0);
+        let pixel_count = rgba_icon.rgba.len() / PIXEL_SIZE;
+        assert_eq!(pixel_count, (rgba_icon.width * rgba_icon.height) as usize);
+        let mut data = Vec::with_capacity(pixel_count);
+        data.push(rgba_icon.width as Cardinal);
+        data.push(rgba_icon.height as Cardinal);
+        let pixels = rgba_icon.rgba.as_ptr() as *const Pixel;
+        for pixel_index in 0..pixel_count {
+            let pixel = unsafe { &*pixels.add(pixel_index) };
+            data.push(pixel.to_packed_argb());
+        }
+        data
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/util/input.rs

@@ -0,0 +1,190 @@
+use std::{slice, str};
+
+use super::*;
+use crate::event::ModifiersState;
+
+pub const VIRTUAL_CORE_POINTER: c_int = 2;
+pub const VIRTUAL_CORE_KEYBOARD: c_int = 3;
+
+// A base buffer size of 1kB uses a negligible amount of RAM while preventing us from having to
+// re-allocate (and make another round-trip) in the *vast* majority of cases.
+// To test if `lookup_utf8` works correctly, set this to 1.
+const TEXT_BUFFER_SIZE: usize = 1024;
+
+impl ModifiersState {
+    pub(crate) fn from_x11(state: &ffi::XIModifierState) -> Self {
+        ModifiersState::from_x11_mask(state.effective as c_uint)
+    }
+
+    pub(crate) fn from_x11_mask(mask: c_uint) -> Self {
+        let mut m = ModifiersState::empty();
+        m.set(ModifiersState::ALT, mask & ffi::Mod1Mask != 0);
+        m.set(ModifiersState::SHIFT, mask & ffi::ShiftMask != 0);
+        m.set(ModifiersState::CTRL, mask & ffi::ControlMask != 0);
+        m.set(ModifiersState::LOGO, mask & ffi::Mod4Mask != 0);
+        m
+    }
+}
+
+// NOTE: Some of these fields are not used, but may be of use in the future.
+pub struct PointerState<'a> {
+    xconn: &'a XConnection,
+    pub root: ffi::Window,
+    pub child: ffi::Window,
+    pub root_x: c_double,
+    pub root_y: c_double,
+    pub win_x: c_double,
+    pub win_y: c_double,
+    buttons: ffi::XIButtonState,
+    modifiers: ffi::XIModifierState,
+    pub group: ffi::XIGroupState,
+    pub relative_to_window: bool,
+}
+
+impl<'a> PointerState<'a> {
+    pub fn get_modifier_state(&self) -> ModifiersState {
+        ModifiersState::from_x11(&self.modifiers)
+    }
+}
+
+impl<'a> Drop for PointerState<'a> {
+    fn drop(&mut self) {
+        if !self.buttons.mask.is_null() {
+            unsafe {
+                // This is why you need to read the docs carefully...
+                (self.xconn.xlib.XFree)(self.buttons.mask as _);
+            }
+        }
+    }
+}
+
+impl XConnection {
+    pub fn select_xinput_events(
+        &self,
+        window: c_ulong,
+        device_id: c_int,
+        mask: i32,
+    ) -> Flusher<'_> {
+        let mut event_mask = ffi::XIEventMask {
+            deviceid: device_id,
+            mask: &mask as *const _ as *mut c_uchar,
+            mask_len: mem::size_of_val(&mask) as c_int,
+        };
+        unsafe {
+            (self.xinput2.XISelectEvents)(
+                self.display,
+                window,
+                &mut event_mask as *mut ffi::XIEventMask,
+                1, // number of masks to read from pointer above
+            );
+        }
+        Flusher::new(self)
+    }
+
+    #[allow(dead_code)]
+    pub fn select_xkb_events(&self, device_id: c_uint, mask: c_ulong) -> Option<Flusher<'_>> {
+        let status = unsafe { (self.xlib.XkbSelectEvents)(self.display, device_id, mask, mask) };
+        if status == ffi::True {
+            Some(Flusher::new(self))
+        } else {
+            None
+        }
+    }
+
+    pub fn query_pointer(
+        &self,
+        window: ffi::Window,
+        device_id: c_int,
+    ) -> Result<PointerState<'_>, XError> {
+        unsafe {
+            let mut root = 0;
+            let mut child = 0;
+            let mut root_x = 0.0;
+            let mut root_y = 0.0;
+            let mut win_x = 0.0;
+            let mut win_y = 0.0;
+            let mut buttons = Default::default();
+            let mut modifiers = Default::default();
+            let mut group = Default::default();
+
+            let relative_to_window = (self.xinput2.XIQueryPointer)(
+                self.display,
+                device_id,
+                window,
+                &mut root,
+                &mut child,
+                &mut root_x,
+                &mut root_y,
+                &mut win_x,
+                &mut win_y,
+                &mut buttons,
+                &mut modifiers,
+                &mut group,
+            ) == ffi::True;
+
+            self.check_errors()?;
+
+            Ok(PointerState {
+                xconn: self,
+                root,
+                child,
+                root_x,
+                root_y,
+                win_x,
+                win_y,
+                buttons,
+                modifiers,
+                group,
+                relative_to_window,
+            })
+        }
+    }
+
+    fn lookup_utf8_inner(
+        &self,
+        ic: ffi::XIC,
+        key_event: &mut ffi::XKeyEvent,
+        buffer: *mut u8,
+        size: usize,
+    ) -> (ffi::KeySym, ffi::Status, c_int) {
+        let mut keysym: ffi::KeySym = 0;
+        let mut status: ffi::Status = 0;
+        let count = unsafe {
+            (self.xlib.Xutf8LookupString)(
+                ic,
+                key_event,
+                buffer as *mut c_char,
+                size as c_int,
+                &mut keysym,
+                &mut status,
+            )
+        };
+        (keysym, status, count)
+    }
+
+    pub fn lookup_utf8(&self, ic: ffi::XIC, key_event: &mut ffi::XKeyEvent) -> String {
+        // `assume_init` is safe here because the array consists of `MaybeUninit` values,
+        // which do not require initialization.
+        let mut buffer: [MaybeUninit<u8>; TEXT_BUFFER_SIZE] =
+            unsafe { MaybeUninit::uninit().assume_init() };
+        // If the buffer overflows, we'll make a new one on the heap.
+        let mut vec;
+
+        let (_, status, count) =
+            self.lookup_utf8_inner(ic, key_event, buffer.as_mut_ptr() as *mut u8, buffer.len());
+
+        let bytes = if status == ffi::XBufferOverflow {
+            vec = Vec::with_capacity(count as usize);
+            let (_, _, new_count) =
+                self.lookup_utf8_inner(ic, key_event, vec.as_mut_ptr(), vec.capacity());
+            debug_assert_eq!(count, new_count);
+
+            unsafe { vec.set_len(count as usize) };
+            &vec[..count as usize]
+        } else {
+            unsafe { slice::from_raw_parts(buffer.as_ptr() as *const u8, count as usize) }
+        };
+
+        str::from_utf8(bytes).unwrap_or("").to_string()
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/util/keys.rs

@@ -0,0 +1,92 @@
+use std::{iter::Enumerate, ptr, slice::Iter};
+
+use super::*;
+
+pub struct Keymap {
+    keys: [u8; 32],
+}
+
+pub struct KeymapIter<'a> {
+    iter: Enumerate<Iter<'a, u8>>,
+    index: usize,
+    item: Option<u8>,
+}
+
+impl Keymap {
+    pub fn iter(&self) -> KeymapIter<'_> {
+        KeymapIter {
+            iter: self.keys.iter().enumerate(),
+            index: 0,
+            item: None,
+        }
+    }
+}
+
+impl<'a> IntoIterator for &'a Keymap {
+    type Item = ffi::KeyCode;
+    type IntoIter = KeymapIter<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl Iterator for KeymapIter<'_> {
+    type Item = ffi::KeyCode;
+
+    fn next(&mut self) -> Option<ffi::KeyCode> {
+        if self.item.is_none() {
+            for (index, &item) in self.iter.by_ref() {
+                if item != 0 {
+                    self.index = index;
+                    self.item = Some(item);
+                    break;
+                }
+            }
+        }
+
+        self.item.take().map(|item| {
+            debug_assert!(item != 0);
+
+            let bit = first_bit(item);
+
+            if item != bit {
+                // Remove the first bit; save the rest for further iterations
+                self.item = Some(item ^ bit);
+            }
+
+            let shift = bit.trailing_zeros() + (self.index * 8) as u32;
+            shift as ffi::KeyCode
+        })
+    }
+}
+
+impl XConnection {
+    pub fn keycode_to_keysym(&self, keycode: ffi::KeyCode) -> ffi::KeySym {
+        unsafe { (self.xlib.XKeycodeToKeysym)(self.display, keycode, 0) }
+    }
+
+    pub fn lookup_keysym(&self, xkev: &mut ffi::XKeyEvent) -> ffi::KeySym {
+        let mut keysym = 0;
+
+        unsafe {
+            (self.xlib.XLookupString)(xkev, ptr::null_mut(), 0, &mut keysym, ptr::null_mut());
+        }
+
+        keysym
+    }
+
+    pub fn query_keymap(&self) -> Keymap {
+        let mut keys = [0; 32];
+
+        unsafe {
+            (self.xlib.XQueryKeymap)(self.display, keys.as_mut_ptr() as *mut c_char);
+        }
+
+        Keymap { keys }
+    }
+}
+
+fn first_bit(b: u8) -> u8 {
+    1 << b.trailing_zeros()
+}

third-party/vendor/winit/src/platform_impl/linux/x11/util/memory.rs

@@ -0,0 +1,59 @@
+use std::ops::{Deref, DerefMut};
+
+use super::*;
+
+pub(crate) struct XSmartPointer<'a, T> {
+    xconn: &'a XConnection,
+    pub ptr: *mut T,
+}
+
+impl<'a, T> XSmartPointer<'a, T> {
+    // You're responsible for only passing things to this that should be XFree'd.
+    // Returns None if ptr is null.
+    pub fn new(xconn: &'a XConnection, ptr: *mut T) -> Option<Self> {
+        if !ptr.is_null() {
+            Some(XSmartPointer { xconn, ptr })
+        } else {
+            None
+        }
+    }
+}
+
+impl<'a, T> Deref for XSmartPointer<'a, T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        unsafe { &*self.ptr }
+    }
+}
+
+impl<'a, T> DerefMut for XSmartPointer<'a, T> {
+    fn deref_mut(&mut self) -> &mut T {
+        unsafe { &mut *self.ptr }
+    }
+}
+
+impl<'a, T> Drop for XSmartPointer<'a, T> {
+    fn drop(&mut self) {
+        unsafe {
+            (self.xconn.xlib.XFree)(self.ptr as *mut _);
+        }
+    }
+}
+
+impl XConnection {
+    pub fn alloc_class_hint(&self) -> XSmartPointer<'_, ffi::XClassHint> {
+        XSmartPointer::new(self, unsafe { (self.xlib.XAllocClassHint)() })
+            .expect("`XAllocClassHint` returned null; out of memory")
+    }
+
+    pub fn alloc_size_hints(&self) -> XSmartPointer<'_, ffi::XSizeHints> {
+        XSmartPointer::new(self, unsafe { (self.xlib.XAllocSizeHints)() })
+            .expect("`XAllocSizeHints` returned null; out of memory")
+    }
+
+    pub fn alloc_wm_hints(&self) -> XSmartPointer<'_, ffi::XWMHints> {
+        XSmartPointer::new(self, unsafe { (self.xlib.XAllocWMHints)() })
+            .expect("`XAllocWMHints` returned null; out of memory")
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/util/mod.rs

@@ -0,0 +1,99 @@
+// Welcome to the util module, where we try to keep you from shooting yourself in the foot.
+// *results may vary
+
+mod atom;
+mod client_msg;
+mod cursor;
+mod format;
+mod geometry;
+mod hint;
+mod icon;
+mod input;
+pub mod keys;
+mod memory;
+pub mod modifiers;
+mod randr;
+mod window_property;
+mod wm;
+
+pub use self::{
+    atom::*, client_msg::*, format::*, geometry::*, hint::*, icon::*, input::*, randr::*,
+    window_property::*, wm::*,
+};
+
+pub(crate) use self::memory::*;
+
+use std::{
+    mem::{self, MaybeUninit},
+    ops::BitAnd,
+    os::raw::*,
+    ptr,
+};
+
+use super::{ffi, XConnection, XError};
+
+pub fn maybe_change<T: PartialEq>(field: &mut Option<T>, value: T) -> bool {
+    let wrapped = Some(value);
+    if *field != wrapped {
+        *field = wrapped;
+        true
+    } else {
+        false
+    }
+}
+
+pub fn has_flag<T>(bitset: T, flag: T) -> bool
+where
+    T: Copy + PartialEq + BitAnd<T, Output = T>,
+{
+    bitset & flag == flag
+}
+
+#[must_use = "This request was made asynchronously, and is still in the output buffer. You must explicitly choose to either `.flush()` (empty the output buffer, sending the request now) or `.queue()` (wait to send the request, allowing you to continue to add more requests without additional round-trips). For more information, see the documentation for `util::flush_requests`."]
+pub(crate) struct Flusher<'a> {
+    xconn: &'a XConnection,
+}
+
+impl<'a> Flusher<'a> {
+    pub fn new(xconn: &'a XConnection) -> Self {
+        Flusher { xconn }
+    }
+
+    // "I want this request sent now!"
+    pub fn flush(self) -> Result<(), XError> {
+        self.xconn.flush_requests()
+    }
+
+    // "I want the response now too!"
+    pub fn sync(self) -> Result<(), XError> {
+        self.xconn.sync_with_server()
+    }
+
+    // "I'm aware that this request hasn't been sent, and I'm okay with waiting."
+    pub fn queue(self) {}
+}
+
+impl XConnection {
+    // This is impoartant, so pay attention!
+    // Xlib has an output buffer, and tries to hide the async nature of X from you.
+    // This buffer contains the requests you make, and is flushed under various circumstances:
+    // 1. `XPending`, `XNextEvent`, and `XWindowEvent` flush "as needed"
+    // 2. `XFlush` explicitly flushes
+    // 3. `XSync` flushes and blocks until all requests are responded to
+    // 4. Calls that have a return dependent on a response (i.e. `XGetWindowProperty`) sync internally.
+    //    When in doubt, check the X11 source; if a function calls `_XReply`, it flushes and waits.
+    // All util functions that abstract an async function will return a `Flusher`.
+    pub fn flush_requests(&self) -> Result<(), XError> {
+        unsafe { (self.xlib.XFlush)(self.display) };
+        //println!("XFlush");
+        // This isn't necessarily a useful time to check for errors (since our request hasn't
+        // necessarily been processed yet)
+        self.check_errors()
+    }
+
+    pub fn sync_with_server(&self) -> Result<(), XError> {
+        unsafe { (self.xlib.XSync)(self.display, ffi::False) };
+        //println!("XSync");
+        self.check_errors()
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/util/modifiers.rs

@@ -0,0 +1,187 @@
+use std::{collections::HashMap, slice};
+
+use super::*;
+
+use crate::event::{ElementState, ModifiersState};
+
+// Offsets within XModifierKeymap to each set of keycodes.
+// We are only interested in Shift, Control, Alt, and Logo.
+//
+// There are 8 sets total. The order of keycode sets is:
+//     Shift, Lock, Control, Mod1 (Alt), Mod2, Mod3, Mod4 (Logo), Mod5
+//
+// https://tronche.com/gui/x/xlib/input/XSetModifierMapping.html
+const SHIFT_OFFSET: usize = 0;
+const CONTROL_OFFSET: usize = 2;
+const ALT_OFFSET: usize = 3;
+const LOGO_OFFSET: usize = 6;
+const NUM_MODS: usize = 8;
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum Modifier {
+    Alt,
+    Ctrl,
+    Shift,
+    Logo,
+}
+
+#[derive(Debug, Default)]
+pub(crate) struct ModifierKeymap {
+    // Maps keycodes to modifiers
+    keys: HashMap<ffi::KeyCode, Modifier>,
+}
+
+#[derive(Clone, Debug, Default)]
+pub(crate) struct ModifierKeyState {
+    // Contains currently pressed modifier keys and their corresponding modifiers
+    keys: HashMap<ffi::KeyCode, Modifier>,
+    state: ModifiersState,
+}
+
+impl ModifierKeymap {
+    pub fn new() -> ModifierKeymap {
+        ModifierKeymap::default()
+    }
+
+    pub fn get_modifier(&self, keycode: ffi::KeyCode) -> Option<Modifier> {
+        self.keys.get(&keycode).cloned()
+    }
+
+    pub fn reset_from_x_connection(&mut self, xconn: &XConnection) {
+        unsafe {
+            let keymap = (xconn.xlib.XGetModifierMapping)(xconn.display);
+
+            if keymap.is_null() {
+                panic!("failed to allocate XModifierKeymap");
+            }
+
+            self.reset_from_x_keymap(&*keymap);
+
+            (xconn.xlib.XFreeModifiermap)(keymap);
+        }
+    }
+
+    pub fn reset_from_x_keymap(&mut self, keymap: &ffi::XModifierKeymap) {
+        let keys_per_mod = keymap.max_keypermod as usize;
+
+        let keys = unsafe {
+            slice::from_raw_parts(keymap.modifiermap as *const _, keys_per_mod * NUM_MODS)
+        };
+
+        self.keys.clear();
+
+        self.read_x_keys(keys, SHIFT_OFFSET, keys_per_mod, Modifier::Shift);
+        self.read_x_keys(keys, CONTROL_OFFSET, keys_per_mod, Modifier::Ctrl);
+        self.read_x_keys(keys, ALT_OFFSET, keys_per_mod, Modifier::Alt);
+        self.read_x_keys(keys, LOGO_OFFSET, keys_per_mod, Modifier::Logo);
+    }
+
+    fn read_x_keys(
+        &mut self,
+        keys: &[ffi::KeyCode],
+        offset: usize,
+        keys_per_mod: usize,
+        modifier: Modifier,
+    ) {
+        let start = offset * keys_per_mod;
+        let end = start + keys_per_mod;
+
+        for &keycode in &keys[start..end] {
+            if keycode != 0 {
+                self.keys.insert(keycode, modifier);
+            }
+        }
+    }
+}
+
+impl ModifierKeyState {
+    pub fn update_keymap(&mut self, mods: &ModifierKeymap) {
+        self.keys.retain(|k, v| {
+            if let Some(m) = mods.get_modifier(*k) {
+                *v = m;
+                true
+            } else {
+                false
+            }
+        });
+
+        self.reset_state();
+    }
+
+    pub fn update_state(
+        &mut self,
+        state: &ModifiersState,
+        except: Option<Modifier>,
+    ) -> Option<ModifiersState> {
+        let mut new_state = *state;
+
+        match except {
+            Some(Modifier::Alt) => new_state.set(ModifiersState::ALT, self.state.alt()),
+            Some(Modifier::Ctrl) => new_state.set(ModifiersState::CTRL, self.state.ctrl()),
+            Some(Modifier::Shift) => new_state.set(ModifiersState::SHIFT, self.state.shift()),
+            Some(Modifier::Logo) => new_state.set(ModifiersState::LOGO, self.state.logo()),
+            None => (),
+        }
+
+        if self.state == new_state {
+            None
+        } else {
+            self.keys.retain(|_k, v| get_modifier(&new_state, *v));
+            self.state = new_state;
+            Some(new_state)
+        }
+    }
+
+    pub fn modifiers(&self) -> ModifiersState {
+        self.state
+    }
+
+    pub fn key_event(&mut self, state: ElementState, keycode: ffi::KeyCode, modifier: Modifier) {
+        match state {
+            ElementState::Pressed => self.key_press(keycode, modifier),
+            ElementState::Released => self.key_release(keycode),
+        }
+    }
+
+    pub fn key_press(&mut self, keycode: ffi::KeyCode, modifier: Modifier) {
+        self.keys.insert(keycode, modifier);
+
+        set_modifier(&mut self.state, modifier, true);
+    }
+
+    pub fn key_release(&mut self, keycode: ffi::KeyCode) {
+        if let Some(modifier) = self.keys.remove(&keycode) {
+            if !self.keys.values().any(|&m| m == modifier) {
+                set_modifier(&mut self.state, modifier, false);
+            }
+        }
+    }
+
+    fn reset_state(&mut self) {
+        let mut new_state = ModifiersState::default();
+
+        for &m in self.keys.values() {
+            set_modifier(&mut new_state, m, true);
+        }
+
+        self.state = new_state;
+    }
+}
+
+fn get_modifier(state: &ModifiersState, modifier: Modifier) -> bool {
+    match modifier {
+        Modifier::Alt => state.alt(),
+        Modifier::Ctrl => state.ctrl(),
+        Modifier::Shift => state.shift(),
+        Modifier::Logo => state.logo(),
+    }
+}
+
+fn set_modifier(state: &mut ModifiersState, modifier: Modifier, value: bool) {
+    match modifier {
+        Modifier::Alt => state.set(ModifiersState::ALT, value),
+        Modifier::Ctrl => state.set(ModifiersState::CTRL, value),
+        Modifier::Shift => state.set(ModifiersState::SHIFT, value),
+        Modifier::Logo => state.set(ModifiersState::LOGO, value),
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/util/randr.rs

@@ -0,0 +1,214 @@
+use std::{env, slice, str::FromStr};
+
+use super::{
+    ffi::{CurrentTime, RRCrtc, RRMode, Success, XRRCrtcInfo, XRRScreenResources},
+    *,
+};
+use crate::platform_impl::platform::x11::monitor;
+use crate::{dpi::validate_scale_factor, platform_impl::platform::x11::VideoMode};
+
+/// Represents values of `WINIT_HIDPI_FACTOR`.
+pub enum EnvVarDPI {
+    Randr,
+    Scale(f64),
+    NotSet,
+}
+
+pub fn calc_dpi_factor(
+    (width_px, height_px): (u32, u32),
+    (width_mm, height_mm): (u64, u64),
+) -> f64 {
+    // See http://xpra.org/trac/ticket/728 for more information.
+    if width_mm == 0 || height_mm == 0 {
+        warn!("XRandR reported that the display's 0mm in size, which is certifiably insane");
+        return 1.0;
+    }
+
+    let ppmm = ((width_px as f64 * height_px as f64) / (width_mm as f64 * height_mm as f64)).sqrt();
+    // Quantize 1/12 step size
+    let dpi_factor = ((ppmm * (12.0 * 25.4 / 96.0)).round() / 12.0).max(1.0);
+    assert!(validate_scale_factor(dpi_factor));
+    if dpi_factor <= 20. {
+        dpi_factor
+    } else {
+        1.
+    }
+}
+
+impl XConnection {
+    // Retrieve DPI from Xft.dpi property
+    pub unsafe fn get_xft_dpi(&self) -> Option<f64> {
+        (self.xlib.XrmInitialize)();
+        let resource_manager_str = (self.xlib.XResourceManagerString)(self.display);
+        if resource_manager_str.is_null() {
+            return None;
+        }
+        if let Ok(res) = ::std::ffi::CStr::from_ptr(resource_manager_str).to_str() {
+            let name: &str = "Xft.dpi:\t";
+            for pair in res.split('\n') {
+                if let Some(stripped) = pair.strip_prefix(name) {
+                    return f64::from_str(stripped).ok();
+                }
+            }
+        }
+        None
+    }
+    pub unsafe fn get_output_info(
+        &self,
+        resources: *mut XRRScreenResources,
+        crtc: *mut XRRCrtcInfo,
+    ) -> Option<(String, f64, Vec<VideoMode>)> {
+        let output_info =
+            (self.xrandr.XRRGetOutputInfo)(self.display, resources, *(*crtc).outputs.offset(0));
+        if output_info.is_null() {
+            // When calling `XRRGetOutputInfo` on a virtual monitor (versus a physical display)
+            // it's possible for it to return null.
+            // https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=816596
+            let _ = self.check_errors(); // discard `BadRROutput` error
+            return None;
+        }
+
+        let screen = (self.xlib.XDefaultScreen)(self.display);
+        let bit_depth = (self.xlib.XDefaultDepth)(self.display, screen);
+
+        let output_modes =
+            slice::from_raw_parts((*output_info).modes, (*output_info).nmode as usize);
+        let resource_modes = slice::from_raw_parts((*resources).modes, (*resources).nmode as usize);
+
+        let modes = resource_modes
+            .iter()
+            // XRROutputInfo contains an array of mode ids that correspond to
+            // modes in the array in XRRScreenResources
+            .filter(|x| output_modes.iter().any(|id| x.id == *id))
+            .map(|mode| {
+                VideoMode {
+                    size: (mode.width, mode.height),
+                    refresh_rate_millihertz: monitor::mode_refresh_rate_millihertz(mode)
+                        .unwrap_or(0),
+                    bit_depth: bit_depth as u16,
+                    native_mode: mode.id,
+                    // This is populated in `MonitorHandle::video_modes` as the
+                    // video mode is returned to the user
+                    monitor: None,
+                }
+            })
+            .collect();
+
+        let name_slice = slice::from_raw_parts(
+            (*output_info).name as *mut u8,
+            (*output_info).nameLen as usize,
+        );
+        let name = String::from_utf8_lossy(name_slice).into();
+        // Override DPI if `WINIT_X11_SCALE_FACTOR` variable is set
+        let deprecated_dpi_override = env::var("WINIT_HIDPI_FACTOR").ok();
+        if deprecated_dpi_override.is_some() {
+            warn!(
+	            "The WINIT_HIDPI_FACTOR environment variable is deprecated; use WINIT_X11_SCALE_FACTOR"
+	        )
+        }
+        let dpi_env = env::var("WINIT_X11_SCALE_FACTOR").ok().map_or_else(
+            || EnvVarDPI::NotSet,
+            |var| {
+                if var.to_lowercase() == "randr" {
+                    EnvVarDPI::Randr
+                } else if let Ok(dpi) = f64::from_str(&var) {
+                    EnvVarDPI::Scale(dpi)
+                } else if var.is_empty() {
+                    EnvVarDPI::NotSet
+                } else {
+                    panic!(
+                        "`WINIT_X11_SCALE_FACTOR` invalid; DPI factors must be either normal floats greater than 0, or `randr`. Got `{var}`"
+                    );
+                }
+            },
+        );
+
+        let scale_factor = match dpi_env {
+            EnvVarDPI::Randr => calc_dpi_factor(
+                ((*crtc).width, (*crtc).height),
+                ((*output_info).mm_width as _, (*output_info).mm_height as _),
+            ),
+            EnvVarDPI::Scale(dpi_override) => {
+                if !validate_scale_factor(dpi_override) {
+                    panic!(
+                        "`WINIT_X11_SCALE_FACTOR` invalid; DPI factors must be either normal floats greater than 0, or `randr`. Got `{dpi_override}`",
+                    );
+                }
+                dpi_override
+            }
+            EnvVarDPI::NotSet => {
+                if let Some(dpi) = self.get_xft_dpi() {
+                    dpi / 96.
+                } else {
+                    calc_dpi_factor(
+                        ((*crtc).width, (*crtc).height),
+                        ((*output_info).mm_width as _, (*output_info).mm_height as _),
+                    )
+                }
+            }
+        };
+
+        (self.xrandr.XRRFreeOutputInfo)(output_info);
+        Some((name, scale_factor, modes))
+    }
+
+    #[must_use]
+    pub fn set_crtc_config(&self, crtc_id: RRCrtc, mode_id: RRMode) -> Option<()> {
+        unsafe {
+            let mut major = 0;
+            let mut minor = 0;
+            (self.xrandr.XRRQueryVersion)(self.display, &mut major, &mut minor);
+
+            let root = (self.xlib.XDefaultRootWindow)(self.display);
+            let resources = if (major == 1 && minor >= 3) || major > 1 {
+                (self.xrandr.XRRGetScreenResourcesCurrent)(self.display, root)
+            } else {
+                (self.xrandr.XRRGetScreenResources)(self.display, root)
+            };
+
+            let crtc = (self.xrandr.XRRGetCrtcInfo)(self.display, resources, crtc_id);
+            let status = (self.xrandr.XRRSetCrtcConfig)(
+                self.display,
+                resources,
+                crtc_id,
+                CurrentTime,
+                (*crtc).x,
+                (*crtc).y,
+                mode_id,
+                (*crtc).rotation,
+                (*crtc).outputs.offset(0),
+                1,
+            );
+
+            (self.xrandr.XRRFreeCrtcInfo)(crtc);
+            (self.xrandr.XRRFreeScreenResources)(resources);
+
+            if status == Success as i32 {
+                Some(())
+            } else {
+                None
+            }
+        }
+    }
+
+    pub fn get_crtc_mode(&self, crtc_id: RRCrtc) -> RRMode {
+        unsafe {
+            let mut major = 0;
+            let mut minor = 0;
+            (self.xrandr.XRRQueryVersion)(self.display, &mut major, &mut minor);
+
+            let root = (self.xlib.XDefaultRootWindow)(self.display);
+            let resources = if (major == 1 && minor >= 3) || major > 1 {
+                (self.xrandr.XRRGetScreenResourcesCurrent)(self.display, root)
+            } else {
+                (self.xrandr.XRRGetScreenResources)(self.display, root)
+            };
+
+            let crtc = (self.xrandr.XRRGetCrtcInfo)(self.display, resources, crtc_id);
+            let mode = (*crtc).mode;
+            (self.xrandr.XRRFreeCrtcInfo)(crtc);
+            (self.xrandr.XRRFreeScreenResources)(resources);
+            mode
+        }
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/util/window_property.rs

@@ -0,0 +1,142 @@
+use super::*;
+
+pub type Cardinal = c_long;
+pub const CARDINAL_SIZE: usize = mem::size_of::<c_long>();
+
+#[derive(Debug, Clone)]
+pub enum GetPropertyError {
+    XError(XError),
+    TypeMismatch(ffi::Atom),
+    FormatMismatch(c_int),
+    NothingAllocated,
+}
+
+impl GetPropertyError {
+    pub fn is_actual_property_type(&self, t: ffi::Atom) -> bool {
+        if let GetPropertyError::TypeMismatch(actual_type) = *self {
+            actual_type == t
+        } else {
+            false
+        }
+    }
+}
+
+// Number of 32-bit chunks to retrieve per iteration of get_property's inner loop.
+// To test if `get_property` works correctly, set this to 1.
+const PROPERTY_BUFFER_SIZE: c_long = 1024; // 4k of RAM ought to be enough for anyone!
+
+#[derive(Debug)]
+#[allow(dead_code)]
+pub enum PropMode {
+    Replace = ffi::PropModeReplace as isize,
+    Prepend = ffi::PropModePrepend as isize,
+    Append = ffi::PropModeAppend as isize,
+}
+
+impl XConnection {
+    pub fn get_property<T: Formattable>(
+        &self,
+        window: c_ulong,
+        property: ffi::Atom,
+        property_type: ffi::Atom,
+    ) -> Result<Vec<T>, GetPropertyError> {
+        let mut data = Vec::new();
+        let mut offset = 0;
+
+        let mut done = false;
+        let mut actual_type = 0;
+        let mut actual_format = 0;
+        let mut quantity_returned = 0;
+        let mut bytes_after = 0;
+        let mut buf: *mut c_uchar = ptr::null_mut();
+
+        while !done {
+            unsafe {
+                (self.xlib.XGetWindowProperty)(
+                    self.display,
+                    window,
+                    property,
+                    // This offset is in terms of 32-bit chunks.
+                    offset,
+                    // This is the quantity of 32-bit chunks to receive at once.
+                    PROPERTY_BUFFER_SIZE,
+                    ffi::False,
+                    property_type,
+                    &mut actual_type,
+                    &mut actual_format,
+                    // This is the quantity of items we retrieved in our format, NOT of 32-bit chunks!
+                    &mut quantity_returned,
+                    // ...and this is a quantity of bytes. So, this function deals in 3 different units.
+                    &mut bytes_after,
+                    &mut buf,
+                );
+
+                if let Err(e) = self.check_errors() {
+                    return Err(GetPropertyError::XError(e));
+                }
+
+                if actual_type != property_type {
+                    return Err(GetPropertyError::TypeMismatch(actual_type));
+                }
+
+                let format_mismatch = Format::from_format(actual_format as _) != Some(T::FORMAT);
+                if format_mismatch {
+                    return Err(GetPropertyError::FormatMismatch(actual_format));
+                }
+
+                if !buf.is_null() {
+                    offset += PROPERTY_BUFFER_SIZE;
+                    let new_data =
+                        std::slice::from_raw_parts(buf as *mut T, quantity_returned as usize);
+                    /*println!(
+                        "XGetWindowProperty prop:{:?} fmt:{:02} len:{:02} off:{:02} out:{:02}, buf:{:?}",
+                        property,
+                        mem::size_of::<T>() * 8,
+                        data.len(),
+                        offset,
+                        quantity_returned,
+                        new_data,
+                    );*/
+                    data.extend_from_slice(new_data);
+                    // Fun fact: XGetWindowProperty allocates one extra byte at the end.
+                    (self.xlib.XFree)(buf as _); // Don't try to access new_data after this.
+                } else {
+                    return Err(GetPropertyError::NothingAllocated);
+                }
+
+                done = bytes_after == 0;
+            }
+        }
+
+        Ok(data)
+    }
+
+    pub fn change_property<'a, T: Formattable>(
+        &'a self,
+        window: c_ulong,
+        property: ffi::Atom,
+        property_type: ffi::Atom,
+        mode: PropMode,
+        new_value: &[T],
+    ) -> Flusher<'a> {
+        debug_assert_eq!(mem::size_of::<T>(), T::FORMAT.get_actual_size());
+        unsafe {
+            (self.xlib.XChangeProperty)(
+                self.display,
+                window,
+                property,
+                property_type,
+                T::FORMAT as c_int,
+                mode as c_int,
+                new_value.as_ptr() as *const c_uchar,
+                new_value.len() as c_int,
+            );
+        }
+        /*println!(
+            "XChangeProperty prop:{:?} val:{:?}",
+            property,
+            new_value,
+        );*/
+        Flusher::new(self)
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/util/wm.rs

@@ -0,0 +1,123 @@
+use std::sync::Mutex;
+
+use once_cell::sync::Lazy;
+
+use super::*;
+
+// https://specifications.freedesktop.org/wm-spec/latest/ar01s04.html#idm46075117309248
+pub const MOVERESIZE_TOPLEFT: isize = 0;
+pub const MOVERESIZE_TOP: isize = 1;
+pub const MOVERESIZE_TOPRIGHT: isize = 2;
+pub const MOVERESIZE_RIGHT: isize = 3;
+pub const MOVERESIZE_BOTTOMRIGHT: isize = 4;
+pub const MOVERESIZE_BOTTOM: isize = 5;
+pub const MOVERESIZE_BOTTOMLEFT: isize = 6;
+pub const MOVERESIZE_LEFT: isize = 7;
+pub const MOVERESIZE_MOVE: isize = 8;
+
+// This info is global to the window manager.
+static SUPPORTED_HINTS: Lazy<Mutex<Vec<ffi::Atom>>> =
+    Lazy::new(|| Mutex::new(Vec::with_capacity(0)));
+static WM_NAME: Lazy<Mutex<Option<String>>> = Lazy::new(|| Mutex::new(None));
+
+pub fn hint_is_supported(hint: ffi::Atom) -> bool {
+    (*SUPPORTED_HINTS.lock().unwrap()).contains(&hint)
+}
+
+pub fn wm_name_is_one_of(names: &[&str]) -> bool {
+    if let Some(ref name) = *WM_NAME.lock().unwrap() {
+        names.contains(&name.as_str())
+    } else {
+        false
+    }
+}
+
+impl XConnection {
+    pub fn update_cached_wm_info(&self, root: ffi::Window) {
+        *SUPPORTED_HINTS.lock().unwrap() = self.get_supported_hints(root);
+        *WM_NAME.lock().unwrap() = self.get_wm_name(root);
+    }
+
+    fn get_supported_hints(&self, root: ffi::Window) -> Vec<ffi::Atom> {
+        let supported_atom = unsafe { self.get_atom_unchecked(b"_NET_SUPPORTED\0") };
+        self.get_property(root, supported_atom, ffi::XA_ATOM)
+            .unwrap_or_else(|_| Vec::with_capacity(0))
+    }
+
+    fn get_wm_name(&self, root: ffi::Window) -> Option<String> {
+        let check_atom = unsafe { self.get_atom_unchecked(b"_NET_SUPPORTING_WM_CHECK\0") };
+        let wm_name_atom = unsafe { self.get_atom_unchecked(b"_NET_WM_NAME\0") };
+
+        // Mutter/Muffin/Budgie doesn't have _NET_SUPPORTING_WM_CHECK in its _NET_SUPPORTED, despite
+        // it working and being supported. This has been reported upstream, but due to the
+        // inavailability of time machines, we'll just try to get _NET_SUPPORTING_WM_CHECK
+        // regardless of whether or not the WM claims to support it.
+        //
+        // Blackbox 0.70 also incorrectly reports not supporting this, though that appears to be fixed
+        // in 0.72.
+        /*if !supported_hints.contains(&check_atom) {
+            return None;
+        }*/
+
+        // IceWM (1.3.x and earlier) doesn't report supporting _NET_WM_NAME, but will nonetheless
+        // provide us with a value for it. Note that the unofficial 1.4 fork of IceWM works fine.
+        /*if !supported_hints.contains(&wm_name_atom) {
+            return None;
+        }*/
+
+        // Of the WMs tested, only xmonad and dwm fail to provide a WM name.
+
+        // Querying this property on the root window will give us the ID of a child window created by
+        // the WM.
+        let root_window_wm_check = {
+            let result = self.get_property(root, check_atom, ffi::XA_WINDOW);
+
+            let wm_check = result.ok().and_then(|wm_check| wm_check.first().cloned());
+
+            wm_check?
+        };
+
+        // Querying the same property on the child window we were given, we should get this child
+        // window's ID again.
+        let child_window_wm_check = {
+            let result = self.get_property(root_window_wm_check, check_atom, ffi::XA_WINDOW);
+
+            let wm_check = result.ok().and_then(|wm_check| wm_check.first().cloned());
+
+            wm_check?
+        };
+
+        // These values should be the same.
+        if root_window_wm_check != child_window_wm_check {
+            return None;
+        }
+
+        // All of that work gives us a window ID that we can get the WM name from.
+        let wm_name = {
+            let utf8_string_atom = unsafe { self.get_atom_unchecked(b"UTF8_STRING\0") };
+
+            let result = self.get_property(root_window_wm_check, wm_name_atom, utf8_string_atom);
+
+            // IceWM requires this. IceWM was also the only WM tested that returns a null-terminated
+            // string. For more fun trivia, IceWM is also unique in including version and uname
+            // information in this string (this means you'll have to be careful if you want to match
+            // against it, though).
+            // The unofficial 1.4 fork of IceWM still includes the extra details, but properly
+            // returns a UTF8 string that isn't null-terminated.
+            let no_utf8 = if let Err(ref err) = result {
+                err.is_actual_property_type(ffi::XA_STRING)
+            } else {
+                false
+            };
+
+            if no_utf8 {
+                self.get_property(root_window_wm_check, wm_name_atom, ffi::XA_STRING)
+            } else {
+                result
+            }
+        }
+        .ok();
+
+        wm_name.and_then(|wm_name| String::from_utf8(wm_name).ok())
+    }
+}

third-party/vendor/winit/src/platform_impl/linux/x11/xdisplay.rs

@@ -0,0 +1,149 @@
+use std::{collections::HashMap, error::Error, fmt, os::raw::c_int, ptr, sync::Mutex};
+
+use crate::window::CursorIcon;
+
+use super::ffi;
+
+/// A connection to an X server.
+pub(crate) struct XConnection {
+    pub xlib: ffi::Xlib,
+    /// Exposes XRandR functions from version < 1.5
+    pub xrandr: ffi::Xrandr_2_2_0,
+    pub xcursor: ffi::Xcursor,
+    pub xinput2: ffi::XInput2,
+    pub xlib_xcb: ffi::Xlib_xcb,
+    pub display: *mut ffi::Display,
+    pub x11_fd: c_int,
+    pub latest_error: Mutex<Option<XError>>,
+    pub cursor_cache: Mutex<HashMap<Option<CursorIcon>, ffi::Cursor>>,
+}
+
+unsafe impl Send for XConnection {}
+unsafe impl Sync for XConnection {}
+
+pub type XErrorHandler =
+    Option<unsafe extern "C" fn(*mut ffi::Display, *mut ffi::XErrorEvent) -> libc::c_int>;
+
+impl XConnection {
+    pub fn new(error_handler: XErrorHandler) -> Result<XConnection, XNotSupported> {
+        // opening the libraries
+        let xlib = ffi::Xlib::open()?;
+        let xcursor = ffi::Xcursor::open()?;
+        let xrandr = ffi::Xrandr_2_2_0::open()?;
+        let xinput2 = ffi::XInput2::open()?;
+        let xlib_xcb = ffi::Xlib_xcb::open()?;
+
+        unsafe { (xlib.XInitThreads)() };
+        unsafe { (xlib.XSetErrorHandler)(error_handler) };
+
+        // calling XOpenDisplay
+        let display = unsafe {
+            let display = (xlib.XOpenDisplay)(ptr::null());
+            if display.is_null() {
+                return Err(XNotSupported::XOpenDisplayFailed);
+            }
+            display
+        };
+
+        // Get X11 socket file descriptor
+        let fd = unsafe { (xlib.XConnectionNumber)(display) };
+
+        Ok(XConnection {
+            xlib,
+            xrandr,
+            xcursor,
+            xinput2,
+            xlib_xcb,
+            display,
+            x11_fd: fd,
+            latest_error: Mutex::new(None),
+            cursor_cache: Default::default(),
+        })
+    }
+
+    /// Checks whether an error has been triggered by the previous function calls.
+    #[inline]
+    pub fn check_errors(&self) -> Result<(), XError> {
+        let error = self.latest_error.lock().unwrap().take();
+        if let Some(error) = error {
+            Err(error)
+        } else {
+            Ok(())
+        }
+    }
+}
+
+impl fmt::Debug for XConnection {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.display.fmt(f)
+    }
+}
+
+impl Drop for XConnection {
+    #[inline]
+    fn drop(&mut self) {
+        unsafe { (self.xlib.XCloseDisplay)(self.display) };
+    }
+}
+
+/// Error triggered by xlib.
+#[derive(Debug, Clone)]
+pub struct XError {
+    pub description: String,
+    pub error_code: u8,
+    pub request_code: u8,
+    pub minor_code: u8,
+}
+
+impl Error for XError {}
+
+impl fmt::Display for XError {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        write!(
+            formatter,
+            "X error: {} (code: {}, request code: {}, minor code: {})",
+            self.description, self.error_code, self.request_code, self.minor_code
+        )
+    }
+}
+
+/// Error returned if this system doesn't have XLib or can't create an X connection.
+#[derive(Clone, Debug)]
+pub enum XNotSupported {
+    /// Failed to load one or several shared libraries.
+    LibraryOpenError(ffi::OpenError),
+    /// Connecting to the X server with `XOpenDisplay` failed.
+    XOpenDisplayFailed, // TODO: add better message
+}
+
+impl From<ffi::OpenError> for XNotSupported {
+    #[inline]
+    fn from(err: ffi::OpenError) -> XNotSupported {
+        XNotSupported::LibraryOpenError(err)
+    }
+}
+
+impl XNotSupported {
+    fn description(&self) -> &'static str {
+        match self {
+            XNotSupported::LibraryOpenError(_) => "Failed to load one of xlib's shared libraries",
+            XNotSupported::XOpenDisplayFailed => "Failed to open connection to X server",
+        }
+    }
+}
+
+impl Error for XNotSupported {
+    #[inline]
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match *self {
+            XNotSupported::LibraryOpenError(ref err) => Some(err),
+            _ => None,
+        }
+    }
+}
+
+impl fmt::Display for XNotSupported {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        formatter.write_str(self.description())
+    }
+}

third-party/vendor/winit/src/platform_impl/macos/app.rs

@@ -0,0 +1,98 @@
+#![allow(clippy::unnecessary_cast)]
+
+use objc2::foundation::NSObject;
+use objc2::{declare_class, msg_send, ClassType};
+
+use super::appkit::{NSApplication, NSEvent, NSEventModifierFlags, NSEventType, NSResponder};
+use super::{app_state::AppState, event::EventWrapper, DEVICE_ID};
+use crate::event::{DeviceEvent, ElementState, Event};
+
+declare_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(super) struct WinitApplication {}
+
+    unsafe impl ClassType for WinitApplication {
+        #[inherits(NSResponder, NSObject)]
+        type Super = NSApplication;
+    }
+
+    unsafe impl WinitApplication {
+        // Normally, holding Cmd + any key never sends us a `keyUp` event for that key.
+        // Overriding `sendEvent:` like this fixes that. (https://stackoverflow.com/a/15294196)
+        // Fun fact: Firefox still has this bug! (https://bugzilla.mozilla.org/show_bug.cgi?id=1299553)
+        #[sel(sendEvent:)]
+        fn send_event(&self, event: &NSEvent) {
+            // For posterity, there are some undocumented event types
+            // (https://github.com/servo/cocoa-rs/issues/155)
+            // but that doesn't really matter here.
+            let event_type = event.type_();
+            let modifier_flags = event.modifierFlags();
+            if event_type == NSEventType::NSKeyUp
+                && modifier_flags.contains(NSEventModifierFlags::NSCommandKeyMask)
+            {
+                if let Some(key_window) = self.keyWindow() {
+                    unsafe { key_window.sendEvent(event) };
+                }
+            } else {
+                maybe_dispatch_device_event(event);
+                unsafe { msg_send![super(self), sendEvent: event] }
+            }
+        }
+    }
+);
+
+fn maybe_dispatch_device_event(event: &NSEvent) {
+    let event_type = event.type_();
+    match event_type {
+        NSEventType::NSMouseMoved
+        | NSEventType::NSLeftMouseDragged
+        | NSEventType::NSOtherMouseDragged
+        | NSEventType::NSRightMouseDragged => {
+            let delta_x = event.deltaX() as f64;
+            let delta_y = event.deltaY() as f64;
+
+            if delta_x != 0.0 {
+                queue_device_event(DeviceEvent::Motion {
+                    axis: 0,
+                    value: delta_x,
+                });
+            }
+
+            if delta_y != 0.0 {
+                queue_device_event(DeviceEvent::Motion {
+                    axis: 1,
+                    value: delta_y,
+                })
+            }
+
+            if delta_x != 0.0 || delta_y != 0.0 {
+                queue_device_event(DeviceEvent::MouseMotion {
+                    delta: (delta_x, delta_y),
+                });
+            }
+        }
+        NSEventType::NSLeftMouseDown
+        | NSEventType::NSRightMouseDown
+        | NSEventType::NSOtherMouseDown => {
+            queue_device_event(DeviceEvent::Button {
+                button: event.buttonNumber() as u32,
+                state: ElementState::Pressed,
+            });
+        }
+        NSEventType::NSLeftMouseUp | NSEventType::NSRightMouseUp | NSEventType::NSOtherMouseUp => {
+            queue_device_event(DeviceEvent::Button {
+                button: event.buttonNumber() as u32,
+                state: ElementState::Released,
+            });
+        }
+        _ => (),
+    }
+}
+
+fn queue_device_event(event: DeviceEvent) {
+    let event = Event::DeviceEvent {
+        device_id: DEVICE_ID,
+        event,
+    };
+    AppState::queue_event(EventWrapper::StaticEvent(event));
+}

third-party/vendor/winit/src/platform_impl/macos/app_delegate.rs

@@ -0,0 +1,73 @@
+use objc2::foundation::NSObject;
+use objc2::rc::{Id, Shared};
+use objc2::runtime::Object;
+use objc2::{declare_class, msg_send, msg_send_id, ClassType};
+
+use super::app_state::AppState;
+use super::appkit::NSApplicationActivationPolicy;
+
+declare_class!(
+    #[derive(Debug)]
+    pub(super) struct ApplicationDelegate {
+        activation_policy: NSApplicationActivationPolicy,
+        default_menu: bool,
+        activate_ignoring_other_apps: bool,
+    }
+
+    unsafe impl ClassType for ApplicationDelegate {
+        type Super = NSObject;
+        const NAME: &'static str = "WinitApplicationDelegate";
+    }
+
+    unsafe impl ApplicationDelegate {
+        #[sel(initWithActivationPolicy:defaultMenu:activateIgnoringOtherApps:)]
+        fn init(
+            &mut self,
+            activation_policy: NSApplicationActivationPolicy,
+            default_menu: bool,
+            activate_ignoring_other_apps: bool,
+        ) -> Option<&mut Self> {
+            let this: Option<&mut Self> = unsafe { msg_send![super(self), init] };
+            this.map(|this| {
+                *this.activation_policy = activation_policy;
+                *this.default_menu = default_menu;
+                *this.activate_ignoring_other_apps = activate_ignoring_other_apps;
+                this
+            })
+        }
+
+        #[sel(applicationDidFinishLaunching:)]
+        fn did_finish_launching(&self, _sender: *const Object) {
+            trace_scope!("applicationDidFinishLaunching:");
+            AppState::launched(
+                *self.activation_policy,
+                *self.default_menu,
+                *self.activate_ignoring_other_apps,
+            );
+        }
+
+        #[sel(applicationWillTerminate:)]
+        fn will_terminate(&self, _sender: *const Object) {
+            trace_scope!("applicationWillTerminate:");
+            // TODO: Notify every window that it will be destroyed, like done in iOS?
+            AppState::exit();
+        }
+    }
+);
+
+impl ApplicationDelegate {
+    pub(super) fn new(
+        activation_policy: NSApplicationActivationPolicy,
+        default_menu: bool,
+        activate_ignoring_other_apps: bool,
+    ) -> Id<Self, Shared> {
+        unsafe {
+            msg_send_id![
+                msg_send_id![Self::class(), alloc],
+                initWithActivationPolicy: activation_policy,
+                defaultMenu: default_menu,
+                activateIgnoringOtherApps: activate_ignoring_other_apps,
+            ]
+        }
+    }
+}

third-party/vendor/winit/src/platform_impl/macos/app_state.rs

@@ -0,0 +1,434 @@
+use std::{
+    cell::{RefCell, RefMut},
+    collections::VecDeque,
+    fmt::{self, Debug},
+    mem,
+    rc::{Rc, Weak},
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Mutex, MutexGuard,
+    },
+    time::Instant,
+};
+
+use core_foundation::runloop::{CFRunLoopGetMain, CFRunLoopWakeUp};
+use objc2::foundation::{is_main_thread, NSSize};
+use objc2::rc::autoreleasepool;
+use once_cell::sync::Lazy;
+
+use super::appkit::{NSApp, NSApplication, NSApplicationActivationPolicy, NSEvent};
+use crate::{
+    dpi::LogicalSize,
+    event::{Event, StartCause, WindowEvent},
+    event_loop::{ControlFlow, EventLoopWindowTarget as RootWindowTarget},
+    platform_impl::platform::{
+        event::{EventProxy, EventWrapper},
+        event_loop::PanicInfo,
+        menu,
+        observer::EventLoopWaker,
+        util::Never,
+        window::WinitWindow,
+    },
+    window::WindowId,
+};
+
+static HANDLER: Lazy<Handler> = Lazy::new(Default::default);
+
+impl<'a, Never> Event<'a, Never> {
+    fn userify<T: 'static>(self) -> Event<'a, T> {
+        self.map_nonuser_event()
+            // `Never` can't be constructed, so the `UserEvent` variant can't
+            // be present here.
+            .unwrap_or_else(|_| unreachable!())
+    }
+}
+
+pub trait EventHandler: Debug {
+    // Not sure probably it should accept Event<'static, Never>
+    fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow);
+    fn handle_user_events(&mut self, control_flow: &mut ControlFlow);
+}
+
+pub(crate) type Callback<T> =
+    RefCell<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>;
+
+struct EventLoopHandler<T: 'static> {
+    callback: Weak<Callback<T>>,
+    window_target: Rc<RootWindowTarget<T>>,
+}
+
+impl<T> EventLoopHandler<T> {
+    fn with_callback<F>(&mut self, f: F)
+    where
+        F: FnOnce(
+            &mut EventLoopHandler<T>,
+            RefMut<'_, dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>,
+        ),
+    {
+        if let Some(callback) = self.callback.upgrade() {
+            let callback = callback.borrow_mut();
+            (f)(self, callback);
+        } else {
+            panic!(
+                "Tried to dispatch an event, but the event loop that \
+                owned the event handler callback seems to be destroyed"
+            );
+        }
+    }
+}
+
+impl<T> Debug for EventLoopHandler<T> {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter
+            .debug_struct("EventLoopHandler")
+            .field("window_target", &self.window_target)
+            .finish()
+    }
+}
+
+impl<T> EventHandler for EventLoopHandler<T> {
+    fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow) {
+        self.with_callback(|this, mut callback| {
+            if let ControlFlow::ExitWithCode(code) = *control_flow {
+                let dummy = &mut ControlFlow::ExitWithCode(code);
+                (callback)(event.userify(), &this.window_target, dummy);
+            } else {
+                (callback)(event.userify(), &this.window_target, control_flow);
+            }
+        });
+    }
+
+    fn handle_user_events(&mut self, control_flow: &mut ControlFlow) {
+        self.with_callback(|this, mut callback| {
+            for event in this.window_target.p.receiver.try_iter() {
+                if let ControlFlow::ExitWithCode(code) = *control_flow {
+                    let dummy = &mut ControlFlow::ExitWithCode(code);
+                    (callback)(Event::UserEvent(event), &this.window_target, dummy);
+                } else {
+                    (callback)(Event::UserEvent(event), &this.window_target, control_flow);
+                }
+            }
+        });
+    }
+}
+
+#[derive(Default)]
+struct Handler {
+    ready: AtomicBool,
+    in_callback: AtomicBool,
+    control_flow: Mutex<ControlFlow>,
+    control_flow_prev: Mutex<ControlFlow>,
+    start_time: Mutex<Option<Instant>>,
+    callback: Mutex<Option<Box<dyn EventHandler>>>,
+    pending_events: Mutex<VecDeque<EventWrapper>>,
+    pending_redraw: Mutex<Vec<WindowId>>,
+    waker: Mutex<EventLoopWaker>,
+}
+
+unsafe impl Send for Handler {}
+unsafe impl Sync for Handler {}
+
+impl Handler {
+    fn events(&self) -> MutexGuard<'_, VecDeque<EventWrapper>> {
+        self.pending_events.lock().unwrap()
+    }
+
+    fn redraw(&self) -> MutexGuard<'_, Vec<WindowId>> {
+        self.pending_redraw.lock().unwrap()
+    }
+
+    fn waker(&self) -> MutexGuard<'_, EventLoopWaker> {
+        self.waker.lock().unwrap()
+    }
+
+    fn is_ready(&self) -> bool {
+        self.ready.load(Ordering::Acquire)
+    }
+
+    fn set_ready(&self) {
+        self.ready.store(true, Ordering::Release);
+    }
+
+    fn should_exit(&self) -> bool {
+        matches!(
+            *self.control_flow.lock().unwrap(),
+            ControlFlow::ExitWithCode(_)
+        )
+    }
+
+    fn get_control_flow_and_update_prev(&self) -> ControlFlow {
+        let control_flow = self.control_flow.lock().unwrap();
+        *self.control_flow_prev.lock().unwrap() = *control_flow;
+        *control_flow
+    }
+
+    fn get_old_and_new_control_flow(&self) -> (ControlFlow, ControlFlow) {
+        let old = *self.control_flow_prev.lock().unwrap();
+        let new = *self.control_flow.lock().unwrap();
+        (old, new)
+    }
+
+    fn get_start_time(&self) -> Option<Instant> {
+        *self.start_time.lock().unwrap()
+    }
+
+    fn update_start_time(&self) {
+        *self.start_time.lock().unwrap() = Some(Instant::now());
+    }
+
+    fn take_events(&self) -> VecDeque<EventWrapper> {
+        mem::take(&mut *self.events())
+    }
+
+    fn should_redraw(&self) -> Vec<WindowId> {
+        mem::take(&mut *self.redraw())
+    }
+
+    fn get_in_callback(&self) -> bool {
+        self.in_callback.load(Ordering::Acquire)
+    }
+
+    fn set_in_callback(&self, in_callback: bool) {
+        self.in_callback.store(in_callback, Ordering::Release);
+    }
+
+    fn handle_nonuser_event(&self, wrapper: EventWrapper) {
+        if let Some(ref mut callback) = *self.callback.lock().unwrap() {
+            match wrapper {
+                EventWrapper::StaticEvent(event) => {
+                    callback.handle_nonuser_event(event, &mut self.control_flow.lock().unwrap())
+                }
+                EventWrapper::EventProxy(proxy) => self.handle_proxy(proxy, callback),
+            }
+        }
+    }
+
+    fn handle_user_events(&self) {
+        if let Some(ref mut callback) = *self.callback.lock().unwrap() {
+            callback.handle_user_events(&mut self.control_flow.lock().unwrap());
+        }
+    }
+
+    fn handle_scale_factor_changed_event(
+        &self,
+        callback: &mut Box<dyn EventHandler + 'static>,
+        window: &WinitWindow,
+        suggested_size: LogicalSize<f64>,
+        scale_factor: f64,
+    ) {
+        let mut size = suggested_size.to_physical(scale_factor);
+        let new_inner_size = &mut size;
+        let event = Event::WindowEvent {
+            window_id: WindowId(window.id()),
+            event: WindowEvent::ScaleFactorChanged {
+                scale_factor,
+                new_inner_size,
+            },
+        };
+
+        callback.handle_nonuser_event(event, &mut self.control_flow.lock().unwrap());
+
+        let physical_size = *new_inner_size;
+        let logical_size = physical_size.to_logical(scale_factor);
+        let size = NSSize::new(logical_size.width, logical_size.height);
+        window.setContentSize(size);
+    }
+
+    fn handle_proxy(&self, proxy: EventProxy, callback: &mut Box<dyn EventHandler + 'static>) {
+        match proxy {
+            EventProxy::DpiChangedProxy {
+                window,
+                suggested_size,
+                scale_factor,
+            } => self.handle_scale_factor_changed_event(
+                callback,
+                &window,
+                suggested_size,
+                scale_factor,
+            ),
+        }
+    }
+}
+
+pub(crate) enum AppState {}
+
+impl AppState {
+    pub fn set_callback<T>(callback: Weak<Callback<T>>, window_target: Rc<RootWindowTarget<T>>) {
+        *HANDLER.callback.lock().unwrap() = Some(Box::new(EventLoopHandler {
+            callback,
+            window_target,
+        }));
+    }
+
+    pub fn exit() -> i32 {
+        HANDLER.set_in_callback(true);
+        HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::LoopDestroyed));
+        HANDLER.set_in_callback(false);
+        HANDLER.callback.lock().unwrap().take();
+        if let ControlFlow::ExitWithCode(code) = HANDLER.get_old_and_new_control_flow().1 {
+            code
+        } else {
+            0
+        }
+    }
+
+    pub fn launched(
+        activation_policy: NSApplicationActivationPolicy,
+        create_default_menu: bool,
+        activate_ignoring_other_apps: bool,
+    ) {
+        let app = NSApp();
+        // We need to delay setting the activation policy and activating the app
+        // until `applicationDidFinishLaunching` has been called. Otherwise the
+        // menu bar is initially unresponsive on macOS 10.15.
+        app.setActivationPolicy(activation_policy);
+
+        window_activation_hack(&app);
+        app.activateIgnoringOtherApps(activate_ignoring_other_apps);
+
+        HANDLER.set_ready();
+        HANDLER.waker().start();
+        if create_default_menu {
+            // The menubar initialization should be before the `NewEvents` event, to allow
+            // overriding of the default menu even if it's created
+            menu::initialize();
+        }
+        HANDLER.set_in_callback(true);
+        HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::NewEvents(
+            StartCause::Init,
+        )));
+        // NB: For consistency all platforms must emit a 'resumed' event even though macOS
+        // applications don't themselves have a formal suspend/resume lifecycle.
+        HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::Resumed));
+        HANDLER.set_in_callback(false);
+    }
+
+    pub fn wakeup(panic_info: Weak<PanicInfo>) {
+        let panic_info = panic_info
+            .upgrade()
+            .expect("The panic info must exist here. This failure indicates a developer error.");
+
+        // Return when in callback due to https://github.com/rust-windowing/winit/issues/1779
+        if panic_info.is_panicking() || !HANDLER.is_ready() || HANDLER.get_in_callback() {
+            return;
+        }
+        let start = HANDLER.get_start_time().unwrap();
+        let cause = match HANDLER.get_control_flow_and_update_prev() {
+            ControlFlow::Poll => StartCause::Poll,
+            ControlFlow::Wait => StartCause::WaitCancelled {
+                start,
+                requested_resume: None,
+            },
+            ControlFlow::WaitUntil(requested_resume) => {
+                if Instant::now() >= requested_resume {
+                    StartCause::ResumeTimeReached {
+                        start,
+                        requested_resume,
+                    }
+                } else {
+                    StartCause::WaitCancelled {
+                        start,
+                        requested_resume: Some(requested_resume),
+                    }
+                }
+            }
+            ControlFlow::ExitWithCode(_) => StartCause::Poll, //panic!("unexpected `ControlFlow::Exit`"),
+        };
+        HANDLER.set_in_callback(true);
+        HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::NewEvents(cause)));
+        HANDLER.set_in_callback(false);
+    }
+
+    // This is called from multiple threads at present
+    pub fn queue_redraw(window_id: WindowId) {
+        let mut pending_redraw = HANDLER.redraw();
+        if !pending_redraw.contains(&window_id) {
+            pending_redraw.push(window_id);
+        }
+        unsafe {
+            let rl = CFRunLoopGetMain();
+            CFRunLoopWakeUp(rl);
+        }
+    }
+
+    pub fn handle_redraw(window_id: WindowId) {
+        // Redraw request might come out of order from the OS.
+        // -> Don't go back into the callback when our callstack originates from there
+        if !HANDLER.in_callback.swap(true, Ordering::AcqRel) {
+            HANDLER
+                .handle_nonuser_event(EventWrapper::StaticEvent(Event::RedrawRequested(window_id)));
+            HANDLER.set_in_callback(false);
+        }
+    }
+
+    pub fn queue_event(wrapper: EventWrapper) {
+        if !is_main_thread() {
+            panic!("Event queued from different thread: {wrapper:#?}");
+        }
+        HANDLER.events().push_back(wrapper);
+    }
+
+    pub fn cleared(panic_info: Weak<PanicInfo>) {
+        let panic_info = panic_info
+            .upgrade()
+            .expect("The panic info must exist here. This failure indicates a developer error.");
+
+        // Return when in callback due to https://github.com/rust-windowing/winit/issues/1779
+        if panic_info.is_panicking() || !HANDLER.is_ready() || HANDLER.get_in_callback() {
+            return;
+        }
+
+        HANDLER.set_in_callback(true);
+        HANDLER.handle_user_events();
+        for event in HANDLER.take_events() {
+            HANDLER.handle_nonuser_event(event);
+        }
+        HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::MainEventsCleared));
+        for window_id in HANDLER.should_redraw() {
+            HANDLER
+                .handle_nonuser_event(EventWrapper::StaticEvent(Event::RedrawRequested(window_id)));
+        }
+        HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::RedrawEventsCleared));
+        HANDLER.set_in_callback(false);
+
+        if HANDLER.should_exit() {
+            let app = NSApp();
+            autoreleasepool(|_| {
+                app.stop(None);
+                // To stop event loop immediately, we need to post some event here.
+                app.postEvent_atStart(&NSEvent::dummy(), true);
+            });
+        }
+        HANDLER.update_start_time();
+        match HANDLER.get_old_and_new_control_flow() {
+            (ControlFlow::ExitWithCode(_), _) | (_, ControlFlow::ExitWithCode(_)) => (),
+            (old, new) if old == new => (),
+            (_, ControlFlow::Wait) => HANDLER.waker().stop(),
+            (_, ControlFlow::WaitUntil(instant)) => HANDLER.waker().start_at(instant),
+            (_, ControlFlow::Poll) => HANDLER.waker().start(),
+        }
+    }
+}
+
+/// A hack to make activation of multiple windows work when creating them before
+/// `applicationDidFinishLaunching:` / `Event::Event::NewEvents(StartCause::Init)`.
+///
+/// Alternative to this would be the user calling `window.set_visible(true)` in
+/// `StartCause::Init`.
+///
+/// If this becomes too bothersome to maintain, it can probably be removed
+/// without too much damage.
+fn window_activation_hack(app: &NSApplication) {
+    // TODO: Proper ordering of the windows
+    app.windows().into_iter().for_each(|window| {
+        // Call `makeKeyAndOrderFront` if it was called on the window in `WinitWindow::new`
+        // This way we preserve the user's desired initial visiblity status
+        // TODO: Also filter on the type/"level" of the window, and maybe other things?
+        if window.isVisible() {
+            trace!("Activating visible window");
+            window.makeKeyAndOrderFront(None);
+        } else {
+            trace!("Skipping activating invisible window");
+        }
+    })
+}

third-party/vendor/winit/src/platform_impl/macos/appkit/appearance.rs

@@ -0,0 +1,29 @@
+use objc2::foundation::{NSArray, NSObject, NSString};
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct NSAppearance;
+
+    unsafe impl ClassType for NSAppearance {
+        type Super = NSObject;
+    }
+);
+
+type NSAppearanceName = NSString;
+
+extern_methods!(
+    unsafe impl NSAppearance {
+        pub fn appearanceNamed(name: &NSAppearanceName) -> Id<Self, Shared> {
+            unsafe { msg_send_id![Self::class(), appearanceNamed: name] }
+        }
+
+        pub fn bestMatchFromAppearancesWithNames(
+            &self,
+            appearances: &NSArray<NSAppearanceName>,
+        ) -> Id<NSAppearanceName, Shared> {
+            unsafe { msg_send_id![self, bestMatchFromAppearancesWithNames: appearances,] }
+        }
+    }
+);

third-party/vendor/winit/src/platform_impl/macos/appkit/application.rs

@@ -0,0 +1,142 @@
+use objc2::foundation::{MainThreadMarker, NSArray, NSInteger, NSObject, NSUInteger};
+use objc2::rc::{Id, Shared};
+use objc2::runtime::Object;
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
+use objc2::{Encode, Encoding};
+
+use super::{NSAppearance, NSEvent, NSMenu, NSResponder, NSWindow};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct NSApplication;
+
+    unsafe impl ClassType for NSApplication {
+        #[inherits(NSObject)]
+        type Super = NSResponder;
+    }
+);
+
+pub(crate) fn NSApp() -> Id<NSApplication, Shared> {
+    // TODO: Only allow access from main thread
+    NSApplication::shared(unsafe { MainThreadMarker::new_unchecked() })
+}
+
+extern_methods!(
+    unsafe impl NSApplication {
+        /// This can only be called on the main thread since it may initialize
+        /// the application and since it's parameters may be changed by the main
+        /// thread at any time (hence it is only safe to access on the main thread).
+        pub fn shared(_mtm: MainThreadMarker) -> Id<Self, Shared> {
+            let app: Option<_> = unsafe { msg_send_id![Self::class(), sharedApplication] };
+            // SAFETY: `sharedApplication` always initializes the app if it isn't already
+            unsafe { app.unwrap_unchecked() }
+        }
+
+        pub fn currentEvent(&self) -> Option<Id<NSEvent, Shared>> {
+            unsafe { msg_send_id![self, currentEvent] }
+        }
+
+        #[sel(postEvent:atStart:)]
+        pub fn postEvent_atStart(&self, event: &NSEvent, front_of_queue: bool);
+
+        #[sel(presentationOptions)]
+        pub fn presentationOptions(&self) -> NSApplicationPresentationOptions;
+
+        pub fn windows(&self) -> Id<NSArray<NSWindow, Shared>, Shared> {
+            unsafe { msg_send_id![self, windows] }
+        }
+
+        pub fn keyWindow(&self) -> Option<Id<NSWindow, Shared>> {
+            unsafe { msg_send_id![self, keyWindow] }
+        }
+
+        // TODO: NSApplicationDelegate
+        #[sel(setDelegate:)]
+        pub fn setDelegate(&self, delegate: &Object);
+
+        #[sel(setPresentationOptions:)]
+        pub fn setPresentationOptions(&self, options: NSApplicationPresentationOptions);
+
+        #[sel(hide:)]
+        pub fn hide(&self, sender: Option<&Object>);
+
+        #[sel(orderFrontCharacterPalette:)]
+        #[allow(dead_code)]
+        pub fn orderFrontCharacterPalette(&self, sender: Option<&Object>);
+
+        #[sel(hideOtherApplications:)]
+        pub fn hideOtherApplications(&self, sender: Option<&Object>);
+
+        #[sel(stop:)]
+        pub fn stop(&self, sender: Option<&Object>);
+
+        #[sel(activateIgnoringOtherApps:)]
+        pub fn activateIgnoringOtherApps(&self, ignore: bool);
+
+        #[sel(requestUserAttention:)]
+        pub fn requestUserAttention(&self, type_: NSRequestUserAttentionType) -> NSInteger;
+
+        #[sel(setActivationPolicy:)]
+        pub fn setActivationPolicy(&self, policy: NSApplicationActivationPolicy) -> bool;
+
+        #[sel(setMainMenu:)]
+        pub fn setMainMenu(&self, menu: &NSMenu);
+
+        pub fn effectiveAppearance(&self) -> Id<NSAppearance, Shared> {
+            unsafe { msg_send_id![self, effectiveAppearance] }
+        }
+
+        #[sel(setAppearance:)]
+        pub fn setAppearance(&self, appearance: Option<&NSAppearance>);
+
+        #[sel(run)]
+        pub unsafe fn run(&self);
+    }
+);
+
+#[allow(dead_code)]
+#[repr(isize)] // NSInteger
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum NSApplicationActivationPolicy {
+    NSApplicationActivationPolicyRegular = 0,
+    NSApplicationActivationPolicyAccessory = 1,
+    NSApplicationActivationPolicyProhibited = 2,
+    NSApplicationActivationPolicyERROR = -1,
+}
+
+unsafe impl Encode for NSApplicationActivationPolicy {
+    const ENCODING: Encoding = NSInteger::ENCODING;
+}
+
+bitflags! {
+    pub struct NSApplicationPresentationOptions: NSUInteger {
+        const NSApplicationPresentationDefault = 0;
+        const NSApplicationPresentationAutoHideDock = 1 << 0;
+        const NSApplicationPresentationHideDock = 1 << 1;
+        const NSApplicationPresentationAutoHideMenuBar = 1 << 2;
+        const NSApplicationPresentationHideMenuBar = 1 << 3;
+        const NSApplicationPresentationDisableAppleMenu = 1 << 4;
+        const NSApplicationPresentationDisableProcessSwitching = 1 << 5;
+        const NSApplicationPresentationDisableForceQuit = 1 << 6;
+        const NSApplicationPresentationDisableSessionTermination = 1 << 7;
+        const NSApplicationPresentationDisableHideApplication = 1 << 8;
+        const NSApplicationPresentationDisableMenuBarTransparency = 1 << 9;
+        const NSApplicationPresentationFullScreen = 1 << 10;
+        const NSApplicationPresentationAutoHideToolbar = 1 << 11;
+    }
+}
+
+unsafe impl Encode for NSApplicationPresentationOptions {
+    const ENCODING: Encoding = NSUInteger::ENCODING;
+}
+
+#[repr(usize)] // NSUInteger
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum NSRequestUserAttentionType {
+    NSCriticalRequest = 0,
+    NSInformationalRequest = 10,
+}
+
+unsafe impl Encode for NSRequestUserAttentionType {
+    const ENCODING: Encoding = NSUInteger::ENCODING;
+}

third-party/vendor/winit/src/platform_impl/macos/appkit/button.rs

@@ -0,0 +1,14 @@
+use objc2::foundation::NSObject;
+use objc2::{extern_class, ClassType};
+
+use super::{NSControl, NSResponder, NSView};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct NSButton;
+
+    unsafe impl ClassType for NSButton {
+        #[inherits(NSView, NSResponder, NSObject)]
+        type Super = NSControl;
+    }
+);

third-party/vendor/winit/src/platform_impl/macos/appkit/color.rs

@@ -0,0 +1,28 @@
+use objc2::foundation::NSObject;
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
+
+extern_class!(
+    /// An object that stores color data and sometimes opacity (alpha value).
+    ///
+    /// <https://developer.apple.com/documentation/appkit/nscolor?language=objc>
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct NSColor;
+
+    unsafe impl ClassType for NSColor {
+        type Super = NSObject;
+    }
+);
+
+// SAFETY: Documentation clearly states:
+// > Color objects are immutable and thread-safe
+unsafe impl Send for NSColor {}
+unsafe impl Sync for NSColor {}
+
+extern_methods!(
+    unsafe impl NSColor {
+        pub fn clear() -> Id<Self, Shared> {
+            unsafe { msg_send_id![Self::class(), clearColor] }
+        }
+    }
+);

third-party/vendor/winit/src/platform_impl/macos/appkit/control.rs

@@ -0,0 +1,24 @@
+use objc2::foundation::NSObject;
+use objc2::{extern_class, extern_methods, ClassType};
+
+use super::{NSResponder, NSView};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct NSControl;
+
+    unsafe impl ClassType for NSControl {
+        #[inherits(NSResponder, NSObject)]
+        type Super = NSView;
+    }
+);
+
+extern_methods!(
+    unsafe impl NSControl {
+        #[sel(setEnabled:)]
+        pub fn setEnabled(&self, enabled: bool);
+
+        #[sel(isEnabled)]
+        pub fn isEnabled(&self) -> bool;
+    }
+);

third-party/vendor/winit/src/platform_impl/macos/appkit/cursor.rs

@@ -0,0 +1,241 @@
+use once_cell::sync::Lazy;
+
+use objc2::foundation::{NSData, NSDictionary, NSNumber, NSObject, NSPoint, NSString};
+use objc2::rc::{DefaultId, Id, Shared};
+use objc2::runtime::Sel;
+use objc2::{extern_class, extern_methods, msg_send_id, ns_string, sel, ClassType};
+
+use super::NSImage;
+use crate::window::CursorIcon;
+
+extern_class!(
+    /// <https://developer.apple.com/documentation/appkit/nscursor?language=objc>
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct NSCursor;
+
+    unsafe impl ClassType for NSCursor {
+        type Super = NSObject;
+    }
+);
+
+// SAFETY: NSCursor is immutable, stated here:
+// https://developer.apple.com/documentation/appkit/nscursor/1527062-image?language=objc
+unsafe impl Send for NSCursor {}
+unsafe impl Sync for NSCursor {}
+
+macro_rules! def_cursor {
+    {$(
+        $(#[$($m:meta)*])*
+        pub fn $name:ident();
+    )*} => {$(
+        $(#[$($m)*])*
+        pub fn $name() -> Id<Self, Shared> {
+            unsafe { msg_send_id![Self::class(), $name] }
+        }
+    )*};
+}
+
+macro_rules! def_undocumented_cursor {
+    {$(
+        $(#[$($m:meta)*])*
+        pub fn $name:ident();
+    )*} => {$(
+        $(#[$($m)*])*
+        pub fn $name() -> Id<Self, Shared> {
+            unsafe { Self::from_selector(sel!($name)).unwrap_or_else(|| Default::default()) }
+        }
+    )*};
+}
+
+extern_methods!(
+    /// Documented cursors
+    unsafe impl NSCursor {
+        def_cursor!(
+            pub fn arrowCursor();
+            pub fn pointingHandCursor();
+            pub fn openHandCursor();
+            pub fn closedHandCursor();
+            pub fn IBeamCursor();
+            pub fn IBeamCursorForVerticalLayout();
+            pub fn dragCopyCursor();
+            pub fn dragLinkCursor();
+            pub fn operationNotAllowedCursor();
+            pub fn contextualMenuCursor();
+            pub fn crosshairCursor();
+            pub fn resizeRightCursor();
+            pub fn resizeUpCursor();
+            pub fn resizeLeftCursor();
+            pub fn resizeDownCursor();
+            pub fn resizeLeftRightCursor();
+            pub fn resizeUpDownCursor();
+        );
+
+        // Creating cursors should be thread-safe, though using them for anything probably isn't.
+        pub fn new(image: &NSImage, hotSpot: NSPoint) -> Id<Self, Shared> {
+            let this = unsafe { msg_send_id![Self::class(), alloc] };
+            unsafe { msg_send_id![this, initWithImage: image, hotSpot: hotSpot] }
+        }
+
+        pub fn invisible() -> Id<Self, Shared> {
+            // 16x16 GIF data for invisible cursor
+            // You can reproduce this via ImageMagick.
+            // $ convert -size 16x16 xc:none cursor.gif
+            static CURSOR_BYTES: &[u8] = &[
+                0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x10, 0x00, 0x10, 0x00, 0xF0, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0xF9, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x2C,
+                0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x10, 0x00, 0x00, 0x02, 0x0E, 0x84, 0x8F, 0xA9,
+                0xCB, 0xED, 0x0F, 0xA3, 0x9C, 0xB4, 0xDA, 0x8B, 0xB3, 0x3E, 0x05, 0x00, 0x3B,
+            ];
+
+            static CURSOR: Lazy<Id<NSCursor, Shared>> = Lazy::new(|| {
+                // TODO: Consider using `dataWithBytesNoCopy:`
+                let data = NSData::with_bytes(CURSOR_BYTES);
+                let image = NSImage::new_with_data(&data);
+                NSCursor::new(&image, NSPoint::new(0.0, 0.0))
+            });
+
+            CURSOR.clone()
+        }
+    }
+
+    /// Undocumented cursors
+    unsafe impl NSCursor {
+        #[sel(respondsToSelector:)]
+        fn class_responds_to(sel: Sel) -> bool;
+
+        unsafe fn from_selector_unchecked(sel: Sel) -> Id<Self, Shared> {
+            unsafe { msg_send_id![Self::class(), performSelector: sel] }
+        }
+
+        unsafe fn from_selector(sel: Sel) -> Option<Id<Self, Shared>> {
+            if Self::class_responds_to(sel) {
+                Some(unsafe { Self::from_selector_unchecked(sel) })
+            } else {
+                warn!("Cursor `{:?}` appears to be invalid", sel);
+                None
+            }
+        }
+
+        def_undocumented_cursor!(
+            // Undocumented cursors: https://stackoverflow.com/a/46635398/5435443
+            pub fn _helpCursor();
+            pub fn _zoomInCursor();
+            pub fn _zoomOutCursor();
+            pub fn _windowResizeNorthEastCursor();
+            pub fn _windowResizeNorthWestCursor();
+            pub fn _windowResizeSouthEastCursor();
+            pub fn _windowResizeSouthWestCursor();
+            pub fn _windowResizeNorthEastSouthWestCursor();
+            pub fn _windowResizeNorthWestSouthEastCursor();
+
+            // While these two are available, the former just loads a white arrow,
+            // and the latter loads an ugly deflated beachball!
+            // pub fn _moveCursor();
+            // pub fn _waitCursor();
+
+            // An even more undocumented cursor...
+            // https://bugs.eclipse.org/bugs/show_bug.cgi?id=522349
+            pub fn busyButClickableCursor();
+        );
+    }
+
+    /// Webkit cursors
+    unsafe impl NSCursor {
+        // Note that loading `busybutclickable` with this code won't animate
+        // the frames; instead you'll just get them all in a column.
+        unsafe fn load_webkit_cursor(name: &NSString) -> Id<Self, Shared> {
+            // Snatch a cursor from WebKit; They fit the style of the native
+            // cursors, and will seem completely standard to macOS users.
+            //
+            // https://stackoverflow.com/a/21786835/5435443
+            let root = ns_string!("/System/Library/Frameworks/ApplicationServices.framework/Versions/A/Frameworks/HIServices.framework/Versions/A/Resources/cursors");
+            let cursor_path = root.join_path(name);
+
+            let pdf_path = cursor_path.join_path(ns_string!("cursor.pdf"));
+            let image = NSImage::new_by_referencing_file(&pdf_path);
+
+            // TODO: Handle PLists better
+            let info_path = cursor_path.join_path(ns_string!("info.plist"));
+            let info: Id<NSDictionary<NSObject, NSObject>, Shared> = unsafe {
+                msg_send_id![
+                    <NSDictionary<NSObject, NSObject>>::class(),
+                    dictionaryWithContentsOfFile: &*info_path,
+                ]
+            };
+            let mut x = 0.0;
+            if let Some(n) = info.get(&*ns_string!("hotx")) {
+                if n.is_kind_of::<NSNumber>() {
+                    let ptr: *const NSObject = n;
+                    let ptr: *const NSNumber = ptr.cast();
+                    x = unsafe { &*ptr }.as_cgfloat()
+                }
+            }
+            let mut y = 0.0;
+            if let Some(n) = info.get(&*ns_string!("hotx")) {
+                if n.is_kind_of::<NSNumber>() {
+                    let ptr: *const NSObject = n;
+                    let ptr: *const NSNumber = ptr.cast();
+                    y = unsafe { &*ptr }.as_cgfloat()
+                }
+            }
+
+            let hotspot = NSPoint::new(x, y);
+            Self::new(&image, hotspot)
+        }
+
+        pub fn moveCursor() -> Id<Self, Shared> {
+            unsafe { Self::load_webkit_cursor(ns_string!("move")) }
+        }
+
+        pub fn cellCursor() -> Id<Self, Shared> {
+            unsafe { Self::load_webkit_cursor(ns_string!("cell")) }
+        }
+    }
+);
+
+impl NSCursor {
+    pub fn from_icon(icon: CursorIcon) -> Id<Self, Shared> {
+        match icon {
+            CursorIcon::Default => Default::default(),
+            CursorIcon::Arrow => Self::arrowCursor(),
+            CursorIcon::Hand => Self::pointingHandCursor(),
+            CursorIcon::Grab => Self::openHandCursor(),
+            CursorIcon::Grabbing => Self::closedHandCursor(),
+            CursorIcon::Text => Self::IBeamCursor(),
+            CursorIcon::VerticalText => Self::IBeamCursorForVerticalLayout(),
+            CursorIcon::Copy => Self::dragCopyCursor(),
+            CursorIcon::Alias => Self::dragLinkCursor(),
+            CursorIcon::NotAllowed | CursorIcon::NoDrop => Self::operationNotAllowedCursor(),
+            CursorIcon::ContextMenu => Self::contextualMenuCursor(),
+            CursorIcon::Crosshair => Self::crosshairCursor(),
+            CursorIcon::EResize => Self::resizeRightCursor(),
+            CursorIcon::NResize => Self::resizeUpCursor(),
+            CursorIcon::WResize => Self::resizeLeftCursor(),
+            CursorIcon::SResize => Self::resizeDownCursor(),
+            CursorIcon::EwResize | CursorIcon::ColResize => Self::resizeLeftRightCursor(),
+            CursorIcon::NsResize | CursorIcon::RowResize => Self::resizeUpDownCursor(),
+            CursorIcon::Help => Self::_helpCursor(),
+            CursorIcon::ZoomIn => Self::_zoomInCursor(),
+            CursorIcon::ZoomOut => Self::_zoomOutCursor(),
+            CursorIcon::NeResize => Self::_windowResizeNorthEastCursor(),
+            CursorIcon::NwResize => Self::_windowResizeNorthWestCursor(),
+            CursorIcon::SeResize => Self::_windowResizeSouthEastCursor(),
+            CursorIcon::SwResize => Self::_windowResizeSouthWestCursor(),
+            CursorIcon::NeswResize => Self::_windowResizeNorthEastSouthWestCursor(),
+            CursorIcon::NwseResize => Self::_windowResizeNorthWestSouthEastCursor(),
+            // This is the wrong semantics for `Wait`, but it's the same as
+            // what's used in Safari and Chrome.
+            CursorIcon::Wait | CursorIcon::Progress => Self::busyButClickableCursor(),
+            CursorIcon::Move | CursorIcon::AllScroll => Self::moveCursor(),
+            CursorIcon::Cell => Self::cellCursor(),
+        }
+    }
+}
+
+impl DefaultId for NSCursor {
+    type Ownership = Shared;
+
+    fn default_id() -> Id<Self, Shared> {
+        Self::arrowCursor()
+    }
+}

third-party/vendor/winit/src/platform_impl/macos/appkit/event.rs

@@ -0,0 +1,286 @@
+use std::os::raw::c_ushort;
+
+use objc2::encode::{Encode, Encoding};
+use objc2::foundation::{
+    CGFloat, NSCopying, NSInteger, NSObject, NSPoint, NSString, NSTimeInterval, NSUInteger,
+};
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct NSEvent;
+
+    unsafe impl ClassType for NSEvent {
+        type Super = NSObject;
+    }
+);
+
+// > Safely handled only on the same thread, whether that be the main thread
+// > or a secondary thread; otherwise you run the risk of having events get
+// > out of sequence.
+// <https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/CocoaFundamentals/AddingBehaviortoaCocoaProgram/AddingBehaviorCocoa.html#//apple_ref/doc/uid/TP40002974-CH5-SW47>
+// <https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/Multithreading/ThreadSafetySummary/ThreadSafetySummary.html#//apple_ref/doc/uid/10000057i-CH12-123383>
+
+extern_methods!(
+    unsafe impl NSEvent {
+        unsafe fn otherEventWithType(
+            type_: NSEventType,
+            location: NSPoint,
+            flags: NSEventModifierFlags,
+            time: NSTimeInterval,
+            window_num: NSInteger,
+            context: Option<&NSObject>, // NSGraphicsContext
+            subtype: NSEventSubtype,
+            data1: NSInteger,
+            data2: NSInteger,
+        ) -> Id<Self, Shared> {
+            unsafe {
+                msg_send_id![
+                    Self::class(),
+                    otherEventWithType: type_,
+                    location: location,
+                    modifierFlags: flags,
+                    timestamp: time,
+                    windowNumber: window_num,
+                    context: context,
+                    subtype: subtype,
+                    data1: data1,
+                    data2: data2,
+                ]
+            }
+        }
+
+        pub fn dummy() -> Id<Self, Shared> {
+            unsafe {
+                Self::otherEventWithType(
+                    NSEventType::NSApplicationDefined,
+                    NSPoint::new(0.0, 0.0),
+                    NSEventModifierFlags::empty(),
+                    0.0,
+                    0,
+                    None,
+                    NSEventSubtype::NSWindowExposedEventType,
+                    0,
+                    0,
+                )
+            }
+        }
+
+        pub fn keyEventWithType(
+            type_: NSEventType,
+            location: NSPoint,
+            modifier_flags: NSEventModifierFlags,
+            timestamp: NSTimeInterval,
+            window_num: NSInteger,
+            context: Option<&NSObject>,
+            characters: &NSString,
+            characters_ignoring_modifiers: &NSString,
+            is_a_repeat: bool,
+            scancode: c_ushort,
+        ) -> Id<Self, Shared> {
+            unsafe {
+                msg_send_id![
+                    Self::class(),
+                    keyEventWithType: type_,
+                    location: location,
+                    modifierFlags: modifier_flags,
+                    timestamp: timestamp,
+                    windowNumber: window_num,
+                    context: context,
+                    characters: characters,
+                    charactersIgnoringModifiers: characters_ignoring_modifiers,
+                    isARepeat: is_a_repeat,
+                    keyCode: scancode,
+                ]
+            }
+        }
+
+        #[sel(locationInWindow)]
+        pub fn locationInWindow(&self) -> NSPoint;
+
+        // TODO: MainThreadMarker
+        #[sel(pressedMouseButtons)]
+        pub fn pressedMouseButtons() -> NSUInteger;
+
+        #[sel(modifierFlags)]
+        pub fn modifierFlags(&self) -> NSEventModifierFlags;
+
+        #[sel(type)]
+        pub fn type_(&self) -> NSEventType;
+
+        // In AppKit, `keyCode` refers to the position (scancode) of a key rather than its character,
+        // and there is no easy way to navtively retrieve the layout-dependent character.
+        // In winit, we use keycode to refer to the key's character, and so this function aligns
+        // AppKit's terminology with ours.
+        #[sel(keyCode)]
+        pub fn scancode(&self) -> c_ushort;
+
+        #[sel(magnification)]
+        pub fn magnification(&self) -> CGFloat;
+
+        #[sel(phase)]
+        pub fn phase(&self) -> NSEventPhase;
+
+        #[sel(momentumPhase)]
+        pub fn momentumPhase(&self) -> NSEventPhase;
+
+        #[sel(deltaX)]
+        pub fn deltaX(&self) -> CGFloat;
+
+        #[sel(deltaY)]
+        pub fn deltaY(&self) -> CGFloat;
+
+        #[sel(buttonNumber)]
+        pub fn buttonNumber(&self) -> NSInteger;
+
+        #[sel(scrollingDeltaX)]
+        pub fn scrollingDeltaX(&self) -> CGFloat;
+
+        #[sel(scrollingDeltaY)]
+        pub fn scrollingDeltaY(&self) -> CGFloat;
+
+        #[sel(hasPreciseScrollingDeltas)]
+        pub fn hasPreciseScrollingDeltas(&self) -> bool;
+
+        #[sel(rotation)]
+        pub fn rotation(&self) -> f32;
+
+        #[sel(pressure)]
+        pub fn pressure(&self) -> f32;
+
+        #[sel(stage)]
+        pub fn stage(&self) -> NSInteger;
+
+        #[sel(isARepeat)]
+        pub fn is_a_repeat(&self) -> bool;
+
+        #[sel(windowNumber)]
+        pub fn window_number(&self) -> NSInteger;
+
+        #[sel(timestamp)]
+        pub fn timestamp(&self) -> NSTimeInterval;
+
+        pub fn characters(&self) -> Option<Id<NSString, Shared>> {
+            unsafe { msg_send_id![self, characters] }
+        }
+
+        pub fn charactersIgnoringModifiers(&self) -> Option<Id<NSString, Shared>> {
+            unsafe { msg_send_id![self, charactersIgnoringModifiers] }
+        }
+
+        pub fn lalt_pressed(&self) -> bool {
+            let raw_modifiers = self.modifierFlags().bits() as u32;
+            raw_modifiers & NX_DEVICELALTKEYMASK != 0
+        }
+
+        pub fn ralt_pressed(&self) -> bool {
+            let raw_modifiers = self.modifierFlags().bits() as u32;
+            raw_modifiers & NX_DEVICERALTKEYMASK != 0
+        }
+    }
+);
+
+unsafe impl NSCopying for NSEvent {
+    type Ownership = Shared;
+    type Output = NSEvent;
+}
+
+// The values are from the https://github.com/apple-oss-distributions/IOHIDFamily/blob/19666c840a6d896468416ff0007040a10b7b46b8/IOHIDSystem/IOKit/hidsystem/IOLLEvent.h#L258-L259
+const NX_DEVICELALTKEYMASK: u32 = 0x00000020;
+const NX_DEVICERALTKEYMASK: u32 = 0x00000040;
+
+bitflags! {
+    pub struct NSEventModifierFlags: NSUInteger {
+        const NSAlphaShiftKeyMask                     = 1 << 16;
+        const NSShiftKeyMask                          = 1 << 17;
+        const NSControlKeyMask                        = 1 << 18;
+        const NSAlternateKeyMask                      = 1 << 19;
+        const NSCommandKeyMask                        = 1 << 20;
+        const NSNumericPadKeyMask                     = 1 << 21;
+        const NSHelpKeyMask                           = 1 << 22;
+        const NSFunctionKeyMask                       = 1 << 23;
+        const NSDeviceIndependentModifierFlagsMask    = 0xffff0000;
+    }
+}
+
+unsafe impl Encode for NSEventModifierFlags {
+    const ENCODING: Encoding = NSUInteger::ENCODING;
+}
+
+bitflags! {
+    pub struct NSEventPhase: NSUInteger {
+       const NSEventPhaseNone        = 0;
+       const NSEventPhaseBegan       = 0x1 << 0;
+       const NSEventPhaseStationary  = 0x1 << 1;
+       const NSEventPhaseChanged     = 0x1 << 2;
+       const NSEventPhaseEnded       = 0x1 << 3;
+       const NSEventPhaseCancelled   = 0x1 << 4;
+       const NSEventPhaseMayBegin    = 0x1 << 5;
+    }
+}
+
+unsafe impl Encode for NSEventPhase {
+    const ENCODING: Encoding = NSUInteger::ENCODING;
+}
+
+#[allow(dead_code)]
+#[repr(i16)] // short
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum NSEventSubtype {
+    // TODO: Not sure what these values are
+    // NSMouseEventSubtype           = NX_SUBTYPE_DEFAULT,
+    // NSTabletPointEventSubtype     = NX_SUBTYPE_TABLET_POINT,
+    // NSTabletProximityEventSubtype = NX_SUBTYPE_TABLET_PROXIMITY
+    // NSTouchEventSubtype           = NX_SUBTYPE_MOUSE_TOUCH,
+    NSWindowExposedEventType = 0,
+    NSApplicationActivatedEventType = 1,
+    NSApplicationDeactivatedEventType = 2,
+    NSWindowMovedEventType = 4,
+    NSScreenChangedEventType = 8,
+    NSAWTEventType = 16,
+}
+
+unsafe impl Encode for NSEventSubtype {
+    const ENCODING: Encoding = i16::ENCODING;
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[repr(usize)] // NSUInteger
+pub enum NSEventType {
+    NSLeftMouseDown = 1,
+    NSLeftMouseUp = 2,
+    NSRightMouseDown = 3,
+    NSRightMouseUp = 4,
+    NSMouseMoved = 5,
+    NSLeftMouseDragged = 6,
+    NSRightMouseDragged = 7,
+    NSMouseEntered = 8,
+    NSMouseExited = 9,
+    NSKeyDown = 10,
+    NSKeyUp = 11,
+    NSFlagsChanged = 12,
+    NSAppKitDefined = 13,
+    NSSystemDefined = 14,
+    NSApplicationDefined = 15,
+    NSPeriodic = 16,
+    NSCursorUpdate = 17,
+    NSScrollWheel = 22,
+    NSTabletPoint = 23,
+    NSTabletProximity = 24,
+    NSOtherMouseDown = 25,
+    NSOtherMouseUp = 26,
+    NSOtherMouseDragged = 27,
+    NSEventTypeGesture = 29,
+    NSEventTypeMagnify = 30,
+    NSEventTypeSwipe = 31,
+    NSEventTypeRotate = 18,
+    NSEventTypeBeginGesture = 19,
+    NSEventTypeEndGesture = 20,
+    NSEventTypePressure = 34,
+}
+
+unsafe impl Encode for NSEventType {
+    const ENCODING: Encoding = NSUInteger::ENCODING;
+}

third-party/vendor/winit/src/platform_impl/macos/appkit/image.rs

@@ -0,0 +1,37 @@
+use objc2::foundation::{NSData, NSObject, NSString};
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
+
+extern_class!(
+    // TODO: Can this be mutable?
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct NSImage;
+
+    unsafe impl ClassType for NSImage {
+        type Super = NSObject;
+    }
+);
+
+// Documented Thread-Unsafe, but:
+// > One thread can create an NSImage object, draw to the image buffer,
+// > and pass it off to the main thread for drawing. The underlying image
+// > cache is shared among all threads.
+// <https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/Multithreading/ThreadSafetySummary/ThreadSafetySummary.html#//apple_ref/doc/uid/10000057i-CH12-126728>
+//
+// So really only unsafe to mutate on several threads.
+unsafe impl Send for NSImage {}
+unsafe impl Sync for NSImage {}
+
+extern_methods!(
+    unsafe impl NSImage {
+        pub fn new_by_referencing_file(path: &NSString) -> Id<Self, Shared> {
+            let this = unsafe { msg_send_id![Self::class(), alloc] };
+            unsafe { msg_send_id![this, initByReferencingFile: path] }
+        }
+
+        pub fn new_with_data(data: &NSData) -> Id<Self, Shared> {
+            let this = unsafe { msg_send_id![Self::class(), alloc] };
+            unsafe { msg_send_id![this, initWithData: data] }
+        }
+    }
+);

third-party/vendor/winit/src/platform_impl/macos/appkit/menu.rs

@@ -0,0 +1,25 @@
+use objc2::foundation::NSObject;
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
+
+use super::NSMenuItem;
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct NSMenu;
+
+    unsafe impl ClassType for NSMenu {
+        type Super = NSObject;
+    }
+);
+
+extern_methods!(
+    unsafe impl NSMenu {
+        pub fn new() -> Id<Self, Shared> {
+            unsafe { msg_send_id![Self::class(), new] }
+        }
+
+        #[sel(addItem:)]
+        pub fn addItem(&self, item: &NSMenuItem);
+    }
+);