From 3c866c15aa1db944a2056f01449a2fbdda2f5abb Mon Sep 17 00:00:00 2001
From: Cory Forsstrom <cforsstrom18@gmail.com>
Date: Tue, 17 Jan 2023 10:01:17 -0800
Subject: Add group overlay element

---
 native/src/overlay.rs       |   2 +
 native/src/overlay/group.rs | 165 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 167 insertions(+)
 create mode 100644 native/src/overlay/group.rs

(limited to 'native')

diff --git a/native/src/overlay.rs b/native/src/overlay.rs
index 22f8b6ec..0b1e8daf 100644
--- a/native/src/overlay.rs
+++ b/native/src/overlay.rs
@@ -1,9 +1,11 @@
 //! Display interactive elements on top of other widgets.
 mod element;
+mod group;
 
 pub mod menu;
 
 pub use element::Element;
+pub use group::Group;
 pub use menu::Menu;
 
 use crate::event::{self, Event};
diff --git a/native/src/overlay/group.rs b/native/src/overlay/group.rs
new file mode 100644
index 00000000..f894f911
--- /dev/null
+++ b/native/src/overlay/group.rs
@@ -0,0 +1,165 @@
+use iced_core::{Point, Rectangle, Size};
+
+use crate::event;
+use crate::layout;
+use crate::mouse;
+use crate::overlay;
+use crate::renderer;
+use crate::widget;
+use crate::{Clipboard, Event, Layout, Overlay, Shell};
+
+/// An [`Overlay`] container that displays multiple overlay
+/// [`overlay::Element`] children
+#[allow(missing_debug_implementations)]
+pub struct Group<'a, Message, Renderer> {
+    children: Vec<overlay::Element<'a, Message, Renderer>>,
+}
+
+impl<'a, Message, Renderer> Group<'a, Message, Renderer>
+where
+    Renderer: 'a + crate::Renderer,
+    Message: 'a,
+{
+    /// Creates an empty [`Group`].
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Creates a [`Group`] with the given elements.
+    pub fn with_children(
+        children: Vec<overlay::Element<'a, Message, Renderer>>,
+    ) -> Self {
+        Group { children }
+    }
+
+    /// Adds an [`overlay::Element`] to the [`Group`].
+    pub fn push(
+        mut self,
+        child: impl Into<overlay::Element<'a, Message, Renderer>>,
+    ) -> Self {
+        self.children.push(child.into());
+        self
+    }
+
+    /// Turns the [`Group`] into an overlay [`overlay::Element`]
+    pub fn overlay(self) -> overlay::Element<'a, Message, Renderer> {
+        overlay::Element::new(Point::ORIGIN, Box::new(self))
+    }
+}
+
+impl<'a, Message, Renderer> Default for Group<'a, Message, Renderer>
+where
+    Renderer: 'a + crate::Renderer,
+    Message: 'a,
+{
+    fn default() -> Self {
+        Self::with_children(Vec::new())
+    }
+}
+
+impl<'a, Message, Renderer> Overlay<Message, Renderer>
+    for Group<'a, Message, Renderer>
+where
+    Renderer: crate::Renderer,
+{
+    fn layout(
+        &self,
+        renderer: &Renderer,
+        bounds: Size,
+        _position: Point,
+    ) -> layout::Node {
+        layout::Node::with_children(
+            bounds,
+            self.children
+                .iter()
+                .map(|child| child.layout(renderer, bounds))
+                .collect(),
+        )
+    }
+
+    fn on_event(
+        &mut self,
+        event: Event,
+        layout: Layout<'_>,
+        cursor_position: Point,
+        renderer: &Renderer,
+        clipboard: &mut dyn Clipboard,
+        shell: &mut Shell<'_, Message>,
+    ) -> event::Status {
+        self.children
+            .iter_mut()
+            .zip(layout.children())
+            .map(|(child, layout)| {
+                child.on_event(
+                    event.clone(),
+                    layout,
+                    cursor_position,
+                    renderer,
+                    clipboard,
+                    shell,
+                )
+            })
+            .fold(event::Status::Ignored, event::Status::merge)
+    }
+
+    fn draw(
+        &self,
+        renderer: &mut Renderer,
+        theme: &<Renderer as crate::Renderer>::Theme,
+        style: &renderer::Style,
+        layout: Layout<'_>,
+        cursor_position: Point,
+    ) {
+        for (child, layout) in self.children.iter().zip(layout.children()) {
+            child.draw(renderer, theme, style, layout, cursor_position);
+        }
+    }
+
+    fn mouse_interaction(
+        &self,
+        layout: Layout<'_>,
+        cursor_position: Point,
+        viewport: &Rectangle,
+        renderer: &Renderer,
+    ) -> mouse::Interaction {
+        self.children
+            .iter()
+            .zip(layout.children())
+            .map(|(child, layout)| {
+                child.mouse_interaction(
+                    layout,
+                    cursor_position,
+                    viewport,
+                    renderer,
+                )
+            })
+            .max()
+            .unwrap_or_default()
+    }
+
+    fn operate(
+        &mut self,
+        layout: Layout<'_>,
+        renderer: &Renderer,
+        operation: &mut dyn widget::Operation<Message>,
+    ) {
+        operation.container(None, &mut |operation| {
+            self.children.iter_mut().zip(layout.children()).for_each(
+                |(child, layout)| {
+                    child.operate(layout, renderer, operation);
+                },
+            )
+        });
+    }
+}
+
+impl<'a, Message, Renderer> From<Group<'a, Message, Renderer>>
+    for overlay::Element<'a, Message, Renderer>
+where
+    Renderer: 'a + crate::Renderer,
+    Message: 'a,
+{
+    fn from(group: Group<'a, Message, Renderer>) -> Self {
+        group.overlay()
+    }
+}
-- 
cgit 


From b2a3a85acb2a0722e90c46b70d574f1d676da9d1 Mon Sep 17 00:00:00 2001
From: Cory Forsstrom <cforsstrom18@gmail.com>
Date: Tue, 17 Jan 2023 10:12:51 -0800
Subject: Use group overlay for containers w/ children

---
 native/src/overlay.rs          |  8 +++++---
 native/src/widget/pane_grid.rs | 13 ++++++++-----
 2 files changed, 13 insertions(+), 8 deletions(-)

(limited to 'native')

diff --git a/native/src/overlay.rs b/native/src/overlay.rs
index 0b1e8daf..e7394494 100644
--- a/native/src/overlay.rs
+++ b/native/src/overlay.rs
@@ -91,7 +91,7 @@ where
     }
 }
 
-/// Obtains the first overlay [`Element`] found in the given children.
+/// Returns a [`Group`] of overlay [`Element`] children.
 ///
 /// This method will generally only be used by advanced users that are
 /// implementing the [`Widget`](crate::Widget) trait.
@@ -104,12 +104,14 @@ pub fn from_children<'a, Message, Renderer>(
 where
     Renderer: crate::Renderer,
 {
-    children
+    let children = children
         .iter_mut()
         .zip(&mut tree.children)
         .zip(layout.children())
         .filter_map(|((child, state), layout)| {
             child.as_widget_mut().overlay(state, layout, renderer)
         })
-        .next()
+        .collect::<Vec<_>>();
+
+    (!children.is_empty()).then(|| Group::with_children(children).overlay())
 }
diff --git a/native/src/widget/pane_grid.rs b/native/src/widget/pane_grid.rs
index 8dbd1825..eb04c0ba 100644
--- a/native/src/widget/pane_grid.rs
+++ b/native/src/widget/pane_grid.rs
@@ -35,7 +35,7 @@ pub use iced_style::pane_grid::{Line, StyleSheet};
 use crate::event::{self, Event};
 use crate::layout;
 use crate::mouse;
-use crate::overlay;
+use crate::overlay::{self, Group};
 use crate::renderer;
 use crate::touch;
 use crate::widget;
@@ -450,14 +450,17 @@ where
         layout: Layout<'_>,
         renderer: &Renderer,
     ) -> Option<overlay::Element<'_, Message, Renderer>> {
-        self.contents
+        let children = self
+            .contents
             .iter_mut()
             .zip(&mut tree.children)
             .zip(layout.children())
-            .filter_map(|(((_, pane), tree), layout)| {
-                pane.overlay(tree, layout, renderer)
+            .filter_map(|(((_, content), state), layout)| {
+                content.overlay(state, layout, renderer)
             })
-            .next()
+            .collect::<Vec<_>>();
+
+        (!children.is_empty()).then(|| Group::with_children(children).overlay())
     }
 }
 
-- 
cgit 


From 3ab679725526bd095cc1a160705312b16c408b92 Mon Sep 17 00:00:00 2001
From: Cory Forsstrom <cforsstrom18@gmail.com>
Date: Tue, 17 Jan 2023 11:12:10 -0800
Subject: New method to determine if overlay contains cursor

This is needed for "container" overlay's such as `Group` which should
only consider it's childrens layouts and not it's own when determining
if the cursor is captured by the overlay.
---
 native/src/overlay.rs         |  9 +++++++++
 native/src/overlay/element.rs | 17 +++++++++++++++++
 native/src/overlay/group.rs   | 13 +++++++++++++
 native/src/user_interface.rs  | 11 +++++++++--
 4 files changed, 48 insertions(+), 2 deletions(-)

(limited to 'native')

diff --git a/native/src/overlay.rs b/native/src/overlay.rs
index e7394494..16d8bb31 100644
--- a/native/src/overlay.rs
+++ b/native/src/overlay.rs
@@ -89,6 +89,15 @@ where
     ) -> mouse::Interaction {
         mouse::Interaction::Idle
     }
+
+    /// Whether the [`Overlay`] contains the cursor
+    fn contains_cursor(
+        &self,
+        layout: Layout<'_>,
+        cursor_position: Point,
+    ) -> bool {
+        layout.bounds().contains(cursor_position)
+    }
 }
 
 /// Returns a [`Group`] of overlay [`Element`] children.
diff --git a/native/src/overlay/element.rs b/native/src/overlay/element.rs
index 41a8a597..125258c5 100644
--- a/native/src/overlay/element.rs
+++ b/native/src/overlay/element.rs
@@ -115,6 +115,15 @@ where
     ) {
         self.overlay.operate(layout, renderer, operation);
     }
+
+    /// Whether the [`Overlay`] contains the cursor
+    pub fn contains_cursor(
+        &self,
+        layout: Layout<'_>,
+        cursor_position: Point,
+    ) -> bool {
+        self.overlay.contains_cursor(layout, cursor_position)
+    }
 }
 
 struct Map<'a, A, B, Renderer> {
@@ -252,4 +261,12 @@ where
         self.content
             .draw(renderer, theme, style, layout, cursor_position)
     }
+
+    fn contains_cursor(
+        &self,
+        layout: Layout<'_>,
+        cursor_position: Point,
+    ) -> bool {
+        self.content.contains_cursor(layout, cursor_position)
+    }
 }
diff --git a/native/src/overlay/group.rs b/native/src/overlay/group.rs
index f894f911..96d10c19 100644
--- a/native/src/overlay/group.rs
+++ b/native/src/overlay/group.rs
@@ -151,6 +151,19 @@ where
             )
         });
     }
+
+    fn contains_cursor(
+        &self,
+        layout: Layout<'_>,
+        cursor_position: Point,
+    ) -> bool {
+        self.children
+            .iter()
+            .zip(layout.children())
+            .any(|(child, layout)| {
+                child.contains_cursor(layout, cursor_position)
+            })
+    }
 }
 
 impl<'a, Message, Renderer> From<Group<'a, Message, Renderer>>
diff --git a/native/src/user_interface.rs b/native/src/user_interface.rs
index 29cc3472..8659caa3 100644
--- a/native/src/user_interface.rs
+++ b/native/src/user_interface.rs
@@ -261,7 +261,11 @@ where
                 }
             }
 
-            let base_cursor = if layout.bounds().contains(cursor_position) {
+            let base_cursor = if manual_overlay
+                .as_ref()
+                .unwrap()
+                .contains_cursor(Layout::new(&layout), cursor_position)
+            {
                 // TODO: Type-safe cursor availability
                 Point::new(-1.0, -1.0)
             } else {
@@ -504,7 +508,10 @@ where
                             );
                         });
 
-                        if overlay_bounds.contains(cursor_position) {
+                        if overlay.contains_cursor(
+                            Layout::new(layout),
+                            cursor_position,
+                        ) {
                             overlay_interaction
                         } else {
                             base_interaction
-- 
cgit 


From d470467718ecad0f37599a811bef846846dbb2b9 Mon Sep 17 00:00:00 2001
From: Cory Forsstrom <cforsstrom18@gmail.com>
Date: Tue, 17 Jan 2023 17:10:58 -0800
Subject: Add toast example

---
 native/src/shell.rs | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'native')

diff --git a/native/src/shell.rs b/native/src/shell.rs
index f1ddb48e..74a5c616 100644
--- a/native/src/shell.rs
+++ b/native/src/shell.rs
@@ -25,6 +25,11 @@ impl<'a, Message> Shell<'a, Message> {
         }
     }
 
+    /// Returns true if the [`Shell`] contains no published messages
+    pub fn is_empty(&self) -> bool {
+        self.messages.is_empty()
+    }
+
     /// Publish the given `Message` for an application to process it.
     pub fn publish(&mut self, message: Message) {
         self.messages.push(message);
-- 
cgit 


From be860508a9deed1f4583e045790eb9ddd74d07d5 Mon Sep 17 00:00:00 2001
From: Cory Forsstrom <cforsstrom18@gmail.com>
Date: Tue, 17 Jan 2023 17:20:53 -0800
Subject: Rename method to is_over

---
 native/src/overlay.rs         |  8 ++------
 native/src/overlay/element.rs | 18 +++++-------------
 native/src/overlay/group.rs   | 10 ++--------
 native/src/user_interface.rs  |  8 +++-----
 4 files changed, 12 insertions(+), 32 deletions(-)

(limited to 'native')

diff --git a/native/src/overlay.rs b/native/src/overlay.rs
index 16d8bb31..1c3d0fb9 100644
--- a/native/src/overlay.rs
+++ b/native/src/overlay.rs
@@ -90,12 +90,8 @@ where
         mouse::Interaction::Idle
     }
 
-    /// Whether the [`Overlay`] contains the cursor
-    fn contains_cursor(
-        &self,
-        layout: Layout<'_>,
-        cursor_position: Point,
-    ) -> bool {
+    /// Returns true if the cursor is over the [`Overlay`]
+    fn is_over(&self, layout: Layout<'_>, cursor_position: Point) -> bool {
         layout.bounds().contains(cursor_position)
     }
 }
diff --git a/native/src/overlay/element.rs b/native/src/overlay/element.rs
index 125258c5..edeb7dbf 100644
--- a/native/src/overlay/element.rs
+++ b/native/src/overlay/element.rs
@@ -116,13 +116,9 @@ where
         self.overlay.operate(layout, renderer, operation);
     }
 
-    /// Whether the [`Overlay`] contains the cursor
-    pub fn contains_cursor(
-        &self,
-        layout: Layout<'_>,
-        cursor_position: Point,
-    ) -> bool {
-        self.overlay.contains_cursor(layout, cursor_position)
+    /// Returns true if the cursor is over the [`Element`]
+    pub fn is_over(&self, layout: Layout<'_>, cursor_position: Point) -> bool {
+        self.overlay.is_over(layout, cursor_position)
     }
 }
 
@@ -262,11 +258,7 @@ where
             .draw(renderer, theme, style, layout, cursor_position)
     }
 
-    fn contains_cursor(
-        &self,
-        layout: Layout<'_>,
-        cursor_position: Point,
-    ) -> bool {
-        self.content.contains_cursor(layout, cursor_position)
+    fn is_over(&self, layout: Layout<'_>, cursor_position: Point) -> bool {
+        self.content.is_over(layout, cursor_position)
     }
 }
diff --git a/native/src/overlay/group.rs b/native/src/overlay/group.rs
index 96d10c19..fa3c7396 100644
--- a/native/src/overlay/group.rs
+++ b/native/src/overlay/group.rs
@@ -152,17 +152,11 @@ where
         });
     }
 
-    fn contains_cursor(
-        &self,
-        layout: Layout<'_>,
-        cursor_position: Point,
-    ) -> bool {
+    fn is_over(&self, layout: Layout<'_>, cursor_position: Point) -> bool {
         self.children
             .iter()
             .zip(layout.children())
-            .any(|(child, layout)| {
-                child.contains_cursor(layout, cursor_position)
-            })
+            .any(|(child, layout)| child.is_over(layout, cursor_position))
     }
 }
 
diff --git a/native/src/user_interface.rs b/native/src/user_interface.rs
index 8659caa3..0def730c 100644
--- a/native/src/user_interface.rs
+++ b/native/src/user_interface.rs
@@ -264,7 +264,7 @@ where
             let base_cursor = if manual_overlay
                 .as_ref()
                 .unwrap()
-                .contains_cursor(Layout::new(&layout), cursor_position)
+                .is_over(Layout::new(&layout), cursor_position)
             {
                 // TODO: Type-safe cursor availability
                 Point::new(-1.0, -1.0)
@@ -508,10 +508,8 @@ where
                             );
                         });
 
-                        if overlay.contains_cursor(
-                            Layout::new(layout),
-                            cursor_position,
-                        ) {
+                        if overlay.is_over(Layout::new(layout), cursor_position)
+                        {
                             overlay_interaction
                         } else {
                             base_interaction
-- 
cgit 


From 01c484245be54c1aeb6605659fb0f222856c28da Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Tue, 24 Jan 2023 01:59:34 +0100
Subject: Fix some minor documentation inconsistencies

---
 native/src/overlay.rs         | 5 ++++-
 native/src/overlay/element.rs | 2 +-
 native/src/overlay/group.rs   | 6 +++---
 3 files changed, 8 insertions(+), 5 deletions(-)

(limited to 'native')

diff --git a/native/src/overlay.rs b/native/src/overlay.rs
index 1c3d0fb9..6cada416 100644
--- a/native/src/overlay.rs
+++ b/native/src/overlay.rs
@@ -90,7 +90,10 @@ where
         mouse::Interaction::Idle
     }
 
-    /// Returns true if the cursor is over the [`Overlay`]
+    /// Returns true if the cursor is over the [`Overlay`].
+    ///
+    /// By default, it returns true if the bounds of the `layout` contain
+    /// the `cursor_position`.
     fn is_over(&self, layout: Layout<'_>, cursor_position: Point) -> bool {
         layout.bounds().contains(cursor_position)
     }
diff --git a/native/src/overlay/element.rs b/native/src/overlay/element.rs
index edeb7dbf..bdf7766e 100644
--- a/native/src/overlay/element.rs
+++ b/native/src/overlay/element.rs
@@ -116,7 +116,7 @@ where
         self.overlay.operate(layout, renderer, operation);
     }
 
-    /// Returns true if the cursor is over the [`Element`]
+    /// Returns true if the cursor is over the [`Element`].
     pub fn is_over(&self, layout: Layout<'_>, cursor_position: Point) -> bool {
         self.overlay.is_over(layout, cursor_position)
     }
diff --git a/native/src/overlay/group.rs b/native/src/overlay/group.rs
index fa3c7396..5c9cf809 100644
--- a/native/src/overlay/group.rs
+++ b/native/src/overlay/group.rs
@@ -8,8 +8,8 @@ use crate::renderer;
 use crate::widget;
 use crate::{Clipboard, Event, Layout, Overlay, Shell};
 
-/// An [`Overlay`] container that displays multiple overlay
-/// [`overlay::Element`] children
+/// An [`Overlay`] container that displays multiple overlay [`overlay::Element`]
+/// children.
 #[allow(missing_debug_implementations)]
 pub struct Group<'a, Message, Renderer> {
     children: Vec<overlay::Element<'a, Message, Renderer>>,
@@ -41,7 +41,7 @@ where
         self
     }
 
-    /// Turns the [`Group`] into an overlay [`overlay::Element`]
+    /// Turns the [`Group`] into an overlay [`overlay::Element`].
     pub fn overlay(self) -> overlay::Element<'a, Message, Renderer> {
         overlay::Element::new(Point::ORIGIN, Box::new(self))
     }
-- 
cgit 


From 2e4aefa7fc19e4d66152332d28baafe1349c1636 Mon Sep 17 00:00:00 2001
From: Ian Douglas Scott <idscott@system76.com>
Date: Thu, 26 Jan 2023 16:10:45 -0800
Subject: Annotate `Command` and `Subscription` with `#[must_use]`

Calling a function returning one of these types without using it is
almost certainly a mistake. Luckily Rust's `#[must_use]` can help warn
about this.
---
 native/src/command.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'native')

diff --git a/native/src/command.rs b/native/src/command.rs
index 89ee7375..ca9d0b64 100644
--- a/native/src/command.rs
+++ b/native/src/command.rs
@@ -11,6 +11,7 @@ use std::fmt;
 use std::future::Future;
 
 /// A set of asynchronous actions to be performed by some runtime.
+#[must_use = "`Command` must be returned to runtime to take effect"]
 pub struct Command<T>(iced_futures::Command<Action<T>>);
 
 impl<T> Command<T> {
-- 
cgit 


From d2008eed47ced61937fafbec19978291397389e0 Mon Sep 17 00:00:00 2001
From: frey <frey@users.noreply.github.com>
Date: Thu, 26 Jan 2023 20:39:47 -0600
Subject: Mapped operations is missing text_input()...

This fixes a bug where some operations could be dropped.
---
 native/src/widget/action.rs | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

(limited to 'native')

diff --git a/native/src/widget/action.rs b/native/src/widget/action.rs
index 1e21ff38..3f1b6b6c 100644
--- a/native/src/widget/action.rs
+++ b/native/src/widget/action.rs
@@ -1,4 +1,6 @@
-use crate::widget::operation::{self, Focusable, Operation, Scrollable};
+use crate::widget::operation::{
+    self, Focusable, Operation, Scrollable, TextInput,
+};
 use crate::widget::Id;
 
 use iced_futures::MaybeSend;
@@ -86,6 +88,14 @@ where
                 self.operation.focusable(state, id);
             }
 
+            fn text_input(
+                &mut self,
+                state: &mut dyn TextInput,
+                id: Option<&Id>,
+            ) {
+                self.operation.text_input(state, id);
+            }
+
             fn custom(&mut self, state: &mut dyn Any, id: Option<&Id>) {
                 self.operation.custom(state, id);
             }
-- 
cgit 


From 5bc37f10e2a325c543860d21b658734a590dd725 Mon Sep 17 00:00:00 2001
From: Casper Storm <casper.storm@lich.io>
Date: Fri, 27 Jan 2023 10:21:57 +0100
Subject: Fixed a small pixel width issue on `pick_list`

---
 native/src/overlay/menu.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

(limited to 'native')

diff --git a/native/src/overlay/menu.rs b/native/src/overlay/menu.rs
index 099b1a97..9e37380f 100644
--- a/native/src/overlay/menu.rs
+++ b/native/src/overlay/menu.rs
@@ -281,10 +281,7 @@ where
 
         renderer.fill_quad(
             renderer::Quad {
-                bounds: Rectangle {
-                    width: bounds.width - 1.0,
-                    ..bounds
-                },
+                bounds,
                 border_color: appearance.border_color,
                 border_width: appearance.border_width,
                 border_radius: appearance.border_radius.into(),
-- 
cgit 


From e6092e81a42efe0bbaaad2e7ce475c25a379e672 Mon Sep 17 00:00:00 2001
From: 13r0ck <brock@szu.email>
Date: Fri, 27 Jan 2023 13:37:32 -0700
Subject: Fix: Clippy lint 'needless_lifetimes'

---
 native/src/renderer.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'native')

diff --git a/native/src/renderer.rs b/native/src/renderer.rs
index d5329acd..2ac78982 100644
--- a/native/src/renderer.rs
+++ b/native/src/renderer.rs
@@ -16,9 +16,9 @@ pub trait Renderer: Sized {
     ///
     /// You should override this if you need to perform any operations before or
     /// after layouting. For instance, trimming the measurements cache.
-    fn layout<'a, Message>(
+    fn layout<Message>(
         &mut self,
-        element: &Element<'a, Message, Self>,
+        element: &Element<'_, Message, Self>,
         limits: &layout::Limits,
     ) -> layout::Node {
         element.as_widget().layout(self, limits)
-- 
cgit 


From 42b1bfe66d2407901c1ae640f80ce9e0d3c64b60 Mon Sep 17 00:00:00 2001
From: 13r0ck <brock@szu.email>
Date: Fri, 27 Jan 2023 13:25:04 -0700
Subject: Fix: Clippy lint 'uninlined_format_args'

---
 native/src/command/action.rs   |  6 +++---
 native/src/debug/basic.rs      |  8 ++++----
 native/src/image.rs            |  4 ++--
 native/src/svg.rs              |  2 +-
 native/src/widget/operation.rs |  2 +-
 native/src/window/action.rs    | 11 +++++------
 6 files changed, 16 insertions(+), 17 deletions(-)

(limited to 'native')

diff --git a/native/src/command/action.rs b/native/src/command/action.rs
index a6954f8f..a51b8c21 100644
--- a/native/src/command/action.rs
+++ b/native/src/command/action.rs
@@ -58,10 +58,10 @@ impl<T> fmt::Debug for Action<T> {
         match self {
             Self::Future(_) => write!(f, "Action::Future"),
             Self::Clipboard(action) => {
-                write!(f, "Action::Clipboard({:?})", action)
+                write!(f, "Action::Clipboard({action:?})")
             }
-            Self::Window(action) => write!(f, "Action::Window({:?})", action),
-            Self::System(action) => write!(f, "Action::System({:?})", action),
+            Self::Window(action) => write!(f, "Action::Window({action:?})"),
+            Self::System(action) => write!(f, "Action::System({action:?})"),
             Self::Widget(_action) => write!(f, "Action::Widget"),
         }
     }
diff --git a/native/src/debug/basic.rs b/native/src/debug/basic.rs
index 603f2fd5..92f614da 100644
--- a/native/src/debug/basic.rs
+++ b/native/src/debug/basic.rs
@@ -133,7 +133,7 @@ impl Debug {
     }
 
     pub fn log_message<Message: std::fmt::Debug>(&mut self, message: &Message) {
-        self.last_messages.push_back(format!("{:?}", message));
+        self.last_messages.push_back(format!("{message:?}"));
 
         if self.last_messages.len() > 10 {
             let _ = self.last_messages.pop_front();
@@ -150,7 +150,7 @@ impl Debug {
         let mut lines = Vec::new();
 
         fn key_value<T: std::fmt::Debug>(key: &str, value: T) -> String {
-            format!("{} {:?}", key, value)
+            format!("{key} {value:?}")
         }
 
         lines.push(format!(
@@ -176,9 +176,9 @@ impl Debug {
         lines.push(String::from("Last messages:"));
         lines.extend(self.last_messages.iter().map(|msg| {
             if msg.len() <= 100 {
-                format!("    {}", msg)
+                format!("    {msg}")
             } else {
-                format!("    {:.100}...", msg)
+                format!("    {msg:.100}...")
             }
         }));
 
diff --git a/native/src/image.rs b/native/src/image.rs
index 06fd7ae6..5d2843c9 100644
--- a/native/src/image.rs
+++ b/native/src/image.rs
@@ -107,10 +107,10 @@ pub enum Data {
 impl std::fmt::Debug for Data {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Data::Path(path) => write!(f, "Path({:?})", path),
+            Data::Path(path) => write!(f, "Path({path:?})"),
             Data::Bytes(_) => write!(f, "Bytes(...)"),
             Data::Rgba { width, height, .. } => {
-                write!(f, "Pixels({} * {})", width, height)
+                write!(f, "Pixels({width} * {height})")
             }
         }
     }
diff --git a/native/src/svg.rs b/native/src/svg.rs
index 2168e409..9b98877a 100644
--- a/native/src/svg.rs
+++ b/native/src/svg.rs
@@ -71,7 +71,7 @@ pub enum Data {
 impl std::fmt::Debug for Data {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Data::Path(path) => write!(f, "Path({:?})", path),
+            Data::Path(path) => write!(f, "Path({path:?})"),
             Data::Bytes(_) => write!(f, "Bytes(...)"),
         }
     }
diff --git a/native/src/widget/operation.rs b/native/src/widget/operation.rs
index 73e6a6b0..53688a21 100644
--- a/native/src/widget/operation.rs
+++ b/native/src/widget/operation.rs
@@ -62,7 +62,7 @@ where
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Self::None => write!(f, "Outcome::None"),
-            Self::Some(output) => write!(f, "Outcome::Some({:?})", output),
+            Self::Some(output) => write!(f, "Outcome::Some({output:?})"),
             Self::Chain(_) => write!(f, "Outcome::Chain(...)"),
         }
     }
diff --git a/native/src/window/action.rs b/native/src/window/action.rs
index 37fcc273..525434e4 100644
--- a/native/src/window/action.rs
+++ b/native/src/window/action.rs
@@ -106,15 +106,14 @@ impl<T> fmt::Debug for Action<T> {
             Self::Drag => write!(f, "Action::Drag"),
             Self::Resize { width, height } => write!(
                 f,
-                "Action::Resize {{ widget: {}, height: {} }}",
-                width, height
+                "Action::Resize {{ widget: {width}, height: {height} }}"
             ),
-            Self::Maximize(value) => write!(f, "Action::Maximize({})", value),
-            Self::Minimize(value) => write!(f, "Action::Minimize({}", value),
+            Self::Maximize(value) => write!(f, "Action::Maximize({value})"),
+            Self::Minimize(value) => write!(f, "Action::Minimize({value}"),
             Self::Move { x, y } => {
-                write!(f, "Action::Move {{ x: {}, y: {} }}", x, y)
+                write!(f, "Action::Move {{ x: {x}, y: {y} }}")
             }
-            Self::SetMode(mode) => write!(f, "Action::SetMode({:?})", mode),
+            Self::SetMode(mode) => write!(f, "Action::SetMode({mode:?})"),
             Self::FetchMode(_) => write!(f, "Action::FetchMode"),
             Self::ToggleMaximize => write!(f, "Action::ToggleMaximize"),
             Self::ToggleDecorations => write!(f, "Action::ToggleDecorations"),
-- 
cgit 


From 7356f2b68d6716699990fb9c6e053debcbf781ae Mon Sep 17 00:00:00 2001
From: Cory Forsstrom <cforsstrom18@gmail.com>
Date: Sat, 28 Jan 2023 18:41:33 -0800
Subject: Refactor image draw to standalone function

---
 native/src/widget/image.rs | 68 +++++++++++++++++++++++++++-------------------
 1 file changed, 40 insertions(+), 28 deletions(-)

(limited to 'native')

diff --git a/native/src/widget/image.rs b/native/src/widget/image.rs
index 8bd8ca1e..3ff06a76 100644
--- a/native/src/widget/image.rs
+++ b/native/src/widget/image.rs
@@ -111,6 +111,45 @@ where
     layout::Node::new(final_size)
 }
 
+/// Draws an [`Image`]
+pub fn draw<Renderer, Handle>(
+    renderer: &mut Renderer,
+    layout: Layout<'_>,
+    handle: &Handle,
+    content_fit: ContentFit,
+) where
+    Renderer: image::Renderer<Handle = Handle>,
+    Handle: Clone + Hash,
+{
+    let Size { width, height } = renderer.dimensions(handle);
+    let image_size = Size::new(width as f32, height as f32);
+
+    let bounds = layout.bounds();
+    let adjusted_fit = content_fit.fit(image_size, bounds.size());
+
+    let render = |renderer: &mut Renderer| {
+        let offset = Vector::new(
+            (bounds.width - adjusted_fit.width).max(0.0) / 2.0,
+            (bounds.height - adjusted_fit.height).max(0.0) / 2.0,
+        );
+
+        let drawing_bounds = Rectangle {
+            width: adjusted_fit.width,
+            height: adjusted_fit.height,
+            ..bounds
+        };
+
+        renderer.draw(handle.clone(), drawing_bounds + offset)
+    };
+
+    if adjusted_fit.width > bounds.width || adjusted_fit.height > bounds.height
+    {
+        renderer.with_layer(bounds, render);
+    } else {
+        render(renderer)
+    }
+}
+
 impl<Message, Renderer, Handle> Widget<Message, Renderer> for Image<Handle>
 where
     Renderer: image::Renderer<Handle = Handle>,
@@ -149,34 +188,7 @@ where
         _cursor_position: Point,
         _viewport: &Rectangle,
     ) {
-        let Size { width, height } = renderer.dimensions(&self.handle);
-        let image_size = Size::new(width as f32, height as f32);
-
-        let bounds = layout.bounds();
-        let adjusted_fit = self.content_fit.fit(image_size, bounds.size());
-
-        let render = |renderer: &mut Renderer| {
-            let offset = Vector::new(
-                (bounds.width - adjusted_fit.width).max(0.0) / 2.0,
-                (bounds.height - adjusted_fit.height).max(0.0) / 2.0,
-            );
-
-            let drawing_bounds = Rectangle {
-                width: adjusted_fit.width,
-                height: adjusted_fit.height,
-                ..bounds
-            };
-
-            renderer.draw(self.handle.clone(), drawing_bounds + offset)
-        };
-
-        if adjusted_fit.width > bounds.width
-            || adjusted_fit.height > bounds.height
-        {
-            renderer.with_layer(bounds, render);
-        } else {
-            render(renderer)
-        }
+        draw(renderer, layout, &self.handle, self.content_fit)
     }
 }
 
-- 
cgit 


From a50cc32d09ddff1d061701074908c28d5c5509ba Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Mon, 30 Jan 2023 05:01:28 +0100
Subject: Fix layout translation in `overlay::Group`

This bug produced improper positioning of overlays of elements inside a
`Scrollable`.
---
 native/src/overlay/element.rs | 10 ++++++++--
 native/src/overlay/group.rs   |  6 ++++--
 native/src/user_interface.rs  | 18 ++++++++++--------
 3 files changed, 22 insertions(+), 12 deletions(-)

(limited to 'native')

diff --git a/native/src/overlay/element.rs b/native/src/overlay/element.rs
index bdf7766e..237d25d1 100644
--- a/native/src/overlay/element.rs
+++ b/native/src/overlay/element.rs
@@ -53,8 +53,14 @@ where
     }
 
     /// Computes the layout of the [`Element`] in the given bounds.
-    pub fn layout(&self, renderer: &Renderer, bounds: Size) -> layout::Node {
-        self.overlay.layout(renderer, bounds, self.position)
+    pub fn layout(
+        &self,
+        renderer: &Renderer,
+        bounds: Size,
+        translation: Vector,
+    ) -> layout::Node {
+        self.overlay
+            .layout(renderer, bounds, self.position + translation)
     }
 
     /// Processes a runtime [`Event`].
diff --git a/native/src/overlay/group.rs b/native/src/overlay/group.rs
index 5c9cf809..1126f0cf 100644
--- a/native/src/overlay/group.rs
+++ b/native/src/overlay/group.rs
@@ -66,13 +66,15 @@ where
         &self,
         renderer: &Renderer,
         bounds: Size,
-        _position: Point,
+        position: Point,
     ) -> layout::Node {
+        let translation = position - Point::ORIGIN;
+
         layout::Node::with_children(
             bounds,
             self.children
                 .iter()
-                .map(|child| child.layout(renderer, bounds))
+                .map(|child| child.layout(renderer, bounds, translation))
                 .collect(),
         )
     }
diff --git a/native/src/user_interface.rs b/native/src/user_interface.rs
index 0def730c..80dece21 100644
--- a/native/src/user_interface.rs
+++ b/native/src/user_interface.rs
@@ -6,7 +6,9 @@ use crate::mouse;
 use crate::renderer;
 use crate::widget;
 use crate::window;
-use crate::{Clipboard, Element, Layout, Point, Rectangle, Shell, Size};
+use crate::{
+    Clipboard, Element, Layout, Point, Rectangle, Shell, Size, Vector,
+};
 
 /// A set of interactive graphical elements with a specific [`Layout`].
 ///
@@ -203,7 +205,7 @@ where
             let bounds = self.bounds;
 
             let mut overlay = manual_overlay.as_mut().unwrap();
-            let mut layout = overlay.layout(renderer, bounds);
+            let mut layout = overlay.layout(renderer, bounds, Vector::ZERO);
             let mut event_statuses = Vec::new();
 
             for event in events.iter().cloned() {
@@ -252,7 +254,7 @@ where
                     overlay = manual_overlay.as_mut().unwrap();
 
                     shell.revalidate_layout(|| {
-                        layout = overlay.layout(renderer, bounds);
+                        layout = overlay.layout(renderer, bounds, Vector::ZERO);
                     });
                 }
 
@@ -434,10 +436,9 @@ where
             .as_widget_mut()
             .overlay(&mut self.state, Layout::new(&self.base), renderer)
         {
-            let overlay_layout = self
-                .overlay
-                .take()
-                .unwrap_or_else(|| overlay.layout(renderer, self.bounds));
+            let overlay_layout = self.overlay.take().unwrap_or_else(|| {
+                overlay.layout(renderer, self.bounds, Vector::ZERO)
+            });
 
             let new_cursor_position =
                 if overlay_layout.bounds().contains(cursor_position) {
@@ -538,7 +539,8 @@ where
             renderer,
         ) {
             if self.overlay.is_none() {
-                self.overlay = Some(overlay.layout(renderer, self.bounds));
+                self.overlay =
+                    Some(overlay.layout(renderer, self.bounds, Vector::ZERO));
             }
 
             overlay.operate(
-- 
cgit 


From ecc5bfaeff6503e9e0752035c5e0c94c5a5263a2 Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Tue, 31 Jan 2023 04:04:29 +0100
Subject: Improve consistency of `window::Action`

---
 native/src/window/action.rs | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

(limited to 'native')

diff --git a/native/src/window/action.rs b/native/src/window/action.rs
index 525434e4..d277649b 100644
--- a/native/src/window/action.rs
+++ b/native/src/window/action.rs
@@ -33,18 +33,19 @@ pub enum Action<T> {
         /// The new logical y location of the window
         y: i32,
     },
-    /// Set the [`Mode`] of the window.
-    SetMode(Mode),
+    /// Change the [`Mode`] of the window.
+    ChangeMode(Mode),
     /// Fetch the current [`Mode`] of the window.
     FetchMode(Box<dyn FnOnce(Mode) -> T + 'static>),
-    /// Sets the window to maximized or back
+    /// Toggle the window to maximized or back
     ToggleMaximize,
-    /// Toggles whether window has decorations
+    /// Toggle whether window has decorations.
+    ///
     /// ## Platform-specific
     /// - **X11:** Not implemented.
     /// - **Web:** Unsupported.
     ToggleDecorations,
-    /// Requests user attention to the window, this has no effect if the application
+    /// Request user attention to the window, this has no effect if the application
     /// is already focused. How requesting for user attention manifests is platform dependent,
     /// see [`UserAttentionType`] for details.
     ///
@@ -58,7 +59,7 @@ pub enum Action<T> {
     /// - **X11:** Requests for user attention must be manually cleared.
     /// - **Wayland:** Requires `xdg_activation_v1` protocol, `None` has no effect.
     RequestUserAttention(Option<UserAttention>),
-    /// Brings the window to the front and sets input focus. Has no effect if the window is
+    /// Bring the window to the front and sets input focus. Has no effect if the window is
     /// already in focus, minimized, or not visible.
     ///
     /// This method steals input focus from other applications. Do not use this method unless
@@ -87,7 +88,7 @@ impl<T> Action<T> {
             Self::Maximize(bool) => Action::Maximize(bool),
             Self::Minimize(bool) => Action::Minimize(bool),
             Self::Move { x, y } => Action::Move { x, y },
-            Self::SetMode(mode) => Action::SetMode(mode),
+            Self::ChangeMode(mode) => Action::ChangeMode(mode),
             Self::FetchMode(o) => Action::FetchMode(Box::new(move |s| f(o(s)))),
             Self::ToggleMaximize => Action::ToggleMaximize,
             Self::ToggleDecorations => Action::ToggleDecorations,
@@ -113,7 +114,7 @@ impl<T> fmt::Debug for Action<T> {
             Self::Move { x, y } => {
                 write!(f, "Action::Move {{ x: {x}, y: {y} }}")
             }
-            Self::SetMode(mode) => write!(f, "Action::SetMode({mode:?})"),
+            Self::ChangeMode(mode) => write!(f, "Action::SetMode({mode:?})"),
             Self::FetchMode(_) => write!(f, "Action::FetchMode"),
             Self::ToggleMaximize => write!(f, "Action::ToggleMaximize"),
             Self::ToggleDecorations => write!(f, "Action::ToggleDecorations"),
-- 
cgit 


From 98a717383acf71d7939d7cc90d350743487f0380 Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Tue, 31 Jan 2023 04:08:19 +0100
Subject: Write missing `window::Action` helpers in `window`

---
 native/src/window/action.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'native')

diff --git a/native/src/window/action.rs b/native/src/window/action.rs
index d277649b..168974bc 100644
--- a/native/src/window/action.rs
+++ b/native/src/window/action.rs
@@ -47,7 +47,7 @@ pub enum Action<T> {
     ToggleDecorations,
     /// Request user attention to the window, this has no effect if the application
     /// is already focused. How requesting for user attention manifests is platform dependent,
-    /// see [`UserAttentionType`] for details.
+    /// see [`UserAttention`] for details.
     ///
     /// Providing `None` will unset the request for user attention. Unsetting the request for
     /// user attention might not be done automatically by the WM when the window receives input.
-- 
cgit 


From 41822d0dc55a68d3b515e76a6bc6d2accdc611f4 Mon Sep 17 00:00:00 2001
From: Nick Senger <dev@nsenger.com>
Date: Sat, 11 Feb 2023 09:11:00 -0800
Subject: fix: panic when overlay event processing removes overlay

---
 native/src/user_interface.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'native')

diff --git a/native/src/user_interface.rs b/native/src/user_interface.rs
index 80dece21..2358bff1 100644
--- a/native/src/user_interface.rs
+++ b/native/src/user_interface.rs
@@ -263,16 +263,16 @@ where
                 }
             }
 
-            let base_cursor = if manual_overlay
+            let base_cursor = manual_overlay
                 .as_ref()
-                .unwrap()
-                .is_over(Layout::new(&layout), cursor_position)
-            {
-                // TODO: Type-safe cursor availability
-                Point::new(-1.0, -1.0)
-            } else {
-                cursor_position
-            };
+                .filter(|overlay| {
+                    overlay.is_over(Layout::new(&layout), cursor_position)
+                })
+                .map(|_| {
+                    // TODO: Type-safe cursor availability
+                    Point::new(-1.0, -1.0)
+                })
+                .unwrap_or(cursor_position);
 
             self.overlay = Some(layout);
 
-- 
cgit 


From efaa80fb4429e7f9bd2f8a1161be3fa66a3e9e32 Mon Sep 17 00:00:00 2001
From: Casper Storm <casper.storm@lich.io>
Date: Thu, 26 Jan 2023 12:20:43 +0100
Subject: Extend pick_list::Handle

---
 native/src/widget/pick_list.rs | 82 ++++++++++++++++++++++++++++++++++--------
 1 file changed, 68 insertions(+), 14 deletions(-)

(limited to 'native')

diff --git a/native/src/widget/pick_list.rs b/native/src/widget/pick_list.rs
index c2853314..862c4157 100644
--- a/native/src/widget/pick_list.rs
+++ b/native/src/widget/pick_list.rs
@@ -20,6 +20,43 @@ use std::borrow::Cow;
 
 pub use iced_style::pick_list::{Appearance, StyleSheet};
 
+/// The content of the [`Handle`].
+#[derive(Clone)]
+pub struct HandleContent<Renderer>
+where
+    Renderer: text::Renderer,
+{
+    /// Font that will be used to display the `text`,
+    pub font: Renderer::Font,
+    /// Text that will be shown.
+    pub text: String,
+    /// Font size of the content.
+    pub size: Option<u16>,
+}
+
+impl<Renderer> std::fmt::Debug for HandleContent<Renderer>
+where
+    Renderer: text::Renderer,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("HandleIcon")
+            .field("text", &self.text)
+            .field("size", &self.size)
+            .finish()
+    }
+}
+
+impl<Renderer> PartialEq for HandleContent<Renderer>
+where
+    Renderer: text::Renderer,
+{
+    fn eq(&self, other: &Self) -> bool {
+        self.text.eq(&other.text) && self.size.eq(&other.size)
+    }
+}
+
+impl<Renderer> Eq for HandleContent<Renderer> where Renderer: text::Renderer {}
+
 /// The handle to the right side of the [`PickList`].
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Handle<Renderer>
@@ -33,14 +70,14 @@ where
         /// Font size of the content.
         size: Option<u16>,
     },
-    /// A custom handle.
-    Custom {
-        /// Font that will be used to display the `text`,
-        font: Renderer::Font,
-        /// Text that will be shown.
-        text: String,
-        /// Font size of the content.
-        size: Option<u16>,
+    /// A custom static handle.
+    Static(HandleContent<Renderer>),
+    /// A custom dynamic handle.
+    Dynamic {
+        /// The [`HandleContent`] used when [`PickList`] is closed.
+        closed: HandleContent<Renderer>,
+        /// The [`HandleContent`] used when [`PickList`] is open.
+        open: HandleContent<Renderer>,
     },
     /// No handle will be shown.
     None,
@@ -59,16 +96,30 @@ impl<Renderer> Handle<Renderer>
 where
     Renderer: text::Renderer,
 {
-    fn content(&self) -> Option<(Renderer::Font, String, Option<u16>)> {
+    fn content(
+        &self,
+        is_open: bool,
+    ) -> Option<(Renderer::Font, String, Option<u16>)> {
         match self {
             Self::Arrow { size } => Some((
                 Renderer::ICON_FONT,
                 Renderer::ARROW_DOWN_ICON.to_string(),
                 *size,
             )),
-            Self::Custom { font, text, size } => {
+            Self::Static(HandleContent { font, text, size }) => {
                 Some((font.clone(), text.clone(), *size))
             }
+            Self::Dynamic { open, closed } => {
+                if is_open {
+                    Some((open.font.clone(), open.text.clone(), open.size))
+                } else {
+                    Some((
+                        closed.font.clone(),
+                        closed.text.clone(),
+                        closed.size,
+                    ))
+                }
+            }
             Self::None => None,
         }
     }
@@ -258,7 +309,7 @@ where
 
     fn draw(
         &self,
-        _tree: &Tree,
+        tree: &Tree,
         renderer: &mut Renderer,
         theme: &Renderer::Theme,
         _style: &renderer::Style,
@@ -278,6 +329,7 @@ where
             self.selected.as_ref(),
             &self.handle,
             &self.style,
+            || tree.state.downcast_ref::<State<T>>(),
         )
     }
 
@@ -568,7 +620,7 @@ where
 }
 
 /// Draws a [`PickList`].
-pub fn draw<T, Renderer>(
+pub fn draw<'a, T, Renderer>(
     renderer: &mut Renderer,
     theme: &Renderer::Theme,
     layout: Layout<'_>,
@@ -580,11 +632,13 @@ pub fn draw<T, Renderer>(
     selected: Option<&T>,
     handle: &Handle<Renderer>,
     style: &<Renderer::Theme as StyleSheet>::Style,
+    state: impl FnOnce() -> &'a State<T>,
 ) where
     Renderer: text::Renderer,
     Renderer::Theme: StyleSheet,
-    T: ToString,
+    T: ToString + 'a,
 {
+    let state = state();
     let bounds = layout.bounds();
     let is_mouse_over = bounds.contains(cursor_position);
     let is_selected = selected.is_some();
@@ -605,7 +659,7 @@ pub fn draw<T, Renderer>(
         style.background,
     );
 
-    if let Some((font, text, size)) = handle.content() {
+    if let Some((font, text, size)) = handle.content(state.is_open) {
         let size = f32::from(size.unwrap_or_else(|| renderer.default_size()));
 
         renderer.fill_text(Text {
-- 
cgit 


From 5569e12149f9c29345fe404552ce156ef0bebf0e Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Tue, 14 Feb 2023 06:56:59 +0100
Subject: Rename `HandleContent` to `Icon` and simplify generics

---
 native/src/widget/pick_list.rs | 74 ++++++++++++------------------------------
 1 file changed, 20 insertions(+), 54 deletions(-)

(limited to 'native')

diff --git a/native/src/widget/pick_list.rs b/native/src/widget/pick_list.rs
index 862c4157..17fb00d5 100644
--- a/native/src/widget/pick_list.rs
+++ b/native/src/widget/pick_list.rs
@@ -20,49 +20,20 @@ use std::borrow::Cow;
 
 pub use iced_style::pick_list::{Appearance, StyleSheet};
 
-/// The content of the [`Handle`].
-#[derive(Clone)]
-pub struct HandleContent<Renderer>
-where
-    Renderer: text::Renderer,
-{
+/// The icon of a [`Handle`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Icon<Font> {
     /// Font that will be used to display the `text`,
-    pub font: Renderer::Font,
+    pub font: Font,
     /// Text that will be shown.
     pub text: String,
     /// Font size of the content.
     pub size: Option<u16>,
 }
 
-impl<Renderer> std::fmt::Debug for HandleContent<Renderer>
-where
-    Renderer: text::Renderer,
-{
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("HandleIcon")
-            .field("text", &self.text)
-            .field("size", &self.size)
-            .finish()
-    }
-}
-
-impl<Renderer> PartialEq for HandleContent<Renderer>
-where
-    Renderer: text::Renderer,
-{
-    fn eq(&self, other: &Self) -> bool {
-        self.text.eq(&other.text) && self.size.eq(&other.size)
-    }
-}
-
-impl<Renderer> Eq for HandleContent<Renderer> where Renderer: text::Renderer {}
-
 /// The handle to the right side of the [`PickList`].
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Handle<Renderer>
-where
-    Renderer: text::Renderer,
-{
+pub enum Handle<Font> {
     /// Displays an arrow icon (▼).
     ///
     /// This is the default.
@@ -71,42 +42,36 @@ where
         size: Option<u16>,
     },
     /// A custom static handle.
-    Static(HandleContent<Renderer>),
+    Static(Icon<Font>),
     /// A custom dynamic handle.
     Dynamic {
-        /// The [`HandleContent`] used when [`PickList`] is closed.
-        closed: HandleContent<Renderer>,
-        /// The [`HandleContent`] used when [`PickList`] is open.
-        open: HandleContent<Renderer>,
+        /// The [`Icon`] used when [`PickList`] is closed.
+        closed: Icon<Font>,
+        /// The [`Icon`] used when [`PickList`] is open.
+        open: Icon<Font>,
     },
     /// No handle will be shown.
     None,
 }
 
-impl<Renderer> Default for Handle<Renderer>
-where
-    Renderer: text::Renderer,
-{
+impl<Font> Default for Handle<Font> {
     fn default() -> Self {
         Self::Arrow { size: None }
     }
 }
 
-impl<Renderer> Handle<Renderer>
-where
-    Renderer: text::Renderer,
-{
-    fn content(
+impl<Font: Clone> Handle<Font> {
+    fn content<Renderer: text::Renderer<Font = Font>>(
         &self,
         is_open: bool,
-    ) -> Option<(Renderer::Font, String, Option<u16>)> {
+    ) -> Option<(Font, String, Option<u16>)> {
         match self {
             Self::Arrow { size } => Some((
                 Renderer::ICON_FONT,
                 Renderer::ARROW_DOWN_ICON.to_string(),
                 *size,
             )),
-            Self::Static(HandleContent { font, text, size }) => {
+            Self::Static(Icon { font, text, size }) => {
                 Some((font.clone(), text.clone(), *size))
             }
             Self::Dynamic { open, closed } => {
@@ -141,7 +106,7 @@ where
     padding: Padding,
     text_size: Option<u16>,
     font: Renderer::Font,
-    handle: Handle<Renderer>,
+    handle: Handle<Renderer::Font>,
     style: <Renderer::Theme as StyleSheet>::Style,
 }
 
@@ -212,7 +177,7 @@ where
     }
 
     /// Sets the [`Handle`] of the [`PickList`].
-    pub fn handle(mut self, handle: Handle<Renderer>) -> Self {
+    pub fn handle(mut self, handle: Handle<Renderer::Font>) -> Self {
         self.handle = handle;
         self
     }
@@ -630,7 +595,7 @@ pub fn draw<'a, T, Renderer>(
     font: &Renderer::Font,
     placeholder: Option<&str>,
     selected: Option<&T>,
-    handle: &Handle<Renderer>,
+    handle: &Handle<Renderer::Font>,
     style: &<Renderer::Theme as StyleSheet>::Style,
     state: impl FnOnce() -> &'a State<T>,
 ) where
@@ -659,7 +624,8 @@ pub fn draw<'a, T, Renderer>(
         style.background,
     );
 
-    if let Some((font, text, size)) = handle.content(state.is_open) {
+    if let Some((font, text, size)) = handle.content::<Renderer>(state.is_open)
+    {
         let size = f32::from(size.unwrap_or_else(|| renderer.default_size()));
 
         renderer.fill_text(Text {
-- 
cgit 


From 0272cac89e2bb3e037d0d9d5caa8b7c584386417 Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Tue, 14 Feb 2023 06:59:37 +0100
Subject: Move `Handle` and `Icon` definitions in `pick_list`

---
 native/src/widget/pick_list.rs | 140 ++++++++++++++++++++---------------------
 1 file changed, 70 insertions(+), 70 deletions(-)

(limited to 'native')

diff --git a/native/src/widget/pick_list.rs b/native/src/widget/pick_list.rs
index 17fb00d5..b9f6f088 100644
--- a/native/src/widget/pick_list.rs
+++ b/native/src/widget/pick_list.rs
@@ -20,76 +20,6 @@ use std::borrow::Cow;
 
 pub use iced_style::pick_list::{Appearance, StyleSheet};
 
-/// The icon of a [`Handle`].
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Icon<Font> {
-    /// Font that will be used to display the `text`,
-    pub font: Font,
-    /// Text that will be shown.
-    pub text: String,
-    /// Font size of the content.
-    pub size: Option<u16>,
-}
-
-/// The handle to the right side of the [`PickList`].
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Handle<Font> {
-    /// Displays an arrow icon (▼).
-    ///
-    /// This is the default.
-    Arrow {
-        /// Font size of the content.
-        size: Option<u16>,
-    },
-    /// A custom static handle.
-    Static(Icon<Font>),
-    /// A custom dynamic handle.
-    Dynamic {
-        /// The [`Icon`] used when [`PickList`] is closed.
-        closed: Icon<Font>,
-        /// The [`Icon`] used when [`PickList`] is open.
-        open: Icon<Font>,
-    },
-    /// No handle will be shown.
-    None,
-}
-
-impl<Font> Default for Handle<Font> {
-    fn default() -> Self {
-        Self::Arrow { size: None }
-    }
-}
-
-impl<Font: Clone> Handle<Font> {
-    fn content<Renderer: text::Renderer<Font = Font>>(
-        &self,
-        is_open: bool,
-    ) -> Option<(Font, String, Option<u16>)> {
-        match self {
-            Self::Arrow { size } => Some((
-                Renderer::ICON_FONT,
-                Renderer::ARROW_DOWN_ICON.to_string(),
-                *size,
-            )),
-            Self::Static(Icon { font, text, size }) => {
-                Some((font.clone(), text.clone(), *size))
-            }
-            Self::Dynamic { open, closed } => {
-                if is_open {
-                    Some((open.font.clone(), open.text.clone(), open.size))
-                } else {
-                    Some((
-                        closed.font.clone(),
-                        closed.text.clone(),
-                        closed.size,
-                    ))
-                }
-            }
-            Self::None => None,
-        }
-    }
-}
-
 /// A widget for selecting a single value from a list of options.
 #[allow(missing_debug_implementations)]
 pub struct PickList<'a, T, Message, Renderer>
@@ -366,6 +296,76 @@ impl<T> Default for State<T> {
     }
 }
 
+/// The handle to the right side of the [`PickList`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Handle<Font> {
+    /// Displays an arrow icon (▼).
+    ///
+    /// This is the default.
+    Arrow {
+        /// Font size of the content.
+        size: Option<u16>,
+    },
+    /// A custom static handle.
+    Static(Icon<Font>),
+    /// A custom dynamic handle.
+    Dynamic {
+        /// The [`Icon`] used when [`PickList`] is closed.
+        closed: Icon<Font>,
+        /// The [`Icon`] used when [`PickList`] is open.
+        open: Icon<Font>,
+    },
+    /// No handle will be shown.
+    None,
+}
+
+impl<Font> Default for Handle<Font> {
+    fn default() -> Self {
+        Self::Arrow { size: None }
+    }
+}
+
+impl<Font: Clone> Handle<Font> {
+    fn content<Renderer: text::Renderer<Font = Font>>(
+        &self,
+        is_open: bool,
+    ) -> Option<(Font, String, Option<u16>)> {
+        match self {
+            Self::Arrow { size } => Some((
+                Renderer::ICON_FONT,
+                Renderer::ARROW_DOWN_ICON.to_string(),
+                *size,
+            )),
+            Self::Static(Icon { font, text, size }) => {
+                Some((font.clone(), text.clone(), *size))
+            }
+            Self::Dynamic { open, closed } => {
+                if is_open {
+                    Some((open.font.clone(), open.text.clone(), open.size))
+                } else {
+                    Some((
+                        closed.font.clone(),
+                        closed.text.clone(),
+                        closed.size,
+                    ))
+                }
+            }
+            Self::None => None,
+        }
+    }
+}
+
+/// The icon of a [`Handle`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Icon<Font> {
+    /// Font that will be used to display the `text`,
+    pub font: Font,
+    /// Text that will be shown.
+    pub text: String,
+    /// Font size of the content.
+    pub size: Option<u16>,
+}
+
 /// Computes the layout of a [`PickList`].
 pub fn layout<Renderer, T>(
     renderer: &Renderer,
-- 
cgit 


From bbff06b4621ae586b951564c8cc4bf95608bbb81 Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Tue, 14 Feb 2023 07:02:33 +0100
Subject: Use `char` instead of `String` for `pick_list::Icon`

---
 native/src/widget/pick_list.rs | 35 ++++++++++++++++-------------------
 1 file changed, 16 insertions(+), 19 deletions(-)

(limited to 'native')

diff --git a/native/src/widget/pick_list.rs b/native/src/widget/pick_list.rs
index b9f6f088..b96ffac2 100644
--- a/native/src/widget/pick_list.rs
+++ b/native/src/widget/pick_list.rs
@@ -329,25 +329,21 @@ impl<Font: Clone> Handle<Font> {
     fn content<Renderer: text::Renderer<Font = Font>>(
         &self,
         is_open: bool,
-    ) -> Option<(Font, String, Option<u16>)> {
+    ) -> Option<(Font, char, Option<u16>)> {
         match self {
-            Self::Arrow { size } => Some((
-                Renderer::ICON_FONT,
-                Renderer::ARROW_DOWN_ICON.to_string(),
-                *size,
-            )),
-            Self::Static(Icon { font, text, size }) => {
-                Some((font.clone(), text.clone(), *size))
+            Self::Arrow { size } => {
+                Some((Renderer::ICON_FONT, Renderer::ARROW_DOWN_ICON, *size))
             }
+            Self::Static(Icon {
+                font,
+                code_point,
+                size,
+            }) => Some((font.clone(), *code_point, *size)),
             Self::Dynamic { open, closed } => {
                 if is_open {
-                    Some((open.font.clone(), open.text.clone(), open.size))
+                    Some((open.font.clone(), open.code_point, open.size))
                 } else {
-                    Some((
-                        closed.font.clone(),
-                        closed.text.clone(),
-                        closed.size,
-                    ))
+                    Some((closed.font.clone(), closed.code_point, closed.size))
                 }
             }
             Self::None => None,
@@ -358,10 +354,10 @@ impl<Font: Clone> Handle<Font> {
 /// The icon of a [`Handle`].
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Icon<Font> {
-    /// Font that will be used to display the `text`,
+    /// Font that will be used to display the `code_point`,
     pub font: Font,
-    /// Text that will be shown.
-    pub text: String,
+    /// The unicode code point that will be used as the icon.
+    pub code_point: char,
     /// Font size of the content.
     pub size: Option<u16>,
 }
@@ -624,12 +620,13 @@ pub fn draw<'a, T, Renderer>(
         style.background,
     );
 
-    if let Some((font, text, size)) = handle.content::<Renderer>(state.is_open)
+    if let Some((font, code_point, size)) =
+        handle.content::<Renderer>(state.is_open)
     {
         let size = f32::from(size.unwrap_or_else(|| renderer.default_size()));
 
         renderer.fill_text(Text {
-            content: &text,
+            content: &code_point.to_string(),
             size,
             font,
             color: style.handle_color,
-- 
cgit 


From fee1ab69e2bab01e5d736540be8b253ff62c3e5e Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Tue, 14 Feb 2023 07:05:18 +0100
Subject: Provide `State` reference instead of closure to `pick_list::draw`

---
 native/src/widget/pick_list.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'native')

diff --git a/native/src/widget/pick_list.rs b/native/src/widget/pick_list.rs
index b96ffac2..8189dd61 100644
--- a/native/src/widget/pick_list.rs
+++ b/native/src/widget/pick_list.rs
@@ -224,7 +224,7 @@ where
             self.selected.as_ref(),
             &self.handle,
             &self.style,
-            || tree.state.downcast_ref::<State<T>>(),
+            tree.state.downcast_ref::<State<T>>(),
         )
     }
 
@@ -593,13 +593,12 @@ pub fn draw<'a, T, Renderer>(
     selected: Option<&T>,
     handle: &Handle<Renderer::Font>,
     style: &<Renderer::Theme as StyleSheet>::Style,
-    state: impl FnOnce() -> &'a State<T>,
+    state: &State<T>,
 ) where
     Renderer: text::Renderer,
     Renderer::Theme: StyleSheet,
     T: ToString + 'a,
 {
-    let state = state();
     let bounds = layout.bounds();
     let is_mouse_over = bounds.contains(cursor_position);
     let is_selected = selected.is_some();
-- 
cgit 


From 7f1d58aa4591eba40dd6f3e6bc2869dcdc3e9adb Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Tue, 14 Feb 2023 07:09:24 +0100
Subject: Inline `Handle::content` for simplicity and efficiency

We can avoid downcasting `state` :^)
---
 native/src/widget/pick_list.rs | 53 ++++++++++++++++++------------------------
 1 file changed, 22 insertions(+), 31 deletions(-)

(limited to 'native')

diff --git a/native/src/widget/pick_list.rs b/native/src/widget/pick_list.rs
index 8189dd61..b1cdfad4 100644
--- a/native/src/widget/pick_list.rs
+++ b/native/src/widget/pick_list.rs
@@ -224,7 +224,7 @@ where
             self.selected.as_ref(),
             &self.handle,
             &self.style,
-            tree.state.downcast_ref::<State<T>>(),
+            || tree.state.downcast_ref::<State<T>>(),
         )
     }
 
@@ -325,32 +325,6 @@ impl<Font> Default for Handle<Font> {
     }
 }
 
-impl<Font: Clone> Handle<Font> {
-    fn content<Renderer: text::Renderer<Font = Font>>(
-        &self,
-        is_open: bool,
-    ) -> Option<(Font, char, Option<u16>)> {
-        match self {
-            Self::Arrow { size } => {
-                Some((Renderer::ICON_FONT, Renderer::ARROW_DOWN_ICON, *size))
-            }
-            Self::Static(Icon {
-                font,
-                code_point,
-                size,
-            }) => Some((font.clone(), *code_point, *size)),
-            Self::Dynamic { open, closed } => {
-                if is_open {
-                    Some((open.font.clone(), open.code_point, open.size))
-                } else {
-                    Some((closed.font.clone(), closed.code_point, closed.size))
-                }
-            }
-            Self::None => None,
-        }
-    }
-}
-
 /// The icon of a [`Handle`].
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Icon<Font> {
@@ -593,7 +567,7 @@ pub fn draw<'a, T, Renderer>(
     selected: Option<&T>,
     handle: &Handle<Renderer::Font>,
     style: &<Renderer::Theme as StyleSheet>::Style,
-    state: &State<T>,
+    state: impl FnOnce() -> &'a State<T>,
 ) where
     Renderer: text::Renderer,
     Renderer::Theme: StyleSheet,
@@ -619,9 +593,26 @@ pub fn draw<'a, T, Renderer>(
         style.background,
     );
 
-    if let Some((font, code_point, size)) =
-        handle.content::<Renderer>(state.is_open)
-    {
+    let handle = match handle {
+        Handle::Arrow { size } => {
+            Some((Renderer::ICON_FONT, Renderer::ARROW_DOWN_ICON, *size))
+        }
+        Handle::Static(Icon {
+            font,
+            code_point,
+            size,
+        }) => Some((font.clone(), *code_point, *size)),
+        Handle::Dynamic { open, closed } => {
+            if state().is_open {
+                Some((open.font.clone(), open.code_point, open.size))
+            } else {
+                Some((closed.font.clone(), closed.code_point, closed.size))
+            }
+        }
+        Handle::None => None,
+    };
+
+    if let Some((font, code_point, size)) = handle {
         let size = f32::from(size.unwrap_or_else(|| renderer.default_size()));
 
         renderer.fill_text(Text {
-- 
cgit 


From a9992d131b8cbbc2c73854ecf073ca28c35397e6 Mon Sep 17 00:00:00 2001
From: Cory Forsstrom <cforsstrom18@gmail.com>
Date: Tue, 14 Feb 2023 11:40:29 -0800
Subject: Pad after setting width

Otherwise `width` will set limits back to a fixed width if
`Length::Units` is used, overwriting padding.
---
 native/src/widget/text_input.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'native')

diff --git a/native/src/widget/text_input.rs b/native/src/widget/text_input.rs
index 8755b85d..5bfc918c 100644
--- a/native/src/widget/text_input.rs
+++ b/native/src/widget/text_input.rs
@@ -389,8 +389,8 @@ where
     let padding = padding.fit(Size::ZERO, limits.max());
 
     let limits = limits
-        .pad(padding)
         .width(width)
+        .pad(padding)
         .height(Length::Units(text_size));
 
     let mut text = layout::Node::new(limits.resolve(Size::ZERO));
-- 
cgit