monolith

public

Star0

Fork 0

Watch0

48 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `e9ef7cdfe55a`

tarball

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

8 files changed+329-32

monolith: support session lock, idle notify and idle inhibit

The locker is told it holds the session only after every output has drawn a frame without the windows, so no private content stays on screen after swaylock reports success. A locker that dies leaves the session locked, which is what the protocol requires. Idle inhibitors count only while their surface is shown, so a video left on a hidden tag does not keep the screen awake.

Modified file: crates/monolith/src/drm.rs+24 additions−13 deletions@@ -589,6 +589,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
         cursor,
         cursor_status,
         pointer_pos,
+        lock,
         ..
     } = state
     else {
@@ -637,17 +638,20 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
         elements.extend(cursor.elements(renderer, cursor_status, local));
     }
     let scene_began = std::time::Instant::now();
-    elements.extend(crate::scene::build(
-        layout,
-        surface.id,
-        windows,
-        anim,
-        renderer,
-        now,
-        &config.decoration,
-        borders,
-        Some(&surface.output),
-    ));
+    match crate::lock::elements(lock, renderer, &surface.output) {
+        Some(locked) => elements.extend(locked),
+        None => elements.extend(crate::scene::build(
+            layout,
+            surface.id,
+            windows,
+            anim,
+            renderer,
+            now,
+            &config.decoration,
+            borders,
+            Some(&surface.output),
+        )),
+    }
     let scene_ns = scene_began.elapsed().as_nanos() as u64;
     let animating = anim.active(now);
     anim.prune(now);
@@ -661,12 +665,15 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
         Ok(result) if !result.is_empty => {
             let queue_began = std::time::Instant::now();
             match surface.drm.queue_frame(()) {
-                Ok(()) => surface.queued = true,
+                Ok(()) => {
+                    surface.queued = true;
+                    lock.shown(&surface.output);
+                }
                 Err(e) => tracing::warn!("queueing a frame failed: {e}"),
             }
             queue_ns = queue_began.elapsed().as_nanos() as u64;
         }
-        Ok(_) => {}
+        Ok(_) => lock.shown(&surface.output),
         Err(e) => tracing::warn!("rendering failed: {e}"),
     }
     let render_cpu_ns = thread_cpu_ns() - cpu_began;
@@ -690,6 +697,10 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
     surface.redraw = animating;
     let elapsed = start.elapsed();
     let output = surface.output.clone();
+    if lock.active() {
+        crate::lock::send_frames(lock, &output, elapsed);
+        return animating && !surface.queued;
+    }
     for window in space.elements_for_output(&output) {
         window.send_frame(&output, elapsed, Some(Duration::ZERO), |_, _| {
             Some(output.clone())

Added file: crates/monolith/src/idle.rs+54 additions@@ -0,0 +1,54 @@
+//! ext-idle-notify and idle-inhibit, so lockers and screen blankers know
+//! when the user went away and video players can keep the screen on.
+
+use crate::state::State;
+use smithay::reexports::wayland_server::Resource;
+use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
+use smithay::wayland::compositor::get_parent;
+use smithay::wayland::idle_inhibit::IdleInhibitHandler;
+use smithay::wayland::idle_notify::{IdleNotifierHandler, IdleNotifierState};
+
+impl IdleNotifierHandler for State {
+    fn idle_notifier_state(&mut self) -> &mut IdleNotifierState<Self> {
+        &mut self.idle_notifier
+    }
+}
+
+impl IdleInhibitHandler for State {
+    fn inhibit(&mut self, surface: WlSurface) {
+        self.inhibitors.insert(surface);
+        self.update_inhibit();
+    }
+
+    fn uninhibit(&mut self, surface: WlSurface) {
+        self.inhibitors.remove(&surface);
+        self.update_inhibit();
+    }
+}
+
+impl State {
+    pub fn activity(&mut self) {
+        let seat = self.seat.clone();
+        self.idle_notifier.notify_activity(&seat);
+    }
+
+    /// An inhibitor only counts while its surface is on screen, as the
+    /// protocol asks, so a video on a hidden tag lets the screen blank.
+    pub fn update_inhibit(&mut self) {
+        self.inhibitors.retain(|s| s.is_alive());
+        let shown = self.inhibitors.iter().any(|s| {
+            let mut root = s.clone();
+            while let Some(parent) = get_parent(&root) {
+                root = parent;
+            }
+            self.space
+                .elements()
+                .any(|w| w.toplevel().is_some_and(|t| t.wl_surface() == &root))
+                || self.layer_maps_contain(&root)
+        });
+        if shown != self.inhibited {
+            self.inhibited = shown;
+            self.idle_notifier.set_is_inhibited(shown);
+        }
+    }
+}

Modified file: crates/monolith/src/input.rs+8 additions−1 deletions@@ -14,6 +14,7 @@ use smithay::wayland::shell::wlr_layer::Layer;
 impl State {
     pub fn pointer_to(&mut self, pos: Point<f64, Logical>, time: InputTime) {
         self.pointer_pos = pos;
+        self.activity();
         if drag_to(self, pos) {
             return;
         }
@@ -33,10 +34,11 @@ impl State {
     }
 
     pub fn pointer_button(&mut self, button: u32, pressed: ButtonState, time: InputTime) {
+        self.activity();
         if pressed == ButtonState::Released && self.drag.take().is_some() {
             return;
         }
-        if pressed == ButtonState::Pressed {
+        if pressed == ButtonState::Pressed && !self.lock.active() {
             focus_under_pointer(self);
             if start_drag(self, button) {
                 return;
@@ -57,6 +59,7 @@ impl State {
     }
 
     pub fn pointer_axis(&mut self, frame: AxisFrame) {
+        self.activity();
         if let Some(pointer) = self.seat.get_pointer() {
             pointer.axis(self, frame);
         }
@@ -69,6 +72,7 @@ impl State {
     }
 
     pub fn key(&mut self, code: Keycode, pressed: KeyState, time: InputTime) {
+        self.activity();
         let Some(keyboard) = self.seat.get_keyboard() else {
             return;
         };
@@ -96,6 +100,9 @@ impl State {
                     let vt = (sym - xkb::keysyms::KEY_XF86Switch_VT_1 + 1) as i32;
                     return FilterResult::Intercept(Some(Action::Vt(vt)));
                 }
+                if state.lock.active() {
+                    return FilterResult::Forward;
+                }
                 match state.binds.find(mods, &handle.raw_syms()) {
                     Some(cmd) => {
                         tracing::debug!(?cmd, "bind");

Modified file: crates/monolith/src/layers.rs+8 additions@@ -154,6 +154,14 @@ impl State {
         self.layer_focus.clone().filter(|s| s.is_alive())
     }
 
+    pub fn layer_maps_contain(&self, surface: &WlSurface) -> bool {
+        self.space.outputs().any(|o| {
+            layer_map_for_output(o)
+                .layer_for_surface(surface, WindowSurfaceType::TOPLEVEL)
+                .is_some()
+        })
+    }
+
     /// The layer surface under `pos` on `layers`, with its surface origin.
     pub fn layer_under(
         &self,

Added file: crates/monolith/src/lock.rs+185 additions@@ -0,0 +1,185 @@
+//! ext-session-lock. While locked only the locker's surfaces are drawn and
+//! receive input, and no binds run.
+
+use crate::scene::Draw;
+use crate::state::State;
+use monolith_render_vk::VulkanRenderer;
+use smithay::backend::renderer::element::Kind;
+use smithay::backend::renderer::element::surface::render_elements_from_surface_tree;
+use smithay::desktop::WindowSurfaceType;
+use smithay::desktop::utils::{send_frames_surface_tree, under_from_surface_tree};
+use smithay::output::Output;
+use smithay::reexports::wayland_server::protocol::wl_output::WlOutput;
+use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
+use smithay::utils::{Logical, Point};
+use smithay::wayland::session_lock::{
+    LockSurface, SessionLockHandler, SessionLockManagerState, SessionLocker,
+};
+use std::collections::HashSet;
+use std::time::Duration;
+
+#[derive(Default)]
+pub struct Lock {
+    pending: Option<SessionLocker>,
+    locked: bool,
+    /// Outputs that have shown a locked frame since the lock was requested.
+    blanked: HashSet<String>,
+    surfaces: Vec<(Output, LockSurface)>,
+}
+
+impl Lock {
+    pub fn active(&self) -> bool {
+        self.locked || self.pending.is_some()
+    }
+
+    fn surface_on(&self, output: &Output) -> Option<&LockSurface> {
+        self.surfaces
+            .iter()
+            .find(|(o, s)| o == output && s.alive())
+            .map(|(_, s)| s)
+    }
+
+    /// Records a frame shown on `output`, which counts towards confirming a
+    /// pending lock.
+    pub fn shown(&mut self, output: &Output) {
+        if self.pending.is_some() {
+            self.blanked.insert(output.name());
+        }
+    }
+}
+
+impl SessionLockHandler for State {
+    fn lock_state(&mut self) -> &mut SessionLockManagerState {
+        &mut self.session_lock_state
+    }
+
+    fn lock(&mut self, confirmation: SessionLocker) {
+        tracing::info!("session lock requested");
+        self.lock.pending = Some(confirmation);
+        self.lock.blanked.clear();
+        self.drag = None;
+        self.sync_focus();
+        self.needs_redraw = true;
+    }
+
+    fn unlock(&mut self) {
+        tracing::info!("session unlocked");
+        self.lock = Lock::default();
+        self.sync_focus();
+        self.needs_redraw = true;
+    }
+
+    fn new_surface(&mut self, surface: LockSurface, output: WlOutput) {
+        let Some(output) = Output::from_resource(&output) else {
+            return;
+        };
+        configure(&surface, &output);
+        self.lock
+            .surfaces
+            .retain(|(o, s)| o != &output && s.alive());
+        self.lock.surfaces.push((output, surface));
+        self.sync_focus();
+        self.needs_redraw = true;
+    }
+}
+
+fn configure(surface: &LockSurface, output: &Output) {
+    let Some(mode) = output.current_mode() else {
+        return;
+    };
+    let size = (mode.size.w as u32, mode.size.h as u32);
+    surface.with_pending_state(|s| s.size = Some(size.into()));
+    surface.send_configure();
+}
+
+impl State {
+    /// Confirms a pending lock once every output has drawn without the
+    /// windows, so nothing private is left on screen when the locker is told
+    /// it holds the session.
+    pub fn confirm_lock(&mut self) {
+        if self.lock.pending.is_none() {
+            return;
+        }
+        let all = self
+            .space
+            .outputs()
+            .all(|o| self.lock.blanked.contains(&o.name()));
+        if all && let Some(locker) = self.lock.pending.take() {
+            locker.lock();
+            self.lock.locked = true;
+            tracing::info!("session locked");
+        }
+    }
+
+    /// Resends sizes after an output changed mode.
+    pub fn reconfigure_lock(&self) {
+        for (output, surface) in &self.lock.surfaces {
+            configure(surface, output);
+        }
+    }
+
+    pub fn lock_keyboard_focus(&self) -> Option<WlSurface> {
+        let under = self.space.output_under(self.pointer_pos).next();
+        under
+            .and_then(|o| self.lock.surface_on(o))
+            .or_else(|| {
+                self.lock
+                    .surfaces
+                    .iter()
+                    .map(|(_, s)| s)
+                    .find(|s| s.alive())
+            })
+            .map(|s| s.wl_surface().clone())
+    }
+
+    pub fn lock_surface_under(
+        &self,
+        pos: Point<f64, Logical>,
+    ) -> Option<(WlSurface, Point<f64, Logical>)> {
+        let output = self.space.output_under(pos).next()?;
+        let origin = self.space.output_geometry(output)?.loc;
+        let surface = self.lock.surface_on(output)?;
+        under_from_surface_tree(
+            surface.wl_surface(),
+            pos - origin.to_f64(),
+            (0, 0),
+            WindowSurfaceType::ALL,
+        )
+        .map(|(s, p)| (s, (p + origin).to_f64()))
+    }
+}
+
+/// What a locked output draws, or None when the session is not locked.
+pub fn elements(lock: &Lock, renderer: &mut VulkanRenderer, output: &Output) -> Option<Vec<Draw>> {
+    if !lock.active() {
+        return None;
+    }
+    let Some(surface) = lock.surface_on(output) else {
+        return Some(Vec::new());
+    };
+    Some(
+        render_elements_from_surface_tree(
+            renderer,
+            surface.wl_surface(),
+            (0, 0),
+            1.0,
+            1.0,
+            Kind::Unspecified,
+        )
+        .into_iter()
+        .map(Draw::Surface)
+        .collect(),
+    )
+}
+
+pub fn send_frames(lock: &Lock, output: &Output, elapsed: Duration) {
+    if let Some(surface) = lock.surface_on(output) {
+        send_frames_surface_tree(
+            surface.wl_surface(),
+            output,
+            elapsed,
+            Some(Duration::ZERO),
+            |_, _| Some(output.clone()),
+        );
+    }
+}

Modified file: crates/monolith/src/main.rs+2 additions@@ -3,10 +3,12 @@ mod commands;
 mod cursor;
 mod drm;
 mod handlers;
+mod idle;
 mod input;
 mod ipc;
 mod launch;
 mod layers;
+mod lock;
 mod nested;
 mod scene;
 mod state;

Modified file: crates/monolith/src/nested/mod.rs+17 additions−12 deletions@@ -179,6 +179,7 @@ pub fn render(state: &mut State) {
         borders,
         config,
         output_id,
+        lock,
         ..
     } = state;
     let Some(host) = host.as_mut() else { return };
@@ -223,17 +224,19 @@ pub fn render(state: &mut State) {
             }
         };
         let Some(o) = *output_id else { return };
-        let elements = crate::scene::build(
-            layout,
-            o,
-            windows,
-            anim,
-            renderer,
-            now,
-            &config.decoration,
-            borders,
-            Some(&host.output),
-        );
+        let elements = crate::lock::elements(lock, renderer, &host.output).unwrap_or_else(|| {
+            crate::scene::build(
+                layout,
+                o,
+                windows,
+                anim,
+                renderer,
+                now,
+                &config.decoration,
+                borders,
+                Some(&host.output),
+            )
+        });
         match host
             .damage
             .render_output(renderer, &mut fb, slot.age() as usize, &elements, CLEAR)
@@ -252,8 +255,10 @@ pub fn render(state: &mut State) {
     };
     *needs_redraw = anim.active(now);
     anim.prune(now);
+    lock.shown(&host.output);
     let elapsed = start.elapsed();
-    for window in space.elements() {
+    crate::lock::send_frames(lock, &host.output, elapsed);
+    for window in space.elements().filter(|_| !lock.active()) {
         window.send_frame(&host.output, elapsed, Some(Duration::ZERO), |_, _| {
             Some(host.output.clone())
         });

Modified file: crates/monolith/src/state.rs+31 additions−6 deletions@@ -24,8 +24,11 @@ use smithay::reexports::wayland_server::{Display, DisplayHandle, Resource};
 use smithay::utils::{Clock, Logical, Monotonic, Point, SERIAL_COUNTER, Size};
 use smithay::wayland::compositor::{CompositorClientState, CompositorState, with_states};
 use smithay::wayland::dmabuf::{DmabufGlobal, DmabufState};
+use smithay::wayland::idle_inhibit::IdleInhibitManagerState;
+use smithay::wayland::idle_notify::IdleNotifierState;
 use smithay::wayland::output::OutputManagerState;
 use smithay::wayland::selection::data_device::DataDeviceState;
+use smithay::wayland::session_lock::SessionLockManagerState;
 use smithay::wayland::shell::wlr_layer::{Layer, WlrLayerShellState};
 use smithay::wayland::shell::xdg::decoration::XdgDecorationState;
 use smithay::wayland::shell::xdg::{XdgShellState, XdgToplevelSurfaceData};
@@ -79,11 +82,17 @@ pub struct State {
     pub awaiting: HashSet<WindowId>,
     /// A layer surface given the keyboard by a click, like a launcher.
     pub layer_focus: Option<WlSurface>,
+    pub lock: crate::lock::Lock,
+    pub inhibitors: HashSet<WlSurface>,
+    pub inhibited: bool,
     pub handle: LoopHandle<'static, State>,
 
     pub compositor_state: CompositorState,
     pub xdg_shell_state: XdgShellState,
     pub layer_shell_state: WlrLayerShellState,
+    pub session_lock_state: SessionLockManagerState,
+    pub idle_notifier: IdleNotifierState<State>,
+    pub _idle_inhibit: IdleInhibitManagerState,
     pub _xdg_decoration_state: XdgDecorationState,
     pub shm_state: ShmState,
     pub dmabuf_state: DmabufState,
@@ -176,10 +185,16 @@ impl State {
             last_kind: HashMap::new(),
             awaiting: HashSet::new(),
             layer_focus: None,
+            lock: Default::default(),
+            inhibitors: HashSet::new(),
+            inhibited: false,
             handle: event_loop.handle(),
             compositor_state: CompositorState::new::<State>(&dh),
             xdg_shell_state: XdgShellState::new::<State>(&dh),
             layer_shell_state: WlrLayerShellState::new::<State>(&dh),
+            session_lock_state: SessionLockManagerState::new::<State, _>(&dh, |_| true),
+            idle_notifier: IdleNotifierState::new(&dh, event_loop.handle()),
+            _idle_inhibit: IdleInhibitManagerState::new::<State>(&dh),
             _xdg_decoration_state: XdgDecorationState::new::<State>(&dh),
             shm_state: ShmState::new::<State>(&dh, vec![]),
             dmabuf_state,
@@ -198,6 +213,7 @@ impl State {
         self.popups.cleanup();
         crate::nested::render(self);
         crate::drm::render(self);
+        self.confirm_lock();
         crate::ipc::broadcast(self);
         self.publish_workspaces();
         let _ = self.display.flush_clients();
@@ -216,6 +232,7 @@ impl State {
                     .change_current_state(Some(mode), None, None, None);
             }
             self.reserve_layers();
+            self.reconfigure_lock();
             self.apply_layout();
         }
     }
@@ -467,6 +484,7 @@ impl State {
             self.space.raise_element(&self.windows[id], false);
         }
         self.sync_focus();
+        self.update_inhibit();
         self.needs_redraw = true;
     }
 
@@ -480,12 +498,16 @@ impl State {
                 t.send_pending_configure();
             }
         }
-        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())
-        });
+        let target = if self.lock.active() {
+            self.lock_keyboard_focus()
+        } else {
+            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
         {
@@ -543,6 +565,9 @@ impl State {
         &self,
         pos: Point<f64, Logical>,
     ) -> Option<(WlSurface, Point<f64, Logical>)> {
+        if self.lock.active() {
+            return self.lock_surface_under(pos);
+        }
         let fullscreen = self.layout.outputs().any(|(o, out)| {
             let a = out.area;
             (a.x..a.right()).contains(&pos.x)

monolith

Commit e9ef7cdfe55a

Commit `e9ef7cdfe55a`