Add semi_focused tags

I use multiple outputs, and as such often need to remember which
output is currently focused.

Fortunately, river tells us which output is currently in focus.
Therefore, I added the `is_semi_focused` flag to a `Tag`, to signify
that it is a focused Tag on its output, but that it is _not_ actually
focused, because the whole output is not focused.

For users that do not need or want this extra differentiation, setting
`tag_semi_focused_{fg,bg}` to the `tag_focused_{fg,bg}` values, will
result in the previous behaviour.

I am not familiar enough with niri or hyprland to know if they can
support something like this too. As such, both of their information
providers set `is_semi_focused` unconditionally to `false`.

Author: bpeetz

README.md

@@ -55,6 +55,8 @@ tag_fg = "#d79921ff"
 tag_bg = "#282828ff"
 tag_focused_fg = "#1d2021ff"
 tag_focused_bg = "#689d68ff"
+tag_semi_focused_fg = "#1da021ff"
+tag_semi_focused_bg = "#689d68ff"
 tag_urgent_fg = "#282828ff"
 tag_urgent_bg = "#cc241dff"
 tag_inactive_fg = "#d79921ff"

src/bar.rs

@@ -216,6 +216,8 @@ impl Bar {
                     (ss.config.tag_urgent_bg, ss.config.tag_urgent_fg)
                 } else if tag.is_focused {
                     (ss.config.tag_focused_bg, ss.config.tag_focused_fg)
+                } else if tag.is_semi_focused {
+                    (ss.config.tag_semi_focused_bg, ss.config.tag_semi_focused_fg)
                 } else if tag.is_active {
                     (ss.config.tag_bg, ss.config.tag_fg)
                 } else if !ss.config.hide_inactive_tags {

src/config.rs

@@ -22,6 +22,8 @@ pub struct Config {
     pub tag_bg: Color,
     pub tag_focused_fg: Color,
     pub tag_focused_bg: Color,
+    pub tag_semi_focused_fg: Color,
+    pub tag_semi_focused_bg: Color,
     pub tag_urgent_fg: Color,
     pub tag_urgent_bg: Color,
     pub tag_inactive_fg: Color,
@@ -68,6 +70,8 @@ impl Default for Config {
             tag_bg: Color::from_rgba_hex(0x282828ff),
             tag_focused_fg: Color::from_rgba_hex(0x1d2021ff),
             tag_focused_bg: Color::from_rgba_hex(0x689d68ff),
+            tag_semi_focused_fg: Color::from_rgba_hex(0x1da021ff),
+            tag_semi_focused_bg: Color::from_rgba_hex(0x689d68ff),
             tag_urgent_fg: Color::from_rgba_hex(0x282828ff),
             tag_urgent_bg: Color::from_rgba_hex(0xcc241dff),
             tag_inactive_fg: Color::from_rgba_hex(0xd79921ff),

src/wm_info_provider.rs

@@ -68,7 +68,16 @@ pub fn bind(conn: &mut Connection<State>, config: &WmConfig) -> Box<dyn WmInfoPr
 pub struct Tag {
     pub id: u32,
     pub name: String,
+
+    /// The tag is focused and on the currently focused output.
     pub is_focused: bool,
+
+    /// The tag is focused, but not on the currently focused output.
+    pub is_semi_focused: bool,
+
+    /// The tag contains views.
     pub is_active: bool,
+
+    /// The tag contains views marked as “urgent”.
     pub is_urgent: bool,
 }

src/wm_info_provider/hyprland.rs

@@ -59,6 +59,7 @@ impl WmInfoProvider for HyprlandInfoProvider {
                 is_focused: ws.name == self.active_name,
                 is_active: true,
                 is_urgent: false,
+                is_semi_focused: false,
             })
             .collect()
     }

src/wm_info_provider/niri.rs

@@ -69,6 +69,7 @@ impl WmInfoProvider for NiriInfoProvider {
                 is_focused: ws.is_active,
                 is_active: i < output_workspaces.len() - 1 || ws.is_focused,
                 is_urgent: false,
+                is_semi_focused: false,
             })
             .collect()
     }

src/wm_info_provider/river.rs

@@ -20,6 +20,7 @@ struct OutputStatus {
     urgent_tags: u32,
     active_tags: u32,
     layout_name: Option<String>,
+    is_focused: bool,
 }
 
 impl RiverInfoProvider {
@@ -62,6 +63,7 @@ impl WmInfoProvider for RiverInfoProvider {
             urgent_tags: 0,
             active_tags: 0,
             layout_name: None,
+            is_focused: true,
         });
     }
 
@@ -79,11 +81,13 @@ impl WmInfoProvider for RiverInfoProvider {
         let Some(status) = self.output_statuses.iter().find(|s| s.output == output.wl) else {
             return Vec::new();
         };
+
         (1..=u8::min(self.max_tag, 32))
             .map(|tag| Tag {
                 id: tag as u32,
                 name: tag.to_string(),
-                is_focused: status.focused_tags & (1 << (tag - 1)) != 0,
+                is_focused: status.focused_tags & (1 << (tag - 1)) != 0 && status.is_focused,
+                is_semi_focused: status.focused_tags & (1 << (tag - 1)) != 0 && !status.is_focused,
                 is_active: status.active_tags & (1 << (tag - 1)) != 0,
                 is_urgent: status.urgent_tags & (1 << (tag - 1)) != 0,
             })
@@ -184,11 +188,38 @@ fn output_status_cb(ctx: EventCtx<State, ZriverOutputStatusV1>) {
 }
 
 fn seat_status_cb(ctx: EventCtx<State, ZriverSeatStatusV1>) {
-    if let zriver_seat_status_v1::Event::Mode(mode) = ctx.event {
-        let river = ctx.state.shared_state.get_river().unwrap();
-        let mode = mode.to_string_lossy().into_owned();
-        river.mode = (mode != "normal").then_some(mode);
-        ctx.state.mode_name_updated(ctx.conn, None);
+    match ctx.event {
+        zriver_seat_status_v1::Event::Mode(mode) => {
+            let river = ctx.state.shared_state.get_river().unwrap();
+            let mode = mode.to_string_lossy().into_owned();
+            river.mode = (mode != "normal").then_some(mode);
+            ctx.state.mode_name_updated(ctx.conn, None);
+        }
+        zriver_seat_status_v1::Event::FocusedOutput(output) => {
+            let river = ctx.state.shared_state.get_river().unwrap();
+            let Some(status) = river
+                .output_statuses
+                .iter_mut()
+                .find(|s| s.output == output)
+            else {
+                return;
+            };
+            status.is_focused = true;
+            ctx.state.tags_updated(ctx.conn, None);
+        }
+        zriver_seat_status_v1::Event::UnfocusedOutput(output) => {
+            let river = ctx.state.shared_state.get_river().unwrap();
+            let Some(status) = river
+                .output_statuses
+                .iter_mut()
+                .find(|s| s.output == output)
+            else {
+                return;
+            };
+            status.is_focused = false;
+            ctx.state.tags_updated(ctx.conn, None);
+        }
+        _ => {}
     }
 }