Merge pull request #871 from JakeStanger/feat/niri-workspaces

feat(workspaces): niri support

Author: JakeStanger

Diff for: Cargo.toml

@@ -81,9 +81,10 @@ upower = ["zbus", "futures-lite"]
 volume = ["libpulse-binding"]
 
 workspaces = ["futures-lite"]
-"workspaces+all" = ["workspaces", "workspaces+sway", "workspaces+hyprland"]
+"workspaces+all" = ["workspaces", "workspaces+sway", "workspaces+hyprland", "workspaces+niri"]
 "workspaces+sway" = ["workspaces", "sway"]
 "workspaces+hyprland" = ["workspaces", "hyprland"]
+"workspaces+niri" = ["workspaces"]
 
 sway = ["swayipc-async"]
 

Diff for: README.md

@@ -48,10 +48,10 @@ Ironbar is designed to support anything from a lightweight bar to a full desktop
 
 ## Features
 
-- First-class support for Sway and Hyprland
+- First-class support for Sway and Hyprland, and partial support for Niri
 - Fully themeable with hot-loaded CSS
 - Popups to show rich content
-- Ability to create custom widgets, run scripts and embed dynamic content
+- Ability to create custom widgets, run scripts and embed dynamic content (including via Lua)
 - Easy to configure anything from a single bar across all monitors, to multiple different unique bars per monitor 
 - Support for multiple config languages
 

Diff for: docs/Compiling.md

@@ -118,6 +118,7 @@ cargo build --release --no-default-features \
 | workspaces+all      | Enables the `workspaces` module with support for all compositors.                 |
 | workspaces+sway     | Enables the `workspaces` module with support for Sway.                            |
 | workspaces+hyprland | Enables the `workspaces` module with support for Hyprland.                        |
+| workspaces+niri     | Enables the `workspaces` module with support for Niri.                            |
 | **Other**           |                                                                                   |
 | schema              | Enables JSON schema support and the CLI `--print-schema` flag.                    |
 
@@ -200,4 +201,4 @@ codegen-backend = true
 
 [profile.dev]
 codegen-backend = "cranelift"
-```
+```

Diff for: docs/modules/Workspaces.md

@@ -1,4 +1,5 @@
-> ⚠ **This module is currently only supported on Sway and Hyprland**
+> [!IMPORTANT]
+> This module is currently only supported on Sway, Hyprland and Niri**
 
 Shows all current workspaces. Clicking a workspace changes focus to it.
 

Diff for: src/clients/compositor/hyprland.rs

@@ -327,11 +327,8 @@ impl Client {
 }
 
 impl WorkspaceClient for Client {
-    fn focus(&self, id: String) {
-        let identifier = id.parse::<i32>().map_or_else(
-            |_| WorkspaceIdentifierWithSpecial::Name(&id),
-            WorkspaceIdentifierWithSpecial::Id,
-        );
+    fn focus(&self, id: i64) {
+        let identifier = WorkspaceIdentifierWithSpecial::Id(id as i32);
 
         if let Err(e) = Dispatch::call(DispatchType::Workspace(identifier)) {
             error!("Couldn't focus workspace '{id}': {e:#}");

Diff for: src/clients/compositor/mod.rs

@@ -8,6 +8,8 @@ use tracing::debug;
 
 #[cfg(feature = "workspaces+hyprland")]
 pub mod hyprland;
+#[cfg(feature = "workspaces+niri")]
+pub mod niri;
 #[cfg(feature = "workspaces+sway")]
 pub mod sway;
 
@@ -16,6 +18,8 @@ pub enum Compositor {
     Sway,
     #[cfg(feature = "workspaces+hyprland")]
     Hyprland,
+    #[cfg(feature = "workspaces+niri")]
+    Niri,
     Unsupported,
 }
 
@@ -29,6 +33,8 @@ impl Display for Compositor {
                 Self::Sway => "Sway",
                 #[cfg(feature = "workspaces+hyprland")]
                 Self::Hyprland => "Hyprland",
+                #[cfg(feature = "workspaces+niri")]
+                Self::Niri => "Niri",
                 Self::Unsupported => "Unsupported",
             }
         )
@@ -49,6 +55,11 @@ impl Compositor {
                 if #[cfg(feature = "workspaces+hyprland")] { Self::Hyprland }
                 else { tracing::error!("Not compiled with Hyprland support"); Self::Unsupported }
             }
+        } else if std::env::var("NIRI_SOCKET").is_ok() {
+            cfg_if! {
+                if #[cfg(feature = "workspaces+niri")] { Self::Niri }
+                else {tracing::error!("Not compiled with Niri support"); Self::Unsupported }
+            }
         } else {
             Self::Unsupported
         }
@@ -68,7 +79,7 @@ impl Compositor {
             Self::Hyprland => clients
                 .hyprland()
                 .map(|client| client as Arc<dyn KeyboardLayoutClient + Send + Sync>),
-            Self::Unsupported => Err(Report::msg("Unsupported compositor").note(
+            Self::Niri | Self::Unsupported => Err(Report::msg("Unsupported compositor").note(
                 "Currently keyboard layout functionality are only supported by Sway and Hyprland",
             )),
         }
@@ -90,8 +101,10 @@ impl Compositor {
             Self::Hyprland => clients
                 .hyprland()
                 .map(|client| client as Arc<dyn WorkspaceClient + Send + Sync>),
+            #[cfg(feature = "workspaces+niri")]
+            Self::Niri => Ok(Arc::new(niri::Client::new())),
             Self::Unsupported => Err(Report::msg("Unsupported compositor")
-                .note("Currently workspaces are only supported by Sway and Hyprland")),
+                .note("Currently workspaces are only supported by Sway, Niri and Hyprland")),
         }
     }
 }
@@ -125,6 +138,10 @@ impl Visibility {
         Self::Visible { focused: true }
     }
 
+    pub fn is_visible(self) -> bool {
+        matches!(self, Self::Visible { .. })
+    }
+
     pub fn is_focused(self) -> bool {
         if let Self::Visible { focused } = self {
             focused
@@ -170,8 +187,8 @@ pub enum WorkspaceUpdate {
 }
 
 pub trait WorkspaceClient: Debug + Send + Sync {
-    /// Requests the workspace with this name is focused.
-    fn focus(&self, name: String);
+    /// Requests the workspace with this id is focused.
+    fn focus(&self, id: i64);
 
     /// Creates a new to workspace event receiver.
     fn subscribe(&self) -> broadcast::Receiver<WorkspaceUpdate>;

Diff for: src/clients/compositor/niri/connection.rs

@@ -0,0 +1,117 @@
+/// Taken from the `niri_ipc` crate.
+/// Only a relevant snippet has been extracted
+/// to reduce compile times.
+use crate::clients::compositor::Workspace as IronWorkspace;
+use crate::{await_sync, clients::compositor::Visibility};
+use color_eyre::eyre::{eyre, Result};
+use core::str;
+use serde::{Deserialize, Serialize};
+use std::{env, path::Path};
+use tokio::{
+    io::{AsyncBufReadExt, AsyncWriteExt, BufReader},
+    net::UnixStream,
+};
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub enum Request {
+    Action(Action),
+    EventStream,
+}
+
+pub type Reply = Result<Response, String>;
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub enum Response {
+    Handled,
+    Workspaces(Vec<Workspace>),
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub enum Action {
+    FocusWorkspace { reference: WorkspaceReferenceArg },
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+pub enum WorkspaceReferenceArg {
+    Name(String),
+    Id(u64),
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Workspace {
+    pub id: u64,
+    pub idx: u8,
+    pub name: Option<String>,
+    pub output: Option<String>,
+    pub is_active: bool,
+    pub is_focused: bool,
+}
+
+impl From<&Workspace> for IronWorkspace {
+    fn from(workspace: &Workspace) -> IronWorkspace {
+        // Workspaces in niri don't neccessarily have names.
+        // If the niri workspace has a name then it is assigned as is,
+        // but if it does not have a name, the monitor index is used.
+        Self {
+            id: workspace.id as i64,
+            name: workspace.name.clone().unwrap_or(workspace.idx.to_string()),
+            monitor: workspace.output.clone().unwrap_or_default(),
+            visibility: if workspace.is_active {
+                Visibility::Visible {
+                    focused: workspace.is_focused,
+                }
+            } else {
+                Visibility::Hidden
+            },
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum Event {
+    WorkspacesChanged { workspaces: Vec<Workspace> },
+    WorkspaceActivated { id: u64, focused: bool },
+    Other,
+}
+
+#[derive(Debug)]
+pub struct Connection(UnixStream);
+impl Connection {
+    pub async fn connect() -> Result<Self> {
+        let socket_path =
+            env::var_os("NIRI_SOCKET").ok_or_else(|| eyre!("NIRI_SOCKET not found!"))?;
+        Self::connect_to(socket_path).await
+    }
+
+    pub async fn connect_to(path: impl AsRef<Path>) -> Result<Self> {
+        let raw_stream = UnixStream::connect(path.as_ref()).await?;
+        let stream = raw_stream;
+        Ok(Self(stream))
+    }
+
+    pub async fn send(
+        &mut self,
+        request: Request,
+    ) -> Result<(Reply, impl FnMut() -> Result<Event> + '_)> {
+        let Self(stream) = self;
+        let mut buf = serde_json::to_string(&request)?;
+
+        stream.write_all(buf.as_bytes()).await?;
+        stream.shutdown().await?;
+
+        buf.clear();
+        let mut reader = BufReader::new(stream);
+        reader.read_line(&mut buf).await?;
+        let reply = serde_json::from_str(&buf)?;
+
+        let events = move || {
+            buf.clear();
+            await_sync(async {
+                reader.read_line(&mut buf).await.unwrap_or(0);
+            });
+            let event: Event = serde_json::from_str(&buf).unwrap_or(Event::Other);
+            Ok(event)
+        };
+        Ok((reply, events))
+    }
+}