monolith

public

Star0

Fork 0

Watch0

47 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `bc51c38a6fd9`

tarball

atagen <boss@atagen.co>2026-10-16 22:21 UTC

9 files changed+301-12

monolith: support wlr-layer-shell

Exclusive zones are kept as insets on the layout output rather than by shrinking its area, so fullscreen windows still cover the whole output and a resize does not wipe out what bars reserved. The top layer hides under a fullscreen window and the overlay layer does not, matching what bars and notification daemons expect from sway.

Modified file: crates/layout/src/lib.rs+30 additions−1 deletions@@ -28,6 +28,15 @@ pub enum ExpandScope {
     All,
 }
 
+/// Space taken from an output's edges by bars and other panels.
+#[derive(Clone, Copy, Debug, PartialEq, Default)]
+pub struct Insets {
+    pub top: f64,
+    pub right: f64,
+    pub bottom: f64,
+    pub left: f64,
+}
+
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct Gaps {
     pub inner: f64,
@@ -65,6 +74,7 @@ pub struct Tag {
 pub struct Output {
     pub name: String,
     pub area: Rect,
+    pub reserved: Insets,
     pub tree: Tree<WindowId>,
     /// Viewed tags besides the homeless tag, which is always viewed.
     pub viewed: Vec<TagId>,
@@ -216,6 +226,7 @@ impl Layout {
         let id = self.outputs.insert(Output {
             name: name.into(),
             area,
+            reserved: Insets::default(),
             tree: Tree::default(),
             viewed: Vec::new(),
             floating: Vec::new(),
@@ -331,6 +342,17 @@ impl Layout {
         }
     }
 
+    /// Returns whether anything changed.
+    pub fn set_reserved(&mut self, o: OutputId, reserved: Insets) -> bool {
+        match self.outputs.get_mut(o) {
+            Some(out) if out.reserved != reserved => {
+                out.reserved = reserved;
+                true
+            }
+            _ => false,
+        }
+    }
+
     pub fn is_viewed(&self, o: OutputId, tag: TagId) -> bool {
         tag == self.homeless
             || self
@@ -821,7 +843,14 @@ impl Layout {
         let Some(out) = self.outputs.get(o) else {
             return Arrangement::default();
         };
-        let area = inset(out.area, self.gaps.outer);
+        let r = out.reserved;
+        let usable = Rect::new(
+            out.area.x + r.left,
+            out.area.y + r.top,
+            (out.area.w - r.left - r.right).max(0.0),
+            (out.area.h - r.top - r.bottom).max(0.0),
+        );
+        let area = inset(usable, self.gaps.outer);
         let shown = self.vis_on(o);
         let vis = &|w: WindowId| shown(w) && !hide.contains(&w);
         let tiled = out

Modified file: crates/monolith/src/drm.rs+2 additions@@ -646,6 +646,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
         now,
         &config.decoration,
         borders,
+        Some(&surface.output),
     ));
     let scene_ns = scene_began.elapsed().as_nanos() as u64;
     let animating = anim.active(now);
@@ -694,6 +695,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
             Some(output.clone())
         });
     }
+    crate::layers::send_frames(&output, elapsed);
     animating && !surface.queued
 }
 

Modified file: crates/monolith/src/handlers.rs+1

@@ -94,6 +94,7 @@ impl CompositorHandler for State {

9494 {

9595 let _ = popup.send_configure();

9696 }

97+ self.layer_commit(surface);

9798 self.needs_redraw = true;

9899 }

99100 }

Modified file: crates/monolith/src/input.rs+13 additions@@ -9,6 +9,7 @@ use smithay::backend::session::Session;
 use smithay::input::keyboard::{FilterResult, Keycode, xkb};
 use smithay::input::pointer::{AxisFrame, ButtonEvent, MotionEvent};
 use smithay::utils::{Logical, Point, SERIAL_COUNTER};
+use smithay::wayland::shell::wlr_layer::Layer;
 
 impl State {
     pub fn pointer_to(&mut self, pos: Point<f64, Logical>, time: InputTime) {
@@ -107,6 +108,7 @@ impl State {
         );
         match action {
             Some(Some(Action::Run(cmd))) => {
+                self.layer_focus = None;
                 if let Err(e) = self.run(cmd) {
                     tracing::warn!("bind failed: {e}");
                 }
@@ -130,6 +132,17 @@ enum Action {
 
 fn focus_under_pointer(state: &mut State) {
     let pos = state.pointer_pos;
+    let layers = [Layer::Overlay, Layer::Top, Layer::Bottom, Layer::Background];
+    if let Some((layer, surface, _)) = state.layer_under(pos, &layers)
+        && layer.can_receive_keyboard_focus()
+    {
+        state.layer_focus = Some(surface);
+        state.sync_focus();
+        return;
+    }
+    if state.layer_focus.take().is_some() {
+        state.sync_focus();
+    }
     let id = state
         .space
         .element_under(pos)

Added file: crates/monolith/src/layers.rs+195 additions@@ -0,0 +1,195 @@
+//! wlr-layer-shell, for bars, launchers, wallpapers and notifications.
+
+use crate::scene::Draw;
+use crate::state::State;
+use monolith_layout::{Insets, OutputId};
+use monolith_render_vk::VulkanRenderer;
+use smithay::backend::renderer::element::AsRenderElements;
+use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
+use smithay::desktop::{LayerSurface, PopupKind, WindowSurfaceType, layer_map_for_output};
+use smithay::output::Output;
+use smithay::reexports::wayland_server::Resource;
+use smithay::reexports::wayland_server::protocol::wl_output::WlOutput;
+use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
+use smithay::utils::{Logical, Point, Scale};
+use smithay::wayland::compositor::with_states;
+use smithay::wayland::shell::wlr_layer::{
+    KeyboardInteractivity, Layer, LayerSurface as WlrLayerSurface, LayerSurfaceData,
+    WlrLayerShellHandler, WlrLayerShellState,
+};
+use smithay::wayland::shell::xdg::PopupSurface;
+use std::time::Duration;
+
+impl WlrLayerShellHandler for State {
+    fn shell_state(&mut self) -> &mut WlrLayerShellState {
+        &mut self.layer_shell_state
+    }
+
+    fn new_layer_surface(
+        &mut self,
+        surface: WlrLayerSurface,
+        output: Option<WlOutput>,
+        _layer: Layer,
+        namespace: String,
+    ) {
+        let output = output
+            .as_ref()
+            .and_then(Output::from_resource)
+            .or_else(|| self.space.output_under(self.pointer_pos).next().cloned())
+            .or_else(|| self.space.outputs().next().cloned());
+        let Some(output) = output else {
+            surface.send_close();
+            return;
+        };
+        let mut map = layer_map_for_output(&output);
+        if let Err(e) = map.map_layer(&LayerSurface::new(surface, namespace)) {
+            tracing::warn!("cannot map layer surface: {e}");
+        }
+    }
+
+    fn new_popup(&mut self, _parent: WlrLayerSurface, popup: PopupSurface) {
+        let _ = self.popups.track_popup(PopupKind::Xdg(popup));
+    }
+
+    fn layer_destroyed(&mut self, surface: WlrLayerSurface) {
+        let outputs: Vec<Output> = self.space.outputs().cloned().collect();
+        for output in outputs {
+            let mut map = layer_map_for_output(&output);
+            let gone = map
+                .layers()
+                .find(|l| l.layer_surface() == &surface)
+                .cloned();
+            if let Some(layer) = gone {
+                map.unmap_layer(&layer);
+            }
+        }
+        if self.layer_focus.as_ref() == Some(surface.wl_surface()) {
+            self.layer_focus = None;
+        }
+        self.reserve_layers();
+    }
+}
+
+impl State {
+    /// Sends a layer surface its first configure once it has committed its
+    /// anchors and size, and picks up exclusive zone changes after that.
+    /// Returns false for surfaces that are not layer surfaces.
+    pub fn layer_commit(&mut self, surface: &WlSurface) -> bool {
+        let Some(output) = self
+            .space
+            .outputs()
+            .find(|o| {
+                layer_map_for_output(o)
+                    .layer_for_surface(surface, WindowSurfaceType::TOPLEVEL)
+                    .is_some()
+            })
+            .cloned()
+        else {
+            return false;
+        };
+        let configured = with_states(surface, |s| {
+            s.data_map
+                .get::<LayerSurfaceData>()
+                .and_then(|d| d.lock().ok())
+                .is_some_and(|d| d.initial_configure_sent)
+        });
+        {
+            let mut map = layer_map_for_output(&output);
+            map.arrange();
+            if !configured
+                && let Some(layer) = map.layer_for_surface(surface, WindowSurfaceType::TOPLEVEL)
+            {
+                layer.layer_surface().send_configure();
+            }
+        }
+        self.reserve_layers();
+        true
+    }
+
+    /// Keeps tiled windows out of the space bars reserve.
+    pub fn reserve_layers(&mut self) {
+        let outputs: Vec<OutputId> = self.layout.outputs().map(|(o, _)| o).collect();
+        let mut changed = false;
+        for o in outputs {
+            let Some(output) = self.smithay_output(o) else {
+                continue;
+            };
+            let Some(area) = self.layout.output(o).map(|out| out.area) else {
+                continue;
+            };
+            let mut map = layer_map_for_output(&output);
+            map.arrange();
+            let zone = map.non_exclusive_zone();
+            let reserved = Insets {
+                top: f64::from(zone.loc.y),
+                left: f64::from(zone.loc.x),
+                bottom: (area.h - f64::from(zone.loc.y + zone.size.h)).max(0.0),
+                right: (area.w - f64::from(zone.loc.x + zone.size.w)).max(0.0),
+            };
+            drop(map);
+            changed |= self.layout.set_reserved(o, reserved);
+        }
+        if changed {
+            self.apply_layout();
+        } else {
+            self.sync_focus();
+        }
+    }
+
+    /// The layer surface that should hold the keyboard, if any. One asking
+    /// for exclusive focus above the windows wins over everything.
+    pub fn layer_keyboard_focus(&self) -> Option<WlSurface> {
+        for output in self.space.outputs() {
+            let map = layer_map_for_output(output);
+            let exclusive = map
+                .layers_on(Layer::Overlay)
+                .chain(map.layers_on(Layer::Top))
+                .find(|l| {
+                    l.cached_state().keyboard_interactivity == KeyboardInteractivity::Exclusive
+                });
+            if let Some(l) = exclusive {
+                return Some(l.wl_surface().clone());
+            }
+        }
+        self.layer_focus.clone().filter(|s| s.is_alive())
+    }
+
+    /// The layer surface under `pos` on `layers`, with its surface origin.
+    pub fn layer_under(
+        &self,
+        pos: Point<f64, Logical>,
+        layers: &[Layer],
+    ) -> Option<(LayerSurface, WlSurface, Point<f64, Logical>)> {
+        let output = self.space.output_under(pos).next()?;
+        let origin = self.space.output_geometry(output)?.loc;
+        let local = pos - origin.to_f64();
+        let map = layer_map_for_output(output);
+        layers.iter().find_map(|&layer| {
+            let l = map.layer_under(layer, local)?;
+            let geo = map.layer_geometry(l)?;
+            let (s, p) = l.surface_under(local - geo.loc.to_f64(), WindowSurfaceType::ALL)?;
+            Some((l.clone(), s, (p + geo.loc + origin).to_f64()))
+        })
+    }
+}
+
+/// Draws an output's layer surfaces on `layer`, front to back.
+pub fn elements(out: &mut Vec<Draw>, renderer: &mut VulkanRenderer, output: &Output, layer: Layer) {
+    let map = layer_map_for_output(output);
+    for l in map.layers_on(layer).rev() {
+        let Some(geo) = map.layer_geometry(l) else {
+            continue;
+        };
+        let elems: Vec<WaylandSurfaceRenderElement<VulkanRenderer>> =
+            l.render_elements(renderer, geo.loc.to_physical(1), Scale::from(1.0), 1.0);
+        out.extend(elems.into_iter().map(Draw::Surface));
+    }
+}
+
+pub fn send_frames(output: &Output, elapsed: Duration) {
+    for l in layer_map_for_output(output).layers() {
+        l.send_frame(output, elapsed, Some(Duration::ZERO), |_, _| {
+            Some(output.clone())
+        });
+    }
+}

Modified file: crates/monolith/src/main.rs+1

@@ -6,6 +6,7 @@ mod handlers;

66 mod input;

77 mod ipc;

88 mod launch;

9+mod layers;

910 mod nested;

1011 mod scene;

1112 mod state;

Modified file: crates/monolith/src/nested/mod.rs+2 additions@@ -232,6 +232,7 @@ pub fn render(state: &mut State) {
             now,
             &config.decoration,
             borders,
+            Some(&host.output),
         );
         match host
             .damage
@@ -257,6 +258,7 @@ pub fn render(state: &mut State) {
             Some(host.output.clone())
         });
     }
+    crate::layers::send_frames(&host.output, elapsed);
     let Some(damage) = damage else {
         if *needs_redraw {
             host.surface.frame(&host.qh, ());

Modified file: crates/monolith/src/scene.rs+13 additions@@ -15,8 +15,10 @@ use smithay::backend::renderer::utils::CommitCounter;
 use smithay::backend::renderer::utils::with_renderer_surface_state;
 use smithay::backend::renderer::{ContextId, Renderer, Texture};
 use smithay::desktop::Window;
+use smithay::output::Output;
 use smithay::utils::user_data::UserDataMap;
 use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform};
+use smithay::wayland::shell::wlr_layer::Layer;
 use std::collections::HashMap;
 
 smithay::backend::renderer::element::render_elements! {
@@ -47,6 +49,7 @@ pub fn build(
     now: u64,
     deco: &Decoration,
     borders: &mut Borders,
+    output: Option<&Output>,
 ) -> Vec<Draw> {
     let Some(area) = layout.output(o).map(|out| out.area) else {
         return Vec::new();
@@ -87,6 +90,12 @@ pub fn build(
     borders.0.retain(|id, _| windows.contains_key(id));
     let focused = layout.focused();
     let mut out = Vec::new();
+    if let Some(output) = output {
+        crate::layers::elements(&mut out, renderer, output, Layer::Overlay);
+        if !fullscreen_at_rest {
+            crate::layers::elements(&mut out, renderer, output, Layer::Top);
+        }
+    }
     for (id, r, framed, gliding) in tiled.into_iter().chain(above).rev() {
         let Some(window) = windows.get(&id) else {
             continue;
@@ -121,6 +130,10 @@ pub fn build(
             anim.ghost_effect(g, now),
         )));
     }
+    if let Some(output) = output {
+        crate::layers::elements(&mut out, renderer, output, Layer::Bottom);
+        crate::layers::elements(&mut out, renderer, output, Layer::Background);
+    }
     out
 }
 

Modified file: crates/monolith/src/state.rs+44 additions−11 deletions@@ -26,6 +26,7 @@ use smithay::wayland::compositor::{CompositorClientState, CompositorState, with_
 use smithay::wayland::dmabuf::{DmabufGlobal, DmabufState};
 use smithay::wayland::output::OutputManagerState;
 use smithay::wayland::selection::data_device::DataDeviceState;
+use smithay::wayland::shell::wlr_layer::{Layer, WlrLayerShellState};
 use smithay::wayland::shell::xdg::decoration::XdgDecorationState;
 use smithay::wayland::shell::xdg::{XdgShellState, XdgToplevelSurfaceData};
 use smithay::wayland::shm::ShmState;
@@ -76,10 +77,13 @@ pub struct State {
     /// switches between tiled, floating and fullscreen.
     pub last_kind: HashMap<WindowId, (Kind, Rect, OutputId)>,
     pub awaiting: HashSet<WindowId>,
+    /// A layer surface given the keyboard by a click, like a launcher.
+    pub layer_focus: Option<WlSurface>,
     pub handle: LoopHandle<'static, State>,
 
     pub compositor_state: CompositorState,
     pub xdg_shell_state: XdgShellState,
+    pub layer_shell_state: WlrLayerShellState,
     pub _xdg_decoration_state: XdgDecorationState,
     pub shm_state: ShmState,
     pub dmabuf_state: DmabufState,
@@ -171,9 +175,11 @@ impl State {
             borders: Default::default(),
             last_kind: HashMap::new(),
             awaiting: HashSet::new(),
+            layer_focus: None,
             handle: event_loop.handle(),
             compositor_state: CompositorState::new::<State>(&dh),
             xdg_shell_state: XdgShellState::new::<State>(&dh),
+            layer_shell_state: WlrLayerShellState::new::<State>(&dh),
             _xdg_decoration_state: XdgDecorationState::new::<State>(&dh),
             shm_state: ShmState::new::<State>(&dh, vec![]),
             dmabuf_state,
@@ -201,6 +207,15 @@ impl State {
         if let Some(o) = self.output_id {
             let area = Rect::new(0.0, 0.0, f64::from(size.w), f64::from(size.h));
             self.layout.set_output_area(o, area);
+            if let Some(host) = &self.host {
+                let mode = smithay::output::Mode {
+                    size: (size.w, size.h).into(),
+                    refresh: 60_000,
+                };
+                host.output
+                    .change_current_state(Some(mode), None, None, None);
+            }
+            self.reserve_layers();
             self.apply_layout();
         }
     }
@@ -455,7 +470,7 @@ impl State {
         self.needs_redraw = true;
     }
 
-    fn sync_focus(&mut self) {
+    pub fn sync_focus(&mut self) {
         let focused = self.layout.focused();
         for (id, window) in &self.windows {
             if window.set_activated(Some(*id) == focused)
@@ -465,10 +480,12 @@ impl State {
                 t.send_pending_configure();
             }
         }
-        let target = focused
-            .and_then(|id| self.windows.get(&id))
-            .and_then(|w| w.toplevel())
-            .map(|t| t.wl_surface().clone());
+        let target = self.layer_keyboard_focus().or_else(|| {
+            focused
+                .and_then(|id| self.windows.get(&id))
+                .and_then(|w| w.toplevel())
+                .map(|t| t.wl_surface().clone())
+        });
         if let Some(keyboard) = self.seat.get_keyboard()
             && keyboard.current_focus() != target
         {
@@ -526,13 +543,29 @@ impl State {
         &self,
         pos: Point<f64, Logical>,
     ) -> Option<(WlSurface, Point<f64, Logical>)> {
-        self.space
-            .element_under(pos)
-            .and_then(|(window, location)| {
-                window
-                    .surface_under(pos - location.to_f64(), WindowSurfaceType::ALL)
-                    .map(|(s, p)| (s, (p + location).to_f64()))
+        let fullscreen = self.layout.outputs().any(|(o, out)| {
+            let a = out.area;
+            (a.x..a.right()).contains(&pos.x)
+                && (a.y..a.bottom()).contains(&pos.y)
+                && self.layout.arrange(o).fullscreen.is_some()
+        });
+        let above: &[Layer] = if fullscreen {
+            &[Layer::Overlay]
+        } else {
+            &[Layer::Overlay, Layer::Top]
+        };
+        let layer = |layers| self.layer_under(pos, layers).map(|(_, s, p)| (s, p));
+        layer(above)
+            .or_else(|| {
+                self.space
+                    .element_under(pos)
+                    .and_then(|(window, location)| {
+                        window
+                            .surface_under(pos - location.to_f64(), WindowSurfaceType::ALL)
+                            .map(|(s, p)| (s, (p + location).to_f64()))
+                    })
             })
+            .or_else(|| layer(&[Layer::Bottom, Layer::Background]))
     }
 }

monolith

Commit bc51c38a6fd9

Commit `bc51c38a6fd9`