Add Tree::active_tiles for getting visible tiles (#42)

This function returns all tiles that are visible and not in a background
(inactive) tab.

examples/advanced.rs

@@ -165,9 +165,6 @@ struct MyApp {
 
     #[cfg_attr(feature = "serde", serde(skip))]
     behavior: TreeBehavior,
-
-    #[cfg_attr(feature = "serde", serde(skip))]
-    last_tree_debug: String,
 }
 
 impl Default for MyApp {
@@ -208,7 +205,6 @@ impl Default for MyApp {
         Self {
             tree,
             behavior: Default::default(),
-            last_tree_debug: Default::default(),
         }
     }
 }
@@ -220,6 +216,26 @@ impl eframe::App for MyApp {
                 *self = Default::default();
             }
             self.behavior.ui(ui);
+
+            ui.separator();
+
+            ui.collapsing("Tree", |ui| {
+                ui.style_mut().wrap = Some(false);
+                let tree_debug = format!("{:#?}", self.tree);
+                ui.monospace(&tree_debug);
+            });
+
+            ui.separator();
+
+            ui.collapsing("Active tiles", |ui| {
+                let active = self.tree.active_tiles();
+                for tile_id in active {
+                    use egui_tiles::Behavior as _;
+                    let name = self.behavior.tab_title_for_tile(&self.tree.tiles, tile_id);
+                    ui.label(format!("{} - {tile_id:?}", name.text()));
+                }
+            });
+
             ui.separator();
 
             if let Some(root) = self.tree.root() {
@@ -235,14 +251,6 @@ impl eframe::App for MyApp {
                     tabs.set_active(new_child);
                 }
             }
-
-            ui.separator();
-            ui.style_mut().wrap = Some(false);
-            let tree_debug = format!("{:#?}", self.tree);
-            ui.monospace(&tree_debug);
-            if self.last_tree_debug != tree_debug {
-                self.last_tree_debug = tree_debug;
-            }
         });
 
         egui::CentralPanel::default().show(ctx, |ui| {

src/container/mod.rs

@@ -112,6 +112,7 @@ impl Container {
         }
     }
 
+    /// All the childrens of this container.
     pub fn children(&self) -> impl Iterator<Item = &TileId> {
         match self {
             Self::Tabs(tabs) => itertools::Either::Left(tabs.children.iter()),
@@ -120,6 +121,22 @@ impl Container {
         }
     }
 
+    /// All the active childrens of this container.
+    ///
+    /// For tabs, this is just the active tab.
+    /// For other containers, it is all children.
+    pub fn active_children(&self) -> impl Iterator<Item = &TileId> {
+        match self {
+            Self::Tabs(tabs) => {
+                itertools::Either::Left(itertools::Either::Left(tabs.active.iter()))
+            }
+            Self::Linear(linear) => {
+                itertools::Either::Left(itertools::Either::Right(linear.children.iter()))
+            }
+            Self::Grid(grid) => itertools::Either::Right(grid.children()),
+        }
+    }
+
     /// If we have exactly one child, return it
     pub fn only_child(&self) -> Option<TileId> {
         let mut only_child = None;

src/tiles.rs

@@ -139,6 +139,20 @@ impl<Pane> Tiles<Pane> {
         self.set_visible(tile_id, !self.is_visible(tile_id));
     }
 
+    /// This excludes all tiles that invisible or are inactive tabs, recursively.
+    pub(crate) fn collect_acticve_tiles(&self, tile_id: TileId, tiles: &mut Vec<TileId>) {
+        if !self.is_visible(tile_id) {
+            return;
+        }
+        tiles.push(tile_id);
+
+        if let Some(Tile::Container(container)) = self.get(tile_id) {
+            for &child_id in container.active_children() {
+                self.collect_acticve_tiles(child_id, tiles);
+            }
+        }
+    }
+
     pub fn insert(&mut self, id: TileId, tile: Tile<Pane>) {
         self.tiles.insert(id, tile);
     }