swww-query: support json printing

Author: LGFae

Cargo.lock

@@ -29,6 +29,7 @@ image = { version = "0.25", default-features = false, features = [
   "tiff",
   "webp",
 ] }
+json  = { version = "0.12", default-features = false }
 resvg = { version = "0.45" }
 rustix = { version = "1.1", default-features = false, features = [ "fs" ] }
 fast_image_resize = "5.3"

client/Cargo.toml

@@ -265,6 +265,10 @@ pub struct Query {
     #[arg(short, long, default_value = "false")]
     pub all: bool,
 
+    /// Print the information in `json` format
+    #[arg(short, long, default_value = "false")]
+    pub json: bool,
+
     /// The daemon's namespace.
     ///
     /// The resulting namespace will be 'swww-daemon' appended to what you pass in this argument.

client/src/cli.rs

@@ -2,14 +2,15 @@ use std::{str::FromStr, time::Duration};
 
 use clap::Parser;
 use common::cache;
-use common::ipc::{self, Answer, Client, IpcSocket, RequestSend};
+use common::ipc::{self, Answer, BgInfo, Client, IpcSocket, RequestSend};
 use common::mmap::Mmap;
 
 mod imgproc;
 use imgproc::*;
 
 mod cli;
 use cli::{CliImage, Filter, ResizeStrategy, Swww};
+use json::stringify_pretty;
 
 fn main() -> Result<(), String> {
     let swww = Swww::parse();
@@ -42,8 +43,9 @@ fn main() -> Result<(), String> {
         }
     };
 
-    for namespace in namespaces {
-        let socket = IpcSocket::connect(&namespace).map_err(|err| err.to_string())?;
+    let mut infos = Vec::new();
+    for namespace in &namespaces {
+        let socket = IpcSocket::connect(namespace).map_err(|err| err.to_string())?;
         loop {
             RequestSend::Ping.send(&socket)?;
             let bytes = socket.recv().map_err(|err| err.to_string())?;
@@ -58,22 +60,66 @@ fn main() -> Result<(), String> {
             std::thread::sleep(Duration::from_millis(1));
         }
 
-        process_swww_args(&swww, &namespace)?;
+        if let Some(info) = process_swww_args(&swww, namespace)? {
+            infos.push(info);
+        }
+    }
+
+    if !infos.is_empty() {
+        if let Swww::Query(query) = swww
+            && query.json
+        {
+            use json::object;
+            let mut buf = String::new();
+            for (namespace, infos) in namespaces.iter().zip(infos) {
+                let mut arr = json::JsonValue::new_array();
+                for info in infos {
+                    let displaying = match info.img {
+                        ipc::BgImg::Color(color) => {
+                            object! { color: format!("#{:x}", u32::from_ne_bytes(color)) }
+                        }
+                        ipc::BgImg::Img(img) => {
+                            object! { image: img.as_ref() }
+                        }
+                    };
+                    _ = arr.push(object! {
+                        name: info.name.as_ref(),
+                        width: info.dim.0,
+                        height: info.dim.1,
+                        scale: info.scale_factor.to_f32(),
+                        displaying: displaying
+                    });
+                }
+                buf = format!("{buf}\n\"{namespace}\": {},", stringify_pretty(arr, 4));
+            }
+            buf.pop(); // delete trailing comma
+            println!("{{{buf}\n}}");
+        } else {
+            for (namespace, infos) in namespaces.iter().zip(infos) {
+                for info in infos {
+                    println!("{namespace}: {info}");
+                }
+            }
+        }
     }
     Ok(())
 }
 
-fn process_swww_args(args: &Swww, namespace: &str) -> Result<(), String> {
+fn process_swww_args(args: &Swww, namespace: &str) -> Result<Option<Box<[BgInfo]>>, String> {
     let request = match make_request(args, namespace)? {
         Some(request) => request,
-        None => return Ok(()),
+        None => return Ok(None),
     };
     let socket = IpcSocket::connect(namespace).map_err(|err| err.to_string())?;
     request.send(&socket)?;
     let bytes = socket.recv().map_err(|err| err.to_string())?;
     drop(socket);
     match Answer::receive(bytes) {
-        Answer::Info(info) => info.iter().for_each(|i| println!("{namespace}: {i}")),
+        Answer::Info(infos) => {
+            if let Swww::Query(_) = args {
+                return Ok(Some(infos));
+            }
+        }
         Answer::Ok => {
             if let Swww::Kill(_) = args {
                 #[cfg(debug_assertions)]
@@ -83,7 +129,7 @@ fn process_swww_args(args: &Swww, namespace: &str) -> Result<(), String> {
                 let path = IpcSocket::<Client>::path(namespace);
                 for _ in 0..tries {
                     if rustix::fs::access(&path, rustix::fs::Access::EXISTS).is_err() {
-                        return Ok(());
+                        return Ok(None);
                     }
                     std::thread::sleep(Duration::from_millis(100));
                 }
@@ -94,10 +140,10 @@ fn process_swww_args(args: &Swww, namespace: &str) -> Result<(), String> {
             }
         }
         Answer::Ping(_) => {
-            return Ok(());
+            return Ok(None);
         }
     }
-    Ok(())
+    Ok(None)
 }
 
 fn make_request(args: &Swww, namespace: &str) -> Result<Option<RequestSend>, String> {
@@ -405,5 +451,6 @@ fn restore_output(output: &str, namespace: &str) -> Result<(), String> {
             transition_wave: (0.0, 0.0),
         }),
         namespace,
-    )
+    )?;
+    Ok(())
 }

client/src/main.rs

@@ -177,6 +177,14 @@ impl Scale {
             }
         }
     }
+
+    #[must_use]
+    pub fn to_f32(&self) -> f32 {
+        match self {
+            Scale::Output(i) | Scale::Preferred(i) => i.get() as f32,
+            Scale::Fractional(f) => f.get() as f32 / 120.0,
+        }
+    }
 }
 
 impl PartialEq for Scale {
@@ -193,14 +201,7 @@ impl PartialEq for Scale {
 
 impl fmt::Display for Scale {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "{}",
-            match self {
-                Scale::Output(i) | Scale::Preferred(i) => i.get() as f32,
-                Scale::Fractional(f) => f.get() as f32 / 120.0,
-            }
-        )
+        write!(f, "{}", self.to_f32())
     }
 }
 

common/src/ipc/types.rs

@@ -11,6 +11,9 @@ swww-query
 *-a*,*--all*
 	Send this command to all active *swww-daemon* namespaces.
 
+*-j*,*--j*
+	Print the information in *json* format.
+
 *-n*,*--namespace* <namespace>
 	Which wayland namespace to send this command to.