kossLAN/wry
1
0
Fork 0
forked from wry/wry
Code Pull requests Activity

add config options for waking dpms on mouse and keyboard interaction

Browse source
This commit is contained in:
kossLAN 2026-05-25 22:57:29 -04:00
parent 2167484861
commit eece44a59c
No known key found for this signature in database
12 changed files with 116 additions and 9 deletions
Download patch file Download diff file Expand all files Collapse all files

8
jay-config/src/_private/client.rs
View file

@ -1327,6 +1327,14 @@ impl ConfigClient {
self.send(&ClientMessage::SetIdle { timeout })
}
pub fn set_key_press_enables_dpms(&self, enabled: bool) {
self.send(&ClientMessage::SetKeyPressEnablesDpms { enabled })
}
pub fn set_mouse_move_enables_dpms(&self, enabled: bool) {
self.send(&ClientMessage::SetMouseMoveEnablesDpms { enabled })
}
pub fn set_idle_grace_period(&self, period: Duration) {
self.send(&ClientMessage::SetIdleGracePeriod { period })
}

6
jay-config/src/_private/ipc.rs
View file

@ -475,6 +475,12 @@ pub enum ClientMessage<'a> {
SetIdle {
timeout: Duration,
},
SetKeyPressEnablesDpms {
enabled: bool,
},
SetMouseMoveEnablesDpms {
enabled: bool,
},
MoveToOutput {
workspace: WorkspaceSource,
connector: Connector,

14
jay-config/src/lib.rs
View file

@ -252,6 +252,20 @@ pub fn set_idle(timeout: Option<Duration>) {
get!().set_idle(timeout.unwrap_or_default())
}
/// Configures whether a key press turns monitors back on after `jay dpms off`.
///
/// The default is `false`.
pub fn set_key_press_enables_dpms(enabled: bool) {
get!().set_key_press_enables_dpms(enabled)
}
/// Configures whether mouse movement turns monitors back on after `jay dpms off`.
///
/// The default is `false`.
pub fn set_mouse_move_enables_dpms(enabled: bool) {
get!().set_mouse_move_enables_dpms(enabled)
}
/// Configures the idle grace period.
///
/// The grace period starts after the idle timeout expires. During the grace period, the

3
src/compositor.rs
View file

@ -279,11 +279,14 @@ fn start_compositor2(
change: Default::default(),
timeout: Cell::new(Duration::from_secs(10 * 60)),
grace_period: Cell::new(Duration::from_secs(5)),
key_press_enables_dpms: Cell::new(false),
mouse_move_enables_dpms: Cell::new(false),
timeout_changed: Default::default(),
inhibitors: Default::default(),
inhibitors_changed: Default::default(),
inhibited_idle_notifications: Default::default(),
backend_idle: Cell::new(true),
dpms_off_by_command: Cell::new(false),
in_grace_period: Cell::new(false),
},
run_args,

14
src/config/handler.rs
View file

@ -1134,6 +1134,14 @@ impl ConfigProxyHandler {
self.state.idle.set_timeout(&self.state, timeout);
}
fn handle_set_key_press_enables_dpms(&self, enabled: bool) {
self.state.idle.key_press_enables_dpms.set(enabled);
}
fn handle_set_mouse_move_enables_dpms(&self, enabled: bool) {
self.state.idle.mouse_move_enables_dpms.set(enabled);
}
fn handle_set_idle_grace_period(&self, period: Duration) {
self.state.idle.set_grace_period(&self.state, period);
}
@ -3129,6 +3137,12 @@ impl ConfigProxyHandler {
.handle_get_input_device_devnode(device)
.wrn("get_input_device_devnode")?,
ClientMessage::SetIdle { timeout } => self.handle_set_idle(timeout),
ClientMessage::SetKeyPressEnablesDpms { enabled } => {
self.handle_set_key_press_enables_dpms(enabled)
}
ClientMessage::SetMouseMoveEnablesDpms { enabled } => {
self.handle_set_mouse_move_enables_dpms(enabled)
}
ClientMessage::MoveToOutput {
workspace,
connector,

2
src/ifs/jay_compositor.rs
View file

@ -547,7 +547,7 @@ impl JayCompositorRequestHandler for JayCompositor {
fn set_dpms(&self, req: SetDpms, _slf: &Rc<Self>) -> Result<(), Self::Error> {
self.client
.state
.set_connectors_active(req.active != 0)
.set_dpms_active(req.active != 0)
.map_err(JayCompositorError::SetDpms)?;
Ok(())
}

21
src/state.rs
View file

@ -342,10 +342,13 @@ pub struct IdleState {
pub change: AsyncEvent,
pub timeout: Cell<Duration>,
pub grace_period: Cell<Duration>,
pub key_press_enables_dpms: Cell<bool>,
pub mouse_move_enables_dpms: Cell<bool>,
pub timeout_changed: Cell<bool>,
pub inhibitors: CopyHashMap<IdleInhibitorId, Rc<ZwpIdleInhibitorV1>>,
pub inhibitors_changed: Cell<bool>,
pub backend_idle: Cell<bool>,
pub dpms_off_by_command: Cell<bool>,
pub inhibited_idle_notifications:
CopyHashMap<(ClientId, ExtIdleNotificationV1Id), Rc<ExtIdleNotificationV1>>,
pub in_grace_period: Cell<bool>,
@ -975,7 +978,14 @@ impl State {
}
}
pub fn input_occurred(&self) {
pub fn input_occurred(self: &Rc<Self>, key_press: bool, mouse_move: bool) {
if self.idle.dpms_off_by_command.get() {
let enable_dpms = key_press && self.idle.key_press_enables_dpms.get()
|| mouse_move && self.idle.mouse_move_enables_dpms.get();
if enable_dpms && let Err(e) = self.set_dpms_active(true) {
log::error!("Could not enable DPMS after input: {}", ErrorFmt(e));
}
}
if !self.idle.input.replace(true) {
self.idle.change.trigger();
}
@ -1420,6 +1430,15 @@ impl State {
Ok(())
}
pub fn set_dpms_active(
self: &Rc<Self>,
active: bool,
) -> Result<(), BackendConnectorTransactionError> {
self.set_connectors_active(active)?;
self.idle.dpms_off_by_command.set(!active);
Ok(())
}
pub fn root_visible(&self) -> bool {
!self.idle.backend_idle.get()
}

25
src/tasks/input_device.rs
View file

@ -1,6 +1,6 @@
use {
crate::{
backend::{InputDevice, InputDeviceCapability},
backend::{InputDevice, InputDeviceCapability, InputEvent, KeyState},
ifs::wl_seat::PX_PER_SCROLL,
state::{DeviceHandlerData, InputDeviceData, State},
tasks::udev_utils::{UdevProps, udev_props},
@ -80,13 +80,21 @@ impl DeviceHandler {
}
if let Some(seat) = self.data.seat.get() {
let mut any_events = false;
let mut key_press = false;
let mut mouse_move = false;
while let Some(event) = self.dev.event() {
let (is_key_press, is_mouse_move) = dpms_wake_triggers_for(&event);
key_press |= is_key_press;
mouse_move |= is_mouse_move;
if is_key_press || is_mouse_move {
self.state.input_occurred(is_key_press, is_mouse_move);
}
seat.event(&self.data, event);
any_events = true;
}
if any_events {
seat.mark_last_active();
self.state.input_occurred();
self.state.input_occurred(key_press, mouse_move);
}
} else {
while self.dev.event().is_some() {
@ -105,3 +113,16 @@ impl DeviceHandler {
self.data.set_seat(&self.state, None);
}
}
fn dpms_wake_triggers_for(event: &InputEvent) -> (bool, bool) {
match event {
InputEvent::Key {
state: KeyState::Pressed,
..
} => (true, false),
InputEvent::ConnectorPosition { .. }
| InputEvent::Motion { .. }
| InputEvent::MotionAbsolute { .. } => (false, true),
_ => (false, false),
}
}

2
toml-config/src/config.rs
View file

@ -560,6 +560,8 @@ pub struct Config {
pub inputs: Vec<Input>,
pub idle: Option<Duration>,
pub grace_period: Option<Duration>,
pub key_press_enables_dpms: Option<bool>,
pub mouse_move_enables_dpms: Option<bool>,
pub explicit_sync_enabled: Option<bool>,
pub focus_follows_mouse: bool,
pub window_management_key: Option<ModifiedKeySym>,

6
toml-config/src/config/parsers/config.rs
View file

@ -367,11 +367,15 @@ impl Parser for ConfigParser<'_> {
}
let mut idle = None;
let mut grace_period = None;
let mut key_press_enables_dpms = None;
let mut mouse_move_enables_dpms = None;
if let Some(value) = idle_val {
match value.parse(&mut IdleParser(self.0)) {
Ok(v) => {
idle = v.timeout;
grace_period = v.grace_period;
key_press_enables_dpms = v.key_press_enables_dpms;
mouse_move_enables_dpms = v.mouse_move_enables_dpms;
}
Err(e) => {
log::warn!("Could not parse the idle timeout: {}", self.0.error(e));
@ -581,6 +585,8 @@ impl Parser for ConfigParser<'_> {
inputs,
idle,
grace_period,
key_press_enables_dpms,
mouse_move_enables_dpms,
focus_follows_mouse: focus_follows_mouse.despan().unwrap_or(true),
window_management_key,
vrr,

16
toml-config/src/config/parsers/idle.rs
View file

@ -2,7 +2,7 @@ use {
crate::{
config::{
context::Context,
extractor::{Extractor, ExtractorError, n64, opt, val},
extractor::{Extractor, ExtractorError, bol, n64, opt, recover, val},
parser::{DataType, ParseResult, Parser, UnexpectedDataType},
},
toml::{
@ -28,6 +28,8 @@ pub struct IdleParser<'a>(pub &'a Context<'a>);
pub struct Idle {
pub timeout: Option<Duration>,
pub grace_period: Option<Duration>,
pub key_press_enables_dpms: Option<bool>,
pub mouse_move_enables_dpms: Option<bool>,
}
impl Parser for IdleParser<'_> {
@ -41,10 +43,18 @@ impl Parser for IdleParser<'_> {
table: &IndexMap<Spanned<String>, Spanned<Value>>,
) -> ParseResult<Self> {
let mut ext = Extractor::new(self.0, span, table);
let (minutes, seconds, grace_period_val) = ext.extract((
let (
minutes,
seconds,
grace_period_val,
key_press_enables_dpms,
mouse_move_enables_dpms,
) = ext.extract((
opt(n64("minutes")),
opt(n64("seconds")),
opt(val("grace-period")),
recover(opt(bol("key-press-enables-dpms"))),
recover(opt(bol("mouse-move-enables-dpms"))),
))?;
let mut timeout = None;
if minutes.is_some() || seconds.is_some() {
@ -57,6 +67,8 @@ impl Parser for IdleParser<'_> {
Ok(Idle {
timeout,
grace_period,
key_press_enables_dpms: key_press_enables_dpms.despan(),
mouse_move_enables_dpms: mouse_move_enables_dpms.despan(),
})
}
}

8
toml-config/src/lib.rs
View file

@ -40,9 +40,9 @@ use {
on_devices_enumerated, on_idle, on_unload, quit, reload, set_autotile,
set_color_management_enabled, set_corner_radius, set_default_workspace_capture,
set_explicit_sync_enabled, set_float_above_fullscreen, set_floating_titles, set_idle,
set_idle_grace_period, set_middle_click_paste_enabled, set_show_bar,
set_show_float_pin_icon, set_show_titles, set_tab_title_align, set_ui_drag_enabled,
set_ui_drag_threshold,
set_idle_grace_period, set_key_press_enables_dpms, set_middle_click_paste_enabled,
set_mouse_move_enables_dpms, set_show_bar, set_show_float_pin_icon, set_show_titles,
set_tab_title_align, set_ui_drag_enabled, set_ui_drag_threshold,
status::{set_i3bar_separator, set_status, set_status_command, unset_status_command},
switch_to_vt,
tasks::{self, JoinHandle},
@ -1657,6 +1657,8 @@ fn load_config(initial_load: bool, auto_reload: bool, persistent: &Rc<Persistent
set_x_scaling_mode(mode);
}
}
set_key_press_enables_dpms(config.key_press_enables_dpms.unwrap_or(false));
set_mouse_move_enables_dpms(config.mouse_move_enables_dpms.unwrap_or(false));
if let Some(cm) = config.color_management
&& let Some(enabled) = cm.enabled
{