keep a tile's TileId when it gets wrapped in a container

Dropping a tile onto another tile wraps them both in a new container. That wrapper
used to take over the *target's* `TileId`, with the target itself moved to a
freshly allocated one. So a `TileId` did not keep referring to the same tile: an
id that meant "pane_a" one frame meant "the container holding pane_a" the next.

That is a trap for any application that keys its own state off `TileId`s -- which
Rerun does, and which `examples/tree_recreated_every_frame.rs` demonstrates. Such
an app maps the id back to its own model, gets told a container now lives where a
pane used to, and reuses the pane's identity for it. Next frame it builds a tree
with a pane and a container at the same id, one overwrites the other, and a pane
disappears.

Now the wrapped tile keeps its id and the new container gets the fresh one. The
wrapper also inherits what the wrapped tile had by virtue of its position: its
share of a linear container's space, its cell in a grid, and whether it was the
open tab. Whoever referenced the wrapped tile is re-pointed at the wrapper, and
since `Tiles` does not know the root, `insert_at` hands the new container back so
`Tree` can re-point the root when it was the root that got wrapped.

Verified by restoring the naive version of the example's model-sync -- the one
that lost panes -- and confirming the full drag sweep now passes with it. Kept the
tidier version regardless, since panes never needed to be in that map.

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

Author: emilk

examples/tree_recreated_every_frame.rs

@@ -117,9 +117,8 @@ impl Blueprint {
                 Node::Pane { id } => {
                     let id_ = tile_id(id);
                     tiles.insert(id_, Tile::Pane(id.clone()));
-                    // Deliberately NOT in `reverse`: a pane carries its own app id as its
-                    // payload, and `reverse` is only consulted for containers. Putting panes in
-                    // here is a trap -- see the note on `sync_from_tree`.
+                    // Not in `reverse`: a pane carries its own app id as its payload, and
+                    // `reverse` is only consulted for containers.
                     id_
                 }
                 Node::Container { id, kind, children } => {
@@ -140,19 +139,10 @@ impl Blueprint {
     /// Fold an edited tree back into the blueprint, minting fresh ids for any newly-created
     /// containers (tiles whose id isn't in `reverse`) — exactly what Rerun does on a drop.
     ///
-    /// ## Watch out
-    ///
-    /// `reverse` maps a `TileId` back to an app id, and it deliberately contains **containers
-    /// only**. Panes are looked up from their own payload instead.
-    ///
-    /// That matters because a `TileId` does not keep referring to the same kind of tile. Drop a
-    /// pane onto another pane and `egui_tiles` reuses the *target's* id for the new container it
-    /// wraps them both in, moving the target pane itself to a freshly allocated id. So a tile id
-    /// that meant `"pane_a"` one frame can mean `"the container holding pane_a"` the next.
-    ///
-    /// If panes were in `reverse`, that new container would be handed the app id `"pane_a"`, and
-    /// the next `to_tree()` would insert both a pane and a container at `tile_id("pane_a")` — the
-    /// second overwriting the first, silently losing a pane.
+    /// `reverse` maps a `TileId` back to an app id, and holds **containers only** — a pane is
+    /// identified by its own payload instead. A container appearing somewhere the app has never
+    /// seen before therefore gets a freshly minted id, which is exactly what should happen when
+    /// `egui_tiles` wraps tiles in a new container on drop.
     fn sync_from_tree(&mut self, tree: &Tree<String>, reverse: &HashMap<TileId, String>) {
         fn rebuild(
             tile_id: TileId,

src/container/grid.rs

@@ -111,6 +111,17 @@ impl Grid {
 
     /// Returns the child already at the given index, if any.
     #[must_use]
+    /// Swap out one child for another, keeping its cell.
+    ///
+    /// The column and row shares are positional, so they need no fixing up.
+    pub(super) fn replace_child(&mut self, old: TileId, new: TileId) -> bool {
+        let Some(slot) = self.children.iter_mut().find(|child| **child == Some(old)) else {
+            return false;
+        };
+        *slot = Some(new);
+        true
+    }
+
     pub fn replace_at(&mut self, index: usize, child: TileId) -> Option<TileId> {
         if let Some(slot) = self.children.get_mut(index) {
             slot.replace(child)

src/container/linear.rs

@@ -144,6 +144,16 @@ impl Linear {
         slf
     }
 
+    /// Swap out one child for another, keeping its position and its share of the space.
+    pub(super) fn replace_child(&mut self, old: TileId, new: TileId) -> bool {
+        let Some(slot) = self.children.iter_mut().find(|child| **child == old) else {
+            return false;
+        };
+        *slot = new;
+        self.shares.replace_with(old, new);
+        true
+    }
+
     pub fn add_child(&mut self, child: TileId) {
         self.children.push(child);
     }

src/container/mod.rs

@@ -176,6 +176,17 @@ impl Container {
         }
     }
 
+    /// Swap out one child for another, keeping its place and its share of the space.
+    ///
+    /// Returns `false` if `old` was not a child of this container.
+    pub fn replace_child(&mut self, old: TileId, new: TileId) -> bool {
+        match self {
+            Self::Tabs(tabs) => tabs.replace_child(old, new),
+            Self::Linear(linear) => linear.replace_child(old, new),
+            Self::Grid(grid) => grid.replace_child(old, new),
+        }
+    }
+
     /// Returns child index, if found.
     pub fn remove_child(&mut self, child: TileId) -> Option<usize> {
         match self {

src/container/tabs.rs

@@ -152,6 +152,18 @@ impl Tabs {
         self.children.push(child);
     }
 
+    /// Swap out one tab for another, keeping its position and whether it was the open one.
+    pub(super) fn replace_child(&mut self, old: TileId, new: TileId) -> bool {
+        let Some(slot) = self.children.iter_mut().find(|child| **child == old) else {
+            return false;
+        };
+        *slot = new;
+        if self.active == Some(old) {
+            self.active = Some(new);
+        }
+        true
+    }
+
     pub fn set_active(&mut self, child: TileId) {
         self.active = Some(child);
     }