Keep the pane type out of the layout pass (#141)

Pure refactor, extracted from #139. No behavior change.

The layout pass never looks at a pane's contents. All it needs from
`Behavior` are a few numbers, so this gathers them up front into a
`LayoutContext`:

```rust
pub(crate) struct LayoutContext<'a> {
    pub gap_width: f32,
    pub tab_bar_height: f32,
    pub grid_auto_column_count: &'a dyn Fn(usize, Rect, f32) -> usize,
    pub tab_auto_selected: &'a Cell<bool>,
}
```

Two consequences:

* Every layout signature loses both its `style` and `behavior` arguments
— `Tiles::layout_tile` goes from 5 parameters to 3.
* The layout code no longer mentions `Pane` at all, so it can lay out a
`Tiles<T>` for any `T`, not only the one the `Behavior` was written for.
#139 needs exactly that.

### Drive-by fix

`Tabs::layout` called `Behavior::on_edit(TabSelected)` from deep inside
the layout recursion. It now reports the auto-selection up through the
`LayoutContext` and the single caller emits the event. Same event, same
conditions — but laying out a tree is no longer a way to trigger
user-visible callbacks, which matters once anything wants to lay out a
tree speculatively.

### Breaking

⚠️ `Linear::layout` is no longer `pub`, matching the other containers.
It took `&mut Tiles` and a `&mut dyn Behavior`, so it was not callable
in practice.

### Testing

`cargo fmt --check`, `cargo clippy --all-features --all-targets` and
`cargo test --all-features` all clean. No new tests: this is intended to
be behavior-preserving, and the existing `test_grid_with_chaos_monkey`
exercises the layout paths.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: emilk

CHANGELOG.md

@@ -1,6 +1,11 @@
 # `egui_tiles` Changelog
 
 
+## Unreleased
+
+* ⚠️ `Linear::layout` is no longer `pub`. It took `&mut Tiles` and a `&mut dyn Behavior`, so it could not be called usefully from outside the crate.
+
+
 ## 0.16.0 - 2026-06-26
 Full diff at https://github.com/rerun-io/egui_tiles/compare/0.15.0..HEAD
 

src/behavior.rs

@@ -35,6 +35,57 @@ pub struct TabState {
     pub closable: bool,
 }
 
+/// Everything the layout pass needs from a [`Behavior`], with the pane type erased.
+///
+/// The layout pass never looks at a pane's contents — it only needs a handful of numbers.
+/// Gathering them up front keeps `Pane` out of the layout signatures entirely, which lets the
+/// same code lay out any [`Tiles`], whatever it happens to store in its panes.
+pub(crate) struct LayoutContext<'a> {
+    pub gap_width: f32,
+    pub tab_bar_height: f32,
+    pub grid_auto_column_count: &'a dyn Fn(usize, Rect, f32) -> usize,
+
+    /// Set by the layout pass if it had to pick an active tab for a [`crate::Tabs`] container.
+    ///
+    /// Reported back to the caller rather than straight to [`Behavior::on_edit`]: laying out
+    /// the tree is not the place to be emitting user-visible edit events from.
+    pub tab_auto_selected: &'a std::cell::Cell<bool>,
+}
+
+/// Lay out `tiles` starting at `root`, using only the pane-agnostic parts of `behavior`.
+///
+/// Generic over the pane type of `tiles`, which need not be the pane type `behavior` is for.
+///
+/// Returns `true` if the pass had to auto-select an active tab, in which case the caller
+/// should report [`EditAction::TabSelected`].
+pub(crate) fn layout_tiles<Pane, TilesPane>(
+    tiles: &mut Tiles<TilesPane>,
+    root: Option<TileId>,
+    behavior: &dyn Behavior<Pane>,
+    style: &egui::Style,
+    rect: Rect,
+) -> bool {
+    let Some(root) = root else {
+        return false;
+    };
+
+    let grid_auto_column_count = |num_visible_children, rect, gap| {
+        behavior.grid_auto_column_count(num_visible_children, rect, gap)
+    };
+    let tab_auto_selected = std::cell::Cell::new(false);
+
+    let layout = LayoutContext {
+        gap_width: behavior.gap_width(style),
+        tab_bar_height: behavior.tab_bar_height(style),
+        grid_auto_column_count: &grid_auto_column_count,
+        tab_auto_selected: &tab_auto_selected,
+    };
+
+    tiles.layout_tile(&layout, rect, root);
+
+    tab_auto_selected.get()
+}
+
 /// Trait defining how the [`super::Tree`] and its panes should be shown.
 pub trait Behavior<Pane> {
     /// Show a pane tile in the given [`egui::Ui`].

src/container/grid.rs

@@ -5,7 +5,7 @@ use egui::{
 };
 use itertools::Itertools as _;
 
-use crate::behavior::EditAction;
+use crate::behavior::{EditAction, LayoutContext};
 use crate::{
     Behavior, ContainerInsertion, DropContext, InsertionPoint, ResizeState, SimplifyAction, TileId,
     Tiles, Tree,
@@ -137,16 +137,15 @@ impl Grid {
     pub(super) fn layout<Pane>(
         &mut self,
         tiles: &mut Tiles<Pane>,
-        style: &egui::Style,
-        behavior: &mut dyn Behavior<Pane>,
+        layout: &LayoutContext<'_>,
         rect: Rect,
     ) {
         // clean up any empty holes at the end
         while self.children.last() == Some(&None) {
             self.children.pop();
         }
 
-        let gap = behavior.gap_width(style);
+        let gap = layout.gap_width;
 
         let visible_children_and_holes = self.visible_children_and_holes(tiles);
 
@@ -156,7 +155,7 @@ impl Grid {
 
             let num_cols = match self.layout {
                 GridLayout::Auto => {
-                    behavior.grid_auto_column_count(num_visible_children, rect, gap)
+                    (layout.grid_auto_column_count)(num_visible_children, rect, gap)
                 }
                 GridLayout::Columns(num_columns) => num_columns,
             };
@@ -222,7 +221,7 @@ impl Grid {
                 let col = i % num_cols;
                 let row = i / num_cols;
                 let child_rect = Rect::from_x_y_ranges(self.col_ranges[col], self.row_ranges[row]);
-                tiles.layout_tile(style, behavior, child_rect, child);
+                tiles.layout_tile(layout, child_rect, child);
             }
         }
 
@@ -571,15 +570,15 @@ mod tests {
         };
 
         let style = egui::Style::default();
-        let mut behavior = TestBehavior {};
+        let behavior = TestBehavior {};
         let area = egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(1024.0, 768.0));
 
         // Go crazy on it to make sure we never crash:
         let mut rng = Pcg64::new_seed(123_456_789_012);
 
         for _ in 0..1000 {
             let root = tree.root.unwrap();
-            tree.tiles.layout_tile(&style, &mut behavior, area, root);
+            crate::behavior::layout_tiles(&mut tree.tiles, Some(root), &behavior, &style, area);
 
             // Add some tiles:
             for _ in 0..rng.rand_u64() % 3 {

src/container/linear.rs

@@ -3,7 +3,7 @@
 use egui::{NumExt as _, Rect, emath::GuiRounding as _, pos2, vec2};
 use itertools::Itertools as _;
 
-use crate::behavior::EditAction;
+use crate::behavior::{EditAction, LayoutContext};
 use crate::{
     Behavior, ContainerInsertion, DropContext, InsertionPoint, ResizeState, SimplifyAction, TileId,
     Tiles, Tree, is_being_dragged,
@@ -148,11 +148,10 @@ impl Linear {
         self.children.push(child);
     }
 
-    pub fn layout<Pane>(
+    pub(super) fn layout<Pane>(
         &mut self,
         tiles: &mut Tiles<Pane>,
-        style: &egui::Style,
-        behavior: &mut dyn Behavior<Pane>,
+        layout: &LayoutContext<'_>,
         rect: Rect,
     ) {
         // GC:
@@ -161,23 +160,22 @@ impl Linear {
 
         match self.dir {
             LinearDir::Horizontal => {
-                self.layout_horizontal(tiles, style, behavior, rect);
+                self.layout_horizontal(tiles, layout, rect);
             }
-            LinearDir::Vertical => self.layout_vertical(tiles, style, behavior, rect),
+            LinearDir::Vertical => self.layout_vertical(tiles, layout, rect),
         }
     }
 
     fn layout_horizontal<Pane>(
         &self,
         tiles: &mut Tiles<Pane>,
-        style: &egui::Style,
-        behavior: &mut dyn Behavior<Pane>,
+        layout: &LayoutContext<'_>,
         rect: Rect,
     ) {
         let visible_children = self.visible_children(tiles);
 
         let num_gaps = visible_children.len().saturating_sub(1);
-        let gap_width = behavior.gap_width(style);
+        let gap_width = layout.gap_width;
         let total_gap_width = gap_width * num_gaps as f32;
         let available_width = (rect.width() - total_gap_width).at_least(0.0);
 
@@ -186,22 +184,21 @@ impl Linear {
         let mut x = rect.min.x;
         for (child, width) in visible_children.iter().zip(widths) {
             let child_rect = Rect::from_min_size(pos2(x, rect.min.y), vec2(width, rect.height()));
-            tiles.layout_tile(style, behavior, child_rect, *child);
+            tiles.layout_tile(layout, child_rect, *child);
             x += width + gap_width;
         }
     }
 
     fn layout_vertical<Pane>(
         &self,
         tiles: &mut Tiles<Pane>,
-        style: &egui::Style,
-        behavior: &mut dyn Behavior<Pane>,
+        layout: &LayoutContext<'_>,
         rect: Rect,
     ) {
         let visible_children = self.visible_children(tiles);
 
         let num_gaps = visible_children.len().saturating_sub(1);
-        let gap_height = behavior.gap_width(style);
+        let gap_height = layout.gap_width;
         let total_gap_height = gap_height * num_gaps as f32;
         let available_height = (rect.height() - total_gap_height).at_least(0.0);
 
@@ -210,7 +207,7 @@ impl Linear {
         let mut y = rect.min.y;
         for (child, height) in visible_children.iter().zip(heights) {
             let child_rect = Rect::from_min_size(pos2(rect.min.x, y), vec2(rect.width(), height));
-            tiles.layout_tile(style, behavior, child_rect, *child);
+            tiles.layout_tile(layout, child_rect, *child);
             y += height + gap_height;
         }
     }

src/container/mod.rs

@@ -3,6 +3,7 @@ use egui::Rect;
 use crate::Tree;
 
 use super::{Behavior, DropContext, SimplifyAction, TileId, Tiles};
+use crate::behavior::LayoutContext;
 
 mod grid;
 mod linear;
@@ -223,20 +224,19 @@ impl Container {
     pub(super) fn layout<Pane>(
         &mut self,
         tiles: &mut Tiles<Pane>,
-        style: &egui::Style,
-        behavior: &mut dyn Behavior<Pane>,
+        layout: &LayoutContext<'_>,
         rect: Rect,
     ) {
         if self.is_empty() {
             return;
         }
 
         match self {
-            Self::Tabs(tabs) => tabs.layout(tiles, style, behavior, rect),
+            Self::Tabs(tabs) => tabs.layout(tiles, layout, rect),
             Self::Linear(linear) => {
-                linear.layout(tiles, style, behavior, rect);
+                linear.layout(tiles, layout, rect);
             }
-            Self::Grid(grid) => grid.layout(tiles, style, behavior, rect),
+            Self::Grid(grid) => grid.layout(tiles, layout, rect),
         }
     }
 

src/container/tabs.rs

@@ -1,6 +1,6 @@
 use egui::{NumExt as _, Rect, Vec2, scroll_area::ScrollBarVisibility, vec2};
 
-use crate::behavior::{EditAction, TabState};
+use crate::behavior::{EditAction, LayoutContext, TabState};
 use crate::{
     Behavior, ContainerInsertion, DropContext, InsertionPoint, SimplifyAction, TileId, Tiles, Tree,
     is_being_dragged,
@@ -163,22 +163,21 @@ impl Tabs {
     pub(super) fn layout<Pane>(
         &mut self,
         tiles: &mut Tiles<Pane>,
-        style: &egui::Style,
-        behavior: &mut dyn Behavior<Pane>,
+        layout: &LayoutContext<'_>,
         rect: Rect,
     ) {
         let prev_active = self.active;
         self.ensure_active(tiles);
         if prev_active != self.active {
-            behavior.on_edit(EditAction::TabSelected);
+            layout.tab_auto_selected.set(true);
         }
 
         let mut active_rect = rect;
-        active_rect.min.y += behavior.tab_bar_height(style);
+        active_rect.min.y += layout.tab_bar_height;
 
         if let Some(active) = self.active {
             // Only lay out the active tab (saves CPU):
-            tiles.layout_tile(style, behavior, active_rect, active);
+            tiles.layout_tile(layout, active_rect, active);
         }
     }
 

src/tiles.rs

@@ -1,5 +1,7 @@
 use egui::{Pos2, Rect};
 
+use crate::behavior::LayoutContext;
+
 use super::{
     Behavior, Container, ContainerInsertion, ContainerKind, GcAction, Grid, InsertionPoint, Linear,
     LinearDir, SimplificationOptions, SimplifyAction, Tabs, Tile, TileId,
@@ -411,21 +413,15 @@ impl<Pane> Tiles<Pane> {
         GcAction::Keep
     }
 
-    pub(super) fn layout_tile(
-        &mut self,
-        style: &egui::Style,
-        behavior: &mut dyn Behavior<Pane>,
-        rect: Rect,
-        tile_id: TileId,
-    ) {
+    pub(super) fn layout_tile(&mut self, layout: &LayoutContext<'_>, rect: Rect, tile_id: TileId) {
         let Some(mut tile) = self.tiles.remove(&tile_id) else {
             log::debug!("Failed to find tile {tile_id:?} during layout");
             return;
         };
         self.rects.insert(tile_id, rect);
 
         if let Tile::Container(container) = &mut tile {
-            container.layout(self, style, behavior, rect);
+            container.layout(self, layout, rect);
         }
 
         self.tiles.insert(tile_id, tile);

src/tree.rs

@@ -1,6 +1,6 @@
 use egui::{NumExt as _, Rect, Ui};
 
-use crate::behavior::EditAction;
+use crate::behavior::{EditAction, layout_tiles};
 use crate::{ContainerInsertion, ContainerKind, UiResponse};
 
 use super::{
@@ -328,9 +328,11 @@ impl<Pane> Tree<Pane> {
         if self.width.is_finite() {
             rect.set_width(self.width);
         }
-        if let Some(root) = self.root {
-            self.tiles.layout_tile(ui.style(), behavior, rect, root);
+        if layout_tiles(&mut self.tiles, self.root, behavior, ui.style(), rect) {
+            behavior.on_edit(EditAction::TabSelected);
+        }
 
+        if let Some(root) = self.root {
             self.tile_ui(behavior, &mut drop_context, ui, root);
         }