feat(tui): enable window management bindings

Enable the default `Ctrl-w` window keymap so split, close, navigation, resize, balance, and maximize commands are available without manual config edits.

Implement balance and maximize actions so every enabled binding has visible window behavior, and cover the default config plus layout behavior with tests.

Author: fcoury

default_config.toml

@@ -115,28 +115,6 @@ Esc = { EnterMode = "Normal" }
 "/" = { EnterMode = "Search" }
 # "|" = "Split" 
 # "_" = "SplitVertical"
-# Window management (uncomment to enable)
-# "Ctrl-w" = { 
-#     "h" = "MoveWindowLeft", 
-#     "j" = "MoveWindowDown", 
-#     "k" = "MoveWindowUp", 
-#     "l" = "MoveWindowRight",
-#     "w" = "NextWindow", 
-#     "W" = "PreviousWindow",
-#     "p" = "PreviousWindow",
-#     "s" = "SplitHorizontal",
-#     "v" = "SplitVertical",
-#     "-" = "SplitHorizontal",
-#     "|" = "SplitVertical",
-#     "c" = "CloseWindow",
-#     "q" = "CloseWindow",
-#     "Ctrl-w" = "NextWindow",
-#     "+" = { ResizeWindowDown = 1 },
-#     "<" = { ResizeWindowLeft = 1 },
-#     ">" = { ResizeWindowRight = 1 },
-#     "=" = "BalanceWindows",
-#     "_" = "MaximizeWindow"
-# }
 "Ctrl-p" = "FilePicker"
 "Ctrl-z" = "Suspend"
 "Ctrl-e" = { PluginCommand = "NeoTree" }
@@ -156,6 +134,27 @@ Esc = { EnterMode = "Normal" }
 [keys.normal."<"]
 "<" = "UnindentLine"
 
+[keys.normal."Ctrl-w"]
+"h" = "MoveWindowLeft"
+"j" = "MoveWindowDown"
+"k" = "MoveWindowUp"
+"l" = "MoveWindowRight"
+"w" = "NextWindow"
+"W" = "PreviousWindow"
+"p" = "PreviousWindow"
+"s" = "SplitHorizontal"
+"v" = "SplitVertical"
+"-" = "SplitHorizontal"
+"|" = "SplitVertical"
+"c" = "CloseWindow"
+"q" = "CloseWindow"
+"Ctrl-w" = "NextWindow"
+"+" = { ResizeWindowDown = 1 }
+"<" = { ResizeWindowLeft = 1 }
+">" = { ResizeWindowRight = 1 }
+"=" = "BalanceWindows"
+"_" = "MaximizeWindow"
+
 [keys.normal." "]
 " " = "NextBuffer"
 "n" = "NextBuffer"

src/config.rs

@@ -540,6 +540,43 @@ theme = "theme/nightfox.json"
         );
     }
 
+    #[test]
+    fn default_config_enables_window_management_prefix() {
+        let config: Config = toml::from_str(include_str!("../default_config.toml")).unwrap();
+        let Some(KeyAction::Nested(ctrl_w)) = config.keys.normal.get("Ctrl-w") else {
+            panic!("default config should map Ctrl-w to window management actions");
+        };
+
+        assert_eq!(
+            ctrl_w.get("s"),
+            Some(&KeyAction::Single(Action::SplitHorizontal))
+        );
+        assert_eq!(
+            ctrl_w.get("v"),
+            Some(&KeyAction::Single(Action::SplitVertical))
+        );
+        assert_eq!(
+            ctrl_w.get("w"),
+            Some(&KeyAction::Single(Action::NextWindow))
+        );
+        assert_eq!(
+            ctrl_w.get("W"),
+            Some(&KeyAction::Single(Action::PreviousWindow))
+        );
+        assert_eq!(
+            ctrl_w.get("c"),
+            Some(&KeyAction::Single(Action::CloseWindow))
+        );
+        assert_eq!(
+            ctrl_w.get("="),
+            Some(&KeyAction::Single(Action::BalanceWindows))
+        );
+        assert_eq!(
+            ctrl_w.get("_"),
+            Some(&KeyAction::Single(Action::MaximizeWindow))
+        );
+    }
+
     #[test]
     fn cursor_config_defaults_match_current_behavior() {
         let config: Config = toml::from_str(

src/editor.rs

@@ -4883,10 +4883,14 @@ impl Editor {
                 }
             }
             Action::BalanceWindows => {
-                // TODO: Implement window balancing
+                if self.update_window_layout(WindowManager::balance_windows) {
+                    self.render(buffer)?;
+                }
             }
             Action::MaximizeWindow => {
-                // TODO: Implement window maximizing
+                if self.update_window_layout(WindowManager::maximize_window) {
+                    self.render(buffer)?;
+                }
             }
         }
 

src/window.rs

@@ -136,6 +136,35 @@ mod tests {
         assert_eq!(manager.active_window_id(), 0);
     }
 
+    #[test]
+    fn balance_windows_restores_even_split_ratios() {
+        let mut manager = WindowManager::new(0, (80, 26));
+        manager.split_vertical(0).unwrap();
+        manager.set_active(0);
+
+        assert!(manager.resize_window(Direction::Right, 4).is_some());
+        let resized_width = manager.active_window().unwrap().size.0;
+
+        assert!(manager.balance_windows().is_some());
+
+        assert!(manager.active_window().unwrap().size.0 < resized_width);
+        assert_eq!(manager.active_window().unwrap().size.0, 39);
+        assert_eq!(manager.active_window_id(), 0);
+    }
+
+    #[test]
+    fn maximize_window_expands_active_window() {
+        let mut manager = WindowManager::new(0, (80, 26));
+        manager.split_vertical(0).unwrap();
+        manager.set_active(1);
+        let initial_width = manager.active_window().unwrap().size.0;
+
+        assert!(manager.maximize_window().is_some());
+
+        assert!(manager.active_window().unwrap().size.0 > initial_width);
+        assert_eq!(manager.active_window_id(), 1);
+    }
+
     #[test]
     fn snapshot_round_trips_split_layout() {
         let mut manager = WindowManager::new(0, (80, 26));
@@ -709,6 +738,91 @@ impl WindowManager {
         }
     }
 
+    /// Resets every split ratio so windows share space evenly.
+    pub fn balance_windows(&mut self) -> Option<()> {
+        if self.root.windows().len() <= 1 {
+            return None;
+        }
+
+        let (width, height) = self.get_terminal_bounds();
+        Self::balance_split(&mut self.root);
+        self.root.layout(Point::new(0, 0), (width, height));
+        self.set_active(self.active_window_id);
+        Some(())
+    }
+
+    fn balance_split(node: &mut Split) {
+        match node {
+            Split::Window(_) => {}
+            Split::Horizontal { top, bottom, ratio } => {
+                *ratio = 0.5;
+                Self::balance_split(top);
+                Self::balance_split(bottom);
+            }
+            Split::Vertical { left, right, ratio } => {
+                *ratio = 0.5;
+                Self::balance_split(left);
+                Self::balance_split(right);
+            }
+        }
+    }
+
+    /// Expands the active window along each ancestor split while preserving layout.
+    pub fn maximize_window(&mut self) -> Option<()> {
+        if self.root.windows().len() <= 1 {
+            return None;
+        }
+
+        let (width, height) = self.get_terminal_bounds();
+        let mut current_id = 0;
+        let maximized =
+            Self::maximize_window_recursive(&mut self.root, &mut current_id, self.active_window_id);
+
+        if maximized {
+            self.root.layout(Point::new(0, 0), (width, height));
+            self.set_active(self.active_window_id);
+            Some(())
+        } else {
+            None
+        }
+    }
+
+    fn maximize_window_recursive(
+        node: &mut Split,
+        current_id: &mut usize,
+        target_id: usize,
+    ) -> bool {
+        match node {
+            Split::Window(_) => {
+                let found = *current_id == target_id;
+                *current_id += 1;
+                found
+            }
+            Split::Horizontal { top, bottom, ratio } => {
+                if Self::maximize_window_recursive(top, current_id, target_id) {
+                    *ratio = 0.9;
+                    true
+                } else if Self::maximize_window_recursive(bottom, current_id, target_id) {
+                    *ratio = 0.1;
+                    true
+                } else {
+                    false
+                }
+            }
+            Split::Vertical { left, right, ratio } => {
+                if Self::maximize_window_recursive(left, current_id, target_id) {
+                    *ratio = 0.9;
+                    true
+                } else if Self::maximize_window_recursive(right, current_id, target_id) {
+                    *ratio = 0.1;
+                    true
+                } else {
+                    false
+                }
+            }
+        }
+    }
+
     /// Adjust the split ratio for the window in the given direction
     fn adjust_split_ratio(
         node: &mut Split,