monolith

public

Star0

Fork 0

Watch0

62 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `17d5669ab74b`

tarball

atagen <boss@atagen.co>2026-10-17 01:18 UTC

5 files changed+437-0

monolith: support foreign toplevel list and management

Bars and taskbars need the window list to show titles and the focused window. wlr-foreign-toplevel-management is written here, since smithay only ships the read-only ext list, and it diffs snapshots like ext-workspace. Activating a window on a hidden tag views that tag alongside the current ones rather than switching away from them. Minimize requests are ignored, since tags have no minimized state.

Modified file: crates/monolith/src/main.rs+1

@@ -16,6 +16,7 @@ mod lock;

1616 mod nested;

1717 mod scene;

1818 mod state;

19+mod toplevels;

1920 mod xwayland;

2021

2122 #[cfg(feature = "spans")]

Modified file: crates/monolith/src/state.rs+11 additions@@ -84,6 +84,9 @@ pub struct State {
     pub ipc: crate::ipc::Server,
     pub launches: crate::launch::Launches,
     pub workspaces: WorkspaceState,
+    pub foreign_toplevels: monolith_protocols::toplevel::ForeignToplevelState,
+    pub toplevel_list: smithay::wayland::foreign_toplevel_list::ForeignToplevelListState,
+    pub list_handles: crate::toplevels::ListHandles,
     pub anim: Animator,
     pub borders: crate::scene::Borders,
     /// How each shown window was placed by the last layout pass, to spot
@@ -208,6 +211,13 @@ impl State {
             ipc: crate::ipc::Server::default(),
             launches: Default::default(),
             workspaces: WorkspaceState::new::<State>(&dh),
+            foreign_toplevels: monolith_protocols::toplevel::ForeignToplevelState::new::<State>(
+                &dh,
+            ),
+            toplevel_list: smithay::wayland::foreign_toplevel_list::ForeignToplevelListState::new::<
+                State,
+            >(&dh),
+            list_handles: Default::default(),
             anim: Animator::new(animation),
             borders: Default::default(),
             last_kind: HashMap::new(),
@@ -269,6 +279,7 @@ impl State {
         self.complete_captures();
         crate::ipc::broadcast(self);
         self.publish_workspaces();
+        self.publish_toplevels();
         let _ = self.display.flush_clients();
     }
 

Added file: crates/monolith/src/toplevels.rs+136 additions@@ -0,0 +1,136 @@
+//! Window lists for other clients: ext-foreign-toplevel-list for listing,
+//! and wlr-foreign-toplevel-management for taskbars that also act on them.
+
+use crate::state::{State, identity};
+use monolith_layout::WindowId;
+use monolith_protocols::toplevel::{
+    Action, ForeignToplevelHandler, ForeignToplevelState, Snapshot, Toplevel,
+};
+use smithay::wayland::foreign_toplevel_list::{
+    ForeignToplevelHandle, ForeignToplevelListHandler, ForeignToplevelListState,
+};
+use std::collections::HashMap;
+
+#[derive(Default)]
+pub struct ListHandles(HashMap<WindowId, ForeignToplevelHandle>);
+
+pub fn key(id: WindowId) -> u64 {
+    slotmap::Key::data(&id).as_ffi()
+}
+
+impl ForeignToplevelListHandler for State {
+    fn foreign_toplevel_list_state(&mut self) -> &mut ForeignToplevelListState {
+        &mut self.toplevel_list
+    }
+}
+
+impl ForeignToplevelHandler for State {
+    fn foreign_toplevel_state(&mut self) -> &mut ForeignToplevelState {
+        &mut self.foreign_toplevels
+    }
+
+    fn foreign_toplevel_action(&mut self, action: Action) {
+        let id_of = |k: u64| self.windows.keys().copied().find(|&id| key(id) == k);
+        match action {
+            Action::Activate(k) => {
+                let Some(id) = id_of(k) else { return };
+                if !self.layout.visible(id)
+                    && let Some(w) = self.layout.window(id)
+                    && let Some(o) = w.output
+                    && w.scratchpad.is_none()
+                {
+                    let tag = w.tag;
+                    self.layout.toggle_view(o, tag);
+                }
+                self.layout.focus(id);
+            }
+            Action::Close(k) => {
+                let Some(window) = id_of(k).and_then(|id| self.windows.get(&id)) else {
+                    return;
+                };
+                match (window.toplevel(), window.x11_surface()) {
+                    (Some(t), _) => t.send_close(),
+                    (_, Some(x)) => {
+                        let _ = x.close();
+                    }
+                    _ => {}
+                }
+                return;
+            }
+            Action::Maximize(k, on) => {
+                let Some(id) = id_of(k) else { return };
+                if self.layout.maximized(id) != on {
+                    self.layout.focus(id);
+                    self.layout.expand(monolith_layout::ExpandScope::All);
+                }
+            }
+            Action::Fullscreen(k, on) => {
+                let Some(id) = id_of(k) else { return };
+                if self.layout.window(id).is_some_and(|w| w.fullscreen != on) {
+                    self.layout.toggle_fullscreen(id);
+                }
+            }
+        }
+        self.apply_layout();
+    }
+}
+
+impl State {
+    /// Brings both window lists in line with the windows.
+    pub fn publish_toplevels(&mut self) {
+        let mut handles = std::mem::take(&mut self.list_handles.0);
+        handles.retain(|id, h| {
+            let keep = self.windows.contains_key(id);
+            if !keep {
+                self.toplevel_list.remove_toplevel(h);
+            }
+            keep
+        });
+        for (id, window) in &self.windows {
+            let (app_id, title) = identity(window);
+            match handles.get(id) {
+                Some(h) => {
+                    if h.title() != title || h.app_id() != app_id {
+                        h.send_title(&title);
+                        h.send_app_id(&app_id);
+                        h.send_done();
+                    }
+                }
+                None => {
+                    let h = self.toplevel_list.new_toplevel::<State>(title, app_id);
+                    handles.insert(*id, h);
+                }
+            }
+        }
+        self.list_handles.0 = handles;
+
+        if !self.foreign_toplevels.has_clients() {
+            return;
+        }
+        let focused = self.layout.focused();
+        let toplevels = self
+            .windows
+            .iter()
+            .map(|(&id, window)| {
+                let (app_id, title) = identity(window);
+                let w = self.layout.window(id);
+                Toplevel {
+                    key: key(id),
+                    title,
+                    app_id,
+                    outputs: w
+                        .and_then(|w| w.output)
+                        .and_then(|o| self.smithay_output(o))
+                        .into_iter()
+                        .collect(),
+                    activated: focused == Some(id),
+                    maximized: self.layout.maximized(id),
+                    fullscreen: w.is_some_and(|w| w.fullscreen),
+                }
+            })
+            .collect();
+        let dh = self.display.clone();
+        self.foreign_toplevels
+            .update::<State>(&dh, Snapshot { toplevels });
+    }
+}

Modified file: crates/protocols/src/lib.rs+1

@@ -1,3 +1,4 @@

11 //! Wayland protocols monolith implements itself.

3+pub mod toplevel;

34 pub mod workspace;

Added file: crates/protocols/src/toplevel.rs+288 additions@@ -0,0 +1,288 @@
+//! wlr-foreign-toplevel-management-v1, for taskbars and window titles in
+//! bars. Like ext-workspace, the compositor publishes a snapshot of its
+//! windows and each client is sent the difference from what it has seen.
+
+use smithay::output::Output;
+use smithay::reexports::wayland_protocols_wlr::foreign_toplevel::v1::server::{
+    zwlr_foreign_toplevel_handle_v1::{self, ZwlrForeignToplevelHandleV1},
+    zwlr_foreign_toplevel_manager_v1::{self, ZwlrForeignToplevelManagerV1},
+};
+use smithay::reexports::wayland_server::backend::{ClientId, GlobalId};
+use smithay::reexports::wayland_server::protocol::wl_output::WlOutput;
+use smithay::reexports::wayland_server::{
+    Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New, Resource,
+};
+use smithay::wayland::{Dispatch2, GlobalDispatch2};
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Snapshot {
+    pub toplevels: Vec<Toplevel>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Toplevel {
+    /// Stable for the window's lifetime.
+    pub key: u64,
+    pub title: String,
+    pub app_id: String,
+    pub outputs: Vec<Output>,
+    pub activated: bool,
+    pub maximized: bool,
+    pub fullscreen: bool,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Action {
+    Activate(u64),
+    Close(u64),
+    Maximize(u64, bool),
+    Fullscreen(u64, bool),
+}
+
+pub trait ForeignToplevelHandler {
+    fn foreign_toplevel_state(&mut self) -> &mut ForeignToplevelState;
+    fn foreign_toplevel_action(&mut self, action: Action);
+}
+
+struct Sent {
+    handle: ZwlrForeignToplevelHandleV1,
+    last: Toplevel,
+    outputs: Vec<WlOutput>,
+}
+
+struct Manager {
+    handle: ZwlrForeignToplevelManagerV1,
+    toplevels: Vec<Sent>,
+}
+
+pub struct ForeignToplevelState {
+    global: GlobalId,
+    managers: Vec<Manager>,
+    snapshot: Snapshot,
+}
+
+pub struct ManagerGlobal;
+
+pub struct ManagerData;
+
+pub struct HandleData {
+    key: u64,
+}
+
+impl ForeignToplevelState {
+    pub fn new<D>(dh: &DisplayHandle) -> Self
+    where
+        D: GlobalDispatch<ZwlrForeignToplevelManagerV1, ManagerGlobal> + 'static,
+    {
+        Self {
+            global: dh.create_global::<D, ZwlrForeignToplevelManagerV1, _>(3, ManagerGlobal),
+            managers: Vec::new(),
+            snapshot: Snapshot::default(),
+        }
+    }
+
+    pub fn global(&self) -> GlobalId {
+        self.global.clone()
+    }
+
+    pub fn has_clients(&self) -> bool {
+        !self.managers.is_empty()
+    }
+
+    pub fn update<D>(&mut self, dh: &DisplayHandle, snapshot: Snapshot)
+    where
+        D: Dispatch<ZwlrForeignToplevelHandleV1, HandleData> + 'static,
+    {
+        self.snapshot = snapshot;
+        self.managers.retain(|m| m.handle.is_alive());
+        for m in &mut self.managers {
+            sync::<D>(dh, m, &self.snapshot);
+        }
+    }
+}
+
+fn sync<D>(dh: &DisplayHandle, m: &mut Manager, snap: &Snapshot)
+where
+    D: Dispatch<ZwlrForeignToplevelHandleV1, HandleData> + 'static,
+{
+    let Ok(client) = dh.get_client(m.handle.id()) else {
+        return;
+    };
+    m.toplevels.retain(|t| {
+        let keep = snap.toplevels.iter().any(|s| s.key == t.last.key);
+        if !keep {
+            t.handle.closed();
+        }
+        keep
+    });
+    for top in &snap.toplevels {
+        let i = match m.toplevels.iter().position(|t| t.last.key == top.key) {
+            Some(i) => i,
+            None => {
+                let Ok(handle) = client.create_resource::<ZwlrForeignToplevelHandleV1, _, D>(
+                    dh,
+                    m.handle.version(),
+                    HandleData { key: top.key },
+                ) else {
+                    continue;
+                };
+                m.handle.toplevel(&handle);
+                send_props(&handle, None, top);
+                m.toplevels.push(Sent {
+                    handle,
+                    last: top.clone(),
+                    outputs: Vec::new(),
+                });
+                let sent = m.toplevels.last_mut().expect("just pushed");
+                sync_outputs(&client, sent, top);
+                sent.handle.done();
+                continue;
+            }
+        };
+        let sent = &mut m.toplevels[i];
+        let mut changed = sync_outputs(&client, sent, top);
+        if sent.last != *top {
+            send_props(&sent.handle, Some(&sent.last), top);
+            sent.last = top.clone();
+            changed = true;
+        }
+        if changed {
+            sent.handle.done();
+        }
+    }
+}
+
+/// Sends output enter and leave for the client's wl_outputs. Returns
+/// whether anything was sent.
+fn sync_outputs(client: &Client, sent: &mut Sent, top: &Toplevel) -> bool {
+    let want: Vec<WlOutput> = top
+        .outputs
+        .iter()
+        .flat_map(|o| o.client_outputs(client))
+        .collect();
+    let mut changed = false;
+    sent.outputs.retain(|o| {
+        let keep = o.is_alive() && want.contains(o);
+        if !keep && o.is_alive() {
+            sent.handle.output_leave(o);
+            changed = true;
+        }
+        keep
+    });
+    for wl in want {
+        if !sent.outputs.contains(&wl) {
+            sent.handle.output_enter(&wl);
+            sent.outputs.push(wl);
+            changed = true;
+        }
+    }
+    changed
+}
+
+fn send_props(h: &ZwlrForeignToplevelHandleV1, old: Option<&Toplevel>, new: &Toplevel) {
+    if old.is_none_or(|o| o.title != new.title) {
+        h.title(new.title.clone());
+    }
+    if old.is_none_or(|o| o.app_id != new.app_id) {
+        h.app_id(new.app_id.clone());
+    }
+    let states = |t: &Toplevel| {
+        let mut s: Vec<u32> = Vec::new();
+        if t.maximized {
+            s.push(zwlr_foreign_toplevel_handle_v1::State::Maximized as u32);
+        }
+        if t.activated {
+            s.push(zwlr_foreign_toplevel_handle_v1::State::Activated as u32);
+        }
+        if t.fullscreen && h.version() >= 2 {
+            s.push(zwlr_foreign_toplevel_handle_v1::State::Fullscreen as u32);
+        }
+        s
+    };
+    if old.is_none_or(|o| states(o) != states(new)) {
+        h.state(states(new).iter().flat_map(|s| s.to_ne_bytes()).collect());
+    }
+}
+
+impl<D> GlobalDispatch2<ZwlrForeignToplevelManagerV1, D> for ManagerGlobal
+where
+    D: ForeignToplevelHandler
+        + Dispatch<ZwlrForeignToplevelManagerV1, ManagerData>
+        + Dispatch<ZwlrForeignToplevelHandleV1, HandleData>
+        + 'static,
+{
+    fn bind(
+        &self,
+        state: &mut D,
+        dh: &DisplayHandle,
+        _client: &Client,
+        resource: New<ZwlrForeignToplevelManagerV1>,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        let handle = data_init.init(resource, ManagerData);
+        let s = state.foreign_toplevel_state();
+        let mut m = Manager {
+            handle,
+            toplevels: Vec::new(),
+        };
+        sync::<D>(dh, &mut m, &s.snapshot);
+        s.managers.push(m);
+    }
+}
+
+impl<D: ForeignToplevelHandler> Dispatch2<ZwlrForeignToplevelManagerV1, D> for ManagerData {
+    fn request(
+        &self,
+        state: &mut D,
+        _client: &Client,
+        resource: &ZwlrForeignToplevelManagerV1,
+        request: zwlr_foreign_toplevel_manager_v1::Request,
+        _dh: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        if let zwlr_foreign_toplevel_manager_v1::Request::Stop = request {
+            resource.finished();
+            state
+                .foreign_toplevel_state()
+                .managers
+                .retain(|m| m.handle != *resource);
+        }
+    }
+
+    fn destroyed(&self, state: &mut D, _client: ClientId, resource: &ZwlrForeignToplevelManagerV1) {
+        state
+            .foreign_toplevel_state()
+            .managers
+            .retain(|m| m.handle != *resource);
+    }
+}
+
+impl<D: ForeignToplevelHandler> Dispatch2<ZwlrForeignToplevelHandleV1, D> for HandleData {
+    fn request(
+        &self,
+        state: &mut D,
+        _client: &Client,
+        _resource: &ZwlrForeignToplevelHandleV1,
+        request: zwlr_foreign_toplevel_handle_v1::Request,
+        _dh: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        use zwlr_foreign_toplevel_handle_v1::Request;
+        let action = match request {
+            Request::Activate { .. } => Action::Activate(self.key),
+            Request::Close => Action::Close(self.key),
+            Request::SetMaximized => Action::Maximize(self.key, true),
+            Request::UnsetMaximized => Action::Maximize(self.key, false),
+            Request::SetFullscreen { .. } => Action::Fullscreen(self.key, true),
+            Request::UnsetFullscreen => Action::Fullscreen(self.key, false),
+            _ => return,
+        };
+        state.foreign_toplevel_action(action);
+    }
+
+    fn destroyed(&self, state: &mut D, _client: ClientId, resource: &ZwlrForeignToplevelHandleV1) {
+        for m in &mut state.foreign_toplevel_state().managers {
+            m.toplevels.retain(|t| t.handle != *resource);
+        }
+    }
+}

monolith

Commit 17d5669ab74b

Commit `17d5669ab74b`