Add inhibit idle to window config, add tests

Author: griccardos

niri-config/src/appearance.rs

@@ -622,6 +622,12 @@ pub enum BlockOutFrom {
     ScreenCapture,
 }
 
+#[derive(knuffel::DecodeScalar, Debug, Clone, Copy, PartialEq, Eq)]
+pub enum InhibitIdle {
+    Always,
+    Fullscreen,
+}
+
 #[derive(knuffel::Decode, Debug, Default, Clone, Copy, PartialEq)]
 pub struct BorderRule {
     #[knuffel(child)]

niri-config/src/lib.rs

@@ -587,6 +587,36 @@ mod tests {
             .unwrap()
     }
 
+    #[test]
+    fn inhibit() {
+        let parsed = do_parse(
+            r##"
+            window-rule {
+                inhibit-idle "fullscreen"                
+            }
+            window-rule {
+                inhibit-idle "always"
+            }
+            window-rule {
+                inhibit-idle null
+            }
+            window-rule {
+            }
+            "##,
+        );
+
+        assert!(matches!(
+            parsed.window_rules[0].inhibit_idle,
+            Some(Some(InhibitIdle::Fullscreen))
+        ));
+        assert!(matches!(
+            parsed.window_rules[1].inhibit_idle,
+            Some(Some(InhibitIdle::Always))
+        ));
+        assert!(matches!(parsed.window_rules[2].inhibit_idle, Some(None)));
+        assert!(matches!(parsed.window_rules[3].inhibit_idle, None));
+    }
+
     #[test]
     fn parse() {
         let parsed = do_parse(
@@ -1795,6 +1825,7 @@ mod tests {
                     ),
                     scroll_factor: None,
                     tiled_state: None,
+                    inhibit_idle: None,
                 },
             ],
             layer_rules: [

niri-config/src/window_rule.rs

@@ -3,7 +3,7 @@ use niri_ipc::ColumnDisplay;
 use crate::appearance::{BlockOutFrom, BorderRule, CornerRadius, ShadowRule, TabIndicatorRule};
 use crate::layout::DefaultPresetSize;
 use crate::utils::RegexEq;
-use crate::FloatOrInt;
+use crate::{FloatOrInt, InhibitIdle};
 
 #[derive(knuffel::Decode, Debug, Default, Clone, PartialEq)]
 pub struct WindowRule {
@@ -72,6 +72,8 @@ pub struct WindowRule {
     pub scroll_factor: Option<FloatOrInt<0, 100>>,
     #[knuffel(child, unwrap(argument))]
     pub tiled_state: Option<bool>,
+    #[knuffel(child, unwrap(argument))]
+    pub inhibit_idle: Option<Option<InhibitIdle>>,
 }
 
 #[derive(knuffel::Decode, Debug, Default, Clone, PartialEq)]

src/niri.rs

@@ -15,7 +15,7 @@ use anyhow::{bail, ensure, Context};
 use calloop::futures::Scheduler;
 use niri_config::debug::PreviewRender;
 use niri_config::{
-    Config, FloatOrInt, Key, Modifiers, OutputName, TrackLayout, WarpMouseToFocusMode,
+    Config, FloatOrInt, InhibitIdle, Key, Modifiers, OutputName, TrackLayout, WarpMouseToFocusMode,
     WorkspaceReference, Xkb,
 };
 use smithay::backend::allocator::Fourcc;
@@ -4147,7 +4147,17 @@ impl Niri {
                 with_states(surface, |states| {
                     surface_primary_scanout_output(surface, states).is_some()
                 })
-            });
+            })
+            || self
+                .layout
+                .windows()
+                .into_iter()
+                .any(|a| match a.1.rules().inhibit_idle {
+                    Some(InhibitIdle::Always) => true,
+                    Some(InhibitIdle::Fullscreen) => a.1.is_fullscreen(),
+                    None => false,
+                });
+
         self.idle_notifier_state.set_is_inhibited(is_inhibited);
     }
 

src/window/mod.rs

@@ -3,7 +3,7 @@ use std::cmp::{max, min};
 use niri_config::utils::MergeWith as _;
 use niri_config::window_rule::{Match, WindowRule};
 use niri_config::{
-    BlockOutFrom, BorderRule, CornerRadius, FloatingPosition, PresetSize, ShadowRule,
+    BlockOutFrom, BorderRule, CornerRadius, FloatingPosition, InhibitIdle, PresetSize, ShadowRule,
     TabIndicatorRule,
 };
 use niri_ipc::ColumnDisplay;
@@ -119,6 +119,9 @@ pub struct ResolvedWindowRules {
 
     /// Override whether to set the Tiled xdg-toplevel state on the window.
     pub tiled_state: Option<bool>,
+
+    /// Whether to inhibit idle for this window.
+    pub inhibit_idle: Option<InhibitIdle>,
 }
 
 impl<'a> WindowRef<'a> {
@@ -174,6 +177,75 @@ impl<'a> WindowRef<'a> {
 }
 
 impl ResolvedWindowRules {
+    pub const fn empty() -> Self {
+        Self {
+            default_width: None,
+            default_height: None,
+            default_column_display: None,
+            default_floating_position: None,
+            open_on_output: None,
+            open_on_workspace: None,
+            open_maximized: None,
+            open_fullscreen: None,
+            open_floating: None,
+            open_focused: None,
+            min_width: None,
+            min_height: None,
+            max_width: None,
+            max_height: None,
+            focus_ring: BorderRule {
+                off: false,
+                on: false,
+                width: None,
+                active_color: None,
+                inactive_color: None,
+                urgent_color: None,
+                active_gradient: None,
+                inactive_gradient: None,
+                urgent_gradient: None,
+            },
+            border: BorderRule {
+                off: false,
+                on: false,
+                width: None,
+                active_color: None,
+                inactive_color: None,
+                urgent_color: None,
+                active_gradient: None,
+                inactive_gradient: None,
+                urgent_gradient: None,
+            },
+            shadow: ShadowRule {
+                off: false,
+                on: false,
+                offset: None,
+                softness: None,
+                spread: None,
+                draw_behind_window: None,
+                color: None,
+                inactive_color: None,
+            },
+            tab_indicator: TabIndicatorRule {
+                active_color: None,
+                inactive_color: None,
+                urgent_color: None,
+                active_gradient: None,
+                inactive_gradient: None,
+                urgent_gradient: None,
+            },
+            draw_border_with_background: None,
+            opacity: None,
+            geometry_corner_radius: None,
+            clip_to_geometry: None,
+            baba_is_float: None,
+            block_out_from: None,
+            variable_refresh_rate: None,
+            scroll_factor: None,
+            tiled_state: None,
+            inhibit_idle: None,
+        }
+    }
+
     pub fn compute(rules: &[WindowRule], window: WindowRef, is_at_startup: bool) -> Self {
         let _span = tracy_client::span!("ResolvedWindowRules::compute");
 
@@ -296,6 +368,9 @@ impl ResolvedWindowRules {
                 if let Some(x) = rule.tiled_state {
                     resolved.tiled_state = Some(x);
                 }
+                if let Some(x) = rule.inhibit_idle {
+                    resolved.inhibit_idle = x;
+                }
             }
 
             resolved.open_on_output = open_on_output.map(|x| x.to_owned());