Have AppDriver take a reference to RenderRoot for more flexibility (#808)

Author: PoignardAzur

masonry/README.md

@@ -54,10 +54,12 @@ impl AppDriver for Driver {
     fn on_action(&mut self, ctx: &mut DriverCtx<'_>, _widget_id: WidgetId, action: Action) {
         match action {
             Action::ButtonPressed(_) => {
-                let mut root: WidgetMut<RootWidget<Portal<Flex>>> = ctx.get_root();
-                let mut portal = RootWidget::child_mut(&mut root);
-                let mut flex = Portal::child_mut(&mut portal);
-                Flex::add_child(&mut flex, Label::new(self.next_task.clone()));
+                ctx.render_root().edit_root_widget(|mut root| {
+                    let mut root = root.downcast::<RootWidget<Portal<Flex>>>();
+                    let mut portal = RootWidget::child_mut(&mut root);
+                    let mut flex = Portal::child_mut(&mut portal);
+                    Flex::add_child(&mut flex, Label::new(self.next_task.clone()));
+                });
             }
             Action::TextChanged(new_text) => {
                 self.next_task = new_text.clone();

masonry/examples/calc_masonry.rs

@@ -254,11 +254,13 @@ impl AppDriver for CalcState {
             _ => unreachable!(),
         }
 
-        let mut root = ctx.get_root::<RootWidget<Flex>>();
-        let mut flex = RootWidget::child_mut(&mut root);
-        let mut label = Flex::child_mut(&mut flex, 1).unwrap();
-        let mut label = label.downcast::<Label>();
-        Label::set_text(&mut label, &*self.value);
+        ctx.render_root().edit_root_widget(|mut root| {
+            let mut root = root.downcast::<RootWidget<Flex>>();
+            let mut flex = RootWidget::child_mut(&mut root);
+            let mut label = Flex::child_mut(&mut flex, 1).unwrap();
+            let mut label = label.downcast::<Label>();
+            Label::set_text(&mut label, &*self.value);
+        });
     }
 }
 

masonry/examples/grid_masonry.rs

@@ -28,9 +28,11 @@ impl AppDriver for Driver {
                 self.grid_spacing += 0.5;
             }
 
-            let mut root = ctx.get_root::<RootWidget<Grid>>();
-            let mut grid = RootWidget::child_mut(&mut root);
-            Grid::set_spacing(&mut grid, self.grid_spacing);
+            ctx.render_root().edit_root_widget(|mut root| {
+                let mut root = root.downcast::<RootWidget<Grid>>();
+                let mut grid = RootWidget::child_mut(&mut root);
+                Grid::set_spacing(&mut grid, self.grid_spacing);
+            });
         }
     }
 }

masonry/examples/to_do_list.rs

@@ -6,10 +6,9 @@
 
 // On Windows platform, don't show a console when opening the app.
 #![windows_subsystem = "windows"]
-#![expect(elided_lifetimes_in_paths, reason = "Deferred: Noisy")]
 
 use masonry::dpi::LogicalSize;
-use masonry::widget::{Button, Flex, Label, Portal, RootWidget, TextArea, Textbox, WidgetMut};
+use masonry::widget::{Button, Flex, Label, Portal, RootWidget, TextArea, Textbox};
 use masonry::{Action, AppDriver, DriverCtx, WidgetId};
 use winit::window::Window;
 
@@ -23,17 +22,20 @@ impl AppDriver for Driver {
     fn on_action(&mut self, ctx: &mut DriverCtx<'_>, _widget_id: WidgetId, action: Action) {
         match action {
             Action::ButtonPressed(_) => {
-                let mut root: WidgetMut<RootWidget<Portal<Flex>>> = ctx.get_root();
-                let mut portal = RootWidget::child_mut(&mut root);
-                let mut flex = Portal::child_mut(&mut portal);
-                Flex::add_child(&mut flex, Label::new(self.next_task.clone()));
+                ctx.render_root().edit_root_widget(|mut root| {
+                    let mut root = root.downcast::<RootWidget<Portal<Flex>>>();
 
-                let mut first_row = Flex::child_mut(&mut flex, 0).unwrap();
-                let mut first_row = first_row.downcast::<Flex>();
-                let mut textbox = Flex::child_mut(&mut first_row, 0).unwrap();
-                let mut textbox = textbox.downcast::<Textbox>();
-                let mut text_area = Textbox::text_mut(&mut textbox);
-                TextArea::reset_text(&mut text_area, "");
+                    let mut portal = RootWidget::child_mut(&mut root);
+                    let mut flex = Portal::child_mut(&mut portal);
+                    Flex::add_child(&mut flex, Label::new(self.next_task.clone()));
+
+                    let mut first_row = Flex::child_mut(&mut flex, 0).unwrap();
+                    let mut first_row = first_row.downcast::<Flex>();
+                    let mut textbox = Flex::child_mut(&mut first_row, 0).unwrap();
+                    let mut textbox = textbox.downcast::<Textbox>();
+                    let mut text_area = Textbox::text_mut(&mut textbox);
+                    TextArea::reset_text(&mut text_area, "");
+                });
             }
             Action::TextChanged(new_text) => {
                 self.next_task = new_text.clone();

masonry/src/app_driver.rs

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::event_loop_runner::MasonryState;
-use crate::widget::WidgetMut;
-use crate::{Action, Widget, WidgetId};
+use crate::{Action, RenderRoot, WidgetId};
 
 pub struct DriverCtx<'a> {
-    // TODO
-    // This is exposed publicly for now to let people drive
-    // masonry on their own, but this is not expected to be
-    // stable or even supported. This is for short term
-    // expedience only while better solutions are devised.
-    #[doc(hidden)]
-    pub main_root_widget: WidgetMut<'a, Box<dyn Widget>>,
+    pub(crate) render_root: &'a mut RenderRoot,
 }
 
 pub trait AppDriver {
@@ -29,15 +22,12 @@ pub trait AppDriver {
 impl DriverCtx<'_> {
     // TODO - Add method to create timer
 
-    /// Return a [`WidgetMut`] to the root widget.
-    pub fn get_root<W: Widget>(&mut self) -> WidgetMut<'_, W> {
-        self.main_root_widget.downcast()
+    /// Access the [`RenderRoot`].
+    pub fn render_root(&mut self) -> &mut RenderRoot {
+        self.render_root
     }
 
     pub fn content_changed(&self) -> bool {
-        let ctx = &self.main_root_widget.ctx;
-        ctx.widget_state.needs_rewrite_passes()
-            || ctx.widget_state.needs_render()
-            || ctx.global_state.focus_changed()
+        self.render_root.needs_rewrite_passes()
     }
 }

masonry/src/doc/01_creating_app.md

@@ -90,10 +90,12 @@ impl AppDriver for Driver {
     fn on_action(&mut self, ctx: &mut DriverCtx<'_>, _widget_id: WidgetId, action: Action) {
         match action {
             Action::ButtonPressed(_) => {
-                let mut root: WidgetMut<RootWidget<Portal<Flex>>> = ctx.get_root();
-                let mut portal = RootWidget::child_mut(&mut root);
-                let mut flex = Portal::child_mut(&mut portal);
-                Flex::add_child(&mut flex, Label::new(self.next_task.clone()));
+                ctx.render_root().edit_root_widget(|mut root| {
+                    let mut root = root.downcast::<RootWidget<Portal<Flex>>>();
+                    let mut portal = RootWidget::child_mut(&mut root);
+                    let mut flex = Portal::child_mut(&mut portal);
+                    Flex::add_child(&mut flex, Label::new(self.next_task.clone()));
+                });
             }
             Action::TextChanged(new_text) => {
                 self.next_task = new_text.clone();
@@ -113,9 +115,11 @@ Because our widget tree only has one button and one textbox, there is no possibl
 
 When handling `ButtonPressed`:
 
-- `ctx.get_root()` returns a `WidgetMut<RootWidget<...>>`.
-- `root.child_mut()` returns a `WidgetMut<Portal<...>>` for the `Portal`.
-- `portal.child_mut()` returns a `WidgetMut<Flex>` for the `Flex`.
+- `ctx.render_root()` returns a reference to the `RenderRoot`, which owns the widget tree and all the associated visual state.
+- `RenderRoot::edit_root_widget()` takes a closure; that closure takes a `WidgetMut<Box<dyn Widget>>` which we call `root`. Once the closure returns, `RenderRoot` runs some passes to update the app's internal states.
+- `root.downcast::<...>()` returns a `WidgetMut<RootWidget<...>>`.
+- `RootWidget::child_mut()` returns a `WidgetMut<Portal<...>>` for the `Portal`.
+- `Portal::child_mut()` returns a `WidgetMut<Flex>` for the `Flex`.
 
 A [`WidgetMut`] is a smart reference type which lets us modify the widget tree.
 It's set up to automatically propagate update flags and update internal state when dropped.
@@ -165,7 +169,7 @@ The last step is to create our Winit window and start our main loop.
 
 Our complete program therefore looks like this:
 
-```rust,ignore
+```rust
 fn main() {
     const VERTICAL_WIDGET_SPACING: f64 = 20.0;
 
@@ -182,8 +186,7 @@ fn main() {
     );
     let main_widget = RootWidget::new(main_widget);
 
-    use masonry::app_driver::{AppDriver, DriverCtx};
-    use masonry::{Action, WidgetId};
+    use masonry::{Action, AppDriver, DriverCtx, WidgetId};
     use masonry::widget::{Label};
 
     struct Driver {
@@ -194,10 +197,12 @@ fn main() {
         fn on_action(&mut self, ctx: &mut DriverCtx<'_>, _widget_id: WidgetId, action: Action) {
             match action {
                 Action::ButtonPressed(_) => {
-                    let mut root: WidgetMut<RootWidget<Portal<Flex>>> = ctx.get_root();
-                    let mut portal = root.child_mut();
-                    let mut flex = portal.child_mut();
-                    flex.add_child(Label::new(self.next_task.clone()));
+                    ctx.render_root().edit_root_widget(|mut root| {
+                        let mut root = root.downcast::<RootWidget<Portal<Flex>>>();
+                        let mut portal = RootWidget::child_mut(&mut root);
+                        let mut flex = Portal::child_mut(&mut portal);
+                        Flex::add_child(&mut flex, Label::new(self.next_task.clone()));
+                    });
                 }
                 Action::TextChanged(new_text) => {
                     self.next_task = new_text.clone();
@@ -211,14 +216,16 @@ fn main() {
         next_task: String::new(),
     };
 
-use masonry::dpi::LogicalSize;
+    use masonry::dpi::LogicalSize;
     use winit::window::Window;
 
     let window_attributes = Window::default_attributes()
         .with_title("To-do list")
         .with_resizable(true)
         .with_min_inner_size(LogicalSize::new(400.0, 400.0));
 
+    # return;
+
     masonry::event_loop_runner::run(
         masonry::event_loop_runner::EventLoop::with_user_event(),
         window_attributes,

masonry/src/doc/02_implementing_widget.md

@@ -82,13 +82,9 @@ As mentioned in the previous chapter, a `WidgetMut` is a smart reference type to
 Most Widgets will implement methods that let their users "project" a WidgetMut from a parent to its child.
 For example, `WidgetMut<Portal<MyWidget>>` has a `get_child_mut()` method that returns a `WidgetMut<MyWidget>`.
 
-So far, we've seen one way to get a WidgetMut: the [`DriverCtx::get_root()`] method in `AppDriver` implementations.
+So far, we've seen one way to get a WidgetMut: the [`RenderRoot::edit_root_widget()`] method.
 This methods returns a WidgetMut to the root widget, which you can then project into a WidgetMut reference to its descendants.
 
-<!-- TODO - Change AppDriver trait to take a `&mut RenderRoot` instead, and rewrite above doc. -->
-
-<!-- TODO - Mention edit_root_widget, edit_widget. -->
-
 ### Using WidgetMut in your custom Widget code
 
 The WidgetMut type only has two fields, both public:
@@ -330,7 +326,7 @@ The next one is about creating a container widgets, and the complications it add
 
 [`Widget`]: crate::Widget
 [`WidgetMut`]: crate::widget::WidgetMut
-[`DriverCtx::get_root()`]: crate::DriverCtx::get_root
 [`ButtonPressed`]: crate::Action::ButtonPressed
 [`vello::Scene`]: crate::vello::Scene
 [`Role::Button`]: accesskit::Role::Button
+[`RenderRoot::edit_root_widget()`]: crate::RenderRoot::edit_root_widget

masonry/src/event_loop_runner.rs

@@ -677,13 +677,11 @@ impl MasonryState<'_> {
         while let Some(signal) = self.render_root.pop_signal() {
             match signal {
                 render_root::RenderRootSignal::Action(action, widget_id) => {
-                    self.render_root.edit_root_widget(|root| {
-                        debug!("Action {:?} on widget {:?}", action, widget_id);
-                        let mut driver_ctx = DriverCtx {
-                            main_root_widget: root,
-                        };
-                        app_driver.on_action(&mut driver_ctx, widget_id, action);
-                    });
+                    let mut driver_ctx = DriverCtx {
+                        render_root: &mut self.render_root,
+                    };
+                    debug!("Action {:?} on widget {:?}", action, widget_id);
+                    app_driver.on_action(&mut driver_ctx, widget_id, action);
                 }
                 render_root::RenderRootSignal::StartIme => {
                     window.set_ime_allowed(true);

masonry/src/lib.rs

@@ -30,10 +30,12 @@
 //!     fn on_action(&mut self, ctx: &mut DriverCtx<'_>, _widget_id: WidgetId, action: Action) {
 //!         match action {
 //!             Action::ButtonPressed(_) => {
-//!                 let mut root: WidgetMut<RootWidget<Portal<Flex>>> = ctx.get_root();
-//!                 let mut portal = RootWidget::child_mut(&mut root);
-//!                 let mut flex = Portal::child_mut(&mut portal);
-//!                 Flex::add_child(&mut flex, Label::new(self.next_task.clone()));
+//!                 ctx.render_root().edit_root_widget(|mut root| {
+//!                     let mut root = root.downcast::<RootWidget<Portal<Flex>>>();
+//!                     let mut portal = RootWidget::child_mut(&mut root);
+//!                     let mut flex = Portal::child_mut(&mut portal);
+//!                     Flex::add_child(&mut flex, Label::new(self.next_task.clone()));
+//!                 });
 //!             }
 //!             Action::TextChanged(new_text) => {
 //!                 self.next_task = new_text.clone();

masonry/src/render_root.rs

@@ -206,7 +206,16 @@ impl RenderRoot {
         root
     }
 
-    pub(crate) fn root_state(&mut self) -> &mut WidgetState {
+    pub(crate) fn root_state(&self) -> &WidgetState {
+        self.widget_arena
+            .widget_states
+            .root_token()
+            .into_child(self.root.id())
+            .expect("root widget not in widget tree")
+            .item
+    }
+
+    pub(crate) fn root_state_mut(&mut self) -> &mut WidgetState {
         self.widget_arena
             .widget_states
             .root_token_mut()
@@ -225,8 +234,8 @@ impl RenderRoot {
             }
             WindowEvent::Resize(size) => {
                 self.size = size;
-                self.root_state().request_layout = true;
-                self.root_state().needs_layout = true;
+                self.root_state_mut().request_layout = true;
+                self.root_state_mut().needs_layout = true;
                 self.run_rewrite_passes();
                 Handled::Yes
             }
@@ -592,8 +601,7 @@ impl RenderRoot {
         &self.root_state().focus_chain
     }
 
-    #[allow(dead_code)]
-    pub(crate) fn needs_rewrite_passes(&mut self) -> bool {
+    pub(crate) fn needs_rewrite_passes(&self) -> bool {
         self.root_state().needs_rewrite_passes() || self.global_state.focus_changed()
     }
 }

masonry/src/widget/widget_state.rs

@@ -278,8 +278,4 @@ impl WidgetState {
             || self.needs_update_disabled
             || self.needs_update_stashed
     }
-
-    pub(crate) fn needs_render(&self) -> bool {
-        self.needs_anim || self.needs_paint || self.needs_accessibility
-    }
 }

xilem/src/driver.rs

@@ -109,15 +109,16 @@ where
         if rebuild {
             let next_view = (self.logic)(&mut self.state);
 
-            let mut root = masonry_ctx.get_root::<RootWidget<View::Widget>>();
-
-            next_view.rebuild(
-                &self.current_view,
-                &mut self.view_state,
-                &mut self.ctx,
-                RootWidget::child_mut(&mut root),
-            );
-            self.current_view = next_view;
+            masonry_ctx.render_root().edit_root_widget(|mut root| {
+                let mut root = root.downcast::<RootWidget<View::Widget>>();
+                next_view.rebuild(
+                    &self.current_view,
+                    &mut self.view_state,
+                    &mut self.ctx,
+                    RootWidget::child_mut(&mut root),
+                );
+                self.current_view = next_view;
+            });
         }
         if cfg!(debug_assertions) && rebuild && !masonry_ctx.content_changed() {
             tracing::debug!("Nothing changed as result of action");