Live-expose workspace.per_monitor, titlebar buttons, and desktop icons

Closes the remaining "config-file only" gaps from the AGS capability
survey. workspace.per_monitor gets srd set per_monitor <bool> - safe to
flip live since a monitor with no per-monitor override already falls
back to current_workspace regardless of mode, so nothing visually jumps
on toggle.

theme.decorations.title_bar.button_style/button_side/button_order and
general.desktop_icons/desktop_icons_all_monitors all get the same
live-set + SettingsResponse readback treatment as everything else this
session. New srdwm_core::format_button_order is parse_button_order's
exact inverse, so button_order's readback matches the same string shape
srd set itself accepts.

3 files changed, 219 insertions, 1 deletions

diff --git a/crates/platform/src/ipc/dispatch.rs b/crates/platform/src/ipc/dispatch.rs
index 3dcca57..c5e70be 100644
--- a/crates/platform/src/ipc/dispatch.rs
+++ b/crates/platform/src/ipc/dispatch.rs
@@ -36,6 +36,14 @@ pub(crate) fn handle_request(line: &[u8], wm: &std::rc::Rc<std::cell::RefCell<Wi
                 gap_outer: wm.tiling.gap_outer,
                 master_ratio: wm.tiling.master_ratio,
                 master_count: wm.tiling.master_count,
+                per_monitor: wm.per_monitor_workspaces,
+                button_style: if wm.theme.traffic_light_buttons { "traffic_lights" } else { "traditional" }.to_string(),
+                button_side: if wm.theme.buttons_left { "left" } else { "right" }.to_string(),
+                button_order: wm.theme.button_order.map(srdwm_core::format_button_order),
+                title_centered: wm.theme.title_centered,
+                button_glyph_always: wm.theme.button_glyph_always,
+                desktop_icons: wm.desktop_icons_enabled,
+                desktop_icons_all_monitors: wm.desktop_icons_all_monitors,
             };
             (serde_json::to_vec(&settings).unwrap_or_default(), false)
         }
@@ -498,6 +506,86 @@ fn handle_set(req: &serde_json::Value, wm: &std::rc::Rc<std::cell::RefCell<Windo
             wm.borrow_mut().theme.default_decorated = mode != "client";
             (ok(), true)
         }
+        // `srd set button_style <traffic_lights|traditional>` - live
+        // equivalent of `theme.decorations.title_bar.button_style`
+        // (`ThemeConfig::traffic_light_buttons`), previously config-file/
+        // restart-only. Same "only affects windows created (or
+        // redecorated) after this call" scope as `decoration_mode` above
+        // - retroactively repainting every already-open window's titlebar
+        // is real, separate work (a redraw-buffer invalidation this
+        // backend-agnostic crate has no way to trigger itself).
+        "button_style" => {
+            let Some(v) = value.and_then(|v| v.as_str()) else { return (err("button_style needs \"traffic_lights\" or \"traditional\""), false) };
+            if v != "traffic_lights" && v != "traditional" {
+                return (err("button_style needs \"traffic_lights\" or \"traditional\""), false);
+            }
+            wm.borrow_mut().theme.traffic_light_buttons = v == "traffic_lights";
+            (ok(), true)
+        }
+        // `srd set button_side <left|right>` - live equivalent of `theme.
+        // decorations.title_bar.button_side`. Same scope note as
+        // `button_style` above.
+        "button_side" => {
+            let Some(v) = value.and_then(|v| v.as_str()) else { return (err("button_side needs \"left\" or \"right\""), false) };
+            if v != "left" && v != "right" {
+                return (err("button_side needs \"left\" or \"right\""), false);
+            }
+            wm.borrow_mut().theme.buttons_left = v == "left";
+            (ok(), true)
+        }
+        // `srd set button_order "close,minimize,maximize"` - live
+        // equivalent of `theme.decorations.title_bar.button_order`.
+        // `None` (the built-in default order for whichever side `button_
+        // side` selects) is not reachable through this live path - only
+        // a config reload clears an explicit override back to that,
+        // matching the same asymmetry `rounded_corners`'s own live toggle
+        // already has (an explicit live `Some`/`Some` only, never back to
+        // an unset default).
+        "button_order" => {
+            let Some(raw) = value.and_then(|v| v.as_str()) else { return (err("button_order needs a string value"), false) };
+            let Some(order) = srdwm_core::parse_button_order(raw) else {
+                return (err("button_order must name close, minimize and maximize exactly once each, comma-separated"), false);
+            };
+            wm.borrow_mut().theme.button_order = Some(order);
+            (ok(), true)
+        }
+        // `srd set title_centered <bool>` - live equivalent of `theme.
+        // decorations.title_bar.title_centered`.
+        "title_centered" => {
+            let Some(v) = value.and_then(|v| v.as_bool()) else { return (err("title_centered needs a boolean value"), false) };
+            wm.borrow_mut().theme.title_centered = v;
+            (ok(), true)
+        }
+        // `srd set button_glyph_always <bool>` - live equivalent of
+        // `theme.decorations.title_bar.button_glyph_always` (GNOME/Adwaita's
+        // "always visible" convention vs classic macOS's "hidden until
+        // hover").
+        "button_glyph_always" => {
+            let Some(v) = value.and_then(|v| v.as_bool()) else { return (err("button_glyph_always needs a boolean value"), false) };
+            wm.borrow_mut().theme.button_glyph_always = v;
+            (ok(), true)
+        }
+        // `srd set desktop_icons <bool>` - live equivalent of `general.
+        // desktop_icons`. Unlike the theme keys above, this one *is*
+        // immediately visible either way: `ensure_desktop_icons`'s own
+        // early `if !self.wm.borrow().desktop_icons_enabled { return }`
+        // check runs on every dirty tick, so turning icons off actually
+        // stops drawing them (and back on redraws them) on this compositor's
+        // very next redraw, not just for icons created after the call.
+        "desktop_icons" => {
+            let Some(v) = value.and_then(|v| v.as_bool()) else { return (err("desktop_icons needs a boolean value"), false) };
+            wm.borrow_mut().desktop_icons_enabled = v;
+            (ok(), true)
+        }
+        // `srd set desktop_icons_all_monitors <bool>` - live equivalent
+        // of `general.desktop_icons_all_monitors`. Same immediacy as
+        // `desktop_icons` above - `desktop_icon_origins` (this session's
+        // own split-screen fix) reads this fresh every call.
+        "desktop_icons_all_monitors" => {
+            let Some(v) = value.and_then(|v| v.as_bool()) else { return (err("desktop_icons_all_monitors needs a boolean value"), false) };
+            wm.borrow_mut().desktop_icons_all_monitors = v;
+            (ok(), true)
+        }
         // Tiling-only: `arrange_workspace` skips floating/fullscreen
         // windows regardless, and under `"dynamic"` (the no-op default
         // layout) nothing reads `tiling.gap_*` at all - so setting these
@@ -588,6 +676,23 @@ fn handle_set(req: &serde_json::Value, wm: &std::rc::Rc<std::cell::RefCell<Windo
             wm.borrow_mut().phone_mode = v;
             (ok(), true)
         }
+        // `srd set per_monitor <bool>` - live equivalent of `workspace.
+        // per_monitor`, previously restart-only (flagged in the same
+        // capability survey monitor split/scale were). Safe to flip live
+        // with no reconciliation step needed: `monitor_workspaces` (the
+        // per-monitor override map) starts empty and a monitor with no
+        // entry in it always falls back to `current_workspace` regardless
+        // of mode (`WindowManager::workspace_for_monitor`'s own doc
+        // comment) - so turning this *on* changes nothing visually until
+        // a monitor's workspace is switched independently for the first
+        // time, and turning it back *off* simply resumes every monitor
+        // showing `current_workspace`, the same shared value they'd
+        // already fall back to individually.
+        "per_monitor" => {
+            let Some(v) = value.and_then(|v| v.as_bool()) else { return (err("per_monitor needs a boolean value"), false) };
+            wm.borrow_mut().per_monitor_workspaces = v;
+            (ok(), true)
+        }
         // `srd set multi_cursor <bool>` - live equivalent of `general.
         // multi_cursor`. See `WindowManager::multi_cursor_enabled`'s own
         // doc comment for why this is opt-in rather than always-on.
diff --git a/crates/platform/src/ipc/tests.rs b/crates/platform/src/ipc/tests.rs
index 13ab4c2..c2a678c 100644
--- a/crates/platform/src/ipc/tests.rs
+++ b/crates/platform/src/ipc/tests.rs
@@ -751,7 +751,24 @@ fn settings_reports_the_readback_fields_flagged_as_missing() {
     server.poll(&wm);
     let line = read_line(&mut std::io::BufReader::new(client));
     let parsed: serde_json::Value = serde_json::from_str(&line).unwrap();
-    for field in ["border_width", "border_color", "corner_radius", "decoration_mode_server", "gap_inner", "gap_outer", "master_ratio", "master_count"] {
+    for field in [
+        "border_width",
+        "border_color",
+        "corner_radius",
+        "decoration_mode_server",
+        "gap_inner",
+        "gap_outer",
+        "master_ratio",
+        "master_count",
+        "per_monitor",
+        "button_style",
+        "button_side",
+        "button_order",
+        "title_centered",
+        "button_glyph_always",
+        "desktop_icons",
+        "desktop_icons_all_monitors",
+    ] {
         assert!(parsed.get(field).is_some(), "settings response is missing '{field}'");
     }
     assert_eq!(parsed["border_color"].as_str().unwrap().chars().next(), Some('#'), "border_color must be a hex string, matching what srd set border_color itself accepts");
@@ -791,6 +808,84 @@ fn set_master_ratio_clamps_to_a_sane_range() {
 }
 
 #[test]
+fn set_per_monitor_is_reflected_immediately_by_settings() {
+    let dir = tempfile::tempdir().unwrap();
+    let mut server = IpcServer::bind_in(dir.path(), "test").unwrap();
+    let wm = Rc::new(RefCell::new(WindowManager::new()));
+
+    let mut set_client = UnixStream::connect(&server.path).unwrap();
+    set_client.write_all(b"{\"cmd\":\"set\",\"key\":\"per_monitor\",\"value\":true}\n").unwrap();
+    server.poll(&wm);
+    let _ = read_line(&mut std::io::BufReader::new(set_client));
+
+    let mut settings_client = UnixStream::connect(&server.path).unwrap();
+    settings_client.write_all(b"{\"cmd\":\"settings\"}\n").unwrap();
+    server.poll(&wm);
+    let line = read_line(&mut std::io::BufReader::new(settings_client));
+    assert!(line.contains(r#""per_monitor":true"#));
+}
+
+#[test]
+fn button_and_desktop_icon_settings_are_readable_and_live_settable() {
+    let dir = tempfile::tempdir().unwrap();
+    let mut server = IpcServer::bind_in(dir.path(), "test").unwrap();
+    let wm = Rc::new(RefCell::new(WindowManager::new()));
+
+    for (key, value) in [
+        ("button_style", "\"traditional\""),
+        ("button_side", "\"left\""),
+        ("button_order", "\"maximize,minimize,close\""),
+        ("title_centered", "true"),
+        ("button_glyph_always", "true"),
+        ("desktop_icons", "false"),
+        ("desktop_icons_all_monitors", "false"),
+    ] {
+        let mut client = UnixStream::connect(&server.path).unwrap();
+        client.write_all(format!("{{\"cmd\":\"set\",\"key\":\"{key}\",\"value\":{value}}}\n").as_bytes()).unwrap();
+        server.poll(&wm);
+        let _ = read_line(&mut std::io::BufReader::new(client));
+    }
+
+    let mut settings_client = UnixStream::connect(&server.path).unwrap();
+    settings_client.write_all(b"{\"cmd\":\"settings\"}\n").unwrap();
+    server.poll(&wm);
+    let line = read_line(&mut std::io::BufReader::new(settings_client));
+    assert!(line.contains(r#""button_style":"traditional""#));
+    assert!(line.contains(r#""button_side":"left""#));
+    assert!(line.contains(r#""button_order":"maximize,minimize,close""#));
+    assert!(line.contains(r#""title_centered":true"#));
+    assert!(line.contains(r#""button_glyph_always":true"#));
+    assert!(line.contains(r#""desktop_icons":false"#));
+    assert!(line.contains(r#""desktop_icons_all_monitors":false"#));
+}
+
+#[test]
+fn button_order_is_null_until_explicitly_set() {
+    let dir = tempfile::tempdir().unwrap();
+    let mut server = IpcServer::bind_in(dir.path(), "test").unwrap();
+    let wm = Rc::new(RefCell::new(WindowManager::new()));
+
+    let mut client = UnixStream::connect(&server.path).unwrap();
+    client.write_all(b"{\"cmd\":\"settings\"}\n").unwrap();
+    server.poll(&wm);
+    let line = read_line(&mut std::io::BufReader::new(client));
+    assert!(line.contains(r#""button_order":null"#));
+}
+
+#[test]
+fn set_button_order_rejects_an_invalid_ordering() {
+    let dir = tempfile::tempdir().unwrap();
+    let mut server = IpcServer::bind_in(dir.path(), "test").unwrap();
+    let wm = Rc::new(RefCell::new(WindowManager::new()));
+
+    let mut client = UnixStream::connect(&server.path).unwrap();
+    client.write_all(b"{\"cmd\":\"set\",\"key\":\"button_order\",\"value\":\"close,close,maximize\"}\n").unwrap();
+    server.poll(&wm);
+    let line = read_line(&mut std::io::BufReader::new(client));
+    assert!(line.contains(r#""error""#));
+}
+
+#[test]
 fn pinned_inputs_lists_nothing_before_any_pin_is_applied() {
     let dir = tempfile::tempdir().unwrap();
     let mut server = IpcServer::bind_in(dir.path(), "test").unwrap();
diff --git a/crates/platform/src/ipc/types.rs b/crates/platform/src/ipc/types.rs
index 24e3148..bf1526e 100644
--- a/crates/platform/src/ipc/types.rs
+++ b/crates/platform/src/ipc/types.rs
@@ -198,6 +198,24 @@ pub(crate) struct SettingsResponse {
     /// `master_count`.
     pub(crate) master_ratio: f32,
     pub(crate) master_count: usize,
+    /// `WindowManager::per_monitor_workspaces`'s own doc comment - `srd
+    /// set per_monitor <bool>`'s readback.
+    pub(crate) per_monitor: bool,
+    /// `ThemeConfig::traffic_light_buttons`'s readback, as the same
+    /// `"traffic_lights"`/`"traditional"` string `srd set button_style`
+    /// itself accepts.
+    pub(crate) button_style: String,
+    /// `ThemeConfig::buttons_left`'s readback, as `"left"`/`"right"`.
+    pub(crate) button_side: String,
+    /// `ThemeConfig::button_order`'s readback - `null` when unset (the
+    /// built-in default for whichever side `button_side` selects), the
+    /// same `"close,minimize,maximize"` string shape `srd set button_
+    /// order` accepts otherwise.
+    pub(crate) button_order: Option<String>,
+    pub(crate) title_centered: bool,
+    pub(crate) button_glyph_always: bool,
+    pub(crate) desktop_icons: bool,
+    pub(crate) desktop_icons_all_monitors: bool,
 }
 
 /// `"keyboard_layout"`'s one-shot reply shape - the active XKB layout's