monolith

public

Star0

Fork 0

Watch0

15 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `4e5afcada08b`

tarball

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

11 files changed+937-73

monolith: place windows through the layout model

Toplevels enter the layout on their first commit rather than at creation, because clients set app_id and title in between and rules need both. Windows started by the spawn command land on the output and tag the user was on when it ran, matched by PID ancestry. Focusing a homeless window does not count as leaving the viewed tag.

Modified file: crates/layout/Cargo.toml+1−1

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

1010

1111 [dependencies]

1212 monolith-planner.workspace = true

13-slotmap = "1"

13+slotmap.workspace = true

1414

1515 [dev-dependencies]

1616 proptest.workspace = true

Modified file: crates/layout/src/lib.rs+23 additions−6 deletions@@ -366,6 +366,18 @@ impl Layout {
         }
     }
 
+    /// The tag a launch from `o` belongs to. The focused window's tag, else
+    /// the first viewed tag, else homeless. Homeless is always on screen, so
+    /// focusing one of its windows does not mean the user left their tag.
+    pub fn launch_tag(&self, o: OutputId) -> TagId {
+        self.focused_on(o)
+            .map(|w| &self.windows[w])
+            .filter(|w| w.scratchpad.is_none() && !w.sticky && w.tag != self.homeless)
+            .map(|w| w.tag)
+            .or_else(|| self.outputs.get(o)?.viewed.first().copied())
+            .unwrap_or(self.homeless)
+    }
+
     pub fn view_everywhere(&mut self, tag: TagId) {
         for o in self.outputs.keys().collect::<Vec<_>>() {
             self.view(o, tag);
@@ -533,12 +545,7 @@ impl Layout {
             self.focus(w);
             return Some(w);
         }
-        let here = self.outputs[o].area;
-        let next = nearest(
-            here,
-            dir,
-            self.outputs.iter().map(|(id, out)| (id, out.area)),
-        )?;
+        let next = self.output_towards(o, dir)?;
         self.active = Some(next);
         let w = self.focused_on(next);
         if let Some(w) = w {
@@ -547,6 +554,16 @@ impl Layout {
         w
     }
 
+    pub fn output_towards(&self, from: OutputId, dir: Dir) -> Option<OutputId> {
+        let here = self.outputs.get(from)?.area;
+        let others = self
+            .outputs
+            .iter()
+            .filter(|&(id, _)| id != from)
+            .map(|(id, out)| (id, out.area));
+        nearest(here, dir, others)
+    }
+
     fn rect_of(&self, w: WindowId) -> Option<Rect> {
         let o = self.windows.get(w)?.output?;
         let arr = self.arrange(o);

Modified file: crates/monolith/Cargo.toml+5 additions@@ -13,7 +13,12 @@ profile = ["dep:tracy-client", "tracy-client/enable"]
 
 [dependencies]
 calloop-wayland-source = "0.4"
+monolith-config.workspace = true
+monolith-ipc.workspace = true
+monolith-layout.workspace = true
 monolith-render-vk.workspace = true
+serde_json.workspace = true
+slotmap.workspace = true
 smithay = { workspace = true, features = ["desktop"] }
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }

Added file: crates/monolith/src/commands.rs+190 additions@@ -0,0 +1,190 @@
+use crate::state::State;
+use monolith_config::{Config, Mods};
+use monolith_ipc::Command;
+use monolith_layout::{Axis, Dir, ExpandScope, WindowId};
+use smithay::input::keyboard::{Keysym, ModifiersState, xkb};
+use std::process::Stdio;
+
+pub struct Binds(Vec<(Mods, Keysym, Command)>);
+
+impl Binds {
+    pub fn new(config: &Config) -> Self {
+        let binds = config
+            .binds
+            .iter()
+            .filter_map(|b| {
+                let sym = xkb::keysym_from_name(&b.key, xkb::KEYSYM_CASE_INSENSITIVE);
+                if sym.raw() == xkb::keysyms::KEY_NoSymbol {
+                    tracing::warn!("bind: unknown key {:?}", b.key);
+                    return None;
+                }
+                Some((b.mods, sym, b.command.clone()))
+            })
+            .collect();
+        Self(binds)
+    }
+
+    /// Matches on the unshifted keysyms so `Mod+Shift+1` means the 1 key.
+    pub fn find(&self, mods: &ModifiersState, syms: &[Keysym]) -> Option<Command> {
+        let held = Mods {
+            logo: mods.logo,
+            alt: mods.alt,
+            ctrl: mods.ctrl,
+            shift: mods.shift,
+        };
+        self.0
+            .iter()
+            .find(|(m, sym, _)| *m == held && syms.contains(sym))
+            .map(|(_, _, c)| c.clone())
+    }
+}
+
+fn dir(d: monolith_ipc::Dir) -> Dir {
+    match d {
+        monolith_ipc::Dir::Left => Dir::Left,
+        monolith_ipc::Dir::Right => Dir::Right,
+        monolith_ipc::Dir::Up => Dir::Up,
+        monolith_ipc::Dir::Down => Dir::Down,
+    }
+}
+
+impl State {
+    pub fn run(&mut self, cmd: Command) -> Result<(), String> {
+        let output = self.layout.active_output();
+        let focused = self.layout.focused();
+        let on_focused = |state: &mut Self, f: fn(&mut monolith_layout::Layout, WindowId)| {
+            if let Some(w) = focused {
+                f(&mut state.layout, w);
+            }
+        };
+        match cmd {
+            Command::Spawn { argv } => self.spawn(&argv)?,
+            Command::Close => {
+                if let Some(t) = focused
+                    .and_then(|w| self.windows.get(&w))
+                    .and_then(|w| w.toplevel())
+                {
+                    t.send_close();
+                }
+            }
+            Command::Quit => self.signal.stop(),
+            Command::Reload => self.reload()?,
+            Command::Focus { dir: d } => {
+                self.layout.focus_dir(dir(d));
+            }
+            Command::Move { dir: d } => {
+                self.layout.move_window(dir(d));
+            }
+            Command::MoveBlock { dir: d } => {
+                self.layout.move_block(dir(d));
+            }
+            Command::Resize { axis, delta } => {
+                let axis = match axis {
+                    monolith_ipc::Axis::Horizontal => Axis::Horizontal,
+                    monolith_ipc::Axis::Vertical => Axis::Vertical,
+                };
+                self.layout.resize(axis, delta);
+            }
+            Command::Expand { scope } => {
+                self.layout.expand(match scope {
+                    monolith_ipc::ExpandScope::Window => ExpandScope::Window,
+                    monolith_ipc::ExpandScope::Block => ExpandScope::Block,
+                    monolith_ipc::ExpandScope::All => ExpandScope::All,
+                });
+            }
+            Command::Flip => output.into_iter().for_each(|o| self.layout.flip(o)),
+            Command::Float => on_focused(self, |l, w| l.toggle_floating(w)),
+            Command::Fullscreen => on_focused(self, |l, w| l.toggle_fullscreen(w)),
+            Command::Sticky => on_focused(self, |l, w| l.toggle_sticky(w)),
+            Command::View { tag } => {
+                let t = self.layout.tag(&tag);
+                output.into_iter().for_each(|o| self.layout.view(o, t));
+            }
+            Command::ToggleView { tag } => {
+                let t = self.layout.tag(&tag);
+                output
+                    .into_iter()
+                    .for_each(|o| self.layout.toggle_view(o, t));
+            }
+            Command::ViewEverywhere { tag } => {
+                let t = self.layout.tag(&tag);
+                self.layout.view_everywhere(t);
+            }
+            Command::Tag { tag } => {
+                let t = self.layout.tag(&tag);
+                if let Some(w) = focused {
+                    self.layout.set_tag(w, t);
+                }
+            }
+            Command::ReorderTag { tag, index } => {
+                let t = self
+                    .layout
+                    .tag_id(&tag)
+                    .ok_or_else(|| format!("no tag {tag}"))?;
+                self.layout.reorder_tag(t, index);
+            }
+            Command::FocusOutput { dir: d } => {
+                if let Some(o) = output.and_then(|o| self.layout.output_towards(o, dir(d))) {
+                    self.layout.set_active_output(o);
+                    if let Some(w) = self.layout.focused_on(o) {
+                        self.layout.focus(w);
+                    }
+                }
+            }
+            Command::SendToOutput { dir: d } => {
+                if let (Some(w), Some(o)) = (
+                    focused,
+                    output.and_then(|o| self.layout.output_towards(o, dir(d))),
+                ) {
+                    self.layout.send_to_output(w, o);
+                }
+            }
+            Command::Scratchpad { name } => {
+                if let Some(w) = focused {
+                    self.layout.scratchpad_add(w, &name);
+                }
+            }
+            Command::Summon { name } => {
+                if !self.layout.scratchpads().iter().any(|s| s.name == name) {
+                    return Err(format!("no scratchpad {name}"));
+                }
+                self.layout.summon(&name);
+            }
+            Command::Dismiss { name } => self.layout.dismiss(name.as_deref()),
+        }
+        self.apply_layout();
+        Ok(())
+    }
+
+    pub fn spawn(&mut self, argv: &[String]) -> Result<(), String> {
+        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)
+            .stdin(Stdio::null());
+        if let Some(sock) = &self.ipc.path {
+            cmd.env("MONOLITH_SOCKET", sock);
+        }
+        let mut child = cmd.spawn().map_err(|e| format!("{program}: {e}"))?;
+        let output = self.layout.active_output();
+        let tag = output.map_or(self.layout.homeless(), |o| self.layout.launch_tag(o));
+        self.launches.record(child.id(), output, tag);
+        std::thread::spawn(move || child.wait());
+        Ok(())
+    }
+
+    /// 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);
+        self.layout.gaps = crate::state::gaps(&config);
+        self.config = config;
+        if keyboard_changed {
+            self.reconfigure_keyboard();
+        }
+        tracing::info!("config reloaded");
+        Ok(())
+    }
+}

Modified file: crates/monolith/src/handlers.rs+60 additions−19 deletions@@ -7,6 +7,8 @@ use smithay::input::dnd::{DndGrabHandler, GrabType, Source};
 use smithay::input::pointer::CursorImageStatus;
 use smithay::input::{Seat, SeatHandler, SeatState};
 use smithay::reexports::wayland_server::protocol::wl_buffer::WlBuffer;
+use smithay::reexports::wayland_protocols::xdg::decoration::zv1::server::zxdg_toplevel_decoration_v1::Mode as DecorationMode;
+use smithay::reexports::wayland_server::protocol::wl_output::WlOutput;
 use smithay::reexports::wayland_server::protocol::wl_seat::WlSeat;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::reexports::wayland_server::{Client, Resource};
@@ -21,6 +23,7 @@ use smithay::wayland::selection::SelectionHandler;
 use smithay::wayland::selection::data_device::{
     DataDeviceHandler, DataDeviceState, WaylandDndGrabHandler, set_data_device_focus,
 };
+use smithay::wayland::shell::xdg::decoration::XdgDecorationHandler;
 use smithay::wayland::shell::xdg::{
     PopupSurface, PositionerState, ToplevelSurface, XdgShellHandler, XdgShellState,
 };
@@ -46,22 +49,25 @@ impl CompositorHandler for State {
                 root = parent;
             }
             if let Some(window) = self
-                .space
-                .elements()
+                .windows
+                .values()
+                .chain(&self.unmapped)
                 .find(|w| w.toplevel().is_some_and(|t| t.wl_surface() == &root))
             {
                 window.on_commit();
             }
         }
-        if let Some(window) = self
-            .space
-            .elements()
-            .find(|w| w.toplevel().is_some_and(|t| t.wl_surface() == surface))
-            .cloned()
-            && let Some(toplevel) = window.toplevel()
-            && !toplevel.is_initial_configure_sent()
+        if let Some(i) = self
+            .unmapped
+            .iter()
+            .position(|w| w.toplevel().is_some_and(|t| t.wl_surface() == surface))
         {
-            toplevel.send_configure();
+            let window = self.unmapped.remove(i);
+            let toplevel = window.toplevel().cloned();
+            self.map_window(window);
+            if let Some(t) = toplevel {
+                t.send_configure();
+            }
         }
         self.popups.commit(surface);
         if let Some(PopupKind::Xdg(popup)) = self.popups.find_popup(surface)
@@ -108,17 +114,19 @@ impl XdgShellHandler for State {
     }
 
     fn new_toplevel(&mut self, surface: ToplevelSurface) {
-        let focus = surface.wl_surface().clone();
-        self.space
-            .map_element(Window::new_wayland_window(surface), (0, 0), true);
-        self.relayout();
-        if let Some(keyboard) = self.seat.get_keyboard() {
-            keyboard.set_focus(self, Some(focus), Serial::from(0));
-        }
+        self.unmapped.push(Window::new_wayland_window(surface));
+    }
+
+    fn toplevel_destroyed(&mut self, surface: ToplevelSurface) {
+        self.unmap_window(surface.wl_surface());
+    }
+
+    fn fullscreen_request(&mut self, surface: ToplevelSurface, _output: Option<WlOutput>) {
+        self.set_fullscreen(surface.wl_surface(), true);
     }
 
-    fn toplevel_destroyed(&mut self, _surface: ToplevelSurface) {
-        self.relayout();
+    fn unfullscreen_request(&mut self, surface: ToplevelSurface) {
+        self.set_fullscreen(surface.wl_surface(), false);
     }
 
     fn new_popup(&mut self, surface: PopupSurface, positioner: PositionerState) {
@@ -204,3 +212,36 @@ impl smithay::wayland::pointer_constraints::PointerConstraintsHandler for State 
 }
 
 smithay::delegate_dispatch2!(State);
+
+impl XdgDecorationHandler for State {
+    fn new_decoration(&mut self, toplevel: ToplevelSurface) {
+        server_side(&toplevel);
+    }
+
+    fn request_mode(&mut self, toplevel: ToplevelSurface, _mode: DecorationMode) {
+        server_side(&toplevel);
+    }
+
+    fn unset_mode(&mut self, toplevel: ToplevelSurface) {
+        server_side(&toplevel);
+    }
+}
+
+/// monolith draws no titlebars, and clients are told so whatever they ask for.
+fn server_side(toplevel: &ToplevelSurface) {
+    toplevel.with_pending_state(|s| s.decoration_mode = Some(DecorationMode::ServerSide));
+    if toplevel.is_initial_configure_sent() {
+        toplevel.send_pending_configure();
+    }
+}
+
+impl State {
+    fn set_fullscreen(&mut self, surface: &WlSurface, on: bool) {
+        if let Some(id) = self.window_id(surface)
+            && self.layout.window(id).is_some_and(|w| w.fullscreen != on)
+        {
+            self.layout.toggle_fullscreen(id);
+            self.apply_layout();
+        }
+    }
+}

Modified file: crates/monolith/src/input.rs+36 additions−13 deletions@@ -133,14 +133,37 @@ impl Dispatch<wl_keyboard::WlKeyboard, ()> for State {
                 _ => KeyState::Released,
             };
             let time = InputTime::now();
-            keyboard.input::<(), _>(
+            let code = Keycode::new(key + 8);
+            let action = keyboard.input(
                 state,
-                Keycode::new(key + 8),
+                code,
                 key_state,
                 SERIAL_COUNTER.next_serial(),
                 time,
-                |_, _, _| FilterResult::Forward,
+                |state, mods, handle| {
+                    if key_state == KeyState::Released {
+                        let before = state.suppressed.len();
+                        state.suppressed.retain(|k| *k != code);
+                        return if state.suppressed.len() < before {
+                            FilterResult::Intercept(None)
+                        } else {
+                            FilterResult::Forward
+                        };
+                    }
+                    match state.binds.find(mods, &handle.raw_syms()) {
+                        Some(cmd) => {
+                            state.suppressed.push(code);
+                            FilterResult::Intercept(Some(cmd))
+                        }
+                        None => FilterResult::Forward,
+                    }
+                },
             );
+            if let Some(Some(cmd)) = action
+                && let Err(e) = state.run(cmd)
+            {
+                tracing::warn!("bind failed: {e}");
+            }
         }
     }
 }
@@ -149,15 +172,15 @@ fn focus_under_pointer(state: &mut State) {
     let Some(pos) = state.host.as_ref().map(|h| h.pointer_pos) else {
         return;
     };
-    let Some((window, _)) = state.space.element_under(pos).map(|(w, l)| (w.clone(), l)) else {
-        return;
-    };
-    state.space.raise_element(&window, true);
-    if let (Some(keyboard), Some(toplevel)) = (state.seat.get_keyboard(), window.toplevel()) {
-        keyboard.set_focus(
-            state,
-            Some(toplevel.wl_surface().clone()),
-            SERIAL_COUNTER.next_serial(),
-        );
+    let id = state
+        .space
+        .element_under(pos)
+        .and_then(|(w, _)| w.toplevel())
+        .and_then(|t| state.window_id(t.wl_surface()));
+    if let Some(id) = id
+        && state.layout.focused() != Some(id)
+    {
+        state.layout.focus(id);
+        state.apply_layout();
     }
 }

Added file: crates/monolith/src/ipc.rs+272 additions@@ -0,0 +1,272 @@
+//! The JSONL control socket, and the `msg`, `get` and `subscribe` client
+//! subcommands that talk to it.
+
+use crate::state::{State, identity};
+use monolith_ipc::{Answer, Command, Envelope, Query, Reply, Request, VERSION};
+use smithay::reexports::calloop::generic::Generic;
+use smithay::reexports::calloop::{EventLoop, Interest, LoopHandle, Mode, PostAction};
+use std::io::{BufRead, BufReader, ErrorKind, Read, Write};
+use std::os::unix::net::{UnixListener, UnixStream};
+use std::path::PathBuf;
+use std::process::ExitCode;
+
+#[derive(Default)]
+pub struct Server {
+    pub path: Option<PathBuf>,
+    handle: Option<LoopHandle<'static, State>>,
+    subscribers: Vec<UnixStream>,
+    last: Option<monolith_ipc::State>,
+}
+
+impl Drop for Server {
+    fn drop(&mut self) {
+        if let Some(p) = &self.path {
+            let _ = std::fs::remove_file(p);
+        }
+    }
+}
+
+pub fn init(event_loop: &EventLoop<'static, State>, state: &mut State) -> std::io::Result<()> {
+    let Some(path) = state
+        .socket_name
+        .to_str()
+        .and_then(monolith_ipc::socket_path_for)
+    else {
+        tracing::warn!("no XDG_RUNTIME_DIR, the control socket is disabled");
+        return Ok(());
+    };
+    let _ = std::fs::remove_file(&path);
+    let listener = UnixListener::bind(&path)?;
+    listener.set_nonblocking(true)?;
+    tracing::info!(path = %path.display(), "control socket");
+    state.ipc.path = Some(path);
+    let handle = event_loop.handle();
+    state.ipc.handle = Some(handle.clone());
+    handle
+        .insert_source(
+            Generic::new(listener, Interest::READ, Mode::Level),
+            |_, listener, state| {
+                loop {
+                    match listener.accept() {
+                        Ok((stream, _)) => add_client(state, stream),
+                        Err(e) if e.kind() == ErrorKind::WouldBlock => break,
+                        Err(e) => return Err(e),
+                    }
+                }
+                Ok(PostAction::Continue)
+            },
+        )
+        .map_err(|e| std::io::Error::other(e.to_string()))?;
+    Ok(())
+}
+
+fn add_client(state: &mut State, stream: UnixStream) {
+    let Some(handle) = state.ipc.handle.clone() else {
+        return;
+    };
+    if stream.set_nonblocking(true).is_err() {
+        return;
+    }
+    let mut buf = Vec::new();
+    let source = Generic::new(stream, Interest::READ, Mode::Level);
+    let inserted = handle.insert_source(source, move |_, stream, state| {
+        let mut chunk = [0u8; 4096];
+        loop {
+            match (&**stream).read(&mut chunk) {
+                Ok(0) => return Ok(PostAction::Remove),
+                Ok(n) => buf.extend_from_slice(&chunk[..n]),
+                Err(e) if e.kind() == ErrorKind::WouldBlock => break,
+                Err(_) => return Ok(PostAction::Remove),
+            }
+        }
+        while let Some(i) = buf.iter().position(|&b| b == b'\n') {
+            let line: Vec<u8> = buf.drain(..=i).collect();
+            if let Some(reply) = handle_line(state, stream, &line[..i]) {
+                send(stream, &reply);
+            }
+        }
+        Ok(PostAction::Continue)
+    });
+    if let Err(e) = inserted {
+        tracing::warn!("ipc client dropped: {e}");
+    }
+}
+
+fn handle_line(state: &mut State, stream: &UnixStream, line: &[u8]) -> Option<Envelope<Reply>> {
+    let req: Envelope<Request> = match serde_json::from_slice(line) {
+        Ok(r) => r,
+        Err(e) => return Some(Envelope::new(None, Reply::Error(e.to_string()))),
+    };
+    let id = req.id;
+    if req.v != VERSION {
+        let msg = format!("protocol version {} is not {VERSION}", req.v);
+        return Some(Envelope::new(id, Reply::Error(msg)));
+    }
+    let reply = match req.body {
+        Request::Run(cmd) => match state.run(cmd) {
+            Ok(()) => Reply::Ok(None),
+            Err(e) => Reply::Error(e),
+        },
+        Request::Get(Query::State) => Reply::Ok(Some(Answer::State(snapshot(state)))),
+        Request::Get(Query::Version) => {
+            Reply::Ok(Some(Answer::Version(env!("CARGO_PKG_VERSION").into())))
+        }
+        Request::Subscribe {} => {
+            let Ok(sub) = stream.try_clone() else {
+                return Some(Envelope::new(id, Reply::Error("cannot subscribe".into())));
+            };
+            send(&sub, &Envelope::new(None, Reply::Event(snapshot(state))));
+            state.ipc.subscribers.push(sub);
+            return None;
+        }
+    };
+    Some(Envelope::new(id, reply))
+}
+
+fn send(mut stream: &UnixStream, msg: &Envelope<Reply>) -> bool {
+    let Ok(mut line) = serde_json::to_vec(msg) else {
+        return false;
+    };
+    line.push(b'\n');
+    stream.write_all(&line).is_ok()
+}
+
+/// Sends subscribers the new state whenever it differs from the last one.
+pub fn broadcast(state: &mut State) {
+    if state.ipc.subscribers.is_empty() {
+        return;
+    }
+    let now = snapshot(state);
+    if state.ipc.last.as_ref() == Some(&now) {
+        return;
+    }
+    let msg = Envelope::new(None, Reply::Event(now.clone()));
+    state.ipc.subscribers.retain(|s| send(s, &msg));
+    state.ipc.last = Some(now);
+}
+
+fn snapshot(state: &State) -> monolith_ipc::State {
+    let l = &state.layout;
+    let focused = l.focused();
+    let tags = l
+        .tags()
+        .map(|(_, t)| monolith_ipc::Tag {
+            name: t.name.clone(),
+            urgent: t.urgent,
+        })
+        .collect();
+    let outputs = l
+        .outputs()
+        .map(|(id, o)| monolith_ipc::Output {
+            name: o.name.clone(),
+            area: [o.area.x, o.area.y, o.area.w, o.area.h],
+            viewed: o
+                .viewed
+                .iter()
+                .filter_map(|&t| l.tags().find(|(id, _)| *id == t))
+                .map(|(_, t)| t.name.clone())
+                .collect(),
+            active: l.active_output() == Some(id),
+        })
+        .collect();
+    let mut windows: Vec<monolith_ipc::Window> = l
+        .windows()
+        .map(|(id, w)| {
+            let (app_id, title) = state
+                .windows
+                .get(&id)
+                .and_then(|w| w.toplevel())
+                .map(identity)
+                .unwrap_or_default();
+            monolith_ipc::Window {
+                id: slotmap::Key::data(&id).as_ffi(),
+                app_id,
+                title,
+                tag: l
+                    .tags()
+                    .find(|(t, _)| *t == w.tag)
+                    .map(|(_, t)| t.name.clone())
+                    .unwrap_or_default(),
+                output: w.output.and_then(|o| l.output(o)).map(|o| o.name.clone()),
+                floating: w.floating,
+                fullscreen: w.fullscreen,
+                sticky: w.sticky,
+                scratchpad: w
+                    .scratchpad
+                    .and_then(|s| l.scratchpads().get(s))
+                    .map(|s| s.name.clone()),
+                visible: l.visible(id),
+                focused: focused == Some(id),
+            }
+        })
+        .collect();
+    windows.sort_by_key(|w| w.id);
+    monolith_ipc::State {
+        tags,
+        outputs,
+        windows,
+    }
+}
+
+/// Runs a client subcommand, if `args` names one.
+pub fn client(args: &[String]) -> Option<ExitCode> {
+    let (sub, rest) = args.split_first()?;
+    let request = match sub.as_str() {
+        "msg" => match Command::parse(rest) {
+            Ok(cmd) => Request::Run(cmd),
+            Err(e) => return Some(fail(&e.to_string())),
+        },
+        "get" => match rest {
+            [q] if q == "state" => Request::Get(Query::State),
+            [q] if q == "version" => Request::Get(Query::Version),
+            _ => return Some(fail("get takes state or version")),
+        },
+        "subscribe" => Request::Subscribe {},
+        _ => return None,
+    };
+    Some(talk(request))
+}
+
+fn fail(msg: &str) -> ExitCode {
+    eprintln!("monolith: {msg}");
+    ExitCode::FAILURE
+}
+
+fn talk(request: Request) -> ExitCode {
+    let Some(path) = monolith_ipc::socket_path() else {
+        return fail("no socket, set MONOLITH_SOCKET or WAYLAND_DISPLAY");
+    };
+    let mut stream = match UnixStream::connect(&path) {
+        Ok(s) => s,
+        Err(e) => return fail(&format!("{}: {e}", path.display())),
+    };
+    let subscribe = matches!(request, Request::Subscribe {});
+    let mut line =
+        serde_json::to_vec(&Envelope::new(Some(1), request)).expect("requests serialize");
+    line.push(b'\n');
+    if let Err(e) = stream.write_all(&line) {
+        return fail(&e.to_string());
+    }
+    for line in BufReader::new(stream).lines() {
+        let Ok(line) = line else { break };
+        let reply: Envelope<Reply> = match serde_json::from_str(&line) {
+            Ok(r) => r,
+            Err(e) => return fail(&format!("bad reply: {e}")),
+        };
+        match reply.body {
+            Reply::Error(e) => return fail(&e),
+            Reply::Ok(None) => {}
+            Reply::Ok(Some(answer)) => match answer {
+                Answer::Version(v) => println!("{v}"),
+                Answer::State(s) => {
+                    println!("{}", serde_json::to_string_pretty(&s).unwrap_or_default())
+                }
+            },
+            Reply::Event(s) => println!("{}", serde_json::to_string(&s).unwrap_or_default()),
+        }
+        if !subscribe {
+            break;
+        }
+    }
+    ExitCode::SUCCESS
+}

Added file: crates/monolith/src/launch.rs+47 additions@@ -0,0 +1,47 @@
+//! Launch context. A window goes to the output and tag the user was on when
+//! its launch began, found by matching its process or an ancestor against
+//! the programs monolith spawned.
+
+use monolith_layout::{OutputId, TagId};
+use std::time::{Duration, Instant};
+
+const KEEP: Duration = Duration::from_secs(120);
+
+struct Launch {
+    pid: u32,
+    output: Option<OutputId>,
+    tag: TagId,
+    at: Instant,
+}
+
+#[derive(Default)]
+pub struct Launches(Vec<Launch>);
+
+impl Launches {
+    pub fn record(&mut self, pid: u32, output: Option<OutputId>, tag: TagId) {
+        self.0.retain(|l| l.at.elapsed() < KEEP);
+        self.0.push(Launch {
+            pid,
+            output,
+            tag,
+            at: Instant::now(),
+        });
+    }
+
+    pub fn find(&self, pid: u32) -> Option<(Option<OutputId>, TagId)> {
+        let mut pid = pid;
+        for _ in 0..32 {
+            if let Some(l) = self.0.iter().find(|l| l.pid == pid) {
+                return Some((l.output, l.tag));
+            }
+            pid = parent(pid).filter(|&p| p > 1)?;
+        }
+        None
+    }
+}
+
+fn parent(pid: u32) -> Option<u32> {
+    let stat = std::fs::read_to_string(format!("/proc/{pid}/stat")).ok()?;
+    let rest = stat.get(stat.rfind(')')? + 2..)?;
+    rest.split(' ').nth(1)?.parse().ok()
+}

Modified file: crates/monolith/src/main.rs+30 additions−9 deletions@@ -1,32 +1,53 @@
+mod commands;
 mod handlers;
 mod input;
+mod ipc;
+mod launch;
 mod nested;
 mod state;
 
 use smithay::reexports::calloop::EventLoop;
 use smithay::reexports::wayland_server::Display;
 use state::State;
-use std::process::Command;
+use std::process::ExitCode;
 use tracing_subscriber::EnvFilter;
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
+fn main() -> ExitCode {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    if let Some(code) = ipc::client(&args) {
+        return code;
+    }
     tracing_subscriber::fmt()
         .with_env_filter(
             EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
         )
         .init();
-    let mut event_loop: EventLoop<State> = EventLoop::try_new()?;
+    match run(&args) {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(e) => {
+            tracing::error!("{e}");
+            ExitCode::FAILURE
+        }
+    }
+}
+
+/// Runs the compositor. Any arguments are a program to start inside it.
+fn run(args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let mut event_loop: EventLoop<'static, State> = EventLoop::try_new()?;
     let display: Display<State> = Display::new()?;
     let mut state = State::new(&mut event_loop, display)?;
     nested::init(&mut event_loop, &mut state)?;
+    ipc::init(&event_loop, &mut state)?;
     tracing::info!(socket = ?state.socket_name, device = state.renderer.device_name(), "monolith running nested");
 
-    let args: Vec<String> = std::env::args().skip(1).collect();
-    if let Some((program, rest)) = args.split_first() {
-        Command::new(program)
-            .args(rest)
-            .env("WAYLAND_DISPLAY", &state.socket_name)
-            .spawn()?;
+    let startup = state.config.startup.clone();
+    for argv in startup
+        .iter()
+        .chain((!args.is_empty()).then_some(&args.to_vec()))
+    {
+        if let Err(e) = state.spawn(argv) {
+            tracing::warn!("startup: {e}");
+        }
     }
 
     event_loop.run(None, &mut state, |state| state.after_dispatch())?;

Modified file: crates/monolith/src/nested.rs+9 additions−1 deletions@@ -5,6 +5,7 @@
 
 use crate::state::State;
 use calloop_wayland_source::WaylandSource;
+use monolith_layout::Rect;
 use monolith_render_vk::VulkanAllocator;
 use smithay::backend::allocator::dmabuf::Dmabuf;
 use smithay::backend::allocator::{Format, Fourcc, Modifier, Slot, Swapchain};
@@ -107,6 +108,13 @@ pub fn init(
     );
     output.set_preferred(mode);
     state.space.map_output(&output, (0, 0));
+    let area = Rect::new(
+        0.0,
+        0.0,
+        f64::from(DEFAULT_SIZE.0),
+        f64::from(DEFAULT_SIZE.1),
+    );
+    state.output_id = Some(state.layout.add_output("nested", area));
 
     state.host = Some(Host {
         size: DEFAULT_SIZE.into(),
@@ -359,7 +367,7 @@ impl Dispatch<xdg_toplevel::XdgToplevel, ()> for State {
                 {
                     host.pending_size = Some(size);
                     host.size = size;
-                    state.relayout();
+                    state.resize_output(size);
                 }
             }
             xdg_toplevel::Event::Close => state.signal.stop(),

Modified file: crates/monolith/src/state.rs+264 additions−24 deletions@@ -1,22 +1,30 @@
+use crate::commands::Binds;
 use crate::nested::Host;
+use monolith_config::Config;
+use monolith_layout::{Layout, OutputId, Rect, WindowId};
 use monolith_render_vk::VulkanRenderer;
 use smithay::backend::renderer::ImportDma;
 use smithay::desktop::{PopupManager, Space, Window, WindowSurfaceType};
+use smithay::input::keyboard::{Keycode, XkbConfig};
 use smithay::input::{Seat, SeatState};
 use smithay::reexports::calloop::generic::Generic;
 use smithay::reexports::calloop::{EventLoop, Interest, LoopSignal, Mode, PostAction};
+use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel::State as XdgState;
 use smithay::reexports::wayland_server::backend::{ClientData, ClientId, DisconnectReason};
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
-use smithay::reexports::wayland_server::{Display, DisplayHandle};
-use smithay::utils::{Logical, Point, Size};
-use smithay::wayland::compositor::{CompositorClientState, CompositorState};
+use smithay::reexports::wayland_server::{Display, DisplayHandle, Resource};
+use smithay::utils::{Logical, Point, SERIAL_COUNTER, Size};
+use smithay::wayland::compositor::{CompositorClientState, CompositorState, with_states};
 use smithay::wayland::dmabuf::{DmabufGlobal, DmabufState};
 use smithay::wayland::output::OutputManagerState;
 use smithay::wayland::selection::data_device::DataDeviceState;
-use smithay::wayland::shell::xdg::XdgShellState;
+use smithay::wayland::shell::xdg::decoration::XdgDecorationState;
+use smithay::wayland::shell::xdg::{XdgShellState, XdgToplevelSurfaceData};
 use smithay::wayland::shm::ShmState;
 use smithay::wayland::socket::ListeningSocketSource;
+use std::collections::HashMap;
 use std::ffi::OsString;
+use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::Instant;
 
@@ -31,8 +39,22 @@ pub struct State {
     pub host: Option<Host>,
     pub needs_redraw: bool,
 
+    pub layout: Layout,
+    pub windows: HashMap<WindowId, Window>,
+    /// Toplevels that have not committed yet. Rules need their app_id and
+    /// 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 ipc: crate::ipc::Server,
+    pub launches: crate::launch::Launches,
+
     pub compositor_state: CompositorState,
     pub xdg_shell_state: XdgShellState,
+    pub _xdg_decoration_state: XdgDecorationState,
     pub shm_state: ShmState,
     pub dmabuf_state: DmabufState,
     pub _dmabuf_global: DmabufGlobal,
@@ -48,12 +70,18 @@ impl State {
         display: Display<State>,
     ) -> Result<Self, Box<dyn std::error::Error>> {
         let dh = display.handle();
+        let config_path = Config::path();
+        let config = Config::load(config_path.as_deref()).unwrap_or_else(|e| {
+            tracing::error!("config: {e}, using the built-in default");
+            Config::parse(monolith_config::DEFAULT).expect("the default config parses")
+        });
         let renderer = 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");
-        seat.add_keyboard(Default::default(), 200, 25)?;
+        let kb = &config.keyboard;
+        seat.add_keyboard(xkb_config(kb), kb.repeat_delay, kb.repeat_rate)?;
         seat.add_pointer();
 
         let listener = ListeningSocketSource::new_auto()?;
@@ -76,6 +104,9 @@ impl State {
             },
         )?;
 
+        let mut layout = Layout::default();
+        layout.gaps = gaps(&config);
+        let binds = Binds::new(&config);
         Ok(Self {
             start: Instant::now(),
             socket_name,
@@ -85,8 +116,19 @@ impl State {
             popups: PopupManager::default(),
             host: None,
             needs_redraw: true,
+            layout,
+            windows: HashMap::new(),
+            unmapped: Vec::new(),
+            output_id: None,
+            config,
+            config_path,
+            binds,
+            suppressed: Vec::new(),
+            ipc: crate::ipc::Server::default(),
+            launches: Default::default(),
             compositor_state: CompositorState::new::<State>(&dh),
             xdg_shell_state: XdgShellState::new::<State>(&dh),
+            _xdg_decoration_state: XdgDecorationState::new::<State>(&dh),
             shm_state: ShmState::new::<State>(&dh, vec![]),
             dmabuf_state,
             _dmabuf_global: dmabuf_global,
@@ -103,37 +145,157 @@ impl State {
         self.space.refresh();
         self.popups.cleanup();
         crate::nested::render(self);
+        crate::ipc::broadcast(self);
         let _ = self.display.flush_clients();
     }
 
-    pub fn output_size(&self) -> Size<i32, Logical> {
-        self.host.as_ref().map_or((1280, 800).into(), |h| h.size)
+    pub fn resize_output(&mut self, size: Size<i32, Logical>) {
+        if let Some(o) = self.output_id {
+            let area = Rect::new(0.0, 0.0, f64::from(size.w), f64::from(size.h));
+            self.layout.set_output_area(o, area);
+            self.apply_layout();
+        }
     }
 
-    /// Lays toplevels out side by side across the output. A stand-in until
-    /// the layout crate takes over.
-    pub fn relayout(&mut self) {
-        let windows: Vec<Window> = self.space.elements().cloned().collect();
-        let size = self.output_size();
-        let n = windows.len() as i32;
-        if n == 0 {
-            return;
+    /// Adds a toplevel to the layout on its first commit, where its app_id
+    /// and title are known and the initial configure can carry its size.
+    pub fn map_window(&mut self, window: Window) {
+        let (app_id, title) = window.toplevel().map(identity).unwrap_or_default();
+        let rule = self.config.placement(&app_id, &title);
+        let launch = window
+            .toplevel()
+            .and_then(|t| t.wl_surface().client())
+            .and_then(|c| c.get_credentials(&self.display).ok())
+            .and_then(|c| self.launches.find(c.pid as u32));
+        let output = rule
+            .output
+            .as_deref()
+            .and_then(|name| {
+                self.layout
+                    .outputs()
+                    .find(|(_, o)| o.name == name)
+                    .map(|(id, _)| id)
+            })
+            .or(launch.and_then(|l| l.0));
+        let tag = match rule.tag.as_deref() {
+            Some(t) => Some(self.layout.tag(t)),
+            None => launch.map(|l| l.1),
+        };
+        let id = self.layout.add_window(output, tag, None);
+        if rule.floating == Some(true) {
+            self.layout.toggle_floating(id);
+        }
+        if rule.sticky == Some(true) {
+            self.layout.toggle_sticky(id);
         }
-        let gap = 8;
-        let w = (size.w - gap * (n + 1)) / n;
-        for (i, window) in windows.into_iter().enumerate() {
-            let loc = (gap + i as i32 * (w + gap), gap);
-            if let Some(toplevel) = window.toplevel() {
-                toplevel.with_pending_state(|s| s.size = Some((w, size.h - 2 * gap).into()));
-                if toplevel.is_initial_configure_sent() {
-                    toplevel.send_pending_configure();
+        if let Some(name) = &rule.scratchpad {
+            self.layout.scratchpad_add(id, name);
+        }
+        self.windows.insert(id, window);
+        if self.layout.visible(id) {
+            self.layout.focus(id);
+        }
+        self.apply_layout();
+    }
+
+    pub fn unmap_window(&mut self, surface: &WlSurface) {
+        self.unmapped
+            .retain(|w| w.toplevel().is_some_and(|t| t.wl_surface() != surface));
+        if let Some(id) = self.window_id(surface) {
+            if let Some(window) = self.windows.remove(&id) {
+                self.space.unmap_elem(&window);
+            }
+            self.layout.remove_window(id);
+            self.apply_layout();
+        }
+    }
+
+    pub fn window_id(&self, surface: &WlSurface) -> Option<WindowId> {
+        self.windows
+            .iter()
+            .find(|(_, w)| w.toplevel().is_some_and(|t| t.wl_surface() == surface))
+            .map(|(id, _)| *id)
+    }
+
+    /// Pushes the layout's target geometry into the space and to clients.
+    pub fn apply_layout(&mut self) {
+        let mut shown = Vec::new();
+        let outputs: Vec<OutputId> = self.layout.outputs().map(|(o, _)| o).collect();
+        for o in outputs {
+            let arr = self.layout.arrange(o);
+            let area = self.layout.output(o).map(|o| o.area).unwrap_or_default();
+            for p in &arr.tiled {
+                if p.visible && arr.fullscreen != Some(p.window) {
+                    shown.push((p.window, p.rect, Kind::Tiled));
+                }
+            }
+            for &(w, rect) in &arr.floating {
+                if arr.fullscreen != Some(w) {
+                    shown.push((w, rect, Kind::Floating));
                 }
             }
-            self.space.map_element(window, loc, false);
+            if let Some(w) = arr.fullscreen {
+                shown.push((w, area, Kind::Fullscreen));
+            }
+        }
+        let mut mapped = Vec::new();
+        for (id, rect, kind) in shown {
+            if let Some(window) = self.windows.get(&id)
+                && configure(window, rect, kind)
+            {
+                let loc = (rect.x.round() as i32, rect.y.round() as i32);
+                let loc = Point::from(loc) - window.geometry().loc;
+                self.space.map_element(window.clone(), loc, false);
+                mapped.push(id);
+            }
         }
+        let hidden: Vec<Window> = self
+            .windows
+            .iter()
+            .filter(|(id, _)| !mapped.contains(id))
+            .map(|(_, w)| w.clone())
+            .collect();
+        for window in hidden {
+            self.space.unmap_elem(&window);
+        }
+        for id in &mapped {
+            self.space.raise_element(&self.windows[id], false);
+        }
+        self.sync_focus();
         self.needs_redraw = true;
     }
 
+    fn sync_focus(&mut self) {
+        let focused = self.layout.focused();
+        for (id, window) in &self.windows {
+            if window.set_activated(Some(*id) == focused)
+                && let Some(t) = window.toplevel()
+                && t.is_initial_configure_sent()
+            {
+                t.send_pending_configure();
+            }
+        }
+        let target = focused
+            .and_then(|id| self.windows.get(&id))
+            .and_then(|w| w.toplevel())
+            .map(|t| t.wl_surface().clone());
+        if let Some(keyboard) = self.seat.get_keyboard()
+            && keyboard.current_focus() != target
+        {
+            keyboard.set_focus(self, target, SERIAL_COUNTER.next_serial());
+        }
+    }
+
+    pub fn reconfigure_keyboard(&mut self) {
+        let kb = self.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:?}");
+            }
+            keyboard.change_repeat_info(kb.repeat_rate, kb.repeat_delay);
+        }
+    }
+
     pub fn surface_under(
         &self,
         pos: Point<f64, Logical>,
@@ -148,6 +310,84 @@ impl State {
     }
 }
 
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Kind {
+    Tiled,
+    Floating,
+    Fullscreen,
+}
+
+/// Sets a window's pending size and states. Returns false for windows
+/// squeezed to a line by an expanded sibling, which are not shown.
+fn configure(window: &Window, rect: Rect, kind: Kind) -> bool {
+    let (x, y) = (rect.x.round(), rect.y.round());
+    let w = (rect.right().round() - x) as i32;
+    let h = (rect.bottom().round() - y) as i32;
+    if w < 1 || h < 1 {
+        return false;
+    }
+    if let Some(t) = window.toplevel() {
+        t.with_pending_state(|s| {
+            s.size = Some((w, h).into());
+            let tiled = [
+                XdgState::TiledLeft,
+                XdgState::TiledRight,
+                XdgState::TiledTop,
+                XdgState::TiledBottom,
+            ];
+            for st in tiled {
+                if kind == Kind::Tiled {
+                    s.states.set(st);
+                } else {
+                    s.states.unset(st);
+                }
+            }
+            if kind == Kind::Fullscreen {
+                s.states.set(XdgState::Fullscreen);
+            } else {
+                s.states.unset(XdgState::Fullscreen);
+            }
+        });
+        if t.is_initial_configure_sent() {
+            t.send_pending_configure();
+        }
+    }
+    true
+}
+
+pub fn identity(t: &smithay::wayland::shell::xdg::ToplevelSurface) -> (String, String) {
+    with_states(t.wl_surface(), |s| {
+        let data = s
+            .data_map
+            .get::<XdgToplevelSurfaceData>()
+            .and_then(|d| d.lock().ok());
+        data.map(|d| {
+            (
+                d.app_id.clone().unwrap_or_default(),
+                d.title.clone().unwrap_or_default(),
+            )
+        })
+        .unwrap_or_default()
+    })
+}
+
+pub fn gaps(config: &Config) -> monolith_layout::Gaps {
+    monolith_layout::Gaps {
+        inner: config.general.gaps.inner,
+        outer: config.general.gaps.outer,
+    }
+}
+
+fn xkb_config(kb: &monolith_config::Keyboard) -> XkbConfig<'_> {
+    XkbConfig {
+        rules: &kb.rules,
+        model: &kb.model,
+        layout: &kb.layout,
+        variant: &kb.variant,
+        options: kb.options.clone(),
+    }
+}
+
 #[derive(Default)]
 pub struct ClientState {
     pub compositor_state: CompositorClientState,

monolith

Commit 4e5afcada08b

Commit `4e5afcada08b`