monolith

public

Star0

Fork 0

Watch0

228 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `f4c93ddeb08f`

tarball

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

3 files changed+416-31

config: parse the full set of window rule matchers and effects

Rule matched only app_id and title and carried five placement fields, so apps could not be sized, left unfocused, dimmed or kept from idling by config. Rule now splits into a Matcher over a Subject and a Placement, and a pattern that fails to compile still drops the whole rule since it would otherwise hit every window.

Modified file: crates/config/default.toml+56 additions−1 deletions@@ -181,7 +181,62 @@ selection_access = "focused"
 "Mod+Shift+8" = "tag 8"
 "Mod+Shift+9" = "tag 9"
 
-# Rules match app_id and title by regex, later rules overriding earlier ones.
+# Every rule matcher given must hit, later rules overriding earlier ones. Rules
+# are matched when a window maps and again when its title or app_id changes
+# before it has drawn, since many apps only set the real ones after their first
+# commit. A pattern that does not compile leaves the rule out.
+#
+# Matchers, all optional. Patterns are regexes searched anywhere in the text.
+#   app_id         the Wayland app_id, or the X11 class
+#   title          the current title
+#   initial_title  the title the window had when it mapped, which never changes
+#   class          the X11 WM_CLASS class, never hits a Wayland window
+#   instance       the X11 WM_CLASS instance, never hits a Wayland window
+#   xwayland       true for X11 windows, false for Wayland ones
+#   dialog         true for a window with a parent or transient, or an X11
+#                  dialog, false for any other
+#   parent_app_id  the app_id of the window it is a dialog of, never hits a
+#                  window without a parent
+#
+# Placement, fixed when the window maps or when its rules change before it has
+# drawn.
+#   tag            tag name to open on
+#   output         connector name to open on
+#   floating       open floating or tiled, whatever the window would be
+#   sticky         show on every tag
+#   scratchpad     name of the scratchpad to join
+#   fullscreen     open fullscreen or not, over what the client asks
+#   focus          false keeps the focus where it is when the window maps
+#   size           [width, height] of a floating window
+#   position       [x, y] of a floating window from its output top left
+#   center         true centres a floating window, over position
+#   min_size       [width, height] lower bound for floating sizes, 0 for none
+#   max_size       [width, height] upper bound for floating sizes, 0 for none
+# size, position, center and the bounds only touch windows that float, so
+# pair them with floating = true unless the window floats anyway.
+#
+# Effects, following the latest rules that hit for the window's lifetime.
+#   opacity        0.0 to 1.0, multiplies how opaque the window is drawn
+#   idle_inhibit   visible keeps the screen on while the window is shown,
+#                  fullscreen only while it is also fullscreen
+#   vrr            true or false forces adaptive sync on or off for the output
+#                  while this window is fullscreen on it
+#   tearing        reserved, tearing presentation is not implemented yet
+#
 # [[rules]]
 # app_id = "^pavucontrol$"
 # floating = true
+# size = [900, 600]
+# center = true
+#
+# [[rules]]
+# app_id = "^mpv$"
+# idle_inhibit = "fullscreen"
+# vrr = true
+#
+# [[rules]]
+# app_id = "^firefox$"
+# title = "^Picture-in-Picture$"
+# floating = true
+# opacity = 0.9
+# focus = false

Modified file: crates/config/src/lib.rs+352 additions−29 deletions@@ -509,13 +509,68 @@ pub struct Bind {
 
 #[derive(Debug, Clone)]
 pub struct Rule {
+    pub when: Matcher,
+    pub set: Placement,
+}
+
+/// What a rule asks of a window. Every matcher given must hit.
+#[derive(Debug, Clone, Default)]
+pub struct Matcher {
     pub app_id: Option<Regex>,
     pub title: Option<Regex>,
-    pub tag: Option<String>,
-    pub output: Option<String>,
-    pub floating: Option<bool>,
-    pub sticky: Option<bool>,
-    pub scratchpad: Option<String>,
+    pub initial_title: Option<Regex>,
+    pub class: Option<Regex>,
+    pub instance: Option<Regex>,
+    pub xwayland: Option<bool>,
+    pub dialog: Option<bool>,
+    pub parent_app_id: Option<Regex>,
+}
+
+/// What the rules can see of a window. `class` and `instance` are None for
+/// windows that are not X11, and `parent_app_id` for those without a parent.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Subject<'a> {
+    pub app_id: &'a str,
+    pub title: &'a str,
+    pub initial_title: &'a str,
+    pub class: Option<&'a str>,
+    pub instance: Option<&'a str>,
+    pub xwayland: bool,
+    pub dialog: bool,
+    pub parent_app_id: Option<&'a str>,
+}
+
+impl Matcher {
+    fn hits(&self, s: &Subject) -> bool {
+        fn re(re: &Option<Regex>, s: Option<&str>) -> bool {
+            re.as_ref()
+                .is_none_or(|re| s.is_some_and(|s| re.is_match(s)))
+        }
+        re(&self.app_id, Some(s.app_id))
+            && re(&self.title, Some(s.title))
+            && re(&self.initial_title, Some(s.initial_title))
+            && re(&self.class, s.class)
+            && re(&self.instance, s.instance)
+            && re(&self.parent_app_id, s.parent_app_id)
+            && self.xwayland.is_none_or(|x| x == s.xwayland)
+            && self.dialog.is_none_or(|d| d == s.dialog)
+    }
+}
+
+/// Where a rule puts a floating window.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum At {
+    /// From the top left of the output's area.
+    Position(i32, i32),
+    Center,
+}
+
+#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum IdleInhibit {
+    /// While the window is on screen.
+    Visible,
+    Fullscreen,
 }
 
 /// Everything the matching rules say about a window, later rules winning.
@@ -526,6 +581,52 @@ pub struct Placement {
     pub floating: Option<bool>,
     pub sticky: Option<bool>,
     pub scratchpad: Option<String>,
+    pub size: Option<(u32, u32)>,
+    pub at: Option<At>,
+    /// A zero axis puts no lower bound on it.
+    pub min_size: Option<(u32, u32)>,
+    /// A zero axis puts no upper bound on it.
+    pub max_size: Option<(u32, u32)>,
+    pub fullscreen: Option<bool>,
+    pub focus: Option<bool>,
+    pub opacity: Option<f32>,
+    pub idle_inhibit: Option<IdleInhibit>,
+    pub vrr: Option<bool>,
+    /// Inert until tearing presentation exists.
+    pub tearing: Option<bool>,
+}
+
+impl Placement {
+    fn over(&mut self, r: &Placement) {
+        self.tag = r.tag.clone().or(self.tag.take());
+        self.output = r.output.clone().or(self.output.take());
+        self.floating = r.floating.or(self.floating);
+        self.sticky = r.sticky.or(self.sticky);
+        self.scratchpad = r.scratchpad.clone().or(self.scratchpad.take());
+        self.size = r.size.or(self.size);
+        self.at = r.at.or(self.at);
+        self.min_size = r.min_size.or(self.min_size);
+        self.max_size = r.max_size.or(self.max_size);
+        self.fullscreen = r.fullscreen.or(self.fullscreen);
+        self.focus = r.focus.or(self.focus);
+        self.opacity = r.opacity.or(self.opacity);
+        self.idle_inhibit = r.idle_inhibit.or(self.idle_inhibit);
+        self.vrr = r.vrr.or(self.vrr);
+        self.tearing = r.tearing.or(self.tearing);
+    }
+
+    /// Bounds `(w, h)` by `min_size` and `max_size`.
+    pub fn clamp_size(&self, w: f64, h: f64) -> (f64, f64) {
+        let axis = |v: f64, min: Option<u32>, max: Option<u32>| {
+            let v = min.map_or(v, |m| v.max(f64::from(m)));
+            max.filter(|&m| m > 0).map_or(v, |m| v.min(f64::from(m)))
+        };
+        let (min, max) = (self.min_size, self.max_size);
+        (
+            axis(w, min.map(|s| s.0), max.map(|s| s.0)),
+            axis(h, min.map(|s| s.1), max.map(|s| s.1)),
+        )
+    }
 }
 
 #[derive(Debug)]
@@ -557,11 +658,91 @@ enum Words {
 struct RawRule {
     app_id: Option<String>,
     title: Option<String>,
+    initial_title: Option<String>,
+    class: Option<String>,
+    instance: Option<String>,
+    xwayland: Option<bool>,
+    dialog: Option<bool>,
+    parent_app_id: Option<String>,
     tag: Option<String>,
     output: Option<String>,
     floating: Option<bool>,
     sticky: Option<bool>,
     scratchpad: Option<String>,
+    size: Option<[u32; 2]>,
+    position: Option<[i32; 2]>,
+    center: Option<bool>,
+    min_size: Option<[u32; 2]>,
+    max_size: Option<[u32; 2]>,
+    fullscreen: Option<bool>,
+    focus: Option<bool>,
+    opacity: Option<f32>,
+    idle_inhibit: Option<IdleInhibit>,
+    vrr: Option<bool>,
+    tearing: Option<bool>,
+}
+
+impl RawRule {
+    /// A pattern that does not compile drops the rule, since without it the
+    /// rule would hit every window. A bad effect only drops itself.
+    fn build(self, name: &str, warn: &mut Vec<String>) -> Result<Rule, regex::Error> {
+        let regex = |p: Option<String>| p.map(|p| Regex::new(&p)).transpose();
+        let when = Matcher {
+            app_id: regex(self.app_id)?,
+            title: regex(self.title)?,
+            initial_title: regex(self.initial_title)?,
+            class: regex(self.class)?,
+            instance: regex(self.instance)?,
+            xwayland: self.xwayland,
+            dialog: self.dialog,
+            parent_app_id: regex(self.parent_app_id)?,
+        };
+        let mut set = Placement {
+            tag: self.tag,
+            output: self.output,
+            floating: self.floating,
+            sticky: self.sticky,
+            scratchpad: self.scratchpad,
+            size: self.size.map(|[a, b]| (a, b)),
+            at: self.position.map(|[x, y]| At::Position(x, y)),
+            min_size: self.min_size.map(|[a, b]| (a, b)),
+            max_size: self.max_size.map(|[a, b]| (a, b)),
+            fullscreen: self.fullscreen,
+            focus: self.focus,
+            opacity: self.opacity,
+            idle_inhibit: self.idle_inhibit,
+            vrr: self.vrr,
+            tearing: self.tearing,
+        };
+        if self.center == Some(true) {
+            if set.at.is_some() {
+                warn.push(format!("{name}: position and center both set, center wins"));
+            }
+            set.at = Some(At::Center);
+        }
+        if set.size.is_some_and(|(w, h)| w == 0 || h == 0) {
+            warn.push(format!("{name}.size: must be above zero, ignored"));
+            set.size = None;
+        }
+        if let (Some(min), Some(max)) = (set.min_size, set.max_size)
+            && [(min.0, max.0), (min.1, max.1)]
+                .iter()
+                .any(|&(lo, hi)| hi > 0 && lo > hi)
+        {
+            warn.push(format!(
+                "{name}: min_size is larger than max_size, both ignored"
+            ));
+            set.min_size = None;
+            set.max_size = None;
+        }
+        if let Some(o) = set.opacity
+            && !(0.0..=1.0).contains(&o)
+        {
+            warn.push(format!("{name}.opacity: {o} is outside 0 to 1, ignored"));
+            set.opacity = None;
+        }
+        Ok(Rule { when, set })
+    }
 }
 
 impl Config {
@@ -631,29 +812,21 @@ impl Config {
                 }
             }
         }
-        let regex = |p: Option<String>| p.map(|p| Regex::new(&p)).transpose();
         let mut rules = Vec::new();
         for (i, raw) in items::<RawRule>("rules", table.remove("rules"), w)
             .into_iter()
             .enumerate()
         {
-            match (regex(raw.app_id), regex(raw.title)) {
-                (Ok(app_id), Ok(title)) => rules.push(Rule {
-                    app_id,
-                    title,
-                    tag: raw.tag,
-                    output: raw.output,
-                    floating: raw.floating,
-                    sticky: raw.sticky,
-                    scratchpad: raw.scratchpad,
-                }),
-                (Err(e), _) | (_, Err(e)) => {
+            let name = format!("rules[{i}]");
+            match raw.build(&name, w) {
+                Ok(rule) => rules.push(rule),
+                Err(e) => {
                     let e = e
                         .to_string()
                         .split_whitespace()
                         .collect::<Vec<_>>()
                         .join(" ");
-                    w.push(format!("rules[{i}]: {e}, left out"));
+                    w.push(format!("{name}: {e}, left out"));
                 }
             }
         }
@@ -677,18 +850,10 @@ impl Config {
         Ok(Loaded { config, warnings })
     }
 
-    pub fn placement(&self, app_id: &str, title: &str) -> Placement {
+    pub fn placement(&self, window: &Subject) -> Placement {
         let mut p = Placement::default();
-        let hit = |re: &Option<Regex>, s: &str| re.as_ref().is_none_or(|re| re.is_match(s));
-        for r in &self.rules {
-            if !hit(&r.app_id, app_id) || !hit(&r.title, title) {
-                continue;
-            }
-            p.tag = r.tag.clone().or(p.tag);
-            p.output = r.output.clone().or(p.output);
-            p.floating = r.floating.or(p.floating);
-            p.sticky = r.sticky.or(p.sticky);
-            p.scratchpad = r.scratchpad.clone().or(p.scratchpad);
+        for r in self.rules.iter().filter(|r| r.when.hits(window)) {
+            p.over(&r.set);
         }
         p
     }
@@ -1027,4 +1192,162 @@ mod tests {
         assert_eq!(input.device[2].settings.accel_points, None);
         assert_eq!(loaded.warnings.len(), 3, "{:#?}", loaded.warnings);
     }
+
+    fn subject<'a>(app_id: &'a str, title: &'a str) -> Subject<'a> {
+        Subject {
+            app_id,
+            title,
+            initial_title: title,
+            ..Subject::default()
+        }
+    }
+
+    #[test]
+    fn rules_match_every_given_matcher_and_later_ones_win() {
+        let loaded = Config::parse(
+            r#"
+            [[rules]]
+            app_id = "^mpv$"
+            size = [800, 600]
+            opacity = 0.5
+            idle_inhibit = "visible"
+            [[rules]]
+            title = "Picture"
+            opacity = 0.8
+            focus = false
+            vrr = true
+            tearing = true
+            [[rules]]
+            class = "^Steam$"
+            instance = "steam"
+            xwayland = true
+            fullscreen = true
+            [[rules]]
+            dialog = true
+            parent_app_id = "^firefox$"
+            center = true
+            min_size = [300, 0]
+            max_size = [0, 500]
+            "#,
+        )
+        .unwrap();
+        assert_eq!(loaded.warnings, Vec::<String>::new());
+        let c = loaded.config;
+        let p = c.placement(&subject("mpv", "Picture in picture"));
+        assert_eq!(p.size, Some((800, 600)));
+        assert_eq!(p.opacity, Some(0.8));
+        assert_eq!(p.idle_inhibit, Some(IdleInhibit::Visible));
+        assert_eq!(
+            (p.focus, p.vrr, p.tearing),
+            (Some(false), Some(true), Some(true))
+        );
+        assert_eq!(c.placement(&subject("foot", "sh")), Placement::default());
+
+        let x11 = Subject {
+            class: Some("Steam"),
+            instance: Some("steam"),
+            xwayland: true,
+            ..subject("Steam", "Steam")
+        };
+        assert_eq!(c.placement(&x11).fullscreen, Some(true));
+        let wayland = Subject {
+            xwayland: false,
+            ..subject("Steam", "Steam")
+        };
+        assert_eq!(c.placement(&wayland).fullscreen, None);
+
+        let dialog = Subject {
+            dialog: true,
+            parent_app_id: Some("firefox"),
+            ..subject("firefox", "Save")
+        };
+        let p = c.placement(&dialog);
+        assert_eq!(p.at, Some(At::Center));
+        assert_eq!(p.clamp_size(100.0, 900.0), (300.0, 500.0));
+        let orphan = Subject {
+            parent_app_id: None,
+            ..dialog
+        };
+        assert_eq!(c.placement(&orphan), Placement::default());
+    }
+
+    #[test]
+    fn initial_title_holds_when_the_title_changes() {
+        let loaded = Config::parse(
+            r#"
+            [[rules]]
+            initial_title = "^Untitled$"
+            floating = true
+            "#,
+        )
+        .unwrap();
+        let later = Subject {
+            title: "notes.txt",
+            initial_title: "Untitled",
+            ..subject("gedit", "")
+        };
+        assert_eq!(loaded.config.placement(&later).floating, Some(true));
+        let other = Subject {
+            initial_title: "notes.txt",
+            ..later
+        };
+        assert_eq!(loaded.config.placement(&other).floating, None);
+    }
+
+    #[test]
+    fn bad_rule_values_are_warned_about_and_cost_little() {
+        let loaded = Config::parse(
+            r#"
+            [[rules]]
+            app_id = "a"
+            opacity = 1.5
+            size = [0, 100]
+            min_size = [500, 500]
+            max_size = [400, 0]
+            position = [10, 10]
+            center = true
+            floating = true
+            [[rules]]
+            app_id = "b"
+            idle_inhibit = "always"
+            [[rules]]
+            class = "("
+            [[rules]]
+            parent_app_id = "["
+            [[rules]]
+            app_id = "c"
+            size = [-1, 10]
+            [[rules]]
+            app_id = "d"
+            focus = "no"
+            [[rules]]
+            app_id = "e"
+            vrr = false
+            "#,
+        )
+        .unwrap();
+        let c = loaded.config;
+        assert_eq!(c.rules.len(), 2, "{:#?}", loaded.warnings);
+        let a = c.placement(&subject("a", ""));
+        assert_eq!(a.floating, Some(true));
+        assert_eq!(
+            (a.opacity, a.size, a.min_size, a.max_size),
+            (None, None, None, None)
+        );
+        assert_eq!(a.at, Some(At::Center));
+        assert_eq!(c.placement(&subject("e", "")).vrr, Some(false));
+        assert_eq!(loaded.warnings.len(), 9, "{:#?}", loaded.warnings);
+    }
+
+    #[test]
+    fn size_bounds_treat_zero_as_open() {
+        let p = Placement {
+            min_size: Some((200, 0)),
+            max_size: Some((0, 300)),
+            ..Placement::default()
+        };
+        assert_eq!(p.clamp_size(50.0, 900.0), (200.0, 300.0));
+        assert_eq!(p.clamp_size(4000.0, 10.0), (4000.0, 10.0));
+        assert_eq!(Placement::default().clamp_size(7.0, 9.0), (7.0, 9.0));
+    }
 }

Modified file: crates/monolith/src/windows.rs+8 additions−1 deletions@@ -1,6 +1,7 @@
 use crate::anim::Ghost;
 use crate::state::{State, now_ns};
 use crate::wm::{Kind, LastFrame, identity, root};
+use monolith_config::Subject;
 use monolith_layout::{OutputId, Rect, WindowId};
 use monolith_render_vk::VulkanTexture;
 use smithay::backend::renderer::Renderer;
@@ -20,7 +21,13 @@ impl State {
     /// and title are known and the initial configure can carry its size.
     pub fn map_window(&mut self, window: Window, float: Option<Rectangle<i32, Logical>>) {
         let (app_id, title) = identity(&window);
-        let rule = self.settings.config.placement(&app_id, &title);
+        let subject = Subject {
+            app_id: &app_id,
+            title: &title,
+            initial_title: &title,
+            ..Subject::default()
+        };
+        let rule = self.settings.config.placement(&subject);
         let launch = self.launch_of(self.window_pid(&window));
         let (fullscreen, fullscreen_output) = requested_fullscreen(&window);
         let output = rule

monolith

Commit f4c93ddeb08f

Commit `f4c93ddeb08f`