monolith

public

Star0

Fork 0

Watch0

329 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `406db966344c`

tarball

atagen <boss@atagen.co>2026-10-20 12:08 UTC

3 files changed+52-25

scene: draw a double border around an extended window

An extended window looked like any other tile, giving no hint that moving it carries the windows it covers. A second ring one border width further out marks it as a group.

Modified file: crates/layout/src/lib.rs+8 additions@@ -647,6 +647,14 @@ impl Layout {
         merged
     }
 
+    /// Whether a tiled window is extended over others sharing its container.
+    pub fn grouped(&self, w: WindowId) -> bool {
+        let Some(o) = self.windows.get(w).and_then(|w| w.output) else {
+            return false;
+        };
+        self.outputs[o].tree.grouped(w, self.vis_on(o))
+    }
+
     /// Whether another window is extended over the tiled window `w`, which
     /// leaves it no room and takes it out of reach of focus.
     pub fn eclipsed(&self, w: WindowId) -> bool {

Modified file: crates/monolith/src/scene.rs+42 additions−23 deletions@@ -193,11 +193,24 @@ pub fn build(
                 deco.unfocused.0
             };
             let alpha = effect.map_or(1.0, |e| e.progress) * opacity;
-            let borders = &mut state.borders;
-            let first = out.len();
-            border_elements(&mut out, borders, r, deco, color, alpha, scale);
-            if let Some(clip) = clip {
-                ring_borders(&mut out, first, clip, border_width(deco, scale));
+            let b = border_width(deco, scale);
+            let radius = deco.radius.0.into_iter().max().unwrap_or(0);
+            let radius = (f64::from(radius) * scale).round() as i32;
+            let rings = if layout.grouped(id) { 2 } else { 1 };
+            let Some((at, size)) = pixels(r, scale) else {
+                continue;
+            };
+            let window = Rectangle::new(at.into(), size.into());
+            for (k, borders) in state.borders.iter_mut().take(rings).enumerate() {
+                let by = 2 * b * k as i32;
+                let frame = outset_rect(window, by);
+                let reach = if radius > 0 { radius + by } else { 0 };
+                let reach = reach.min(frame.size.w / 2).min(frame.size.h / 2);
+                let first = out.len();
+                border_elements(&mut out, borders, frame, b, reach, color, alpha);
+                if let Some(clip) = clip {
+                    ring_borders(&mut out, first, outset(clip, by), b);
+                }
             }
         }
     }
@@ -342,24 +355,19 @@ fn window_elements(
     );
 }
 
-/// Four strips just outside `r`, in the gap, so the client keeps its size.
-/// With rounded corners they reach in by the largest radius, to cover the
-/// band the ring curves through inside the window's corners.
+/// Four strips `b` wide just outside `frame`, in the gap, so the client keeps
+/// its size. With rounded corners they `reach` in by the largest radius, to
+/// cover the band the ring curves through inside the frame's corners.
 fn border_elements(
     out: &mut Vec<Draw>,
     borders: &mut Option<[SolidColorBuffer; 4]>,
-    r: Rect,
-    deco: &Decoration,
+    frame: Rectangle<i32, Physical>,
+    b: i32,
+    reach: i32,
     color: [f32; 4],
     alpha: f32,
-    scale: f64,
 ) {
-    let Some(((x, y), (w, h))) = pixels(r, scale) else {
-        return;
-    };
-    let b = border_width(deco, scale);
-    let reach = (f64::from(deco.radius.0.into_iter().max().unwrap_or(0)) * scale).round() as i32;
-    let reach = reach.min(w / 2).min(h / 2);
+    let (x, y, w, h) = (frame.loc.x, frame.loc.y, frame.size.w, frame.size.h);
     let strips = [
         ((x - b, y - b), (w + 2 * b, b + reach)),
         ((x - b, y + h - reach), (w + 2 * b, b + reach)),
@@ -662,20 +670,31 @@ fn clip_window(out: &mut [Draw], first: usize, clip: Clip) {
 /// Turns the border strips from `first` on into a ring around the window's
 /// rounded outline.
 fn ring_borders(out: &mut [Draw], first: usize, window: Clip, b: i32) {
-    let grow = |r: f32| if r > 0.0 { r + b as f32 } else { 0.0 };
     let ring = Clip {
-        rect: Rectangle::new(
-            window.rect.loc - Point::from((b, b)),
-            window.rect.size + Size::from((2 * b, 2 * b)),
-        ),
-        radii: window.radii.map(grow),
         ring: b as f32,
+        ..outset(window, b)
     };
     for draw in &mut out[first..] {
         wrap(draw, ring);
     }
 }
 
+fn outset(clip: Clip, by: i32) -> Clip {
+    let grow = |r: f32| if r > 0.0 { r + by as f32 } else { 0.0 };
+    Clip {
+        rect: outset_rect(clip.rect, by),
+        radii: clip.radii.map(grow),
+        ring: clip.ring,
+    }
+}
+
+fn outset_rect(r: Rectangle<i32, Physical>, by: i32) -> Rectangle<i32, Physical> {
+    Rectangle::new(
+        r.loc - Point::from((by, by)),
+        r.size + Size::from((2 * by, 2 * by)),
+    )
+}
+
 fn wrap(draw: &mut Draw, clip: Clip) {
     let inner = std::mem::replace(draw, Draw::Clipped(ClipElement::empty()));
     *draw = Draw::Clipped(ClipElement::new(inner, clip));

Modified file: crates/monolith/src/wm.rs+2 additions−2 deletions@@ -99,7 +99,7 @@ pub struct WindowState {
     /// A rule sent it somewhere, so activation tokens leave it alone.
     pub placed_by_rule: bool,
     pub list_handle: Option<ForeignToplevelHandle>,
-    pub borders: Option<[SolidColorBuffer; 4]>,
+    pub borders: [Option<[SolidColorBuffer; 4]>; 2],
     pub app_id: String,
     pub title: String,
     /// The title it mapped with, which `initial_title` rules match.
@@ -172,7 +172,7 @@ impl Wm {
                 reclassify: false,
                 placed_by_rule,
                 list_handle: None,
-                borders: None,
+                borders: [None, None],
                 app_id,
                 initial_title: title.clone(),
                 title,

monolith

Commit 406db966344c

Commit `406db966344c`