From 354ce158575388d17ca9c58587e8cdde02332779 Mon Sep 17 00:00:00 2001 From: srdusr <99972264+srdusr@users.noreply.github.com> Date: Sun, 16 Nov 2025 21:46:00 +0200 Subject: 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 - 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. --- crates/platform/src/ipc/dispatch.rs | 105 ++++++++++++++++++++++++++++++++++++ crates/platform/src/ipc/tests.rs | 97 ++++++++++++++++++++++++++++++++- crates/platform/src/ipc/types.rs | 18 +++++++ 3 files changed, 219 insertions(+), 1 deletion(-) (limited to 'crates/platform/src/ipc') 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` - 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 ` - 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 ` - 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 ` - 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 ` - 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 ` - 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` - 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 ` - 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"); @@ -790,6 +807,84 @@ fn set_master_ratio_clamps_to_a_sane_range() { assert_eq!(wm.borrow().tiling.master_ratio, 0.9, "a value past the sane range must clamp, not be accepted verbatim"); } +#[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(); 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 `'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, + 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 -- cgit v1.2.3