Replace stateful widgets with new `iced_pure` API

11 files changed, 67 insertions, 164 deletions

diff --git a/graphics/Cargo.toml b/graphics/Cargo.toml
index 97500112..49d4d9c6 100644
--- a/graphics/Cargo.toml
+++ b/graphics/Cargo.toml
@@ -17,7 +17,6 @@ font-source = ["font-kit"]
 font-fallback = []
 font-icons = []
 opengl = []
-pure = ["iced_pure"]
 
 [dependencies]
 glam = "0.10"
@@ -36,11 +35,6 @@ path = "../native"
 version = "0.4"
 path = "../style"
 
-[dependencies.iced_pure]
-version = "0.2"
-path = "../pure"
-optional = true
-
 [dependencies.lyon]
 version = "1.0"
 optional = true
diff --git a/graphics/src/lib.rs b/graphics/src/lib.rs
index a7a1cabb..11082472 100644
--- a/graphics/src/lib.rs
+++ b/graphics/src/lib.rs
@@ -36,9 +36,6 @@ pub mod triangle;
 pub mod widget;
 pub mod window;
 
-#[doc(no_inline)]
-pub use widget::*;
-
 pub use antialiasing::Antialiasing;
 pub use backend::Backend;
 pub use error::Error;
diff --git a/graphics/src/renderer.rs b/graphics/src/renderer.rs
index 3c19fbfb..cdbc4f40 100644
--- a/graphics/src/renderer.rs
+++ b/graphics/src/renderer.rs
@@ -58,7 +58,7 @@ where
         element: &Element<'a, Message, Self>,
         limits: &layout::Limits,
     ) -> layout::Node {
-        let layout = element.layout(self, limits);
+        let layout = element.as_widget().layout(self, limits);
 
         self.backend.trim_measurements();
 
diff --git a/graphics/src/widget/canvas.rs b/graphics/src/widget/canvas.rs
index c3e28e8c..88403fd7 100644
--- a/graphics/src/widget/canvas.rs
+++ b/graphics/src/widget/canvas.rs
@@ -3,8 +3,6 @@
 //! A [`Canvas`] widget can be used to draw different kinds of 2D shapes in a
 //! [`Frame`]. It can be used for animation, data visualization, game graphics,
 //! and more!
-use crate::renderer::{self, Renderer};
-use crate::{Backend, Primitive};
 
 pub mod event;
 pub mod path;
@@ -29,42 +27,31 @@ pub use program::Program;
 pub use stroke::{LineCap, LineDash, LineJoin, Stroke};
 pub use text::Text;
 
-use iced_native::layout;
+use crate::{Backend, Primitive, Renderer};
+
+use iced_native::layout::{self, Layout};
 use iced_native::mouse;
+use iced_native::renderer;
+use iced_native::widget::tree::{self, Tree};
 use iced_native::{
-    Clipboard, Element, Layout, Length, Point, Rectangle, Shell, Size, Vector,
-    Widget,
+    Clipboard, Element, Length, Point, Rectangle, Shell, Size, Vector, Widget,
 };
 
 use std::marker::PhantomData;
 
 /// A widget capable of drawing 2D graphics.
 ///
-/// # Examples
-/// The repository has a couple of [examples] showcasing how to use a
-/// [`Canvas`]:
-///
-/// - [`clock`], an application that uses the [`Canvas`] widget to draw a clock
-/// and its hands to display the current time.
-/// - [`game_of_life`], an interactive version of the Game of Life, invented by
-/// John Conway.
-/// - [`solar_system`], an animated solar system drawn using the [`Canvas`] widget
-/// and showcasing how to compose different transforms.
-///
-/// [examples]: https://github.com/iced-rs/iced/tree/0.4/examples
-/// [`clock`]: https://github.com/iced-rs/iced/tree/0.4/examples/clock
-/// [`game_of_life`]: https://github.com/iced-rs/iced/tree/0.4/examples/game_of_life
-/// [`solar_system`]: https://github.com/iced-rs/iced/tree/0.4/examples/solar_system
-///
 /// ## Drawing a simple circle
 /// If you want to get a quick overview, here's how we can draw a simple circle:
 ///
 /// ```no_run
 /// # mod iced {
-/// #     pub use iced_graphics::canvas;
+/// #     pub mod widget {
+/// #         pub use iced_graphics::widget::canvas;
+/// #     }
 /// #     pub use iced_native::{Color, Rectangle, Theme};
 /// # }
-/// use iced::canvas::{self, Canvas, Cursor, Fill, Frame, Geometry, Path, Program};
+/// use iced::widget::canvas::{self, Canvas, Cursor, Fill, Frame, Geometry, Path, Program};
 /// use iced::{Color, Rectangle, Theme};
 ///
 /// // First, we define the data we need for drawing
@@ -75,7 +62,9 @@ use std::marker::PhantomData;
 ///
 /// // Then, we implement the `Program` trait
 /// impl Program<()> for Circle {
-///     fn draw(&self, _theme: &Theme, bounds: Rectangle, _cursor: Cursor) -> Vec<Geometry>{
+///     type State = ();
+///
+///     fn draw(&self, _state: &(), _theme: &Theme, bounds: Rectangle, _cursor: Cursor) -> Vec<Geometry>{
 ///         // We prepare a new `Frame`
 ///         let mut frame = Frame::new(bounds.size());
 ///
@@ -140,6 +129,15 @@ where
     P: Program<Message, T>,
     B: Backend,
 {
+    fn tag(&self) -> tree::Tag {
+        struct Tag<T>(T);
+        tree::Tag::of::<Tag<P::State>>()
+    }
+
+    fn state(&self) -> tree::State {
+        tree::State::new(P::State::default())
+    }
+
     fn width(&self) -> Length {
         self.width
     }
@@ -161,6 +159,7 @@ where
 
     fn on_event(
         &mut self,
+        tree: &mut Tree,
         event: iced_native::Event,
         layout: Layout<'_>,
         cursor_position: Point,
@@ -183,8 +182,10 @@ where
         let cursor = Cursor::from_window_position(cursor_position);
 
         if let Some(canvas_event) = canvas_event {
+            let state = tree.state.downcast_mut::<P::State>();
+
             let (event_status, message) =
-                self.program.update(canvas_event, bounds, cursor);
+                self.program.update(state, canvas_event, bounds, cursor);
 
             if let Some(message) = message {
                 shell.publish(message);
@@ -198,6 +199,7 @@ where
 
     fn mouse_interaction(
         &self,
+        tree: &Tree,
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
@@ -205,12 +207,14 @@ where
     ) -> mouse::Interaction {
         let bounds = layout.bounds();
         let cursor = Cursor::from_window_position(cursor_position);
+        let state = tree.state.downcast_ref::<P::State>();
 
-        self.program.mouse_interaction(bounds, cursor)
+        self.program.mouse_interaction(state, bounds, cursor)
     }
 
     fn draw(
         &self,
+        tree: &Tree,
         renderer: &mut Renderer<B, T>,
         theme: &T,
         _style: &renderer::Style,
@@ -228,12 +232,13 @@ where
 
         let translation = Vector::new(bounds.x, bounds.y);
         let cursor = Cursor::from_window_position(cursor_position);
+        let state = tree.state.downcast_ref::<P::State>();
 
         renderer.with_translation(translation, |renderer| {
             renderer.draw_primitive(Primitive::Group {
                 primitives: self
                     .program
-                    .draw(theme, bounds, cursor)
+                    .draw(state, theme, bounds, cursor)
                     .into_iter()
                     .map(Geometry::into_primitive)
                     .collect(),
@@ -245,7 +250,7 @@ where
 impl<'a, Message, P, B, T> From<Canvas<Message, T, P>>
     for Element<'a, Message, Renderer<B, T>>
 where
-    Message: 'static,
+    Message: 'a,
     P: Program<Message, T> + 'a,
     B: Backend,
     T: 'a,
diff --git a/graphics/src/widget/canvas/cache.rs b/graphics/src/widget/canvas/cache.rs
index a469417d..5af694e9 100644
--- a/graphics/src/widget/canvas/cache.rs
+++ b/graphics/src/widget/canvas/cache.rs
@@ -1,7 +1,5 @@
-use crate::{
-    canvas::{Frame, Geometry},
-    Primitive,
-};
+use crate::widget::canvas::{Frame, Geometry};
+use crate::Primitive;
 
 use iced_native::Size;
 use std::{cell::RefCell, sync::Arc};
diff --git a/graphics/src/widget/canvas/frame.rs b/graphics/src/widget/canvas/frame.rs
index 2f46079c..417412b2 100644
--- a/graphics/src/widget/canvas/frame.rs
+++ b/graphics/src/widget/canvas/frame.rs
@@ -2,11 +2,10 @@ use std::borrow::Cow;
 
 use iced_native::{Point, Rectangle, Size, Vector};
 
-use crate::{
-    canvas::path,
-    canvas::{Fill, Geometry, Path, Stroke, Text},
-    triangle, Primitive,
-};
+use crate::triangle;
+use crate::widget::canvas::path;
+use crate::widget::canvas::{Fill, Geometry, Path, Stroke, Text};
+use crate::Primitive;
 
 use lyon::tessellation;
 
diff --git a/graphics/src/widget/canvas/path.rs b/graphics/src/widget/canvas/path.rs
index 608507ad..aeb2589e 100644
--- a/graphics/src/widget/canvas/path.rs
+++ b/graphics/src/widget/canvas/path.rs
@@ -7,7 +7,7 @@ mod builder;
 pub use arc::Arc;
 pub use builder::Builder;
 
-use crate::canvas::LineDash;
+use crate::widget::canvas::LineDash;
 
 use iced_native::{Point, Size};
 use lyon::algorithms::walk::{walk_along_path, RepeatedPattern, WalkerEvent};
diff --git a/graphics/src/widget/canvas/path/builder.rs b/graphics/src/widget/canvas/path/builder.rs
index c49ccdc3..5121aa68 100644
--- a/graphics/src/widget/canvas/path/builder.rs
+++ b/graphics/src/widget/canvas/path/builder.rs
@@ -1,4 +1,4 @@
-use crate::canvas::path::{arc, Arc, Path};
+use crate::widget::canvas::path::{arc, Arc, Path};
 
 use iced_native::{Point, Size};
 use lyon::path::builder::SvgPathBuilder;
diff --git a/graphics/src/widget/canvas/program.rs b/graphics/src/widget/canvas/program.rs
index dddc387d..656dbfa6 100644
--- a/graphics/src/widget/canvas/program.rs
+++ b/graphics/src/widget/canvas/program.rs
@@ -1,8 +1,7 @@
-use crate::canvas::event::{self, Event};
-use crate::canvas::{Cursor, Geometry};
-
-use iced_native::mouse;
-use iced_native::Rectangle;
+use crate::widget::canvas::event::{self, Event};
+use crate::widget::canvas::mouse;
+use crate::widget::canvas::{Cursor, Geometry};
+use crate::Rectangle;
 
 /// The state and logic of a [`Canvas`].
 ///
@@ -11,7 +10,10 @@ use iced_native::Rectangle;
 ///
 /// [`Canvas`]: crate::widget::Canvas
 pub trait Program<Message, Theme = iced_native::Theme> {
-    /// Updates the state of the [`Program`].
+    /// The internal state mutated by the [`Program`].
+    type State: Default + 'static;
+
+    /// Updates the [`State`](Self::State) of the [`Program`].
     ///
     /// When a [`Program`] is used in a [`Canvas`], the runtime will call this
     /// method for each [`Event`].
@@ -23,7 +25,8 @@ pub trait Program<Message, Theme = iced_native::Theme> {
     ///
     /// [`Canvas`]: crate::widget::Canvas
     fn update(
-        &mut self,
+        &self,
+        _state: &mut Self::State,
         _event: Event,
         _bounds: Rectangle,
         _cursor: Cursor,
@@ -40,6 +43,7 @@ pub trait Program<Message, Theme = iced_native::Theme> {
     /// [`Cache`]: crate::widget::canvas::Cache
     fn draw(
         &self,
+        state: &Self::State,
         theme: &Theme,
         bounds: Rectangle,
         cursor: Cursor,
@@ -53,6 +57,7 @@ pub trait Program<Message, Theme = iced_native::Theme> {
     /// [`Canvas`]: crate::widget::Canvas
     fn mouse_interaction(
         &self,
+        _state: &Self::State,
         _bounds: Rectangle,
         _cursor: Cursor,
     ) -> mouse::Interaction {
@@ -60,33 +65,38 @@ pub trait Program<Message, Theme = iced_native::Theme> {
     }
 }
 
-impl<T, Message, Theme> Program<Message, Theme> for &mut T
+impl<Message, Theme, T> Program<Message, Theme> for &T
 where
     T: Program<Message, Theme>,
 {
+    type State = T::State;
+
     fn update(
-        &mut self,
+        &self,
+        state: &mut Self::State,
         event: Event,
         bounds: Rectangle,
         cursor: Cursor,
     ) -> (event::Status, Option<Message>) {
-        T::update(self, event, bounds, cursor)
+        T::update(self, state, event, bounds, cursor)
     }
 
     fn draw(
         &self,
+        state: &Self::State,
         theme: &Theme,
         bounds: Rectangle,
         cursor: Cursor,
     ) -> Vec<Geometry> {
-        T::draw(self, theme, bounds, cursor)
+        T::draw(self, state, theme, bounds, cursor)
     }
 
     fn mouse_interaction(
         &self,
+        state: &Self::State,
         bounds: Rectangle,
         cursor: Cursor,
     ) -> mouse::Interaction {
-        T::mouse_interaction(self, bounds, cursor)
+        T::mouse_interaction(self, state, bounds, cursor)
     }
 }
diff --git a/graphics/src/widget/pure/canvas/program.rs b/graphics/src/widget/pure/canvas/program.rs
deleted file mode 100644
index 20c6406e..00000000
--- a/graphics/src/widget/pure/canvas/program.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-use crate::widget::pure::canvas::event::{self, Event};
-use crate::widget::pure::canvas::mouse;
-use crate::widget::pure::canvas::{Cursor, Geometry};
-use crate::Rectangle;
-
-/// The state and logic of a [`Canvas`].
-///
-/// A [`Program`] can mutate internal state and produce messages for an
-/// application.
-///
-/// [`Canvas`]: crate::widget::Canvas
-pub trait Program<Message, Theme = iced_native::Theme> {
-    /// The internal state mutated by the [`Program`].
-    type State: Default + 'static;
-
-    /// Updates the [`State`](Self::State) of the [`Program`].
-    ///
-    /// When a [`Program`] is used in a [`Canvas`], the runtime will call this
-    /// method for each [`Event`].
-    ///
-    /// This method can optionally return a `Message` to notify an application
-    /// of any meaningful interactions.
-    ///
-    /// By default, this method does and returns nothing.
-    ///
-    /// [`Canvas`]: crate::widget::Canvas
-    fn update(
-        &self,
-        _state: &mut Self::State,
-        _event: Event,
-        _bounds: Rectangle,
-        _cursor: Cursor,
-    ) -> (event::Status, Option<Message>) {
-        (event::Status::Ignored, None)
-    }
-
-    /// Draws the state of the [`Program`], producing a bunch of [`Geometry`].
-    ///
-    /// [`Geometry`] can be easily generated with a [`Frame`] or stored in a
-    /// [`Cache`].
-    ///
-    /// [`Frame`]: crate::widget::canvas::Frame
-    /// [`Cache`]: crate::widget::canvas::Cache
-    fn draw(
-        &self,
-        state: &Self::State,
-        theme: &Theme,
-        bounds: Rectangle,
-        cursor: Cursor,
-    ) -> Vec<Geometry>;
-
-    /// Returns the current mouse interaction of the [`Program`].
-    ///
-    /// The interaction returned will be in effect even if the cursor position
-    /// is out of bounds of the program's [`Canvas`].
-    ///
-    /// [`Canvas`]: crate::widget::Canvas
-    fn mouse_interaction(
-        &self,
-        _state: &Self::State,
-        _bounds: Rectangle,
-        _cursor: Cursor,
-    ) -> mouse::Interaction {
-        mouse::Interaction::default()
-    }
-}
-
-impl<Message, Theme, T> Program<Message, Theme> for &T
-where
-    T: Program<Message, Theme>,
-{
-    type State = T::State;
-
-    fn update(
-        &self,
-        state: &mut Self::State,
-        event: Event,
-        bounds: Rectangle,
-        cursor: Cursor,
-    ) -> (event::Status, Option<Message>) {
-        T::update(self, state, event, bounds, cursor)
-    }
-
-    fn draw(
-        &self,
-        state: &Self::State,
-        theme: &Theme,
-        bounds: Rectangle,
-        cursor: Cursor,
-    ) -> Vec<Geometry> {
-        T::draw(self, state, theme, bounds, cursor)
-    }
-
-    fn mouse_interaction(
-        &self,
-        state: &Self::State,
-        bounds: Rectangle,
-        cursor: Cursor,
-    ) -> mouse::Interaction {
-        T::mouse_interaction(self, state, bounds, cursor)
-    }
-}
diff --git a/graphics/src/widget/qr_code.rs b/graphics/src/widget/qr_code.rs
index 1a5c0b0a..12ce5b1f 100644
--- a/graphics/src/widget/qr_code.rs
+++ b/graphics/src/widget/qr_code.rs
@@ -1,9 +1,10 @@
 //! Encode and display information in a QR code.
-use crate::canvas;
 use crate::renderer::{self, Renderer};
+use crate::widget::canvas;
 use crate::Backend;
 
 use iced_native::layout;
+use iced_native::widget::Tree;
 use iced_native::{
     Color, Element, Layout, Length, Point, Rectangle, Size, Vector, Widget,
 };
@@ -72,6 +73,7 @@ where
 
     fn draw(
         &self,
+        _state: &Tree,
         renderer: &mut Renderer<B, T>,
         _theme: &T,
         _style: &renderer::Style,