Merge pull request #2662 from iced-rs/reactive-rendering

Reactive Rendering

8 files changed, 140 insertions, 153 deletions

diff --git a/examples/bezier_tool/src/main.rs b/examples/bezier_tool/src/main.rs
index 949bfad7..5e4da0c2 100644
--- a/examples/bezier_tool/src/main.rs
+++ b/examples/bezier_tool/src/main.rs
@@ -57,8 +57,9 @@ impl Example {
 
 mod bezier {
     use iced::mouse;
-    use iced::widget::canvas::event::{self, Event};
-    use iced::widget::canvas::{self, Canvas, Frame, Geometry, Path, Stroke};
+    use iced::widget::canvas::{
+        self, Canvas, Event, Frame, Geometry, Path, Stroke,
+    };
     use iced::{Element, Fill, Point, Rectangle, Renderer, Theme};
 
     #[derive(Default)]
@@ -96,48 +97,47 @@ mod bezier {
             event: Event,
             bounds: Rectangle,
             cursor: mouse::Cursor,
-        ) -> (event::Status, Option<Curve>) {
-            let Some(cursor_position) = cursor.position_in(bounds) else {
-                return (event::Status::Ignored, None);
-            };
+        ) -> Option<canvas::Action<Curve>> {
+            let cursor_position = cursor.position_in(bounds)?;
 
             match event {
-                Event::Mouse(mouse_event) => {
-                    let message = match mouse_event {
-                        mouse::Event::ButtonPressed(mouse::Button::Left) => {
-                            match *state {
-                                None => {
-                                    *state = Some(Pending::One {
-                                        from: cursor_position,
-                                    });
-
-                                    None
-                                }
-                                Some(Pending::One { from }) => {
-                                    *state = Some(Pending::Two {
-                                        from,
-                                        to: cursor_position,
-                                    });
-
-                                    None
-                                }
-                                Some(Pending::Two { from, to }) => {
-                                    *state = None;
-
-                                    Some(Curve {
-                                        from,
-                                        to,
-                                        control: cursor_position,
-                                    })
-                                }
-                            }
+                Event::Mouse(mouse::Event::ButtonPressed(
+                    mouse::Button::Left,
+                )) => Some(
+                    match *state {
+                        None => {
+                            *state = Some(Pending::One {
+                                from: cursor_position,
+                            });
+
+                            canvas::Action::request_redraw()
                         }
-                        _ => None,
-                    };
+                        Some(Pending::One { from }) => {
+                            *state = Some(Pending::Two {
+                                from,
+                                to: cursor_position,
+                            });
 
-                    (event::Status::Captured, message)
+                            canvas::Action::request_redraw()
+                        }
+                        Some(Pending::Two { from, to }) => {
+                            *state = None;
+
+                            canvas::Action::publish(Curve {
+                                from,
+                                to,
+                                control: cursor_position,
+                            })
+                        }
+                    }
+                    .and_capture(),
+                ),
+                Event::Mouse(mouse::Event::CursorMoved { .. })
+                    if state.is_some() =>
+                {
+                    Some(canvas::Action::request_redraw())
                 }
-                _ => (event::Status::Ignored, None),
+                _ => None,
             }
         }
 
diff --git a/examples/game_of_life/src/main.rs b/examples/game_of_life/src/main.rs
index 9dcebecc..7a7224d5 100644
--- a/examples/game_of_life/src/main.rs
+++ b/examples/game_of_life/src/main.rs
@@ -193,8 +193,9 @@ mod grid {
     use iced::mouse;
     use iced::touch;
     use iced::widget::canvas;
-    use iced::widget::canvas::event::{self, Event};
-    use iced::widget::canvas::{Cache, Canvas, Frame, Geometry, Path, Text};
+    use iced::widget::canvas::{
+        Cache, Canvas, Event, Frame, Geometry, Path, Text,
+    };
     use iced::{
         Color, Element, Fill, Point, Rectangle, Renderer, Size, Theme, Vector,
     };
@@ -383,14 +384,12 @@ mod grid {
             event: Event,
             bounds: Rectangle,
             cursor: mouse::Cursor,
-        ) -> (event::Status, Option<Message>) {
+        ) -> Option<canvas::Action<Message>> {
             if let Event::Mouse(mouse::Event::ButtonReleased(_)) = event {
                 *interaction = Interaction::None;
             }
 
-            let Some(cursor_position) = cursor.position_in(bounds) else {
-                return (event::Status::Ignored, None);
-            };
+            let cursor_position = cursor.position_in(bounds)?;
 
             let cell = Cell::at(self.project(cursor_position, bounds.size()));
             let is_populated = self.state.contains(&cell);
@@ -413,7 +412,12 @@ mod grid {
                         populate.or(unpopulate)
                     };
 
-                    (event::Status::Captured, message)
+                    Some(
+                        message
+                            .map(canvas::Action::publish)
+                            .unwrap_or(canvas::Action::request_redraw())
+                            .and_capture(),
+                    )
                 }
                 Event::Mouse(mouse_event) => match mouse_event {
                     mouse::Event::ButtonPressed(button) => {
@@ -438,7 +442,12 @@ mod grid {
                             _ => None,
                         };
 
-                        (event::Status::Captured, message)
+                        Some(
+                            message
+                                .map(canvas::Action::publish)
+                                .unwrap_or(canvas::Action::request_redraw())
+                                .and_capture(),
+                        )
                     }
                     mouse::Event::CursorMoved { .. } => {
                         let message = match *interaction {
@@ -454,12 +463,14 @@ mod grid {
                             Interaction::None => None,
                         };
 
-                        let event_status = match interaction {
-                            Interaction::None => event::Status::Ignored,
-                            _ => event::Status::Captured,
-                        };
+                        let action = message
+                            .map(canvas::Action::publish)
+                            .unwrap_or(canvas::Action::request_redraw());
 
-                        (event_status, message)
+                        Some(match interaction {
+                            Interaction::None => action,
+                            _ => action.and_capture(),
+                        })
                     }
                     mouse::Event::WheelScrolled { delta } => match delta {
                         mouse::ScrollDelta::Lines { y, .. }
@@ -496,18 +507,21 @@ mod grid {
                                         None
                                     };
 
-                                (
-                                    event::Status::Captured,
-                                    Some(Message::Scaled(scaling, translation)),
+                                Some(
+                                    canvas::Action::publish(Message::Scaled(
+                                        scaling,
+                                        translation,
+                                    ))
+                                    .and_capture(),
                                 )
                             } else {
-                                (event::Status::Captured, None)
+                                Some(canvas::Action::capture())
                             }
                         }
                     },
-                    _ => (event::Status::Ignored, None),
+                    _ => None,
                 },
-                _ => (event::Status::Ignored, None),
+                _ => None,
             }
         }
 
diff --git a/examples/loading_spinners/src/circular.rs b/examples/loading_spinners/src/circular.rs
index 9239f01f..a10d5cec 100644
--- a/examples/loading_spinners/src/circular.rs
+++ b/examples/loading_spinners/src/circular.rs
@@ -3,11 +3,10 @@ use iced::advanced::layout;
 use iced::advanced::renderer;
 use iced::advanced::widget::tree::{self, Tree};
 use iced::advanced::{self, Clipboard, Layout, Shell, Widget};
-use iced::event;
 use iced::mouse;
 use iced::time::Instant;
 use iced::widget::canvas;
-use iced::window::{self, RedrawRequest};
+use iced::window;
 use iced::{
     Background, Color, Element, Event, Length, Radians, Rectangle, Renderer,
     Size, Vector,
@@ -262,7 +261,7 @@ where
         layout::atomic(limits, self.size, self.size)
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
         event: Event,
@@ -272,7 +271,7 @@ where
         _clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         _viewport: &Rectangle,
-    ) -> event::Status {
+    ) {
         let state = tree.state.downcast_mut::<State>();
 
         if let Event::Window(window::Event::RedrawRequested(now)) = event {
@@ -283,10 +282,8 @@ where
             );
 
             state.cache.clear();
-            shell.request_redraw(RedrawRequest::NextFrame);
+            shell.request_redraw();
         }
-
-        event::Status::Ignored
     }
 
     fn draw(
diff --git a/examples/loading_spinners/src/linear.rs b/examples/loading_spinners/src/linear.rs
index 164993c6..91c8d523 100644
--- a/examples/loading_spinners/src/linear.rs
+++ b/examples/loading_spinners/src/linear.rs
@@ -3,10 +3,9 @@ use iced::advanced::layout;
 use iced::advanced::renderer::{self, Quad};
 use iced::advanced::widget::tree::{self, Tree};
 use iced::advanced::{self, Clipboard, Layout, Shell, Widget};
-use iced::event;
 use iced::mouse;
 use iced::time::Instant;
-use iced::window::{self, RedrawRequest};
+use iced::window;
 use iced::{Background, Color, Element, Event, Length, Rectangle, Size};
 
 use super::easing::{self, Easing};
@@ -176,7 +175,7 @@ where
         layout::atomic(limits, self.width, self.height)
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
         event: Event,
@@ -186,16 +185,14 @@ where
         _clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         _viewport: &Rectangle,
-    ) -> event::Status {
+    ) {
         let state = tree.state.downcast_mut::<State>();
 
         if let Event::Window(window::Event::RedrawRequested(now)) = event {
             *state = state.timed_transition(self.cycle_duration, now);
 
-            shell.request_redraw(RedrawRequest::NextFrame);
+            shell.request_redraw();
         }
-
-        event::Status::Ignored
     }
 
     fn draw(
diff --git a/examples/multi_window/Cargo.toml b/examples/multi_window/Cargo.toml
index 2e222dfb..3f89417f 100644
--- a/examples/multi_window/Cargo.toml
+++ b/examples/multi_window/Cargo.toml
@@ -6,4 +6,4 @@ edition = "2021"
 publish = false
 
 [dependencies]
-iced = { path = "../..", features = ["debug", "multi-window"] }
+iced = { path = "../..", features = ["debug"] }
diff --git a/examples/multitouch/src/main.rs b/examples/multitouch/src/main.rs
index d5e5dffa..5f4a5c90 100644
--- a/examples/multitouch/src/main.rs
+++ b/examples/multitouch/src/main.rs
@@ -3,9 +3,8 @@
 //! computers like Microsoft Surface.
 use iced::mouse;
 use iced::touch;
-use iced::widget::canvas::event;
 use iced::widget::canvas::stroke::{self, Stroke};
-use iced::widget::canvas::{self, Canvas, Geometry};
+use iced::widget::canvas::{self, Canvas, Event, Geometry};
 use iced::{Color, Element, Fill, Point, Rectangle, Renderer, Theme};
 
 use std::collections::HashMap;
@@ -56,25 +55,25 @@ impl canvas::Program<Message> for Multitouch {
     fn update(
         &self,
         _state: &mut Self::State,
-        event: event::Event,
+        event: Event,
         _bounds: Rectangle,
         _cursor: mouse::Cursor,
-    ) -> (event::Status, Option<Message>) {
-        match event {
-            event::Event::Touch(touch_event) => match touch_event {
+    ) -> Option<canvas::Action<Message>> {
+        let message = match event {
+            Event::Touch(
                 touch::Event::FingerPressed { id, position }
-                | touch::Event::FingerMoved { id, position } => (
-                    event::Status::Captured,
-                    Some(Message::FingerPressed { id, position }),
-                ),
+                | touch::Event::FingerMoved { id, position },
+            ) => Some(Message::FingerPressed { id, position }),
+            Event::Touch(
                 touch::Event::FingerLifted { id, .. }
-                | touch::Event::FingerLost { id, .. } => (
-                    event::Status::Captured,
-                    Some(Message::FingerLifted { id }),
-                ),
-            },
-            _ => (event::Status::Ignored, None),
-        }
+                | touch::Event::FingerLost { id, .. },
+            ) => Some(Message::FingerLifted { id }),
+            _ => None,
+        };
+
+        message
+            .map(canvas::Action::publish)
+            .map(canvas::Action::and_capture)
     }
 
     fn draw(
diff --git a/examples/sierpinski_triangle/src/main.rs b/examples/sierpinski_triangle/src/main.rs
index 99e7900a..d4d483f5 100644
--- a/examples/sierpinski_triangle/src/main.rs
+++ b/examples/sierpinski_triangle/src/main.rs
@@ -1,6 +1,5 @@
 use iced::mouse;
-use iced::widget::canvas::event::{self, Event};
-use iced::widget::canvas::{self, Canvas, Geometry};
+use iced::widget::canvas::{self, Canvas, Event, Geometry};
 use iced::widget::{column, row, slider, text};
 use iced::{Center, Color, Fill, Point, Rectangle, Renderer, Size, Theme};
 
@@ -80,26 +79,22 @@ impl canvas::Program<Message> for SierpinskiGraph {
         event: Event,
         bounds: Rectangle,
         cursor: mouse::Cursor,
-    ) -> (event::Status, Option<Message>) {
-        let Some(cursor_position) = cursor.position_in(bounds) else {
-            return (event::Status::Ignored, None);
-        };
+    ) -> Option<canvas::Action<Message>> {
+        let cursor_position = cursor.position_in(bounds)?;
 
         match event {
-            Event::Mouse(mouse_event) => {
-                let message = match mouse_event {
-                    iced::mouse::Event::ButtonPressed(
-                        iced::mouse::Button::Left,
-                    ) => Some(Message::PointAdded(cursor_position)),
-                    iced::mouse::Event::ButtonPressed(
-                        iced::mouse::Button::Right,
-                    ) => Some(Message::PointRemoved),
-                    _ => None,
-                };
-                (event::Status::Captured, message)
-            }
-            _ => (event::Status::Ignored, None),
+            Event::Mouse(mouse::Event::ButtonPressed(button)) => match button {
+                mouse::Button::Left => Some(canvas::Action::publish(
+                    Message::PointAdded(cursor_position),
+                )),
+                mouse::Button::Right => {
+                    Some(canvas::Action::publish(Message::PointRemoved))
+                }
+                _ => None,
+            },
+            _ => None,
         }
+        .map(canvas::Action::and_capture)
     }
 
     fn draw(
diff --git a/examples/toast/src/main.rs b/examples/toast/src/main.rs
index 8f6a836e..8d1e3924 100644
--- a/examples/toast/src/main.rs
+++ b/examples/toast/src/main.rs
@@ -169,7 +169,6 @@ mod toast {
     use iced::advanced::renderer;
     use iced::advanced::widget::{self, Operation, Tree};
     use iced::advanced::{Clipboard, Shell, Widget};
-    use iced::event::{self, Event};
     use iced::mouse;
     use iced::theme;
     use iced::widget::{
@@ -177,8 +176,8 @@ mod toast {
     };
     use iced::window;
     use iced::{
-        Alignment, Center, Element, Fill, Length, Point, Rectangle, Renderer,
-        Size, Theme, Vector,
+        Alignment, Center, Element, Event, Fill, Length, Point, Rectangle,
+        Renderer, Size, Theme, Vector,
     };
 
     pub const DEFAULT_TIMEOUT: u64 = 5;
@@ -359,7 +358,7 @@ mod toast {
             });
         }
 
-        fn on_event(
+        fn update(
             &mut self,
             state: &mut Tree,
             event: Event,
@@ -369,8 +368,8 @@ mod toast {
             clipboard: &mut dyn Clipboard,
             shell: &mut Shell<'_, Message>,
             viewport: &Rectangle,
-        ) -> event::Status {
-            self.content.as_widget_mut().on_event(
+        ) {
+            self.content.as_widget_mut().update(
                 &mut state.children[0],
                 event,
                 layout,
@@ -379,7 +378,7 @@ mod toast {
                 clipboard,
                 shell,
                 viewport,
-            )
+            );
         }
 
         fn draw(
@@ -490,7 +489,7 @@ mod toast {
             .translate(Vector::new(self.position.x, self.position.y))
         }
 
-        fn on_event(
+        fn update(
             &mut self,
             event: Event,
             layout: Layout<'_>,
@@ -498,10 +497,8 @@ mod toast {
             renderer: &Renderer,
             clipboard: &mut dyn Clipboard,
             shell: &mut Shell<'_, Message>,
-        ) -> event::Status {
+        ) {
             if let Event::Window(window::Event::RedrawRequested(now)) = &event {
-                let mut next_redraw: Option<window::RedrawRequest> = None;
-
                 self.instants.iter_mut().enumerate().for_each(
                     |(index, maybe_instant)| {
                         if let Some(instant) = maybe_instant.as_mut() {
@@ -512,55 +509,43 @@ mod toast {
                             if remaining == Duration::ZERO {
                                 maybe_instant.take();
                                 shell.publish((self.on_close)(index));
-                                next_redraw =
-                                    Some(window::RedrawRequest::NextFrame);
                             } else {
-                                let redraw_at =
-                                    window::RedrawRequest::At(*now + remaining);
-                                next_redraw = next_redraw
-                                    .map(|redraw| redraw.min(redraw_at))
-                                    .or(Some(redraw_at));
+                                shell.request_redraw_at(*now + remaining);
                             }
                         }
                     },
                 );
-
-                if let Some(redraw) = next_redraw {
-                    shell.request_redraw(redraw);
-                }
             }
 
             let viewport = layout.bounds();
 
-            self.toasts
+            for (((child, state), layout), instant) in self
+                .toasts
                 .iter_mut()
                 .zip(self.state.iter_mut())
                 .zip(layout.children())
                 .zip(self.instants.iter_mut())
-                .map(|(((child, state), layout), instant)| {
-                    let mut local_messages = vec![];
-                    let mut local_shell = Shell::new(&mut local_messages);
-
-                    let status = child.as_widget_mut().on_event(
-                        state,
-                        event.clone(),
-                        layout,
-                        cursor,
-                        renderer,
-                        clipboard,
-                        &mut local_shell,
-                        &viewport,
-                    );
+            {
+                let mut local_messages = vec![];
+                let mut local_shell = Shell::new(&mut local_messages);
 
-                    if !local_shell.is_empty() {
-                        instant.take();
-                    }
+                child.as_widget_mut().update(
+                    state,
+                    event.clone(),
+                    layout,
+                    cursor,
+                    renderer,
+                    clipboard,
+                    &mut local_shell,
+                    &viewport,
+                );
 
-                    shell.merge(local_shell, std::convert::identity);
+                if !local_shell.is_empty() {
+                    instant.take();
+                }
 
-                    status
-                })
-                .fold(event::Status::Ignored, event::Status::merge)
+                shell.merge(local_shell, std::convert::identity);
+            }
         }
 
         fn draw(