`92e1d14`

Add stacked overflow remediation

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 weeks ago

SHA: 92e1d140acce39acc344f0b90da4826e7a0543f3
Parents: ae35f6c
Tree: e1036a4

7 changed files

Status	File	+	-
M	`.gitignore`	1	0
M	`tarmac/src/config/lua.rs`	7	0
M	`tarmac/src/core/input.rs`	2	0
M	`tarmac/src/core/state.rs`	175	138
M	`tarmac/src/core/tree.rs`	375	2
M	`tarmac/src/main.rs`	33	6
M	`tarmacctl/src/main.rs`	1	0

.gitignoremodified

  .claude/
  CLAUDE.md
  .ref/
 +.refs/
  AGENTS.md
  nohup.out

tarmac/src/config/lua.rsmodified

          "close" => Ok(Action::CloseWindow),
          "equalize" => Ok(Action::Equalize),
          "toggle_float" => Ok(Action::ToggleFloat),
 +        "unstack" => Ok(Action::Unstack),
          "workspace_next" => Ok(Action::WorkspaceNext),
          "workspace_prev" => Ok(Action::WorkspacePrev),
          "focus_monitor_next" => Ok(Action::FocusMonitorNext),
              key: Key::Space,
              action: Action::ToggleFloat,
          },
 +        LuaKeybind {
 +            modifiers: ms,
 +            key: Key::U,
 +            action: Action::Unstack,
 +        },
          // Focus
          LuaKeybind {
              modifiers: m,
          Action::WorkspaceNext => "workspace_next".to_string(),
          Action::WorkspacePrev => "workspace_prev".to_string(),
          Action::ToggleFloat => "toggle_float".to_string(),
 +        Action::Unstack => "unstack".to_string(),
          Action::ToggleSpecial(name) => format!("toggle_special {name}"),
          Action::MoveToSpecial(name) => format!("move_to_special {name}"),
          Action::FocusMonitorNext => "focus_monitor_next".to_string(),

tarmac/src/core/input.rsmodified

      FocusMonitorPrev,                 // Focus previous monitor
      MoveToMonitorNext,                // Move window to next monitor
      MoveToMonitorPrev,                // Move window to previous monitor
 +    Unstack,                          // Restore a stacked subtree to its saved BSP shape
      Reload,                           // Hot reload config
      Exit,                             // Clean exit
+ }
          // Spawn / close
          mgr.add(m, Key::Return, Action::SpawnTerminal);
          mgr.add(ms, Key::Q, Action::CloseWindow);
 +        mgr.add(ms, Key::U, Action::Unstack);
          // Focus: Option+hjkl and Option+Arrows
          mgr.add(m, Key::H, Action::Focus(Left));

tarmac/src/core/state.rsmodified

          self.ax_refs.get(&id)
+     }
 +    fn workspace_render_geometries(&self, ws_idx: usize, rect: Rect) -> Vec<(WindowId, Rect)> {
 +        let (gap_inner, gap_outer) = self.workspace_gaps(ws_idx);
 +        self.workspaces
 +            .get(ws_idx)
 +            .tree
 +            .calculate_geometries_with_gaps(rect, gap_inner, gap_outer, true)
 +    }
++
 +    fn workspace_focus_geometries(&self, ws_idx: usize, rect: Rect) -> Vec<(WindowId, Rect)> {
 +        let (gap_inner, gap_outer) = self.workspace_gaps(ws_idx);
 +        self.workspaces
 +            .get(ws_idx)
 +            .tree
 +            .calculate_focus_geometries_with_gaps(rect, gap_inner, gap_outer, true)
 +    }
++
      pub fn process_events(&mut self) {
          let events: Vec<QueuedEvent> = self.event_queue.borrow_mut().drain(..).collect();
          for queued in events {
              let ws_idx = monitor.active_workspace;
              let ws = self.workspaces.get(ws_idx);
              let screen_rect = self.monitor_rect(mi);
 -            let (gap_inner, gap_outer) = self.workspace_gaps(ws_idx);
 -            let geometries =
 -                ws.tree
 -                    .calculate_geometries_with_gaps(screen_rect, gap_inner, gap_outer, true);
 +            let geometries = self.workspace_render_geometries(ws_idx, screen_rect);
              tracing::debug!(monitor = mi, workspace = %ws.id, windows = geometries.len(),
                  sr_x = screen_rect.x, sr_y = screen_rect.y, sr_w = screen_rect.width,
                  sr_h = screen_rect.height, "apply_layout");
              let ws_idx = monitor.active_workspace;
              let ws = self.workspaces.get(ws_idx);
              let sr = self.monitor_rect(mi);
 -            let (gap_inner, gap_outer) = self.workspace_gaps(ws_idx);
 -            let geoms = ws
 -                .tree
 -                .calculate_geometries_with_gaps(sr, gap_inner, gap_outer, true);
 +            let geoms = self.workspace_focus_geometries(ws_idx, sr);
              let focused = ws.focused;
              for (wid, rect) in &geoms {
                  .monitor_showing_workspace(ws_idx)
                  .map(|mi| self.monitor_rect(mi))
                  .unwrap_or_else(|| self.focused_rect());
 -            let (gap_inner, gap_outer) = self.workspace_gaps(ws_idx);
+-
              // Phase 1: Swap oversized windows into larger tiles.
              // Batch all swaps using BSP geometry (no AX calls), then apply layout
              // once and settle. This is both faster (one layout instead of N) and
                      // Geometries are computed from the BSP tree (cheap, no AX).
                      // After batched swaps, tree geometry reflects the new layout
                      // even before apply_layout sends AX commands.
 -                    let geometries = self
 -                        .workspaces
 -                        .get(ws_idx)
 -                        .tree
 -                        .calculate_geometries_with_gaps(screen_rect, gap_inner, gap_outer, true);
 +                    let geometries = self.workspace_focus_geometries(ws_idx, screen_rect);
                      if geometries.is_empty() {
                          break;
+                     }
                  // settling. The settled set prevents ping-pong.
+             }
 -            // Phase 2: Float remaining oversized windows locally.
 -            // Oversized windows should not silently migrate across workspaces;
 -            // keep workspace membership stable and remediate in place.
 +            // Phase 2: Replace the smallest conflicting subtree with a stack.
              loop {
 -                let geometries = self
 -                    .workspaces
 -                    .get(ws_idx)
 -                    .tree
 -                    .calculate_geometries_with_gaps(screen_rect, gap_inner, gap_outer, true);
 +                let geometries = self.workspace_focus_geometries(ws_idx, screen_rect);
                  if geometries.is_empty() {
                      break;
+                 }
                      None => break,
                  };
 -                tracing::info!(
 -                    id = oversized_wid,
 -                    min_w,
 -                    min_h,
 -                    ws = ws_idx + 1,
 -                    "floating oversized window locally"
 -                );
 -                self.workspaces
 -                    .get_mut(ws_idx)
 -                    .toggle_float(oversized_wid, screen_rect);
 -                if let Some(ax_ref) = self.ax_refs.get(&oversized_wid) {
 -                    let fx = screen_rect.x + (screen_rect.width - min_w) / 2.0;
 -                    let fy = screen_rect.y + (screen_rect.height - min_h) / 2.0;
 -                    let _ = ax_set_position(ax_ref, fx, fy);
 -                    let _ = ax_set_size(ax_ref, min_w, min_h);
 +                if self.workspaces.get_mut(ws_idx).tree.make_stack_for_window(oversized_wid) {
 +                    tracing::info!(
 +                        id = oversized_wid,
 +                        min_w,
 +                        min_h,
 +                        ws = ws_idx + 1,
 +                        "stacking oversized subtree locally"
 +                    );
 +                    self.workspaces.get_mut(ws_idx).tree.set_stack_active(oversized_wid);
 +                    self.apply_layout();
 +                    std::thread::sleep(std::time::Duration::from_millis(50));
 +                } else {
 +                    break;
+                 }
 -                self.apply_layout();
 -                self.restack_floating_windows(ws_idx);
+             }
              processed.push(ws_idx);
          let ws = self.active_workspace();
          let focused = ws.focused;
          let sr = self.focused_rect();
 -        let (gap_inner, gap_outer) = self.workspace_gaps(self.active_ws_idx());
++
 +        if let Some(from) = focused
 +            && matches!(direction, Direction::Left | Direction::Right)
 +            && let Some(next) = self
 +                .active_workspace_mut()
 +                .tree
 +                .cycle_stack(from, matches!(direction, Direction::Right))
 +        {
 +            self.focus_window(next);
 +            return;
 +        }
          // Try intra-workspace navigation first (only if we have a focused window)
          if let Some(from) = focused {
 -            let geoms = ws
 -                .tree
 -                .calculate_geometries_with_gaps(sr, gap_inner, gap_outer, true);
 +            let geoms = self.workspace_focus_geometries(self.active_ws_idx(), sr);
              // Check if focused window is at the monitor edge in the requested
              // direction. If so, cross monitors instead of spiraling into the BSP tree.
          if let Some(new_mi) = new_mi {
              self.focused_monitor = new_mi;
              let target_sr = self.focused_rect();
 -            let target_geoms = self
 -                .active_workspace()
 -                .tree
 -                .calculate_geometries_with_gaps(target_sr, gap_inner, gap_outer, true);
 +            let target_geoms = self.workspace_focus_geometries(self.active_ws_idx(), target_sr);
              if let Some(wid) =
                  Node::nearest_to_edge(&target_geoms, direction).or(self.active_workspace().focused)
              None => return,
          };
          let sr = self.focused_rect();
 -        let (gap_inner, gap_outer) = self.workspace_gaps(self.active_ws_idx());
 -        let geoms = ws
 -            .tree
 -            .calculate_geometries_with_gaps(sr, gap_inner, gap_outer, true);
++
 +        if matches!(direction, Direction::Left | Direction::Right)
 +            && let Some(next) = self
 +                .active_workspace_mut()
 +                .tree
 +                .reorder_stack(focused, matches!(direction, Direction::Right))
 +        {
 +            self.apply_layout();
 +            self.focus_window(next);
 +            return;
 +        }
++
 +        let geoms = self.workspace_focus_geometries(self.active_ws_idx(), sr);
          // Check if the focused window touches the monitor edge in the
          // requested direction. If so, skip intra-workspace swap and move
          // Record focus on the workspace that CONTAINS this window,
          // not the active workspace — during cross-monitor FFM the active
          // workspace might be different from the window's workspace.
 -        let old_focused = if let Some(ws_idx) = self.workspaces.find_window(id) {
 +        let (old_focused, stack_focus_changed) = if let Some(ws_idx) = self.workspaces.find_window(id) {
              let old = self.workspaces.get(ws_idx).focused;
              self.workspaces.get_mut(ws_idx).raise_floating(id);
 +            let stack_changed = self.workspaces.get_mut(ws_idx).tree.set_stack_active(id);
              self.workspaces.get_mut(ws_idx).record_focus(id);
 -            old
 +            (old, stack_changed)
          } else {
              let old = self.active_workspace().focused;
              self.active_workspace_mut().raise_floating(id);
 +            let stack_changed = self.active_workspace_mut().tree.set_stack_active(id);
              self.active_workspace_mut().record_focus(id);
 -            old
 +            (old, stack_changed)
          };
 +        if stack_focus_changed {
 +            self.apply_layout();
 +        }
          self.enforce_floating_levels(id);
          // Update border colors on focus change
                  floating_hit
              } else {
                  // Check tiled windows within the overlay rect
 -                let geoms = ws.tree.calculate_geometries_with_gaps(
 -                    overlay_rect,
 -                    gap_inner,
 -                    gap_outer,
 -                    true,
 -                );
 +                let geoms = ws
 +                    .tree
 +                    .calculate_geometries_with_gaps(overlay_rect, gap_inner, gap_outer, true);
                  geoms
                      .iter()
 +                    .rev()
                      .find(|(_, rect)| rect.contains_point(x, y))
                      .map(|(id, _)| *id)
+             }
          } else {
              let ws = self.active_workspace();
 -            let (gap_inner, gap_outer) = self.workspace_gaps(self.active_ws_idx());
              // Check floating windows first -- they're visually on top
              let floating_under = ws
                  floating_under
              } else {
                  // Check tiled windows using gap-aware geometry matching actual layout
 -                let geoms = ws.tree.calculate_geometries_with_gaps(
 -                    self.focused_rect(),
 -                    gap_inner,
 -                    gap_outer,
 -                    true,
 -                );
 +                let geoms =
 +                    self.workspace_render_geometries(self.active_ws_idx(), self.focused_rect());
                  geoms
                      .iter()
 +                    .rev()
                      .find(|(_, rect)| rect.contains_point(x, y))
                      .map(|(id, _)| *id)
+             }
+         }
+     }
 +    pub fn unstack_focused(&mut self) {
 +        let focused = match self.effective_focused() {
 +            Some(f) => f,
 +            None => return,
 +        };
++
 +        let Some(ws_idx) = self.workspaces.find_window(focused) else {
 +            return;
 +        };
++
 +        if self.workspaces.get_mut(ws_idx).tree.unstack(focused) {
 +            self.apply_layout();
 +            self.focus_window(focused);
 +            tracing::info!(id = focused, "restored stacked subtree");
 +        }
 +    }
++
      pub fn click_to_focus(&mut self, x: f64, y: f64) {
          let ws = self.active_workspace();
 -        let (gap_inner, gap_outer) = self.workspace_gaps(self.active_ws_idx());
          // Check floating first
          let floating_hit = ws
          let id = if let Some(fid) = floating_hit {
              Some(fid)
          } else {
 -            let geoms = ws.tree.calculate_geometries_with_gaps(
 -                self.focused_rect(),
 -                gap_inner,
 -                gap_outer,
 -                true,
 -            );
 +            let geoms = self.workspace_render_geometries(self.active_ws_idx(), self.focused_rect());
              geoms
                  .iter()
 +                .rev()
                  .find(|(_, rect)| rect.contains_point(x, y))
                  .map(|(id, _)| *id)
          };
                  // Warp to the focused WINDOW center (not monitor center)
                  if self.mouse_follows_focus {
                      let sr = self.focused_rect();
 -                    let (gap_inner, gap_outer) = self.workspace_gaps(target_idx);
 -                    let geoms = self
 -                        .workspaces
 -                        .get(target_idx)
 -                        .tree
 -                        .calculate_geometries_with_gaps(sr, gap_inner, gap_outer, true);
 +                    let geoms = self.workspace_focus_geometries(target_idx, sr);
                      if let Some((_, rect)) = geoms.iter().find(|(id, _)| *id == wid) {
                          warp_mouse_to_center(rect);
                      } else {
              self.focus_window(wid);
              if self.mouse_follows_focus {
                  let sr = self.focused_rect();
 -                let (gap_inner, gap_outer) = self.workspace_gaps(target_idx);
 -                let geoms = self
 -                    .workspaces
 -                    .get(target_idx)
 -                    .tree
 -                    .calculate_geometries_with_gaps(sr, gap_inner, gap_outer, true);
 +                let geoms = self.workspace_focus_geometries(target_idx, sr);
                  if let Some((_, rect)) = geoms.iter().find(|(id, _)| *id == wid) {
                      warp_mouse_to_center(rect);
                  } else {
              self.focus_window(wid);
              if self.mouse_follows_focus {
                  let sr = self.focused_rect();
 -                let (gap_inner, gap_outer) = self.workspace_gaps(self.active_ws_idx());
 -                let geoms = self
 -                    .active_workspace()
 -                    .tree
 -                    .calculate_geometries_with_gaps(sr, gap_inner, gap_outer, true);
 +                let geoms = self.workspace_focus_geometries(self.active_ws_idx(), sr);
                  if let Some((_, rect)) = geoms.iter().find(|(id, _)| *id == wid) {
                      warp_mouse_to_center(rect);
                  } else {
              self.focus_window(wid);
              if self.mouse_follows_focus {
                  let sr = self.focused_rect();
 -                let (gap_inner, gap_outer) = self.workspace_gaps(self.active_ws_idx());
 -                let geoms = self
 -                    .active_workspace()
 -                    .tree
 -                    .calculate_geometries_with_gaps(sr, gap_inner, gap_outer, true);
 +                let geoms = self.workspace_focus_geometries(self.active_ws_idx(), sr);
                  if let Some((_, rect)) = geoms.iter().find(|(id, _)| *id == wid) {
                      warp_mouse_to_center(rect);
                  } else {
+     }
      /// After moving a window to a specific workspace, try swaps to fix overflow.
 -    /// If no swap works, float the window centered instead of evicting.
 +    /// If no swap works, replace the smallest conflicting subtree with a stack.
      /// Only runs when the target workspace is visible — hidden workspaces have
      /// stale window sizes and will be checked when switched to.
      fn fix_oversized_on_target(&mut self, ws_idx: usize, moved_wid: super::window::WindowId) {
          std::thread::sleep(std::time::Duration::from_millis(100));
          // Check if the moved window actually overflows
 -        let geometries = self
 -            .workspaces
 -            .get(ws_idx)
 -            .tree
 -            .calculate_geometries_with_gaps(
 -                screen_rect,
 -                self.workspace_gaps(ws_idx).0,
 -                self.workspace_gaps(ws_idx).1,
 -                true,
 -            );
 +        let geometries = self.workspace_focus_geometries(ws_idx, screen_rect);
          let (_min_w, _min_h) = match geometries.iter().find(|(wid, _)| *wid == moved_wid) {
              Some((_, rect)) => {
          // Try swaps with settled-set logic (same as fix_oversized_windows phase 1)
          let mut settled: Vec<super::window::WindowId> = Vec::new();
          loop {
 -            let geoms = self
 -                .workspaces
 -                .get(ws_idx)
 -                .tree
 -                .calculate_geometries_with_gaps(
 -                    screen_rect,
 -                    self.workspace_gaps(ws_idx).0,
 -                    self.workspace_gaps(ws_idx).1,
 -                    true,
 -                );
 +            let geoms = self.workspace_focus_geometries(ws_idx, screen_rect);
              if geoms.is_empty() {
                  break;
+             }
                  self.apply_layout();
                  settled.push(ow);
              } else {
 -                // No swap possible — float this window centered
 -                tracing::info!(
 -                    id = ow,
 -                    min_w = ow_min_w,
 -                    min_h = ow_min_h,
 -                    ws = ws_idx + 1,
 -                    "floating oversized window on target workspace"
 -                );
 -                self.workspaces
 -                    .get_mut(ws_idx)
 -                    .toggle_float(ow, screen_rect);
 -                if let Some(ax_ref) = self.ax_refs.get(&ow) {
 -                    let fx = screen_rect.x + (screen_rect.width - ow_min_w) / 2.0;
 -                    let fy = screen_rect.y + (screen_rect.height - ow_min_h) / 2.0;
 -                    let _ = ax_set_position(ax_ref, fx, fy);
 -                    let _ = ax_set_size(ax_ref, ow_min_w, ow_min_h);
 +                if self.workspaces.get_mut(ws_idx).tree.make_stack_for_window(ow) {
 +                    tracing::info!(
 +                        id = ow,
 +                        min_w = ow_min_w,
 +                        min_h = ow_min_h,
 +                        ws = ws_idx + 1,
 +                        "stacking oversized subtree on target workspace"
 +                    );
 +                    self.workspaces.get_mut(ws_idx).tree.set_stack_active(ow);
 +                    self.apply_layout();
 +                    std::thread::sleep(std::time::Duration::from_millis(50));
 +                } else {
 +                    break;
+                 }
 -                use crate::platform::skylight::{K_CG_FLOATING_WINDOW_LEVEL, set_window_level};
 -                set_window_level(ow, K_CG_FLOATING_WINDOW_LEVEL);
 -                self.apply_layout();
 -                // Continue checking — other windows may still overflow
+             }
+         }
+     }
                      // Record on the workspace that contains this window,
                      // not the active workspace (same fix as focus_window_impl)
                      if let Some(ws_idx) = self.workspaces.find_window(id) {
 +                        self.workspaces.get_mut(ws_idx).tree.set_stack_active(id);
                          self.workspaces.get_mut(ws_idx).record_focus(id);
+                     }
+                 }
  mod tests {
      use super::*;
      use crate::core::monitor::Monitor;
 +    use crate::core::tree::Direction;
      #[test]
      fn hide_anchor_frame_defaults_without_monitors() {
          state.sync_workspace_visibility();
          assert!(!state.is_window_hidden(123));
+     }
++
 +    #[test]
 +    fn focus_direction_cycles_stacked_windows_left_right() {
 +        let mut state = WmState::new();
 +        state.monitors = vec![Monitor {
 +            id: 42,
 +            frame: Rect::new(0.0, 0.0, 1920.0, 1080.0),
 +            usable_frame: Rect::new(0.0, 33.0, 1920.0, 1047.0),
 +            is_primary: true,
 +            active_workspace: 0,
 +        }];
 +        state.sync_workspace_visibility();
 +        let screen = state.monitors[0].usable_frame;
++
 +        {
 +            let ws = state.workspaces.get_mut(0);
 +            ws.tree.insert_with_rect(1, None, screen);
 +            ws.tree.insert_with_rect(2, Some(1), screen);
 +            ws.tree.insert_with_rect(3, Some(2), screen);
 +            assert!(ws.tree.make_stack_for_window(3));
 +            ws.tree.set_stack_active(3);
 +            ws.record_focus(3);
 +        }
++
 +        state.focus_direction(Direction::Left);
 +        assert_eq!(state.active_workspace().focused, Some(2));
++
 +        state.focus_direction(Direction::Right);
 +        assert_eq!(state.active_workspace().focused, Some(3));
 +    }
++
 +    #[test]
 +    fn unstack_focused_restores_original_tree() {
 +        let mut state = WmState::new();
 +        state.monitors = vec![Monitor {
 +            id: 42,
 +            frame: Rect::new(0.0, 0.0, 1920.0, 1080.0),
 +            usable_frame: Rect::new(0.0, 33.0, 1920.0, 1047.0),
 +            is_primary: true,
 +            active_workspace: 0,
 +        }];
 +        state.sync_workspace_visibility();
 +        let screen = state.monitors[0].usable_frame;
++
 +        let original = {
 +            let ws = state.workspaces.get_mut(0);
 +            ws.tree.insert_with_rect(1, None, screen);
 +            ws.tree.insert_with_rect(2, Some(1), screen);
 +            ws.tree.insert_with_rect(3, Some(2), screen);
 +            let original = ws.tree.clone();
 +            assert!(ws.tree.make_stack_for_window(3));
 +            ws.tree.set_stack_active(3);
 +            ws.record_focus(3);
 +            original
 +        };
++
 +        state.unstack_focused();
 +        assert_eq!(state.active_workspace().tree, original);
 +    }
+ }

tarmac/src/core/tree.rsmodified

+     }
+ }
 -#[derive(Debug, Clone)]
 +const STACK_REVEAL_OFFSET: f64 = 24.0;
++
 +#[derive(Debug, Clone, PartialEq)]
  pub enum Node {
      Internal {
          split: SplitDirection,
          left: Box<Node>,
          right: Box<Node>,
      },
 +    Stack {
 +        windows: Vec<WindowId>,
 +        active: usize,
 +        previous: Box<Node>,
 +    },
      Leaf {
          window: Option<WindowId>,
      },
          matches!(self, Node::Leaf { window: None })
+     }
 +    pub fn slot_count(&self) -> usize {
 +        match self {
 +            Node::Leaf { window: Some(_) } => 1,
 +            Node::Leaf { window: None } => 0,
 +            Node::Stack { windows, .. } => usize::from(!windows.is_empty()),
 +            Node::Internal { left, right, .. } => left.slot_count() + right.slot_count(),
 +        }
 +    }
++
      pub fn window_count(&self) -> usize {
          match self {
              Node::Leaf { window: Some(_) } => 1,
              Node::Leaf { window: None } => 0,
 +            Node::Stack { windows, .. } => windows.len(),
              Node::Internal { left, right, .. } => left.window_count() + right.window_count(),
+         }
+     }
          match self {
              Node::Leaf { window: Some(w) } => vec![*w],
              Node::Leaf { window: None } => vec![],
 +            Node::Stack { windows, .. } => windows.clone(),
              Node::Internal { left, right, .. } => {
                  let mut ws = left.windows();
                  ws.extend(right.windows());
          match self {
              Node::Leaf { window: Some(w) } => *w == window,
              Node::Leaf { window: None } => false,
 +            Node::Stack { windows, .. } => windows.contains(&window),
              Node::Internal { left, right, .. } => left.contains(window) || right.contains(window),
+         }
+     }
      pub fn first_window(&self) -> Option<WindowId> {
          match self {
              Node::Leaf { window } => *window,
 +            Node::Stack {
 +                windows, active, ..
 +            } => windows.get(*active).copied().or_else(|| windows.first().copied()),
              Node::Internal { left, right, .. } => {
                  left.first_window().or_else(|| right.first_window())
+             }
                      right.insert_with_rect(new_window, None, right_rect);
+                 }
+             }
 +            Node::Stack {
 +                windows,
 +                active,
 +                previous,
 +            } => {
 +                let insert_at = target
 +                    .and_then(|target_window| windows.iter().position(|wid| *wid == target_window))
 +                    .map(|idx| idx + 1)
 +                    .unwrap_or_else(|| (*active + 1).min(windows.len()));
 +                windows.insert(insert_at, new_window);
 +                *active = insert_at;
 +                previous.insert_with_rect(new_window, target, rect);
 +            }
+         }
+     }
                  true
+             }
              Node::Leaf { .. } => false,
 +            Node::Stack {
 +                windows,
 +                active,
 +                previous,
 +            } => {
 +                let Some(idx) = windows.iter().position(|wid| *wid == window) else {
 +                    return false;
 +                };
 +                windows.remove(idx);
 +                previous.remove(window);
++
 +                if windows.is_empty() {
 +                    *self = Node::empty();
 +                } else if windows.len() == 1 {
 +                    *self = Node::Leaf {
 +                        window: windows.first().copied(),
 +                    };
 +                } else if *active >= windows.len() {
 +                    *active = windows.len() - 1;
 +                } else if idx < *active {
 +                    *active -= 1;
 +                }
 +                true
 +            }
              Node::Internal { left, right, .. } => {
                  if left.remove(window) {
                      if left.is_empty() {
          self.calculate_geometries_with_gaps(rect, 0.0, 0.0, true)
+     }
 +    pub fn calculate_focus_geometries(&self, rect: Rect) -> Vec<(WindowId, Rect)> {
 +        self.calculate_focus_geometries_with_gaps(rect, 0.0, 0.0, true)
 +    }
++
      /// Calculate geometries with inner and outer gaps.
      /// `gap_outer` is applied to the root rect edges.
      /// `gap_inner` is the space between adjacent windows (half applied to each side).
          match self {
              Node::Leaf { window: Some(w) } => vec![(*w, padded)],
              Node::Leaf { window: None } => vec![],
 +            Node::Stack {
 +                windows, active, ..
 +            } => {
 +                let active_window = windows.get(*active).copied();
 +                let mut geoms = Vec::with_capacity(windows.len());
 +                let mut depth = 0usize;
 +                for (idx, wid) in windows.iter().enumerate() {
 +                    if Some(*wid) == active_window {
 +                        continue;
 +                    }
 +                    depth += 1;
 +                    geoms.push((
 +                        *wid,
 +                        Rect::new(
 +                            padded.x + STACK_REVEAL_OFFSET * depth as f64,
 +                            padded.y,
 +                            padded.width,
 +                            padded.height,
 +                        ),
 +                    ));
 +                    if idx == *active {
 +                        depth = depth.saturating_sub(1);
 +                    }
 +                }
 +                if let Some(wid) = active_window {
 +                    geoms.push((wid, padded));
 +                }
 +                geoms
 +            }
              Node::Internal {
                  split,
                  ratio,
+         }
+     }
 +    pub fn calculate_focus_geometries_with_gaps(
 +        &self,
 +        rect: Rect,
 +        gap_inner: f64,
 +        gap_outer: f64,
 +        is_root: bool,
 +    ) -> Vec<(WindowId, Rect)> {
 +        let padded = if is_root && gap_outer > 0.0 {
 +            Rect::new(
 +                rect.x + gap_outer,
 +                rect.y + gap_outer,
 +                (rect.width - 2.0 * gap_outer).max(0.0),
 +                (rect.height - 2.0 * gap_outer).max(0.0),
 +            )
 +        } else {
 +            rect
 +        };
++
 +        match self {
 +            Node::Leaf { window: Some(w) } => vec![(*w, padded)],
 +            Node::Leaf { window: None } => vec![],
 +            Node::Stack {
 +                windows, active, ..
 +            } => windows
 +                .get(*active)
 +                .copied()
 +                .map(|wid| vec![(wid, padded)])
 +                .unwrap_or_default(),
 +            Node::Internal {
 +                split,
 +                ratio,
 +                left,
 +                right,
 +            } => {
 +                let half_gap = gap_inner / 2.0;
 +                let (mut left_rect, mut right_rect) = padded.split(*split, *ratio);
++
 +                if gap_inner > 0.0 {
 +                    match split {
 +                        SplitDirection::Vertical => {
 +                            left_rect.width = (left_rect.width - half_gap).max(0.0);
 +                            right_rect.x += half_gap;
 +                            right_rect.width = (right_rect.width - half_gap).max(0.0);
 +                        }
 +                        SplitDirection::Horizontal => {
 +                            left_rect.height = (left_rect.height - half_gap).max(0.0);
 +                            right_rect.y += half_gap;
 +                            right_rect.height = (right_rect.height - half_gap).max(0.0);
 +                        }
 +                    }
 +                }
++
 +                let mut geoms = left.calculate_focus_geometries_with_gaps(
 +                    left_rect, gap_inner, gap_outer, false,
 +                );
 +                geoms.extend(right.calculate_focus_geometries_with_gaps(
 +                    right_rect, gap_inner, gap_outer, false,
 +                ));
 +                geoms
 +            }
 +        }
 +    }
++
      /// Equalize all split ratios to 0.5.
      pub fn equalize(&mut self) {
          if let Node::Internal {
+                 }
+             }
              Node::Leaf { window: None } => {}
 +            Node::Stack {
 +                windows,
 +                active,
 +                previous,
 +            } => {
 +                if let Some(w) = windows.iter_mut().find(|w| **w == a) {
 +                    *w = b;
 +                    *found_a = true;
 +                } else if let Some(w) = windows.iter_mut().find(|w| **w == b) {
 +                    *w = a;
 +                    *found_b = true;
 +                }
 +                if let Some(current) = windows.get(*active).copied() {
 +                    if current == a {
 +                        *active = windows.iter().position(|wid| *wid == b).unwrap_or(*active);
 +                    } else if current == b {
 +                        *active = windows.iter().position(|wid| *wid == a).unwrap_or(*active);
 +                    }
 +                }
 +                previous.swap_impl(a, b, found_a, found_b);
 +            }
              Node::Internal { left, right, .. } => {
                  left.swap_impl(a, b, found_a, found_b);
                  right.swap_impl(a, b, found_a, found_b);
      /// Resize the split affecting a window in the given direction.
      pub fn resize(&mut self, window: WindowId, direction: Direction, delta: f32) -> bool {
          match self {
 -            Node::Leaf { .. } => false,
 +            Node::Leaf { .. } | Node::Stack { .. } => false,
              Node::Internal {
                  split,
                  ratio,
+             }
+         }
+     }
++
 +    pub fn set_stack_active(&mut self, window: WindowId) -> bool {
 +        match self {
 +            Node::Stack {
 +                windows,
 +                active,
 +                previous: _,
 +            } => {
 +                if let Some(idx) = windows.iter().position(|wid| *wid == window) {
 +                    *active = idx;
 +                    true
 +                } else {
 +                    false
 +                }
 +            }
 +            Node::Internal { left, right, .. } => {
 +                left.set_stack_active(window) || right.set_stack_active(window)
 +            }
 +            Node::Leaf { .. } => false,
 +        }
 +    }
++
 +    pub fn stack_info(&self, window: WindowId) -> Option<(Vec<WindowId>, usize)> {
 +        match self {
 +            Node::Stack {
 +                windows, active, ..
 +            } if windows.contains(&window) => Some((windows.clone(), *active)),
 +            Node::Internal { left, right, .. } => left
 +                .stack_info(window)
 +                .or_else(|| right.stack_info(window)),
 +            _ => None,
 +        }
 +    }
++
 +    pub fn cycle_stack(&mut self, window: WindowId, forward: bool) -> Option<WindowId> {
 +        match self {
 +            Node::Stack {
 +                windows, active, ..
 +            } if windows.contains(&window) => {
 +                if windows.is_empty() {
 +                    return None;
 +                }
 +                let len = windows.len();
 +                *active = if forward {
 +                    (*active + 1) % len
 +                } else if *active == 0 {
 +                    len - 1
 +                } else {
 +                    *active - 1
 +                };
 +                windows.get(*active).copied()
 +            }
 +            Node::Internal { left, right, .. } => left
 +                .cycle_stack(window, forward)
 +                .or_else(|| right.cycle_stack(window, forward)),
 +            _ => None,
 +        }
 +    }
++
 +    pub fn reorder_stack(&mut self, window: WindowId, forward: bool) -> Option<WindowId> {
 +        match self {
 +            Node::Stack {
 +                windows,
 +                active,
 +                previous,
 +            } if windows.contains(&window) => {
 +                let idx = windows.iter().position(|wid| *wid == window)?;
 +                let swap_idx = if forward {
 +                    if idx + 1 < windows.len() {
 +                        idx + 1
 +                    } else {
 +                        0
 +                    }
 +                } else if idx == 0 {
 +                    windows.len() - 1
 +                } else {
 +                    idx - 1
 +                };
 +                windows.swap(idx, swap_idx);
 +                *active = swap_idx;
 +                previous.swap(window, windows[idx]);
 +                windows.get(*active).copied()
 +            }
 +            Node::Internal { left, right, .. } => left
 +                .reorder_stack(window, forward)
 +                .or_else(|| right.reorder_stack(window, forward)),
 +            _ => None,
 +        }
 +    }
++
 +    pub fn unstack(&mut self, window: WindowId) -> bool {
 +        match self {
 +            Node::Stack {
 +                windows, previous, ..
 +            } if windows.contains(&window) => {
 +                *self = (**previous).clone();
 +                true
 +            }
 +            Node::Internal { left, right, .. } => left.unstack(window) || right.unstack(window),
 +            _ => false,
 +        }
 +    }
++
 +    pub fn make_stack_for_window(&mut self, window: WindowId) -> bool {
 +        self.make_stack_for_window_impl(window)
 +    }
++
 +    fn make_stack_for_window_impl(&mut self, window: WindowId) -> bool {
 +        match self {
 +            Node::Internal { left, right, .. } => {
 +                let left_contains = left.contains(window);
 +                let right_contains = right.contains(window);
 +                if !left_contains && !right_contains {
 +                    return false;
 +                }
++
 +                let child_contains = if left_contains { left } else { right };
 +                if !matches!(child_contains.as_ref(), Node::Stack { .. })
 +                    && child_contains.slot_count() > 1
 +                    && child_contains.make_stack_for_window_impl(window)
 +                {
 +                    return true;
 +                }
++
 +                if self.slot_count() > 1 {
 +                    let previous = self.clone();
 +                    let windows = self.windows();
 +                    let active = windows.iter().position(|wid| *wid == window).unwrap_or(0);
 +                    *self = Node::Stack {
 +                        windows,
 +                        active,
 +                        previous: Box::new(previous),
 +                    };
 +                    true
 +                } else {
 +                    false
 +                }
 +            }
 +            _ => false,
 +        }
 +    }
+ }
  #[cfg(test)]
              );
+         }
+     }
++
 +    #[test]
 +    fn make_stack_for_window_replaces_smallest_conflicting_subtree() {
 +        let mut tree = Node::empty();
 +        tree.insert_with_rect(1, None, SCREEN);
 +        tree.insert_with_rect(2, Some(1), SCREEN);
 +        tree.insert_with_rect(3, Some(2), SCREEN);
++
 +        assert!(tree.make_stack_for_window(3));
 +        let stack = tree.stack_info(3).expect("window should be stacked");
 +        assert_eq!(stack.0, vec![2, 3]);
 +        assert_eq!(stack.1, 1);
 +        assert!(tree.contains(1));
 +    }
++
 +    #[test]
 +    fn stacked_render_geometries_reveal_background_windows() {
 +        let mut tree = Node::empty();
 +        tree.insert_with_rect(1, None, SCREEN);
 +        tree.insert_with_rect(2, Some(1), SCREEN);
 +        tree.insert_with_rect(3, Some(2), SCREEN);
 +        assert!(tree.make_stack_for_window(3));
++
 +        let geoms = tree.calculate_geometries(SCREEN);
 +        let g2 = geoms.iter().find(|(wid, _)| *wid == 2).unwrap().1;
 +        let g3 = geoms.iter().find(|(wid, _)| *wid == 3).unwrap().1;
++
 +        assert!(g2.x > g3.x);
 +        assert_eq!(g2.width, g3.width);
 +        assert_eq!(g2.height, g3.height);
 +    }
++
 +    #[test]
 +    fn unstack_restores_previous_subtree() {
 +        let mut tree = Node::empty();
 +        tree.insert_with_rect(1, None, SCREEN);
 +        tree.insert_with_rect(2, Some(1), SCREEN);
 +        tree.insert_with_rect(3, Some(2), SCREEN);
 +        let original = tree.clone();
++
 +        assert!(tree.make_stack_for_window(3));
 +        assert!(tree.unstack(3));
 +        assert_eq!(tree, original);
 +    }
++
 +    #[test]
 +    fn removing_from_stack_collapses_to_leaf() {
 +        let mut tree = Node::empty();
 +        tree.insert_with_rect(1, None, SCREEN);
 +        tree.insert_with_rect(2, Some(1), SCREEN);
++
 +        assert!(tree.make_stack_for_window(2));
 +        assert!(tree.remove(2));
++
 +        assert!(matches!(tree, Node::Leaf { window: Some(1) }));
 +    }
+ }

tarmac/src/main.rsmodified

                      });
+                 }
                  Action::ToggleFloat => state.toggle_float(),
 +                Action::Unstack => state.unstack_focused(),
                  Action::ToggleSpecial(ref name) => state.toggle_special(name),
                  Action::MoveToSpecial(ref name) => state.move_to_special(name),
                  Action::FocusMonitorNext => {
  gar.bind("mod+shift+q", "close")
  gar.bind("mod+e", "equalize")
  gar.bind("mod+shift+space", "toggle_float")
 +gar.bind("mod+shift+u", "unstack")
  -- Focus
  gar.bind("mod+h", "focus left")
                  state.equalize();
                  Response::ok_empty()
+             }
 +            "unstack" => {
 +                state.unstack_focused();
 +                Response::ok_empty()
 +            }
              "workspace" => {
                  if let Some(target) = request
                      .args
                          .map(|w| w.app_name.clone())
                          .unwrap_or_default();
                      let floating = state.active_workspace().is_floating(focused_id);
 +                    let stack = state
 +                        .active_workspace()
 +                        .tree
 +                        .stack_info(focused_id)
 +                        .map(|(members, active)| {
 +                            serde_json::json!({
 +                                "members": members,
 +                                "active_index": active,
 +                                "active": members.get(active),
 +                            })
 +                        });
                      // Query live AX data for current title and geometry
                      let (title, x, y, width, height) =
                          "x": x, "y": y,
                          "width": width, "height": height,
                          "floating": floating,
 +                        "stack": stack,
                          "workspace": state.active_workspace().id.to_string(),
                      }))
                  } else {
                      .monitor_showing_workspace(ws_idx)
                      .map(|mi| state.monitor_rect(mi))
                      .unwrap_or_else(|| state.focused_rect());
 -                let geoms = ws.tree.calculate_geometries_with_gaps(
 -                    sr,
 -                    state.gap_inner,
 -                    state.gap_outer,
 -                    true,
 -                );
 +                let (gap_inner, gap_outer) = state.workspace_gaps(ws_idx);
 +                let geoms = ws
 +                    .tree
 +                    .calculate_geometries_with_gaps(sr, gap_inner, gap_outer, true);
                  let windows: Vec<serde_json::Value> = geoms
                      .iter()
                      .map(|(wid, rect)| {
                              .get(*wid)
                              .map(|w| w.app_name.clone())
                              .unwrap_or_default();
 +                        let stack = ws.tree.stack_info(*wid);
 +                        let stack_index = stack
 +                            .as_ref()
 +                            .and_then(|(members, _)| members.iter().position(|id| *id == *wid));
 +                        let stack_active = stack
 +                            .as_ref()
 +                            .map(|(members, active)| members.get(*active) == Some(wid))
 +                            .unwrap_or(false);
                          serde_json::json!({
                              "id": wid,
                              "app_name": app_name,
                              "x": rect.x, "y": rect.y,
                              "width": rect.width, "height": rect.height,
 +                            "stacked": stack.is_some(),
 +                            "stack_index": stack_index,
 +                            "stack_active": stack_active,
                          })
                      })
                      .collect();

tarmacctl/src/main.rsmodified

          eprintln!("  resize <left|right|up|down>   Resize split in direction");
          eprintln!("  close                         Close focused window");
          eprintln!("  equalize                      Equalize all splits");
 +        eprintln!("  unstack                       Restore the focused stacked subtree");
          eprintln!("  workspace <1-10>              Switch workspace");
          eprintln!("  move-to-workspace <1-10>      Move window to workspace");
          eprintln!("  toggle-floating               Toggle floating state");