move window settings to `iced_native`

4 files changed, 203 insertions, 24 deletions

diff --git a/winit/src/icon.rs b/winit/src/icon.rs
new file mode 100644
index 00000000..84b88b39
--- /dev/null
+++ b/winit/src/icon.rs
@@ -0,0 +1,179 @@
+//! Attach an icon to the window of your application.
+use std::fmt;
+use std::io;
+
+#[cfg(feature = "image_rs")]
+use std::path::Path;
+
+/// The icon of a window.
+#[derive(Debug, Clone)]
+pub struct Icon(winit::window::Icon);
+
+impl Icon {
+    /// Creates an icon from 32bpp RGBA data.
+    pub fn from_rgba(
+        rgba: Vec<u8>,
+        width: u32,
+        height: u32,
+    ) -> Result<Self, Error> {
+        let raw = winit::window::Icon::from_rgba(rgba, width, height)?;
+
+        Ok(Icon(raw))
+    }
+
+    /// Creates an icon from an image file.
+    ///
+    /// This will return an error in case the file is missing at run-time. You may prefer [`Self::from_file_data`] instead.
+    #[cfg(feature = "image_rs")]
+    pub fn from_file<P: AsRef<Path>>(icon_path: P) -> Result<Self, Error> {
+        let icon = image_rs::io::Reader::open(icon_path)?.decode()?.to_rgba8();
+
+        Self::from_rgba(icon.to_vec(), icon.width(), icon.height())
+    }
+
+    /// Creates an icon from the content of an image file.
+    ///
+    /// This content can be included in your application at compile-time, e.g. using the `include_bytes!` macro. \
+    /// You can pass an explicit file format. Otherwise, the file format will be guessed at runtime.
+    #[cfg(feature = "image_rs")]
+    pub fn from_file_data(
+        data: &[u8],
+        explicit_format: Option<image_rs::ImageFormat>,
+    ) -> Result<Self, Error> {
+        let mut icon = image_rs::io::Reader::new(std::io::Cursor::new(data));
+        let icon_with_format = match explicit_format {
+            Some(format) => {
+                icon.set_format(format);
+                icon
+            }
+            None => icon.with_guessed_format()?,
+        };
+
+        let pixels = icon_with_format.decode()?.to_rgba8();
+
+        Self::from_rgba(pixels.to_vec(), pixels.width(), pixels.height())
+    }
+}
+
+/// An error produced when using `Icon::from_rgba` with invalid arguments.
+#[derive(Debug)]
+pub enum Error {
+    /// The provided RGBA data isn't divisble by 4.
+    ///
+    /// Therefore, it cannot be safely interpreted as 32bpp RGBA pixels.
+    InvalidData {
+        /// The length of the provided RGBA data.
+        byte_count: usize,
+    },
+
+    /// The number of RGBA pixels does not match the provided dimensions.
+    DimensionsMismatch {
+        /// The provided width.
+        width: u32,
+        /// The provided height.
+        height: u32,
+        /// The amount of pixels of the provided RGBA data.
+        pixel_count: usize,
+    },
+
+    /// The underlying OS failed to create the icon.
+    OsError(io::Error),
+
+    /// The `image` crate reported an error
+    #[cfg(feature = "image_rs")]
+    ImageError(image_rs::error::ImageError),
+}
+
+impl From<std::io::Error> for Error {
+    fn from(os_error: std::io::Error) -> Self {
+        Error::OsError(os_error)
+    }
+}
+
+impl From<winit::window::BadIcon> for Error {
+    fn from(error: winit::window::BadIcon) -> Self {
+        use winit::window::BadIcon;
+
+        match error {
+            BadIcon::ByteCountNotDivisibleBy4 { byte_count } => {
+                Error::InvalidData { byte_count }
+            }
+            BadIcon::DimensionsVsPixelCount {
+                width,
+                height,
+                pixel_count,
+                ..
+            } => Error::DimensionsMismatch {
+                width,
+                height,
+                pixel_count,
+            },
+            BadIcon::OsError(os_error) => Error::OsError(os_error),
+        }
+    }
+}
+
+impl From<Icon> for winit::window::Icon {
+    fn from(icon: Icon) -> Self {
+        icon.0
+    }
+}
+
+#[cfg(feature = "image_rs")]
+impl From<image_rs::error::ImageError> for Error {
+    fn from(image_error: image_rs::error::ImageError) -> Self {
+        Self::ImageError(image_error)
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::InvalidData { byte_count } => {
+                write!(
+                    f,
+                    "The provided RGBA data (with length {:?}) isn't divisble by \
+                4. Therefore, it cannot be safely interpreted as 32bpp RGBA \
+                pixels.",
+                    byte_count,
+                )
+            }
+            Error::DimensionsMismatch {
+                width,
+                height,
+                pixel_count,
+            } => {
+                write!(
+                    f,
+                    "The number of RGBA pixels ({:?}) does not match the provided \
+                dimensions ({:?}x{:?}).",
+                    pixel_count, width, height,
+                )
+            }
+            Error::OsError(e) => write!(
+                f,
+                "The underlying OS failed to create the window \
+                icon: {:?}",
+                e
+            ),
+            #[cfg(feature = "image_rs")]
+            Error::ImageError(e) => {
+                write!(f, "Unable to create icon from a file: {:?}", e)
+            }
+        }
+    }
+}
+
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        Some(self)
+    }
+}
+
+impl TryFrom<iced_native::window::Icon> for Icon {
+    type Error = Error;
+
+    fn try_from(icon: iced_native::window::Icon) -> Result<Self, Self::Error> {
+        Icon::from_rgba(icon.rgba, icon.width, icon.height)
+    }
+}
diff --git a/winit/src/lib.rs b/winit/src/lib.rs
index 9b3c0a02..eb58482b 100644
--- a/winit/src/lib.rs
+++ b/winit/src/lib.rs
@@ -49,7 +49,7 @@ pub mod window;
 pub mod system;
 
 mod error;
-mod position;
+mod icon;
 mod proxy;
 
 #[cfg(feature = "application")]
@@ -58,8 +58,9 @@ pub use application::Application;
 pub use application::Profiler;
 pub use clipboard::Clipboard;
 pub use error::Error;
-pub use position::Position;
+pub use icon::Icon;
 pub use proxy::Proxy;
 pub use settings::Settings;
 
 pub use iced_graphics::Viewport;
+pub use iced_native::window::Position;
diff --git a/winit/src/position.rs b/winit/src/position.rs
deleted file mode 100644
index c260c29e..00000000
--- a/winit/src/position.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-/// 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 ea0ba361..78c8c156 100644
--- a/winit/src/settings.rs
+++ b/winit/src/settings.rs
@@ -22,6 +22,7 @@ mod platform;
 pub use platform::PlatformSpecific;
 
 use crate::conversion;
+use crate::Icon;
 use crate::Position;
 use winit::monitor::MonitorHandle;
 use winit::window::WindowBuilder;
@@ -201,3 +202,23 @@ impl Default for Window {
         }
     }
 }
+
+impl From<iced_native::window::Settings> for Window {
+    fn from(settings: iced_native::window::Settings) -> Self {
+        Self {
+            size: settings.size,
+            position: Position::from(settings.position),
+            min_size: settings.min_size,
+            max_size: settings.max_size,
+            visible: settings.visible,
+            resizable: settings.resizable,
+            decorations: settings.decorations,
+            transparent: settings.transparent,
+            always_on_top: settings.always_on_top,
+            icon: settings.icon.and_then(|icon| {
+                Icon::try_from(icon).map(winit::window::Icon::from).ok()
+            }),
+            platform_specific: Default::default(),
+        }
+    }
+}