monolith

public

Star0

Fork 0

Watch0

338 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `af095d8ce0fc`

tarball

atagen <boss@atagen.co>2026-10-28 04:06 UTC

5 files changed+102-14

layout: keep directional focus on its layer and add focus-layer

Directional focus mixed floating and tiled windows, so a float over a tile could be stepped into by accident and out of only by luck. Floats step by their centres because they overlap, which left the edge-based Layout::focus_dir unable to reach a float overlapping the focused one. focus-layer, on Mod+space, is the way across.

Modified file: crates/config/default.toml+1

@@ -145,6 +145,7 @@ selection_access = "focused"

145145 "Mod+o" = "flip"

146146 "Mod+f" = "fullscreen"

147147 "Mod+Shift+space" = "float"

148+"Mod+space" = "focus-layer"

148149 "Mod+s" = "sticky"

149150

150151 "Mod+comma" = "focus-output left"

Modified file: crates/ipc/src/lib.rs+3 additions@@ -47,6 +47,8 @@ pub enum Command {
     Focus {
         dir: Dir,
     },
+    /// Focuses the latest window on the other layer, floating or tiled.
+    FocusLayer,
     Move {
         dir: Dir,
     },
@@ -173,6 +175,7 @@ impl Command {
             "fullscreen" => none(Command::Fullscreen)?,
             "sticky" => none(Command::Sticky)?,
             "focus" => Command::Focus { dir: dir()? },
+            "focus-layer" => none(Command::FocusLayer)?,
             "move" => Command::Move { dir: dir()? },
             "move-container" => Command::MoveContainer { dir: dir()? },
             "focus-output" => Command::FocusOutput { dir: dir()? },

Modified file: crates/layout/src/lib.rs+71 additions−14 deletions@@ -558,26 +558,24 @@ impl Layout {
             .map(|w| self.modal_leaf(w))
     }
 
-    /// Focuses the nearest visible window in `dir`, crossing to the next
-    /// output when there is none on this one.
+    /// Focuses the nearest visible window in `dir` on the focused window's
+    /// layer, tiled or floating, crossing to the next output when there is
+    /// none on this one.
     pub fn focus_dir(&mut self, dir: Dir) -> Option<WindowId> {
         let o = self.active?;
         let current = self.focused_on(o);
         let from = current.and_then(|f| self.rect_of(f));
         let target = from.and_then(|from| {
             let arr = self.arrange(o);
-            let reachable = |w| {
-                arr.fullscreen
-                    .is_none_or(|f| w == f || arr.over.contains(&w))
-            };
-            let candidates = arr
-                .tiled
-                .iter()
-                .filter(|p| p.visible && !self.eclipsed(p.window))
-                .map(|p| (p.window, p.rect))
-                .chain(arr.floating.iter().copied())
-                .filter(|&(w, _)| Some(self.modal_leaf(w)) != current && reachable(w));
-            nearest(from, dir, candidates)
+            let floating = current.is_some_and(|f| arr.floating.iter().any(|p| p.0 == f));
+            let candidates = self
+                .layer(&arr, floating)
+                .filter(|&(w, _)| Some(self.modal_leaf(w)) != current);
+            if floating {
+                nearest_centre(from, dir, candidates)
+            } else {
+                nearest(from, dir, candidates)
+            }
         });
         if let Some(w) = target {
             return self.focus(w);
@@ -591,6 +589,39 @@ impl Layout {
         w
     }
 
+    /// Focuses the most recently focused window on the other layer, floating
+    /// when a tiled window has focus and tiled otherwise.
+    pub fn focus_layer(&mut self) -> Option<WindowId> {
+        let o = self.active?;
+        let arr = self.arrange(o);
+        let floating = self
+            .focused_on(o)
+            .is_some_and(|f| arr.floating.iter().any(|p| p.0 == f));
+        let w = self
+            .layer(&arr, !floating)
+            .map(|(w, _)| w)
+            .max_by_key(|&w| self.history.iter().position(|&h| h == w))?;
+        self.focus(w)
+    }
+
+    /// The windows focus can reach on one layer of an arrangement.
+    fn layer<'a>(
+        &'a self,
+        arr: &'a Arrangement,
+        floating: bool,
+    ) -> impl Iterator<Item = (WindowId, Rect)> + 'a {
+        let tiled = arr
+            .tiled
+            .iter()
+            .filter(move |p| !floating && p.visible && !self.eclipsed(p.window))
+            .map(|p| (p.window, p.rect));
+        let floats = arr.floating.iter().copied().filter(move |_| floating);
+        tiled.chain(floats).filter(|&(w, _)| {
+            arr.fullscreen
+                .is_none_or(|f| w == f || arr.over.contains(&w))
+        })
+    }
+
     pub fn output_towards(&self, from: OutputId, dir: Dir) -> Option<OutputId> {
         let here = self.outputs.get(from)?.area;
         let others = self
@@ -1091,6 +1122,32 @@ fn nearest<K: Copy>(
         .map(|(k, _)| k)
 }
 
+/// The candidate whose centre is nearest `from`'s within 45 degrees of
+/// `dir`. Floating windows overlap freely, so their edges say little about
+/// which way one lies from another.
+fn nearest_centre<K: Copy>(
+    from: Rect,
+    dir: Dir,
+    candidates: impl Iterator<Item = (K, Rect)>,
+) -> Option<K> {
+    candidates
+        .filter_map(|(k, r)| {
+            let (dx, dy) = (
+                r.center_x() - from.center_x(),
+                r.center_y() - from.center_y(),
+            );
+            let (along, across) = match dir {
+                Dir::Right => (dx, dy),
+                Dir::Left => (-dx, dy),
+                Dir::Down => (dy, dx),
+                Dir::Up => (-dy, dx),
+            };
+            (along > 0.0 && along >= across.abs()).then_some((k, along.hypot(across)))
+        })
+        .min_by(|a, b| a.1.total_cmp(&b.1))
+        .map(|(k, _)| k)
+}
+
 fn span_overlap(a: f64, al: f64, b: f64, bl: f64) -> f64 {
     (a + al).min(b + bl) - a.max(b)
 }

Modified file: crates/layout/src/tests.rs+24 additions@@ -979,3 +979,27 @@ fn new_floats_land_inside_the_bars() {
     let r = l.window(plain).and_then(|w| w.float_rect).unwrap();
     assert_eq!(r.y + r.h / 2.0, usable.y + usable.h / 2.0);
 }
+
+/// Overlapping floats have no clear edge between them, so edge-based focus
+/// could not step from one to another it overlaps.
+#[test]
+fn floating_focus_steps_by_centres_and_stays_on_its_layer() {
+    let mut l = Layout::default();
+    let o = l.add_output("a", AREA);
+    let tiled = l.add_window(Some(o), None, None);
+    let a = l.add_window(Some(o), None, Some(Rect::new(100.0, 100.0, 400.0, 300.0)));
+    let b = l.add_window(Some(o), None, Some(Rect::new(350.0, 120.0, 300.0, 200.0)));
+    let c = l.add_window(Some(o), None, Some(Rect::new(250.0, 350.0, 200.0, 200.0)));
+    l.focus(a);
+    assert_eq!(l.focus_dir(Dir::Right), Some(b));
+    l.focus(a);
+    assert_eq!(l.focus_dir(Dir::Down), Some(c));
+    assert_eq!(
+        l.focus_dir(Dir::Down),
+        None,
+        "no float below, and no other output"
+    );
+    assert_eq!(l.focus_layer(), Some(tiled));
+    assert_eq!(l.focus_dir(Dir::Right), None);
+    assert_eq!(l.focus_layer(), Some(c));
+}

Modified file: crates/monolith/src/commands.rs+3 additions@@ -80,6 +80,9 @@ impl State {
             Command::Focus { dir: d } => {
                 self.wm.layout.focus_dir(d);
             }
+            Command::FocusLayer => {
+                self.wm.layout.focus_layer();
+            }
             Command::Move { dir: d } if merge => {
                 self.wm.layout.merge_window(d);
             }

monolith

Commit af095d8ce0fc

Commit `af095d8ce0fc`