monolith

public

Star0

Fork 0

Watch0

166 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `5b8422a225da`

tarball

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

4 files changed+86-4

power: handle the lid switch

`on_input` dropped libinput switch events, so closing a laptop lid did nothing in monolith. `[lid] close` picks suspend, poweroff or ignore through systemctl. With another output connected the lid only darkens the eDP, LVDS or DSI panel, like logind's docked case, and the action runs once the last external output goes.

Modified file: crates/config/default.toml+8 additions@@ -55,6 +55,14 @@ curve = [0.45, 0.0, 0.2, 1.0]
 # keep the screen on while they are shown.
 blank_after = 0
 
+[lid]
+# What closing the lid does, suspend, poweroff or ignore. The internal panel
+# (eDP, LVDS) switches off whenever the lid is closed and another output is
+# connected, and then neither suspend nor poweroff happens. Without a
+# handle-lid-switch inhibitor, logind still acts on the lid itself, so set
+# HandleLidSwitch=ignore there for ignore to mean anything.
+close = "suspend"
+
 [keyboard]
 layout = ""
 repeat_delay = 200

Modified file: crates/config/src/lib.rs+21 additions@@ -18,6 +18,7 @@ pub struct Config {
     pub keyboard: Keyboard,
     pub input: Input,
     pub idle: Idle,
+    pub lid: Lid,
     pub binds: Vec<Bind>,
     pub rules: Vec<Rule>,
     pub startup: Vec<Vec<String>>,
@@ -244,6 +245,23 @@ pub struct Idle {
     pub blank_after: u64,
 }
 
+#[derive(Deserialize, Debug, Clone, PartialEq, Default)]
+#[serde(default, deny_unknown_fields)]
+pub struct Lid {
+    /// What closing the lid does while no other output is connected.
+    pub close: LidAction,
+}
+
+#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum LidAction {
+    #[default]
+    Suspend,
+    Poweroff,
+    /// Leave it to logind or whatever else watches the switch.
+    Ignore,
+}
+
 #[derive(Deserialize, Debug, Clone, PartialEq)]
 #[serde(default, deny_unknown_fields)]
 pub struct Keyboard {
@@ -522,6 +540,7 @@ impl Config {
         let keyboard = section("keyboard", table.remove("keyboard"), w);
         let input = input(table.remove("input"), w);
         let idle = section("idle", table.remove("idle"), w);
+        let lid = section("lid", table.remove("lid"), 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);
@@ -582,6 +601,7 @@ impl Config {
             keyboard,
             input,
             idle,
+            lid,
             binds,
             rules,
             startup,
@@ -771,6 +791,7 @@ mod tests {
         assert_eq!(c.keyboard, Keyboard::default());
         assert_eq!(c.input, Input::default());
         assert_eq!(c.idle, Idle::default());
+        assert_eq!(c.lid, Lid::default());
         assert!(c.binds.len() > 40);
     }
 

Modified file: crates/monolith/src/drm.rs+7 additions@@ -34,6 +34,7 @@ use smithay::reexports::calloop::{EventLoop, LoopHandle, RegistrationToken};
 use smithay::reexports::drm::Device as _;
 use smithay::reexports::drm::control::{self, ModeTypeFlags, connector, crtc};
 use smithay::reexports::input::Libinput;
+use smithay::reexports::input::event::switch::{Switch, SwitchState};
 use smithay::reexports::rustix::fs::OFlags;
 use smithay::reexports::wayland_server::backend::GlobalId;
 use smithay::utils::{DeviceFd, Logical, Point, Transform};
@@ -318,6 +319,7 @@ fn scan(state: &mut State) {
         retry_connector(state, handle);
     }
     state.apply_power();
+    state.lid_act();
     state.apply_layout();
 }
 
@@ -1146,6 +1148,11 @@ fn on_input(state: &mut State, event: InputEvent<LibinputInputBackend>) {
             state.pointer_axis(frame);
             state.pointer_frame();
         }
+        InputEvent::SwitchToggle { event } => {
+            if event.switch() == Some(Switch::Lid) {
+                state.lid_changed(event.switch_state() == SwitchState::On);
+            }
+        }
         InputEvent::DeviceAdded { device } => {
             if let Some(drm) = state.backend.drm_mut() {
                 drm.devices.add(device, &state.settings.config.input);

Modified file: crates/monolith/src/power.rs+50 additions−4 deletions@@ -3,6 +3,7 @@
 //! came out.
 
 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;
@@ -16,13 +17,19 @@ pub struct Power {
     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 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.idle_blanked || self.off.contains(name) || (self.panel_off && internal(name))
     }
 
     /// An inhibitor going away counts as activity, so the screen does not
@@ -36,6 +43,12 @@ impl Power {
     }
 }
 
+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
@@ -82,6 +95,8 @@ impl State {
     /// 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();
+        let power = &mut self.services.power;
+        power.panel_off = power.lid_closed && names.iter().any(|n| !internal(n));
         for name in names {
             let on = self.output_powered(&name);
             if let Some(drm) = self.backend.drm_mut() {
@@ -89,9 +104,7 @@ impl State {
             }
         }
         let power = &self.services.power;
-        self.protocols
-            .output_power
-            .sync(|o| !power.dark(&o.name()));
+        self.protocols.output_power.sync(|o| !power.dark(&o.name()));
     }
 
     /// Notes input, and lights the outputs again if idleness had blanked them.
@@ -105,6 +118,39 @@ 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 power = &mut self.services.power;
+        if !power.lid_closed || power.lid_acted || power.panel_off {
+            return;
+        }
+        power.lid_acted = true;
+        let verb = match self.settings.config.lid.close {
+            LidAction::Suspend => "suspend",
+            LidAction::Poweroff => "poweroff",
+            LidAction::Ignore => return,
+        };
+        if let Err(e) = self.spawn(&["systemctl".into(), verb.into()]) {
+            tracing::warn!("lid close action failed: {e}");
+        }
+    }
+
     fn wake_idle(&mut self) {
         if std::mem::take(&mut self.services.power.idle_blanked) {
             tracing::info!("input after idle, outputs back on");

monolith

Commit 5b8422a225da

Commit `5b8422a225da`