Add stack promotion action

Status	File	+
M	`tarmac/src/config/lua.rs`	8
M	`tarmac/src/core/input.rs`	1
M	`tarmac/src/core/state.rs`	57
M	`tarmac/src/core/tree.rs`	40
M	`tarmac/src/main.rs`	6
M	`tarmacctl/src/main.rs`	1

tarmac/src/config/lua.rsmodified

          "equalize" => Ok(Action::Equalize),
          "toggle_float" => Ok(Action::ToggleFloat),
          "unstack" => Ok(Action::Unstack),
 +        "promote_stack" => Ok(Action::PromoteStack),
          "workspace_next" => Ok(Action::WorkspaceNext),
          "workspace_prev" => Ok(Action::WorkspacePrev),
          "focus_monitor_next" => Ok(Action::FocusMonitorNext),
              key: Key::U,
              action: Action::Unstack,
          },
 +        LuaKeybind {
 +            modifiers: Modifiers::OPTION | Modifiers::SHIFT,
 +            key: Key::Period,
 +            action: Action::PromoteStack,
 +        },
          // Focus
          LuaKeybind {
              modifiers: m,
          Action::WorkspacePrev => "workspace_prev".to_string(),
          Action::ToggleFloat => "toggle_float".to_string(),
          Action::Unstack => "unstack".to_string(),
 +        Action::PromoteStack => "promote_stack".to_string(),
          Action::ToggleSpecial(name) => format!("toggle_special {name}"),
          Action::MoveToSpecial(name) => format!("move_to_special {name}"),
          Action::FocusMonitorNext => "focus_monitor_next".to_string(),
          assert_eq!(parse_action("equalize").unwrap(), Action::Equalize);
          assert_eq!(parse_action("close").unwrap(), Action::CloseWindow);
          assert_eq!(parse_action("toggle_float").unwrap(), Action::ToggleFloat);
 +        assert_eq!(parse_action("promote_stack").unwrap(), Action::PromoteStack);
+     }
      #[test]

tarmac/src/core/input.rsmodified

      MoveToMonitorNext,                // Move window to next monitor
      MoveToMonitorPrev,                // Move window to previous monitor
      Unstack,                          // Restore a stacked subtree to its saved BSP shape
 +    PromoteStack,                     // Move the active stack member to the top/front of the stack
      Reload,                           // Hot reload config
      Exit,                             // Clean exit
+ }

tarmac/src/core/state.rsmodified

+         }
+     }
 +    pub fn promote_stack_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
 +            .promote_stack_window(focused)
 +        {
 +            self.apply_layout();
 +            self.focus_window(focused);
 +            tracing::info!(id = focused, "promoted focused stack window to top");
 +        }
 +    }
++
      pub fn click_to_focus(&mut self, x: f64, y: f64) {
          let ws = self.active_workspace();
          assert_eq!(state.active_workspace().focused, Some(40));
+     }
 +    #[test]
 +    fn promote_stack_focused_moves_active_window_to_top() {
 +        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.promote_stack_focused();
++
 +        assert_eq!(state.active_workspace().focused, Some(2));
 +        assert_eq!(
 +            state.active_workspace().tree.stack_info(2),
 +            Some((vec![2, 3], 0))
 +        );
 +    }
++
      #[test]
      fn unstack_focused_restores_original_tree() {
          let mut state = WmState::new();

tarmac/src/core/tree.rsmodified

+         }
+     }
 +    pub fn promote_stack_window(&mut self, window: WindowId) -> bool {
 +        match self {
 +            Node::Stack {
 +                windows,
 +                active,
 +                previous,
 +            } if windows.contains(&window) => {
 +                let Some(idx) = windows.iter().position(|wid| *wid == window) else {
 +                    return false;
 +                };
 +                if idx == 0 {
 +                    *active = 0;
 +                    return true;
 +                }
 +                let displaced = windows[0];
 +                windows.remove(idx);
 +                windows.insert(0, window);
 +                *active = 0;
 +                previous.swap(window, displaced);
 +                true
 +            }
 +            Node::Internal { left, right, .. } => {
 +                left.promote_stack_window(window) || right.promote_stack_window(window)
 +            }
 +            _ => false,
 +        }
 +    }
++
      pub fn make_stack_for_window(&mut self, window: WindowId) -> bool {
          self.make_stack_for_window_impl(window)
+     }
          assert_eq!(g2.height, g3.height);
+     }
 +    #[test]
 +    fn promote_stack_window_moves_target_to_top() {
 +        let mut tree = Node::Stack {
 +            windows: vec![1, 2, 3],
 +            active: 2,
 +            previous: Box::new(Node::Leaf { window: Some(3) }),
 +        };
++
 +        assert!(tree.promote_stack_window(3));
 +        assert_eq!(tree.stack_info(3), Some((vec![3, 1, 2], 0)));
 +    }
++
      #[test]
      fn cycle_stack_stops_at_directional_boundary() {
          let mut tree = Node::empty();

tarmac/src/main.rsmodified

+                 }
                  Action::ToggleFloat => state.toggle_float(),
                  Action::Unstack => state.unstack_focused(),
 +                Action::PromoteStack => state.promote_stack_focused(),
                  Action::ToggleSpecial(ref name) => state.toggle_special(name),
                  Action::MoveToSpecial(ref name) => state.move_to_special(name),
                  Action::FocusMonitorNext => {
  gar.bind("mod+e", "equalize")
  gar.bind("mod+shift+space", "toggle_float")
  gar.bind("mod+shift+u", "unstack")
 +gar.bind("alt+shift+.", "promote_stack")
  -- Focus
  gar.bind("mod+h", "focus left")
                  state.unstack_focused();
                  Response::ok_empty()
+             }
 +            "promote_stack" => {
 +                state.promote_stack_focused();
 +                Response::ok_empty()
 +            }
              "workspace" => {
                  if let Some(target) = request
                      .args

tarmacctl/src/main.rsmodified

          eprintln!("  close                         Close focused window");
          eprintln!("  equalize                      Equalize all splits");
          eprintln!("  unstack                       Restore the focused stacked subtree");
 +        eprintln!("  promote_stack                 Move the focused stack window to the top");
          eprintln!("  workspace <1-10>              Switch workspace");
          eprintln!("  move-to-workspace <1-10>      Move window to workspace");
          eprintln!("  toggle-floating               Toggle floating state");

gardesk/tarmac / `3b49a3e`

6 changed files