Linux: accent color via XDG Desktop Portal D-Bus

Author: vdavid

Cargo.lock

@@ -87,6 +87,8 @@ tauri-plugin-window-state = "2"
 trash = "5.2"
 # Credential storage via Linux secret service (GNOME Keyring / KDE Wallet)
 keyring = "3"
+# D-Bus client for XDG Desktop Portal (accent color, appearance settings)
+zbus = "5"
 
 [target.'cfg(any(target_os = "macos", target_os = "linux"))'.dependencies]
 # MTP (Android device) support via pure Rust implementation

apps/desktop/src-tauri/Cargo.lock

@@ -1,16 +1,73 @@
 //! Linux accent color reader.
 //!
-//! Reads the user's desktop accent color via `gsettings` (GNOME 47+).
-//! Falls back to the Cmdr brand gold if gsettings is unavailable or
-//! returns an unrecognized value.
+//! Reads the user's desktop accent color via the XDG Desktop Portal D-Bus API
+//! (works on GNOME 47+ and KDE Plasma 5.23+), falling back to `gsettings`
+//! (older GNOME), then to the Cmdr brand gold.
+//!
+//! Also observes the portal's `SettingChanged` signal for live accent color
+//! updates, matching the macOS `NSSystemColorsDidChangeNotification` behavior.
 
-use log::{debug, warn};
+use log::{debug, info, warn};
+use tauri::{AppHandle, Emitter, Runtime};
+use zbus::zvariant::{OwnedValue, Value};
 
 /// Brand fallback accent (mustard gold from getcmdr.com).
 const FALLBACK_ACCENT_HEX: &str = "#d4a006";
 
+const PORTAL_DEST: &str = "org.freedesktop.portal.Desktop";
+const PORTAL_PATH: &str = "/org/freedesktop/portal/desktop";
+const PORTAL_IFACE: &str = "org.freedesktop.portal.Settings";
+const APPEARANCE_NS: &str = "org.freedesktop.appearance";
+const ACCENT_KEY: &str = "accent-color";
+
+/// Converts sRGB floats in [0, 1] to a `#rrggbb` hex string.
+fn rgb_floats_to_hex(r: f64, g: f64, b: f64) -> String {
+    let r8 = (r.clamp(0.0, 1.0) * 255.0).round() as u8;
+    let g8 = (g.clamp(0.0, 1.0) * 255.0).round() as u8;
+    let b8 = (b.clamp(0.0, 1.0) * 255.0).round() as u8;
+    format!("#{r8:02x}{g8:02x}{b8:02x}")
+}
+
+/// Extracts (r, g, b) floats from a D-Bus variant value.
+/// The portal wraps the color in nested variants: `Variant(Variant((r, g, b)))`.
+fn extract_rgb(value: &Value<'_>) -> Option<(f64, f64, f64)> {
+    // Unwrap up to two levels of Variant nesting
+    let inner = match value {
+        Value::Value(v) => match v.as_ref() {
+            Value::Value(v2) => v2.as_ref(),
+            other => other,
+        },
+        other => other,
+    };
+
+    match inner {
+        Value::Structure(s) => {
+            let fields = s.fields();
+            if fields.len() == 3 {
+                if let (Value::F64(r), Value::F64(g), Value::F64(b)) = (&fields[0], &fields[1], &fields[2]) {
+                    return Some((*r, *g, *b));
+                }
+            }
+            None
+        }
+        _ => None,
+    }
+}
+
+/// Reads accent color via XDG Desktop Portal D-Bus (GNOME 47+, KDE Plasma 5.23+).
+fn read_accent_color_portal() -> Option<String> {
+    let conn = zbus::blocking::Connection::session().ok()?;
+    let proxy = zbus::blocking::Proxy::new(&conn, PORTAL_DEST, PORTAL_PATH, PORTAL_IFACE).ok()?;
+
+    let reply: OwnedValue = proxy.call("ReadOne", &(APPEARANCE_NS, ACCENT_KEY)).ok()?;
+
+    let (r, g, b) = extract_rgb(&reply)?;
+    let hex = rgb_floats_to_hex(r, g, b);
+    debug!("XDG Portal accent color: ({r:.3}, {g:.3}, {b:.3}) -> {hex}");
+    Some(hex)
+}
+
 /// Maps GNOME 47+ accent-color names to hex values.
-/// These are the standard GNOME accent colors as of GNOME 47.
 fn gnome_accent_name_to_hex(name: &str) -> Option<&'static str> {
     match name {
         "blue" => Some("#3584e4"),
@@ -26,34 +83,42 @@ fn gnome_accent_name_to_hex(name: &str) -> Option<&'static str> {
     }
 }
 
-/// Reads the GNOME accent color via `gsettings`.
-fn read_accent_color() -> String {
+/// Reads accent color via `gsettings` (older GNOME without portal support).
+fn read_accent_color_gsettings() -> Option<String> {
     let output = std::process::Command::new("gsettings")
         .args(["get", "org.gnome.desktop.interface", "accent-color"])
-        .output();
-
-    match output {
-        Ok(out) if out.status.success() => {
-            // gsettings returns values like 'blue' (with quotes)
-            let raw = String::from_utf8_lossy(&out.stdout);
-            let name = raw.trim().trim_matches('\'');
-            if let Some(hex) = gnome_accent_name_to_hex(name) {
-                debug!("GNOME accent color: {name} -> {hex}");
-                return hex.to_owned();
-            }
-            warn!("Unrecognized GNOME accent color '{name}', using fallback");
-            FALLBACK_ACCENT_HEX.to_owned()
-        }
-        Ok(out) => {
-            let stderr = String::from_utf8_lossy(&out.stderr);
-            debug!("gsettings failed (not GNOME?): {}", stderr.trim());
-            FALLBACK_ACCENT_HEX.to_owned()
-        }
-        Err(e) => {
-            debug!("gsettings not available: {e}");
-            FALLBACK_ACCENT_HEX.to_owned()
-        }
+        .output()
+        .ok()?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        debug!("gsettings failed (not GNOME?): {}", stderr.trim());
+        return None;
+    }
+
+    let raw = String::from_utf8_lossy(&output.stdout);
+    let name = raw.trim().trim_matches('\'');
+    if let Some(hex) = gnome_accent_name_to_hex(name) {
+        debug!("GNOME accent color: {name} -> {hex}");
+        return Some(hex.to_owned());
     }
+    warn!("Unrecognized GNOME accent color '{name}'");
+    None
+}
+
+/// Reads accent color with fallback chain: XDG Portal → gsettings → brand gold.
+fn read_accent_color() -> String {
+    if let Some(hex) = read_accent_color_portal() {
+        return hex;
+    }
+    debug!("XDG Portal accent color not available, trying gsettings");
+
+    if let Some(hex) = read_accent_color_gsettings() {
+        return hex;
+    }
+    debug!("gsettings accent color not available, using Cmdr brand gold");
+
+    FALLBACK_ACCENT_HEX.to_owned()
 }
 
 /// Tauri command: returns the current Linux accent color as a hex string.
@@ -62,10 +127,65 @@ pub fn get_accent_color() -> String {
     read_accent_color()
 }
 
+/// Starts observing XDG Portal `SettingChanged` signal for live accent color updates.
+/// Emits `accent-color-changed` events to the frontend, matching macOS behavior.
+pub fn observe_accent_color_changes<R: Runtime>(app_handle: AppHandle<R>) {
+    let initial = read_accent_color();
+    debug!("Linux accent color: {initial}");
+
+    tauri::async_runtime::spawn(async move {
+        if let Err(e) = watch_portal_signal(app_handle).await {
+            debug!("Portal accent color watcher not available: {e}");
+        }
+    });
+}
+
+/// Subscribes to the portal's `SettingChanged` D-Bus signal and emits Tauri events.
+async fn watch_portal_signal<R: Runtime>(app_handle: AppHandle<R>) -> zbus::Result<()> {
+    let conn = zbus::Connection::session().await?;
+    let proxy = zbus::Proxy::new(&conn, PORTAL_DEST, PORTAL_PATH, PORTAL_IFACE).await?;
+
+    use futures_util::StreamExt;
+    let mut signals = proxy.receive_signal("SettingChanged").await?;
+
+    while let Some(signal) = signals.next().await {
+        let body = signal.body();
+        let Ok((namespace, key, value)) = body.deserialize::<(String, String, OwnedValue)>() else {
+            continue;
+        };
+
+        if namespace == APPEARANCE_NS && key == ACCENT_KEY {
+            if let Some((r, g, b)) = extract_rgb(&value) {
+                let hex = rgb_floats_to_hex(r, g, b);
+                info!("Accent color changed: {hex}");
+                if let Err(e) = app_handle.emit("accent-color-changed", &hex) {
+                    warn!("Failed to emit accent-color-changed: {e}");
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    #[test]
+    fn rgb_floats_basic_colors() {
+        assert_eq!(rgb_floats_to_hex(1.0, 0.0, 0.0), "#ff0000");
+        assert_eq!(rgb_floats_to_hex(0.0, 1.0, 0.0), "#00ff00");
+        assert_eq!(rgb_floats_to_hex(0.0, 0.0, 1.0), "#0000ff");
+        assert_eq!(rgb_floats_to_hex(0.0, 0.0, 0.0), "#000000");
+        assert_eq!(rgb_floats_to_hex(1.0, 1.0, 1.0), "#ffffff");
+    }
+
+    #[test]
+    fn rgb_floats_clamps_out_of_range() {
+        assert_eq!(rgb_floats_to_hex(-0.5, 1.5, 0.5), "#00ff80");
+    }
+
     #[test]
     fn gnome_accent_names_resolve() {
         assert_eq!(gnome_accent_name_to_hex("blue"), Some("#3584e4"));
@@ -80,9 +200,46 @@ mod tests {
     }
 
     #[test]
-    fn read_accent_color_returns_hex() {
+    fn read_accent_color_returns_valid_hex() {
         let color = read_accent_color();
         assert!(color.starts_with('#'));
-        assert!(color.len() == 7);
+        assert_eq!(color.len(), 7);
+    }
+
+    #[test]
+    fn extract_rgb_from_nested_variants() {
+        // Simulate portal response: Variant(Variant((0.5, 0.5, 0.5)))
+        let structure = zbus::zvariant::StructureBuilder::new()
+            .add_field(0.5_f64)
+            .add_field(0.5_f64)
+            .add_field(0.5_f64)
+            .build()
+            .unwrap();
+        let inner = Value::Structure(structure);
+        let wrapped = Value::Value(Box::new(Value::Value(Box::new(inner))));
+
+        let result = extract_rgb(&wrapped);
+        assert_eq!(result, Some((0.5, 0.5, 0.5)));
+    }
+
+    #[test]
+    fn extract_rgb_wrong_field_count_returns_none() {
+        let structure = zbus::zvariant::StructureBuilder::new()
+            .add_field(0.5_f64)
+            .add_field(0.5_f64)
+            .build()
+            .unwrap();
+        assert_eq!(extract_rgb(&Value::Structure(structure)), None);
+    }
+
+    #[test]
+    fn extract_rgb_wrong_type_returns_none() {
+        let structure = zbus::zvariant::StructureBuilder::new()
+            .add_field("not a float")
+            .add_field(0.5_f64)
+            .add_field(0.5_f64)
+            .build()
+            .unwrap();
+        assert_eq!(extract_rgb(&Value::Structure(structure)), None);
     }
 }

apps/desktop/src-tauri/Cargo.toml

@@ -247,6 +247,8 @@ pub fn run() {
             // Observe system accent color changes and emit events to frontend
             #[cfg(target_os = "macos")]
             accent_color::observe_accent_color_changes(app.handle().clone());
+            #[cfg(target_os = "linux")]
+            accent_color_linux::observe_accent_color_changes(app.handle().clone());
 
             // Initialize font metrics for default font (system font at 12px)
             font_metrics::init_font_metrics(app.handle(), "system-400-12");

apps/desktop/src-tauri/src/accent_color_linux.rs

@@ -22,23 +22,46 @@ pub fn open_privacy_settings() -> Result<(), String> {
 
 /// Opens the system appearance settings via the desktop environment.
 /// Detects the DE from `$XDG_CURRENT_DESKTOP` and launches the appropriate settings app.
+/// When the env var is empty (common when launching via SSH), tries commands in order.
+///
+/// Some settings apps (notably `gnome-control-center`) refuse to launch unless
+/// `XDG_CURRENT_DESKTOP` is set. We pass the expected value to the child process
+/// so it works even from SSH sessions where the variable isn't inherited.
+///
+/// Panel name note: the `background` panel contains style, accent color, and wallpaper
+/// settings on both Ubuntu and vanilla GNOME.
 #[tauri::command]
 pub fn open_appearance_settings() -> Result<(), String> {
     let desktop = std::env::var("XDG_CURRENT_DESKTOP").unwrap_or_default().to_uppercase();
+    log::debug!("open_appearance_settings: XDG_CURRENT_DESKTOP='{desktop}'");
 
-    let (cmd, args): (&str, &[&str]) = if desktop.contains("GNOME") {
-        ("gnome-control-center", &["appearance"])
+    // (command, args, XDG_CURRENT_DESKTOP value the command expects)
+    let candidates: &[(&str, &[&str], &str)] = if desktop.contains("GNOME") {
+        &[("gnome-control-center", &["background"] as &[&str], "GNOME")]
     } else if desktop.contains("KDE") {
-        ("systemsettings", &["kcm_lookandfeel"])
+        &[("systemsettings", &["kcm_lookandfeel"] as &[&str], "KDE")]
     } else if desktop.contains("XFCE") {
-        ("xfce4-appearance-settings", &[])
+        &[("xfce4-appearance-settings", &[] as &[&str], "XFCE")]
     } else {
-        return Err("Appearance settings are not available for your desktop environment.".to_string());
+        // Unknown or empty DE (common via SSH) — try all in order
+        &[
+            ("gnome-control-center", &["background"] as &[&str], "GNOME"),
+            ("systemsettings", &["kcm_lookandfeel"], "KDE"),
+            ("xfce4-appearance-settings", &[], "XFCE"),
+        ]
     };
 
-    std::process::Command::new(cmd)
-        .args(args)
-        .spawn()
-        .map_err(|e| format!("Failed to open appearance settings: {e}"))?;
-    Ok(())
+    for (cmd, args, de_value) in candidates {
+        log::debug!("open_appearance_settings: trying {cmd} {}", args.join(" "));
+        match std::process::Command::new(cmd)
+            .args(*args)
+            .env("XDG_CURRENT_DESKTOP", de_value)
+            .spawn()
+        {
+            Ok(_) => return Ok(()),
+            Err(e) => log::debug!("open_appearance_settings: {cmd} failed: {e}"),
+        }
+    }
+
+    Err("Could not open appearance settings. No supported settings app found.".to_string())
 }

apps/desktop/src-tauri/src/lib.rs

@@ -2,6 +2,9 @@
 
 import { invoke } from '@tauri-apps/api/core'
 import type { VolumeInfo } from '../file-explorer/types'
+import { getAppLogger } from '$lib/logging/logger'
+
+const log = getAppLogger('storage')
 
 /** Default volume ID for the root filesystem */
 export const DEFAULT_VOLUME_ID = 'root'
@@ -102,7 +105,7 @@ export async function openPrivacySettings(): Promise<void> {
 export async function openAppearanceSettings(): Promise<void> {
     try {
         await invoke('open_appearance_settings')
-    } catch {
-        // Command not available (non-macOS) - silently fail
+    } catch (error) {
+        log.warn('Failed to open appearance settings: {error}', { error })
     }
 }

apps/desktop/src-tauri/src/permissions_linux.rs

@@ -9,7 +9,7 @@ Each section is self-contained and can be handed to an agent independently.
 ## Task list
 
 - [x] 1. Quick Look and Get Info (small) — unbind shortcuts, no-op error paths
-- [ ] 2. Accent colors via XDG Desktop Portal (medium) — D-Bus call + live updates + fallback chain
+- [x] 2. Accent colors via XDG Desktop Portal (medium) — D-Bus call + live updates + fallback chain
 - [x] 3. Appearance settings opener (tiny) — DE-specific commands replacing broken `xdg-open`
 - [x] 4. Volume chooser shortcuts and key naming (small) — Alt+F1/F2, F2 rename fix, Super label
 - [x] 5. GTK menu mnemonics (small) — add `&` prefixes to `build_menu_linux()` labels
@@ -109,7 +109,7 @@ for Linux. Detect which is running via the `$XDG_CURRENT_DESKTOP` environment va
 
 | DE | `$XDG_CURRENT_DESKTOP` | Open appearance settings |
 |----|----------------------|------------------------|
-| GNOME | `GNOME` or `ubuntu:GNOME` | `gnome-control-center appearance` |
+| GNOME | `GNOME` or `ubuntu:GNOME` | `gnome-control-center background` |
 | KDE | `KDE` | `systemsettings kcm_lookandfeel` |
 | XFCE | `XFCE` | `xfce4-appearance-settings` |
 | Sway | `sway` | No GUI — return descriptive error |