Rework pixel snapping, take two.

Author: xStrom

masonry/ARCHITECTURE.md

@@ -166,7 +166,7 @@ The current passes are:
 - **on_xxx_event:** Handles UX-related events, e.g. clicks, text entered, IME updates and accessibility input. Widgets can declare these events as "handled" which has a bunch of semantic implications.
 - **anim:** Do updates related to an animation frame.
 - **update:** Handles internal changes to some widgets, e.g. when the widget is marked as "disabled" or Masonry detects that a widget is hovered by a pointer.
-- **layout:** Container widgets measure their children with `LayoutCtx::compute_size` and then lay them out with `LayoutCtx::run_layout`, finally giving them a position with `LayoutCtx::place_child`.
+- **layout:** Container widgets measure their children with `LayoutCtx::compute_size` and then lay them out with `LayoutCtx::layout_child`, choosing an origin and size for each child.
 - **compose:** Computes the global transform/origin for every widget.
 - **paint** Paint every widget.
 - **accessibility:** Compute every widget's node in the accessibility tree.

masonry/examples/layers.rs

@@ -133,8 +133,7 @@ impl Widget for OverlayBox {
 
     fn layout(&mut self, ctx: &mut LayoutCtx<'_>, _props: &PropertiesRef<'_>, size: Size) {
         let child_size = ctx.compute_size(&mut self.child, SizeDef::fit(size), size.into());
-        ctx.run_layout(&mut self.child, child_size);
-        ctx.place_child(&mut self.child, Point::ORIGIN);
+        ctx.layout_child(&mut self.child, Point::ORIGIN, child_size);
     }
 
     fn paint(

masonry/screenshots/badged_button.png

@@ -72,11 +72,11 @@ Like with a leaf widget, the `measure` method must compute and return the length
 Before that, it must call [`MeasureCtx::compute_length`] for each of its own children.
 For a vertical stack, we want to sum these on the vertical axis and take the largest on the horizontal axis.
 
-Then later in `layout`, it must call [`LayoutCtx::run_layout`] then [`LayoutCtx::place_child`] for each of its own children:
+Then later in `layout`, it must call [`LayoutCtx::layout_child`] for each of its own children:
 
-- `LayoutCtx::run_layout` recursively calls `Widget::layout` on the child.
-  It takes a [`Size`] argument, which is the chosen size of the child.
-- `LayoutCtx::place_child` sets the child's position relative to the container.
+- `LayoutCtx::layout_child` recursively calls `Widget::layout` on the child.
+  It takes both a [`Point`] and [`Size`] argument, which are the chosen origin and size of the child.
+  The child's origin is in relation to the container.
 
 The `layout` method *must* iterate over all its children.
 Not doing so is a logical bug.
@@ -144,8 +144,7 @@ impl Widget for VerticalStack {
         let mut y_offset = 0.0;
         for child in &mut self.children {
             let child_size = ctx.compute_size(child, auto_size, context_size);
-            ctx.run_layout(child, child_size);
-            ctx.place_child(child, Point::new(0.0, y_offset));
+            ctx.layout_child(child, Point::new(0.0, y_offset), child_size);
 
             y_offset += child_size.height + self.gap;
         }
@@ -322,11 +321,11 @@ So for instance, if `VerticalStack::children_ids()` returns a list of three chil
 Pass methods in container widgets should only implement the logic that is specific to the container itself.
 For instance, a container widget with a background color should implement `paint` to draw the background.
 
+[`Point`]: crate::kurbo::Point
 [`Size`]: crate::kurbo::Size
 [`Widget`]: crate::core::Widget
 [`WidgetPod`]: crate::core::WidgetPod
 [`WidgetMut`]: crate::core::WidgetMut
 [`MeasureCtx::compute_length`]: crate::core::MeasureCtx::compute_length
-[`LayoutCtx::place_child`]: crate::core::LayoutCtx::place_child
-[`LayoutCtx::run_layout`]: crate::core::LayoutCtx::run_layout
+[`LayoutCtx::layout_child`]: crate::core::LayoutCtx::layout_child
 [`RegisterCtx::register_child`]: crate::core::RegisterCtx::register_child