A theme gives the borders their colors, in place of choosing the color of each kind of window: a Catppuccin theme, a Base16 theme or a palette of one's own, with the color it gives each of the six kinds of border and its default for the ones it does not name. The Theme message puts the six colors where the border manager keeps them and asks for the look again. The palette of a picture is made by the same generator as komorebi for Windows, which takes seconds for a large picture, so each one is kept in the cache directory, in a file named for the picture, a hash of its path, size and time of last change, and the variant: the palette of a picture painted over, or of one of the same name in another folder, is made again and not mistaken. The themes come from komorebi-themes at the revision komorebi-layouts is at. It pulls egui for its types, which the license list, the sources and the advisories of deny.toml now have to allow, and the colors the border manager keeps are the themes' own again. A subscriber that asks for the changes of the state only is sent a Theme message all the same: the colors of the borders are not part of the state, so a theme never changes it, and the subscriber would not hear of the colors at all. komorebi.json takes border_colours, a color for each kind of window as red, green and blue or as a hex color, and a theme, which wins over them.
3.9 KiB
Subscribing to notifications
A program such as a status bar, a widget or a script can follow what komorebi does by subscribing to its notifications. After each event the window manager handles (a window was shown, closed, focused, minimized or restored) and each message it takes on its socket, the daemon sends every subscriber a notification: the event or the message, and the state of the window manager after it.
Subscribing
A subscriber listens on a Unix socket of its own in the daemon's data directory,
$XDG_RUNTIME_DIR/komorebi (on NixOS and most systemd distributions,
/run/user/<uid>/komorebi), and tells the daemon the name of the socket with
komorebic subscribe-socket. The socket has to exist before
it subscribes: the daemon sends the notification of the subscription at once, and removes a
subscriber it cannot connect to.
With socat, a shell can subscribe and print every notification:
socat -u UNIX-LISTEN:"$XDG_RUNTIME_DIR/komorebi/bar.sock",fork STDOUT &
komorebic subscribe-socket bar.sock
komorebic unsubscribe-socket bar.sock stops the
notifications.
Notifications
The daemon sends each notification on a new connection to the subscriber's socket: it connects, writes one JSON object, and closes the connection. There is no newline after the object. The first notification a subscriber receives is the one of its subscription.
A notification has two fields:
event: the event or the message. An event is a window event, with the signal it came from and the window, such as{"type":"Show","content":[{"type":"KWin","content":"WindowAdded"},{"id":...}]}. A message is written the way a client writes it on the daemon's socket, such as{"type":"Retile"}.state: the state of the window manager after it, with the same fields as whatkomorebic stateprints, on one line.
An event about a window that komorebi does not manage, and a message that fails, are not sent.
Only when something changed
A subscriber can ask to be sent a notification only when the event or the message changed
the state, with the filter_state_changes option. It is still sent the notification of a
window that is shown, of every new subscription, so it receives the state as soon as it
subscribes, of a theme, which changes the colors of the borders and nothing in the state,
and of every reload of komorebi.json. komorebic subscribe-socket has no option for it; a
program writes the message on the daemon's socket itself:
printf '%s' '{"type":"AddSubscriberSocketWithOptions","content":["bar.sock",{"filter_state_changes":true}]}' |
socat - UNIX-CONNECT:"$XDG_RUNTIME_DIR/komorebi/komorebi.sock"
When a subscriber goes away
A subscriber that the daemon cannot connect to, because its program has exited or its socket was removed, is removed at the next notification, and its socket file with it. The daemon does not try it again: a program that wants notifications again subscribes again. The daemon keeps its subscribers only while it runs, so after a restart every program has to subscribe again.
When the daemon stops, it connects to each subscriber and closes the connection without writing anything.
A subscriber should accept and read every connection as it comes. The daemon writes each notification while the window manager is locked, and waits when the socket's buffer is full, so a subscriber that stops reading can hold up the window manager. While it is held up, the window events KWin reports wait for it, and once 20 are waiting the daemon drops the ones that come after them.
In Rust
The komorebi-client crate has subscribe and subscribe_with_options, which listen on
the socket, subscribe, and return the listener: each connection on it is one
Notification. cargo doc --package komorebi-client --open shows their documentation,
with an example.