monolith

public

Star0

Fork 0

Watch0

164 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `a2cc6a5809c0`

tarball

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

5 files changed+231-0

protocols: add wlr-output-power-management-v1

smithay does not ship it in this revision and swayidle-style daemons have no other way to switch monolith's outputs. Requests drive the same `Power` state as the idle timeout, and `sync` reports changes made by anything else back to the client.

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

@@ -632,6 +632,7 @@ fn disconnect(state: &mut State, crtc: crtc::Handle) {

632632 state.close_layers(&surface.output);

633633 state.services.lock.forget(&surface.output);

634634 state.services.power.forget(&surface.output.name());

635+ state.protocols.output_power.output_removed(&surface.output);

635636 }

636637

637638 impl Drm {

Modified file: crates/monolith/src/globals.rs+3 additions@@ -2,6 +2,7 @@
 //! own handler impl, the rest publish compositor state to clients.
 
 use crate::state::State;
+use monolith_protocols::output_power::OutputPowerState;
 use monolith_protocols::toplevel::ForeignToplevelState;
 use monolith_protocols::workspace::WorkspaceState;
 use monolith_render_vk::VulkanRenderer;
@@ -47,6 +48,7 @@ pub struct Protocols {
     pub xwayland_shell_state: XWaylandShellState,
     pub workspaces: WorkspaceState,
     pub foreign_toplevels: ForeignToplevelState,
+    pub output_power: OutputPowerState,
     pub toplevel_list: ForeignToplevelListState,
     _image_capture_source: ImageCaptureSourceState,
     _idle_inhibit: IdleInhibitManagerState,
@@ -101,6 +103,7 @@ impl Protocols {
             xwayland_shell_state: XWaylandShellState::new::<State>(dh),
             workspaces: WorkspaceState::new::<State>(dh),
             foreign_toplevels: ForeignToplevelState::new::<State>(dh),
+            output_power: OutputPowerState::new::<State>(dh),
             toplevel_list: ForeignToplevelListState::new::<State>(dh),
             _image_capture_source: ImageCaptureSourceState::new(),
             _idle_inhibit: IdleInhibitManagerState::new::<State>(dh),

Modified file: crates/monolith/src/power.rs+44 additions@@ -3,6 +3,8 @@
 //! came out.
 
 use crate::state::{State, now_ns};
+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;
@@ -34,11 +36,49 @@ impl Power {
     }
 }
 
+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.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> = self.wm.space.outputs().map(|o| o.name()).collect();
@@ -48,6 +88,10 @@ impl State {
                 drm.set_powered(&name, on);
             }
         }
+        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.

Modified file: crates/protocols/src/lib.rs+1

@@ -1,4 +1,5 @@

11 //! Wayland protocols monolith implements itself.

3+pub mod output_power;

34 pub mod toplevel;

45 pub mod workspace;

Added file: crates/protocols/src/output_power.rs+182 additions@@ -0,0 +1,182 @@
+//! wlr-output-power-management-v1, so idle daemons like swayidle can switch
+//! outputs off and on. The compositor owns the power state. This module
+//! turns requests into handler calls and reports the state back to clients.
+
+use smithay::output::Output;
+use smithay::reexports::wayland_protocols_wlr::output_power_management::v1::server::{
+    zwlr_output_power_manager_v1::{self, ZwlrOutputPowerManagerV1},
+    zwlr_output_power_v1::{self, ZwlrOutputPowerV1},
+};
+use smithay::reexports::wayland_server::backend::{ClientId, GlobalId};
+use smithay::reexports::wayland_server::{
+    Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New, Resource,
+};
+use smithay::wayland::{Dispatch2, GlobalDispatch2};
+
+pub trait OutputPowerHandler {
+    fn output_power_state(&mut self) -> &mut OutputPowerState;
+    /// A client asked to switch `output` on or off.
+    fn output_power_request(&mut self, output: &Output, on: bool);
+    fn output_is_powered(&self, output: &Output) -> bool;
+}
+
+struct Control {
+    handle: ZwlrOutputPowerV1,
+    output: Output,
+    last: bool,
+}
+
+pub struct OutputPowerState {
+    global: GlobalId,
+    controls: Vec<Control>,
+}
+
+pub struct ManagerGlobal;
+
+pub struct ManagerData;
+
+pub struct ControlData;
+
+fn mode(on: bool) -> zwlr_output_power_v1::Mode {
+    if on {
+        zwlr_output_power_v1::Mode::On
+    } else {
+        zwlr_output_power_v1::Mode::Off
+    }
+}
+
+impl OutputPowerState {
+    pub fn new<D>(dh: &DisplayHandle) -> Self
+    where
+        D: GlobalDispatch<ZwlrOutputPowerManagerV1, ManagerGlobal> + 'static,
+    {
+        Self {
+            global: dh.create_global::<D, ZwlrOutputPowerManagerV1, _>(1, ManagerGlobal),
+            controls: Vec::new(),
+        }
+    }
+
+    pub fn global(&self) -> GlobalId {
+        self.global.clone()
+    }
+
+    /// Tells every client whose view of an output's power is out of date.
+    pub fn sync(&mut self, powered: impl Fn(&Output) -> bool) {
+        self.controls.retain(|c| c.handle.is_alive());
+        for c in &mut self.controls {
+            let on = powered(&c.output);
+            if on != c.last {
+                c.last = on;
+                c.handle.mode(mode(on));
+            }
+        }
+    }
+
+    /// The output is gone, so controls on it are no longer valid.
+    pub fn output_removed(&mut self, output: &Output) {
+        self.controls.retain(|c| {
+            let gone = &c.output == output;
+            if gone {
+                c.handle.failed();
+            }
+            !gone
+        });
+    }
+}
+
+impl<D> GlobalDispatch2<ZwlrOutputPowerManagerV1, D> for ManagerGlobal
+where
+    D: OutputPowerHandler + Dispatch<ZwlrOutputPowerManagerV1, ManagerData> + 'static,
+{
+    fn bind(
+        &self,
+        _state: &mut D,
+        _dh: &DisplayHandle,
+        _client: &Client,
+        resource: New<ZwlrOutputPowerManagerV1>,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        data_init.init(resource, ManagerData);
+    }
+}
+
+impl<D> Dispatch2<ZwlrOutputPowerManagerV1, D> for ManagerData
+where
+    D: OutputPowerHandler + Dispatch<ZwlrOutputPowerV1, ControlData> + 'static,
+{
+    fn request(
+        &self,
+        state: &mut D,
+        _client: &Client,
+        _resource: &ZwlrOutputPowerManagerV1,
+        request: zwlr_output_power_manager_v1::Request,
+        _dh: &DisplayHandle,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        let zwlr_output_power_manager_v1::Request::GetOutputPower { id, output } = request else {
+            return;
+        };
+        let handle = data_init.init(id, ControlData);
+        let Some(output) = Output::from_resource(&output) else {
+            handle.failed();
+            return;
+        };
+        state.output_power_state().controls.retain(|c| c.handle.is_alive());
+        if state
+            .output_power_state()
+            .controls
+            .iter()
+            .any(|c| c.output == output)
+        {
+            handle.failed();
+            return;
+        }
+        let on = state.output_is_powered(&output);
+        handle.mode(mode(on));
+        state.output_power_state().controls.push(Control {
+            handle,
+            output,
+            last: on,
+        });
+    }
+}
+
+impl<D: OutputPowerHandler> Dispatch2<ZwlrOutputPowerV1, D> for ControlData {
+    fn request(
+        &self,
+        state: &mut D,
+        _client: &Client,
+        resource: &ZwlrOutputPowerV1,
+        request: zwlr_output_power_v1::Request,
+        _dh: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        let zwlr_output_power_v1::Request::SetMode { mode } = request else {
+            return;
+        };
+        let on = match mode.into_result() {
+            Ok(zwlr_output_power_v1::Mode::On) => true,
+            Ok(zwlr_output_power_v1::Mode::Off) => false,
+            _ => {
+                resource.post_error(zwlr_output_power_v1::Error::InvalidMode, "invalid mode");
+                return;
+            }
+        };
+        let output = state
+            .output_power_state()
+            .controls
+            .iter()
+            .find(|c| c.handle == *resource)
+            .map(|c| c.output.clone());
+        if let Some(output) = output {
+            state.output_power_request(&output, on);
+        }
+    }
+
+    fn destroyed(&self, state: &mut D, _client: ClientId, resource: &ZwlrOutputPowerV1) {
+        state
+            .output_power_state()
+            .controls
+            .retain(|c| c.handle != *resource);
+    }
+}

monolith

Commit a2cc6a5809c0

Commit `a2cc6a5809c0`