monolith

public

Star0

Fork 0

Watch0

16 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `a1a05e799a71`

tarball

atagen <boss@atagen.co>2026-10-16 10:21 UTC

9 files changed+676-0

protocols: serve ext-workspace from layout snapshots

The compositor publishes a full snapshot and each client is sent only the difference from what it last saw. That keeps tag and view bookkeeping out of the protocol code, and wl_outputs bound after the manager are picked up without an extra hook. Activating a workspace views its tag alone, matching what a bar click means. Floating windows also become movable and resizable with Mod and the mouse.

Modified file: Cargo.lock+3 additions@@ -398,6 +398,7 @@ dependencies = [
  "monolith-config",
  "monolith-ipc",
  "monolith-layout",
+ "monolith-protocols",
  "monolith-render-vk",
  "serde_json",
  "slotmap",
@@ -454,6 +455,8 @@ name = "monolith-protocols"
 version = "0.0.0"
 dependencies = [
  "smithay",
+ "wayland-client",
+ "wayland-protocols",
 ]
 
 [[package]]

Modified file: crates/monolith/Cargo.toml+1

@@ -16,6 +16,7 @@ calloop-wayland-source = "0.4"

1616 monolith-config.workspace = true

1717 monolith-ipc.workspace = true

1818 monolith-layout.workspace = true

19+monolith-protocols.workspace = true

1920 monolith-render-vk.workspace = true

2021 serde_json.workspace = true

2122 slotmap.workspace = true

Modified file: crates/monolith/src/handlers.rs+36 additions@@ -27,6 +27,7 @@ use smithay::wayland::shell::xdg::decoration::XdgDecorationHandler;
 use smithay::wayland::shell::xdg::{
     PopupSurface, PositionerState, ToplevelSurface, XdgShellHandler, XdgShellState,
 };
+use monolith_protocols::workspace::{Action, WorkspaceHandler, WorkspaceState};
 use smithay::wayland::shm::{ShmHandler, ShmState};
 
 impl CompositorHandler for State {
@@ -245,3 +246,38 @@ impl State {
         }
     }
 }
+
+impl WorkspaceHandler for State {
+    fn workspace_state(&mut self) -> &mut WorkspaceState {
+        &mut self.workspaces
+    }
+
+    fn workspace_actions(&mut self, actions: Vec<Action>) {
+        for action in actions {
+            let (group, tag) = match &action {
+                Action::Activate { group, workspace } | Action::Deactivate { group, workspace } => {
+                    (group, workspace)
+                }
+                Action::Create { group, name } => (group, name),
+            };
+            let Some(o) = self
+                .layout
+                .outputs()
+                .find(|(_, out)| out.name == *group)
+                .map(|(o, _)| o)
+            else {
+                continue;
+            };
+            let t = self.layout.tag(tag);
+            match action {
+                Action::Activate { .. } | Action::Create { .. } => self.layout.view(o, t),
+                Action::Deactivate { .. } => {
+                    if self.layout.is_viewed(o, t) {
+                        self.layout.toggle_view(o, t);
+                    }
+                }
+            }
+        }
+        self.apply_layout();
+    }
+}

Modified file: crates/monolith/src/input.rs+80 additions@@ -1,9 +1,12 @@
 //! Host input forwarded into monolith's seat.
 
 use crate::state::State;
+use monolith_config::Modifier;
+use monolith_layout::{Rect, WindowId};
 use smithay::backend::input::{Axis, ButtonState, InputTime, KeyState};
 use smithay::input::keyboard::{FilterResult, Keycode};
 use smithay::input::pointer::{AxisFrame, ButtonEvent, MotionEvent};
+use smithay::utils::Logical;
 use smithay::utils::{Point, SERIAL_COUNTER};
 use wayland_client::protocol::{wl_keyboard, wl_pointer, wl_seat};
 use wayland_client::{Connection, Dispatch, QueueHandle, WEnum};
@@ -59,6 +62,9 @@ impl Dispatch<wl_pointer::WlPointer, ()> for State {
                 if let Some(host) = state.host.as_mut() {
                     host.pointer_pos = pos;
                 }
+                if drag_to(state, pos) {
+                    return;
+                }
                 let under = state.surface_under(pos);
                 pointer.motion(
                     state,
@@ -80,8 +86,14 @@ impl Dispatch<wl_pointer::WlPointer, ()> for State {
                     wl_pointer::ButtonState::Pressed => ButtonState::Pressed,
                     _ => ButtonState::Released,
                 };
+                if button_state == ButtonState::Released && state.drag.take().is_some() {
+                    return;
+                }
                 if button_state == ButtonState::Pressed {
                     focus_under_pointer(state);
+                    if start_drag(state, button) {
+                        return;
+                    }
                 }
                 pointer.button(
                     state,
@@ -184,3 +196,71 @@ fn focus_under_pointer(state: &mut State) {
         state.apply_layout();
     }
 }
+
+const BTN_LEFT: u32 = 0x110;
+const BTN_RIGHT: u32 = 0x111;
+
+/// A floating window being moved or resized with Mod and a mouse button.
+pub struct Drag {
+    window: WindowId,
+    from: Point<f64, Logical>,
+    rect: Rect,
+    resize: bool,
+}
+
+fn start_drag(state: &mut State, button: u32) -> bool {
+    if button != BTN_LEFT && button != BTN_RIGHT {
+        return false;
+    }
+    let held = state
+        .seat
+        .get_keyboard()
+        .map(|k| k.modifier_state())
+        .is_some_and(|m| match state.config.general.mod_key {
+            Modifier::Super => m.logo,
+            Modifier::Alt => m.alt,
+            Modifier::Ctrl => m.ctrl,
+            Modifier::Shift => m.shift,
+        });
+    let Some(from) = state.host.as_ref().map(|h| h.pointer_pos) else {
+        return false;
+    };
+    let Some(id) = state.layout.focused() else {
+        return false;
+    };
+    let Some(rect) = state
+        .layout
+        .window(id)
+        .filter(|w| w.floating && !w.fullscreen)
+        .and_then(|w| w.float_rect)
+    else {
+        return false;
+    };
+    if !held {
+        return false;
+    }
+    state.drag = Some(Drag {
+        window: id,
+        from,
+        rect,
+        resize: button == BTN_RIGHT,
+    });
+    true
+}
+
+fn drag_to(state: &mut State, pos: Point<f64, Logical>) -> bool {
+    let Some(d) = &state.drag else {
+        return false;
+    };
+    let (dx, dy) = (pos.x - d.from.x, pos.y - d.from.y);
+    let r = d.rect;
+    let rect = if d.resize {
+        Rect::new(r.x, r.y, (r.w + dx).max(32.0), (r.h + dy).max(32.0))
+    } else {
+        Rect::new(r.x + dx, r.y + dy, r.w, r.h)
+    };
+    let id = d.window;
+    state.layout.set_float_rect(id, rect);
+    state.apply_layout();
+    true
+}

Modified file: crates/monolith/src/state.rs+39 additions@@ -2,6 +2,7 @@ use crate::commands::Binds;
 use crate::nested::Host;
 use monolith_config::Config;
 use monolith_layout::{Layout, OutputId, Rect, WindowId};
+use monolith_protocols::workspace::{Group, Snapshot, Workspace, WorkspaceState};
 use monolith_render_vk::VulkanRenderer;
 use smithay::backend::renderer::ImportDma;
 use smithay::desktop::{PopupManager, Space, Window, WindowSurfaceType};
@@ -49,8 +50,10 @@ pub struct State {
     pub config_path: Option<PathBuf>,
     pub binds: Binds,
     pub suppressed: Vec<Keycode>,
+    pub drag: Option<crate::input::Drag>,
     pub ipc: crate::ipc::Server,
     pub launches: crate::launch::Launches,
+    pub workspaces: WorkspaceState,
 
     pub compositor_state: CompositorState,
     pub xdg_shell_state: XdgShellState,
@@ -124,8 +127,10 @@ impl State {
             config_path,
             binds,
             suppressed: Vec::new(),
+            drag: None,
             ipc: crate::ipc::Server::default(),
             launches: Default::default(),
+            workspaces: WorkspaceState::new::<State>(&dh),
             compositor_state: CompositorState::new::<State>(&dh),
             xdg_shell_state: XdgShellState::new::<State>(&dh),
             _xdg_decoration_state: XdgDecorationState::new::<State>(&dh),
@@ -146,6 +151,7 @@ impl State {
         self.popups.cleanup();
         crate::nested::render(self);
         crate::ipc::broadcast(self);
+        self.publish_workspaces();
         let _ = self.display.flush_clients();
     }
 
@@ -286,6 +292,39 @@ impl State {
         }
     }
 
+    fn publish_workspaces(&mut self) {
+        if !self.workspaces.has_clients() {
+            return;
+        }
+        let l = &self.layout;
+        let groups = l
+            .outputs()
+            .filter_map(|(o, _)| {
+                let output = self
+                    .host
+                    .as_ref()
+                    .filter(|_| Some(o) == self.output_id)?
+                    .output
+                    .clone();
+                let workspaces = l
+                    .tags()
+                    .enumerate()
+                    .map(|(i, (t, tag))| Workspace {
+                        key: tag.name.clone(),
+                        name: tag.name.clone(),
+                        coordinates: vec![i as u32],
+                        active: l.is_viewed(o, t),
+                        urgent: tag.urgent,
+                        hidden: false,
+                    })
+                    .collect();
+                Some(Group { output, workspaces })
+            })
+            .collect();
+        let dh = self.display.clone();
+        self.workspaces.update::<State>(&dh, Snapshot { groups });
+    }
+
     pub fn reconfigure_keyboard(&mut self) {
         let kb = self.config.keyboard.clone();
         if let Some(keyboard) = self.seat.get_keyboard() {

Modified file: crates/protocols/Cargo.toml+4

@@ -10,3 +10,7 @@ workspace = true

1010

1111 [dependencies]

1212 smithay.workspace = true

13+

14+[dev-dependencies]

15+wayland-client = "0.31"

16+wayland-protocols = { version = "0.32", features = ["client", "staging"] }

Added file: crates/protocols/examples/workspaces.rs+114 additions@@ -0,0 +1,114 @@
+//! Prints ext-workspace events from the compositor on $WAYLAND_DISPLAY.
+//! `workspaces activate <name>` activates a workspace and exits.
+
+use wayland_client::globals::{GlobalListContents, registry_queue_init};
+use wayland_client::protocol::{wl_output, wl_registry};
+use wayland_client::{Connection, Dispatch, Proxy, QueueHandle, event_created_child};
+use wayland_protocols::ext::workspace::v1::client::{
+    ext_workspace_group_handle_v1 as group, ext_workspace_handle_v1 as ws,
+    ext_workspace_manager_v1 as manager,
+};
+
+#[derive(Default)]
+struct App {
+    names: Vec<(ws::ExtWorkspaceHandleV1, String)>,
+}
+
+fn main() {
+    let target = std::env::args().nth(2);
+    let conn = Connection::connect_to_env().expect("no compositor");
+    let (globals, mut queue) = registry_queue_init::<App>(&conn).unwrap();
+    let qh = queue.handle();
+    let _output: wl_output::WlOutput = globals.bind(&qh, 1..=4, ()).unwrap();
+    let m: manager::ExtWorkspaceManagerV1 = globals.bind(&qh, 1..=1, ()).unwrap();
+    let mut app = App::default();
+    queue.roundtrip(&mut app).unwrap();
+    queue.roundtrip(&mut app).unwrap();
+    if let Some(name) = target {
+        if let Some((h, _)) = app.names.iter().find(|(_, n)| *n == name) {
+            h.activate();
+            m.commit();
+            queue.roundtrip(&mut app).unwrap();
+            queue.roundtrip(&mut app).unwrap();
+        }
+        return;
+    }
+    loop {
+        queue.blocking_dispatch(&mut app).unwrap();
+    }
+}
+
+impl Dispatch<wl_registry::WlRegistry, GlobalListContents> for App {
+    fn event(
+        _: &mut Self,
+        _: &wl_registry::WlRegistry,
+        _: wl_registry::Event,
+        _: &GlobalListContents,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+    }
+}
+
+impl Dispatch<wl_output::WlOutput, ()> for App {
+    fn event(
+        _: &mut Self,
+        _: &wl_output::WlOutput,
+        _: wl_output::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+    }
+}
+
+impl Dispatch<manager::ExtWorkspaceManagerV1, ()> for App {
+    fn event(
+        _: &mut Self,
+        _: &manager::ExtWorkspaceManagerV1,
+        event: manager::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        match event {
+            manager::Event::WorkspaceGroup { .. } => println!("group"),
+            manager::Event::Workspace { .. } => println!("workspace"),
+            e => println!("manager {e:?}"),
+        }
+    }
+
+    event_created_child!(App, manager::ExtWorkspaceManagerV1, [
+        manager::EVT_WORKSPACE_GROUP_OPCODE => (group::ExtWorkspaceGroupHandleV1, ()),
+        manager::EVT_WORKSPACE_OPCODE => (ws::ExtWorkspaceHandleV1, ()),
+    ]);
+}
+
+impl Dispatch<group::ExtWorkspaceGroupHandleV1, ()> for App {
+    fn event(
+        _: &mut Self,
+        _: &group::ExtWorkspaceGroupHandleV1,
+        event: group::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        println!("  group {event:?}");
+    }
+}
+
+impl Dispatch<ws::ExtWorkspaceHandleV1, ()> for App {
+    fn event(
+        app: &mut Self,
+        h: &ws::ExtWorkspaceHandleV1,
+        event: ws::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        if let ws::Event::Name { name } = &event {
+            app.names.push((h.clone(), name.clone()));
+        }
+        println!("  workspace {:?} {event:?}", h.id().protocol_id());
+    }
+}

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

@@ -1 +1,3 @@

1+//! Wayland protocols monolith implements itself.

3+pub mod workspace;

Added file: crates/protocols/src/workspace.rs+397 additions@@ -0,0 +1,397 @@
+//! ext-workspace-v1. The compositor publishes a snapshot of groups and
+//! workspaces, and this module sends each client the difference from what
+//! it has already seen. Client requests are queued until `commit` and then
+//! handed over as one batch.
+
+use smithay::output::Output;
+use smithay::reexports::wayland_protocols::ext::workspace::v1::server::{
+    ext_workspace_group_handle_v1::{self, ExtWorkspaceGroupHandleV1, GroupCapabilities},
+    ext_workspace_handle_v1::{self, ExtWorkspaceHandleV1, WorkspaceCapabilities},
+    ext_workspace_manager_v1::{self, ExtWorkspaceManagerV1},
+};
+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};
+use std::sync::Mutex;
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Snapshot {
+    pub groups: Vec<Group>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Group {
+    pub output: Output,
+    pub workspaces: Vec<Workspace>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Workspace {
+    /// Unique within its group, and reported to clients as the stable id.
+    pub key: String,
+    pub name: String,
+    pub coordinates: Vec<u32>,
+    pub active: bool,
+    pub urgent: bool,
+    pub hidden: bool,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Action {
+    Activate { group: String, workspace: String },
+    Deactivate { group: String, workspace: String },
+    Create { group: String, name: String },
+}
+
+pub trait WorkspaceHandler {
+    fn workspace_state(&mut self) -> &mut WorkspaceState;
+    fn workspace_actions(&mut self, actions: Vec<Action>);
+}
+
+struct SentGroup {
+    name: String,
+    handle: ExtWorkspaceGroupHandleV1,
+    outputs: Vec<WlOutput>,
+}
+
+struct SentWorkspace {
+    group: String,
+    handle: ExtWorkspaceHandleV1,
+    last: Workspace,
+}
+
+struct Manager {
+    handle: ExtWorkspaceManagerV1,
+    groups: Vec<SentGroup>,
+    workspaces: Vec<SentWorkspace>,
+}
+
+pub struct WorkspaceState {
+    global: GlobalId,
+    managers: Vec<Manager>,
+    snapshot: Snapshot,
+}
+
+pub struct ManagerGlobal;
+
+#[derive(Default)]
+pub struct ManagerData {
+    pending: Mutex<Vec<Action>>,
+}
+
+pub struct GroupData {
+    manager: ExtWorkspaceManagerV1,
+    group: String,
+}
+
+pub struct WorkspaceData {
+    manager: ExtWorkspaceManagerV1,
+    group: String,
+    key: String,
+}
+
+impl WorkspaceState {
+    pub fn new<D>(dh: &DisplayHandle) -> Self
+    where
+        D: GlobalDispatch<ExtWorkspaceManagerV1, ManagerGlobal> + 'static,
+    {
+        Self {
+            global: dh.create_global::<D, ExtWorkspaceManagerV1, _>(1, 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()
+    }
+
+    /// Publishes a snapshot. Clients only hear about differences, including
+    /// wl_outputs they bound after the manager.
+    pub fn update<D>(&mut self, dh: &DisplayHandle, snapshot: Snapshot)
+    where
+        D: Dispatch<ExtWorkspaceGroupHandleV1, GroupData>
+            + Dispatch<ExtWorkspaceHandleV1, WorkspaceData>
+            + '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<ExtWorkspaceGroupHandleV1, GroupData>
+        + Dispatch<ExtWorkspaceHandleV1, WorkspaceData>
+        + 'static,
+{
+    let Ok(client) = dh.get_client(m.handle.id()) else {
+        return;
+    };
+    let mut changed = false;
+
+    let gone: Vec<String> = m
+        .groups
+        .iter()
+        .filter(|g| !snap.groups.iter().any(|s| s.output.name() == g.name))
+        .map(|g| g.name.clone())
+        .collect();
+    m.workspaces.retain(|w| {
+        let in_snap = snap
+            .groups
+            .iter()
+            .find(|g| g.output.name() == w.group)
+            .is_some_and(|g| g.workspaces.iter().any(|s| s.key == w.last.key));
+        if !in_snap {
+            if let Some(g) = m.groups.iter().find(|g| g.name == w.group) {
+                g.handle.workspace_leave(&w.handle);
+            }
+            w.handle.removed();
+            changed = true;
+        }
+        in_snap
+    });
+    m.groups.retain(|g| {
+        let keep = !gone.contains(&g.name);
+        if !keep {
+            g.handle.removed();
+            changed = true;
+        }
+        keep
+    });
+
+    for group in &snap.groups {
+        let name = group.output.name();
+        let idx = match m.groups.iter().position(|g| g.name == name) {
+            Some(i) => i,
+            None => {
+                let Ok(handle) = client.create_resource::<ExtWorkspaceGroupHandleV1, _, D>(
+                    dh,
+                    m.handle.version(),
+                    GroupData {
+                        manager: m.handle.clone(),
+                        group: name.clone(),
+                    },
+                ) else {
+                    continue;
+                };
+                m.handle.workspace_group(&handle);
+                handle.capabilities(GroupCapabilities::CreateWorkspace);
+                m.groups.push(SentGroup {
+                    name: name.clone(),
+                    handle,
+                    outputs: Vec::new(),
+                });
+                changed = true;
+                m.groups.len() - 1
+            }
+        };
+        let sent = &mut m.groups[idx];
+        for wl in group.output.client_outputs(&client) {
+            if !sent.outputs.contains(&wl) {
+                sent.handle.output_enter(&wl);
+                sent.outputs.push(wl);
+                changed = true;
+            }
+        }
+        sent.outputs.retain(|o| o.is_alive());
+
+        for ws in &group.workspaces {
+            match m
+                .workspaces
+                .iter_mut()
+                .find(|w| w.group == name && w.last.key == ws.key)
+            {
+                Some(w) => {
+                    if w.last != *ws {
+                        send_props(&w.handle, Some(&w.last), ws);
+                        w.last = ws.clone();
+                        changed = true;
+                    }
+                }
+                None => {
+                    let Ok(handle) = client.create_resource::<ExtWorkspaceHandleV1, _, D>(
+                        dh,
+                        m.handle.version(),
+                        WorkspaceData {
+                            manager: m.handle.clone(),
+                            group: name.clone(),
+                            key: ws.key.clone(),
+                        },
+                    ) else {
+                        continue;
+                    };
+                    m.handle.workspace(&handle);
+                    handle.id(ws.key.clone());
+                    handle.capabilities(
+                        WorkspaceCapabilities::Activate | WorkspaceCapabilities::Deactivate,
+                    );
+                    send_props(&handle, None, ws);
+                    m.groups[idx].handle.workspace_enter(&handle);
+                    m.workspaces.push(SentWorkspace {
+                        group: name.clone(),
+                        handle,
+                        last: ws.clone(),
+                    });
+                    changed = true;
+                }
+            }
+        }
+    }
+    if changed {
+        m.handle.done();
+    }
+}
+
+fn send_props(h: &ExtWorkspaceHandleV1, old: Option<&Workspace>, new: &Workspace) {
+    if old.is_none_or(|o| o.name != new.name) {
+        h.name(new.name.clone());
+    }
+    if old.is_none_or(|o| o.coordinates != new.coordinates) {
+        let bytes = new
+            .coordinates
+            .iter()
+            .flat_map(|c| c.to_ne_bytes())
+            .collect();
+        h.coordinates(bytes);
+    }
+    let state = |w: &Workspace| {
+        let mut s = ext_workspace_handle_v1::State::empty();
+        s.set(ext_workspace_handle_v1::State::Active, w.active);
+        s.set(ext_workspace_handle_v1::State::Urgent, w.urgent);
+        s.set(ext_workspace_handle_v1::State::Hidden, w.hidden);
+        s
+    };
+    if old.is_none_or(|o| state(o) != state(new)) {
+        h.state(state(new));
+    }
+}
+
+fn queue(manager: &ExtWorkspaceManagerV1, action: Action) {
+    if let Some(data) = manager.data::<ManagerData>() {
+        data.pending
+            .lock()
+            .unwrap_or_else(|e| e.into_inner())
+            .push(action);
+    }
+}
+
+impl<D> GlobalDispatch2<ExtWorkspaceManagerV1, D> for ManagerGlobal
+where
+    D: WorkspaceHandler
+        + Dispatch<ExtWorkspaceManagerV1, ManagerData>
+        + Dispatch<ExtWorkspaceGroupHandleV1, GroupData>
+        + Dispatch<ExtWorkspaceHandleV1, WorkspaceData>
+        + 'static,
+{
+    fn bind(
+        &self,
+        state: &mut D,
+        dh: &DisplayHandle,
+        _client: &Client,
+        resource: New<ExtWorkspaceManagerV1>,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        let handle = data_init.init(resource, ManagerData::default());
+        let ws = state.workspace_state();
+        let mut m = Manager {
+            handle,
+            groups: Vec::new(),
+            workspaces: Vec::new(),
+        };
+        sync::<D>(dh, &mut m, &ws.snapshot);
+        ws.managers.push(m);
+    }
+}
+
+impl<D: WorkspaceHandler> Dispatch2<ExtWorkspaceManagerV1, D> for ManagerData {
+    fn request(
+        &self,
+        state: &mut D,
+        _client: &Client,
+        resource: &ExtWorkspaceManagerV1,
+        request: ext_workspace_manager_v1::Request,
+        _dh: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            ext_workspace_manager_v1::Request::Commit => {
+                let actions =
+                    std::mem::take(&mut *self.pending.lock().unwrap_or_else(|e| e.into_inner()));
+                if !actions.is_empty() {
+                    state.workspace_actions(actions);
+                }
+            }
+            ext_workspace_manager_v1::Request::Stop => {
+                resource.finished();
+                state
+                    .workspace_state()
+                    .managers
+                    .retain(|m| m.handle != *resource);
+            }
+            _ => {}
+        }
+    }
+
+    fn destroyed(&self, state: &mut D, _client: ClientId, resource: &ExtWorkspaceManagerV1) {
+        state
+            .workspace_state()
+            .managers
+            .retain(|m| m.handle != *resource);
+    }
+}
+
+impl<D: WorkspaceHandler> Dispatch2<ExtWorkspaceGroupHandleV1, D> for GroupData {
+    fn request(
+        &self,
+        _state: &mut D,
+        _client: &Client,
+        _resource: &ExtWorkspaceGroupHandleV1,
+        request: ext_workspace_group_handle_v1::Request,
+        _dh: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        if let ext_workspace_group_handle_v1::Request::CreateWorkspace { workspace } = request {
+            queue(
+                &self.manager,
+                Action::Create {
+                    group: self.group.clone(),
+                    name: workspace,
+                },
+            );
+        }
+    }
+}
+
+impl<D: WorkspaceHandler> Dispatch2<ExtWorkspaceHandleV1, D> for WorkspaceData {
+    fn request(
+        &self,
+        _state: &mut D,
+        _client: &Client,
+        _resource: &ExtWorkspaceHandleV1,
+        request: ext_workspace_handle_v1::Request,
+        _dh: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        let (group, workspace) = (self.group.clone(), self.key.clone());
+        match request {
+            ext_workspace_handle_v1::Request::Activate => {
+                queue(&self.manager, Action::Activate { group, workspace });
+            }
+            ext_workspace_handle_v1::Request::Deactivate => {
+                queue(&self.manager, Action::Deactivate { group, workspace });
+            }
+            _ => {}
+        }
+    }
+}

monolith

Commit a1a05e799a71

Commit `a1a05e799a71`