Separate theme rendering from client subscriptions and materials

crates/ferese-theme-client/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "ferese-theme-client"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+ferese-config = { path = "../ferese-config" }
+ferese-ipc = { path = "../ferese-ipc" }
+ferese-protocols = { path = "../ferese-protocols", default-features = false, features = ["client"] }
+libcosmic.workspace = true
+wayland-client.workspace = true
+tokio = { version = "1", features = ["rt", "sync", "time"] }
+
+[dev-dependencies]
+serde_json.workspace = true
+tempfile.workspace = true

crates/ferese-theme-client/src/lib.rs

@@ -0,0 +1,4 @@
+//! Theme subscriptions and window-scoped material bindings for Ferese clients.
+//! Applications own subscription cancellation and keep bindings within window lifetimes.
+pub mod material;
+pub mod service;

crates/ferese-theme-client/src/material.rs

@@ -111,3 +111,65 @@ impl Dispatch<FereseSurfaceMaterialV1, ()> for MaterialState {
 }
 
 delegate_noop!(MaterialState: ignore FereseMaterialManagerV1);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use cosmic::iced::window::raw_window_handle::{
+        DisplayHandle, HandleError, HasDisplayHandle, HasWindowHandle, WaylandDisplayHandle, WaylandWindowHandle,
+        WindowHandle,
+    };
+    use std::ptr::NonNull;
+    use wayland_client::protocol::wl_compositor;
+
+    // Supplies the same borrowed Wayland handles used by Iced, backed by a real client.
+    struct Window {
+        connection: Connection,
+        surface: wl_surface::WlSurface,
+    }
+    impl HasDisplayHandle for Window {
+        fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
+            let pointer = NonNull::new(self.connection.backend().display_ptr().cast()).unwrap();
+            // The connection outlives the returned handle.
+            Ok(unsafe { DisplayHandle::borrow_raw(WaylandDisplayHandle::new(pointer).into()) })
+        }
+    }
+    impl HasWindowHandle for Window {
+        fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError> {
+            let pointer = NonNull::new(self.surface.id().as_ptr().cast()).unwrap();
+            // The surface outlives the returned handle.
+            Ok(unsafe { WindowHandle::borrow_raw(WaylandWindowHandle::new(pointer).into()) })
+        }
+    }
+    delegate_noop!(MaterialState: ignore wl_compositor::WlCompositor);
+    delegate_noop!(MaterialState: ignore wl_surface::WlSurface);
+
+    #[test]
+    #[ignore = "requires a private nested Ferese compositor"]
+    fn attachment_acknowledgement_and_last_clone_release() {
+        assert_eq!(std::env::var("FERESE_TEST_MATERIAL").as_deref(), Ok("1"));
+        let connection = Connection::connect_to_env().unwrap();
+        let (globals, mut queue) = registry_queue_init::<MaterialState>(&connection).unwrap();
+        let qh = queue.handle();
+        let compositor: wl_compositor::WlCompositor = globals.bind(&qh, 1..=6, ()).unwrap();
+        let window = Window {
+            surface: compositor.create_surface(&qh, ()),
+            connection,
+        };
+        let binding = ModalMaterial::attach(&window).expect("compositor acknowledges attachment");
+        let retained = binding.clone();
+        let weak = Arc::downgrade(&binding._binding);
+        drop(binding);
+        assert!(weak.upgrade().is_some());
+        drop(retained);
+        assert!(weak.upgrade().is_none());
+        queue.roundtrip(&mut MaterialState::default()).unwrap();
+        // The compositor rejects duplicate materials. Reattachment proves the final
+        // drop destroyed the first material while preserving the borrowed display.
+        let replacement = ModalMaterial::attach(&window).expect("last clone released the surface material");
+        drop(replacement);
+        queue.roundtrip(&mut MaterialState::default()).unwrap();
+        window.surface.destroy();
+        queue.roundtrip(&mut MaterialState::default()).unwrap();
+    }
+}

crates/ferese-theme-client/src/service.rs

@@ -0,0 +1,154 @@
+use cosmic::iced::futures::SinkExt;
+use ferese_ipc::theme::Snapshot;
+
+pub fn current() -> Snapshot {
+    ferese_ipc::theme::Connection::connect()
+        .ok()
+        .and_then(|mut connection| connection.get(ferese_config::families::builtins).ok())
+        .unwrap_or_else(fallback)
+}
+
+/// Standalone appearance; it does not represent compositor acceptance.
+pub fn fallback() -> Snapshot {
+    let theme = ferese_config::theme::default_theme();
+    Snapshot {
+        version: ferese_ipc::theme::SCHEMA_VERSION,
+        revision: 0,
+        mode: ferese_config::theme::Mode::Dark,
+        presented: theme.clone(),
+        theme,
+        warnings: Vec::new(),
+        error: None,
+        families: ferese_config::families::builtins(),
+        fallback_note: None,
+    }
+}
+
+pub fn subscription() -> cosmic::iced::Subscription<Snapshot> {
+    cosmic::iced::Subscription::run(stream)
+}
+
+fn stream() -> impl cosmic::iced::futures::Stream<Item = Snapshot> {
+    cosmic::iced::stream::channel(1, async |mut output| {
+        loop {
+            let connection = tokio::task::spawn_blocking(ferese_ipc::theme::Connection::connect).await;
+            let Ok(Ok(mut connection)) = connection else {
+                tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+                continue;
+            };
+            let Ok(cancellation) = connection.cancellation() else {
+                return;
+            };
+            let (send, mut receive) = tokio::sync::watch::channel(None);
+            tokio::task::spawn_blocking(move || {
+                let Ok(mut snapshot) = connection.get(ferese_config::families::builtins) else {
+                    return;
+                };
+                loop {
+                    let revision = snapshot.revision;
+                    if send.send(Some(snapshot)).is_err() {
+                        return;
+                    }
+                    match connection.watch(revision, ferese_config::families::builtins) {
+                        Ok(next) => snapshot = next,
+                        Err(_) => return,
+                    }
+                }
+            });
+            while receive.changed().await.is_ok() {
+                let snapshot = receive.borrow_and_update().clone();
+                if let Some(snapshot) = snapshot
+                    && output.send(snapshot).await.is_err()
+                {
+                    return;
+                }
+            }
+            drop(cancellation);
+            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+        }
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use cosmic::iced::futures::StreamExt;
+    use ferese_ipc::{Request, Response, read_frame, write_frame};
+    use std::os::unix::net::UnixListener;
+    use std::time::Duration;
+
+    #[test]
+    fn subscription_reconnects_and_drop_cancels_a_pending_watch() {
+        const CHILD: &str = "FERESE_THEME_SUBSCRIPTION_TEST";
+        if std::env::var_os(CHILD).is_none() {
+            let root = tempfile::tempdir().unwrap();
+            let output = std::process::Command::new(std::env::current_exe().unwrap())
+                .args([
+                    "--exact",
+                    "service::tests::subscription_reconnects_and_drop_cancels_a_pending_watch",
+                    "--nocapture",
+                ])
+                .env(CHILD, "1")
+                .env("XDG_RUNTIME_DIR", root.path())
+                .output()
+                .unwrap();
+            assert!(
+                output.status.success(),
+                "{}\n{}",
+                String::from_utf8_lossy(&output.stdout),
+                String::from_utf8_lossy(&output.stderr)
+            );
+            return;
+        }
+        // No compositor: return the same standalone values without connecting elsewhere.
+        assert_eq!(current(), fallback());
+        let path = ferese_ipc::theme::socket_path().unwrap();
+        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+        let listener = UnixListener::bind(path).unwrap();
+        let (watch_send, watch_receive) = std::sync::mpsc::channel();
+        let server = std::thread::spawn(move || {
+            for revision in [1, 2] {
+                let (mut connection, _) = listener.accept().unwrap();
+                connection.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
+                let get: Request = read_frame(&mut connection).unwrap();
+                assert_eq!(get.command, "theme-get");
+                let mut snapshot = fallback();
+                snapshot.revision = revision;
+                write_frame(
+                    &mut connection,
+                    &Response::success(get.id, serde_json::to_value(snapshot).unwrap()),
+                )
+                .unwrap();
+                let watch: Request = read_frame(&mut connection).unwrap();
+                assert_eq!(watch.command, "theme-watch");
+                assert_eq!(watch.args["since"], revision);
+                if revision == 2 {
+                    watch_send.send(()).unwrap();
+                    use std::io::Read;
+                    // EOF, not the read deadline: dropping the stream must shut down the watch.
+                    assert_eq!(connection.read(&mut [0]).unwrap(), 0);
+                }
+                // First connection closes while watched; the stream must reconnect.
+            }
+        });
+        let runtime = tokio::runtime::Builder::new_current_thread()
+            .enable_time()
+            .build()
+            .unwrap();
+        runtime.block_on(async {
+            let mut subscription = Box::pin(stream());
+            for revision in [1, 2] {
+                let snapshot = tokio::time::timeout(Duration::from_secs(5), subscription.next())
+                    .await
+                    .unwrap()
+                    .unwrap();
+                assert_eq!(snapshot.revision, revision);
+            }
+            tokio::task::spawn_blocking(move || watch_receive.recv_timeout(Duration::from_secs(5)).unwrap())
+                .await
+                .unwrap();
+            drop(subscription);
+        });
+        server.join().unwrap();
+    }
+}

crates/ferese-theme-client/tests/theme_wire.rs

@@ -1,5 +1,5 @@
 use ferese_ipc::theme::Snapshot;
-use ferese_theme::service::fallback;
+use ferese_theme_client::service::fallback;
 use serde_json::{Value, json};
 
 fn fixture() -> Value {
@@ -59,5 +59,8 @@ fn complete_snapshots_do_not_resolve_fallbacks_and_future_versions_are_rejected(
     assert_eq!(serde_json::to_value(snapshot).unwrap(), value);
     let mut future = value;
     future["version"] = json!(ferese_ipc::theme::SCHEMA_VERSION + 1);
-    assert_eq!(Snapshot::decode(future, Vec::new).unwrap_err(), "Unsupported theme snapshot version");
+    assert_eq!(
+        Snapshot::decode(future, Vec::new).unwrap_err(),
+        "Unsupported theme snapshot version"
+    );
 }

crates/ferese-theme/Cargo.toml

@@ -7,12 +7,10 @@ rust-version.workspace = true
 
 [dependencies]
 jiff.workspace = true
-ferese-config = { path = "../ferese-config" }
+ferese-theme-model = { path = "../ferese-theme-model" }
 libcosmic = { workspace = true, features = ["a11y"] }
-ferese-protocols = { path = "../ferese-protocols", default-features = false, features = ["client"] }
-wayland-client.workspace = true
-ferese-ipc = { path = "../ferese-ipc" }
-serde_json.workspace = true
-tokio = { version = "1", features = ["rt", "sync", "time"] }
 
 iced_accessibility = { git = "https://github.com/pop-os/libcosmic", rev = "03d7dcb832bc6d15bc1bb07327a1aa426b2d5bc0" }
+
+[dev-dependencies]
+ferese-config = { path = "../ferese-config" }

crates/ferese-theme/src/controls.rs

@@ -355,7 +355,7 @@ mod tests {
         use cosmic::widget::button::Catalog;
 
         let palette = Palette {
-            appearance: ferese_config::theme::Appearance::Dark,
+            appearance: ferese_theme_model::Appearance::Dark,
             high_contrast: false,
             background: Color::from_rgb8(17, 24, 33),
             sidebar: Color::from_rgb8(17, 24, 33),
@@ -387,8 +387,8 @@ mod tests {
 
     #[test]
     fn switch_thumb_remains_readable_in_every_preset_and_state() {
-        for preset in crate::PRESETS {
-            let resolved = ferese_config::theme::ResolvedTheme {
+        for preset in ferese_config::presets::PRESETS {
+            let resolved = ferese_theme_model::ResolvedTheme {
                 appearance: preset.appearance,
                 tokens: ferese_config::theme::preset(preset.id, preset.appearance).unwrap(),
                 ..ferese_config::theme::default_theme()

crates/ferese-theme/src/gallery.rs

@@ -2,8 +2,8 @@ use cosmic::iced::advanced::widget::{Id, Operation, Tree, tree};
 use cosmic::iced::advanced::{Clipboard, Layout, Shell, Widget, layout, mouse, renderer};
 use cosmic::iced::{Event, Length, Rectangle, Size, keyboard};
 use cosmic::{Element, Renderer, Theme};
-use ferese_config::families::{Family, Palette};
-use ferese_config::theme::Appearance;
+use ferese_theme_model::Appearance;
+use ferese_theme_model::families::{Family, Palette};
 use iced_accessibility::{A11yTree, accesskit};
 
 pub struct TileOptions {
@@ -184,9 +184,9 @@ pub fn svg(family: &Family, variant: Option<Appearance>, active: Option<Appearan
             .or(family.dark.as_ref())
             .or(family.light.as_ref())
             .unwrap();
-        let foreground = ferese_config::theme::hex(ferese_config::theme::readable(
+        let foreground = ferese_theme_model::hex(ferese_theme_model::readable(
             [1.; 4],
-            ferese_config::theme::rgba(&p.accent).unwrap(),
+            ferese_theme_model::rgba(&p.accent).unwrap(),
             4.5,
         ));
         result.push_str(&format!(r#"<circle cx="183" cy="16" r="10" fill="{}"/><path d="M178 16l3 3 6-6" fill="none" stroke="{foreground}" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>"#, p.accent));

crates/ferese-theme/src/lib.rs

@@ -1,4 +1,4 @@
-//! Shared colors, typography, controls and compositor materials for Ferese applications.
+//! Rendering helpers for supplied theme values: colors, typography and controls.
 mod button;
 pub mod calendar;
 mod contrast;
@@ -6,16 +6,12 @@ pub mod controls;
 pub mod gallery;
 mod geometry;
 pub mod icons;
-pub mod material;
 pub mod menus;
 mod palette;
-mod presets;
-pub mod service;
 mod typography;
 
 pub use button::accent_button;
 pub use contrast::{accent_color, accent_pair, apply, composite, contrast, foreground, luminance};
 pub use geometry::inner_radius;
-pub use palette::{Palette, mix, parse_color, surface_shade};
-pub use presets::{PRESETS, Preset};
+pub use palette::{Palette, material_opacity, mix, parse_color, surface_shade};
 pub use typography::{font, text};

crates/ferese-theme/src/palette.rs

@@ -2,7 +2,7 @@ use cosmic::iced::Color;
 
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct Palette {
-    pub appearance: ferese_config::theme::Appearance,
+    pub appearance: ferese_theme_model::Appearance,
     pub high_contrast: bool,
     pub background: Color,
     pub sidebar: Color,
@@ -16,7 +16,7 @@ pub struct Palette {
 }
 
 impl Palette {
-    pub fn from_resolved(theme: &ferese_config::theme::ResolvedTheme) -> Self {
+    pub fn from_resolved(theme: &ferese_theme_model::ResolvedTheme) -> Self {
         let color = |value: &str| parse_color(value).expect("validated resolved theme color");
         Self {
             appearance: theme.appearance,
@@ -46,7 +46,7 @@ impl Palette {
     pub fn native_theme(self) -> cosmic::Theme {
         let rgba = |c: Color| cosmic::cosmic_theme::palette::Srgba::new(c.r, c.g, c.b, 1.);
         use cosmic::cosmic_theme::ThemeBuilder;
-        use ferese_config::theme::Appearance;
+        use ferese_theme_model::Appearance;
         let builder = match (self.appearance, self.high_contrast) {
             (Appearance::Light, false) => ThemeBuilder::light(),
             (Appearance::Dark, false) => ThemeBuilder::dark(),
@@ -109,6 +109,14 @@ pub fn surface_shade(base: Color) -> Color {
     }
 }
 
+pub fn material_opacity(theme: &ferese_theme_model::ResolvedTheme) -> f32 {
+    if theme.tokens.material.style == "translucent" {
+        theme.tokens.material.opacity as f32
+    } else {
+        1.
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -116,11 +124,11 @@ mod tests {
     #[test]
     fn native_theme_preserves_the_resolved_accessibility_mode() {
         for appearance in [
-            ferese_config::theme::Appearance::Light,
-            ferese_config::theme::Appearance::Dark,
+            ferese_theme_model::Appearance::Light,
+            ferese_theme_model::Appearance::Dark,
         ] {
             for high_contrast in [false, true] {
-                let mut resolved = ferese_config::theme::ResolvedTheme {
+                let mut resolved = ferese_theme_model::ResolvedTheme {
                     appearance,
                     ..ferese_config::theme::default_theme()
                 };
@@ -134,8 +142,8 @@ mod tests {
 
     #[test]
     fn every_preset_builds_an_opaque_control_palette_over_translucent_materials() {
-        for preset in crate::PRESETS {
-            let mut resolved = ferese_config::theme::ResolvedTheme {
+        for preset in ferese_config::presets::PRESETS {
+            let mut resolved = ferese_theme_model::ResolvedTheme {
                 appearance: preset.appearance,
                 tokens: ferese_config::theme::preset(preset.id, preset.appearance).unwrap(),
                 ..ferese_config::theme::default_theme()
@@ -145,7 +153,7 @@ mod tests {
             resolved.tokens.geometry.shell_radius = 0.;
             let palette = Palette::from_resolved(&resolved);
             let native = palette.native_theme();
-            assert_eq!(crate::service::opacity(&resolved), 0.25);
+            assert_eq!(crate::material_opacity(&resolved), 0.25);
             assert_eq!(native.cosmic().primary(false).base.alpha, 1.);
             assert_eq!(native.cosmic().corner_radii.radius_m, [0.; 4]);
             for component in [&native.cosmic().accent, &native.cosmic().accent_button] {
@@ -171,7 +179,7 @@ mod tests {
             let mut theme = ferese_config::theme::default_theme();
             theme.tokens.material.style = style.into();
             theme.tokens.material.opacity = opacity;
-            assert_eq!(crate::service::opacity(&theme), expected);
+            assert_eq!(crate::material_opacity(&theme), expected);
         }
     }
 }

crates/ferese-theme/src/presets.rs

@@ -1 +0,0 @@
-pub use ferese_config::presets::{PRESETS, Preset};

crates/ferese-theme/src/service.rs

@@ -1,78 +0,0 @@
-use cosmic::iced::futures::SinkExt;
-use ferese_ipc::theme::Snapshot;
-
-pub fn current() -> Snapshot {
-    ferese_ipc::theme::Connection::connect()
-        .ok()
-        .and_then(|mut connection| connection.get(ferese_config::families::builtins).ok())
-        .unwrap_or_else(fallback)
-}
-
-/// Standalone appearance; it does not represent compositor acceptance.
-pub fn fallback() -> Snapshot {
-    let theme = ferese_config::theme::default_theme();
-    Snapshot {
-        version: ferese_ipc::theme::SCHEMA_VERSION,
-        revision: 0,
-        mode: ferese_config::theme::Mode::Dark,
-        presented: theme.clone(),
-        theme,
-        warnings: Vec::new(),
-        error: None,
-        families: ferese_config::families::builtins(),
-        fallback_note: None,
-    }
-}
-
-pub fn opacity(theme: &ferese_config::theme::ResolvedTheme) -> f32 {
-    if theme.tokens.material.style == "translucent" {
-        theme.tokens.material.opacity as f32
-    } else {
-        1.
-    }
-}
-
-pub fn subscription() -> cosmic::iced::Subscription<Snapshot> {
-    cosmic::iced::Subscription::run(stream)
-}
-
-fn stream() -> impl cosmic::iced::futures::Stream<Item = Snapshot> {
-    cosmic::iced::stream::channel(1, async |mut output| {
-        loop {
-            let connection = tokio::task::spawn_blocking(ferese_ipc::theme::Connection::connect).await;
-            let Ok(Ok(mut connection)) = connection else {
-                tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-                continue;
-            };
-            let Ok(cancellation) = connection.cancellation() else {
-                return;
-            };
-            let (send, mut receive) = tokio::sync::watch::channel(None);
-            tokio::task::spawn_blocking(move || {
-                let Ok(mut snapshot) = connection.get(ferese_config::families::builtins) else {
-                    return;
-                };
-                loop {
-                    let revision = snapshot.revision;
-                    if send.send(Some(snapshot)).is_err() {
-                        return;
-                    }
-                    match connection.watch(revision, ferese_config::families::builtins) {
-                        Ok(next) => snapshot = next,
-                        Err(_) => return,
-                    }
-                }
-            });
-            while receive.changed().await.is_ok() {
-                let snapshot = receive.borrow_and_update().clone();
-                if let Some(snapshot) = snapshot
-                    && output.send(snapshot).await.is_err()
-                {
-                    return;
-                }
-            }
-            drop(cancellation);
-            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-        }
-    })
-}