monolith

public

Star0

Fork 0

Watch0

163 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `47b86d08d05a`

tarball

atagen <boss@atagen.co>2026-10-19 07:51 UTC

9 files changed+196-12

power: blank every output after an idle timeout

ext-idle-notify only tells clients the user left, so nothing in monolith itself turned the panels off without swayidle. `[idle] blank_after` now sets DPMS off through `DrmCompositor::clear`, which keeps the surface so the next queued frame re-enables it without a reconnect. Input wakes the outputs and idle inhibitors hold the blank off.

Modified file: crates/config/default.toml+6 additions@@ -49,6 +49,12 @@ style = "orthogonal"
 phase_ms = 160
 curve = [0.45, 0.0, 0.2, 1.0]
 
+[idle]
+# Seconds without input before every output is switched off, any input
+# switches them back on. 0 never blanks. Windows holding an idle inhibitor
+# keep the screen on while they are shown.
+blank_after = 0
+
 [keyboard]
 layout = ""
 repeat_delay = 200

Modified file: crates/config/src/lib.rs+12 additions@@ -17,6 +17,7 @@ pub struct Config {
     pub animation: Animation,
     pub keyboard: Keyboard,
     pub input: Input,
+    pub idle: Idle,
     pub binds: Vec<Bind>,
     pub rules: Vec<Rule>,
     pub startup: Vec<Vec<String>>,
@@ -235,6 +236,14 @@ pub enum AnimationStyle {
     Direct,
 }
 
+#[derive(Deserialize, Debug, Clone, PartialEq, Default)]
+#[serde(default, deny_unknown_fields)]
+pub struct Idle {
+    /// Seconds without input before every output is switched off, 0 for
+    /// never.
+    pub blank_after: u64,
+}
+
 #[derive(Deserialize, Debug, Clone, PartialEq)]
 #[serde(default, deny_unknown_fields)]
 pub struct Keyboard {
@@ -512,6 +521,7 @@ impl Config {
         let general: General = section("general", table.remove("general"), w);
         let keyboard = section("keyboard", table.remove("keyboard"), w);
         let input = input(table.remove("input"), w);
+        let idle = section("idle", table.remove("idle"), w);
         let animation = section("animation", table.remove("animation"), w);
         let decoration = section("decoration", table.remove("decoration"), w);
         let output: Outputs = section("output", table.remove("output"), w);
@@ -571,6 +581,7 @@ impl Config {
             output,
             keyboard,
             input,
+            idle,
             binds,
             rules,
             startup,
@@ -759,6 +770,7 @@ mod tests {
         assert_eq!(c.animation, Animation::default());
         assert_eq!(c.keyboard, Keyboard::default());
         assert_eq!(c.input, Input::default());
+        assert_eq!(c.idle, Idle::default());
         assert!(c.binds.len() > 40);
     }
 

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

@@ -229,6 +229,7 @@ impl State {

229229 drm.devices.reconfigure(&self.settings.config.input);

230230 }

231231 crate::drm::reconfigure_outputs(self);

232+ self.configure_idle();

232233 tracing::info!("config reloaded");

233234 Ok(())

234235 }

Modified file: crates/monolith/src/drm.rs+45 additions−2 deletions@@ -83,6 +83,8 @@ struct Surface {
     /// A frame is on its way to the screen and its vblank has not landed.
     queued: bool,
     queued_at: u64,
+    /// The panel is lit. Off outputs are not rendered to.
+    powered: bool,
     /// Fires when a queued frame's vblank never arrives.
     watchdog: Option<RegistrationToken>,
     /// Consecutive frames that failed to render or queue.
@@ -221,6 +223,11 @@ pub fn init(
                     s.target_ns = None;
                     s.failures = 0;
                     s.redraw = true;
+                    if !s.powered
+                        && let Err(e) = s.drm.with_compositor(|c| c.clear())
+                    {
+                        tracing::warn!("could not keep the output off: {e}");
+                    }
                 }
             }
             scan(state);
@@ -310,6 +317,7 @@ fn scan(state: &mut State) {
     for handle in retry {
         retry_connector(state, handle);
     }
+    state.apply_power();
     state.apply_layout();
 }
 
@@ -471,6 +479,7 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
             drm: out,
             queued: false,
             queued_at: 0,
+            powered: true,
             watchdog: None,
             failures: 0,
             redraw: true,
@@ -622,9 +631,43 @@ fn disconnect(state: &mut State, crtc: crtc::Handle) {
     state.wm.layout.remove_output(surface.id);
     state.close_layers(&surface.output);
     state.services.lock.forget(&surface.output);
+    state.services.power.forget(&surface.output.name());
 }
 
 impl Drm {
+    /// Lights or darkens the output called `name`. Dark outputs get DPMS off
+    /// and no frames, and the next frame after turning on is a full modeset.
+    pub fn set_powered(&mut self, name: &str, on: bool) {
+        let active = self.session.is_active();
+        for s in self
+            .surfaces
+            .values_mut()
+            .filter(|s| s.output.name() == name)
+        {
+            if s.powered == on {
+                continue;
+            }
+            s.powered = on;
+            tracing::info!(name, on, "output power");
+            if on {
+                s.redraw = true;
+                continue;
+            }
+            for token in [s.scheduled.take(), s.watchdog.take()]
+                .into_iter()
+                .flatten()
+            {
+                self.handle.remove(token);
+            }
+            s.queued = false;
+            s.target_ns = None;
+            s.cursor_redraw = false;
+            if active && let Err(e) = s.drm.with_compositor(|c| c.clear()) {
+                tracing::warn!(name, "could not switch the output off: {e}");
+            }
+        }
+    }
+
     pub fn output(&self, id: OutputId) -> Option<Output> {
         self.surfaces
             .values()
@@ -713,7 +756,7 @@ fn schedule(state: &mut State, crtc: crtc::Handle) {
     let Some(surface) = drm.surfaces.get_mut(&crtc) else {
         return;
     };
-    if surface.queued || surface.scheduled.is_some() {
+    if !surface.powered || surface.queued || surface.scheduled.is_some() {
         return;
     }
     let now = now_ns();
@@ -918,7 +961,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
     let Some(surface) = drm.surfaces.get_mut(&crtc) else {
         return false;
     };
-    if surface.queued {
+    if surface.queued || !surface.powered {
         return false;
     }
     surface.cursor_redraw = false;

Modified file: crates/monolith/src/idle.rs+3 additions−5 deletions@@ -45,11 +45,6 @@ impl IdleInhibitHandler for State {
 }
 
 impl State {
-    pub fn activity(&mut self) {
-        let seat = self.input.seat.clone();
-        self.services.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) {
@@ -67,6 +62,9 @@ impl State {
         });
         if shown != self.services.idle.inhibited {
             self.services.idle.inhibited = shown;
+            if !shown {
+                self.services.power.touch();
+            }
             self.services.idle.notifier.set_is_inhibited(shown);
         }
     }

Modified file: crates/monolith/src/lock.rs+4 additions−5 deletions@@ -108,11 +108,10 @@ impl State {
         if self.services.lock.pending.is_none() {
             return;
         }
-        let all = self
-            .wm
-            .space
-            .outputs()
-            .all(|o| self.services.lock.blanked.contains(&o.name()));
+        let all = self.wm.space.outputs().all(|o| {
+            let name = o.name();
+            self.services.lock.blanked.contains(&name) || !self.output_powered(&name)
+        });
         if all && let Some(locker) = self.services.lock.pending.take() {
             locker.lock();
             self.services.lock.locked = true;

Modified file: crates/monolith/src/main.rs+2 additions@@ -19,6 +19,7 @@ mod layers;
 mod lock;
 mod nested;
 mod pacing;
+mod power;
 mod scene;
 mod seat;
 mod state;
@@ -264,6 +265,7 @@ fn run(
     }
     ipc::init(&event_loop, &mut state)?;
     xwayland::init(&mut state);
+    state.configure_idle();
     tracing::info!(socket = ?state.core.socket_name, device = state.renderer.device_name(), "monolith running");
 
     if gpu.is_some() {

Added file: crates/monolith/src/power.rs+121 additions@@ -0,0 +1,121 @@
+//! Whether each output is lit. Idle blanking, the ipc `power` command and
+//! wlr-output-power-management all end up here, and the backend is told what
+//! came out.
+
+use crate::state::{State, now_ns};
+use smithay::reexports::calloop::RegistrationToken;
+use smithay::reexports::calloop::timer::{TimeoutAction, Timer};
+use std::collections::HashSet;
+use std::time::Duration;
+
+#[derive(Default)]
+pub struct Power {
+    /// Every output is dark until the next input.
+    idle_blanked: bool,
+    /// Outputs switched off by name, which input does not wake.
+    off: HashSet<String>,
+    last_activity: u64,
+    timer: Option<RegistrationToken>,
+}
+
+impl Power {
+    pub fn dark(&self, name: &str) -> bool {
+        self.idle_blanked || self.off.contains(name)
+    }
+
+    /// An inhibitor going away counts as activity, so the screen does not
+    /// blank the moment a video stops.
+    pub fn touch(&mut self) {
+        self.last_activity = now_ns();
+    }
+
+    pub fn forget(&mut self, name: &str) {
+        self.off.remove(name);
+    }
+}
+
+impl State {
+    pub fn output_powered(&self, name: &str) -> bool {
+        !self.services.power.dark(name)
+    }
+
+    /// Pushes the wanted power state of every output to the backend.
+    pub fn apply_power(&mut self) {
+        let names: Vec<String> = self.wm.space.outputs().map(|o| o.name()).collect();
+        for name in names {
+            let on = self.output_powered(&name);
+            if let Some(drm) = self.backend.drm_mut() {
+                drm.set_powered(&name, on);
+            }
+        }
+    }
+
+    /// Notes input, and lights the outputs again if idleness had blanked them.
+    pub fn activity(&mut self) {
+        let seat = self.input.seat.clone();
+        self.services.idle.notifier.notify_activity(&seat);
+        self.services.power.touch();
+        if self.services.power.idle_blanked {
+            self.wake_idle();
+            self.apply_power();
+        }
+    }
+
+    fn wake_idle(&mut self) {
+        if std::mem::take(&mut self.services.power.idle_blanked) {
+            tracing::info!("input after idle, outputs back on");
+            self.configure_idle();
+        }
+    }
+
+    /// Arms the idle timer from the config, or disarms it.
+    pub fn configure_idle(&mut self) {
+        if let Some(token) = self.services.power.timer.take() {
+            self.core.handle.remove(token);
+        }
+        let secs = self.settings.config.idle.blank_after;
+        if secs == 0 || self.services.power.idle_blanked {
+            return;
+        }
+        let power = &mut self.services.power;
+        if power.last_activity == 0 {
+            power.touch();
+        }
+        let timeout = secs.saturating_mul(1_000_000_000);
+        let left = timeout.saturating_sub(now_ns().saturating_sub(power.last_activity));
+        let after = Timer::from_duration(Duration::from_nanos(left.max(1_000_000)));
+        let token = self
+            .core
+            .handle
+            .insert_source(after, |_, _, state| state.idle_elapsed());
+        match token {
+            Ok(token) => self.services.power.timer = Some(token),
+            Err(e) => tracing::warn!("could not arm the idle timer: {e}"),
+        }
+    }
+
+    fn idle_elapsed(&mut self) -> TimeoutAction {
+        let timeout = self
+            .settings
+            .config
+            .idle
+            .blank_after
+            .saturating_mul(1_000_000_000);
+        if timeout == 0 {
+            self.services.power.timer = None;
+            return TimeoutAction::Drop;
+        }
+        let idle_for = now_ns().saturating_sub(self.services.power.last_activity);
+        if idle_for < timeout {
+            return TimeoutAction::ToDuration(Duration::from_nanos(timeout - idle_for));
+        }
+        if self.services.idle.inhibited {
+            return TimeoutAction::ToDuration(Duration::from_nanos(timeout));
+        }
+        tracing::info!("idle, switching outputs off");
+        self.services.power.timer = None;
+        self.services.power.idle_blanked = true;
+        self.apply_power();
+        TimeoutAction::Drop
+    }
+}

Modified file: crates/monolith/src/state.rs+2 additions@@ -88,6 +88,7 @@ pub struct Services {
     pub launches: crate::launch::Launches,
     pub ipc: crate::ipc::Server,
     pub idle: crate::idle::Idle,
+    pub power: crate::power::Power,
     pub commits: crate::stats::CommitStats,
 }
 
@@ -199,6 +200,7 @@ impl State {
                 launches: Default::default(),
                 ipc: Default::default(),
                 idle,
+                power: Default::default(),
                 commits: Default::default(),
             },
         })

monolith

Commit 47b86d08d05a

Commit `47b86d08d05a`