Reorganize Masonry modules (#848)

masonry/README.md

@@ -40,9 +40,10 @@ Lots of things need improvements, e.g. text input is janky and snapshot testing
 The to-do-list example looks like this:
 
 ```rust
+use masonry::app::{AppDriver, DriverCtx};
+use masonry::core::{Action, Widget, WidgetId};
 use masonry::dpi::LogicalSize;
-use masonry::widget::{Button, Flex, Label, Portal, RootWidget, Textbox, WidgetMut};
-use masonry::{Action, AppDriver, DriverCtx, WidgetId};
+use masonry::widgets::{Button, Flex, Label, Portal, RootWidget, Textbox};
 use winit::window::Window;
 
 struct Driver {
@@ -87,8 +88,8 @@ fn main() {
         .with_resizable(true)
         .with_min_inner_size(window_size);
 
-    masonry::event_loop_runner::run(
-        masonry::event_loop_runner::EventLoop::with_user_event(),
+    masonry::app::run(
+        masonry::app::EventLoop::with_user_event(),
         window_attributes,
         RootWidget::new(main_widget),
         Driver {

masonry/examples/calc_masonry.rs

@@ -13,14 +13,16 @@
 #![expect(elided_lifetimes_in_paths, reason = "Deferred: Noisy")]
 
 use accesskit::{Node, Role};
-use masonry::dpi::LogicalSize;
-use masonry::text::StyleProperty;
-use masonry::widget::{Align, CrossAxisAlignment, Flex, Label, RootWidget, SizedBox};
-use masonry::{
-    AccessCtx, AccessEvent, Action, AppDriver, BoxConstraints, Color, DriverCtx, EventCtx,
-    LayoutCtx, PaintCtx, Point, PointerEvent, QueryCtx, RegisterCtx, Size, TextEvent, Update,
-    UpdateCtx, Widget, WidgetId, WidgetPod,
+use masonry::app::{AppDriver, DriverCtx};
+use masonry::core::{
+    AccessCtx, AccessEvent, Action, BoxConstraints, EventCtx, LayoutCtx, PaintCtx, PointerEvent,
+    QueryCtx, RegisterCtx, StyleProperty, TextEvent, Update, UpdateCtx, Widget, WidgetId,
+    WidgetPod,
 };
+use masonry::dpi::LogicalSize;
+use masonry::kurbo::{Point, Size};
+use masonry::peniko::Color;
+use masonry::widgets::{Align, CrossAxisAlignment, Flex, Label, RootWidget, SizedBox};
 use smallvec::{smallvec, SmallVec};
 use tracing::{trace, trace_span, Span};
 use vello::Scene;
@@ -392,8 +394,8 @@ fn main() {
         in_num: false,
     };
 
-    masonry::event_loop_runner::run(
-        masonry::event_loop_runner::EventLoop::with_user_event(),
+    masonry::app::run(
+        masonry::app::EventLoop::with_user_event(),
         window_attributes,
         RootWidget::new(build_calc()),
         calc_state,

masonry/examples/custom_widget.rs

@@ -11,13 +11,15 @@
 #![expect(clippy::cast_possible_truncation, reason = "Deferred: Noisy")]
 
 use accesskit::{Node, Role};
-use masonry::kurbo::{BezPath, Stroke};
-use masonry::widget::{ObjectFit, RootWidget};
-use masonry::{
-    palette, AccessCtx, AccessEvent, Action, Affine, AppDriver, BoxConstraints, Color, DriverCtx,
-    EventCtx, LayoutCtx, PaintCtx, Point, PointerEvent, QueryCtx, Rect, RegisterCtx, Size,
-    TextEvent, Widget, WidgetId,
+use masonry::app::{AppDriver, DriverCtx};
+use masonry::core::{
+    AccessCtx, AccessEvent, Action, BoxConstraints, EventCtx, LayoutCtx, ObjectFit, PaintCtx,
+    PointerEvent, QueryCtx, RegisterCtx, TextEvent, Widget, WidgetId,
 };
+use masonry::kurbo::{Affine, BezPath, Point, Rect, Size, Stroke};
+use masonry::palette;
+use masonry::peniko::Color;
+use masonry::widgets::RootWidget;
 use parley::layout::Alignment;
 use parley::style::{FontFamily, FontStack, StyleProperty};
 use smallvec::SmallVec;
@@ -116,7 +118,7 @@ impl Widget for CustomWidget {
         text_layout.align(None, Alignment::Start);
 
         // We can pass a transform matrix to rotate the text we render
-        masonry::text::render_text(
+        masonry::core::render_text(
             scene,
             Affine::rotate(std::f64::consts::FRAC_PI_4).then_translate((80.0, 40.0).into()),
             &text_layout,
@@ -155,8 +157,8 @@ fn main() {
     let my_string = "Masonry + Vello".to_string();
     let window_attributes = Window::default_attributes().with_title("Fancy colors");
 
-    masonry::event_loop_runner::run(
-        masonry::event_loop_runner::EventLoop::with_user_event(),
+    masonry::app::run(
+        masonry::app::EventLoop::with_user_event(),
         window_attributes,
         RootWidget::new(CustomWidget(my_string)),
         Driver,

masonry/examples/grid_masonry.rs

@@ -6,10 +6,11 @@
 // On Windows platform, don't show a console when opening the app.
 #![windows_subsystem = "windows"]
 
+use masonry::app::{AppDriver, DriverCtx};
+use masonry::core::{Action, PointerButton, StyleProperty, WidgetId};
 use masonry::dpi::LogicalSize;
-use masonry::text::StyleProperty;
-use masonry::widget::{Button, Grid, GridParams, Prose, RootWidget, SizedBox, TextArea};
-use masonry::{Action, AppDriver, Color, DriverCtx, PointerButton, WidgetId};
+use masonry::peniko::Color;
+use masonry::widgets::{Button, Grid, GridParams, Prose, RootWidget, SizedBox, TextArea};
 use parley::layout::Alignment;
 use winit::window::Window;
 
@@ -118,8 +119,8 @@ fn main() {
         .with_resizable(true)
         .with_min_inner_size(window_size);
 
-    masonry::event_loop_runner::run(
-        masonry::event_loop_runner::EventLoop::with_user_event(),
+    masonry::app::run(
+        masonry::app::EventLoop::with_user_event(),
         window_attributes,
         RootWidget::new(main_widget),
         driver,

masonry/examples/hello_masonry.rs

@@ -7,10 +7,11 @@
 // On Windows platform, don't show a console when opening the app.
 #![windows_subsystem = "windows"]
 
+use masonry::app::{AppDriver, DriverCtx};
+use masonry::core::{Action, StyleProperty, WidgetId};
 use masonry::dpi::LogicalSize;
-use masonry::text::StyleProperty;
-use masonry::widget::{Button, Flex, Label, RootWidget};
-use masonry::{Action, AppDriver, DriverCtx, FontWeight, WidgetId};
+use masonry::parley::style::FontWeight;
+use masonry::widgets::{Button, Flex, Label, RootWidget};
 use winit::window::Window;
 
 const VERTICAL_WIDGET_SPACING: f64 = 20.0;
@@ -49,8 +50,8 @@ fn main() {
         .with_resizable(true)
         .with_min_inner_size(window_size);
 
-    masonry::event_loop_runner::run(
-        masonry::event_loop_runner::EventLoop::with_user_event(),
+    masonry::app::run(
+        masonry::app::EventLoop::with_user_event(),
         window_attributes,
         RootWidget::new(main_widget),
         Driver,

masonry/examples/simple_image.rs

@@ -8,9 +8,10 @@
 // On Windows platform, don't show a console when opening the app.
 #![windows_subsystem = "windows"]
 
+use masonry::app::{AppDriver, DriverCtx};
+use masonry::core::{Action, ObjectFit, WidgetId};
 use masonry::dpi::LogicalSize;
-use masonry::widget::{Image, ObjectFit, RootWidget};
-use masonry::{Action, AppDriver, DriverCtx, WidgetId};
+use masonry::widgets::{Image, RootWidget};
 use vello::peniko::{Image as ImageBuf, ImageFormat};
 use winit::window::Window;
 
@@ -41,8 +42,8 @@ fn main() {
         .with_min_inner_size(window_size)
         .with_max_inner_size(window_size);
 
-    masonry::event_loop_runner::run(
-        masonry::event_loop_runner::EventLoop::with_user_event(),
+    masonry::app::run(
+        masonry::app::EventLoop::with_user_event(),
         window_attributes,
         RootWidget::new(make_image()),
         Driver,

masonry/examples/to_do_list.rs

@@ -7,9 +7,10 @@
 // On Windows platform, don't show a console when opening the app.
 #![windows_subsystem = "windows"]
 
+use masonry::app::{AppDriver, DriverCtx};
+use masonry::core::{Action, Widget, WidgetId};
 use masonry::dpi::LogicalSize;
-use masonry::widget::{Button, Flex, Label, Portal, RootWidget, TextArea, Textbox};
-use masonry::{Action, AppDriver, DriverCtx, Widget, WidgetId};
+use masonry::widgets::{Button, Flex, Label, Portal, RootWidget, TextArea, Textbox};
 use winit::window::Window;
 
 const VERTICAL_WIDGET_SPACING: f64 = 20.0;
@@ -64,8 +65,8 @@ fn main() {
         .with_resizable(true)
         .with_min_inner_size(window_size);
 
-    masonry::event_loop_runner::run(
-        masonry::event_loop_runner::EventLoop::with_user_event(),
+    masonry::app::run(
+        masonry::app::EventLoop::with_user_event(),
         window_attributes,
         RootWidget::new(make_widget_tree()),
         Driver {

masonry/examples/two_textboxes.rs

@@ -7,9 +7,10 @@
 // On Windows platform, don't show a console when opening the app.
 #![windows_subsystem = "windows"]
 
+use masonry::app::{AppDriver, DriverCtx};
+use masonry::core::{Action, WidgetId};
 use masonry::dpi::LogicalSize;
-use masonry::widget::{Flex, RootWidget, Textbox};
-use masonry::{Action, AppDriver, DriverCtx, WidgetId};
+use masonry::widgets::{Flex, RootWidget, Textbox};
 use winit::window::Window;
 
 const VERTICAL_WIDGET_SPACING: f64 = 20.0;
@@ -34,8 +35,8 @@ fn main() {
         .with_resizable(true)
         .with_min_inner_size(window_size);
 
-    masonry::event_loop_runner::run(
-        masonry::event_loop_runner::EventLoop::with_user_event(),
+    masonry::app::run(
+        masonry::app::EventLoop::with_user_event(),
         window_attributes,
         RootWidget::new(main_widget),
         Driver,

masonry/src/app_driver.rs → masonry/src/app/app_driver.rs

@@ -1,8 +1,8 @@
 // Copyright 2024 the Xilem Authors
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::event_loop_runner::MasonryState;
-use crate::{Action, RenderRoot, WidgetId};
+use crate::app::{MasonryState, RenderRoot};
+use crate::core::{Action, WidgetId};
 
 /// Context for the [`AppDriver`] trait.
 ///
@@ -19,7 +19,7 @@ pub struct DriverCtx<'a> {
 
 /// A trait for defining how your app interacts with the Masonry widget tree.
 ///
-/// When launching your app with [`crate::event_loop_runner::run`], you need to provide
+/// When launching your app with [`crate::app::run`], you need to provide
 /// a type that implements this trait.
 pub trait AppDriver {
     /// A hook which will be executed when a widget emits an [`Action`].
@@ -51,7 +51,7 @@ impl DriverCtx<'_> {
 /// Doctests aren't collected under `cfg(test)`; we can use `cfg(doctest)` instead
 mod doctests {
     /// ```no_run
-    /// use masonry::DriverCtx;
+    /// use masonry::app::DriverCtx;
     /// let _ctx = DriverCtx {
     ///     render_root: unimplemented!()
     /// };

masonry/src/event_loop_runner.rs → masonry/src/app/event_loop_runner.rs

@@ -22,17 +22,20 @@ use winit::event::{
 use winit::event_loop::ActiveEventLoop;
 use winit::window::{Window, WindowAttributes, WindowId};
 
-use crate::app_driver::{AppDriver, DriverCtx};
+use crate::app::{
+    AppDriver, DriverCtx, RenderRoot, RenderRootOptions, RenderRootSignal, WindowSizePolicy,
+};
+use crate::core::{
+    PointerButton, PointerEvent, PointerState, TextEvent, Widget, WidgetId, WindowEvent,
+};
 use crate::dpi::LogicalPosition;
-use crate::event::{PointerButton, PointerState, WindowEvent};
-use crate::render_root::{self, RenderRoot, WindowSizePolicy};
-use crate::{Color, PointerEvent, TextEvent, Widget, WidgetId};
+use crate::peniko::Color;
 
 #[derive(Debug)]
 pub enum MasonryUserEvent {
     AccessKit(accesskit_winit::Event),
     // TODO: A more considered design here
-    Action(crate::Action, WidgetId),
+    Action(crate::core::Action, WidgetId),
 }
 
 impl From<accesskit_winit::Event> for MasonryUserEvent {
@@ -139,7 +142,7 @@ pub fn run_with(
     // already been set, we get an error which we swallow.
     // By now, we're about to take control of the event loop. The user is unlikely
     // to try to set their own subscriber once the event loop has started.
-    let _ = crate::tracing_backend::try_init_tracing();
+    let _ = crate::app::try_init_tracing();
 
     let mut main_state = MainState {
         masonry_state: MasonryState::new(window, &event_loop, root_widget, background_color),
@@ -234,7 +237,7 @@ impl MasonryState<'_> {
             render_cx,
             render_root: RenderRoot::new(
                 root_widget,
-                render_root::RenderRootOptions {
+                RenderRootOptions {
                     use_system_fonts: true,
                     size_policy: WindowSizePolicy::User,
                     scale_factor,
@@ -656,7 +659,7 @@ impl MasonryState<'_> {
                 .render_root
                 .global_state
                 .signal_queue
-                .push_back(render_root::RenderRootSignal::Action(action, widget)),
+                .push_back(RenderRootSignal::Action(action, widget)),
         }
 
         self.handle_signals(event_loop, app_driver);
@@ -681,63 +684,63 @@ impl MasonryState<'_> {
         let mut needs_redraw = false;
         while let Some(signal) = self.render_root.pop_signal() {
             match signal {
-                render_root::RenderRootSignal::Action(action, widget_id) => {
+                RenderRootSignal::Action(action, widget_id) => {
                     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 => {
+                RenderRootSignal::StartIme => {
                     window.set_ime_allowed(true);
                 }
-                render_root::RenderRootSignal::EndIme => {
+                RenderRootSignal::EndIme => {
                     window.set_ime_allowed(false);
                 }
-                render_root::RenderRootSignal::ImeMoved(position, size) => {
+                RenderRootSignal::ImeMoved(position, size) => {
                     window.set_ime_cursor_area(position, size);
                 }
-                render_root::RenderRootSignal::RequestRedraw => {
+                RenderRootSignal::RequestRedraw => {
                     needs_redraw = true;
                 }
-                render_root::RenderRootSignal::RequestAnimFrame => {
+                RenderRootSignal::RequestAnimFrame => {
                     // TODO
                     needs_redraw = true;
                 }
-                render_root::RenderRootSignal::TakeFocus => {
+                RenderRootSignal::TakeFocus => {
                     window.focus_window();
                 }
-                render_root::RenderRootSignal::SetCursor(cursor) => {
+                RenderRootSignal::SetCursor(cursor) => {
                     window.set_cursor(cursor);
                 }
-                render_root::RenderRootSignal::SetSize(size) => {
+                RenderRootSignal::SetSize(size) => {
                     // TODO - Handle return value?
                     let _ = window.request_inner_size(size);
                 }
-                render_root::RenderRootSignal::SetTitle(title) => {
+                RenderRootSignal::SetTitle(title) => {
                     window.set_title(&title);
                 }
-                render_root::RenderRootSignal::DragWindow => {
+                RenderRootSignal::DragWindow => {
                     // TODO - Handle return value?
                     let _ = window.drag_window();
                 }
-                render_root::RenderRootSignal::DragResizeWindow(direction) => {
+                RenderRootSignal::DragResizeWindow(direction) => {
                     // TODO - Handle return value?
                     let _ = window.drag_resize_window(direction);
                 }
-                render_root::RenderRootSignal::ToggleMaximized => {
+                RenderRootSignal::ToggleMaximized => {
                     window.set_maximized(!window.is_maximized());
                 }
-                render_root::RenderRootSignal::Minimize => {
+                RenderRootSignal::Minimize => {
                     window.set_minimized(true);
                 }
-                render_root::RenderRootSignal::Exit => {
+                RenderRootSignal::Exit => {
                     event_loop.exit();
                 }
-                render_root::RenderRootSignal::ShowWindowMenu(position) => {
+                RenderRootSignal::ShowWindowMenu(position) => {
                     window.show_window_menu(position);
                 }
-                render_root::RenderRootSignal::WidgetSelectedInInspector(widget_id) => {
+                RenderRootSignal::WidgetSelectedInInspector(widget_id) => {
                     let (widget, state) = self.render_root.widget_arena.get_pair(widget_id);
                     let widget_name = widget.item.short_type_name();
                     let display_name = if let Some(debug_text) = widget.item.get_debug_text() {