monolith

public

Star0

Fork 0

Watch0

69 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `a772647a949f`

tarball

atagen <boss@atagen.co>2026-10-17 02:45 UTC

17 files changed+233-183

monolith: group protocol globals, core plumbing and settings out of State

State had grown to 70 flat fields, most of them protocol globals that only their own handler touches. They now live in Protocols, the event loop and display in Core, and the config with its path and binds in Settings, which reload can swap as one. First step of the split sketched in design/state-split.md.

Modified file: crates/monolith/src/activation.rs+2 additions−2 deletions@@ -23,7 +23,7 @@ struct Context {
 
 impl XdgActivationHandler for State {
     fn activation_state(&mut self) -> &mut XdgActivationState {
-        &mut self.activation_state
+        &mut self.protocols.activation_state
     }
 
     fn token_created(&mut self, _token: XdgActivationToken, data: XdgActivationTokenData) -> bool {
@@ -86,7 +86,7 @@ impl State {
             tag,
             may_focus: true,
         });
-        let (token, _) = self.activation_state.create_external_token(data);
+        let (token, _) = self.protocols.activation_state.create_external_token(data);
         token.to_string()
     }
 }

Modified file: crates/monolith/src/capture.rs+4 additions−4 deletions@@ -69,7 +69,7 @@ impl ImageCaptureSourceHandler for State {
 
 impl OutputCaptureSourceHandler for State {
     fn output_capture_source_state(&mut self) -> &mut OutputCaptureSourceState {
-        &mut self.output_capture_source_state
+        &mut self.protocols.output_capture_source_state
     }
 
     fn output_source_created(&mut self, source: ImageCaptureSource, output: &Output) {
@@ -79,7 +79,7 @@ impl OutputCaptureSourceHandler for State {
 
 impl ToplevelCaptureSourceHandler for State {
     fn toplevel_capture_source_state(&mut self) -> &mut ToplevelCaptureSourceState {
-        &mut self.toplevel_capture_source_state
+        &mut self.protocols.toplevel_capture_source_state
     }
 
     fn toplevel_source_created(
@@ -95,7 +95,7 @@ impl ToplevelCaptureSourceHandler for State {
 
 impl ImageCopyCaptureHandler for State {
     fn image_copy_capture_state(&mut self) -> &mut ImageCopyCaptureState {
-        &mut self.image_copy_capture_state
+        &mut self.protocols.image_copy_capture_state
     }
 
     fn capture_constraints(&mut self, source: &ImageCaptureSource) -> Option<BufferConstraints> {
@@ -284,7 +284,7 @@ impl State {
                 &self.anim,
                 &mut self.renderer,
                 now,
-                &self.config.decoration,
+                &self.settings.config.decoration,
                 &mut self.borders,
                 Some(output),
                 self.xwayland.as_ref().map_or(&[], |x| &x.unmanaged),

Modified file: crates/monolith/src/commands.rs+7 additions−7 deletions@@ -53,7 +53,7 @@ impl State {
         let output = self.layout.active_output();
         let focused = self.layout.focused();
         let inverted = std::mem::take(&mut self.move_inverted);
-        let merge = (self.config.general.move_mode == MoveMode::Merge) != inverted;
+        let merge = (self.settings.config.general.move_mode == MoveMode::Merge) != inverted;
         let on_focused = |state: &mut Self, f: fn(&mut monolith_layout::Layout, WindowId)| {
             if let Some(w) = focused {
                 f(&mut state.layout, w);
@@ -72,7 +72,7 @@ impl State {
                     }
                 }
             }
-            Command::Quit => self.signal.stop(),
+            Command::Quit => self.core.signal.stop(),
             Command::Reload => self.reload()?,
             Command::Focus { dir: d } => {
                 self.layout.focus_dir(dir(d));
@@ -171,7 +171,7 @@ impl State {
         let (program, args) = argv.split_first().ok_or("nothing to spawn")?;
         let mut cmd = std::process::Command::new(program);
         cmd.args(args)
-            .env("WAYLAND_DISPLAY", &self.socket_name)
+            .env("WAYLAND_DISPLAY", &self.core.socket_name)
             .stdin(Stdio::null());
         if let Some(sock) = &self.ipc.path {
             cmd.env("MONOLITH_SOCKET", sock);
@@ -197,12 +197,12 @@ impl State {
     /// Swaps in a freshly parsed config. A broken file leaves the running
     /// config untouched.
     pub fn reload(&mut self) -> Result<(), String> {
-        let config = Config::load(self.config_path.as_deref()).map_err(|e| e.to_string())?;
-        let keyboard_changed = config.keyboard != self.config.keyboard;
-        self.binds = Binds::new(&config);
+        let config = Config::load(self.settings.path.as_deref()).map_err(|e| e.to_string())?;
+        let keyboard_changed = config.keyboard != self.settings.config.keyboard;
+        self.settings.binds = Binds::new(&config);
         self.layout.gaps = crate::state::gaps(&config);
         self.anim.settings = config.animation.clone();
-        self.config = config;
+        self.settings.config = config;
         if keyboard_changed {
             self.reconfigure_keyboard();
         }

Modified file: crates/monolith/src/drm.rs+11 additions−8 deletions@@ -193,7 +193,10 @@ pub fn init(
         .map(|d| d.name().to_string_lossy().to_lowercase().contains("nvidia"))
         .unwrap_or(false);
     if supports_syncobj_eventfd(&fd) {
-        state.syncobj = Some(DrmSyncobjState::new::<State>(&state.display, fd.clone()));
+        state.syncobj = Some(DrmSyncobjState::new::<State>(
+            &state.core.display,
+            fd.clone(),
+        ));
     } else {
         tracing::info!("no syncobj eventfd support, clients stay on implicit sync");
     }
@@ -335,7 +338,7 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
         renderer,
         layout,
         space,
-        display,
+        core,
         ..
     } = state
     else {
@@ -365,7 +368,7 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
         Some(position),
     );
     output.set_preferred(wl_mode);
-    output.create_global::<State>(display);
+    output.create_global::<State>(&core.display);
     let mut planes = drm.manager.device().planes(&crtc).ok();
     if drm.nvidia
         && let Some(p) = planes.as_mut()
@@ -590,9 +593,9 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
         windows,
         anim,
         borders,
-        config,
+        settings,
         space,
-        start,
+        core,
         cursor,
         cursor_status,
         pointer_pos,
@@ -615,7 +618,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
     }
     surface.cursor_redraw = false;
     let want_vrr = surface.vrr_capable
-        && match config.output.vrr {
+        && match settings.config.output.vrr {
             Vrr::Off => false,
             Vrr::On => true,
             Vrr::Fullscreen => layout.arrange(surface.id).fullscreen.is_some(),
@@ -656,7 +659,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
             anim,
             renderer,
             now,
-            &config.decoration,
+            &settings.config.decoration,
             borders,
             Some(&surface.output),
             xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
@@ -706,7 +709,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
         surface.target_ns = None;
     }
     surface.redraw = animating;
-    let elapsed = start.elapsed();
+    let elapsed = core.start.elapsed();
     let output = surface.output.clone();
     if lock.active() {
         crate::lock::send_frames(lock, &output, elapsed);

Added file: crates/monolith/src/globals.rs+107 additions@@ -0,0 +1,107 @@
+//! The Wayland globals monolith advertises. Most are only touched by their
+//! own handler impl, the rest publish compositor state to clients.
+
+use crate::state::State;
+use monolith_protocols::toplevel::ForeignToplevelState;
+use monolith_protocols::workspace::WorkspaceState;
+use monolith_render_vk::VulkanRenderer;
+use smithay::backend::renderer::ImportDma;
+use smithay::reexports::calloop::LoopHandle;
+use smithay::reexports::wayland_server::DisplayHandle;
+use smithay::wayland::compositor::CompositorState;
+use smithay::wayland::cursor_shape::CursorShapeManagerState;
+use smithay::wayland::dmabuf::{DmabufGlobal, DmabufState};
+use smithay::wayland::foreign_toplevel_list::ForeignToplevelListState;
+use smithay::wayland::idle_inhibit::IdleInhibitManagerState;
+use smithay::wayland::idle_notify::IdleNotifierState;
+use smithay::wayland::image_capture_source::{
+    ImageCaptureSourceState, OutputCaptureSourceState, ToplevelCaptureSourceState,
+};
+use smithay::wayland::image_copy_capture::ImageCopyCaptureState;
+use smithay::wayland::output::OutputManagerState;
+use smithay::wayland::selection::data_device::DataDeviceState;
+use smithay::wayland::selection::ext_data_control::DataControlState as ExtDataControlState;
+use smithay::wayland::selection::primary_selection::PrimarySelectionState;
+use smithay::wayland::selection::wlr_data_control::DataControlState as WlrDataControlState;
+use smithay::wayland::session_lock::SessionLockManagerState;
+use smithay::wayland::shell::wlr_layer::WlrLayerShellState;
+use smithay::wayland::shell::xdg::XdgShellState;
+use smithay::wayland::shell::xdg::decoration::XdgDecorationState;
+use smithay::wayland::shm::ShmState;
+use smithay::wayland::xdg_activation::XdgActivationState;
+use smithay::wayland::xwayland_shell::XWaylandShellState;
+
+pub struct Protocols {
+    pub compositor_state: CompositorState,
+    pub xdg_shell_state: XdgShellState,
+    pub layer_shell_state: WlrLayerShellState,
+    pub output_capture_source_state: OutputCaptureSourceState,
+    pub toplevel_capture_source_state: ToplevelCaptureSourceState,
+    pub image_copy_capture_state: ImageCopyCaptureState,
+    pub activation_state: XdgActivationState,
+    pub primary_selection_state: PrimarySelectionState,
+    pub wlr_data_control_state: WlrDataControlState,
+    pub ext_data_control_state: ExtDataControlState,
+    pub session_lock_state: SessionLockManagerState,
+    pub idle_notifier: IdleNotifierState<State>,
+    pub shm_state: ShmState,
+    pub dmabuf_state: DmabufState,
+    pub data_device_state: DataDeviceState,
+    pub xwayland_shell_state: XWaylandShellState,
+    pub workspaces: WorkspaceState,
+    pub foreign_toplevels: ForeignToplevelState,
+    pub toplevel_list: ForeignToplevelListState,
+    _image_capture_source: ImageCaptureSourceState,
+    _idle_inhibit: IdleInhibitManagerState,
+    _xdg_decoration: XdgDecorationState,
+    _dmabuf_global: DmabufGlobal,
+    _output_manager: OutputManagerState,
+    _cursor_shape: CursorShapeManagerState,
+}
+
+impl Protocols {
+    pub fn new(
+        dh: &DisplayHandle,
+        handle: LoopHandle<'static, State>,
+        renderer: &VulkanRenderer,
+    ) -> Self {
+        let mut dmabuf_state = DmabufState::new();
+        let dmabuf_global = dmabuf_state.create_global::<State>(dh, renderer.dmabuf_formats());
+        let primary_selection_state = PrimarySelectionState::new::<State>(dh);
+        Self {
+            compositor_state: CompositorState::new::<State>(dh),
+            xdg_shell_state: XdgShellState::new::<State>(dh),
+            layer_shell_state: WlrLayerShellState::new::<State>(dh),
+            output_capture_source_state: OutputCaptureSourceState::new::<State>(dh),
+            toplevel_capture_source_state: ToplevelCaptureSourceState::new::<State>(dh),
+            image_copy_capture_state: ImageCopyCaptureState::new::<State>(dh),
+            activation_state: XdgActivationState::new::<State>(dh),
+            wlr_data_control_state: WlrDataControlState::new::<State, _>(
+                dh,
+                Some(&primary_selection_state),
+                |_| true,
+            ),
+            ext_data_control_state: ExtDataControlState::new::<State, _>(
+                dh,
+                Some(&primary_selection_state),
+                |_| true,
+            ),
+            primary_selection_state,
+            session_lock_state: SessionLockManagerState::new::<State, _>(dh, |_| true),
+            idle_notifier: IdleNotifierState::new(dh, handle),
+            shm_state: ShmState::new::<State>(dh, vec![]),
+            dmabuf_state,
+            data_device_state: DataDeviceState::new::<State>(dh),
+            xwayland_shell_state: XWaylandShellState::new::<State>(dh),
+            workspaces: WorkspaceState::new::<State>(dh),
+            foreign_toplevels: ForeignToplevelState::new::<State>(dh),
+            toplevel_list: ForeignToplevelListState::new::<State>(dh),
+            _image_capture_source: ImageCaptureSourceState::new(),
+            _idle_inhibit: IdleInhibitManagerState::new::<State>(dh),
+            _xdg_decoration: XdgDecorationState::new::<State>(dh),
+            _dmabuf_global: dmabuf_global,
+            _output_manager: OutputManagerState::new_with_xdg_output::<State>(dh),
+            _cursor_shape: CursorShapeManagerState::new::<State>(dh),
+        }
+    }
+}

Modified file: crates/monolith/src/handlers.rs+16 additions−16 deletions@@ -41,7 +41,7 @@ use smithay::wayland::shm::{ShmHandler, ShmState};
 
 impl CompositorHandler for State {
     fn compositor_state(&mut self) -> &mut CompositorState {
-        &mut self.compositor_state
+        &mut self.protocols.compositor_state
     }
 
     fn new_surface(&mut self, surface: &WlSurface) {
@@ -116,13 +116,13 @@ impl BufferHandler for State {
 
 impl ShmHandler for State {
     fn shm_state(&self) -> &ShmState {
-        &self.shm_state
+        &self.protocols.shm_state
     }
 }
 
 impl DmabufHandler for State {
     fn dmabuf_state(&mut self) -> &mut DmabufState {
-        &mut self.dmabuf_state
+        &mut self.protocols.dmabuf_state
     }
 
     fn dmabuf_imported(
@@ -137,7 +137,7 @@ impl DmabufHandler for State {
 
 impl XdgShellHandler for State {
     fn xdg_shell_state(&mut self) -> &mut XdgShellState {
-        &mut self.xdg_shell_state
+        &mut self.protocols.xdg_shell_state
     }
 
     fn new_toplevel(&mut self, surface: ToplevelSurface) {
@@ -194,9 +194,9 @@ impl SeatHandler for State {
     fn focus_changed(&mut self, seat: &Seat<Self>, focused: Option<&crate::focus::Focus>) {
         let client = focused
             .and_then(|f| f.wl_surface())
-            .and_then(|s| self.display.get_client(s.id()).ok());
-        set_data_device_focus(&self.display, seat, client.clone());
-        set_primary_focus(&self.display, seat, client);
+            .and_then(|s| self.core.display.get_client(s.id()).ok());
+        set_data_device_focus(&self.core.display, seat, client.clone());
+        set_primary_focus(&self.core.display, seat, client);
     }
 }
 
@@ -206,13 +206,13 @@ impl SelectionHandler for State {
 
 impl DataDeviceHandler for State {
     fn data_device_state(&mut self) -> &mut DataDeviceState {
-        &mut self.data_device_state
+        &mut self.protocols.data_device_state
     }
 }
 
 impl PrimarySelectionHandler for State {
     fn primary_selection_state(&mut self) -> &mut PrimarySelectionState {
-        &mut self.primary_selection_state
+        &mut self.protocols.primary_selection_state
     }
 }
 
@@ -220,7 +220,7 @@ impl smithay::wayland::selection::wlr_data_control::DataControlHandler for State
     fn data_control_state(
         &mut self,
     ) -> &mut smithay::wayland::selection::wlr_data_control::DataControlState {
-        &mut self.wlr_data_control_state
+        &mut self.protocols.wlr_data_control_state
     }
 }
 
@@ -228,7 +228,7 @@ impl smithay::wayland::selection::ext_data_control::DataControlHandler for State
     fn data_control_state(
         &mut self,
     ) -> &mut smithay::wayland::selection::ext_data_control::DataControlState {
-        &mut self.ext_data_control_state
+        &mut self.protocols.ext_data_control_state
     }
 }
 
@@ -310,8 +310,8 @@ fn hold_until_readable(state: &mut State, surface: &WlSurface) {
     if let Some(point) = acquire
         && let Ok((blocker, source)) = point.generate_blocker()
     {
-        let inserted = state.handle.insert_source(source, move |_, _, state| {
-            let dh = state.display.clone();
+        let inserted = state.core.handle.insert_source(source, move |_, _, state| {
+            let dh = state.core.display.clone();
             state
                 .client_compositor_state(&client)
                 .blocker_cleared(state, &dh);
@@ -323,8 +323,8 @@ fn hold_until_readable(state: &mut State, surface: &WlSurface) {
         return;
     }
     if let Ok((blocker, source)) = dmabuf.generate_blocker(Interest::READ) {
-        let inserted = state.handle.insert_source(source, move |_, _, state| {
-            let dh = state.display.clone();
+        let inserted = state.core.handle.insert_source(source, move |_, _, state| {
+            let dh = state.core.display.clone();
             state
                 .client_compositor_state(&client)
                 .blocker_cleared(state, &dh);
@@ -371,7 +371,7 @@ impl State {
 
 impl WorkspaceHandler for State {
     fn workspace_state(&mut self) -> &mut WorkspaceState {
-        &mut self.workspaces
+        &mut self.protocols.workspaces
     }
 
     fn workspace_actions(&mut self, actions: Vec<Action>) {

Modified file: crates/monolith/src/idle.rs+3 additions−3 deletions@@ -10,7 +10,7 @@ use smithay::wayland::idle_notify::{IdleNotifierHandler, IdleNotifierState};
 
 impl IdleNotifierHandler for State {
     fn idle_notifier_state(&mut self) -> &mut IdleNotifierState<Self> {
-        &mut self.idle_notifier
+        &mut self.protocols.idle_notifier
     }
 }
 
@@ -29,7 +29,7 @@ impl IdleInhibitHandler for State {
 impl State {
     pub fn activity(&mut self) {
         let seat = self.seat.clone();
-        self.idle_notifier.notify_activity(&seat);
+        self.protocols.idle_notifier.notify_activity(&seat);
     }
 
     /// An inhibitor only counts while its surface is on screen, as the
@@ -48,7 +48,7 @@ impl State {
         });
         if shown != self.inhibited {
             self.inhibited = shown;
-            self.idle_notifier.set_is_inhibited(shown);
+            self.protocols.idle_notifier.set_is_inhibited(shown);
         }
     }
 }

Modified file: crates/monolith/src/import.rs+1−1

@@ -124,7 +124,7 @@ impl State {

124124 }

125125 }

126126 waiters.done.store(true, Ordering::Release);

127- let dh = self.display.clone();

127+ let dh = self.core.display.clone();

128128 for client in waiters.clients {

129129 self.client_compositor_state(&client)

130130 .blocker_cleared(self, &dh);

Modified file: crates/monolith/src/input.rs+2 additions−2 deletions@@ -103,7 +103,7 @@ impl State {
                 if state.lock.active() {
                     return FilterResult::Forward;
                 }
-                match state.binds.find(mods, &handle.raw_syms()) {
+                match state.settings.binds.find(mods, &handle.raw_syms()) {
                     Some(cmd) => {
                         tracing::debug!(?cmd, "bind");
                         state.suppressed.push(code);
@@ -182,7 +182,7 @@ fn start_drag(state: &mut State, button: u32) -> bool {
         .seat
         .get_keyboard()
         .map(|k| k.modifier_state())
-        .is_some_and(|m| match state.config.general.mod_key {
+        .is_some_and(|m| match state.settings.config.general.mod_key {
             Modifier::Super => m.logo,
             Modifier::Alt => m.alt,
             Modifier::Ctrl => m.ctrl,

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

@@ -28,6 +28,7 @@ impl Drop for Server {

2828

2929 pub fn init(event_loop: &EventLoop<'static, State>, state: &mut State) -> std::io::Result<()> {

3030 let Some(path) = state

31+ .core

3132 .socket_name

3233 .to_str()

3334 .and_then(monolith_ipc::socket_path_for)

Modified file: crates/monolith/src/layers.rs+1−1

@@ -22,7 +22,7 @@ use std::time::Duration;

2222

2323 impl WlrLayerShellHandler for State {

2424 fn shell_state(&mut self) -> &mut WlrLayerShellState {

25- &mut self.layer_shell_state

25+ &mut self.protocols.layer_shell_state

2626 }

2727

2828 fn new_layer_surface(

Modified file: crates/monolith/src/lock.rs+1−1

@@ -50,7 +50,7 @@ impl Lock {

5050

5151 impl SessionLockHandler for State {

5252 fn lock_state(&mut self) -> &mut SessionLockManagerState {

53- &mut self.session_lock_state

53+ &mut self.protocols.session_lock_state

5454 }

5555

5656 fn lock(&mut self, confirmation: SessionLocker) {

Modified file: crates/monolith/src/main.rs+4 additions−3 deletions@@ -5,6 +5,7 @@ mod commands;
 mod cursor;
 mod drm;
 mod focus;
+mod globals;
 mod handlers;
 mod idle;
 mod import;
@@ -157,7 +158,7 @@ fn export_session(state: &State) {
         .arg("--systemd")
         .arg(format!(
             "WAYLAND_DISPLAY={}",
-            state.socket_name.to_string_lossy()
+            state.core.socket_name.to_string_lossy()
         ))
         .arg("XDG_CURRENT_DESKTOP=monolith")
         .arg("XDG_SESSION_TYPE=wayland")
@@ -203,12 +204,12 @@ fn run(
     }
     ipc::init(&event_loop, &mut state)?;
     xwayland::init(&mut state);
-    tracing::info!(socket = ?state.socket_name, device = state.renderer.device_name(), "monolith running");
+    tracing::info!(socket = ?state.core.socket_name, device = state.renderer.device_name(), "monolith running");
 
     if gpu.is_some() {
         export_session(&state);
     }
-    let mut startup = state.config.startup.clone();
+    let mut startup = state.settings.config.startup.clone();
     if !program.is_empty() {
         startup.push(program.to_vec());
     }

Modified file: crates/monolith/src/nested/mod.rs+6 additions−6 deletions@@ -117,7 +117,7 @@ pub fn init(
             serial_number: "0".into(),
         },
     );
-    let _global = output.create_global::<State>(&state.display);
+    let _global = output.create_global::<State>(&state.core.display);
     let mode = Mode {
         size: DEFAULT_SIZE.into(),
         refresh: 60_000,
@@ -172,12 +172,12 @@ pub fn render(state: &mut State) {
         renderer,
         space,
         needs_redraw,
-        start,
+        core,
         layout,
         windows,
         anim,
         borders,
-        config,
+        settings,
         output_id,
         lock,
         captures,
@@ -234,7 +234,7 @@ pub fn render(state: &mut State) {
                 anim,
                 renderer,
                 now,
-                &config.decoration,
+                &settings.config.decoration,
                 borders,
                 Some(&host.output),
                 xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
@@ -259,7 +259,7 @@ pub fn render(state: &mut State) {
     *needs_redraw = anim.active(now);
     anim.prune(now);
     lock.shown(&host.output);
-    let elapsed = start.elapsed();
+    let elapsed = core.start.elapsed();
     crate::lock::send_frames(lock, &host.output, elapsed);
     for window in space.elements().filter(|_| !lock.active()) {
         window.send_frame(&host.output, elapsed, Some(Duration::ZERO), |_, _| {
@@ -430,7 +430,7 @@ impl Dispatch<xdg_toplevel::XdgToplevel, ()> for State {
                     state.resize_output(size);
                 }
             }
-            xdg_toplevel::Event::Close => state.signal.stop(),
+            xdg_toplevel::Event::Close => state.core.signal.stop(),
             _ => {}
         }
     }

Modified file: crates/monolith/src/state.rs+48 additions−115 deletions@@ -1,13 +1,13 @@
 use crate::anim::{Animator, Ghost};
 use crate::commands::Binds;
 use crate::focus::Focus;
+use crate::globals::Protocols;
 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_protocols::workspace::{Group, Snapshot, Workspace};
 use monolith_render_vk::VulkanRenderer;
 use monolith_render_vk::VulkanTexture;
-use smithay::backend::renderer::ImportDma;
 use smithay::backend::renderer::Renderer;
 use smithay::backend::renderer::utils::{import_surface_tree, with_renderer_surface_state};
 use smithay::desktop::utils::under_from_surface_tree;
@@ -24,28 +24,11 @@ use smithay::reexports::wayland_server::backend::{ClientData, ClientId, Disconne
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::reexports::wayland_server::{Display, DisplayHandle, Resource};
 use smithay::utils::{Clock, Logical, Monotonic, Point, Rectangle, SERIAL_COUNTER, Size};
-use smithay::wayland::compositor::{CompositorClientState, CompositorState, with_states};
-use smithay::wayland::dmabuf::{DmabufGlobal, DmabufState};
-use smithay::wayland::idle_inhibit::IdleInhibitManagerState;
-use smithay::wayland::idle_notify::IdleNotifierState;
-use smithay::wayland::image_capture_source::{
-    ImageCaptureSourceState, OutputCaptureSourceState, ToplevelCaptureSourceState,
-};
-use smithay::wayland::image_copy_capture::ImageCopyCaptureState;
-use smithay::wayland::output::OutputManagerState;
+use smithay::wayland::compositor::{CompositorClientState, with_states};
 use smithay::wayland::seat::WaylandFocus;
-use smithay::wayland::selection::data_device::DataDeviceState;
-use smithay::wayland::selection::ext_data_control::DataControlState as ExtDataControlState;
-use smithay::wayland::selection::primary_selection::PrimarySelectionState;
-use smithay::wayland::selection::wlr_data_control::DataControlState as WlrDataControlState;
-use smithay::wayland::session_lock::SessionLockManagerState;
-use smithay::wayland::shell::wlr_layer::{Layer, WlrLayerShellState};
-use smithay::wayland::shell::xdg::decoration::XdgDecorationState;
-use smithay::wayland::shell::xdg::{XdgShellState, XdgToplevelSurfaceData};
-use smithay::wayland::shm::ShmState;
+use smithay::wayland::shell::wlr_layer::Layer;
+use smithay::wayland::shell::xdg::XdgToplevelSurfaceData;
 use smithay::wayland::socket::ListeningSocketSource;
-use smithay::wayland::xdg_activation::XdgActivationState;
-use smithay::wayland::xwayland_shell::XWaylandShellState;
 use std::collections::{HashMap, HashSet};
 use std::ffi::OsString;
 use std::path::PathBuf;
@@ -53,10 +36,9 @@ use std::sync::Arc;
 use std::time::{Duration, Instant};
 
 pub struct State {
-    pub start: Instant,
-    pub socket_name: OsString,
-    pub display: DisplayHandle,
-    pub signal: LoopSignal,
+    pub core: Core,
+    pub settings: Settings,
+    pub protocols: Protocols,
     pub renderer: VulkanRenderer,
     pub space: Space<Window>,
     pub popups: PopupManager,
@@ -75,9 +57,6 @@ pub struct State {
     /// title, which clients set after creating the toplevel.
     pub unmapped: Vec<Window>,
     pub output_id: Option<OutputId>,
-    pub config: Config,
-    pub config_path: Option<PathBuf>,
-    pub binds: Binds,
     pub suppressed: Vec<Keycode>,
     pub move_inverted: bool,
     pub drag: Option<crate::input::Drag>,
@@ -85,9 +64,6 @@ pub struct State {
     pub pointer_pos: Point<f64, Logical>,
     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,
@@ -100,7 +76,6 @@ pub struct State {
     /// A layer surface given the keyboard by a click, like a launcher.
     pub layer_focus: Option<WlSurface>,
     pub xwayland: Option<crate::xwayland::Xwayland>,
-    pub xwayland_shell_state: XWaylandShellState,
     pub captures: crate::capture::Captures,
     pub imports: crate::import::Imports,
     /// The render node clients get dmabufs for, known on bare metal.
@@ -108,33 +83,26 @@ pub struct State {
     pub lock: crate::lock::Lock,
     pub inhibitors: HashSet<WlSurface>,
     pub inhibited: bool,
-    pub handle: LoopHandle<'static, State>,
-
-    pub compositor_state: CompositorState,
-    pub xdg_shell_state: XdgShellState,
-    pub layer_shell_state: WlrLayerShellState,
-    pub _image_capture_source_state: ImageCaptureSourceState,
-    pub output_capture_source_state: OutputCaptureSourceState,
-    pub toplevel_capture_source_state: ToplevelCaptureSourceState,
-    pub image_copy_capture_state: ImageCopyCaptureState,
-    pub activation_state: XdgActivationState,
-    pub primary_selection_state: PrimarySelectionState,
-    pub wlr_data_control_state: WlrDataControlState,
-    pub ext_data_control_state: ExtDataControlState,
-    pub session_lock_state: SessionLockManagerState,
-    pub idle_notifier: IdleNotifierState<State>,
-    pub _idle_inhibit: IdleInhibitManagerState,
-    pub _xdg_decoration_state: XdgDecorationState,
-    pub shm_state: ShmState,
-    pub dmabuf_state: DmabufState,
-    pub _dmabuf_global: DmabufGlobal,
-    pub _output_manager_state: OutputManagerState,
     pub seat_state: SeatState<State>,
-    pub data_device_state: DataDeviceState,
-    pub _cursor_shape_state: smithay::wayland::cursor_shape::CursorShapeManagerState,
     pub seat: Seat<State>,
 }
 
+/// The event loop and Wayland display, which everything uses and nothing owns.
+pub struct Core {
+    pub display: DisplayHandle,
+    pub handle: LoopHandle<'static, State>,
+    pub signal: LoopSignal,
+    pub socket_name: OsString,
+    pub start: Instant,
+}
+
+/// The config and what is derived from it, swapped whole on reload.
+pub struct Settings {
+    pub config: Config,
+    pub path: Option<PathBuf>,
+    pub binds: Binds,
+}
+
 impl State {
     pub fn new(
         event_loop: &mut EventLoop<'static, State>,
@@ -152,8 +120,6 @@ impl State {
             Some(node) => VulkanRenderer::for_node(node)?,
             None => VulkanRenderer::new()?,
         };
-        let mut dmabuf_state = DmabufState::new();
-        let dmabuf_global = dmabuf_state.create_global::<State>(&dh, renderer.dmabuf_formats());
         let mut seat_state = SeatState::new();
         let mut seat = seat_state.new_wl_seat(&dh, "seat0");
         let kb = &config.keyboard;
@@ -165,6 +131,7 @@ impl State {
         let handle = event_loop.handle();
         handle.insert_source(listener, |stream, _, state| {
             if let Err(e) = state
+                .core
                 .display
                 .insert_client(stream, Arc::new(ClientState::default()))
             {
@@ -182,14 +149,22 @@ impl State {
 
         let mut layout = Layout::default();
         layout.gaps = gaps(&config);
-        let binds = Binds::new(&config);
         let animation = config.animation.clone();
-        let primary_selection_state = PrimarySelectionState::new::<State>(&dh);
         let imports = crate::import::Imports::new(&handle, renderer.dmabuf_importer())?;
         Ok(Self {
-            start: Instant::now(),
-            socket_name,
-            signal: event_loop.get_signal(),
+            protocols: Protocols::new(&dh, handle.clone(), &renderer),
+            core: Core {
+                display: dh,
+                handle,
+                signal: event_loop.get_signal(),
+                socket_name,
+                start: Instant::now(),
+            },
+            settings: Settings {
+                binds: Binds::new(&config),
+                config,
+                path: config_path,
+            },
             renderer,
             space: Space::default(),
             popups: PopupManager::default(),
@@ -204,22 +179,12 @@ impl State {
             windows: HashMap::new(),
             unmapped: Vec::new(),
             output_id: None,
-            config,
-            config_path,
-            binds,
             suppressed: Vec::new(),
             move_inverted: false,
             drag: None,
             pointer_pos: Point::default(),
             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(),
@@ -228,48 +193,14 @@ impl State {
             placed_by_rule: HashSet::new(),
             layer_focus: None,
             xwayland: None,
-            xwayland_shell_state: XWaylandShellState::new::<State>(&dh),
             captures: Default::default(),
             imports,
             render_node: None,
             lock: Default::default(),
             inhibitors: HashSet::new(),
             inhibited: false,
-            handle: event_loop.handle(),
-            compositor_state: CompositorState::new::<State>(&dh),
-            xdg_shell_state: XdgShellState::new::<State>(&dh),
-            layer_shell_state: WlrLayerShellState::new::<State>(&dh),
-            _image_capture_source_state: ImageCaptureSourceState::new(),
-            output_capture_source_state: OutputCaptureSourceState::new::<State>(&dh),
-            toplevel_capture_source_state: ToplevelCaptureSourceState::new::<State>(&dh),
-            image_copy_capture_state: ImageCopyCaptureState::new::<State>(&dh),
-            activation_state: XdgActivationState::new::<State>(&dh),
-            wlr_data_control_state: WlrDataControlState::new::<State, _>(
-                &dh,
-                Some(&primary_selection_state),
-                |_| true,
-            ),
-            ext_data_control_state: ExtDataControlState::new::<State, _>(
-                &dh,
-                Some(&primary_selection_state),
-                |_| true,
-            ),
-            primary_selection_state,
-            session_lock_state: SessionLockManagerState::new::<State, _>(&dh, |_| true),
-            idle_notifier: IdleNotifierState::new(&dh, event_loop.handle()),
-            _idle_inhibit: IdleInhibitManagerState::new::<State>(&dh),
-            _xdg_decoration_state: XdgDecorationState::new::<State>(&dh),
-            shm_state: ShmState::new::<State>(&dh, vec![]),
-            dmabuf_state,
-            _dmabuf_global: dmabuf_global,
-            _output_manager_state: OutputManagerState::new_with_xdg_output::<State>(&dh),
             seat_state,
-            data_device_state: DataDeviceState::new::<State>(&dh),
-            _cursor_shape_state: smithay::wayland::cursor_shape::CursorShapeManagerState::new::<
-                State,
-            >(&dh),
             seat,
-            display: dh,
         })
     }
 
@@ -284,7 +215,7 @@ impl State {
         crate::ipc::broadcast(self);
         self.publish_workspaces();
         self.publish_toplevels();
-        let _ = self.display.flush_clients();
+        let _ = self.core.display.flush_clients();
     }
 
     pub fn resize_output(&mut self, size: Size<i32, Logical>) {
@@ -309,13 +240,13 @@ impl State {
     /// and title are known and the initial configure can carry its size.
     pub fn map_window(&mut self, window: Window, float: Option<Rectangle<i32, Logical>>) {
         let (app_id, title) = identity(&window);
-        let rule = self.config.placement(&app_id, &title);
+        let rule = self.settings.config.placement(&app_id, &title);
         let pid = match window.x11_surface() {
             Some(x) => x.pid(),
             None => window
                 .toplevel()
                 .and_then(|t| t.wl_surface().client())
-                .and_then(|c| c.get_credentials(&self.display).ok())
+                .and_then(|c| c.get_credentials(&self.core.display).ok())
                 .map(|c| c.pid as u32),
         };
         let launch = pid.and_then(|pid| self.launches.find(pid));
@@ -368,7 +299,7 @@ impl State {
     fn await_first_buffer(&mut self, id: WindowId) {
         self.awaiting.insert(id);
         let timeout = Timer::from_duration(Duration::from_millis(300));
-        let _ = self.handle.insert_source(timeout, move |_, _, state| {
+        let _ = self.core.handle.insert_source(timeout, move |_, _, state| {
             state.first_buffer(id);
             TimeoutAction::Drop
         });
@@ -613,7 +544,7 @@ impl State {
     }
 
     fn publish_workspaces(&mut self) {
-        if !self.workspaces.has_clients() {
+        if !self.protocols.workspaces.has_clients() {
             return;
         }
         let l = &self.layout;
@@ -646,12 +577,14 @@ impl State {
                 Some(Group { output, workspaces })
             })
             .collect();
-        let dh = self.display.clone();
-        self.workspaces.update::<State>(&dh, Snapshot { groups });
+        let dh = self.core.display.clone();
+        self.protocols
+            .workspaces
+            .update::<State>(&dh, Snapshot { groups });
     }
 
     pub fn reconfigure_keyboard(&mut self) {
-        let kb = self.config.keyboard.clone();
+        let kb = self.settings.config.keyboard.clone();
         if let Some(keyboard) = self.seat.get_keyboard() {
             if let Err(e) = keyboard.set_xkb_config(self, xkb_config(&kb)) {
                 tracing::warn!("keyboard config rejected: {e:?}");

Modified file: crates/monolith/src/toplevels.rs+11 additions−7 deletions@@ -29,13 +29,13 @@ pub fn key(id: WindowId) -> u64 {
 
 impl ForeignToplevelListHandler for State {
     fn foreign_toplevel_list_state(&mut self) -> &mut ForeignToplevelListState {
-        &mut self.toplevel_list
+        &mut self.protocols.toplevel_list
     }
 }
 
 impl ForeignToplevelHandler for State {
     fn foreign_toplevel_state(&mut self) -> &mut ForeignToplevelState {
-        &mut self.foreign_toplevels
+        &mut self.protocols.foreign_toplevels
     }
 
     fn foreign_toplevel_action(&mut self, action: Action) {
@@ -91,7 +91,7 @@ impl State {
         handles.retain(|id, h| {
             let keep = self.windows.contains_key(id);
             if !keep {
-                self.toplevel_list.remove_toplevel(h);
+                self.protocols.toplevel_list.remove_toplevel(h);
             }
             keep
         });
@@ -106,14 +106,17 @@ impl State {
                     }
                 }
                 None => {
-                    let h = self.toplevel_list.new_toplevel::<State>(title, app_id);
+                    let h = self
+                        .protocols
+                        .toplevel_list
+                        .new_toplevel::<State>(title, app_id);
                     handles.insert(*id, h);
                 }
             }
         }
         self.list_handles.0 = handles;
 
-        if !self.foreign_toplevels.has_clients() {
+        if !self.protocols.foreign_toplevels.has_clients() {
             return;
         }
         let focused = self.layout.focused();
@@ -138,8 +141,9 @@ impl State {
                 }
             })
             .collect();
-        let dh = self.display.clone();
-        self.foreign_toplevels
+        let dh = self.core.display.clone();
+        self.protocols
+            .foreign_toplevels
             .update::<State>(&dh, Snapshot { toplevels });
     }
 }

Modified file: crates/monolith/src/xwayland.rs+8 additions−7 deletions@@ -101,7 +101,7 @@ pub fn init(state: &mut State) {
     let mut watch = Vec::new();
     for (i, l) in listeners.iter().enumerate() {
         let Ok(l) = l.try_clone() else { continue };
-        let token = state.handle.insert_source(
+        let token = state.core.handle.insert_source(
             Generic::new(l, Interest::READ, Mode::Level),
             move |_, _, state| {
                 start(state, i);
@@ -130,7 +130,7 @@ fn rearm(state: &mut State) {
     };
     x.running = false;
     for (_, t) in &x.watch {
-        let _ = state.handle.enable(t);
+        let _ = state.core.handle.enable(t);
     }
 }
 
@@ -156,7 +156,7 @@ fn start(state: &mut State, fired: usize) {
     x.running = true;
     for (i, t) in &x.watch {
         if *i != fired {
-            state.handle.disable(t).ok();
+            state.core.handle.disable(t).ok();
         }
     }
     let mut args = Vec::new();
@@ -168,7 +168,7 @@ fn start(state: &mut State, fired: usize) {
     // made inheritable just for this one spawn.
     set_inherit(&x.listeners, true);
     let spawned = XWayland::spawn(
-        &state.display,
+        &state.core.display,
         None,
         std::iter::empty::<(String, String)>(),
         args,
@@ -187,11 +187,12 @@ fn start(state: &mut State, fired: usize) {
     };
     tracing::info!("starting Xwayland");
     let inserted = state
+        .core
         .handle
         .insert_source(xwayland, move |event, _, state| match event {
             XWaylandEvent::Ready { x11_socket, .. } => {
-                let dh = state.display.clone();
-                match X11Wm::start_wm(state.handle.clone(), &dh, x11_socket, client.clone()) {
+                let dh = state.core.display.clone();
+                match X11Wm::start_wm(state.core.handle.clone(), &dh, x11_socket, client.clone()) {
                     Ok(wm) => {
                         tracing::info!("Xwayland ready");
                         if let Some(x) = state.xwayland.as_mut() {
@@ -213,7 +214,7 @@ fn start(state: &mut State, fired: usize) {
 
 impl XWaylandShellHandler for State {
     fn xwayland_shell_state(&mut self) -> &mut XWaylandShellState {
-        &mut self.xwayland_shell_state
+        &mut self.protocols.xwayland_shell_state
     }
 
     fn surface_associated(&mut self, _xwm: XwmId, surface: WlSurface, _window: X11Surface) {

monolith

Commit a772647a949f

Commit `a772647a949f`