Replace stateful widgets with new `iced_pure` API

1 files changed, 68 insertions, 244 deletions

diff --git a/native/src/element.rs b/native/src/element.rs
index 425bddc2..cc74035e 100644
--- a/native/src/element.rs
+++ b/native/src/element.rs
@@ -3,9 +3,10 @@ use crate::layout;
 use crate::mouse;
 use crate::overlay;
 use crate::renderer;
-use crate::{
-    Clipboard, Color, Layout, Length, Point, Rectangle, Shell, Widget,
-};
+use crate::widget::tree::{self, Tree};
+use crate::{Clipboard, Layout, Length, Point, Rectangle, Shell, Widget};
+
+use std::borrow::Borrow;
 
 /// A generic [`Widget`].
 ///
@@ -15,25 +16,33 @@ use crate::{
 /// If you have a [built-in widget], you should be able to use `Into<Element>`
 /// to turn it into an [`Element`].
 ///
-/// [built-in widget]: widget/index.html#built-in-widgets
+/// [built-in widget]: crate::widget
 #[allow(missing_debug_implementations)]
 pub struct Element<'a, Message, Renderer> {
-    pub(crate) widget: Box<dyn Widget<Message, Renderer> + 'a>,
+    widget: Box<dyn Widget<Message, Renderer> + 'a>,
 }
 
-impl<'a, Message, Renderer> Element<'a, Message, Renderer>
-where
-    Renderer: crate::Renderer,
-{
+impl<'a, Message, Renderer> Element<'a, Message, Renderer> {
     /// Creates a new [`Element`] containing the given [`Widget`].
-    pub fn new(
-        widget: impl Widget<Message, Renderer> + 'a,
-    ) -> Element<'a, Message, Renderer> {
-        Element {
+    pub fn new(widget: impl Widget<Message, Renderer> + 'a) -> Self
+    where
+        Renderer: crate::Renderer,
+    {
+        Self {
             widget: Box::new(widget),
         }
     }
 
+    /// Returns a reference to the [`Widget`] of the [`Element`],
+    pub fn as_widget(&self) -> &dyn Widget<Message, Renderer> {
+        self.widget.as_ref()
+    }
+
+    /// Returns a mutable reference to the [`Widget`] of the [`Element`],
+    pub fn as_widget_mut(&mut self) -> &mut dyn Widget<Message, Renderer> {
+        self.widget.as_mut()
+    }
+
     /// Applies a transformation to the produced message of the [`Element`].
     ///
     /// This method is useful when you want to decouple different parts of your
@@ -168,127 +177,22 @@ where
     ///     }
     /// }
     /// ```
-    pub fn map<F, B>(self, f: F) -> Element<'a, B, Renderer>
-    where
-        Message: 'static,
-        Renderer: 'a,
-        B: 'static,
-        F: 'static + Fn(Message) -> B,
-    {
-        Element {
-            widget: Box::new(Map::new(self.widget, f)),
-        }
-    }
-
-    /// Marks the [`Element`] as _to-be-explained_.
-    ///
-    /// The [`Renderer`] will explain the layout of the [`Element`] graphically.
-    /// This can be very useful for debugging your layout!
-    ///
-    /// [`Renderer`]: crate::Renderer
-    pub fn explain<C: Into<Color>>(
+    pub fn map<B>(
         self,
-        color: C,
-    ) -> Element<'a, Message, Renderer>
+        f: impl Fn(Message) -> B + 'a,
+    ) -> Element<'a, B, Renderer>
     where
-        Message: 'static,
-        Renderer: 'a,
+        Message: 'a,
+        Renderer: crate::Renderer + 'a,
+        B: 'a,
     {
-        Element {
-            widget: Box::new(Explain::new(self, color.into())),
-        }
-    }
-
-    /// Returns the width of the [`Element`].
-    pub fn width(&self) -> Length {
-        self.widget.width()
-    }
-
-    /// Returns the height of the [`Element`].
-    pub fn height(&self) -> Length {
-        self.widget.height()
-    }
-
-    /// Computes the layout of the [`Element`] in the given [`Limits`].
-    ///
-    /// [`Limits`]: layout::Limits
-    pub fn layout(
-        &self,
-        renderer: &Renderer,
-        limits: &layout::Limits,
-    ) -> layout::Node {
-        self.widget.layout(renderer, limits)
-    }
-
-    /// Processes a runtime [`Event`].
-    pub 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.widget.on_event(
-            event,
-            layout,
-            cursor_position,
-            renderer,
-            clipboard,
-            shell,
-        )
-    }
-
-    /// Draws the [`Element`] and its children using the given [`Layout`].
-    pub fn draw(
-        &self,
-        renderer: &mut Renderer,
-        theme: &Renderer::Theme,
-        style: &renderer::Style,
-        layout: Layout<'_>,
-        cursor_position: Point,
-        viewport: &Rectangle,
-    ) {
-        self.widget.draw(
-            renderer,
-            theme,
-            style,
-            layout,
-            cursor_position,
-            viewport,
-        )
-    }
-
-    /// Returns the current [`mouse::Interaction`] of the [`Element`].
-    pub fn mouse_interaction(
-        &self,
-        layout: Layout<'_>,
-        cursor_position: Point,
-        viewport: &Rectangle,
-        renderer: &Renderer,
-    ) -> mouse::Interaction {
-        self.widget.mouse_interaction(
-            layout,
-            cursor_position,
-            viewport,
-            renderer,
-        )
-    }
-
-    /// Returns the overlay of the [`Element`], if there is any.
-    pub fn overlay<'b>(
-        &'b mut self,
-        layout: Layout<'_>,
-        renderer: &Renderer,
-    ) -> Option<overlay::Element<'b, Message, Renderer>> {
-        self.widget.overlay(layout, renderer)
+        Element::new(Map::new(self.widget, f))
     }
 }
 
 struct Map<'a, A, B, Renderer> {
     widget: Box<dyn Widget<A, Renderer> + 'a>,
-    mapper: Box<dyn Fn(A) -> B>,
+    mapper: Box<dyn Fn(A) -> B + 'a>,
 }
 
 impl<'a, A, B, Renderer> Map<'a, A, B, Renderer> {
@@ -297,7 +201,7 @@ impl<'a, A, B, Renderer> Map<'a, A, B, Renderer> {
         mapper: F,
     ) -> Map<'a, A, B, Renderer>
     where
-        F: 'static + Fn(A) -> B,
+        F: 'a + Fn(A) -> B,
     {
         Map {
             widget,
@@ -309,9 +213,25 @@ impl<'a, A, B, Renderer> Map<'a, A, B, Renderer> {
 impl<'a, A, B, Renderer> Widget<B, Renderer> for Map<'a, A, B, Renderer>
 where
     Renderer: crate::Renderer + 'a,
-    A: 'static,
-    B: 'static,
+    A: 'a,
+    B: 'a,
 {
+    fn tag(&self) -> tree::Tag {
+        self.widget.tag()
+    }
+
+    fn state(&self) -> tree::State {
+        self.widget.state()
+    }
+
+    fn children(&self) -> Vec<Tree> {
+        self.widget.children()
+    }
+
+    fn diff(&self, tree: &mut Tree) {
+        self.widget.diff(tree)
+    }
+
     fn width(&self) -> Length {
         self.widget.width()
     }
@@ -330,6 +250,7 @@ where
 
     fn on_event(
         &mut self,
+        tree: &mut Tree,
         event: Event,
         layout: Layout<'_>,
         cursor_position: Point,
@@ -341,6 +262,7 @@ where
         let mut local_shell = Shell::new(&mut local_messages);
 
         let status = self.widget.on_event(
+            tree,
             event,
             layout,
             cursor_position,
@@ -356,6 +278,7 @@ where
 
     fn draw(
         &self,
+        tree: &Tree,
         renderer: &mut Renderer,
         theme: &Renderer::Theme,
         style: &renderer::Style,
@@ -364,6 +287,7 @@ where
         viewport: &Rectangle,
     ) {
         self.widget.draw(
+            tree,
             renderer,
             theme,
             style,
@@ -375,12 +299,14 @@ where
 
     fn mouse_interaction(
         &self,
+        tree: &Tree,
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
         renderer: &Renderer,
     ) -> mouse::Interaction {
         self.widget.mouse_interaction(
+            tree,
             layout,
             cursor_position,
             viewport,
@@ -388,134 +314,32 @@ where
         )
     }
 
-    fn overlay(
-        &mut self,
+    fn overlay<'b>(
+        &'b self,
+        tree: &'b mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-    ) -> Option<overlay::Element<'_, B, Renderer>> {
+    ) -> Option<overlay::Element<'b, B, Renderer>> {
         let mapper = &self.mapper;
 
         self.widget
-            .overlay(layout, renderer)
+            .overlay(tree, layout, renderer)
             .map(move |overlay| overlay.map(mapper))
     }
 }
 
-struct Explain<'a, Message, Renderer: crate::Renderer> {
-    element: Element<'a, Message, Renderer>,
-    color: Color,
-}
-
-impl<'a, Message, Renderer> Explain<'a, Message, Renderer>
-where
-    Renderer: crate::Renderer,
+impl<'a, Message, Renderer> Borrow<dyn Widget<Message, Renderer> + 'a>
+    for Element<'a, Message, Renderer>
 {
-    fn new(element: Element<'a, Message, Renderer>, color: Color) -> Self {
-        Explain { element, color }
+    fn borrow(&self) -> &(dyn Widget<Message, Renderer> + 'a) {
+        self.widget.borrow()
     }
 }
 
-impl<'a, Message, Renderer> Widget<Message, Renderer>
-    for Explain<'a, Message, Renderer>
-where
-    Renderer: crate::Renderer,
+impl<'a, Message, Renderer> Borrow<dyn Widget<Message, Renderer> + 'a>
+    for &Element<'a, Message, Renderer>
 {
-    fn width(&self) -> Length {
-        self.element.widget.width()
-    }
-
-    fn height(&self) -> Length {
-        self.element.widget.height()
-    }
-
-    fn layout(
-        &self,
-        renderer: &Renderer,
-        limits: &layout::Limits,
-    ) -> layout::Node {
-        self.element.widget.layout(renderer, limits)
-    }
-
-    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.element.widget.on_event(
-            event,
-            layout,
-            cursor_position,
-            renderer,
-            clipboard,
-            shell,
-        )
-    }
-
-    fn draw(
-        &self,
-        renderer: &mut Renderer,
-        theme: &Renderer::Theme,
-        style: &renderer::Style,
-        layout: Layout<'_>,
-        cursor_position: Point,
-        viewport: &Rectangle,
-    ) {
-        fn explain_layout<Renderer: crate::Renderer>(
-            renderer: &mut Renderer,
-            color: Color,
-            layout: Layout<'_>,
-        ) {
-            renderer.fill_quad(
-                renderer::Quad {
-                    bounds: layout.bounds(),
-                    border_color: color,
-                    border_width: 1.0,
-                    border_radius: 0.0,
-                },
-                Color::TRANSPARENT,
-            );
-
-            for child in layout.children() {
-                explain_layout(renderer, color, child);
-            }
-        }
-
-        self.element.widget.draw(
-            renderer,
-            theme,
-            style,
-            layout,
-            cursor_position,
-            viewport,
-        );
-
-        explain_layout(renderer, self.color, layout);
-    }
-
-    fn mouse_interaction(
-        &self,
-        layout: Layout<'_>,
-        cursor_position: Point,
-        viewport: &Rectangle,
-        renderer: &Renderer,
-    ) -> mouse::Interaction {
-        self.element.widget.mouse_interaction(
-            layout,
-            cursor_position,
-            viewport,
-            renderer,
-        )
-    }
-
-    fn overlay(
-        &mut self,
-        layout: Layout<'_>,
-        renderer: &Renderer,
-    ) -> Option<overlay::Element<'_, Message, Renderer>> {
-        self.element.overlay(layout, renderer)
+    fn borrow(&self) -> &(dyn Widget<Message, Renderer> + 'a) {
+        self.widget.borrow()
     }
 }