monolith

public

Star0

Fork 0

Watch0

27 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `7ce6ae4e5a85`

tarball

atagen <boss@atagen.co>2026-10-16 12:17 UTC

5 files changed+129-8

monolith: draw borders around windows

Clients are told decorations are server side, and monolith drew nothing in their place, so the focused window could not be told apart. Borders sit in the gap outside the window so client sizes are unaffected, follow the animated rect, and fade in with a spawning window.

Modified file: crates/config/default.toml+6 additions@@ -13,6 +13,12 @@ gaps = { inner = 8, outer = 8 }
 # merge joins its lane. invert-move does the other one for the next move.
 move = "swap"
 
+[decoration]
+# Borders sit in the gap around each window, so keep them under half the inner gap.
+border = 2
+focused = "#88bfd1"
+unfocused = "#3b4252"
+
 [animation]
 enabled = true
 # orthogonal moves each window along one axis per phase, direct allows both.

Modified file: crates/config/src/lib.rs+45 additions@@ -12,6 +12,7 @@ pub const DEFAULT: &str = include_str!("../default.toml");
 #[derive(Debug, Clone)]
 pub struct Config {
     pub general: General,
+    pub decoration: Decoration,
     pub animation: Animation,
     pub keyboard: Keyboard,
     pub binds: Vec<Bind>,
@@ -69,6 +70,47 @@ impl Default for Gaps {
 
 #[derive(Deserialize, Debug, Clone, PartialEq)]
 #[serde(default, deny_unknown_fields)]
+pub struct Decoration {
+    /// Border width in logical pixels, drawn in the gap around each window.
+    pub border: u32,
+    pub focused: Color,
+    pub unfocused: Color,
+}
+
+impl Default for Decoration {
+    fn default() -> Self {
+        Self {
+            border: 2,
+            focused: Color([0.53, 0.75, 0.82, 1.0]),
+            unfocused: Color([0.23, 0.26, 0.32, 1.0]),
+        }
+    }
+}
+
+/// Straight RGBA from `#rrggbb` or `#rrggbbaa`.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Color(pub [f32; 4]);
+
+impl<'de> Deserialize<'de> for Color {
+    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        let s = String::deserialize(d)?;
+        let hex = s.strip_prefix('#').unwrap_or(&s);
+        let bad =
+            || serde::de::Error::custom(format!("bad colour {s:?}, use #rrggbb or #rrggbbaa"));
+        if !matches!(hex.len(), 6 | 8) || !hex.is_ascii() {
+            return Err(bad());
+        }
+        let mut c = [1.0f32; 4];
+        for (i, v) in c.iter_mut().enumerate().take(hex.len() / 2) {
+            let byte = u8::from_str_radix(&hex[i * 2..i * 2 + 2], 16).map_err(|_| bad())?;
+            *v = f32::from(byte) / 255.0;
+        }
+        Ok(Self(c))
+    }
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[serde(default, deny_unknown_fields)]
 pub struct Animation {
     pub enabled: bool,
     pub style: AnimationStyle,
@@ -212,6 +254,8 @@ struct Raw {
     #[serde(default)]
     animation: Animation,
     #[serde(default)]
+    decoration: Decoration,
+    #[serde(default)]
     binds: BTreeMap<String, Words>,
     #[serde(default)]
     rules: Vec<RawRule>,
@@ -290,6 +334,7 @@ impl Config {
         Ok(Self {
             general: raw.general,
             animation: raw.animation,
+            decoration: raw.decoration,
             keyboard: raw.keyboard,
             binds,
             rules,

Modified file: crates/monolith/src/nested/mod.rs+11 additions−1 deletions@@ -176,6 +176,8 @@ pub fn render(state: &mut State) {
         layout,
         windows,
         anim,
+        borders,
+        config,
         ..
     } = state;
     let Some(host) = host.as_mut() else { return };
@@ -219,7 +221,15 @@ pub fn render(state: &mut State) {
                 return;
             }
         };
-        let elements = crate::scene::build(layout, windows, anim, renderer, now);
+        let elements = crate::scene::build(
+            layout,
+            windows,
+            anim,
+            renderer,
+            now,
+            &config.decoration,
+            borders,
+        );
         match host
             .damage
             .render_output(renderer, &mut fb, slot.age() as usize, &elements, CLEAR)

Modified file: crates/monolith/src/scene.rs+65 additions−7 deletions@@ -2,8 +2,10 @@
 //! scene draws windows where the animator says they are right now.
 
 use crate::anim::Animator;
+use monolith_config::Decoration;
 use monolith_layout::{Layout, Rect, WindowId};
 use monolith_render_vk::{Effect, VulkanFrame, VulkanRenderer, VulkanTexture};
+use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
 use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
 use smithay::backend::renderer::element::texture::TextureRenderElement;
 use smithay::backend::renderer::element::utils::CropRenderElement;
@@ -22,8 +24,14 @@ smithay::backend::renderer::element::render_elements! {
     Cropped=CropRenderElement<WaylandSurfaceRenderElement<VulkanRenderer>>,
     Texture=TextureRenderElement<VulkanTexture>,
     Effect=EffectElement,
+    Border=SolidColorRenderElement,
 }
 
+/// Border strips per window, kept between frames so unchanged borders cause
+/// no damage.
+#[derive(Default)]
+pub struct Borders(HashMap<WindowId, [SolidColorBuffer; 4]>);
+
 /// Elements for every output, front to back.
 pub fn build(
     layout: &Layout,
@@ -31,6 +39,8 @@ pub fn build(
     anim: &Animator,
     renderer: &mut VulkanRenderer,
     now: u64,
+    deco: &Decoration,
+    borders: &mut Borders,
 ) -> Vec<Draw> {
     let mut ghosts = Vec::new();
     let mut tiled = Vec::new();
@@ -50,24 +60,37 @@ pub fn build(
                 continue;
             }
             match anim.gliding(p.window, now) {
-                Some(r) => above.push((p.window, r)),
+                Some(r) => above.push((p.window, r, true)),
                 None => {
                     let r = anim.tiled(o, p.window, now).unwrap_or(p.rect);
-                    tiled.push((p.window, r));
+                    tiled.push((p.window, r, true));
                 }
             }
         }
         for &(w, r) in &arr.floating {
-            above.push((w, anim.gliding(w, now).unwrap_or(r)));
+            above.push((w, anim.gliding(w, now).unwrap_or(r), true));
         }
         if let Some(w) = arr.fullscreen {
-            above.push((w, anim.gliding(w, now).unwrap_or(out.area)));
+            above.push((w, anim.gliding(w, now).unwrap_or(out.area), false));
         }
     }
+    borders.0.retain(|id, _| windows.contains_key(id));
+    let focused = layout.focused();
     let mut out = Vec::new();
-    for (id, r) in tiled.into_iter().chain(above).rev() {
-        if let Some(window) = windows.get(&id) {
-            window_elements(&mut out, renderer, window, r, anim.effect(id, now));
+    for (id, r, framed) in tiled.into_iter().chain(above).rev() {
+        let Some(window) = windows.get(&id) else {
+            continue;
+        };
+        let effect = anim.effect(id, now);
+        window_elements(&mut out, renderer, window, r, effect);
+        if framed && deco.border > 0 {
+            let color = if focused == Some(id) {
+                deco.focused.0
+            } else {
+                deco.unfocused.0
+            };
+            let alpha = effect.map_or(1.0, |e| e.progress);
+            border_elements(&mut out, borders, id, r, deco.border as i32, color, alpha);
         }
     }
     for (g, r) in ghosts.into_iter().rev() {
@@ -163,6 +186,41 @@ fn window_elements(
     );
 }
 
+/// Four strips just outside `r`, in the gap, so the client keeps its size.
+fn border_elements(
+    out: &mut Vec<Draw>,
+    borders: &mut Borders,
+    id: WindowId,
+    r: Rect,
+    b: i32,
+    color: [f32; 4],
+    alpha: f32,
+) {
+    let Some(((x, y), (w, h))) = pixels(r) else {
+        return;
+    };
+    let strips = [
+        ((x - b, y - b), (w + 2 * b, b)),
+        ((x - b, y + h), (w + 2 * b, b)),
+        ((x - b, y), (b, h)),
+        ((x + w, y), (b, h)),
+    ];
+    let buffers = borders
+        .0
+        .entry(id)
+        .or_insert_with(|| std::array::from_fn(|_| SolidColorBuffer::new((0, 0), color)));
+    for (buffer, (at, size)) in buffers.iter_mut().zip(strips) {
+        buffer.update(size, color);
+        out.push(Draw::Border(SolidColorRenderElement::from_buffer(
+            buffer,
+            at,
+            1.0,
+            alpha,
+            Kind::Unspecified,
+        )));
+    }
+}
+
 /// Snaps a logical rect to whole pixels by rounding its edges, so neighbours
 /// that share an edge stay flush.
 fn pixels(r: Rect) -> Option<((i32, i32), (i32, i32))> {

Modified file: crates/monolith/src/state.rs+2 additions@@ -62,6 +62,7 @@ pub struct State {
     pub launches: crate::launch::Launches,
     pub workspaces: WorkspaceState,
     pub anim: Animator,
+    pub borders: crate::scene::Borders,
     /// How each shown window was placed by the last layout pass, to spot
     /// switches between tiled, floating and fullscreen.
     pub last_kind: HashMap<WindowId, (Kind, Rect, OutputId)>,
@@ -147,6 +148,7 @@ impl State {
             launches: Default::default(),
             workspaces: WorkspaceState::new::<State>(&dh),
             anim: Animator::new(animation),
+            borders: Default::default(),
             last_kind: HashMap::new(),
             compositor_state: CompositorState::new::<State>(&dh),
             xdg_shell_state: XdgShellState::new::<State>(&dh),

monolith

Commit 7ce6ae4e5a85

Commit `7ce6ae4e5a85`