Pane maximization

#3 (closed)

src/ui/composable_view.rs

 use super::{
     layout_manager::LayoutManager,
-    panes::{Pane, PaneBehavior},
+    panes::{Pane, PaneBehavior, PaneKind},
     shortcuts,
+    utils::maximized_pane_ui,
 };
 use std::{
     fs,
@@ -19,6 +20,7 @@ pub struct ComposableView {
 
     pub layout_manager: LayoutManager,
     behavior: ComposableBehavior,
+    maximized_pane: Option<TileId>,
 }
 
 // An app must implement the `App` trait to define how the ui is built
@@ -44,6 +46,8 @@ impl eframe::App for ComposableView {
                 ((Modifiers::NONE, Key::V), PaneAction::SplitV),
                 ((Modifiers::NONE, Key::H), PaneAction::SplitH),
                 ((Modifiers::NONE, Key::C), PaneAction::Close),
+                ((Modifiers::SHIFT, Key::Escape), PaneAction::Maximize),
+                ((Modifiers::NONE, Key::Escape), PaneAction::Exit),
             ];
             pane_action = pane_action.or(shortcuts::map_to_action(ctx, &key_action_pairs[..])
                 .map(|action| (action, hovered_pane)));
@@ -53,40 +57,70 @@ impl eframe::App for ComposableView {
         if let Some((action, hovered_tile)) = pane_action.take() {
             match action {
                 PaneAction::SplitH => {
-                    let hovered_tile_pane = panes_tree.tiles.remove(hovered_tile).unwrap();
-                    let left_pane = panes_tree.tiles.insert_new(hovered_tile_pane);
-                    let right_pane = panes_tree.tiles.insert_pane(Pane::default());
-                    panes_tree.tiles.insert(
-                        hovered_tile,
-                        Tile::Container(Container::Linear(Linear::new_binary(
-                            LinearDir::Horizontal,
-                            [left_pane, right_pane],
-                            0.5,
-                        ))),
-                    );
+                    if self.maximized_pane.is_none() {
+                        let hovered_tile_pane = panes_tree.tiles.remove(hovered_tile).unwrap();
+                        let left_pane = panes_tree.tiles.insert_new(hovered_tile_pane);
+                        let right_pane = panes_tree.tiles.insert_pane(Pane::default());
+                        panes_tree.tiles.insert(
+                            hovered_tile,
+                            Tile::Container(Container::Linear(Linear::new_binary(
+                                LinearDir::Horizontal,
+                                [left_pane, right_pane],
+                                0.5,
+                            ))),
+                        );
+                    }
                 }
                 PaneAction::SplitV => {
-                    let hovered_tile_pane = panes_tree.tiles.remove(hovered_tile).unwrap();
-                    let replaced = panes_tree.tiles.insert_new(hovered_tile_pane);
-                    let lower_pane = panes_tree.tiles.insert_pane(Pane::default());
-                    panes_tree.tiles.insert(
-                        hovered_tile,
-                        Tile::Container(Container::Linear(Linear::new_binary(
-                            LinearDir::Vertical,
-                            [replaced, lower_pane],
-                            0.5,
-                        ))),
-                    );
+                    if self.maximized_pane.is_none() {
+                        let hovered_tile_pane = panes_tree.tiles.remove(hovered_tile).unwrap();
+                        let replaced = panes_tree.tiles.insert_new(hovered_tile_pane);
+                        let lower_pane = panes_tree.tiles.insert_pane(Pane::default());
+                        panes_tree.tiles.insert(
+                            hovered_tile,
+                            Tile::Container(Container::Linear(Linear::new_binary(
+                                LinearDir::Vertical,
+                                [replaced, lower_pane],
+                                0.5,
+                            ))),
+                        );
+                    }
                 }
                 PaneAction::Close => {
                     // Ignore if the root pane is the only one
-                    if panes_tree.tiles.len() != 1 {
+                    if panes_tree.tiles.len() != 1 && self.maximized_pane.is_none() {
                         panes_tree.remove_recursively(hovered_tile);
                     }
                 }
                 PaneAction::Replace(new_pane) => {
                     panes_tree.tiles.insert(hovered_tile, Tile::Pane(*new_pane));
                 }
+                PaneAction::Maximize => {
+                    // This is a toggle: if there is not currently a maximized pane,
+                    // maximize the hovered pane, otherwize remove the maximized pane.
+                    if self.maximized_pane.is_some() {
+                        self.maximized_pane = None;
+                    } else {
+                        let hovered_pane_is_default = panes_tree
+                            .tiles
+                            .get(hovered_tile)
+                            .map(|hovered_pane| match hovered_pane {
+                                Tile::Pane(Pane {
+                                    pane: PaneKind::Default(_),
+                                }) => true,
+                                _ => false,
+                            })
+                            .unwrap_or(false);
+                        if !hovered_pane_is_default {
+                            self.maximized_pane = Some(hovered_tile);
+                        }
+                    }
+                }
+                PaneAction::Exit => {
+                    if self.maximized_pane.is_some() {
+                        self.maximized_pane = None;
+                    }
+                }
             }
         }
 
@@ -98,12 +132,25 @@ impl eframe::App for ComposableView {
                 if ui.button("Layout Manager").clicked() {
                     self.layout_manager.toggle_open_state();
                 }
+
+                // If a pane is maximized show a visual clue
+                if self.maximized_pane.is_some() {
+                    ui.label("Pane Maximized!");
+                }
             })
         });
 
         // A central panel covers the remainder of the screen, i.e. whatever area is left after adding other panels.
         egui::CentralPanel::default().show(ctx, |ui| {
-            panes_tree.ui(&mut self.behavior, ui);
+            if let Some(maximized_pane) = self.maximized_pane {
+                if let Some(Tile::Pane(pane)) = panes_tree.tiles.get_mut(maximized_pane) {
+                    maximized_pane_ui(ui, pane);
+                } else {
+                    panic!("Maximized pane not found in tree!");
+                }
+            } else {
+                panes_tree.ui(&mut self.behavior, ui);
+            }
         });
 
         LayoutManager::show(self, ctx);
@@ -246,4 +293,6 @@ pub enum PaneAction {
     SplitV,
     Close,
     Replace(Box<Pane>),
+    Maximize,
+    Exit,
 }