diff --git a/crates/komorebi-core/src/monitor.rs b/crates/komorebi-core/src/monitor.rs
index 27644982..9e279de7 100644
--- a/crates/komorebi-core/src/monitor.rs
+++ b/crates/komorebi-core/src/monitor.rs
@@ -23,6 +23,9 @@ use serde::de::DeserializeOwned;
use std::collections::VecDeque;
use std::fmt::Debug;
+/// What names a monitor of platform `P`, as [`PlatformWindowId`] does for a window
+pub type PlatformMonitorId
=
::Id;
+
/// What the shared [`Monitor`] needs of a platform, besides what its workspaces need.
pub trait MonitorPlatform: WorkspacePlatform {
/// What names a monitor: `isize` on Windows (a monitor handle), `u32` on KDE.
diff --git a/crates/komorebi-core/src/workspace.rs b/crates/komorebi-core/src/workspace.rs
index 31e45ebb..22a219b2 100644
--- a/crates/komorebi-core/src/workspace.rs
+++ b/crates/komorebi-core/src/workspace.rs
@@ -164,6 +164,14 @@ pub trait WorkspacePlatform: Sized + Clone + std::fmt::Debug + PartialEq + 'stat
Ok(0)
}
+ /// The index of the container that `promote-focus` focuses: the primary position of the layout,
+ /// and the first container when the layout has none (a custom layout without a primary
+ /// column). Where [`WorkspacePlatform::primary_container_idx`] fails, the default falls back
+ /// to 0.
+ fn promote_focus_container_idx(layout: &Layout) -> usize {
+ Self::primary_container_idx(layout).unwrap_or(0)
+ }
+
/// Gives the maximized window back to the layout, for the platforms where that is something
/// to tell the window (KDE asks the compositor; on Windows there is nothing to do).
fn unmaximize_window(_window: &Self::Window) -> eyre::Result<()> {
@@ -2202,4 +2210,12 @@ mod tests {
assert!(workspace.tile);
assert_eq!(workspace.layout, Layout::Default(DefaultLayout::BSP));
}
+
+ #[test]
+ fn promote_focus_falls_back_to_the_primary_position_and_then_to_zero() {
+ assert_eq!(
+ Plat::promote_focus_container_idx(&Layout::Default(DefaultLayout::BSP)),
+ 0
+ );
+ }
}
diff --git a/deny.toml b/deny.toml
index 61f56194..65b0694b 100644
--- a/deny.toml
+++ b/deny.toml
@@ -97,6 +97,61 @@ crate = "komorebi-shortcuts"
expression = "LicenseRef-Komorebi-2.0"
license-files = []
+[[licenses.clarify]]
+crate = "komorebi-backend"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebi-bar-core"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebi-collections"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebi-config"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebi-core"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebi-e2e-agent"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebi-protocol"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebi-settings"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebi-testwin"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebi-transport"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebic-core"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
[[licenses.clarify]]
crate = "whkd-core"
expression = "LicenseRef-Komorebi-2.0"
diff --git a/docs/dev/core-model.md b/docs/dev/core-model.md
index c83df496..6452fff9 100644
--- a/docs/dev/core-model.md
+++ b/docs/dev/core-model.md
@@ -1493,3 +1493,107 @@ Items 3 to 7 would fold with hooks; 1 and 2 are the blockers, and 1 is the owner
macOS scrolling placement becomes the `scrolling_layouts` and `place_container` hooks (and the
truncation of the resize dimensions is accepted for a scrolling workspace, which is a behaviour change),
or `update` stays macOS's.
+
+## 24. What Windows keeps platform-specific for a shared `WindowManager
` (kfw, wip-u-win-deep)
+
+Written against `wip-cand7` plus the revisions of `wip-u-win-deep`: `PlatformMonitorId
` is in
+`komorebi-core` (blocker 5 of section 18), the Windows `monitor_idx_from_current_pos` has KDE's text, and
+`promote-focus` on a custom layout is the `WorkspacePlatform::promote_focus_container_idx` hook (blocker
+6, the fallback part). This is the hook list kfde can implement: every item says what Windows does, what
+KDE and macOS do (from sections 17, 18 and 20), and the proposed shape. Items are ordered by how many
+shared functions they touch.
+
+### 22.1 The unmanaged-window gate (blocker 1): not converged, and why
+
+`handle_unmanaged_window_behaviour()` (refuse a command when `OperationBehaviour::NoOp` is set and the
+focused window is not in a container of the focused workspace) is called at the top of 18 functions on
+Windows: `move_container_to_monitor`, `move_container_to_workspace`, `focus_container_in_direction`,
+`move_container_in_direction`, `focus_container_in_cycle_direction`, `move_container_in_cycle_direction`,
+`cycle_container_window_in_direction`, `cycle_container_window_index_in_direction`,
+`focus_container_window`, `stack_all`, `unstack_all`, `add_window_to_container`,
+`promote_container_to_front`, `promote_container_swap`, `promote_focus_to_front`,
+`remove_window_from_container`, `toggle_monocle`, `toggle_maximize`. KDE and macOS call it once in the
+router, before the `match`, for every message. Moving Windows to the router is **not** behaviour-neutral
+and was not done: the reading of `process_command` shows four ways in which the two forms differ.
+
+1. The router form refuses every message, including queries, rule and configuration commands, the
+ workspace-focus commands and `stop` (those never call one of the 18); the per-function form refuses
+ only what reaches one. A router that gated the same set would need a message list
+ (`requires_managed_focus(&SocketMessage)`) that nothing shares.
+2. An arm that does other work first is not refused as a whole on Windows: `FocusStackWindow` focuses the
+ monitor under the pointer and only then calls `focus_container_window`; `MoveContainerToNamedWorkspace`
+ and the `Cycle*Container*` arms look up the target first; a router gate would refuse before any of it.
+3. The layer split: `FocusWindow`, `MoveWindow` and `CycleFocusWindow` call a gated function in the Tiling
+ layer and an ungated floating function in the Floating layer, so one message is refused in one layer
+ only; a router gate refuses both.
+4. Nested and direct callers that do not pass the router: `focus_container_window` is also called from the
+ arm of `process_command` that focuses a window by its location (`WorkspaceWindowLocation::Monocle` and
+ `Container`), `move_container_to_workspace` from `move_container_to_monitor` and from
+ `move_container_in_direction`, `toggle_monocle` and `toggle_maximize` from
+ `move_container_in_direction` and the cycle functions, and the unit tests of `window_manager.rs` call
+ all of them directly. The nested calls are covered by the outer gate; the direct ones are not.
+
+The hook that makes both shapes expressible is a defaulted method on the shared router,
+`fn gate_message(&self, message: &SocketMessage) -> eyre::Result<()>`: the default (KDE, macOS) calls
+`handle_unmanaged_window_behaviour` for every message; Windows returns `Ok(())` and keeps the call inside
+the 18 functions (they stay Windows text until the owner decides that Windows should refuse more).
+
+### 22.2 Hooks of the window manager (`WindowManagerPlatform`)
+
+| Windows keeps | What it is | KDE / macOS | Shape |
+|---|---|---|---|
+| `new`, `init` | `new` takes the command listener, the event channel and the socket; `init` loads monitor and workspace information through `WindowsApi`, uncloaks left-behind windows, starts the border and stackbar machinery | KDE: backend monitors and desktops; macOS: run loop and AX | `fn init(&mut WindowManager)`, `fn new(..)` as associated functions; the struct's platform fields in `P::State` (section 2: `known_hwnds`, `virtual_desktop_id`, `uncloack_to_ignore`, `has_pending_raise_op`, `pending_move_op` with handle and rect, `already_moved_window_handles`) |
+| `stop` | writes `komorebi.state.json`, switches animations off, waits for them, restores every window, turns focus-follows-mouse off, shuts the subscriber sockets, removes the socket file, waits for a bar restart in progress, `process::exit(0)` | KDE: `backend().shutdown()`; macOS: its own | `fn stop(&mut WindowManager, ignore_restore: bool)`; the shared part is the restore, the rest is the hook |
+| `restore_all_windows` | restores each window by `WindowsApi` (cloak/hide/minimize, the maximized and monocle windows), skipping windows the user hid | KDE and macOS have their own | `fn restore_all_windows(..)`; Windows' body stays |
+| `resize_window` | resizes by edge with DPI scaling and the min-size rules (58 lines); `ResizeWindowEdge` additionally goes through the live-resize guard | macOS 52 lines of its own, KDE none (the compositor) | `fn resize_window(..)`; the arm `ResizeWindowEdge` is a hook too |
+| `focus_workspace` | plans a slide transition (`workspace_transition_plan`, `focus_workspace_towards`) and runs the animation, or shows and hides windows | KDE asks the compositor for the desktop | plan/execute split: `fn plan_workspace_transition(..) -> Plan` (shared) and `fn execute(plan)` (hook) |
+| `enforce_workspace_rules`, `manage_focused_window`, `unmanage_focused_window`, `monitor_idx_from_window` | rules apply to windows found by `WindowsApi` and move them with `SetWindowPos`; manage/unmanage are fed by an event on Windows and a notification on KDE | differ in input | hooks `fn windows_to_enforce(..)`, `fn manage_focused(..)` |
+| `move_container_in_direction` | a DPI check across monitors (`monitors_have_same_dpi`) before a cross-monitor move | none | `fn before_cross_monitor_move(a, b) -> eyre::Result<()>`, no-op default |
+| `move_floating_window_in_direction`, `focus_floating_window_in_direction` | border offsets and the floating-window search (105 lines) | KDE and macOS: 29-line variants | stay platform; extension trait |
+
+### 22.3 Borders, stackbars, animations: the `BorderPlatform` hook
+
+`window_manager.rs` calls the border manager in few places: `cycle_monocle` destroys the borders
+(`border_manager::destroy_all_borders`), `stop` reads the border implementation, the ghost kinds are set in
+one free function; the router arms `Border*`, `Retile*`, `ReloadStaticConfiguration` and `TogglePause` set
+`force_update_borders` and notify the border thread. `monocle_on` and `monocle_off` also hide and restore
+the floating windows (through the backend). The stackbar manager is not called from `window_manager.rs`. KDE draws borders in the
+compositor and calls none of these, macOS has its own border thread. Shape: a defaulted
+`BorderPlatform` with `fn borders_changed(&mut self)`, `fn destroy_borders(&mut self)`,
+`fn hide_floating_for_monocle(&mut self, hide: bool)`; defaults do nothing (KDE) and macOS implements
+its own. The `force_update_borders` flag of the router becomes the return value of those hooks, as
+`replace_configuration` already returns it.
+
+### 22.4 Wallpaper, window-handling behaviour, workspace names, custom layouts
+
+- **Wallpaper.** `apply_wallpaper_for_monitor_workspace` finds the wallpaper of a monitor/workspace pair
+ and calls `Workspace::apply_wallpaper` (which is the `WorkspacePlatform::apply_wallpaper` hook:
+ `WindowsApi::set_wallpaper` through COM on Windows, the backend on KDE, nothing on macOS); the shared
+ function takes a `PlatformMonitorId` now and can move as it is.
+- **Window handling behaviour.** `WINDOW_HANDLING_BEHAVIOUR` (Sync/Async, the `ASYNC_WINDOW_POS` flag of
+ `SetWindowPos`) is read inside `WindowsApi::position_window`, never in `window_manager.rs`: it is a
+ setting of the Windows `set_rect`, not a hook of the window manager. Keep it in `Settings::platform`.
+- **Workspace names.** `set_workspace_name` records the name in the monitor's `Extra` (`workspace_names`),
+ and `known_workspace_name` is already the `MonitorPlatform` hook; a shared `set_workspace_name` calls a
+ `fn record_workspace_name(monitor: &mut Monitor, idx: usize, name: &str)` hook (default: nothing).
+- **Custom layouts.** `Layout::Custom` stays in `komorebi-layouts`; the Windows arms of `cycle_layout`,
+ `promote_container_swap` and `change_workspace_layout_default` fail for a custom layout without a primary
+ column, which `primary_container_idx` already expresses; the one real difference (`promote-focus` falls
+ back to the first column) is `promote_focus_container_idx`, done in this branch.
+
+### 22.5 Cosmetic differences: nothing left to do
+
+Section 18 lists which near-identical functions were cosmetic and converged (`bail!`, `Lockable`, log
+text, the `SessionFloatRules` and `State` arms); the rest of its table is real. Re-reading the Windows and
+KDE copies of the functions that differ by at most four lines against that table found no cosmetic
+difference left (`float_window` and the `focus_*` family read `mouse_follows_focus` into a local on KDE
+because of a borrow, and Windows has no such need: they stay as they are).
+
+### 22.6 Order for kfde
+
+1. `fn gate_message` on the shared router (22.1), Windows `Ok(())`.
+2. `BorderPlatform` (22.3) with no-op defaults: unblocks `cycle_monocle`, `retile_all`, `monocle_on/off`.
+3. `record_workspace_name` (22.4) and the `PlatformMonitorId` use in the shared wallpaper function.
+4. The plan/execute split of `focus_workspace`, then `init`/`stop`/`new`/`restore_all_windows` as hooks.
+Gates for each: Windows `commands`, `workspaces`, `focus`, `stacking`, `monocle` (maximizing), `borders`,
+`layouts` scenarios; KDE fast tier and VM for the router change.
diff --git a/flake.nix b/flake.nix
index 7b867cbe..614f8bdf 100644
--- a/flake.nix
+++ b/flake.nix
@@ -522,12 +522,19 @@
}
);
- komorebi-workspace-fmt = build.craneLib.cargoFmt {
- inherit (build) src;
- pname = "komorebi-workspace";
- version = "0.1.0";
- cargoToml = "${build.real}/Cargo.toml";
- };
+ # the nightly rustfmt over the Windows files, as tools/format-all --tree windows does locally. Not
+ # `cargo fmt`: it ran the stable rustfmt (which ignores the nightly options of rustfmt.toml) over
+ # the stub sources of the other platforms and followed `mod linux;` into files the Windows source
+ # does not have.
+ komorebi-workspace-fmt =
+ pkgs.runCommand "komorebi-workspace-fmt"
+ {
+ nativeBuildInputs = [ nightlyRustfmt ];
+ }
+ ''
+ RUSTFMT=rustfmt bash ${./tools/format-all} --check --tree windows --root ${build.real}
+ touch $out
+ '';
komorebi-workspace-toml-fmt = build.craneLib.taploFmt {
src = pkgs.lib.sources.sourceFilesBySuffices build.real [ ".toml" ];
diff --git a/komorebi-for-kde/deny.toml b/komorebi-for-kde/deny.toml
index eab867dd..a474e33a 100644
--- a/komorebi-for-kde/deny.toml
+++ b/komorebi-for-kde/deny.toml
@@ -88,6 +88,57 @@ crate = "base16-egui-themes"
expression = "MIT"
license-files = []
+
+[[licenses.clarify]]
+crate = "komorebi-backend"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebi-client"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebi-collections"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebi-config"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebi-core"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebi-protocol"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebi-settings"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebi-transport"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebic"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
+[[licenses.clarify]]
+crate = "komorebic-core"
+expression = "LicenseRef-Komorebi-2.0"
+license-files = []
+
[bans]
multiple-versions = "allow"
wildcards = "allow"
diff --git a/komorebi-for-kde/flake.nix b/komorebi-for-kde/flake.nix
index 13dab98e..a1c4fc83 100644
--- a/komorebi-for-kde/flake.nix
+++ b/komorebi-for-kde/flake.nix
@@ -374,6 +374,7 @@
cargoDenyExtraArgs =
"--workspace "
+ lib.concatMapStringsSep " " (p: "--exclude ${p}") [
+ "komorebi-bar-core"
"komorebi-windows"
"komorebi-gui"
"komorebic-no-console"
diff --git a/komorebi/src/window.rs b/komorebi/src/window.rs
index 1d825d0b..278f908f 100644
--- a/komorebi/src/window.rs
+++ b/komorebi/src/window.rs
@@ -74,6 +74,17 @@ pub fn foreground_window_id() -> Option {
WindowsApi::foreground_window().ok()
}
+/// What names a monitor: the type the shared monitor and window manager code compares ids as
+pub type PlatformMonitorId = komorebi_core::PlatformMonitorId;
+
+/// The monitor the pointer is on, if the system says (the nearest one when it is on none)
+pub fn monitor_id_at_cursor() -> Option {
+ let point = WindowsApi::cursor_pos().ok()?;
+ Some(PlatformMonitorId::from_hmonitor(
+ WindowsApi::monitor_from_point(point),
+ ))
+}
+
/// Where the pointer is, if the system says
pub fn cursor_position() -> Option<(i32, i32)> {
WindowsApi::cursor_pos()
diff --git a/komorebi/src/window_manager.rs b/komorebi/src/window_manager.rs
index 2abcb4f4..9551ce3a 100644
--- a/komorebi/src/window_manager.rs
+++ b/komorebi/src/window_manager.rs
@@ -48,8 +48,10 @@ use crate::core::WindowContainerBehaviour;
use crate::core::WindowManagementBehaviour;
use crate::core::config_generation::MatchingRule;
use crate::windows_backend::backend;
+use crate::workspace::WindowsPlatform;
use komorebi_backend::WindowId;
use komorebi_core::ContainerWindow;
+use komorebi_core::WorkspacePlatform;
use crate::CrossBoundaryBehaviour;
use crate::DATA_DIR;
@@ -74,6 +76,7 @@ use crate::static_config::StaticConfig;
use crate::static_config::StaticConfigExt;
use crate::transparency_manager;
use crate::window::Window;
+use crate::window::monitor_id_at_cursor;
use crate::window_manager_event::WindowManagerEvent;
use crate::windows_api::WindowsApi;
use crate::winevent_listener;
@@ -3047,10 +3050,7 @@ impl WindowManager {
tracing::info!("promoting focus");
- let target_idx = match &workspace.layout {
- Layout::Default(_) => 0,
- Layout::Custom(custom) => custom.first_container_idx(custom.primary_idx().unwrap_or(0)),
- };
+ let target_idx = WindowsPlatform::promote_focus_container_idx(&workspace.layout);
workspace.focus_container(target_idx);
self.update_focused_workspace(self.mouse_follows_focus, true)
@@ -3786,17 +3786,17 @@ impl WindowManager {
}
pub fn monitor_idx_from_current_pos(&mut self) -> Option {
- let hmonitor = WindowsApi::monitor_from_point(WindowsApi::cursor_pos().ok()?);
+ let monitor_id = monitor_id_at_cursor()?;
for (i, monitor) in self.monitors().iter().enumerate() {
- if monitor.id.to_hmonitor() == hmonitor {
+ if monitor.id == monitor_id {
return Option::from(i);
}
}
// our hmonitor might be stale, so if we didn't return above, try querying via the latest
// info taken from win32_display_data and update our hmonitor while we're at it
- if let Ok(latest) = WindowsApi::monitor(hmonitor) {
+ if let Ok(latest) = WindowsApi::monitor(monitor_id.to_hmonitor()) {
for (i, monitor) in self.monitors_mut().iter_mut().enumerate() {
if monitor.extra.device_id == latest.extra.device_id {
monitor.id = latest.id;
diff --git a/komorebi/src/workspace.rs b/komorebi/src/workspace.rs
index 6189503c..667dc9e2 100644
--- a/komorebi/src/workspace.rs
+++ b/komorebi/src/workspace.rs
@@ -86,6 +86,16 @@ impl komorebi_core::WorkspacePlatform for WindowsPlatform {
})
}
+ /// `promote-focus` on a custom layout without a primary column focuses its first column rather
+ /// than failing, which is what the Windows daemon always did; the other layouts have the
+ /// primary position first.
+ fn promote_focus_container_idx(layout: &Layout) -> usize {
+ match layout {
+ Layout::Default(_) => 0,
+ Layout::Custom(custom) => custom.first_container_idx(custom.primary_idx().unwrap_or(0)),
+ }
+ }
+
fn begin_update(_workspace: &mut Workspace) -> eyre::Result {
if !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
return Ok(komorebi_core::Flow::Skip);
diff --git a/tools/format-all b/tools/format-all
new file mode 100755
index 00000000..eb6c1a30
--- /dev/null
+++ b/tools/format-all
@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+# format-all: the formatting checks of the nix flakes, runnable locally, and the fix for them.
+#
+# Usage: tools/format-all [--check | --apply] [--tree windows|kde|mac|all] [--root DIR]
+# --check (default) fails if any file is not formatted; prints the diff
+# --apply formats the files in place (do it LAST on a candidate: it touches many files)
+# --tree which flake's check to reproduce (default all)
+# --root the repository (default: the one this script is in; the nix check passes its source)
+#
+# The checks use the nightly rustfmt (rustfmt.toml has nightly options) and edition 2024, the
+# edition of every manifest:
+# windows every .rs file of the Windows crates with the root rustfmt.toml, file by file
+# (skip_children: the entry files name modules of other platforms that are not in the
+# Windows source, which rustfmt would fail to find); the linux and macos modules of the
+# shared crates belong to the kde and mac trees
+# mac komorebi-for-mac/**/*.rs and the macos modules of the shared crates, with
+# komorebi-for-mac/rustfmt.toml
+# kde `cargo fmt -p `, as komorebi-for-kde/flake.nix does
+# The nightly rustfmt is $RUSTFMT if set, else `rustfmt` if that is a nightly, else the one of the
+# dev shell of the root flake (`nix develop`), which is the one the nix checks use (a nightly of the
+# pinned rust-overlay; another nightly may format a little differently).
+set -uo pipefail
+
+mode=check
+tree=all
+root=$(cd "$(dirname "$0")/.." && pwd)
+while [ $# -gt 0 ]; do
+ case $1 in
+ --check) mode=check ;;
+ --apply) mode=apply ;;
+ --tree) tree=$2; shift ;;
+ --root) root=$2; shift ;;
+ -h | --help) sed -n 2,23p "$0"; exit 0 ;;
+ *) echo "format-all: unknown argument $1" >&2; exit 2 ;;
+ esac
+ shift
+done
+root=$(cd "$root" && pwd)
+
+if [ -z "${RUSTFMT:-}" ]; then
+ if rustfmt --version 2>/dev/null | grep -q nightly; then
+ RUSTFMT=rustfmt
+ elif [ -z "${FORMAT_ALL_IN_SHELL:-}" ] && command -v nix >/dev/null; then
+ FORMAT_ALL_IN_SHELL=1 exec nix develop "$root" --command "$0" "$@" --root "$root"
+ else
+ echo "format-all: no nightly rustfmt (set RUSTFMT)" >&2; exit 2
+ fi
+fi
+export RUSTFMT
+cd "$root" || exit 2
+
+flag=--check
+[ "$mode" = apply ] && flag=
+status=0
+
+# the linux and macos modules of the shared crates (the Windows source filter of flake.nix leaves them out)
+other_platform='(^|/)(komorebic/src/(linux|macos)|komorebic/tests/(linux|macos)_|komorebi-client/src/(linux|macos)\.rs|komorebi-client/tests/(linux|macos)_|komorebi-bar/src/macos|komorebi-daemon/tests/(linux|macos)_)'
+
+rs_files() { find . -name '*.rs' -not -path '*/target/*' -not -path './.git/*' -not -path './.jj/*' | sed 's|^\./||' | sort; }
+
+run_rustfmt() { # config-file, files on stdin
+ local cfg=$1 files
+ mapfile -t files
+ [ ${#files[@]} -eq 0 ] && { echo "format-all: no files for $cfg" >&2; return 1; }
+ "$RUSTFMT" --edition 2024 --config-path "$cfg" --config skip_children=true $flag "${files[@]}"
+}
+
+if [ "$tree" = windows ] || [ "$tree" = all ]; then
+ echo "format-all: windows"
+ rs_files | grep -v '^komorebi-for-\(kde\|mac\)/' | grep -Ev "$other_platform" | run_rustfmt rustfmt.toml || status=1
+fi
+if [ "$tree" = mac ] || [ "$tree" = all ]; then
+ echo "format-all: mac"
+ { rs_files | grep '^komorebi-for-mac/'; rs_files | grep -E "^(komorebic/src/macos|komorebi-bar/src/macos|komorebi-client/src/macos\.rs)"; } \
+ | run_rustfmt komorebi-for-mac/rustfmt.toml || status=1
+fi
+if [ "$tree" = kde ] || [ "$tree" = all ]; then
+ echo "format-all: kde"
+ cargo fmt -p komorebi -p komorebi-linux -p komorebic -p komorebi-client -p komorebi-hotkeys -- $flag || status=1
+fi
+exit $status