monolith

public

Star0

Fork 0

Watch0

284 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `2e7a7840d045`

tarball

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

4 files changed+258-237

power: split into dpms, idle blanking and lid modules

power.rs mixed three state machines that share only the Power struct. The lid wake rearm moves into lid::lid_woken so activity() no longer carries lid logic inline.

Deleted file: crates/monolith/src/power.rs−237 deletions@@ -1,237 +0,0 @@
-//! 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::logind::Action;
-use crate::state::{State, now_ns};
-use monolith_config::LidAction;
-use monolith_protocols::output_power::{OutputPowerHandler, OutputPowerState};
-use smithay::output::Output;
-use smithay::reexports::calloop::RegistrationToken;
-use smithay::reexports::calloop::timer::{TimeoutAction, Timer};
-use std::collections::HashSet;
-use std::time::Duration;
-
-/// How long input with the lid shut may go on before the close action runs
-/// again, so waking a closed laptop does not suspend it mid-keystroke.
-const LID_GRACE: Duration = Duration::from_secs(5);
-
-#[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>,
-    lid_closed: bool,
-    /// The lid close action already ran for this closing.
-    lid_acted: bool,
-    /// The internal panel is dark and out of the layout because the lid is
-    /// shut and something else is connected.
-    panel_off: bool,
-    last_activity: u64,
-    timer: Option<RegistrationToken>,
-}
-
-impl Power {
-    pub fn dark(&self, name: &str) -> bool {
-        self.idle_blanked || self.off.contains(name) || (self.panel_off && internal(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);
-    }
-}
-
-pub fn internal(name: &str) -> bool {
-    ["eDP-", "LVDS-", "DSI-"]
-        .iter()
-        .any(|p| name.starts_with(p))
-}
-
-impl OutputPowerHandler for State {
-    fn output_power_state(&mut self) -> &mut OutputPowerState {
-        &mut self.protocols.output_power
-    }
-
-    fn output_power_request(&mut self, output: &Output, on: bool) {
-        let _ = self.set_output_power(Some(&output.name()), on);
-    }
-
-    fn output_is_powered(&self, output: &Output) -> bool {
-        self.output_powered(&output.name())
-    }
-}
-
-impl State {
-    pub fn output_powered(&self, name: &str) -> bool {
-        !self.services.power.dark(name)
-    }
-
-    /// Switches outputs on or off by name, every output when `name` is None.
-    /// Turning on also ends an idle blank.
-    pub fn set_output_power(&mut self, name: Option<&str>, on: bool) -> Result<(), String> {
-        let known: Vec<String> = self.wm.space.outputs().map(|o| o.name()).collect();
-        if let Some(n) = name
-            && !known.iter().any(|k| k == n)
-        {
-            return Err(format!("no output named {n}"));
-        }
-        let power = &mut self.services.power;
-        for k in known.into_iter().filter(|k| name.is_none_or(|n| n == k)) {
-            if on {
-                power.off.remove(&k);
-            } else {
-                power.off.insert(k);
-            }
-        }
-        if on {
-            self.services.power.touch();
-            self.wake_idle();
-        }
-        self.apply_power();
-        Ok(())
-    }
-
-    /// Pushes the wanted power state of every output to the backend.
-    pub fn apply_power(&mut self) {
-        let names: Vec<String> = match self.backend.drm() {
-            Some(drm) => drm.names(),
-            None => self.wm.space.outputs().map(|o| o.name()).collect(),
-        };
-        let power = &mut self.services.power;
-        power.panel_off = power.lid_closed && names.iter().any(|n| !internal(n));
-        let parked = power.panel_off;
-        for name in names {
-            let on = self.output_powered(&name);
-            if let Some(drm) = self.backend.drm_mut() {
-                drm.set_powered(&name, on);
-            }
-            if internal(&name) {
-                crate::drm::set_parked(self, &name, parked);
-            }
-        }
-        let power = &self.services.power;
-        self.protocols.output_power.sync(|o| !power.dark(&o.name()));
-    }
-
-    /// 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();
-        }
-        let acts = !matches!(self.settings.config.lid.close, LidAction::Ignore);
-        if acts
-            && self.services.power.lid_closed
-            && std::mem::take(&mut self.services.power.lid_acted)
-        {
-            let again = Timer::from_duration(LID_GRACE);
-            let armed = self.core.handle.insert_source(again, |_, _, state| {
-                state.lid_act();
-                TimeoutAction::Drop
-            });
-            if let Err(e) = armed {
-                tracing::warn!("could not arm the lid action: {e}");
-            }
-        }
-    }
-
-    /// The lid switch moved. Closing it darkens the internal panel when
-    /// something else shows the desktop, and otherwise runs the configured
-    /// action. Opening it counts as input.
-    pub fn lid_changed(&mut self, closed: bool) {
-        tracing::info!(closed, "lid");
-        self.services.power.lid_closed = closed;
-        self.services.power.lid_acted = false;
-        if !closed {
-            self.activity();
-        }
-        self.apply_power();
-        self.lid_act();
-    }
-
-    /// Runs the lid close action if the lid is shut with no other output.
-    /// Also called when outputs come and go, since unplugging the last
-    /// external display of a closed laptop is when it should sleep.
-    pub fn lid_act(&mut self) {
-        let lit = self.wm.space.outputs().next().is_some();
-        let power = &mut self.services.power;
-        if !lit || !power.lid_closed || power.lid_acted || power.panel_off {
-            return;
-        }
-        power.lid_acted = true;
-        let action = match self.settings.config.lid.close {
-            LidAction::Suspend => Action::Suspend,
-            LidAction::Poweroff => Action::Poweroff,
-            LidAction::Ignore => return,
-        };
-        crate::logind::act(action);
-    }
-
-    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 || self.backend.drm().is_none() {
-            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
-    }
-}

Added file: crates/monolith/src/power/blank.rs+77 additions@@ -0,0 +1,77 @@
+//! Idle blanking, and the input that ends it.
+
+use crate::state::{State, now_ns};
+use smithay::reexports::calloop::timer::{TimeoutAction, Timer};
+use std::time::Duration;
+
+impl State {
+    /// 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();
+        }
+        self.lid_woken();
+    }
+
+    pub(super) 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 || self.backend.drm().is_none() {
+            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
+    }
+}

Added file: crates/monolith/src/power/lid.rs+64 additions@@ -0,0 +1,64 @@
+//! The lid switch, and what closing it does.
+
+use crate::logind::Action;
+use crate::state::State;
+use monolith_config::LidAction;
+use smithay::reexports::calloop::timer::{TimeoutAction, Timer};
+use std::time::Duration;
+
+/// How long input with the lid shut may go on before the close action runs
+/// again, so waking a closed laptop does not suspend it mid-keystroke.
+const LID_GRACE: Duration = Duration::from_secs(5);
+
+impl State {
+    /// The lid switch moved. Closing it darkens the internal panel when
+    /// something else shows the desktop, and otherwise runs the configured
+    /// action. Opening it counts as input.
+    pub fn lid_changed(&mut self, closed: bool) {
+        tracing::info!(closed, "lid");
+        self.services.power.lid_closed = closed;
+        self.services.power.lid_acted = false;
+        if !closed {
+            self.activity();
+        }
+        self.apply_power();
+        self.lid_act();
+    }
+
+    /// Runs the lid close action if the lid is shut with no other output.
+    /// Also called when outputs come and go, since unplugging the last
+    /// external display of a closed laptop is when it should sleep.
+    pub fn lid_act(&mut self) {
+        let lit = self.wm.space.outputs().next().is_some();
+        let power = &mut self.services.power;
+        if !lit || !power.lid_closed || power.lid_acted || power.panel_off {
+            return;
+        }
+        power.lid_acted = true;
+        let action = match self.settings.config.lid.close {
+            LidAction::Suspend => Action::Suspend,
+            LidAction::Poweroff => Action::Poweroff,
+            LidAction::Ignore => return,
+        };
+        crate::logind::act(action);
+    }
+
+    /// Runs the lid close action again a while after input woke a laptop whose
+    /// lid is still shut, since it only ran once when the lid closed.
+    pub(super) fn lid_woken(&mut self) {
+        let acts = !matches!(self.settings.config.lid.close, LidAction::Ignore);
+        if acts
+            && self.services.power.lid_closed
+            && std::mem::take(&mut self.services.power.lid_acted)
+        {
+            let again = Timer::from_duration(LID_GRACE);
+            let armed = self.core.handle.insert_source(again, |_, _, state| {
+                state.lid_act();
+                TimeoutAction::Drop
+            });
+            if let Err(e) = armed {
+                tracing::warn!("could not arm the lid action: {e}");
+            }
+        }
+    }
+}

Added file: crates/monolith/src/power/mod.rs+117 additions@@ -0,0 +1,117 @@
+//! 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.
+
+mod blank;
+mod lid;
+
+use crate::state::{State, now_ns};
+use monolith_protocols::output_power::{OutputPowerHandler, OutputPowerState};
+use smithay::output::Output;
+use smithay::reexports::calloop::RegistrationToken;
+use std::collections::HashSet;
+
+#[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>,
+    lid_closed: bool,
+    /// The lid close action already ran for this closing.
+    lid_acted: bool,
+    /// The internal panel is dark and out of the layout because the lid is
+    /// shut and something else is connected.
+    panel_off: bool,
+    last_activity: u64,
+    timer: Option<RegistrationToken>,
+}
+
+impl Power {
+    pub fn dark(&self, name: &str) -> bool {
+        self.idle_blanked || self.off.contains(name) || (self.panel_off && internal(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);
+    }
+}
+
+pub fn internal(name: &str) -> bool {
+    ["eDP-", "LVDS-", "DSI-"]
+        .iter()
+        .any(|p| name.starts_with(p))
+}
+
+impl OutputPowerHandler for State {
+    fn output_power_state(&mut self) -> &mut OutputPowerState {
+        &mut self.protocols.output_power
+    }
+
+    fn output_power_request(&mut self, output: &Output, on: bool) {
+        let _ = self.set_output_power(Some(&output.name()), on);
+    }
+
+    fn output_is_powered(&self, output: &Output) -> bool {
+        self.output_powered(&output.name())
+    }
+}
+
+impl State {
+    pub fn output_powered(&self, name: &str) -> bool {
+        !self.services.power.dark(name)
+    }
+
+    /// Switches outputs on or off by name, every output when `name` is None.
+    /// Turning on also ends an idle blank.
+    pub fn set_output_power(&mut self, name: Option<&str>, on: bool) -> Result<(), String> {
+        let known: Vec<String> = self.wm.space.outputs().map(|o| o.name()).collect();
+        if let Some(n) = name
+            && !known.iter().any(|k| k == n)
+        {
+            return Err(format!("no output named {n}"));
+        }
+        let power = &mut self.services.power;
+        for k in known.into_iter().filter(|k| name.is_none_or(|n| n == k)) {
+            if on {
+                power.off.remove(&k);
+            } else {
+                power.off.insert(k);
+            }
+        }
+        if on {
+            self.services.power.touch();
+            self.wake_idle();
+        }
+        self.apply_power();
+        Ok(())
+    }
+
+    /// Pushes the wanted power state of every output to the backend.
+    pub fn apply_power(&mut self) {
+        let names: Vec<String> = match self.backend.drm() {
+            Some(drm) => drm.names(),
+            None => self.wm.space.outputs().map(|o| o.name()).collect(),
+        };
+        let power = &mut self.services.power;
+        power.panel_off = power.lid_closed && names.iter().any(|n| !internal(n));
+        let parked = power.panel_off;
+        for name in names {
+            let on = self.output_powered(&name);
+            if let Some(drm) = self.backend.drm_mut() {
+                drm.set_powered(&name, on);
+            }
+            if internal(&name) {
+                crate::drm::set_parked(self, &name, parked);
+            }
+        }
+        let power = &self.services.power;
+        self.protocols.output_power.sync(|o| !power.dark(&o.name()));
+    }
+}

monolith

Commit 2e7a7840d045

Commit `2e7a7840d045`