Improve `window::Position` API

4 files changed, 82 insertions, 6 deletions

diff --git a/winit/src/conversion.rs b/winit/src/conversion.rs
index b850a805..f785fce6 100644
--- a/winit/src/conversion.rs
+++ b/winit/src/conversion.rs
@@ -6,7 +6,7 @@ use crate::keyboard;
 use crate::mouse;
 use crate::touch;
 use crate::window;
-use crate::{Event, Mode, Point};
+use crate::{Event, Mode, Point, Position};
 
 /// Converts a winit window event into an iced event.
 pub fn window_event(
@@ -133,6 +133,49 @@ pub fn window_event(
     }
 }
 
+/// Converts a [`Position`] to a [`winit`] logical position for a given monitor.
+///
+/// [`winit`]: https://github.com/rust-windowing/winit
+pub fn position(
+    monitor: Option<&winit::monitor::MonitorHandle>,
+    (width, height): (u32, u32),
+    position: Position,
+) -> Option<winit::dpi::Position> {
+    match position {
+        Position::Default => None,
+        Position::Specific(x, y) => {
+            Some(winit::dpi::Position::Logical(winit::dpi::LogicalPosition {
+                x: f64::from(x),
+                y: f64::from(y),
+            }))
+        }
+        Position::Centered => {
+            if let Some(monitor) = monitor {
+                let start = monitor.position();
+
+                let resolution: winit::dpi::LogicalSize<f64> =
+                    monitor.size().to_logical(monitor.scale_factor());
+
+                let centered: winit::dpi::PhysicalPosition<i32> =
+                    winit::dpi::LogicalPosition {
+                        x: (resolution.width - f64::from(width)) / 2.0,
+                        y: (resolution.height - f64::from(height)) / 2.0,
+                    }
+                    .to_physical(monitor.scale_factor());
+
+                Some(winit::dpi::Position::Physical(
+                    winit::dpi::PhysicalPosition {
+                        x: start.x + centered.x,
+                        y: start.y + centered.y,
+                    },
+                ))
+            } else {
+                None
+            }
+        }
+    }
+}
+
 /// Converts a [`Mode`] to a [`winit`] fullscreen mode.
 ///
 /// [`winit`]: https://github.com/rust-windowing/winit
diff --git a/winit/src/lib.rs b/winit/src/lib.rs
index c9f324dd..1707846a 100644
--- a/winit/src/lib.rs
+++ b/winit/src/lib.rs
@@ -31,12 +31,14 @@ pub mod settings;
 mod clipboard;
 mod error;
 mod mode;
+mod position;
 mod proxy;
 
 pub use application::Application;
 pub use clipboard::Clipboard;
 pub use error::Error;
 pub use mode::Mode;
+pub use position::Position;
 pub use proxy::Proxy;
 pub use settings::Settings;
 
diff --git a/winit/src/position.rs b/winit/src/position.rs
new file mode 100644
index 00000000..c260c29e
--- /dev/null
+++ b/winit/src/position.rs
@@ -0,0 +1,22 @@
+/// The position of a window in a given screen.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Position {
+    /// The platform-specific default position for a new window.
+    Default,
+    /// The window is completely centered on the screen.
+    Centered,
+    /// The window is positioned with specific coordinates: `(X, Y)`.
+    ///
+    /// When the decorations of the window are enabled, Windows 10 will add some
+    /// invisible padding to the window. This padding gets included in the
+    /// position. So if you have decorations enabled and want the window to be
+    /// at (0, 0) you would have to set the position to
+    /// `(PADDING_X, PADDING_Y)`.
+    Specific(i32, i32),
+}
+
+impl Default for Position {
+    fn default() -> Self {
+        Self::Default
+    }
+}
diff --git a/winit/src/settings.rs b/winit/src/settings.rs
index 1769c676..743f79bc 100644
--- a/winit/src/settings.rs
+++ b/winit/src/settings.rs
@@ -9,7 +9,7 @@ mod platform;
 pub use platform::PlatformSpecific;
 
 use crate::conversion;
-use crate::Mode;
+use crate::{Mode, Position};
 use winit::monitor::MonitorHandle;
 use winit::window::WindowBuilder;
 
@@ -36,7 +36,7 @@ pub struct Window {
     pub size: (u32, u32),
 
     /// The position of the window.
-    pub position: (i32, i32),
+    pub position: Position,
 
     /// The minimum size of the window.
     pub min_size: Option<(u32, u32)>,
@@ -78,15 +78,21 @@ impl Window {
         window_builder = window_builder
             .with_title(title)
             .with_inner_size(winit::dpi::LogicalSize { width, height })
-            .with_position(winit::dpi::LogicalPosition { x: self.position.0, y: self.position.1 })
             .with_resizable(self.resizable)
             .with_decorations(self.decorations)
             .with_transparent(self.transparent)
             .with_window_icon(self.icon)
             .with_always_on_top(self.always_on_top)
-            .with_fullscreen(conversion::fullscreen(primary_monitor, mode))
             .with_visible(conversion::visible(mode));
 
+        if let Some(position) = conversion::position(
+            primary_monitor.as_ref(),
+            self.size,
+            self.position,
+        ) {
+            window_builder = window_builder.with_position(position);
+        }
+
         if let Some((width, height)) = self.min_size {
             window_builder = window_builder
                 .with_min_inner_size(winit::dpi::LogicalSize { width, height });
@@ -108,6 +114,9 @@ impl Window {
                 .with_drag_and_drop(self.platform_specific.drag_and_drop);
         }
 
+        window_builder = window_builder
+            .with_fullscreen(conversion::fullscreen(primary_monitor, mode));
+
         window_builder
     }
 }
@@ -116,7 +125,7 @@ impl Default for Window {
     fn default() -> Window {
         Window {
             size: (1024, 768),
-            position: (100, 100),
+            position: Position::default(),
             min_size: None,
             max_size: None,
             resizable: true,