monolith

public

Star0

Fork 0

Watch0

75 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `7e58494265db`

tarball

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

13 files changed+101-82

monolith: group input state into Input and redraw flags into Dirty

This finishes the split from design/state-split.md. State is down to ten fields, each a struct with one concern, so functions can borrow the part they need.

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

@@ -27,7 +27,7 @@ impl XdgActivationHandler for State {

2727 }

2828

2929 fn token_created(&mut self, _token: XdgActivationToken, data: XdgActivationTokenData) -> bool {

30- let keyboard = self.seat.get_keyboard();

30+ let keyboard = self.input.seat.get_keyboard();

3131 let focused = keyboard

3232 .as_ref()

3333 .and_then(|k| k.current_focus())

Modified file: crates/monolith/src/capture.rs+4 additions−4 deletions@@ -117,7 +117,7 @@ impl ImageCopyCaptureHandler for State {
                 .captures
                 .waiting
                 .push((session.clone(), frame));
-            self.needs_redraw = true;
+            self.dirty.redraw = true;
         } else {
             self.capture(session, frame);
         }
@@ -279,11 +279,11 @@ impl State {
         let now = now_ns();
         let mut elements = Vec::new();
         if cursor && let Some(area) = self.wm.layout.output(o).map(|out| out.area) {
-            let local = self.pointer_pos - Point::from((area.x, area.y));
+            let local = self.input.pointer_pos - Point::from((area.x, area.y));
             if local.x >= 0.0 && local.y >= 0.0 && local.x < area.w && local.y < area.h {
-                elements.extend(self.cursor.elements(
+                elements.extend(self.input.cursor.elements(
                     &mut self.renderer,
-                    &self.cursor_status,
+                    &self.input.cursor_status,
                     local,
                 ));
             }

Modified file: crates/monolith/src/commands.rs+2 additions−2 deletions@@ -52,7 +52,7 @@ impl State {
     pub fn run(&mut self, cmd: Command) -> Result<(), String> {
         let output = self.wm.layout.active_output();
         let focused = self.wm.layout.focused();
-        let inverted = std::mem::take(&mut self.move_inverted);
+        let inverted = std::mem::take(&mut self.input.move_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 {
@@ -83,7 +83,7 @@ impl State {
             Command::Maximize => {
                 self.wm.layout.expand(ExpandScope::All);
             }
-            Command::InvertMove => self.move_inverted = !inverted,
+            Command::InvertMove => self.input.move_inverted = !inverted,
             Command::Resize { axis, delta } => {
                 let axis = match axis {
                     monolith_ipc::Axis::Horizontal => Axis::Horizontal,

Modified file: crates/monolith/src/drm.rs+10 additions−12 deletions@@ -258,7 +258,7 @@ pub fn init(
                     s.redraw = true;
                 }
             }
-            state.needs_redraw = true;
+            state.dirty.redraw = true;
         }
     })?;
     handle.insert_source(drm_events, |event, meta, state| match event {
@@ -584,8 +584,8 @@ pub fn render(state: &mut State) {
     let Some(drm) = state.backend.drm_mut() else {
         return;
     };
-    let cursor = std::mem::take(&mut state.cursor_moved);
-    let all = std::mem::take(&mut state.needs_redraw);
+    let cursor = std::mem::take(&mut state.dirty.cursor);
+    let all = std::mem::take(&mut state.dirty.redraw);
     for s in drm.surfaces.values_mut() {
         s.redraw |= all;
         s.cursor_redraw |= cursor;
@@ -611,9 +611,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
         wm,
         settings,
         core,
-        cursor,
-        cursor_status,
-        pointer_pos,
+        input,
         services:
             Services {
                 lock,
@@ -664,9 +662,9 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
         return false;
     };
     let mut elements = Vec::new();
-    let local = *pointer_pos - Point::from((area.x, area.y));
+    let local = input.pointer_pos - Point::from((area.x, area.y));
     if local.x >= 0.0 && local.y >= 0.0 && local.x < area.w && local.y < area.h {
-        elements.extend(cursor.elements(renderer, cursor_status, local));
+        elements.extend(input.cursor.elements(renderer, &input.cursor_status, local));
     }
     let scene_began = std::time::Instant::now();
     match crate::lock::elements(lock, renderer, &surface.output) {
@@ -756,10 +754,10 @@ fn on_input(state: &mut State, event: InputEvent<LibinputInputBackend>) {
             state.key(event.key_code(), event.state(), time);
         }
         InputEvent::PointerMotion { event } => {
-            let pos = clamp(state, state.pointer_pos + event.delta());
+            let pos = clamp(state, state.input.pointer_pos + event.delta());
             state.pointer_to(pos, event.time());
             state.pointer_frame();
-            state.cursor_moved = true;
+            state.dirty.cursor = true;
         }
         InputEvent::PointerMotionAbsolute { event } => {
             let Some(area) = state.wm.layout.outputs().next().map(|(_, o)| o.area) else {
@@ -769,7 +767,7 @@ fn on_input(state: &mut State, event: InputEvent<LibinputInputBackend>) {
             let pos = Point::from((area.x + p.x, area.y + p.y));
             state.pointer_to(pos, event.time());
             state.pointer_frame();
-            state.cursor_moved = true;
+            state.dirty.cursor = true;
         }
         InputEvent::PointerButton { event } => {
             let time = event.time();
@@ -813,7 +811,7 @@ fn clamp(
     }
     let Some(a) = areas
         .iter()
-        .find(|a| inside(a, state.pointer_pos))
+        .find(|a| inside(a, state.input.pointer_pos))
         .or(areas.first())
     else {
         return pos;

Modified file: crates/monolith/src/handlers.rs+4 additions−4 deletions@@ -109,7 +109,7 @@ impl CompositorHandler for State {
             let _ = popup.send_configure();
         }
         self.layer_commit(surface);
-        self.needs_redraw = true;
+        self.dirty.redraw = true;
     }
 }
 
@@ -186,12 +186,12 @@ impl SeatHandler for State {
     type TouchFocus = WlSurface;
 
     fn seat_state(&mut self) -> &mut SeatState<State> {
-        &mut self.seat_state
+        &mut self.input.seat_state
     }
 
     fn cursor_image(&mut self, _seat: &Seat<Self>, image: CursorImageStatus) {
-        self.cursor_status = image;
-        self.needs_redraw = true;
+        self.input.cursor_status = image;
+        self.dirty.redraw = true;
     }
 
     fn focus_changed(&mut self, seat: &Seat<Self>, focused: Option<&crate::focus::Focus>) {

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

@@ -46,7 +46,7 @@ impl IdleInhibitHandler for State {

4646

4747 impl State {

4848 pub fn activity(&mut self) {

49- let seat = self.seat.clone();

49+ let seat = self.input.seat.clone();

5050 self.services.idle.notifier.notify_activity(&seat);

5151 }

5252

Modified file: crates/monolith/src/input.rs+17 additions−16 deletions@@ -13,12 +13,12 @@ use smithay::wayland::shell::wlr_layer::Layer;
 
 impl State {
     pub fn pointer_to(&mut self, pos: Point<f64, Logical>, time: InputTime) {
-        self.pointer_pos = pos;
+        self.input.pointer_pos = pos;
         self.activity();
         if drag_to(self, pos) {
             return;
         }
-        let Some(pointer) = self.seat.get_pointer() else {
+        let Some(pointer) = self.input.seat.get_pointer() else {
             return;
         };
         let under = self.surface_under(pos);
@@ -35,7 +35,7 @@ impl State {
 
     pub fn pointer_button(&mut self, button: u32, pressed: ButtonState, time: InputTime) {
         self.activity();
-        if pressed == ButtonState::Released && self.drag.take().is_some() {
+        if pressed == ButtonState::Released && self.input.drag.take().is_some() {
             return;
         }
         if pressed == ButtonState::Pressed && !self.services.lock.active() {
@@ -44,7 +44,7 @@ impl State {
                 return;
             }
         }
-        let Some(pointer) = self.seat.get_pointer() else {
+        let Some(pointer) = self.input.seat.get_pointer() else {
             return;
         };
         pointer.button(
@@ -60,20 +60,20 @@ impl State {
 
     pub fn pointer_axis(&mut self, frame: AxisFrame) {
         self.activity();
-        if let Some(pointer) = self.seat.get_pointer() {
+        if let Some(pointer) = self.input.seat.get_pointer() {
             pointer.axis(self, frame);
         }
     }
 
     pub fn pointer_frame(&mut self) {
-        if let Some(pointer) = self.seat.get_pointer() {
+        if let Some(pointer) = self.input.seat.get_pointer() {
             pointer.frame(self);
         }
     }
 
     pub fn key(&mut self, code: Keycode, pressed: KeyState, time: InputTime) {
         self.activity();
-        let Some(keyboard) = self.seat.get_keyboard() else {
+        let Some(keyboard) = self.input.seat.get_keyboard() else {
             return;
         };
         let action = keyboard.input(
@@ -84,9 +84,9 @@ impl State {
             time,
             |state, mods, handle| {
                 if pressed == KeyState::Released {
-                    let before = state.suppressed.len();
-                    state.suppressed.retain(|k| *k != code);
-                    return if state.suppressed.len() < before {
+                    let before = state.input.suppressed.len();
+                    state.input.suppressed.retain(|k| *k != code);
+                    return if state.input.suppressed.len() < before {
                         FilterResult::Intercept(None)
                     } else {
                         FilterResult::Forward
@@ -96,7 +96,7 @@ impl State {
                 if (xkb::keysyms::KEY_XF86Switch_VT_1..=xkb::keysyms::KEY_XF86Switch_VT_12)
                     .contains(&sym)
                 {
-                    state.suppressed.push(code);
+                    state.input.suppressed.push(code);
                     let vt = (sym - xkb::keysyms::KEY_XF86Switch_VT_1 + 1) as i32;
                     return FilterResult::Intercept(Some(Action::Vt(vt)));
                 }
@@ -106,7 +106,7 @@ impl State {
                 match state.settings.binds.find(mods, &handle.raw_syms()) {
                     Some(cmd) => {
                         tracing::debug!(?cmd, "bind");
-                        state.suppressed.push(code);
+                        state.input.suppressed.push(code);
                         FilterResult::Intercept(Some(Action::Run(cmd)))
                     }
                     None => FilterResult::Forward,
@@ -138,7 +138,7 @@ enum Action {
 }
 
 fn focus_under_pointer(state: &mut State) {
-    let pos = state.pointer_pos;
+    let pos = state.input.pointer_pos;
     let layers = [Layer::Overlay, Layer::Top, Layer::Bottom, Layer::Background];
     if let Some((layer, surface, _)) = state.layer_under(pos, &layers)
         && layer.can_receive_keyboard_focus()
@@ -180,6 +180,7 @@ fn start_drag(state: &mut State, button: u32) -> bool {
         return false;
     }
     let held = state
+        .input
         .seat
         .get_keyboard()
         .map(|k| k.modifier_state())
@@ -204,9 +205,9 @@ fn start_drag(state: &mut State, button: u32) -> bool {
     if !held {
         return false;
     }
-    state.drag = Some(Drag {
+    state.input.drag = Some(Drag {
         window: id,
-        from: state.pointer_pos,
+        from: state.input.pointer_pos,
         rect,
         resize: button == BTN_RIGHT,
     });
@@ -214,7 +215,7 @@ fn start_drag(state: &mut State, button: u32) -> bool {
 }
 
 fn drag_to(state: &mut State, pos: Point<f64, Logical>) -> bool {
-    let Some(d) = &state.drag else {
+    let Some(d) = &state.input.drag else {
         return false;
     };
     let (dx, dy) = (pos.x - d.from.x, pos.y - d.from.y);

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

@@ -199,7 +199,7 @@ fn snapshot(state: &State) -> monolith_ipc::State {

199199 .collect();

200200 windows.sort_by_key(|w| w.id);

201201 monolith_ipc::State {

202- move_inverted: state.move_inverted,

202+ move_inverted: state.input.move_inverted,

203203 tags,

204204 outputs,

205205 windows,

Modified file: crates/monolith/src/layers.rs+7 additions−1 deletions@@ -35,7 +35,13 @@ impl WlrLayerShellHandler for State {
         let output = output
             .as_ref()
             .and_then(Output::from_resource)
-            .or_else(|| self.wm.space.output_under(self.pointer_pos).next().cloned())
+            .or_else(|| {
+                self.wm
+                    .space
+                    .output_under(self.input.pointer_pos)
+                    .next()
+                    .cloned()
+            })
             .or_else(|| self.wm.space.outputs().next().cloned());
         let Some(output) = output else {
             surface.send_close();

Modified file: crates/monolith/src/lock.rs+5 additions−5 deletions@@ -57,16 +57,16 @@ impl SessionLockHandler for State {
         tracing::info!("session lock requested");
         self.services.lock.pending = Some(confirmation);
         self.services.lock.blanked.clear();
-        self.drag = None;
+        self.input.drag = None;
         self.sync_focus();
-        self.needs_redraw = true;
+        self.dirty.redraw = true;
     }
 
     fn unlock(&mut self) {
         tracing::info!("session unlocked");
         self.services.lock = Lock::default();
         self.sync_focus();
-        self.needs_redraw = true;
+        self.dirty.redraw = true;
     }
 
     fn new_surface(&mut self, surface: LockSurface, output: WlOutput) {
@@ -80,7 +80,7 @@ impl SessionLockHandler for State {
             .retain(|(o, s)| o != &output && s.alive());
         self.services.lock.surfaces.push((output, surface));
         self.sync_focus();
-        self.needs_redraw = true;
+        self.dirty.redraw = true;
     }
 }
 
@@ -121,7 +121,7 @@ impl State {
     }
 
     pub fn lock_keyboard_focus(&self) -> Option<WlSurface> {
-        let under = self.wm.space.output_under(self.pointer_pos).next();
+        let under = self.wm.space.output_under(self.input.pointer_pos).next();
         under
             .and_then(|o| self.services.lock.surface_on(o))
             .or_else(|| {

Modified file: crates/monolith/src/nested/mod.rs+5 additions−5 deletions@@ -175,7 +175,7 @@ pub fn render(state: &mut State) {
         backend,
         renderer,
         wm,
-        needs_redraw,
+        dirty,
         core,
         settings,
         services:
@@ -190,7 +190,7 @@ pub fn render(state: &mut State) {
     let Some(host) = backend.nested_mut() else {
         return;
     };
-    if !host.configured || host.frame_pending || !*needs_redraw {
+    if !host.configured || host.frame_pending || !dirty.redraw {
         return;
     }
     if let Some(size) = host.pending_size.take() {
@@ -258,7 +258,7 @@ pub fn render(state: &mut State) {
             }
         }
     };
-    *needs_redraw = wm.anim.active(now);
+    dirty.redraw = wm.anim.active(now);
     wm.anim.prune(now);
     lock.shown(&host.output);
     let elapsed = core.start.elapsed();
@@ -273,7 +273,7 @@ pub fn render(state: &mut State) {
         captures.output_damaged(&host.output);
     }
     let Some(damage) = damage else {
-        if *needs_redraw {
+        if dirty.redraw {
             host.surface.frame(&host.qh, ());
             host.surface.commit();
             host.frame_pending = true;
@@ -407,7 +407,7 @@ impl Dispatch<xdg_surface::XdgSurface, ()> for State {
             if let Some(host) = state.backend.nested_mut() {
                 host.configured = true;
             }
-            state.needs_redraw = true;
+            state.dirty.redraw = true;
         }
     }
 }

Modified file: crates/monolith/src/state.rs+40 additions−26 deletions@@ -35,24 +35,34 @@ use std::time::{Duration, Instant};
 pub struct State {
     pub core: Core,
     pub settings: Settings,
-    pub protocols: Protocols,
+    pub backend: crate::backend::Backend,
     pub renderer: VulkanRenderer,
+    pub protocols: Protocols,
+    pub services: Services,
     pub wm: Wm,
-    pub backend: crate::backend::Backend,
-    pub cursor: crate::cursor::Cursor,
-    pub cursor_status: CursorImageStatus,
-    pub needs_redraw: bool,
-    /// The pointer moved, which on its own only redraws the cursor.
-    pub cursor_moved: bool,
+    pub input: Input,
+    pub dirty: Dirty,
+}
 
-    pub suppressed: Vec<Keycode>,
-    pub move_inverted: bool,
-    pub drag: Option<crate::input::Drag>,
+/// The seat and what monolith tracks about input on it.
+pub struct Input {
+    pub seat: Seat<State>,
+    pub seat_state: SeatState<State>,
     /// Global logical position, shared by every backend.
     pub pointer_pos: Point<f64, Logical>,
-    pub services: Services,
-    pub seat_state: SeatState<State>,
-    pub seat: Seat<State>,
+    /// Keys whose press ran a bind, so their release is swallowed too.
+    pub suppressed: Vec<Keycode>,
+    pub drag: Option<crate::input::Drag>,
+    pub move_inverted: bool,
+    pub cursor: crate::cursor::Cursor,
+    pub cursor_status: CursorImageStatus,
+}
+
+/// What needs doing after this batch of events.
+pub struct Dirty {
+    pub redraw: bool,
+    /// The pointer moved, which on its own only redraws the cursor.
+    pub cursor: bool,
 }
 
 /// The event loop and Wayland display, which everything uses and nothing owns.
@@ -148,14 +158,20 @@ impl State {
             renderer,
             wm: Wm::new(layout, Animator::new(animation)),
             backend: crate::backend::Backend::Starting,
-            cursor: crate::cursor::Cursor::load(),
-            cursor_status: CursorImageStatus::default_named(),
-            needs_redraw: true,
-            cursor_moved: false,
-            suppressed: Vec::new(),
-            move_inverted: false,
-            drag: None,
-            pointer_pos: Point::default(),
+            input: Input {
+                seat,
+                seat_state,
+                pointer_pos: Point::default(),
+                suppressed: Vec::new(),
+                drag: None,
+                move_inverted: false,
+                cursor: crate::cursor::Cursor::load(),
+                cursor_status: CursorImageStatus::default_named(),
+            },
+            dirty: Dirty {
+                redraw: true,
+                cursor: false,
+            },
             services: Services {
                 lock: Default::default(),
                 captures: Default::default(),
@@ -165,8 +181,6 @@ impl State {
                 ipc: Default::default(),
                 idle,
             },
-            seat_state,
-            seat,
         })
     }
 
@@ -484,7 +498,7 @@ impl State {
         }
         self.sync_focus();
         self.update_inhibit();
-        self.needs_redraw = true;
+        self.dirty.redraw = true;
     }
 
     pub fn sync_focus(&mut self) {
@@ -509,7 +523,7 @@ impl State {
                 }
             })
         };
-        if let Some(keyboard) = self.seat.get_keyboard()
+        if let Some(keyboard) = self.input.seat.get_keyboard()
             && keyboard.current_focus() != target
         {
             keyboard.set_focus(self, target, SERIAL_COUNTER.next_serial());
@@ -558,7 +572,7 @@ impl State {
 
     pub fn reconfigure_keyboard(&mut self) {
         let kb = self.settings.config.keyboard.clone();
-        if let Some(keyboard) = self.seat.get_keyboard() {
+        if let Some(keyboard) = self.input.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/xwayland.rs+4 additions−4 deletions@@ -222,7 +222,7 @@ impl XWaylandShellHandler for State {
             self.wm.index(id);
         }
         self.on_buffer(&surface);
-        self.needs_redraw = true;
+        self.dirty.redraw = true;
     }
 }
 
@@ -253,7 +253,7 @@ impl XwmHandler for State {
             x.unmanaged.retain(|w| w != &window);
             x.unmanaged.push(window);
         }
-        self.needs_redraw = true;
+        self.dirty.redraw = true;
     }
 
     fn unmapped_window(&mut self, _xwm: XwmId, window: X11Surface) {
@@ -297,7 +297,7 @@ impl XwmHandler for State {
         _above: Option<smithay::xwayland::xwm::X11Window>,
     ) {
         if window.is_override_redirect() {
-            self.needs_redraw = true;
+            self.dirty.redraw = true;
         }
     }
 
@@ -373,7 +373,7 @@ impl State {
         if let Some(id) = self.x11_window_id(window) {
             self.remove_window(id);
         }
-        self.needs_redraw = true;
+        self.dirty.redraw = true;
     }
 
     fn x11_fullscreen(&mut self, window: &X11Surface, on: bool) {

monolith

Commit 7e58494265db

Commit `7e58494265db`