Merge branch 'master' into feature/pane-grid-titlebar

7 files changed, 265 insertions, 14 deletions

diff --git a/src/application.rs b/src/application.rs
index 19cab7da..47b89dbd 100644
--- a/src/application.rs
+++ b/src/application.rs
@@ -1,4 +1,6 @@
-use crate::{window, Command, Element, Executor, Settings, Subscription};
+use crate::{
+    window, Color, Command, Element, Executor, Settings, Subscription,
+};
 
 /// An interactive cross-platform application.
 ///
@@ -174,6 +176,31 @@ pub trait Application: Sized {
         window::Mode::Windowed
     }
 
+    /// Returns the background color of the [`Application`].
+    ///
+    /// By default, it returns [`Color::WHITE`].
+    ///
+    /// [`Application`]: trait.Application.html
+    /// [`Color::WHITE`]: struct.Color.html#const.WHITE
+    fn background_color(&self) -> Color {
+        Color::WHITE
+    }
+
+    /// Returns the scale factor of the [`Application`].
+    ///
+    /// It can be used to dynamically control the size of the UI at runtime
+    /// (i.e. zooming).
+    ///
+    /// For instance, a scale factor of `2.0` will make widgets twice as big,
+    /// while a scale factor of `0.5` will shrink them to half their size.
+    ///
+    /// By default, it returns `1.0`.
+    ///
+    /// [`Application`]: trait.Application.html
+    fn scale_factor(&self) -> f64 {
+        1.0
+    }
+
     /// Runs the [`Application`].
     ///
     /// On native platforms, this method will take control of the current thread
@@ -190,6 +217,7 @@ pub trait Application: Sized {
         {
             let renderer_settings = crate::renderer::Settings {
                 default_font: settings.default_font,
+                default_text_size: settings.default_text_size,
                 antialiasing: if settings.antialiasing {
                     Some(crate::renderer::settings::Antialiasing::MSAAx4)
                 } else {
@@ -256,6 +284,14 @@ where
     fn subscription(&self) -> Subscription<Self::Message> {
         self.0.subscription()
     }
+
+    fn background_color(&self) -> Color {
+        self.0.background_color()
+    }
+
+    fn scale_factor(&self) -> f64 {
+        self.0.scale_factor()
+    }
 }
 
 #[cfg(target_arch = "wasm32")]
diff --git a/src/sandbox.rs b/src/sandbox.rs
index c6fa45d0..6a73eab0 100644
--- a/src/sandbox.rs
+++ b/src/sandbox.rs
@@ -1,4 +1,6 @@
-use crate::{executor, Application, Command, Element, Settings, Subscription};
+use crate::{
+    executor, Application, Color, Command, Element, Settings, Subscription,
+};
 
 /// A sandboxed [`Application`].
 ///
@@ -124,6 +126,31 @@ pub trait Sandbox {
     /// [`Sandbox`]: trait.Sandbox.html
     fn view(&mut self) -> Element<'_, Self::Message>;
 
+    /// Returns the background color of the [`Sandbox`].
+    ///
+    /// By default, it returns [`Color::WHITE`].
+    ///
+    /// [`Sandbox`]: trait.Sandbox.html
+    /// [`Color::WHITE`]: struct.Color.html#const.WHITE
+    fn background_color(&self) -> Color {
+        Color::WHITE
+    }
+
+    /// Returns the scale factor of the [`Sandbox`].
+    ///
+    /// It can be used to dynamically control the size of the UI at runtime
+    /// (i.e. zooming).
+    ///
+    /// For instance, a scale factor of `2.0` will make widgets twice as big,
+    /// while a scale factor of `0.5` will shrink them to half their size.
+    ///
+    /// By default, it returns `1.0`.
+    ///
+    /// [`Sandbox`]: trait.Sandbox.html
+    fn scale_factor(&self) -> f64 {
+        1.0
+    }
+
     /// Runs the [`Sandbox`].
     ///
     /// On native platforms, this method will take control of the current thread
@@ -169,4 +196,12 @@ where
     fn view(&mut self) -> Element<'_, T::Message> {
         T::view(self)
     }
+
+    fn background_color(&self) -> Color {
+        T::background_color(self)
+    }
+
+    fn scale_factor(&self) -> f64 {
+        T::scale_factor(self)
+    }
 }
diff --git a/src/settings.rs b/src/settings.rs
index 01ad0ee0..40b1b1ea 100644
--- a/src/settings.rs
+++ b/src/settings.rs
@@ -2,7 +2,7 @@
 use crate::window;
 
 /// The settings of an application.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+#[derive(Debug, Clone)]
 pub struct Settings<Flags> {
     /// The window settings.
     ///
@@ -22,6 +22,11 @@ pub struct Settings<Flags> {
     // TODO: Add `name` for web compatibility
     pub default_font: Option<&'static [u8]>,
 
+    /// The text size that will be used by default.
+    ///
+    /// The default value is 20.
+    pub default_text_size: u16,
+
     /// If set to true, the renderer will try to perform antialiasing for some
     /// primitives.
     ///
@@ -39,12 +44,28 @@ impl<Flags> Settings<Flags> {
     ///
     /// [`Application`]: ../trait.Application.html
     pub fn with_flags(flags: Flags) -> Self {
+        let default_settings = Settings::<()>::default();
+
         Self {
             flags,
-            // not using ..Default::default() struct update syntax since it is more permissive to
-            // allow initializing with flags without trait bound on Default
+            antialiasing: default_settings.antialiasing,
+            default_font: default_settings.default_font,
+            default_text_size: default_settings.default_text_size,
+            window: default_settings.window,
+        }
+    }
+}
+
+impl<Flags> Default for Settings<Flags>
+where
+    Flags: Default,
+{
+    fn default() -> Self {
+        Self {
+            flags: Default::default(),
             antialiasing: Default::default(),
             default_font: Default::default(),
+            default_text_size: 20,
             window: Default::default(),
         }
     }
@@ -54,12 +75,7 @@ impl<Flags> Settings<Flags> {
 impl<Flags> From<Settings<Flags>> for iced_winit::Settings<Flags> {
     fn from(settings: Settings<Flags>) -> iced_winit::Settings<Flags> {
         iced_winit::Settings {
-            window: iced_winit::settings::Window {
-                size: settings.window.size,
-                resizable: settings.window.resizable,
-                decorations: settings.window.decorations,
-                platform_specific: Default::default(),
-            },
+            window: settings.window.into(),
             flags: settings.flags,
         }
     }
diff --git a/src/widget.rs b/src/widget.rs
index 3e4d4788..007bd531 100644
--- a/src/widget.rs
+++ b/src/widget.rs
@@ -50,7 +50,7 @@ mod platform {
         text_input::TextInput,
     };
 
-    #[cfg(feature = "canvas")]
+    #[cfg(any(feature = "canvas", feature = "glow_canvas"))]
     #[doc(no_inline)]
     pub use canvas::Canvas;
 }
diff --git a/src/window.rs b/src/window.rs
index 54ea2a02..a2883b62 100644
--- a/src/window.rs
+++ b/src/window.rs
@@ -2,5 +2,8 @@
 mod mode;
 mod settings;
 
+pub mod icon;
+
+pub use icon::Icon;
 pub use mode::Mode;
 pub use settings::Settings;
diff --git a/src/window/icon.rs b/src/window/icon.rs
new file mode 100644
index 00000000..15e0312d
--- /dev/null
+++ b/src/window/icon.rs
@@ -0,0 +1,132 @@
+//! Attach an icon to the window of your application.
+use std::fmt;
+use std::io;
+
+/// The icon of a window.
+#[cfg(not(target_arch = "wasm32"))]
+#[derive(Debug, Clone)]
+pub struct Icon(iced_winit::winit::window::Icon);
+
+/// The icon of a window.
+#[cfg(target_arch = "wasm32")]
+#[derive(Debug, Clone)]
+pub struct Icon;
+
+impl Icon {
+    /// Creates an icon from 32bpp RGBA data.
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn from_rgba(
+        rgba: Vec<u8>,
+        width: u32,
+        height: u32,
+    ) -> Result<Self, Error> {
+        let raw =
+            iced_winit::winit::window::Icon::from_rgba(rgba, width, height)?;
+
+        Ok(Icon(raw))
+    }
+
+    /// Creates an icon from 32bpp RGBA data.
+    #[cfg(target_arch = "wasm32")]
+    pub fn from_rgba(
+        _rgba: Vec<u8>,
+        _width: u32,
+        _height: u32,
+    ) -> Result<Self, Error> {
+        Ok(Icon)
+    }
+}
+
+/// 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),
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl From<iced_winit::winit::window::BadIcon> for Error {
+    fn from(error: iced_winit::winit::window::BadIcon) -> Self {
+        use iced_winit::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),
+        }
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl From<Icon> for iced_winit::winit::window::Icon {
+    fn from(icon: Icon) -> Self {
+        icon.0
+    }
+}
+
+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{:?}).",
+                width, height, pixel_count,
+            )
+            }
+            Error::OsError(e) => write!(
+                f,
+                "The underlying OS failed to create the window \
+                icon: {:?}",
+                e
+            ),
+        }
+    }
+}
+
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        Some(self)
+    }
+}
diff --git a/src/window/settings.rs b/src/window/settings.rs
index a31d2af2..2046f2d9 100644
--- a/src/window/settings.rs
+++ b/src/window/settings.rs
@@ -1,22 +1,51 @@
+use crate::window::Icon;
+
 /// The window settings of an application.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone)]
 pub struct Settings {
-    /// The size of the window.
+    /// The initial size of the window.
     pub size: (u32, u32),
 
+    /// The minimum size of the window.
+    pub min_size: Option<(u32, u32)>,
+
+    /// The maximum size of the window.
+    pub max_size: Option<(u32, u32)>,
+
     /// Whether the window should be resizable or not.
     pub resizable: bool,
 
     /// Whether the window should have a border, a title bar, etc. or not.
     pub decorations: bool,
+
+    /// The icon of the window.
+    pub icon: Option<Icon>,
 }
 
 impl Default for Settings {
     fn default() -> Settings {
         Settings {
             size: (1024, 768),
+            min_size: None,
+            max_size: None,
             resizable: true,
             decorations: true,
+            icon: None,
+        }
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl From<Settings> for iced_winit::settings::Window {
+    fn from(settings: Settings) -> Self {
+        Self {
+            size: settings.size,
+            min_size: settings.min_size,
+            max_size: settings.max_size,
+            resizable: settings.resizable,
+            decorations: settings.decorations,
+            icon: settings.icon.map(Icon::into),
+            platform_specific: Default::default(),
         }
     }
 }