Merge branch 'master' into feature/shrink-by-default

native/src/layout/limits.rs

@@ -52,7 +52,7 @@ impl Limits {
             Length::Shrink => {
                 self.fill.width = self.min.width;
             }
-            Length::Fill => {
+            Length::Fill | Length::FillPortion(_) => {
                 self.fill.width = self.fill.width.min(self.max.width);
             }
             Length::Units(units) => {
@@ -76,7 +76,7 @@ impl Limits {
             Length::Shrink => {
                 self.fill.height = self.min.height;
             }
-            Length::Fill => {
+            Length::Fill | Length::FillPortion(_) => {
                 self.fill.height = self.fill.height.min(self.max.height);
             }
             Length::Units(units) => {

native/src/mouse_cursor.rs

@@ -22,3 +22,9 @@ pub enum MouseCursor {
     /// The cursor is over a text widget.
     Text,
 }
+
+impl Default for MouseCursor {
+    fn default() -> MouseCursor {
+        MouseCursor::OutOfBounds
+    }
+}

native/src/widget.rs

@@ -25,10 +25,12 @@ pub mod checkbox;
 pub mod column;
 pub mod container;
 pub mod image;
+pub mod progress_bar;
 pub mod radio;
 pub mod row;
 pub mod scrollable;
 pub mod slider;
+pub mod space;
 pub mod svg;
 pub mod text;
 pub mod text_input;
@@ -44,6 +46,8 @@ pub use container::Container;
 #[doc(no_inline)]
 pub use image::Image;
 #[doc(no_inline)]
+pub use progress_bar::ProgressBar;
+#[doc(no_inline)]
 pub use radio::Radio;
 #[doc(no_inline)]
 pub use row::Row;
@@ -52,6 +56,8 @@ pub use scrollable::Scrollable;
 #[doc(no_inline)]
 pub use slider::Slider;
 #[doc(no_inline)]
+pub use space::Space;
+#[doc(no_inline)]
 pub use svg::Svg;
 #[doc(no_inline)]
 pub use text::Text;

native/src/widget/progress_bar.rs

@@ -0,0 +1,173 @@
+//! Provide progress feedback to your users.
+use crate::{
+    layout, Background, Color, Element, Hasher, Layout, Length, Point,
+    Rectangle, Size, Widget,
+};
+
+use std::{hash::Hash, ops::RangeInclusive};
+
+/// A bar that displays progress.
+///
+/// # Example
+/// ```
+/// # use iced_native::ProgressBar;
+/// #
+/// let value = 50.0;
+///
+/// ProgressBar::new(0.0..=100.0, value);
+/// ```
+///
+/// ![Progress bar drawn with `iced_wgpu`](https://user-images.githubusercontent.com/18618951/71662391-a316c200-2d51-11ea-9cef-52758cab85e3.png)
+#[allow(missing_debug_implementations)]
+pub struct ProgressBar {
+    range: RangeInclusive<f32>,
+    value: f32,
+    width: Length,
+    height: Option<Length>,
+    background: Option<Background>,
+    active_color: Option<Color>,
+}
+
+impl ProgressBar {
+    /// Creates a new [`ProgressBar`].
+    ///
+    /// It expects:
+    ///   * an inclusive range of possible values
+    ///   * the current value of the [`ProgressBar`]
+    ///
+    /// [`ProgressBar`]: struct.ProgressBar.html
+    pub fn new(range: RangeInclusive<f32>, value: f32) -> Self {
+        ProgressBar {
+            value: value.max(*range.start()).min(*range.end()),
+            range,
+            width: Length::Fill,
+            height: None,
+            background: None,
+            active_color: None,
+        }
+    }
+
+    /// Sets the width of the [`ProgressBar`].
+    ///
+    /// [`ProgressBar`]: struct.ProgressBar.html
+    pub fn width(mut self, width: Length) -> Self {
+        self.width = width;
+        self
+    }
+
+    /// Sets the height of the [`ProgressBar`].
+    ///
+    /// [`ProgressBar`]: struct.ProgressBar.html
+    pub fn height(mut self, height: Length) -> Self {
+        self.height = Some(height);
+        self
+    }
+
+    /// Sets the background of the [`ProgressBar`].
+    ///
+    /// [`ProgressBar`]: struct.ProgressBar.html
+    pub fn background(mut self, background: Background) -> Self {
+        self.background = Some(background);
+        self
+    }
+
+    /// Sets the active color of the [`ProgressBar`].
+    ///
+    /// [`ProgressBar`]: struct.ProgressBar.html
+    pub fn active_color(mut self, active_color: Color) -> Self {
+        self.active_color = Some(active_color);
+        self
+    }
+}
+
+impl<Message, Renderer> Widget<Message, Renderer> for ProgressBar
+where
+    Renderer: self::Renderer,
+{
+    fn width(&self) -> Length {
+        self.width
+    }
+
+    fn height(&self) -> Length {
+        self.height
+            .unwrap_or(Length::Units(Renderer::DEFAULT_HEIGHT))
+    }
+
+    fn layout(
+        &self,
+        _renderer: &Renderer,
+        limits: &layout::Limits,
+    ) -> layout::Node {
+        let limits = limits.width(self.width).height(
+            self.height
+                .unwrap_or(Length::Units(Renderer::DEFAULT_HEIGHT)),
+        );
+
+        let size = limits.resolve(Size::ZERO);
+
+        layout::Node::new(size)
+    }
+
+    fn draw(
+        &self,
+        renderer: &mut Renderer,
+        layout: Layout<'_>,
+        _cursor_position: Point,
+    ) -> Renderer::Output {
+        renderer.draw(
+            layout.bounds(),
+            self.range.clone(),
+            self.value,
+            self.background,
+            self.active_color,
+        )
+    }
+
+    fn hash_layout(&self, state: &mut Hasher) {
+        self.width.hash(state);
+        self.height.hash(state);
+    }
+}
+
+/// The renderer of a [`ProgressBar`].
+///
+/// Your [renderer] will need to implement this trait before being
+/// able to use a [`ProgressBar`] in your user interface.
+///
+/// [`ProgressBar`]: struct.ProgressBar.html
+/// [renderer]: ../../renderer/index.html
+pub trait Renderer: crate::Renderer {
+    /// The default height of a [`ProgressBar`].
+    ///
+    /// [`ProgressBar`]: struct.ProgressBar.html
+    const DEFAULT_HEIGHT: u16;
+
+    /// Draws a [`ProgressBar`].
+    ///
+    /// It receives:
+    ///   * the bounds of the [`ProgressBar`]
+    ///   * the range of values of the [`ProgressBar`]
+    ///   * the current value of the [`ProgressBar`]
+    ///   * maybe a specific background of the [`ProgressBar`]
+    ///   * maybe a specific active color of the [`ProgressBar`]
+    ///
+    /// [`ProgressBar`]: struct.ProgressBar.html
+    fn draw(
+        &self,
+        bounds: Rectangle,
+        range: RangeInclusive<f32>,
+        value: f32,
+        background: Option<Background>,
+        active_color: Option<Color>,
+    ) -> Self::Output;
+}
+
+impl<'a, Message, Renderer> From<ProgressBar> for Element<'a, Message, Renderer>
+where
+    Renderer: self::Renderer,
+    Message: 'static,
+{
+    fn from(progress_bar: ProgressBar) -> Element<'a, Message, Renderer> {
+        Element::new(progress_bar)
+    }
+}

native/src/widget/space.rs

@@ -0,0 +1,104 @@
+//! Distribute content vertically.
+use std::hash::Hash;
+
+use crate::{
+    layout, Element, Hasher, Layout, Length, Point, Rectangle, Size, Widget,
+};
+
+/// An amount of empty space.
+///
+/// It can be useful if you want to fill some space with nothing.
+#[derive(Debug)]
+pub struct Space {
+    width: Length,
+    height: Length,
+}
+
+impl Space {
+    /// Creates an amount of empty [`Space`] with the given width and height.
+    ///
+    /// [`Space`]: struct.Space.html
+    pub fn new(width: Length, height: Length) -> Self {
+        Space { width, height }
+    }
+
+    /// Creates an amount of horizontal [`Space`].
+    ///
+    /// [`Space`]: struct.Space.html
+    pub fn with_width(width: Length) -> Self {
+        Space {
+            width,
+            height: Length::Shrink,
+        }
+    }
+
+    /// Creates an amount of vertical [`Space`].
+    ///
+    /// [`Space`]: struct.Space.html
+    pub fn with_height(height: Length) -> Self {
+        Space {
+            width: Length::Shrink,
+            height,
+        }
+    }
+}
+
+impl<'a, Message, Renderer> Widget<Message, Renderer> for Space
+where
+    Renderer: self::Renderer,
+{
+    fn width(&self) -> Length {
+        self.width
+    }
+
+    fn height(&self) -> Length {
+        self.height
+    }
+
+    fn layout(
+        &self,
+        _renderer: &Renderer,
+        limits: &layout::Limits,
+    ) -> layout::Node {
+        let limits = limits.width(self.width).height(self.height);
+
+        layout::Node::new(limits.resolve(Size::ZERO))
+    }
+
+    fn draw(
+        &self,
+        renderer: &mut Renderer,
+        layout: Layout<'_>,
+        _cursor_position: Point,
+    ) -> Renderer::Output {
+        renderer.draw(layout.bounds())
+    }
+
+    fn hash_layout(&self, state: &mut Hasher) {
+        std::any::TypeId::of::<Space>().hash(state);
+        self.width.hash(state);
+        self.height.hash(state);
+    }
+}
+
+/// The renderer of an amount of [`Space`].
+///
+/// [`Space`]: struct.Space.html
+pub trait Renderer: crate::Renderer {
+    /// Draws an amount of empty [`Space`].
+    ///
+    /// You should most likely return an empty primitive here.
+    ///
+    /// [`Space`]: struct.Space.html
+    fn draw(&mut self, bounds: Rectangle) -> Self::Output;
+}
+
+impl<'a, Message, Renderer> From<Space> for Element<'a, Message, Renderer>
+where
+    Renderer: self::Renderer,
+    Message: 'static,
+{
+    fn from(space: Space) -> Element<'a, Message, Renderer> {
+        Element::new(space)
+    }
+}

native/src/widget/text_input.rs

@@ -633,7 +633,8 @@ impl Value {
             .unwrap_or(self.len())
     }
 
-    /// Returns a new [`Value`] containing the graphemes until the given `index`.
+    /// Returns a new [`Value`] containing the graphemes until the given
+    /// `index`.
     ///
     /// [`Value`]: struct.Value.html
     pub fn until(&self, index: usize) -> Self {