Files
komorebi/komorebic/src/main.rs
T
LGUG2Z d1b7d27835 chore(deps): bump sysinfo to 0.40
System::new_all returns a Result since 0.40.
2026-10-28 19:11:00 -07:00

2240 lines
84 KiB
Rust

//! `komorebic`, the command line interface of komorebi for KDE Plasma.
//!
//! A subcommand that asks something of the daemon is one message on its socket: an order, such as
//! `stop` or `retile`, is written and `komorebic` exits; a question, such as `state` or `query`,
//! is written and the answer is printed. The messages are [`komorebi_client::SocketMessage`]s,
//! sent with [`komorebi_client::send_message`] and [`komorebi_client::send_query`].
//!
//! The orders that change what the daemon tiles:
//!
//! - `focus` and `cycle-focus` give the focus to another window of the focused workspace, and
//! `mouse-follows-focus` and `toggle-mouse-follows-focus` set whether the pointer goes with it.
//! - `move` and `cycle-move` move the focused window to another tile.
//! - `change-layout`, `cycle-layout` and `flip-layout` change the layout of the focused
//! workspace, `scrolling-layout-columns` and `layout-ratios` tune it, `toggle-tiling` turns its
//! tiling off and on, and `preselect-direction` and `cancel-preselect` reserve the place of the
//! next window and give it up.
//! - `stack` puts the focused window in one container with the window on one side of it, so that
//! they share a tile and only one is in sight, `unstack` takes it out again, and `stack-all` and
//! `unstack-all` do it for the whole workspace and for the focused stack. `cycle-stack` brings
//! the next or the previous window of the focused stack to the front, `cycle-stack-index` moves
//! the front window along the stack, and `focus-stack-window` brings the window at an index to
//! the front. `toggle-window-container-behaviour` and
//! `toggle-workspace-window-container-behaviour` make a window that opens join the focused
//! container instead of getting a tile, and `toggle-float-override` and
//! `toggle-workspace-float-override` make it float.
//! - `promote`, `promote-swap`, `promote-focus` and `promote-window` bring a window to the largest
//! tile, or the focus to it.
//! - `toggle-float` takes the focused window out of the layout, or puts it back,
//! `toggle-workspace-layer` switches the focused workspace between its tiled windows and its
//! floating ones, and `toggle-lock` locks the focused container at its index, or unlocks it.
//! - `toggle-monocle` gives the focused container the whole work area, or puts it back, and
//! `monocle-focus-behaviour` and `toggle-monocle-focus-behaviour` set what focusing in a
//! direction does meanwhile. `toggle-maximize` has KWin maximize the focused window, which
//! leaves the layout, and restores it.
//! - `focused-workspace-padding`, `focused-workspace-container-padding`, `workspace-padding`,
//! `container-padding` and the two `adjust-*-padding` set the padding around the tiles and
//! between them, and `global-work-area-offset`, `monitor-work-area-offset`,
//! `workspace-work-area-offset` and `toggle-window-based-work-area-offset` keep parts of the work
//! area free of tiles.
//! - `minimize` and `close` minimize and close the focused window, `unmanage` takes it out of
//! the layout until `manage` takes it back, `unmanaged-window-operation-behaviour` sets whether
//! the daemon carries out an order while the focused window is not one it tiles, and
//! `toggle-pause` pauses the daemon and resumes it.
//! - `resize-edge` and `resize-axis` resize the focused window by the `resize-delta`, and
//! `quick-save-resize`, `quick-load-resize`, `save-resize` and `load-resize` save the sizes of
//! the tiles of the focused workspace and load them back.
//! - `focus-workspace` shows another workspace of the focused monitor, `move-to-workspace` moves
//! the focused window to a workspace and shows it, and `send-to-workspace` moves it there and
//! stays. A workspace is KWin's virtual desktop of the same number, counted from 0.
//! `cycle-workspace`, `cycle-empty-workspace`, `cycle-move-to-workspace` and
//! `cycle-send-to-workspace` go to the next or the previous workspace, `focus-last-workspace`,
//! `move-to-last-workspace` and `send-to-last-workspace` to the one that was in front before,
//! `focus-workspaces` shows a workspace on every monitor, and `new-workspace` and
//! `close-workspace` add a workspace and remove an empty one.
//! - `focus-monitor`, `cycle-monitor` and `focus-monitor-at-cursor` focus another monitor, and
//! `focus-monitor-workspace` a workspace of another monitor; `move-to-monitor`,
//! `send-to-monitor`, their `cycle-` forms, `move-to-monitor-workspace`,
//! `send-to-monitor-workspace`, `move-to-named-workspace` and `send-to-named-workspace` take the
//! focused window to another monitor; `move-workspace-to-monitor`,
//! `cycle-move-workspace-to-monitor` and `swap-workspaces-with-monitor` take workspaces there;
//! `cross-monitor-move-behaviour` and `toggle-cross-monitor-move-behaviour` set what `move` does
//! at the edge of a monitor, and `display-index-preference` gives a monitor an index.
//! `eager-focus` focuses the first window of an executable, on any workspace of any monitor.
//! - `workspace-name` names a workspace, which `focus-named-workspace`, `named-workspace-layout`,
//! `named-workspace-tiling`, `named-workspace-padding` and `named-workspace-container-padding`
//! find by its name; `workspace-layout` and `workspace-tiling` set the layout and the tiling of
//! a workspace by its index, and `ensure-workspaces` and `ensure-named-workspaces` give a
//! monitor workspaces up to a number, or with names.
//! - `border` sets whether the compositor draws a border around each window, `border-colour` the
//! color of the border of a kind of window, and `border-width` and `border-offset` the room the
//! layout leaves for it.
//! - `focus-follows-mouse` and `toggle-focus-follows-mouse` set whether KWin gives the focus to the
//! window under the pointer, as the pointer moves.
//! - `transparency` and `toggle-transparency` set whether the windows that do not have the focus
//! are see-through, and `transparency-alpha` how opaque they are.
//! - `animation`, `animation-duration` and `animation-style` set whether windows are animated going
//! to their places, for how long and with what easing, and `animation-fps` the frame rate that
//! is stored and ignored.
//!
//! `ignore-rule` and `manage-rule` add a rule that keeps an application out of the layout or
//! always in it, `session-float-rule` floats the focused window and every window like it until the
//! daemon stops, `session-float-rules` shows those rules and `clear-session-float-rules` removes
//! them, and `global-state` shows the rules the daemon has. `visible-windows` shows the windows
//! that can be seen on the workspace each monitor shows.
//!
//! `initial-workspace-rule`, `initial-named-workspace-rule`, `workspace-rule` and
//! `named-workspace-rule` send the windows of an application to a workspace, when they open or
//! always, `clear-workspace-rules`, `clear-named-workspace-rules` and `clear-all-workspace-rules`
//! take those rules away, and `enforce-workspace-rules` applies them to the windows that are open.
//!
//! `workspace-layout-rule` and `named-workspace-layout-rule` make a workspace change layout once
//! it has so many windows, and `clear-workspace-layout-rules` and
//! `clear-named-workspace-layout-rules` take those rules away. `generate-static-config` prints the
//! settings of the daemon as a `komorebi.json`, and `replace-configuration` makes the daemon
//! start over with another one.
//!
//! `subscribe-socket` and `unsubscribe-socket` add and remove a subscriber: a program that listens
//! on a socket in the daemon's data directory, to which the daemon sends a notification after each
//! event and each message it handles.
//!
//! The others work without the daemon: `quickstart` writes an example `komorebi.json`,
//! `applications.json` and `skhdrc` in the config home, `enable-autostart` and `disable-autostart` write and
//! remove the entry that has Plasma start komorebi at login, `start` runs `komorebi` in the
//! background, with the `komorebi.json` it is given with `--config`, `check` reads the
//! `komorebi.json` the daemon would and the key binding file, looks at the desktop, and reports
//! what is wrong, exiting with status 1 if something is an error, `configuration` shows the path
//! of the `komorebi.json` the daemon reads, `log` follows its log, `data-directory` shows where its
//! socket is, `completions` prints a completion script for a shell, and `static-config-schema`,
//! `application-specific-configuration-schema`, `notification-schema` and `socket-schema` print
//! the JSON Schema of `komorebi.json`, of an `applications.json`, of a notification and of a
//! message. The hidden `docgen` writes the help of every subcommand as Markdown, wrapped
//! at 100 columns whatever the width of the terminal, which is how `docs/cli` is made.
//!
//! `export-kde-shortcuts` and `hotkeys compile` read a key binding file (an skhdrc, a whkdrc or an
//! sxhkdrc) and write the bindings KDE can run by itself as shortcut files. `hotkeys state`,
//! `hotkeys reload` and `hotkeys release` look after the keys the daemon registers with KDE; the
//! [`hotkeys`] module has the details.
use chrono::Utc;
use clap::CommandFactory;
use clap::Parser;
use clap::ValueEnum;
use color_eyre::eyre;
use fs_tail::TailedFile;
use komorebi_client::ApplicationIdentifier;
use komorebi_client::Axis;
use komorebi_client::CycleDirection;
use komorebi_client::DefaultLayout;
use komorebi_client::FocusFollowsMouseImplementation;
use komorebi_client::MoveBehaviour;
use komorebi_client::OperationBehaviour;
use komorebi_client::OperationDirection;
use komorebi_client::PathExt;
use komorebi_client::Rect;
use komorebi_client::Sizing;
use komorebi_client::SocketMessage;
use komorebi_client::StateQuery;
use komorebi_client::WindowKind;
use komorebi_client::replace_env_in_path;
use komorebi_client::send_message;
use komorebi_client::send_query;
use lazy_static::lazy_static;
use std::fs::File;
use std::io::BufRead;
use std::io::Write;
use std::num::NonZeroUsize;
use std::path::PathBuf;
use std::process::Command;
use std::process::Stdio;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering;
use std::time::Duration;
use sysinfo::ProcessesToUpdate;
mod hotkeys;
lazy_static! {
static ref HAS_CUSTOM_CONFIG_HOME: AtomicBool = AtomicBool::new(false);
static ref HOME_DIR: PathBuf = {
std::env::var("KOMOREBI_CONFIG_HOME").map_or_else(
|_| dirs::home_dir().expect("there is no home directory").join(".config").join("komorebi"),
|home_path| {
let home = home_path.replace_env();
if home.as_path().is_dir() {
HAS_CUSTOM_CONFIG_HOME.store(true, Ordering::SeqCst);
home
} else {
panic!(
"$KOMOREBI_CONFIG_HOME is set to \"{home_path}\", which is not a valid directory",
);
}
},
)
};
}
#[derive(Copy, Clone, ValueEnum)]
enum BooleanState {
Enable,
Disable,
}
impl From<BooleanState> for bool {
fn from(b: BooleanState) -> Self {
match b {
BooleanState::Enable => true,
BooleanState::Disable => false,
}
}
}
macro_rules! gen_enum_subcommand_args {
// SubCommand Pattern: Enum Type
( $( $name:ident: $element:ty ),+ $(,)? ) => {
$(
pastey::paste! {
#[derive(clap::Parser)]
pub struct $name {
#[clap(value_enum)]
[<$element:snake>]: $element
}
}
)+
};
}
gen_enum_subcommand_args! {
Focus: OperationDirection,
Move: OperationDirection,
PreselectDirection: OperationDirection,
CycleFocus: CycleDirection,
CycleMove: CycleDirection,
CycleMoveToWorkspace: CycleDirection,
CycleSendToWorkspace: CycleDirection,
CycleSendToMonitor: CycleDirection,
CycleMoveToMonitor: CycleDirection,
CycleMonitor: CycleDirection,
CycleWorkspace: CycleDirection,
CycleEmptyWorkspace: CycleDirection,
CycleMoveWorkspaceToMonitor: CycleDirection,
Stack: OperationDirection,
CycleStack: CycleDirection,
CycleStackIndex: CycleDirection,
FlipLayout: Axis,
ChangeLayout: DefaultLayout,
CycleLayout: CycleDirection,
// WatchConfiguration: BooleanState,
MouseFollowsFocus: BooleanState,
Transparency: BooleanState,
Query: StateQuery,
CrossMonitorMoveBehaviour: MoveBehaviour,
UnmanagedWindowOperationBehaviour: OperationBehaviour,
PromoteWindow: OperationDirection,
}
macro_rules! gen_target_subcommand_args {
// SubCommand Pattern
( $( $name:ident ),+ $(,)? ) => {
$(
#[derive(clap::Parser)]
pub struct $name {
/// Target index (zero-indexed)
target: usize,
}
)+
};
}
gen_target_subcommand_args! {
MoveToMonitor,
MoveToWorkspace,
SendToMonitor,
SendToWorkspace,
FocusMonitor,
FocusWorkspace,
FocusWorkspaces,
MoveWorkspaceToMonitor,
SwapWorkspacesWithMonitor,
FocusStackWindow,
}
#[derive(Parser)]
struct MonocleFocusBehaviour {
/// Desired monocle focus behavior
#[clap(value_enum)]
behaviour: komorebi_client::MonocleFocusBehaviour,
}
macro_rules! gen_named_target_subcommand_args {
// SubCommand Pattern
( $( $name:ident ),+ $(,)? ) => {
$(
#[derive(clap::Parser)]
pub struct $name {
/// Target workspace name
workspace: String,
}
)+
};
}
gen_named_target_subcommand_args! {
MoveToNamedWorkspace,
SendToNamedWorkspace,
FocusNamedWorkspace,
ClearNamedWorkspaceLayoutRules
}
// Thanks to @danielhenrymantilla for showing me how to use cfg_attr with an optional argument like
// this on the Rust Programming Language Community Discord Server
macro_rules! gen_workspace_subcommand_args {
// Workspace Property: #[enum] Value Enum (if the value is an Enum)
// Workspace Property: Value Type (if the value is anything else)
( $( $name:ident: $(#[enum] $(@$value_enum:tt)?)? $value:ty ),+ $(,)? ) => (
pastey::paste! {
$(
#[derive(clap::Parser)]
pub struct [<Workspace $name>] {
/// Monitor index (zero-indexed)
monitor: usize,
/// Workspace index on the specified monitor (zero-indexed)
workspace: usize,
$(#[clap(value_enum)] $($value_enum)?)?
#[cfg_attr(
all($(FALSE $($value_enum)?)?),
doc = ""$name " of the workspace as a "$value ""
)]
value: $value,
}
)+
}
)
}
gen_workspace_subcommand_args! {
Name: String,
Layout: #[enum] DefaultLayout,
Tiling: #[enum] BooleanState,
}
macro_rules! gen_named_workspace_subcommand_args {
// Workspace Property: #[enum] Value Enum (if the value is an Enum)
// Workspace Property: Value Type (if the value is anything else)
( $( $name:ident: $(#[enum] $(@$value_enum:tt)?)? $value:ty ),+ $(,)? ) => (
pastey::paste! {
$(
#[derive(clap::Parser)]
pub struct [<NamedWorkspace $name>] {
/// Target workspace name
workspace: String,
$(#[clap(value_enum)] $($value_enum)?)?
#[cfg_attr(
all($(FALSE $($value_enum)?)?),
doc = ""$name " of the workspace as a "$value ""
)]
value: $value,
}
)+
}
)
}
gen_named_workspace_subcommand_args! {
Layout: #[enum] DefaultLayout,
Tiling: #[enum] BooleanState,
}
macro_rules! gen_focused_workspace_padding_subcommand_args {
// SubCommand Pattern
( $( $name:ident ),+ $(,)? ) => {
$(
#[derive(clap::Parser)]
pub struct $name {
/// Pixels size to set as an integer
size: i32,
}
)+
};
}
gen_focused_workspace_padding_subcommand_args! {
FocusedWorkspaceContainerPadding,
FocusedWorkspacePadding,
}
macro_rules! gen_padding_subcommand_args {
// SubCommand Pattern
( $( $name:ident ),+ $(,)? ) => {
$(
#[derive(clap::Parser)]
pub struct $name {
/// Monitor index (zero-indexed)
monitor: usize,
/// Workspace index on the specified monitor (zero-indexed)
workspace: usize,
/// Pixels to pad with as an integer
size: i32,
}
)+
};
}
gen_padding_subcommand_args! {
ContainerPadding,
WorkspacePadding,
}
macro_rules! gen_named_padding_subcommand_args {
// SubCommand Pattern
( $( $name:ident ),+ $(,)? ) => {
$(
#[derive(clap::Parser)]
pub struct $name {
/// Target workspace name
workspace: String,
/// Pixels to pad with as an integer
size: i32,
}
)+
};
}
gen_named_padding_subcommand_args! {
NamedWorkspaceContainerPadding,
NamedWorkspacePadding,
}
macro_rules! gen_padding_adjustment_subcommand_args {
// SubCommand Pattern
( $( $name:ident ),+ $(,)? ) => {
$(
#[derive(clap::Parser)]
pub struct $name {
#[clap(value_enum)]
sizing: Sizing,
/// Pixels to adjust by as an integer
adjustment: i32,
}
)+
};
}
gen_padding_adjustment_subcommand_args! {
AdjustContainerPadding,
AdjustWorkspacePadding,
}
macro_rules! gen_application_target_subcommand_args {
// SubCommand Pattern
( $( $name:ident ),+ $(,)? ) => {
$(
#[derive(clap::Parser)]
pub struct $name {
#[clap(value_enum)]
identifier: ApplicationIdentifier,
/// Identifier as a string
id: String,
}
)+
};
}
gen_application_target_subcommand_args! {
IgnoreRule,
ManageRule,
// IdentifyTrayApplication,
// IdentifyLayeredApplication,
// IdentifyObjectNameChangeApplication,
// IdentifyBorderOverflowApplication,
// RemoveTitleBar,
}
#[derive(Parser)]
pub struct ClearWorkspaceLayoutRules {
/// Monitor index (zero-indexed)
monitor: usize,
/// Workspace index on the specified monitor (zero-indexed)
workspace: usize,
}
#[derive(Parser)]
struct InitialWorkspaceRule {
#[clap(value_enum)]
identifier: ApplicationIdentifier,
/// Identifier as a string
id: String,
/// Monitor index (zero-indexed)
monitor: usize,
/// Workspace index on the specified monitor (zero-indexed)
workspace: usize,
}
#[derive(Parser)]
struct InitialNamedWorkspaceRule {
#[clap(value_enum)]
identifier: ApplicationIdentifier,
/// Identifier as a string
id: String,
/// Name of a workspace
workspace: String,
}
#[derive(Parser)]
struct WorkspaceRule {
#[clap(value_enum)]
identifier: ApplicationIdentifier,
/// Identifier as a string
id: String,
/// Monitor index (zero-indexed)
monitor: usize,
/// Workspace index on the specified monitor (zero-indexed)
workspace: usize,
}
#[derive(Parser)]
struct NamedWorkspaceRule {
#[clap(value_enum)]
identifier: ApplicationIdentifier,
/// Identifier as a string
id: String,
/// Name of a workspace
workspace: String,
}
#[derive(Parser)]
struct ClearWorkspaceRules {
/// Monitor index (zero-indexed)
monitor: usize,
/// Workspace index on the specified monitor (zero-indexed)
workspace: usize,
}
#[derive(Parser)]
struct ClearNamedWorkspaceRules {
/// Name of a workspace
workspace: String,
}
#[derive(Parser)]
struct Resize {
#[clap(value_enum)]
edge: OperationDirection,
#[clap(value_enum)]
sizing: Sizing,
}
#[derive(Parser)]
struct ResizeAxis {
#[clap(value_enum)]
axis: Axis,
#[clap(value_enum)]
sizing: Sizing,
}
#[derive(Parser)]
struct ResizeDelta {
/// The delta of pixels by which to increase or decrease window dimensions when resizing
pixels: i32,
}
#[derive(Parser)]
struct SubscribeSocket {
/// Name of the socket to send event notifications to
socket: String,
}
#[derive(Parser)]
struct UnsubscribeSocket {
/// Name of the socket to stop sending event notifications to
socket: String,
}
#[derive(Parser)]
struct GlobalWorkAreaOffset {
/// Size of the left work area offset (set right to left * 2 to maintain right padding)
left: i32,
/// Size of the top work area offset (set bottom to the same value to maintain bottom padding)
top: i32,
/// Size of the right work area offset
right: i32,
/// Size of the bottom work area offset
bottom: i32,
}
#[derive(Parser)]
struct MonitorWorkAreaOffset {
/// Monitor index (zero-indexed)
monitor: usize,
/// Size of the left work area offset (set right to left * 2 to maintain right padding)
left: i32,
/// Size of the top work area offset (set bottom to the same value to maintain bottom padding)
top: i32,
/// Size of the right work area offset
right: i32,
/// Size of the bottom work area offset
bottom: i32,
}
#[derive(Parser)]
struct WorkspaceWorkAreaOffset {
/// Monitor index (zero-indexed)
monitor: usize,
/// Workspace index (zero-indexed)
workspace: usize,
/// Size of the left work area offset (set right to left * 2 to maintain right padding)
left: i32,
/// Size of the top work area offset (set bottom to the same value to maintain bottom padding)
top: i32,
/// Size of the right work area offset
right: i32,
/// Size of the bottom work area offset
bottom: i32,
}
#[derive(Parser)]
struct FocusMonitorWorkspace {
/// Target monitor index (zero-indexed)
target_monitor: usize,
/// Workspace index on the target monitor (zero-indexed)
target_workspace: usize,
}
#[derive(Parser)]
pub struct SendToMonitorWorkspace {
/// Target monitor index (zero-indexed)
target_monitor: usize,
/// Workspace index on the target monitor (zero-indexed)
target_workspace: usize,
}
#[derive(Parser)]
pub struct MoveToMonitorWorkspace {
/// Target monitor index (zero-indexed)
target_monitor: usize,
/// Workspace index on the target monitor (zero-indexed)
target_workspace: usize,
}
#[derive(Parser)]
pub struct WorkspaceLayoutRule {
/// Monitor index (zero-indexed)
monitor: usize,
/// Workspace index on the specified monitor (zero-indexed)
workspace: usize,
/// The number of window containers on-screen required to trigger this layout rule
at_container_count: usize,
#[clap(value_enum)]
layout: DefaultLayout,
}
#[derive(Parser)]
pub struct NamedWorkspaceLayoutRule {
/// Target workspace name
workspace: String,
/// The number of window containers on-screen required to trigger this layout rule
at_container_count: usize,
#[clap(value_enum)]
layout: DefaultLayout,
}
#[derive(Parser)]
struct DisplayIndexPreference {
/// Preferred monitor index (zero-indexed)
index_preference: usize,
/// Display name as identified in komorebic state
display: String,
}
#[derive(Parser)]
struct EnsureWorkspaces {
/// Monitor index (zero-indexed)
monitor: usize,
/// Number of desired workspaces
workspace_count: usize,
}
#[derive(Parser)]
struct EnsureNamedWorkspaces {
/// Monitor index (zero-indexed)
monitor: usize,
/// Names of desired workspaces
names: Vec<String>,
}
#[derive(Parser)]
#[allow(clippy::struct_excessive_bools)]
struct Start {
/// Path to a static configuration JSON file
#[clap(short, long)]
#[clap(value_parser = replace_env_in_path)]
config: Option<PathBuf>,
/// Arguments to pass to komorebi, after a `--`: `komorebic start -- --log-level debug`
#[clap(last = true)]
komorebi_args: Vec<String>,
}
#[derive(Parser)]
struct Stop {
/// Do not restore windows after stopping komorebi
#[clap(long, hide = true)]
ignore_restore: bool,
}
#[derive(Parser)]
struct SaveResize {
/// File to which the resize layout dimensions should be saved
#[clap(value_parser = replace_env_in_path)]
path: PathBuf,
}
#[derive(Parser)]
struct LoadResize {
/// File from which the resize layout dimensions should be loaded
#[clap(value_parser = replace_env_in_path)]
path: PathBuf,
}
#[derive(Parser)]
struct ReplaceConfiguration {
/// Static configuration JSON file from which the configuration should be loaded
#[clap(value_parser = replace_env_in_path)]
path: PathBuf,
}
#[derive(Parser)]
struct EnableAutostart {
/// Path to a static configuration JSON file
#[clap(action, short, long)]
#[clap(value_parser = replace_env_in_path)]
config: Option<PathBuf>,
}
#[derive(Parser)]
struct EagerFocus {
/// Case-sensitive exe identifier
exe: String,
}
#[derive(Parser)]
struct ScrollingLayoutColumns {
/// Desired number of visible columns
count: NonZeroUsize,
}
#[derive(Parser)]
struct LayoutRatios {
/// Column width ratios (space-separated values between 0.1 and 0.9)
#[clap(short, long, num_args = 1..)]
columns: Option<Vec<f32>>,
/// Row height ratios (space-separated values between 0.1 and 0.9)
#[clap(short, long, num_args = 1..)]
rows: Option<Vec<f32>>,
}
#[derive(Parser)]
struct Border {
#[clap(value_enum)]
boolean_state: BooleanState,
}
#[derive(Parser)]
struct BorderColour {
#[clap(value_enum, short, long, default_value = "single")]
window_kind: WindowKind,
/// Red
r: u32,
/// Green
g: u32,
/// Blue
b: u32,
}
#[derive(Parser)]
struct BorderWidth {
/// Desired width of the window border
width: i32,
}
#[derive(Parser)]
struct BorderOffset {
/// Desired offset of the window border
offset: i32,
}
#[derive(Parser)]
struct TransparencyAlpha {
/// Alpha
alpha: u8,
}
#[derive(Parser)]
struct FocusFollowsMouse {
/// On KDE both are KWin's own focus policy
#[clap(value_enum, short, long, default_value = "windows")]
implementation: FocusFollowsMouseImplementation,
#[clap(value_enum)]
boolean_state: BooleanState,
}
#[derive(Parser)]
struct ToggleFocusFollowsMouse {
/// On KDE both are KWin's own focus policy
#[clap(value_enum, short, long, default_value = "windows")]
implementation: FocusFollowsMouseImplementation,
}
#[derive(Parser)]
struct Animation {
#[clap(value_enum)]
boolean_state: BooleanState,
/// Animation type to apply the state to. If not specified, sets global state
#[clap(value_enum, short, long)]
animation_type: Option<komorebi_client::AnimationPrefix>,
}
#[derive(Parser)]
struct AnimationDuration {
/// Desired animation durations in ms
duration: u64,
/// Animation type to apply the duration to. If not specified, sets global duration
#[clap(value_enum, short, long)]
animation_type: Option<komorebi_client::AnimationPrefix>,
}
#[derive(Parser)]
struct AnimationFps {
/// Desired animation frames per second
fps: u64,
}
#[derive(Parser)]
struct AnimationStyle {
/// Desired ease function for animation
#[clap(value_enum, short, long, default_value = "linear")]
style: komorebi_client::AnimationStyle,
/// Animation type to apply the style to. If not specified, sets global style
#[clap(value_enum, short, long)]
animation_type: Option<komorebi_client::AnimationPrefix>,
}
#[derive(Parser)]
struct Docgen {
/// Output directory for generated documentation files
#[clap(short, long)]
output: Option<PathBuf>,
}
#[derive(Parser)]
struct Check {
/// Path to a static configuration JSON file
#[clap(action, short, long)]
#[clap(value_parser = replace_env_in_path)]
komorebi_config: Option<PathBuf>,
/// Look at the configuration and the key bindings only, not at the desktop
#[clap(long)]
configuration_only: bool,
}
#[derive(Parser)]
struct Completions {
#[clap(value_enum)]
shell: clap_complete::Shell,
}
#[derive(Parser)]
#[clap(author, about, version = version::LONG_VERSION)]
struct Opts {
#[clap(subcommand)]
subcmd: SubCommand,
}
#[derive(Parser)]
enum SubCommand {
#[clap(hide = true)]
Docgen(Docgen),
/// Generate komorebic CLI completions for the target shell
#[clap(arg_required_else_help = true)]
Completions(Completions),
/// Gather example configurations for a new-user quickstart
Quickstart,
/// Turn an skhdrc into KDE global shortcuts (they work over RDP, unlike evdev hotkey daemons)
ExportKdeShortcuts(hotkeys::ExportKdeShortcuts),
/// Key bindings: KDE global shortcuts from a key binding file, and the keys of the daemon
#[clap(arg_required_else_help = true)]
Hotkeys(hotkeys::Hotkeys),
/// Start komorebi as a background process
Start(Start),
/// Stop the komorebi process
Stop(Stop),
/// Check komorebi configuration and the desktop it runs on for common errors
Check(Check),
/// Show the path to komorebi.json
#[clap(alias = "config")]
Configuration,
/// Show the path to komorebi's data directory, which has its socket
#[clap(alias = "datadir")]
DataDirectory,
/// Show a JSON representation of the current window manager state
State,
/// Show a JSON representation of the current global state
GlobalState,
/// Show a JSON representation of visible windows
VisibleWindows,
/// Show information about connected monitors
#[clap(alias = "monitor-info")]
MonitorInformation,
/// Query the current window manager state
#[clap(arg_required_else_help = true)]
Query(Query),
/// Subscribe to komorebi events using a Unix Domain Socket
#[clap(arg_required_else_help = true)]
SubscribeSocket(SubscribeSocket),
/// Unsubscribe from komorebi events
#[clap(arg_required_else_help = true)]
UnsubscribeSocket(UnsubscribeSocket),
// /// Subscribe to komorebi events using a Named Pipe
// #[clap(arg_required_else_help = true)]
// #[clap(alias = "subscribe")]
// SubscribePipe(SubscribePipe),
// /// Unsubscribe from komorebi events
// #[clap(arg_required_else_help = true)]
// #[clap(alias = "unsubscribe")]
// UnsubscribePipe(UnsubscribePipe),
/// Tail komorebi's process logs (cancel with Ctrl-C)
Log,
/// Quicksave the current resize layout dimensions
#[clap(alias = "quick-save")]
QuickSaveResize,
/// Load the last quicksaved resize layout dimensions
#[clap(alias = "quick-load")]
QuickLoadResize,
/// Save the current resize layout dimensions to a file
#[clap(arg_required_else_help = true)]
#[clap(alias = "save")]
SaveResize(SaveResize),
/// Load the resize layout dimensions from a file
#[clap(arg_required_else_help = true)]
#[clap(alias = "load")]
LoadResize(LoadResize),
/// Change focus to the window in the specified direction
#[clap(arg_required_else_help = true)]
Focus(Focus),
/// Move the focused window in the specified direction
#[clap(arg_required_else_help = true)]
Move(Move),
/// Preselect the specified direction for the next window to be spawned on supported layouts
#[clap(arg_required_else_help = true)]
PreselectDirection(PreselectDirection),
/// Cancel a workspace preselect set by the preselect-direction command, if one exists
CancelPreselect,
/// Minimize the focused window
Minimize,
/// Close the focused window
Close,
// /// Forcibly focus the window at the cursor with a left mouse click
// ForceFocus,
/// Change focus to the window in the specified cycle direction
#[clap(arg_required_else_help = true)]
CycleFocus(CycleFocus),
/// Move the focused window in the specified cycle direction
#[clap(arg_required_else_help = true)]
CycleMove(CycleMove),
/// Focus the first managed window matching the given executable
#[clap(arg_required_else_help = true)]
EagerFocus(EagerFocus),
/// Stack the focused window in the specified direction
#[clap(arg_required_else_help = true)]
Stack(Stack),
/// Unstack the focused window
Unstack,
/// Cycle the focused stack in the specified cycle direction
#[clap(arg_required_else_help = true)]
CycleStack(CycleStack),
/// Cycle the index of the focused window in the focused stack in the specified cycle direction
#[clap(arg_required_else_help = true)]
CycleStackIndex(CycleStackIndex),
/// Focus the specified window index in the focused stack
#[clap(arg_required_else_help = true)]
FocusStackWindow(FocusStackWindow),
/// Stack all windows on the focused workspace
StackAll,
/// Unstack all windows in the focused container
UnstackAll,
/// Resize the focused window in the specified direction
#[clap(arg_required_else_help = true)]
#[clap(alias = "resize")]
ResizeEdge(Resize),
/// Resize the focused window or primary column along the specified axis
#[clap(arg_required_else_help = true)]
ResizeAxis(ResizeAxis),
/// Move the focused window to the specified monitor
#[clap(arg_required_else_help = true)]
MoveToMonitor(MoveToMonitor),
/// Move the focused window to the monitor in the given cycle direction
#[clap(arg_required_else_help = true)]
CycleMoveToMonitor(CycleMoveToMonitor),
/// Move the focused window to the specified workspace
#[clap(arg_required_else_help = true)]
MoveToWorkspace(MoveToWorkspace),
/// Move the focused window to the specified workspace
#[clap(arg_required_else_help = true)]
MoveToNamedWorkspace(MoveToNamedWorkspace),
/// Move the focused window to the workspace in the given cycle direction
#[clap(arg_required_else_help = true)]
CycleMoveToWorkspace(CycleMoveToWorkspace),
/// Send the focused window to the specified monitor
#[clap(arg_required_else_help = true)]
SendToMonitor(SendToMonitor),
/// Send the focused window to the monitor in the given cycle direction
#[clap(arg_required_else_help = true)]
CycleSendToMonitor(CycleSendToMonitor),
/// Send the focused window to the specified workspace
#[clap(arg_required_else_help = true)]
SendToWorkspace(SendToWorkspace),
/// Send the focused window to the specified workspace
#[clap(arg_required_else_help = true)]
SendToNamedWorkspace(SendToNamedWorkspace),
/// Send the focused window to the workspace in the given cycle direction
#[clap(arg_required_else_help = true)]
CycleSendToWorkspace(CycleSendToWorkspace),
/// Send the focused window to the specified monitor workspace
#[clap(arg_required_else_help = true)]
SendToMonitorWorkspace(SendToMonitorWorkspace),
/// Move the focused window to the specified monitor workspace
#[clap(arg_required_else_help = true)]
MoveToMonitorWorkspace(MoveToMonitorWorkspace),
/// Send the focused window to the last focused monitor workspace
SendToLastWorkspace,
/// Move the focused window to the last focused monitor workspace
MoveToLastWorkspace,
/// Focus the specified monitor
#[clap(arg_required_else_help = true)]
FocusMonitor(FocusMonitor),
/// Focus the monitor at the current cursor location
FocusMonitorAtCursor,
/// Focus the last focused workspace on the focused monitor
FocusLastWorkspace,
/// Focus the specified workspace on the focused monitor
#[clap(arg_required_else_help = true)]
FocusWorkspace(FocusWorkspace),
/// Focus the specified workspace on all monitors
#[clap(arg_required_else_help = true)]
FocusWorkspaces(FocusWorkspaces),
/// Focus the specified workspace on the target monitor
#[clap(arg_required_else_help = true)]
FocusMonitorWorkspace(FocusMonitorWorkspace),
/// Focus the specified workspace
#[clap(arg_required_else_help = true)]
FocusNamedWorkspace(FocusNamedWorkspace),
/// Close the focused workspace (must be empty and unnamed)
CloseWorkspace,
/// Focus the monitor in the given cycle direction
#[clap(arg_required_else_help = true)]
CycleMonitor(CycleMonitor),
/// Focus the workspace in the given cycle direction
#[clap(arg_required_else_help = true)]
CycleWorkspace(CycleWorkspace),
/// Focus the next empty workspace in the given cycle direction (if one exists)
#[clap(arg_required_else_help = true)]
CycleEmptyWorkspace(CycleWorkspace),
/// Move the focused workspace to the specified monitor
#[clap(arg_required_else_help = true)]
MoveWorkspaceToMonitor(MoveWorkspaceToMonitor),
/// Move the focused workspace monitor in the given cycle direction
#[clap(arg_required_else_help = true)]
CycleMoveWorkspaceToMonitor(CycleMoveWorkspaceToMonitor),
/// Swap focused monitor workspaces with specified monitor
#[clap(arg_required_else_help = true)]
SwapWorkspacesWithMonitor(SwapWorkspacesWithMonitor),
/// Create and append a new workspace on the focused monitor
NewWorkspace,
/// Set the resize delta (used by resize-edge and resize-axis)
#[clap(arg_required_else_help = true)]
ResizeDelta(ResizeDelta),
// /// Set the invisible border dimensions around each window
// #[clap(arg_required_else_help = true)]
// InvisibleBorders(InvisibleBorders),
/// Set offsets to exclude parts of the work area from tiling
#[clap(arg_required_else_help = true)]
GlobalWorkAreaOffset(GlobalWorkAreaOffset),
/// Set offsets for a monitor to exclude parts of the work area from tiling
#[clap(arg_required_else_help = true)]
MonitorWorkAreaOffset(MonitorWorkAreaOffset),
/// Set offsets for a workspace to exclude parts of the work area from tiling
#[clap(arg_required_else_help = true)]
WorkspaceWorkAreaOffset(WorkspaceWorkAreaOffset),
/// Toggle application of the window-based work area offset for the focused workspace
ToggleWindowBasedWorkAreaOffset,
/// Set container padding on the focused workspace
#[clap(arg_required_else_help = true)]
FocusedWorkspaceContainerPadding(FocusedWorkspaceContainerPadding),
/// Set workspace padding on the focused workspace
#[clap(arg_required_else_help = true)]
FocusedWorkspacePadding(FocusedWorkspacePadding),
/// Adjust container padding on the focused workspace
#[clap(arg_required_else_help = true)]
AdjustContainerPadding(AdjustContainerPadding),
/// Adjust workspace padding on the focused workspace
#[clap(arg_required_else_help = true)]
AdjustWorkspacePadding(AdjustWorkspacePadding),
/// Set the layout on the focused workspace
#[clap(arg_required_else_help = true)]
ChangeLayout(ChangeLayout),
/// Cycle between available layouts
#[clap(arg_required_else_help = true)]
CycleLayout(CycleLayout),
/// Set the number of visible columns for the Scrolling layout on the focused workspace
#[clap(arg_required_else_help = true)]
ScrollingLayoutColumns(ScrollingLayoutColumns),
/// Set the layout column and row ratios for the focused workspace
LayoutRatios(LayoutRatios),
// /// Load a custom layout from file for the focused workspace
// #[clap(hide = true)]
// #[clap(arg_required_else_help = true)]
// LoadCustomLayout(LoadCustomLayout),
/// Flip the layout on the focused workspace
#[clap(arg_required_else_help = true)]
FlipLayout(FlipLayout),
/// Promote the focused window to the largest tile via container removal and re-insertion
Promote,
/// Promote the focused window to the largest tile by swapping container indices with the largest tile
PromoteSwap,
/// Promote the user focus to the largest window container
PromoteFocus,
/// Promote the window in the specified direction
PromoteWindow(PromoteWindow),
/// Force the retiling of all managed windows
Retile,
// /// Set the monitor index preference for a monitor identified using its size
// #[clap(arg_required_else_help = true)]
// MonitorIndexPreference(MonitorIndexPreference),
/// Set the display index preference for a monitor identified using its display name
#[clap(arg_required_else_help = true)]
DisplayIndexPreference(DisplayIndexPreference),
/// Create at least this many workspaces for the specified monitor
#[clap(arg_required_else_help = true)]
EnsureWorkspaces(EnsureWorkspaces),
/// Create these many named workspaces for the specified monitor
#[clap(arg_required_else_help = true)]
EnsureNamedWorkspaces(EnsureNamedWorkspaces),
/// Set the container padding for the specified workspace
#[clap(arg_required_else_help = true)]
ContainerPadding(ContainerPadding),
/// Set the container padding for the specified workspace
#[clap(arg_required_else_help = true)]
NamedWorkspaceContainerPadding(NamedWorkspaceContainerPadding),
/// Set the workspace padding for the specified workspace
#[clap(arg_required_else_help = true)]
WorkspacePadding(WorkspacePadding),
/// Set the workspace padding for the specified workspace
#[clap(arg_required_else_help = true)]
NamedWorkspacePadding(NamedWorkspacePadding),
/// Set the layout for the specified workspace
#[clap(arg_required_else_help = true)]
WorkspaceLayout(WorkspaceLayout),
/// Set the layout for the specified workspace
#[clap(arg_required_else_help = true)]
NamedWorkspaceLayout(NamedWorkspaceLayout),
// /// Set a custom layout for the specified workspace
// #[clap(hide = true)]
// #[clap(arg_required_else_help = true)]
// WorkspaceCustomLayout(WorkspaceCustomLayout),
// /// Set a custom layout for the specified workspace
// #[clap(hide = true)]
// #[clap(arg_required_else_help = true)]
// NamedWorkspaceCustomLayout(NamedWorkspaceCustomLayout),
/// Add a dynamic layout rule for the specified workspace
#[clap(arg_required_else_help = true)]
WorkspaceLayoutRule(WorkspaceLayoutRule),
/// Add a dynamic layout rule for the specified workspace
#[clap(arg_required_else_help = true)]
NamedWorkspaceLayoutRule(NamedWorkspaceLayoutRule),
// /// Add a dynamic custom layout for the specified workspace
// #[clap(hide = true)]
// #[clap(arg_required_else_help = true)]
// WorkspaceCustomLayoutRule(WorkspaceCustomLayoutRule),
// /// Add a dynamic custom layout for the specified workspace
// #[clap(hide = true)]
// #[clap(arg_required_else_help = true)]
// NamedWorkspaceCustomLayoutRule(NamedWorkspaceCustomLayoutRule),
/// Clear all dynamic layout rules for the specified workspace
#[clap(arg_required_else_help = true)]
ClearWorkspaceLayoutRules(ClearWorkspaceLayoutRules),
/// Clear all dynamic layout rules for the specified workspace
#[clap(arg_required_else_help = true)]
ClearNamedWorkspaceLayoutRules(ClearNamedWorkspaceLayoutRules),
/// Enable or disable window tiling for the specified workspace
#[clap(arg_required_else_help = true)]
WorkspaceTiling(WorkspaceTiling),
/// Enable or disable window tiling for the specified workspace
#[clap(arg_required_else_help = true)]
NamedWorkspaceTiling(NamedWorkspaceTiling),
/// Set the workspace name for the specified workspace
#[clap(arg_required_else_help = true)]
WorkspaceName(WorkspaceName),
/// Toggle the behavior for new windows (stacking or dynamic tiling)
ToggleWindowContainerBehaviour,
/// Enable or disable float override, which makes it so every new window opens in floating mode
ToggleFloatOverride,
/// Toggle the behavior for new windows (stacking or dynamic tiling) for currently focused
/// workspace. If there was no behavior set for the workspace previously it takes the opposite
/// of the global value.
ToggleWorkspaceWindowContainerBehaviour,
/// Enable or disable float override, which makes it so every new window opens in floating
/// mode, for the currently focused workspace. If there was no override value set for the
/// workspace previously it takes the opposite of the global value.
ToggleWorkspaceFloatOverride,
/// Toggle between the Tiling and Floating layers on the focused workspace
ToggleWorkspaceLayer,
/// Toggle the paused state for all window tiling
TogglePause,
/// Toggle window tiling on the focused workspace
ToggleTiling,
/// Toggle floating mode for the focused window
ToggleFloat,
/// Toggle monocle mode for the focused container
ToggleMonocle,
/// Toggle the compositor's maximization for the focused window
ToggleMaximize,
/// Toggle a lock for the focused container, ensuring it will not be displaced by any new windows
ToggleLock,
/// Force komorebi to manage the focused window
Manage,
/// Unmanage a window that was forcibly managed
Unmanage,
/// Set the behaviour when moving windows across monitor boundaries
#[clap(arg_required_else_help = true)]
CrossMonitorMoveBehaviour(CrossMonitorMoveBehaviour),
/// Toggle the behaviour when moving windows across monitor boundaries
ToggleCrossMonitorMoveBehaviour,
/// Set the behavior when focusing in a direction while a monocle container is active
#[clap(arg_required_else_help = true)]
MonocleFocusBehaviour(MonocleFocusBehaviour),
/// Toggle the behavior when focusing in a direction while a monocle container is active
ToggleMonocleFocusBehaviour,
/// Set the operation behavior when the focused window is not managed
#[clap(arg_required_else_help = true)]
UnmanagedWindowOperationBehaviour(UnmanagedWindowOperationBehaviour),
/// Add a rule to float the foreground window for the rest of this session
SessionFloatRule,
/// Show all session float rules
SessionFloatRules,
/// Clear all session float rules
ClearSessionFloatRules,
/// Add a rule to ignore the specified application
#[clap(arg_required_else_help = true)]
#[clap(alias = "float-rule")]
IgnoreRule(IgnoreRule),
/// Add a rule to always manage the specified application
#[clap(arg_required_else_help = true)]
ManageRule(ManageRule),
/// Add a rule to associate an application with a workspace on first show
#[clap(arg_required_else_help = true)]
InitialWorkspaceRule(InitialWorkspaceRule),
/// Add a rule to associate an application with a named workspace on first show
#[clap(arg_required_else_help = true)]
InitialNamedWorkspaceRule(InitialNamedWorkspaceRule),
/// Add a rule to associate an application with a workspace
#[clap(arg_required_else_help = true)]
WorkspaceRule(WorkspaceRule),
/// Add a rule to associate an application with a named workspace
#[clap(arg_required_else_help = true)]
NamedWorkspaceRule(NamedWorkspaceRule),
/// Remove all application association rules for a workspace by monitor and workspace index
#[clap(arg_required_else_help = true)]
ClearWorkspaceRules(ClearWorkspaceRules),
/// Remove all application association rules for a named workspace
#[clap(arg_required_else_help = true)]
ClearNamedWorkspaceRules(ClearNamedWorkspaceRules),
/// Remove all application association rules for all workspaces
ClearAllWorkspaceRules,
/// Enforce all workspace rules, including initial workspace rules that have already been applied
EnforceWorkspaceRules,
/// Enable or disable borders
#[clap(arg_required_else_help = true)]
#[clap(alias = "active-window-border")]
Border(Border),
/// Set the color for a window border kind
#[clap(arg_required_else_help = true)]
#[clap(alias = "active-window-border-colour")]
BorderColour(BorderColour),
/// Set the border width
#[clap(arg_required_else_help = true)]
#[clap(alias = "active-window-border-width")]
BorderWidth(BorderWidth),
/// Set the border offset
#[clap(arg_required_else_help = true)]
#[clap(alias = "active-window-border-offset")]
BorderOffset(BorderOffset),
// /// Set the border style
// #[clap(arg_required_else_help = true)]
// BorderStyle(BorderStyle),
// /// Set the border implementation
// #[clap(arg_required_else_help = true)]
// BorderImplementation(BorderImplementation),
/// Enable or disable transparency for unfocused windows
#[clap(arg_required_else_help = true)]
Transparency(Transparency),
/// Set the alpha value for unfocused window transparency
#[clap(arg_required_else_help = true)]
TransparencyAlpha(TransparencyAlpha),
/// Toggle transparency for unfocused windows
ToggleTransparency,
/// Enable or disable movement animations
#[clap(arg_required_else_help = true)]
Animation(Animation),
/// Set the duration for movement animations in ms
#[clap(arg_required_else_help = true)]
AnimationDuration(AnimationDuration),
/// Set the frames per second for movement animations
#[clap(arg_required_else_help = true)]
AnimationFps(AnimationFps),
/// Set the ease function for movement animations
#[clap(arg_required_else_help = true)]
AnimationStyle(AnimationStyle),
/// Enable or disable focus follows mouse (KWin's own focus policy)
#[clap(arg_required_else_help = true)]
FocusFollowsMouse(FocusFollowsMouse),
/// Toggle focus follows mouse (KWin's own focus policy)
ToggleFocusFollowsMouse(ToggleFocusFollowsMouse),
/// Enable or disable mouse follows focus on all workspaces
#[clap(arg_required_else_help = true)]
MouseFollowsFocus(MouseFollowsFocus),
/// Toggle mouse follows focus on all workspaces
ToggleMouseFollowsFocus,
/// Replace the configuration of a running instance of komorebi from a static configuration file
#[clap(arg_required_else_help = true)]
ReplaceConfiguration(ReplaceConfiguration),
/// Generate a JSON Schema for applications.json
#[clap(alias = "asc-schema")]
ApplicationSpecificConfigurationSchema,
/// Generate a JSON Schema of subscription notifications
NotificationSchema,
/// Generate a JSON Schema of socket messages
SocketSchema,
/// Generate a JSON Schema of the static configuration file
StaticConfigSchema,
/// Generates a static configuration JSON file based on the current window manager state
GenerateStaticConfig,
/// Writes an XDG autostart entry so komorebi starts with the Plasma session
EnableAutostart(EnableAutostart),
/// Removes the XDG autostart entry
DisableAutostart,
}
/// `~/.config/autostart/komorebi.desktop`, which Plasma runs at login
fn autostart_entry() -> PathBuf {
dirs::config_dir()
.expect("there is no config directory")
.join("autostart")
.join("komorebi.desktop")
}
fn print_query(message: &SocketMessage) {
match send_query(message) {
Ok(response) => println!("{response}"),
Err(error) => panic!("{}", error),
}
}
fn main() -> eyre::Result<()> {
let opts: Opts = Opts::parse();
match opts.subcmd {
SubCommand::Docgen(args) => {
let mut cli = Opts::command();
let subcommands = cli.get_subcommands_mut();
let output_dir = args.output.unwrap_or_else(|| PathBuf::from("docs/cli"));
std::fs::create_dir_all(&output_dir)?;
let ignore = [
"docgen",
"splash",
"alt-focus-hack",
"identify-border-overflow-application",
"load-custom-layout",
"workspace-custom-layout",
"named-workspace-custom-layout",
"workspace-custom-layout-rule",
"named-workspace-custom-layout-rule",
"focus-follows-mouse",
"toggle-focus-follows-mouse",
"format-app-specific-configuration",
];
for cmd in subcommands {
let name = cmd.get_name().to_string();
if !ignore.contains(&name.as_str()) {
// a subcommand of a subcommand (`hotkeys compile`) gets a page of its own
let nested = cmd
.get_subcommands()
.map(|sub| (format!("{name}-{}", sub.get_name()), sub.clone()));
for (name, cmd) in std::iter::once((name.clone(), cmd.clone())).chain(nested) {
// the same pages whatever the width of the terminal docgen runs in
let help_text = cmd.term_width(100).render_long_help().to_string();
let outpath = output_dir.join(format!("{name}.md"));
let markdown = format!("```text\n{help_text}\n```\n");
std::fs::write(&outpath, markdown)?;
println!("{}", outpath.display());
}
}
}
}
SubCommand::Completions(args) => {
let mut cli = Opts::command();
clap_complete::generate(args.shell, &mut cli, "komorebic", &mut std::io::stdout());
}
SubCommand::ExportKdeShortcuts(args) => hotkeys::export_kde_shortcuts(args)?,
SubCommand::Hotkeys(args) => hotkeys::hotkeys(args)?,
SubCommand::Quickstart => {
fn write_file_with_prompt(
path: &PathBuf,
content: &str,
created_files: &mut Vec<String>,
) -> eyre::Result<()> {
if path.exists() {
print!(
"{} will be overwritten, do you want to continue? (y/N): ",
path.display()
);
std::io::stdout().flush()?;
let mut input = String::new();
std::io::stdin().read_line(&mut input)?;
let trimmed = input.trim().to_lowercase();
if trimmed == "y" || trimmed == "yes" {
std::fs::write(path, content)?;
created_files.push(path.display().to_string());
} else {
println!("Skipping {}", path.display());
}
} else {
std::fs::write(path, content)?;
created_files.push(path.display().to_string());
}
Ok(())
}
std::fs::create_dir_all(&*HOME_DIR)?;
std::fs::create_dir_all(&*komorebi_client::DATA_DIR)?;
let komorebi_json = include_str!("../../docs/komorebi.example.json").to_string();
let komorebi_path = HOME_DIR.join("komorebi.json");
let applications_path = HOME_DIR.join("applications.json");
let skhdrc_path = HOME_DIR.join("skhdrc");
let mut written_files = Vec::new();
write_file_with_prompt(&komorebi_path, &komorebi_json, &mut written_files)?;
let applications_json = include_str!("../applications.json");
write_file_with_prompt(&applications_path, applications_json, &mut written_files)?;
let skhdrc = include_str!("../../docs/skhdrc.sample");
write_file_with_prompt(&skhdrc_path, skhdrc, &mut written_files)?;
if written_files.is_empty() {
println!("\nNo files were written.")
} else {
println!(
"\nThe following example files were written:\n{}",
written_files.join("\n")
);
}
println!("\nYou can now run: komorebic start");
}
SubCommand::EnableAutostart(args) => {
let exec = match args.config {
None => String::from("komorebi"),
Some(config) => format!("komorebi --config \"{}\"", config.display()),
};
let target = autostart_entry();
if let Some(dir) = target.parent() {
std::fs::create_dir_all(dir)?;
}
std::fs::write(
&target,
format!(
"[Desktop Entry]\nType=Application\nName=komorebi\nComment=A tiling window manager for KDE Plasma\nExec={exec}\nX-KDE-autostart-after=plasma-workspace\nTerminal=false\n"
),
)?;
println!("Wrote {}", target.display());
}
SubCommand::DisableAutostart => {
let target = autostart_entry();
if target.exists() {
std::fs::remove_file(&target)?;
println!("Deleted {}", target.display());
} else {
println!("There is no autostart entry at {}", target.display());
}
}
SubCommand::Check(args) => {
use komorebi_client::check::Finding;
use komorebi_client::check::Report;
let mut report = Report::default();
// where komorebi looks
let mut place = vec![];
if std::env::var_os("KOMOREBI_CONFIG_HOME").is_some() {
place.push(Finding::note(format!(
"KOMOREBI_CONFIG_HOME is set: looking in {}",
HOME_DIR.display()
)));
} else {
place.push(Finding::note(format!(
"KOMOREBI_CONFIG_HOME is not set: looking in {}",
HOME_DIR.display()
)));
}
let static_config = match args.komorebi_config {
Some(path) => {
place.push(Finding::note(format!(
"using the configuration file given with --komorebi-config: {}",
path.display()
)));
path
}
None => HOME_DIR.join("komorebi.json"),
};
let (findings, wants) = komorebi_client::check::check_configuration(&static_config);
place.extend(findings);
report.push("Configuration", place);
report.push("Key bindings", hotkeys::check(&HOME_DIR));
if !args.configuration_only {
report.push(
"The desktop",
komorebi_client::check::check_environment(&wants),
);
}
print!("{}", report.render());
if report.has_errors() {
std::process::exit(1);
}
}
SubCommand::Start(args) => {
let mut command = &mut Command::new("komorebi");
if let Some(config) = &args.config {
command = command.args(["--config", &config.display().to_string()])
};
command = command
.args(&args.komorebi_args)
.stdout(Stdio::null())
.stderr(Stdio::null())
.stdin(Stdio::null());
let mut system = sysinfo::System::new_all()?;
system.refresh_processes(ProcessesToUpdate::All, true);
let mut attempts = 0;
let mut running = system
.processes_by_exact_name("komorebi".as_ref())
.next()
.is_some();
while !running && attempts <= 2 {
command.spawn()?;
print!("Waiting for komorebi to start... ");
std::io::stdout().flush()?;
std::thread::sleep(Duration::from_secs(3));
system.refresh_processes(ProcessesToUpdate::All, true);
if system
.processes_by_exact_name("komorebi".as_ref())
.next()
.is_some()
{
println!("Started!");
running = true;
} else {
println!("komorebi did not start... Trying again");
attempts += 1;
}
}
if !running {
println!("\nRunning komorebi directly for detailed error output\n");
let mut command = Command::new("komorebi");
if let Some(config) = &args.config {
command.args(["--config", &config.display().to_string()]);
}
if let Ok(output) = command.args(&args.komorebi_args).output() {
println!("{}", String::from_utf8(output.stderr)?);
}
}
}
SubCommand::Stop(args) => {
if args.ignore_restore {
send_message(&SocketMessage::StopIgnoreRestore)?;
} else {
send_message(&SocketMessage::Stop)?;
}
}
SubCommand::Configuration => {
let static_config = HOME_DIR.join("komorebi.json");
if static_config.exists() {
println!("{}", static_config.display());
}
}
SubCommand::DataDirectory => {
let dir = &*komorebi_client::DATA_DIR;
if dir.exists() {
println!("{}", dir.display());
}
}
SubCommand::Log => {
let timestamp = Utc::now().format("%Y-%m-%d").to_string();
let color_log = komorebi_client::LOG_DIR.join(format!("komorebi.log.{timestamp}"));
let file = TailedFile::new(File::open(color_log)?);
let locked = file.lock();
#[allow(clippy::significant_drop_in_scrutinee, clippy::lines_filter_map_ok)]
for line in locked.lines().flatten() {
println!("{line}");
}
}
SubCommand::Focus(args) => {
send_message(&SocketMessage::FocusWindow(args.operation_direction))?;
}
SubCommand::Move(args) => {
send_message(&SocketMessage::MoveWindow(args.operation_direction))?;
}
SubCommand::PreselectDirection(args) => {
send_message(&SocketMessage::PreselectDirection(args.operation_direction))?;
}
SubCommand::CancelPreselect => {
send_message(&SocketMessage::CancelPreselect)?;
}
SubCommand::CycleFocus(args) => {
send_message(&SocketMessage::CycleFocusWindow(args.cycle_direction))?;
}
SubCommand::CycleMove(args) => {
send_message(&SocketMessage::CycleMoveWindow(args.cycle_direction))?;
}
SubCommand::TogglePause => {
send_message(&SocketMessage::TogglePause)?;
}
SubCommand::ChangeLayout(args) => {
send_message(&SocketMessage::ChangeLayout(args.default_layout))?;
}
SubCommand::CycleLayout(args) => {
send_message(&SocketMessage::CycleLayout(args.cycle_direction))?;
}
SubCommand::FlipLayout(args) => {
send_message(&SocketMessage::FlipLayout(args.axis))?;
}
SubCommand::Stack(args) => {
send_message(&SocketMessage::StackWindow(args.operation_direction))?;
}
SubCommand::StackAll => {
send_message(&SocketMessage::StackAll)?;
}
SubCommand::Unstack => {
send_message(&SocketMessage::UnstackWindow)?;
}
SubCommand::UnstackAll => {
send_message(&SocketMessage::UnstackAll)?;
}
SubCommand::FocusStackWindow(args) => {
send_message(&SocketMessage::FocusStackWindow(args.target))?;
}
SubCommand::CycleStack(args) => {
send_message(&SocketMessage::CycleStack(args.cycle_direction))?;
}
SubCommand::CycleStackIndex(args) => {
send_message(&SocketMessage::CycleStackIndex(args.cycle_direction))?;
}
SubCommand::FocusWorkspace(args) => {
send_message(&SocketMessage::FocusWorkspaceNumber(args.target))?;
}
SubCommand::ToggleCrossMonitorMoveBehaviour => {
send_message(&SocketMessage::ToggleCrossMonitorMoveBehaviour)?;
}
SubCommand::ToggleMonocleFocusBehaviour => {
send_message(&SocketMessage::ToggleMonocleFocusBehaviour)?;
}
SubCommand::FocusMonitor(args) => {
send_message(&SocketMessage::FocusMonitorNumber(args.target))?;
}
SubCommand::FocusMonitorAtCursor => {
send_message(&SocketMessage::FocusMonitorAtCursor)?;
}
SubCommand::FocusLastWorkspace => {
send_message(&SocketMessage::FocusLastWorkspace)?;
}
SubCommand::FocusWorkspaces(args) => {
send_message(&SocketMessage::FocusWorkspaceNumbers(args.target))?;
}
SubCommand::FocusMonitorWorkspace(args) => {
send_message(&SocketMessage::FocusMonitorWorkspaceNumber(
args.target_monitor,
args.target_workspace,
))?;
}
SubCommand::FocusNamedWorkspace(args) => {
send_message(&SocketMessage::FocusNamedWorkspace(args.workspace))?;
}
SubCommand::CloseWorkspace => {
send_message(&SocketMessage::CloseWorkspace)?;
}
SubCommand::CycleMonitor(args) => {
send_message(&SocketMessage::CycleFocusMonitor(args.cycle_direction))?;
}
SubCommand::CycleWorkspace(args) => {
send_message(&SocketMessage::CycleFocusWorkspace(args.cycle_direction))?;
}
SubCommand::CycleEmptyWorkspace(args) => {
send_message(&SocketMessage::CycleFocusEmptyWorkspace(
args.cycle_direction,
))?;
}
SubCommand::ToggleMonocle => {
send_message(&SocketMessage::ToggleMonocle)?;
}
SubCommand::ToggleMaximize => {
send_message(&SocketMessage::ToggleMaximize)?;
}
SubCommand::ToggleFloat => {
send_message(&SocketMessage::ToggleFloat)?;
}
SubCommand::ToggleWorkspaceLayer => {
send_message(&SocketMessage::ToggleWorkspaceLayer)?;
}
SubCommand::ResizeEdge(args) => {
send_message(&SocketMessage::ResizeWindowEdge(args.edge, args.sizing))?;
}
SubCommand::ResizeAxis(args) => {
send_message(&SocketMessage::ResizeWindowAxis(args.axis, args.sizing))?;
}
SubCommand::MoveToMonitor(args) => {
send_message(&SocketMessage::MoveContainerToMonitorNumber(args.target))?;
}
SubCommand::CycleMoveToMonitor(args) => {
send_message(&SocketMessage::CycleMoveContainerToMonitor(
args.cycle_direction,
))?;
}
SubCommand::MoveToWorkspace(args) => {
send_message(&SocketMessage::MoveContainerToWorkspaceNumber(args.target))?;
}
SubCommand::MoveToNamedWorkspace(args) => {
send_message(&SocketMessage::MoveContainerToNamedWorkspace(
args.workspace,
))?;
}
SubCommand::CycleMoveToWorkspace(args) => {
send_message(&SocketMessage::CycleMoveContainerToWorkspace(
args.cycle_direction,
))?;
}
SubCommand::SendToMonitor(args) => {
send_message(&SocketMessage::SendContainerToMonitorNumber(args.target))?;
}
SubCommand::CycleSendToMonitor(args) => {
send_message(&SocketMessage::CycleSendContainerToMonitor(
args.cycle_direction,
))?;
}
SubCommand::SendToWorkspace(args) => {
send_message(&SocketMessage::SendContainerToWorkspaceNumber(args.target))?;
}
SubCommand::SendToNamedWorkspace(args) => {
send_message(&SocketMessage::SendContainerToNamedWorkspace(
args.workspace,
))?;
}
SubCommand::CycleSendToWorkspace(args) => {
send_message(&SocketMessage::CycleSendContainerToWorkspace(
args.cycle_direction,
))?;
}
SubCommand::SendToMonitorWorkspace(args) => {
send_message(&SocketMessage::SendContainerToMonitorWorkspaceNumber(
args.target_monitor,
args.target_workspace,
))?;
}
SubCommand::MoveToMonitorWorkspace(args) => {
send_message(&SocketMessage::MoveContainerToMonitorWorkspaceNumber(
args.target_monitor,
args.target_workspace,
))?;
}
SubCommand::MoveWorkspaceToMonitor(args) => {
send_message(&SocketMessage::MoveWorkspaceToMonitorNumber(args.target))?;
}
SubCommand::CycleMoveWorkspaceToMonitor(args) => {
send_message(&SocketMessage::CycleMoveWorkspaceToMonitor(
args.cycle_direction,
))?;
}
SubCommand::MoveToLastWorkspace => {
send_message(&SocketMessage::MoveContainerToLastWorkspace)?;
}
SubCommand::SendToLastWorkspace => {
send_message(&SocketMessage::SendContainerToLastWorkspace)?;
}
SubCommand::SwapWorkspacesWithMonitor(args) => {
send_message(&SocketMessage::SwapWorkspacesToMonitorNumber(args.target))?;
}
SubCommand::Retile => {
send_message(&SocketMessage::Retile)?;
}
SubCommand::Close => {
send_message(&SocketMessage::Close)?;
}
SubCommand::Minimize => {
send_message(&SocketMessage::Minimize)?;
}
SubCommand::Manage => {
send_message(&SocketMessage::ManageFocusedWindow)?;
}
SubCommand::Unmanage => {
send_message(&SocketMessage::UnmanageFocusedWindow)?;
}
SubCommand::Promote => {
send_message(&SocketMessage::Promote)?;
}
SubCommand::PromoteSwap => {
send_message(&SocketMessage::PromoteSwap)?;
}
SubCommand::PromoteFocus => {
send_message(&SocketMessage::PromoteFocus)?;
}
SubCommand::PromoteWindow(args) => {
send_message(&SocketMessage::PromoteWindow(args.operation_direction))?;
}
SubCommand::ToggleWindowBasedWorkAreaOffset => {
send_message(&SocketMessage::ToggleWindowBasedWorkAreaOffset)?;
}
SubCommand::ToggleWindowContainerBehaviour => {
send_message(&SocketMessage::ToggleWindowContainerBehaviour)?;
}
SubCommand::ToggleFloatOverride => {
send_message(&SocketMessage::ToggleFloatOverride)?;
}
SubCommand::ToggleWorkspaceWindowContainerBehaviour => {
send_message(&SocketMessage::ToggleWorkspaceWindowContainerBehaviour)?;
}
SubCommand::ToggleWorkspaceFloatOverride => {
send_message(&SocketMessage::ToggleWorkspaceFloatOverride)?;
}
SubCommand::ToggleTiling => {
send_message(&SocketMessage::ToggleTiling)?;
}
SubCommand::ToggleLock => {
send_message(&SocketMessage::ToggleLock)?;
}
SubCommand::State => {
print_query(&SocketMessage::State);
}
SubCommand::GlobalState => {
print_query(&SocketMessage::GlobalState);
}
SubCommand::Query(args) => {
print_query(&SocketMessage::Query(args.state_query));
}
SubCommand::VisibleWindows => {
print_query(&SocketMessage::VisibleWindows);
}
SubCommand::MonitorInformation => {
print_query(&SocketMessage::MonitorInformation);
}
SubCommand::SessionFloatRule => {
send_message(&SocketMessage::SessionFloatRule)?;
}
SubCommand::SessionFloatRules => {
print_query(&SocketMessage::SessionFloatRules);
}
SubCommand::ClearSessionFloatRules => {
send_message(&SocketMessage::ClearSessionFloatRules)?;
}
SubCommand::IgnoreRule(args) => {
send_message(&SocketMessage::IgnoreRule(args.identifier, args.id))?;
}
SubCommand::ManageRule(args) => {
send_message(&SocketMessage::ManageRule(args.identifier, args.id))?;
}
SubCommand::InitialWorkspaceRule(args) => {
send_message(&SocketMessage::InitialWorkspaceRule(
args.identifier,
args.id,
args.monitor,
args.workspace,
))?;
}
SubCommand::InitialNamedWorkspaceRule(args) => {
send_message(&SocketMessage::InitialNamedWorkspaceRule(
args.identifier,
args.id,
args.workspace,
))?;
}
SubCommand::WorkspaceRule(args) => {
send_message(&SocketMessage::WorkspaceRule(
args.identifier,
args.id,
args.monitor,
args.workspace,
))?;
}
SubCommand::NamedWorkspaceRule(args) => {
send_message(&SocketMessage::NamedWorkspaceRule(
args.identifier,
args.id,
args.workspace,
))?;
}
SubCommand::ClearWorkspaceRules(args) => {
send_message(&SocketMessage::ClearWorkspaceRules(
args.monitor,
args.workspace,
))?;
}
SubCommand::ClearNamedWorkspaceRules(args) => {
send_message(&SocketMessage::ClearNamedWorkspaceRules(args.workspace))?;
}
SubCommand::ClearAllWorkspaceRules => {
send_message(&SocketMessage::ClearAllWorkspaceRules)?;
}
SubCommand::EnforceWorkspaceRules => {
send_message(&SocketMessage::EnforceWorkspaceRules)?;
}
SubCommand::EagerFocus(args) => {
send_message(&SocketMessage::EagerFocus(args.exe))?;
}
SubCommand::NewWorkspace => {
send_message(&SocketMessage::NewWorkspace)?;
}
SubCommand::WorkspaceName(name) => {
send_message(&SocketMessage::WorkspaceName(
name.monitor,
name.workspace,
name.value,
))?;
}
SubCommand::ResizeDelta(args) => {
send_message(&SocketMessage::ResizeDelta(args.pixels))?;
}
SubCommand::MonitorWorkAreaOffset(args) => {
send_message(&SocketMessage::MonitorWorkAreaOffset(
args.monitor,
Rect {
left: args.left,
top: args.top,
right: args.right,
bottom: args.bottom,
},
))?;
}
SubCommand::GlobalWorkAreaOffset(args) => {
send_message(&SocketMessage::WorkAreaOffset(Rect {
left: args.left,
top: args.top,
right: args.right,
bottom: args.bottom,
}))?;
}
SubCommand::WorkspaceWorkAreaOffset(args) => {
send_message(&SocketMessage::WorkspaceWorkAreaOffset(
args.monitor,
args.workspace,
Rect {
left: args.left,
top: args.top,
right: args.right,
bottom: args.bottom,
},
))?;
}
SubCommand::ContainerPadding(args) => {
send_message(&SocketMessage::ContainerPadding(
args.monitor,
args.workspace,
args.size,
))?;
}
SubCommand::NamedWorkspaceContainerPadding(args) => {
send_message(&SocketMessage::NamedWorkspaceContainerPadding(
args.workspace,
args.size,
))?;
}
SubCommand::WorkspacePadding(args) => {
send_message(&SocketMessage::WorkspacePadding(
args.monitor,
args.workspace,
args.size,
))?;
}
SubCommand::NamedWorkspacePadding(args) => {
send_message(&SocketMessage::NamedWorkspacePadding(
args.workspace,
args.size,
))?;
}
SubCommand::FocusedWorkspacePadding(args) => {
send_message(&SocketMessage::FocusedWorkspacePadding(args.size))?;
}
SubCommand::FocusedWorkspaceContainerPadding(args) => {
send_message(&SocketMessage::FocusedWorkspaceContainerPadding(args.size))?;
}
SubCommand::AdjustWorkspacePadding(args) => {
send_message(&SocketMessage::AdjustWorkspacePadding(
args.sizing,
args.adjustment,
))?;
}
SubCommand::AdjustContainerPadding(args) => {
send_message(&SocketMessage::AdjustContainerPadding(
args.sizing,
args.adjustment,
))?;
}
SubCommand::WorkspaceLayout(args) => {
send_message(&SocketMessage::WorkspaceLayout(
args.monitor,
args.workspace,
args.value,
))?;
}
SubCommand::NamedWorkspaceLayout(args) => {
send_message(&SocketMessage::NamedWorkspaceLayout(
args.workspace,
args.value,
))?;
}
SubCommand::WorkspaceTiling(args) => {
send_message(&SocketMessage::WorkspaceTiling(
args.monitor,
args.workspace,
args.value.into(),
))?;
}
SubCommand::NamedWorkspaceTiling(args) => {
send_message(&SocketMessage::NamedWorkspaceTiling(
args.workspace,
args.value.into(),
))?;
}
SubCommand::ScrollingLayoutColumns(args) => {
send_message(&SocketMessage::ScrollingLayoutColumns(args.count))?;
}
SubCommand::LayoutRatios(args) => {
if args.columns.is_none() && args.rows.is_none() {
println!(
"No ratios provided, nothing to change. Use --columns or --rows to specify ratios."
);
} else {
send_message(&SocketMessage::LayoutRatios(args.columns, args.rows))?;
}
}
SubCommand::ClearWorkspaceLayoutRules(args) => {
send_message(&SocketMessage::ClearWorkspaceLayoutRules(
args.monitor,
args.workspace,
))?;
}
SubCommand::ClearNamedWorkspaceLayoutRules(args) => {
send_message(&SocketMessage::ClearNamedWorkspaceLayoutRules(
args.workspace,
))?;
}
SubCommand::CrossMonitorMoveBehaviour(args) => {
send_message(&SocketMessage::CrossMonitorMoveBehaviour(
args.move_behaviour,
))?;
}
SubCommand::DisplayIndexPreference(args) => {
send_message(&SocketMessage::DisplayIndexPreference(
args.index_preference,
args.display,
))?;
}
SubCommand::EnsureWorkspaces(workspaces) => {
send_message(&SocketMessage::EnsureWorkspaces(
workspaces.monitor,
workspaces.workspace_count,
))?;
}
SubCommand::EnsureNamedWorkspaces(args) => {
send_message(&SocketMessage::EnsureNamedWorkspaces(
args.monitor,
args.names,
))?;
}
SubCommand::WorkspaceLayoutRule(args) => {
send_message(&SocketMessage::WorkspaceLayoutRule(
args.monitor,
args.workspace,
args.at_container_count,
args.layout,
))?;
}
SubCommand::NamedWorkspaceLayoutRule(args) => {
send_message(&SocketMessage::NamedWorkspaceLayoutRule(
args.workspace,
args.at_container_count,
args.layout,
))?;
}
SubCommand::MonocleFocusBehaviour(args) => {
send_message(&SocketMessage::MonocleFocusBehaviour(args.behaviour))?;
}
SubCommand::UnmanagedWindowOperationBehaviour(args) => {
send_message(&SocketMessage::UnmanagedWindowOperationBehaviour(
args.operation_behaviour,
))?;
}
SubCommand::ToggleMouseFollowsFocus => {
send_message(&SocketMessage::ToggleMouseFollowsFocus)?;
}
SubCommand::MouseFollowsFocus(args) => {
send_message(&SocketMessage::MouseFollowsFocus(args.boolean_state.into()))?;
}
SubCommand::ApplicationSpecificConfigurationSchema => {
#[cfg(feature = "schemars")]
{
let asc = schemars::schema_for!(komorebi_client::ApplicationSpecificConfiguration);
let schema = serde_json::to_string_pretty(&asc)?;
println!("{schema}");
}
}
SubCommand::NotificationSchema => {
#[cfg(feature = "schemars")]
{
let notification = schemars::schema_for!(komorebi_client::Notification);
let schema = serde_json::to_string_pretty(&notification)?;
println!("{schema}");
}
}
SubCommand::SocketSchema => {
#[cfg(feature = "schemars")]
{
let socket_message = schemars::schema_for!(SocketMessage);
let schema = serde_json::to_string_pretty(&socket_message)?;
println!("{schema}");
}
}
SubCommand::StaticConfigSchema => {
#[cfg(feature = "schemars")]
{
let socket_message = schemars::schema_for!(komorebi_client::StaticConfig);
let schema = serde_json::to_string_pretty(&socket_message)?;
println!("{schema}");
}
}
SubCommand::SubscribeSocket(args) => {
send_message(&SocketMessage::AddSubscriberSocket(args.socket))?;
}
SubCommand::UnsubscribeSocket(args) => {
send_message(&SocketMessage::RemoveSubscriberSocket(args.socket))?;
}
SubCommand::GenerateStaticConfig => {
print_query(&SocketMessage::GenerateStaticConfig);
}
SubCommand::ReplaceConfiguration(args) => {
send_message(&SocketMessage::ReplaceConfiguration(args.path))?;
}
SubCommand::QuickSaveResize => {
send_message(&SocketMessage::QuickSave)?;
}
SubCommand::QuickLoadResize => {
send_message(&SocketMessage::QuickLoad)?;
}
SubCommand::SaveResize(args) => {
send_message(&SocketMessage::Save(args.path))?;
}
SubCommand::LoadResize(args) => {
send_message(&SocketMessage::Load(args.path))?;
}
SubCommand::Border(args) => {
send_message(&SocketMessage::Border(args.boolean_state.into()))?;
}
SubCommand::BorderColour(args) => {
send_message(&SocketMessage::BorderColour(
args.window_kind,
args.r,
args.g,
args.b,
))?;
}
SubCommand::BorderWidth(args) => {
send_message(&SocketMessage::BorderWidth(args.width))?;
}
SubCommand::BorderOffset(args) => {
send_message(&SocketMessage::BorderOffset(args.offset))?;
}
SubCommand::Transparency(args) => {
send_message(&SocketMessage::Transparency(args.boolean_state.into()))?;
}
SubCommand::TransparencyAlpha(args) => {
send_message(&SocketMessage::TransparencyAlpha(args.alpha))?;
}
SubCommand::ToggleTransparency => {
send_message(&SocketMessage::ToggleTransparency)?;
}
SubCommand::FocusFollowsMouse(args) => {
send_message(&SocketMessage::FocusFollowsMouse(
args.implementation,
args.boolean_state.into(),
))?;
}
SubCommand::ToggleFocusFollowsMouse(args) => {
send_message(&SocketMessage::ToggleFocusFollowsMouse(args.implementation))?;
}
SubCommand::Animation(args) => {
send_message(&SocketMessage::Animation(
args.boolean_state.into(),
args.animation_type,
))?;
}
SubCommand::AnimationDuration(args) => {
send_message(&SocketMessage::AnimationDuration(
args.duration,
args.animation_type,
))?;
}
SubCommand::AnimationFps(args) => {
send_message(&SocketMessage::AnimationFps(args.fps))?;
}
SubCommand::AnimationStyle(args) => {
send_message(&SocketMessage::AnimationStyle(
args.style,
args.animation_type,
))?;
}
}
Ok(())
}