Make Widget::layout and operate mutable

... and bless `responsive`!

core/src/element.rs

@@ -291,7 +291,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -300,7 +300,7 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
@@ -426,7 +426,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -435,7 +435,7 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         state: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
@@ -554,7 +554,7 @@ where
             }
 
             fn layout(
-                &self,
+                &mut self,
                 _tree: &mut Tree,
                 _renderer: &Renderer,
                 _limits: &layout::Limits,

core/src/layout/flex.rs

@@ -68,7 +68,7 @@ pub fn resolve<Message, Theme, Renderer>(
     padding: Padding,
     spacing: f32,
     align_items: Alignment,
-    items: &[Element<'_, Message, Theme, Renderer>],
+    items: &mut [Element<'_, Message, Theme, Renderer>],
     trees: &mut [widget::Tree],
 ) -> Node
 where
@@ -95,7 +95,8 @@ where
     // We lay out non-fluid elements in the main axis.
     // If we need to compress the cross axis, then we skip any of these elements
     // that are also fluid in the cross axis.
-    for (i, (child, tree)) in items.iter().zip(trees.iter_mut()).enumerate() {
+    for (i, (child, tree)) in items.iter_mut().zip(trees.iter_mut()).enumerate()
+    {
         let (fill_main_factor, fill_cross_factor) = {
             let size = child.as_widget().size();
 
@@ -117,7 +118,7 @@ where
                 Limits::new(Size::ZERO, Size::new(max_width, max_height));
 
             let layout =
-                child.as_widget().layout(tree, renderer, &child_limits);
+                child.as_widget_mut().layout(tree, renderer, &child_limits);
             let size = layout.size();
 
             available -= axis.main(size);
@@ -141,7 +142,8 @@ where
     // We can defer the layout of any elements that have a fixed size in the main axis,
     // allowing them to use the cross calculations of the next pass.
     if cross_compress && some_fill_cross {
-        for (i, (child, tree)) in items.iter().zip(trees.iter_mut()).enumerate()
+        for (i, (child, tree)) in
+            items.iter_mut().zip(trees.iter_mut()).enumerate()
         {
             let (main_size, cross_size) = {
                 let size = child.as_widget().size();
@@ -161,7 +163,7 @@ where
                     Limits::new(Size::ZERO, Size::new(max_width, max_height));
 
                 let layout =
-                    child.as_widget().layout(tree, renderer, &child_limits);
+                    child.as_widget_mut().layout(tree, renderer, &child_limits);
                 let size = layout.size();
 
                 available -= axis.main(size);
@@ -186,7 +188,8 @@ where
     // THIRD PASS
     // We lay out the elements that are fluid in the main axis.
     // We use the remaining space to evenly allocate space based on fill factors.
-    for (i, (child, tree)) in items.iter().zip(trees.iter_mut()).enumerate() {
+    for (i, (child, tree)) in items.iter_mut().zip(trees.iter_mut()).enumerate()
+    {
         let (fill_main_factor, fill_cross_factor) = {
             let size = child.as_widget().size();
 
@@ -225,7 +228,7 @@ where
             );
 
             let layout =
-                child.as_widget().layout(tree, renderer, &child_limits);
+                child.as_widget_mut().layout(tree, renderer, &child_limits);
             cross = cross.max(axis.cross(layout.size()));
 
             nodes[i] = layout;
@@ -237,7 +240,7 @@ where
     // These are elements that must be compressed in their cross axis and have
     // a fixed length in the main axis.
     if cross_compress && some_fill_cross {
-        for (i, (child, tree)) in items.iter().zip(trees).enumerate() {
+        for (i, (child, tree)) in items.iter_mut().zip(trees).enumerate() {
             let (main_size, cross_size) = {
                 let size = child.as_widget().size();
 
@@ -255,7 +258,7 @@ where
                     Limits::new(Size::ZERO, Size::new(max_width, max_height));
 
                 let layout =
-                    child.as_widget().layout(tree, renderer, &child_limits);
+                    child.as_widget_mut().layout(tree, renderer, &child_limits);
                 let size = layout.size();
 
                 cross = cross.max(axis.cross(size));

core/src/widget.rs

@@ -58,7 +58,7 @@ where
     /// This [`layout::Node`] is used by the runtime to compute the [`Layout`] of the
     /// user interface.
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -102,7 +102,7 @@ where
 
     /// Applies an [`Operation`] to the [`Widget`].
     fn operate(
-        &self,
+        &mut self,
         _state: &mut Tree,
         _layout: Layout<'_>,
         _renderer: &Renderer,

core/src/widget/text.rs

@@ -207,7 +207,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -245,7 +245,7 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         _state: &mut Tree,
         layout: Layout<'_>,
         _renderer: &Renderer,

examples/custom_quad/src/main.rs

@@ -175,7 +175,7 @@ mod quad {
         }
 
         fn layout(
-            &self,
+            &mut self,
             _tree: &mut widget::Tree,
             _renderer: &Renderer,
             _limits: &layout::Limits,

examples/custom_widget/src/main.rs

@@ -33,7 +33,7 @@ mod circle {
         }
 
         fn layout(
-            &self,
+            &mut self,
             _tree: &mut widget::Tree,
             _renderer: &Renderer,
             _limits: &layout::Limits,

examples/geometry/src/main.rs

@@ -27,7 +27,7 @@ mod rainbow {
         }
 
         fn layout(
-            &self,
+            &mut self,
             _tree: &mut widget::Tree,
             _renderer: &Renderer,
             limits: &layout::Limits,

examples/loading_spinners/src/circular.rs

@@ -253,7 +253,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         _tree: &mut Tree,
         _renderer: &Renderer,
         limits: &layout::Limits,

examples/loading_spinners/src/linear.rs

@@ -167,7 +167,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         _tree: &mut Tree,
         _renderer: &Renderer,
         limits: &layout::Limits,

examples/loupe/src/main.rs

@@ -96,12 +96,12 @@ mod loupe {
         }
 
         fn layout(
-            &self,
+            &mut self,
             tree: &mut widget::Tree,
             renderer: &Renderer,
             limits: &layout::Limits,
         ) -> layout::Node {
-            self.content.as_widget().layout(tree, renderer, limits)
+            self.content.as_widget_mut().layout(tree, renderer, limits)
         }
 
         fn draw(

examples/toast/src/main.rs

@@ -287,12 +287,12 @@ mod toast {
         }
 
         fn layout(
-            &self,
+            &mut self,
             tree: &mut Tree,
             renderer: &Renderer,
             limits: &layout::Limits,
         ) -> layout::Node {
-            self.content.as_widget().layout(
+            self.content.as_widget_mut().layout(
                 &mut tree.children[0],
                 renderer,
                 limits,
@@ -343,14 +343,14 @@ mod toast {
         }
 
         fn operate(
-            &self,
+            &mut self,
             state: &mut Tree,
             layout: Layout<'_>,
             renderer: &Renderer,
             operation: &mut dyn Operation,
         ) {
             operation.container(None, layout.bounds(), &mut |operation| {
-                self.content.as_widget().operate(
+                self.content.as_widget_mut().operate(
                     &mut state.children[0],
                     layout,
                     renderer,
@@ -582,12 +582,12 @@ mod toast {
         ) {
             operation.container(None, layout.bounds(), &mut |operation| {
                 self.toasts
-                    .iter()
+                    .iter_mut()
                     .zip(self.state.iter_mut())
                     .zip(layout.children())
                     .for_each(|((child, state), layout)| {
                         child
-                            .as_widget()
+                            .as_widget_mut()
                             .operate(state, layout, renderer, operation);
                     });
             });

runtime/src/user_interface.rs

@@ -97,12 +97,12 @@ where
         cache: Cache,
         renderer: &mut Renderer,
     ) -> Self {
-        let root = root.into();
+        let mut root = root.into();
 
         let Cache { mut state } = cache;
         state.diff(root.as_widget());
 
-        let base = root.as_widget().layout(
+        let base = root.as_widget_mut().layout(
             &mut state,
             renderer,
             &layout::Limits::new(Size::ZERO, bounds),
@@ -234,7 +234,7 @@ where
                     if shell.is_layout_invalid() {
                         drop(maybe_overlay);
 
-                        self.base = self.root.as_widget().layout(
+                        self.base = self.root.as_widget_mut().layout(
                             &mut self.state,
                             renderer,
                             &layout::Limits::new(Size::ZERO, self.bounds),
@@ -335,7 +335,7 @@ where
                 input_method.merge(shell.input_method());
 
                 shell.revalidate_layout(|| {
-                    self.base = self.root.as_widget().layout(
+                    self.base = self.root.as_widget_mut().layout(
                         &mut self.state,
                         renderer,
                         &layout::Limits::new(Size::ZERO, self.bounds),
@@ -539,7 +539,7 @@ where
     ) {
         let viewport = Rectangle::with_size(self.bounds);
 
-        self.root.as_widget().operate(
+        self.root.as_widget_mut().operate(
             &mut self.state,
             Layout::new(&self.base),
             renderer,

widget/src/button.rs

@@ -235,7 +235,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -246,7 +246,7 @@ where
             self.height,
             self.padding,
             |limits| {
-                self.content.as_widget().layout(
+                self.content.as_widget_mut().layout(
                     &mut tree.children[0],
                     renderer,
                     limits,
@@ -256,14 +256,14 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
         operation: &mut dyn Operation,
     ) {
         operation.container(None, layout.bounds(), &mut |operation| {
-            self.content.as_widget().operate(
+            self.content.as_widget_mut().operate(
                 &mut tree.children[0],
                 layout.children().next().unwrap(),
                 renderer,

widget/src/canvas.rs

@@ -207,7 +207,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         _tree: &mut Tree,
         _renderer: &Renderer,
         limits: &layout::Limits,

widget/src/checkbox.rs

@@ -269,7 +269,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -447,7 +447,7 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         _state: &mut Tree,
         layout: Layout<'_>,
         _renderer: &Renderer,

widget/src/column.rs

@@ -206,7 +206,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -222,13 +222,13 @@ where
             self.padding,
             self.spacing,
             self.align,
-            &self.children,
+            &mut self.children,
             &mut tree.children,
         )
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
@@ -236,12 +236,12 @@ where
     ) {
         operation.container(None, layout.bounds(), &mut |operation| {
             self.children
-                .iter()
+                .iter_mut()
                 .zip(&mut tree.children)
                 .zip(layout.children())
                 .for_each(|((child, state), layout)| {
                     child
-                        .as_widget()
+                        .as_widget_mut()
                         .operate(state, layout, renderer, operation);
                 });
         });

widget/src/combo_box.rs

@@ -471,7 +471,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut widget::Tree,
         renderer: &Renderer,
         limits: &layout::Limits,

widget/src/container.rs

@@ -259,7 +259,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -273,12 +273,14 @@ where
             self.padding,
             self.horizontal_alignment,
             self.vertical_alignment,
-            |limits| self.content.as_widget().layout(tree, renderer, limits),
+            |limits| {
+                self.content.as_widget_mut().layout(tree, renderer, limits)
+            },
         )
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
@@ -288,7 +290,7 @@ where
             self.id.as_ref().map(|id| &id.0),
             layout.bounds(),
             &mut |operation| {
-                self.content.as_widget().operate(
+                self.content.as_widget_mut().operate(
                     tree,
                     layout.children().next().unwrap(),
                     renderer,

widget/src/float.rs

@@ -116,12 +116,12 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut widget::Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
-        self.content.as_widget().layout(tree, renderer, limits)
+        self.content.as_widget_mut().layout(tree, renderer, limits)
     }
 
     fn update(
@@ -197,14 +197,14 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         state: &mut widget::Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
         operation: &mut dyn widget::Operation,
     ) {
         self.content
-            .as_widget()
+            .as_widget_mut()
             .operate(state, layout, renderer, operation);
     }
 

widget/src/grid.rs

@@ -176,7 +176,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -220,10 +220,10 @@ where
         let mut row_height = 0.0f32;
 
         for (i, (child, tree)) in
-            self.children.iter().zip(&mut tree.children).enumerate()
+            self.children.iter_mut().zip(&mut tree.children).enumerate()
         {
             let node = child
-                .as_widget()
+                .as_widget_mut()
                 .layout(tree, renderer, &cell_limits)
                 .move_to((x, y));
 
@@ -251,7 +251,7 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
@@ -259,12 +259,12 @@ where
     ) {
         operation.container(None, layout.bounds(), &mut |operation| {
             self.children
-                .iter()
+                .iter_mut()
                 .zip(&mut tree.children)
                 .zip(layout.children())
                 .for_each(|((child, state), layout)| {
                     child
-                        .as_widget()
+                        .as_widget_mut()
                         .operate(state, layout, renderer, operation);
                 });
         });

widget/src/helpers.rs

@@ -609,12 +609,12 @@ where
         }
 
         fn layout(
-            &self,
+            &mut self,
             tree: &mut Tree,
             renderer: &Renderer,
             limits: &layout::Limits,
         ) -> layout::Node {
-            self.content.as_widget().layout(tree, renderer, limits)
+            self.content.as_widget_mut().layout(tree, renderer, limits)
         }
 
         fn draw(
@@ -633,14 +633,14 @@ where
         }
 
         fn operate(
-            &self,
+            &mut self,
             state: &mut Tree,
             layout: Layout<'_>,
             renderer: &Renderer,
             operation: &mut dyn operation::Operation,
         ) {
             self.content
-                .as_widget()
+                .as_widget_mut()
                 .operate(state, layout, renderer, operation);
         }
 
@@ -772,18 +772,18 @@ where
         }
 
         fn layout(
-            &self,
+            &mut self,
             tree: &mut Tree,
             renderer: &Renderer,
             limits: &layout::Limits,
         ) -> layout::Node {
-            let base = self.base.as_widget().layout(
+            let base = self.base.as_widget_mut().layout(
                 &mut tree.children[0],
                 renderer,
                 limits,
             );
 
-            let top = self.top.as_widget().layout(
+            let top = self.top.as_widget_mut().layout(
                 &mut tree.children[1],
                 renderer,
                 &layout::Limits::new(Size::ZERO, base.size()),
@@ -834,18 +834,20 @@ where
         }
 
         fn operate(
-            &self,
+            &mut self,
             tree: &mut Tree,
             layout: Layout<'_>,
             renderer: &Renderer,
             operation: &mut dyn operation::Operation,
         ) {
-            let children = [&self.base, &self.top]
+            let children = [&mut self.base, &mut self.top]
                 .into_iter()
                 .zip(layout.children().zip(&mut tree.children));
 
             for (child, (layout, tree)) in children {
-                child.as_widget().operate(tree, layout, renderer, operation);
+                child
+                    .as_widget_mut()
+                    .operate(tree, layout, renderer, operation);
             }
         }
 

widget/src/image.rs

@@ -386,7 +386,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         _tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,

widget/src/image/viewer.rs

@@ -117,7 +117,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         _tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,

widget/src/keyed/column.rs

@@ -253,7 +253,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -272,13 +272,13 @@ where
             self.padding,
             self.spacing,
             self.align_items,
-            &self.children,
+            &mut self.children,
             &mut tree.children,
         )
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
@@ -286,12 +286,12 @@ where
     ) {
         operation.container(None, layout.bounds(), &mut |operation| {
             self.children
-                .iter()
+                .iter_mut()
                 .zip(&mut tree.children)
                 .zip(layout.children())
                 .for_each(|((child, state), layout)| {
                     child
-                        .as_widget()
+                        .as_widget_mut()
                         .operate(state, layout, renderer, operation);
                 });
         });

widget/src/lazy.rs

@@ -166,27 +166,29 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
-        self.with_element(|element| {
+        self.with_element_mut(|element| {
-            element
+            element.as_widget_mut().layout(
-                .as_widget()
+                &mut tree.children[0],
-                .layout(&mut tree.children[0], renderer, limits)
+                renderer,
+                limits,
+            )
         })
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
         operation: &mut dyn widget::Operation,
     ) {
-        self.with_element(|element| {
+        self.with_element_mut(|element| {
-            element.as_widget().operate(
+            element.as_widget_mut().operate(
                 &mut tree.children[0],
                 layout,
                 renderer,

widget/src/lazy/component.rs

@@ -299,15 +299,15 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
         let t = tree.state.downcast_mut::<Rc<RefCell<Option<Tree>>>>();
 
-        self.with_element(|element| {
+        self.with_element_mut(|element| {
-            element.as_widget().layout(
+            element.as_widget_mut().layout(
                 &mut t.borrow_mut().as_mut().unwrap().children[0],
                 renderer,
                 limits,
@@ -378,7 +378,7 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
@@ -387,8 +387,8 @@ where
         self.rebuild_element_with_operation(layout, operation);
 
         let tree = tree.state.downcast_mut::<Rc<RefCell<Option<Tree>>>>();
-        self.with_element(|element| {
+        self.with_element_mut(|element| {
-            element.as_widget().operate(
+            element.as_widget_mut().operate(
                 &mut tree.borrow_mut().as_mut().unwrap().children[0],
                 layout,
                 renderer,

widget/src/lazy/responsive.rs

@@ -5,16 +5,10 @@ use crate::core::renderer;
 use crate::core::widget;
 use crate::core::widget::tree::{self, Tree};
 use crate::core::{
-    self, Clipboard, Element, Event, Length, Point, Rectangle, Shell, Size,
+    self, Clipboard, Element, Event, Length, Rectangle, Shell, Size, Vector,
-    Vector, Widget,
+    Widget,
 };
 use crate::horizontal_space;
-use crate::runtime::overlay::Nested;
-
-use ouroboros::self_referencing;
-use std::cell::{RefCell, RefMut};
-use std::marker::PhantomData;
-use std::ops::Deref;
 
 /// A widget that is aware of its dimensions.
 ///
@@ -29,7 +23,7 @@ pub struct Responsive<
     Renderer = crate::Renderer,
 > {
     view: Box<dyn Fn(Size) -> Element<'a, Message, Theme, Renderer> + 'a>,
-    content: RefCell<Content<'a, Message, Theme, Renderer>>,
+    content: Element<'a, Message, Theme, Renderer>,
 }
 
 impl<'a, Message, Theme, Renderer> Responsive<'a, Message, Theme, Renderer>
@@ -47,91 +41,13 @@ where
     ) -> Self {
         Self {
             view: Box::new(view),
-            content: RefCell::new(Content {
+            content: Element::new(horizontal_space().width(0)),
-                size: Size::ZERO,
-                layout: None,
-                is_layout_invalid: true,
-                element: Element::new(horizontal_space().width(0)),
-            }),
         }
     }
 }
 
-struct Content<'a, Message, Theme, Renderer> {
-    size: Size,
-    layout: Option<layout::Node>,
-    is_layout_invalid: bool,
-    element: Element<'a, Message, Theme, Renderer>,
-}
-
-impl<'a, Message, Theme, Renderer> Content<'a, Message, Theme, Renderer>
-where
-    Renderer: core::Renderer,
-{
-    fn layout(&mut self, tree: &mut Tree, renderer: &Renderer) {
-        if self.layout.is_none() || self.is_layout_invalid {
-            self.layout = Some(self.element.as_widget().layout(
-                tree,
-                renderer,
-                &layout::Limits::new(Size::ZERO, self.size),
-            ));
-            self.is_layout_invalid = false;
-        }
-    }
-
-    fn update(
-        &mut self,
-        tree: &mut Tree,
-        new_size: Size,
-        view: &dyn Fn(Size) -> Element<'a, Message, Theme, Renderer>,
-    ) {
-        if self.size != new_size {
-            self.element = view(new_size);
-            self.size = new_size;
-            self.layout = None;
-
-            tree.diff(&self.element);
-        } else {
-            let is_tree_empty =
-                tree.tag == tree::Tag::stateless() && tree.children.is_empty();
-
-            if is_tree_empty {
-                self.layout = None;
-                tree.diff(&self.element);
-            }
-        }
-    }
-
-    fn resolve<R, T>(
-        &mut self,
-        tree: &mut Tree,
-        renderer: R,
-        layout: Layout<'_>,
-        view: &dyn Fn(Size) -> Element<'a, Message, Theme, Renderer>,
-        f: impl FnOnce(
-            &mut Tree,
-            R,
-            Layout<'_>,
-            &mut Element<'a, Message, Theme, Renderer>,
-        ) -> T,
-    ) -> T
-    where
-        R: Deref<Target = Renderer>,
-    {
-        self.update(tree, layout.bounds().size(), view);
-        self.layout(tree, renderer.deref());
-
-        let content_layout = Layout::with_offset(
-            layout.position() - Point::ORIGIN,
-            self.layout.as_ref().unwrap(),
-        );
-
-        f(tree, renderer, content_layout, &mut self.element)
-    }
-}
-
 struct State {
-    tree: RefCell<Tree>,
+    tree: Tree,
 }
 
 impl<Message, Theme, Renderer> Widget<Message, Theme, Renderer>
@@ -145,7 +61,7 @@ where
 
     fn state(&self) -> tree::State {
         tree::State::new(State {
-            tree: RefCell::new(Tree::empty()),
+            tree: Tree::empty(),
         })
     }
 
@@ -157,35 +73,22 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
-        _tree: &mut Tree,
+        tree: &mut Tree,
-        _renderer: &Renderer,
+        renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
-        layout::Node::new(limits.max())
-    }
-
-    fn operate(
-        &self,
-        tree: &mut Tree,
-        layout: Layout<'_>,
-        renderer: &Renderer,
-        operation: &mut dyn widget::Operation,
-    ) {
         let state = tree.state.downcast_mut::<State>();
-        let mut content = self.content.borrow_mut();
+        let size = limits.max();
 
-        content.resolve(
+        self.content = (self.view)(size);
-            &mut state.tree.borrow_mut(),
+        state.tree.diff(&self.content);
+
+        self.content.as_widget_mut().layout(
+            &mut state.tree,
             renderer,
-            layout,
+            &limits.loose(),
-            &self.view,
+        )
-            |tree, renderer, layout, element| {
-                element
-                    .as_widget()
-                    .operate(tree, layout, renderer, operation);
-            },
-        );
     }
 
     fn update(
@@ -200,35 +103,17 @@ where
         viewport: &Rectangle,
     ) {
         let state = tree.state.downcast_mut::<State>();
-        let mut content = self.content.borrow_mut();
 
-        let mut local_messages = vec![];
+        self.content.as_widget_mut().update(
-        let mut local_shell = Shell::new(&mut local_messages);
+            &mut state.tree,
-
+            event,
-        content.resolve(
-            &mut state.tree.borrow_mut(),
-            renderer,
             layout,
-            &self.view,
+            cursor,
-            |tree, renderer, layout, element| {
+            renderer,
-                element.as_widget_mut().update(
+            clipboard,
-                    tree,
+            shell,
-                    event,
+            viewport,
-                    layout,
-                    cursor,
-                    renderer,
-                    clipboard,
-                    &mut local_shell,
-                    viewport,
-                );
-            },
         );
-
-        if local_shell.is_layout_invalid() {
-            content.layout = None;
-        }
-
-        shell.merge(local_shell, std::convert::identity);
     }
 
     fn draw(
@@ -242,18 +127,15 @@ where
         viewport: &Rectangle,
     ) {
         let state = tree.state.downcast_ref::<State>();
-        let mut content = self.content.borrow_mut();
 
-        content.resolve(
+        self.content.as_widget().draw(
-            &mut state.tree.borrow_mut(),
+            &state.tree,
             renderer,
+            theme,
+            style,
             layout,
-            &self.view,
+            cursor,
-            |tree, renderer, layout, element| {
+            viewport,
-                element.as_widget().draw(
-                    tree, renderer, theme, style, layout, cursor, viewport,
-                );
-            },
         );
     }
 
@@ -266,79 +148,50 @@ where
         renderer: &Renderer,
     ) -> mouse::Interaction {
         let state = tree.state.downcast_ref::<State>();
-        let mut content = self.content.borrow_mut();
 
-        content.resolve(
+        self.content.as_widget().mouse_interaction(
-            &mut state.tree.borrow_mut(),
+            &state.tree,
-            renderer,
             layout,
-            &self.view,
+            cursor,
-            |tree, renderer, layout, element| {
+            viewport,
-                element
+            renderer,
-                    .as_widget()
-                    .mouse_interaction(tree, layout, cursor, viewport, renderer)
-            },
         )
     }
 
-    fn overlay<'b>(
+    fn operate(
-        &'b mut self,
+        &mut self,
-        tree: &'b mut Tree,
+        tree: &mut Tree,
-        layout: Layout<'b>,
+        layout: Layout<'_>,
+        renderer: &Renderer,
+        operation: &mut dyn widget::Operation,
+    ) {
+        let state = tree.state.downcast_mut::<State>();
+
+        self.content.as_widget_mut().operate(
+            &mut state.tree,
+            layout,
+            renderer,
+            operation,
+        );
+    }
+
+    fn overlay<'a>(
+        &'a mut self,
+        tree: &'a mut Tree,
+        layout: Layout<'a>,
         renderer: &Renderer,
         viewport: &Rectangle,
         translation: Vector,
-    ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
+    ) -> Option<overlay::Element<'a, Message, Theme, Renderer>> {
-        use std::ops::DerefMut;
+        let state = tree.state.downcast_mut::<State>();
 
-        let state = tree.state.downcast_ref::<State>();
+        self.content.as_widget_mut().overlay(
-
+            &mut state.tree,
-        let overlay = OverlayBuilder {
+            layout,
-            content: self.content.borrow_mut(),
+            renderer,
-            tree: state.tree.borrow_mut(),
+            viewport,
-            types: PhantomData,
+            translation,
-            overlay_builder: |content: &mut RefMut<
+        )
-                '_,
-                Content<'_, _, _, _>,
-            >,
-                              tree| {
-                content.update(tree, layout.bounds().size(), &self.view);
-                content.layout(tree, renderer);
-
-                let Content {
-                    element,
-                    layout: content_layout_node,
-                    is_layout_invalid,
-                    ..
-                } = content.deref_mut();
-
-                let content_layout = Layout::with_offset(
-                    layout.bounds().position() - Point::ORIGIN,
-                    content_layout_node.as_ref().unwrap(),
-                );
-
-                (
-                    element
-                        .as_widget_mut()
-                        .overlay(
-                            tree,
-                            content_layout,
-                            renderer,
-                            viewport,
-                            translation,
-                        )
-                        .map(|overlay| RefCell::new(Nested::new(overlay))),
-                    is_layout_invalid,
-                )
-            },
-        }
-        .build();
-
-        if overlay.with_overlay(|(overlay, _layout)| overlay.is_some()) {
-            Some(overlay::Element::new(Box::new(overlay)))
-        } else {
-            None
-        }
     }
 }
 
@@ -354,108 +207,3 @@ where
         Self::new(responsive)
     }
 }
-
-#[self_referencing]
-struct Overlay<'a, 'b, Message, Theme, Renderer> {
-    content: RefMut<'a, Content<'b, Message, Theme, Renderer>>,
-    tree: RefMut<'a, Tree>,
-    types: PhantomData<Message>,
-
-    #[borrows(mut content, mut tree)]
-    #[not_covariant]
-    overlay: (
-        Option<RefCell<Nested<'this, Message, Theme, Renderer>>>,
-        &'this mut bool,
-    ),
-}
-
-impl<Message, Theme, Renderer> Overlay<'_, '_, Message, Theme, Renderer> {
-    fn with_overlay_maybe<T>(
-        &self,
-        f: impl FnOnce(&mut Nested<'_, Message, Theme, Renderer>) -> T,
-    ) -> Option<T> {
-        self.with_overlay(|(overlay, _layout)| {
-            overlay.as_ref().map(|nested| (f)(&mut nested.borrow_mut()))
-        })
-    }
-
-    fn with_overlay_mut_maybe<T>(
-        &mut self,
-        f: impl FnOnce(&mut Nested<'_, Message, Theme, Renderer>) -> T,
-    ) -> Option<T> {
-        self.with_overlay_mut(|(overlay, _layout)| {
-            overlay.as_mut().map(|nested| (f)(nested.get_mut()))
-        })
-    }
-}
-
-impl<Message, Theme, Renderer> overlay::Overlay<Message, Theme, Renderer>
-    for Overlay<'_, '_, Message, Theme, Renderer>
-where
-    Renderer: core::Renderer,
-{
-    fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
-        self.with_overlay_maybe(|overlay| overlay.layout(renderer, bounds))
-            .unwrap_or_default()
-    }
-
-    fn draw(
-        &self,
-        renderer: &mut Renderer,
-        theme: &Theme,
-        style: &renderer::Style,
-        layout: Layout<'_>,
-        cursor: mouse::Cursor,
-    ) {
-        let _ = self.with_overlay_maybe(|overlay| {
-            overlay.draw(renderer, theme, style, layout, cursor);
-        });
-    }
-
-    fn mouse_interaction(
-        &self,
-        layout: Layout<'_>,
-        cursor: mouse::Cursor,
-        renderer: &Renderer,
-    ) -> mouse::Interaction {
-        self.with_overlay_maybe(|overlay| {
-            overlay.mouse_interaction(layout, cursor, renderer)
-        })
-        .unwrap_or_default()
-    }
-
-    fn update(
-        &mut self,
-        event: &Event,
-        layout: Layout<'_>,
-        cursor: mouse::Cursor,
-        renderer: &Renderer,
-        clipboard: &mut dyn Clipboard,
-        shell: &mut Shell<'_, Message>,
-    ) {
-        let mut is_layout_invalid = false;
-
-        let _ = self.with_overlay_mut_maybe(|overlay| {
-            overlay.update(event, layout, cursor, renderer, clipboard, shell);
-
-            is_layout_invalid = shell.is_layout_invalid();
-        });
-
-        if is_layout_invalid {
-            self.with_overlay_mut(|(_overlay, layout)| {
-                **layout = true;
-            });
-        }
-    }
-
-    fn operate(
-        &mut self,
-        layout: Layout<'_>,
-        renderer: &Renderer,
-        operation: &mut dyn widget::Operation,
-    ) {
-        let _ = self.with_overlay_mut_maybe(|overlay| {
-            overlay.operate(layout, renderer, operation);
-        });
-    }
-}

widget/src/mouse_area.rs

@@ -190,24 +190,26 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
-        self.content
+        self.content.as_widget_mut().layout(
-            .as_widget()
+            &mut tree.children[0],
-            .layout(&mut tree.children[0], renderer, limits)
+            renderer,
+            limits,
+        )
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
         operation: &mut dyn Operation,
     ) {
-        self.content.as_widget().operate(
+        self.content.as_widget_mut().operate(
             &mut tree.children[0],
             layout,
             renderer,

widget/src/overlay/menu.rs

@@ -369,7 +369,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         _tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,

widget/src/pane_grid.rs

@@ -418,7 +418,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -432,20 +432,19 @@ where
 
         let children = self
             .panes
-            .iter()
+            .iter_mut()
-            .copied()
+            .zip(&mut self.contents)
-            .zip(&self.contents)
             .zip(tree.children.iter_mut())
             .filter_map(|((pane, content), tree)| {
                 if self
                     .internal
                     .maximized()
-                    .is_some_and(|maximized| maximized != pane)
+                    .is_some_and(|maximized| maximized != *pane)
                 {
                     return Some(layout::Node::new(Size::ZERO));
                 }
 
-                let region = regions.get(&pane)?;
+                let region = regions.get(pane)?;
                 let size = Size::new(region.width, region.height);
 
                 let node = content.layout(
@@ -462,7 +461,7 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
@@ -470,15 +469,14 @@ where
     ) {
         operation.container(None, layout.bounds(), &mut |operation| {
             self.panes
-                .iter()
+                .iter_mut()
-                .copied()
+                .zip(&mut self.contents)
-                .zip(&self.contents)
                 .zip(&mut tree.children)
                 .zip(layout.children())
                 .filter(|(((pane, _), _), _)| {
                     self.internal
                         .maximized()
-                        .is_none_or(|maximized| *pane == maximized)
+                        .is_none_or(|maximized| **pane == maximized)
                 })
                 .for_each(|(((_, content), state), layout)| {
                     content.operate(state, layout, renderer, operation);

widget/src/pane_grid/content.rs

@@ -165,12 +165,12 @@ where
     }
 
     pub(crate) fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
-        if let Some(title_bar) = &self.title_bar {
+        if let Some(title_bar) = &mut self.title_bar {
             let max_size = limits.max();
 
             let title_bar_layout = title_bar.layout(
@@ -181,7 +181,7 @@ where
 
             let title_bar_size = title_bar_layout.size();
 
-            let body_layout = self.body.as_widget().layout(
+            let body_layout = self.body.as_widget_mut().layout(
                 &mut tree.children[0],
                 renderer,
                 &layout::Limits::new(
@@ -201,7 +201,7 @@ where
                 ],
             )
         } else {
-            self.body.as_widget().layout(
+            self.body.as_widget_mut().layout(
                 &mut tree.children[0],
                 renderer,
                 limits,
@@ -210,13 +210,13 @@ where
     }
 
     pub(crate) fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
         operation: &mut dyn widget::Operation,
     ) {
-        let body_layout = if let Some(title_bar) = &self.title_bar {
+        let body_layout = if let Some(title_bar) = &mut self.title_bar {
             let mut children = layout.children();
 
             title_bar.operate(
@@ -231,7 +231,7 @@ where
             layout
         };
 
-        self.body.as_widget().operate(
+        self.body.as_widget_mut().operate(
             &mut tree.children[0],
             body_layout,
             renderer,

widget/src/pane_grid/title_bar.rs

@@ -274,7 +274,7 @@ where
     }
 
     pub(crate) fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -282,7 +282,7 @@ where
         let limits = limits.shrink(self.padding);
         let max_size = limits.max();
 
-        let title_layout = self.content.as_widget().layout(
+        let title_layout = self.content.as_widget_mut().layout(
             &mut tree.children[0],
             renderer,
             &layout::Limits::new(Size::ZERO, max_size),
@@ -290,8 +290,8 @@ where
 
         let title_size = title_layout.size();
 
-        let node = if let Some(controls) = &self.controls {
+        let node = if let Some(controls) = &mut self.controls {
-            let controls_layout = controls.full.as_widget().layout(
+            let controls_layout = controls.full.as_widget_mut().layout(
                 &mut tree.children[1],
                 renderer,
                 &layout::Limits::new(Size::ZERO, max_size),
@@ -300,8 +300,8 @@ where
             if title_layout.bounds().width + controls_layout.bounds().width
                 > max_size.width
             {
-                if let Some(compact) = controls.compact.as_ref() {
+                if let Some(compact) = controls.compact.as_mut() {
-                    let compact_layout = compact.as_widget().layout(
+                    let compact_layout = compact.as_widget_mut().layout(
                         &mut tree.children[2],
                         renderer,
                         &layout::Limits::new(Size::ZERO, max_size),
@@ -369,7 +369,7 @@ where
     }
 
     pub(crate) fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
@@ -382,16 +382,16 @@ where
         let title_layout = children.next().unwrap();
         let mut show_title = true;
 
-        if let Some(controls) = &self.controls {
+        if let Some(controls) = &mut self.controls {
             let controls_layout = children.next().unwrap();
 
             if title_layout.bounds().width + controls_layout.bounds().width
                 > padded.bounds().width
             {
-                if let Some(compact) = controls.compact.as_ref() {
+                if let Some(compact) = controls.compact.as_mut() {
                     let compact_layout = children.next().unwrap();
 
-                    compact.as_widget().operate(
+                    compact.as_widget_mut().operate(
                         &mut tree.children[2],
                         compact_layout,
                         renderer,
@@ -400,7 +400,7 @@ where
                 } else {
                     show_title = false;
 
-                    controls.full.as_widget().operate(
+                    controls.full.as_widget_mut().operate(
                         &mut tree.children[1],
                         controls_layout,
                         renderer,
@@ -408,7 +408,7 @@ where
                     );
                 }
             } else {
-                controls.full.as_widget().operate(
+                controls.full.as_widget_mut().operate(
                     &mut tree.children[1],
                     controls_layout,
                     renderer,
@@ -418,7 +418,7 @@ where
         };
 
         if show_title {
-            self.content.as_widget().operate(
+            self.content.as_widget_mut().operate(
                 &mut tree.children[0],
                 title_layout,
                 renderer,

widget/src/pick_list.rs

@@ -348,7 +348,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,

widget/src/pin.rs

@@ -139,7 +139,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut widget::Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -151,7 +151,7 @@ where
 
         let node = self
             .content
-            .as_widget()
+            .as_widget_mut()
             .layout(tree, renderer, &layout::Limits::new(Size::ZERO, available))
             .move_to(self.position);
 
@@ -160,13 +160,13 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut widget::Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
         operation: &mut dyn widget::Operation,
     ) {
-        self.content.as_widget().operate(
+        self.content.as_widget_mut().operate(
             tree,
             layout.children().next().unwrap(),
             renderer,

widget/src/progress_bar.rs

@@ -157,7 +157,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         _tree: &mut Tree,
         _renderer: &Renderer,
         limits: &layout::Limits,

widget/src/qr_code.rs

@@ -136,7 +136,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         _tree: &mut Tree,
         _renderer: &Renderer,
         _limits: &layout::Limits,

widget/src/radio.rs

@@ -290,7 +290,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,

widget/src/row.rs

@@ -208,7 +208,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -222,13 +222,13 @@ where
             self.padding,
             self.spacing,
             self.align,
-            &self.children,
+            &mut self.children,
             &mut tree.children,
         )
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
@@ -236,12 +236,12 @@ where
     ) {
         operation.container(None, layout.bounds(), &mut |operation| {
             self.children
-                .iter()
+                .iter_mut()
                 .zip(&mut tree.children)
                 .zip(layout.children())
                 .for_each(|((child, state), layout)| {
                     child
-                        .as_widget()
+                        .as_widget_mut()
                         .operate(state, layout, renderer, operation);
                 });
         });
@@ -407,7 +407,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -449,8 +449,8 @@ where
             }
         };
 
-        for (i, child) in self.row.children.iter().enumerate() {
+        for (i, child) in self.row.children.iter_mut().enumerate() {
-            let node = child.as_widget().layout(
+            let node = child.as_widget_mut().layout(
                 &mut tree.children[i],
                 renderer,
                 &limits,
@@ -528,7 +528,7 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,

widget/src/rule.rs

@@ -112,7 +112,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         _tree: &mut Tree,
         _renderer: &Renderer,
         limits: &layout::Limits,

widget/src/scrollable.rs

@@ -421,7 +421,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -453,7 +453,7 @@ where
                         ),
                     );
 
-                    self.content.as_widget().layout(
+                    self.content.as_widget_mut().layout(
                         &mut tree.children[0],
                         renderer,
                         &child_limits,
@@ -527,7 +527,7 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
@@ -553,7 +553,7 @@ where
             self.id.as_ref().map(|id| &id.0),
             bounds,
             &mut |operation| {
-                self.content.as_widget().operate(
+                self.content.as_widget_mut().operate(
                     &mut tree.children[0],
                     layout.children().next().unwrap(),
                     renderer,

widget/src/sensor.rs

@@ -287,14 +287,16 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
-        self.content
+        self.content.as_widget_mut().layout(
-            .as_widget()
+            &mut tree.children[0],
-            .layout(&mut tree.children[0], renderer, limits)
+            renderer,
+            limits,
+        )
     }
 
     fn draw(
@@ -319,13 +321,13 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: core::Layout<'_>,
         renderer: &Renderer,
         operation: &mut dyn widget::Operation,
     ) {
-        self.content.as_widget().operate(
+        self.content.as_widget_mut().operate(
             &mut tree.children[0],
             layout,
             renderer,

widget/src/shader.rs

@@ -77,7 +77,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         _tree: &mut Tree,
         _renderer: &Renderer,
         limits: &layout::Limits,

widget/src/slider.rs

@@ -234,7 +234,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         _tree: &mut Tree,
         _renderer: &Renderer,
         limits: &layout::Limits,

widget/src/space.rs

@@ -65,7 +65,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         _tree: &mut Tree,
         _renderer: &Renderer,
         limits: &layout::Limits,

widget/src/stack.rs

@@ -158,7 +158,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -173,7 +173,7 @@ where
             ));
         }
 
-        let base = self.children[0].as_widget().layout(
+        let base = self.children[0].as_widget_mut().layout(
             &mut tree.children[0],
             renderer,
             &limits,
@@ -183,18 +183,21 @@ where
         let limits = layout::Limits::new(Size::ZERO, size);
 
         let nodes = std::iter::once(base)
-            .chain(self.children[1..].iter().zip(&mut tree.children[1..]).map(
+            .chain(
-                |(layer, tree)| {
+                self.children[1..]
-                    layer.as_widget().layout(tree, renderer, &limits)
+                    .iter_mut()
-                },
+                    .zip(&mut tree.children[1..])
-            ))
+                    .map(|(layer, tree)| {
+                        layer.as_widget_mut().layout(tree, renderer, &limits)
+                    }),
+            )
             .collect();
 
         layout::Node::with_children(size, nodes)
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
@@ -202,12 +205,12 @@ where
     ) {
         operation.container(None, layout.bounds(), &mut |operation| {
             self.children
-                .iter()
+                .iter_mut()
                 .zip(&mut tree.children)
                 .zip(layout.children())
                 .for_each(|((child, state), layout)| {
                     child
-                        .as_widget()
+                        .as_widget_mut()
                         .operate(state, layout, renderer, operation);
                 });
         });

widget/src/svg.rs

@@ -162,7 +162,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         _tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,

widget/src/table.rs

@@ -232,7 +232,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut widget::Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -265,7 +265,7 @@ where
         let mut y = self.padding_y;
 
         for (i, (cell, state)) in
-            self.cells.iter().zip(&mut tree.children).enumerate()
+            self.cells.iter_mut().zip(&mut tree.children).enumerate()
         {
             let row = i / columns;
             let column = i % columns;
@@ -306,7 +306,7 @@ where
             )
             .width(width);
 
-            let layout = cell.as_widget().layout(state, renderer, &limits);
+            let layout = cell.as_widget_mut().layout(state, renderer, &limits);
             let size = limits.resolve(width, Length::Shrink, layout.size());
 
             metrics.columns[column] = metrics.columns[column].max(size.width);
@@ -344,7 +344,7 @@ where
         let mut y = self.padding_y;
 
         for (i, (cell, state)) in
-            self.cells.iter().zip(&mut tree.children).enumerate()
+            self.cells.iter_mut().zip(&mut tree.children).enumerate()
         {
             let row = i / columns;
             let column = i % columns;
@@ -396,7 +396,7 @@ where
             )
             .width(width);
 
-            let layout = cell.as_widget().layout(state, renderer, &limits);
+            let layout = cell.as_widget_mut().layout(state, renderer, &limits);
             let size = limits.resolve(
                 if let Length::Fixed(_) = width {
                     width
@@ -581,7 +581,7 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut widget::Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
@@ -589,11 +589,12 @@ where
     ) {
         for ((cell, state), layout) in self
             .cells
-            .iter()
+            .iter_mut()
             .zip(&mut tree.children)
             .zip(layout.children())
         {
-            cell.as_widget().operate(state, layout, renderer, operation);
+            cell.as_widget_mut()
+                .operate(state, layout, renderer, operation);
         }
     }
 

widget/src/text/rich.rs

@@ -225,7 +225,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,

widget/src/text_editor.rs

@@ -597,7 +597,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut widget::Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -1051,7 +1051,7 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut widget::Tree,
         layout: Layout<'_>,
         _renderer: &Renderer,

widget/src/text_input.rs

@@ -297,7 +297,7 @@ where
     ///
     /// [`Renderer`]: text::Renderer
     pub fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -671,7 +671,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -680,7 +680,7 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         _renderer: &Renderer,

widget/src/themer.rs

@@ -90,23 +90,23 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
-        self.content.as_widget().layout(tree, renderer, limits)
+        self.content.as_widget_mut().layout(tree, renderer, limits)
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
         operation: &mut dyn Operation,
     ) {
         self.content
-            .as_widget()
+            .as_widget_mut()
             .operate(tree, layout, renderer, operation);
     }
 

widget/src/toggler.rs

@@ -270,7 +270,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,

widget/src/tooltip.rs

@@ -179,14 +179,16 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut widget::Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
-        self.content
+        self.content.as_widget_mut().layout(
-            .as_widget()
+            &mut tree.children[0],
-            .layout(&mut tree.children[0], renderer, limits)
+            renderer,
+            limits,
+        )
     }
 
     fn update(
@@ -294,7 +296,7 @@ where
         let tooltip = if let State::Hovered { cursor_position } = *state {
             Some(overlay::Element::new(Box::new(Overlay {
                 position: layout.position() + translation,
-                tooltip: &self.tooltip,
+                tooltip: &mut self.tooltip,
                 state: children.next().unwrap(),
                 cursor_position,
                 content_bounds: layout.bounds(),
@@ -366,7 +368,7 @@ where
     Renderer: text::Renderer,
 {
     position: Point,
-    tooltip: &'b Element<'a, Message, Theme, Renderer>,
+    tooltip: &'b mut Element<'a, Message, Theme, Renderer>,
     state: &'b mut widget::Tree,
     cursor_position: Point,
     content_bounds: Rectangle,
@@ -386,7 +388,7 @@ where
     fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
         let viewport = Rectangle::with_size(bounds);
 
-        let tooltip_layout = self.tooltip.as_widget().layout(
+        let tooltip_layout = self.tooltip.as_widget_mut().layout(
             self.state,
             renderer,
             &layout::Limits::new(

widget/src/vertical_slider.rs

@@ -238,7 +238,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         _tree: &mut Tree,
         _renderer: &Renderer,
         limits: &layout::Limits,