feat(config): add static json loader and whkd flag

This commit is an implementation of a static JSON configuration loader.

An example komorebi.json configuration file has been added.

The application-specific configurations can be loaded directly from a
file, and workspace configuration can be defined declaratively in the
JSON. Individual rules etc. can also be added directly in the static
configuration as one-offs.

A JSONSchema can be generated using komorebic's static-config-schema
command. This should be added to something like SchemaStore later.

Loading from static configuration is significantly faster on startup, as
the lock does not have to be reacquired for every command that is sent
over the socket.

When loading configuration from a static JSON file, a hotwatch instance
will automatically be created to listen to file changes and apply any
updates to both the global and window manager configuration state.

A new --whkd flag has been added to the komorebic start command to
optionally start whkd in a background process.

A new komorebic command 'generate-static-config' has been added to help
existing users migrate to a static JSON config file. Currently, custom
layout file path information can not be automatically populated in the
output of this command and must be added manually by the user if
required.

A new komorebic command 'fetch-asc' has been added to help users update
to the latest version of the application-specific configurations
in-place.

resolve #427

komorebi/Cargo.toml

@@ -41,28 +41,9 @@ uds_windows = "1"
 which = "4"
 winput = "0.2"
 winreg = "0.50"
-windows-interface = { version = "0.48" }
-windows-implement = { version = "0.48" }
-[dependencies.windows]
-version = "0.48"
-features = [
-    "implement",
-    "Win32_System_Com",
-    "Win32_UI_Shell_Common", # for IObjectArray
-    "Win32_Foundation",
-    "Win32_Graphics_Dwm",
-    "Win32_Graphics_Gdi",
-    "Win32_System_LibraryLoader",
-    "Win32_System_RemoteDesktop",
-    "Win32_System_Threading",
-    "Win32_UI_Accessibility",
-    "Win32_UI_HiDpi",
-    "Win32_UI_Input_KeyboardAndMouse",
-    "Win32_UI_Shell",
-    "Win32_UI_Shell_Common",
-    "Win32_UI_WindowsAndMessaging",
-    "Win32_System_SystemServices"
-]
+windows-interface = { workspace = true }
+windows-implement = { workspace = true }
+windows = { workspace = true }
 
 [features]
 deadlock_detection = []

komorebi/src/main.rs

@@ -48,6 +48,7 @@ use crate::process_command::listen_for_commands;
 use crate::process_command::listen_for_commands_tcp;
 use crate::process_event::listen_for_events;
 use crate::process_movement::listen_for_movements;
+use crate::static_config::StaticConfig;
 use crate::window_manager::State;
 use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
@@ -65,6 +66,7 @@ mod process_command;
 mod process_event;
 mod process_movement;
 mod set_window_position;
+mod static_config;
 mod styles;
 mod window;
 mod window_manager;
@@ -75,6 +77,8 @@ mod winevent;
 mod winevent_listener;
 mod workspace;
 
+type WorkspaceRule = (usize, usize, bool);
+
 lazy_static! {
     static ref HIDDEN_HWNDS: Arc<Mutex<Vec<isize>>> = Arc::new(Mutex::new(vec![]));
     static ref LAYERED_WHITELIST: Arc<Mutex<Vec<String>>> =
@@ -94,7 +98,7 @@ lazy_static! {
     ]));
     static ref MONITOR_INDEX_PREFERENCES: Arc<Mutex<HashMap<usize, Rect>>> =
         Arc::new(Mutex::new(HashMap::new()));
-    static ref WORKSPACE_RULES: Arc<Mutex<HashMap<String, (usize, usize, bool)>>> =
+    static ref WORKSPACE_RULES: Arc<Mutex<HashMap<String, WorkspaceRule>>> =
         Arc::new(Mutex::new(HashMap::new()));
     static ref MANAGE_IDENTIFIERS: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
     static ref FLOAT_IDENTIFIERS: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![
@@ -160,6 +164,9 @@ lazy_static! {
     static ref NO_TITLEBAR: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
 }
 
+pub static DEFAULT_WORKSPACE_PADDING: AtomicI32 = AtomicI32::new(10);
+pub static DEFAULT_CONTAINER_PADDING: AtomicI32 = AtomicI32::new(10);
+
 pub static INITIAL_CONFIGURATION_LOADED: AtomicBool = AtomicBool::new(false);
 pub static CUSTOM_FFM: AtomicBool = AtomicBool::new(false);
 pub static SESSION_ID: AtomicU32 = AtomicU32::new(0);
@@ -411,81 +418,89 @@ struct Opts {
     /// Start a TCP server on the given port to allow the direct sending of SocketMessages
     #[clap(action, short, long)]
     tcp_port: Option<usize>,
+    /// Path to a static configuration JSON file
+    #[clap(action, short, long)]
+    config: Option<PathBuf>,
 }
 
 #[tracing::instrument]
-#[allow(clippy::nonminimal_bool)]
+#[allow(clippy::cognitive_complexity)]
 fn main() -> Result<()> {
     let opts: Opts = Opts::parse();
     CUSTOM_FFM.store(opts.focus_follows_mouse, Ordering::SeqCst);
 
-    let arg_count = std::env::args().count();
+    let process_id = WindowsApi::current_process_id();
+    WindowsApi::allow_set_foreground_window(process_id)?;
+    WindowsApi::set_process_dpi_awareness_context()?;
 
-    let has_valid_args = arg_count == 1
-        || (arg_count == 2
-            && (opts.await_configuration || opts.focus_follows_mouse || opts.tcp_port.is_some()))
-        || (arg_count == 3 && opts.await_configuration && opts.focus_follows_mouse)
-        || (arg_count == 3 && opts.tcp_port.is_some() && opts.focus_follows_mouse)
-        || (arg_count == 3 && opts.tcp_port.is_some() && opts.await_configuration)
-        || (arg_count == 4
-            && (opts.focus_follows_mouse && opts.await_configuration && opts.tcp_port.is_some()));
+    let session_id = WindowsApi::process_id_to_session_id()?;
+    SESSION_ID.store(session_id, Ordering::SeqCst);
 
-    if has_valid_args {
-        let process_id = WindowsApi::current_process_id();
-        WindowsApi::allow_set_foreground_window(process_id)?;
-        WindowsApi::set_process_dpi_awareness_context()?;
+    let mut system = sysinfo::System::new_all();
+    system.refresh_processes();
 
-        let session_id = WindowsApi::process_id_to_session_id()?;
-        SESSION_ID.store(session_id, Ordering::SeqCst);
+    let matched_procs: Vec<&Process> = system.processes_by_name("komorebi.exe").collect();
 
-        let mut system = sysinfo::System::new_all();
-        system.refresh_processes();
-
-        let matched_procs: Vec<&Process> = system.processes_by_name("komorebi.exe").collect();
-
-        if matched_procs.len() > 1 {
-            let mut len = matched_procs.len();
-            for proc in matched_procs {
-                if proc.root().ends_with("shims") {
-                    len -= 1;
-                }
-            }
-
-            if len > 1 {
-                tracing::error!("komorebi.exe is already running, please exit the existing process before starting a new one");
-                std::process::exit(1);
+    if matched_procs.len() > 1 {
+        let mut len = matched_procs.len();
+        for proc in matched_procs {
+            if proc.root().ends_with("shims") {
+                len -= 1;
             }
         }
 
-        // File logging worker guard has to have an assignment in the main fn to work
-        let (_guard, _color_guard) = setup()?;
+        if len > 1 {
+            tracing::error!("komorebi.exe is already running, please exit the existing process before starting a new one");
+            std::process::exit(1);
+        }
+    }
 
-        #[cfg(feature = "deadlock_detection")]
-        detect_deadlocks();
+    // File logging worker guard has to have an assignment in the main fn to work
+    let (_guard, _color_guard) = setup()?;
 
-        let (outgoing, incoming): (Sender<WindowManagerEvent>, Receiver<WindowManagerEvent>) =
-            crossbeam_channel::unbounded();
+    #[cfg(feature = "deadlock_detection")]
+    detect_deadlocks();
 
-        let winevent_listener = winevent_listener::new(Arc::new(Mutex::new(outgoing)));
-        winevent_listener.start();
+    let (outgoing, incoming): (Sender<WindowManagerEvent>, Receiver<WindowManagerEvent>) =
+        crossbeam_channel::unbounded();
 
-        Hidden::create("komorebi-hidden")?;
+    let winevent_listener = winevent_listener::new(Arc::new(Mutex::new(outgoing)));
+    winevent_listener.start();
 
-        let wm = Arc::new(Mutex::new(WindowManager::new(Arc::new(Mutex::new(
+    Hidden::create("komorebi-hidden")?;
+
+    let wm = if let Some(config) = &opts.config {
+        tracing::info!(
+            "creating window manager from static configuration file: {}",
+            config.as_os_str().to_str().unwrap()
+        );
+
+        Arc::new(Mutex::new(StaticConfig::preload(
+            config,
+            Arc::new(Mutex::new(incoming)),
+        )?))
+    } else {
+        Arc::new(Mutex::new(WindowManager::new(Arc::new(Mutex::new(
             incoming,
-        )))?));
+        )))?))
+    };
 
-        wm.lock().init()?;
-        listen_for_commands(wm.clone());
+    wm.lock().init()?;
+    if let Some(config) = &opts.config {
+        StaticConfig::postload(config, &wm)?;
+    }
 
-        if !opts.await_configuration && !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
-            INITIAL_CONFIGURATION_LOADED.store(true, Ordering::SeqCst);
-        };
+    listen_for_commands(wm.clone());
 
-        if let Some(port) = opts.tcp_port {
-            listen_for_commands_tcp(wm.clone(), port);
-        }
+    if !opts.await_configuration && !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
+        INITIAL_CONFIGURATION_LOADED.store(true, Ordering::SeqCst);
+    };
 
+    if let Some(port) = opts.tcp_port {
+        listen_for_commands_tcp(wm.clone(), port);
+    }
+
+    if opts.config.is_none() {
         std::thread::spawn(|| {
             load_configuration().expect("could not load configuration");
         });
@@ -496,36 +511,34 @@ fn main() -> Result<()> {
                 backoff.snooze();
             }
         }
-
-        wm.lock().retile_all(false)?;
-
-        listen_for_events(wm.clone());
-
-        if CUSTOM_FFM.load(Ordering::SeqCst) {
-            listen_for_movements(wm.clone());
-        }
-
-        let (ctrlc_sender, ctrlc_receiver) = crossbeam_channel::bounded(1);
-        ctrlc::set_handler(move || {
-            ctrlc_sender
-                .send(())
-                .expect("could not send signal on ctrl-c channel");
-        })?;
-
-        ctrlc_receiver
-            .recv()
-            .expect("could not receive signal on ctrl-c channel");
-
-        tracing::error!("received ctrl-c, restoring all hidden windows and terminating process");
-
-        wm.lock().restore_all_windows()?;
-
-        if WindowsApi::focus_follows_mouse()? {
-            WindowsApi::disable_focus_follows_mouse()?;
-        }
-
-        std::process::exit(130);
     }
 
-    Ok(())
+    wm.lock().retile_all(false)?;
+
+    listen_for_events(wm.clone());
+
+    if CUSTOM_FFM.load(Ordering::SeqCst) {
+        listen_for_movements(wm.clone());
+    }
+
+    let (ctrlc_sender, ctrlc_receiver) = crossbeam_channel::bounded(1);
+    ctrlc::set_handler(move || {
+        ctrlc_sender
+            .send(())
+            .expect("could not send signal on ctrl-c channel");
+    })?;
+
+    ctrlc_receiver
+        .recv()
+        .expect("could not receive signal on ctrl-c channel");
+
+    tracing::error!("received ctrl-c, restoring all hidden windows and terminating process");
+
+    wm.lock().restore_all_windows()?;
+
+    if WindowsApi::focus_follows_mouse()? {
+        WindowsApi::disable_focus_follows_mouse()?;
+    }
+
+    std::process::exit(130);
 }

komorebi/src/process_command.rs

@@ -36,6 +36,7 @@ use komorebi_core::WindowKind;
 use crate::border::Border;
 use crate::current_virtual_desktop;
 use crate::notify_subscribers;
+use crate::static_config::StaticConfig;
 use crate::window::Window;
 use crate::window_manager;
 use crate::window_manager::WindowManager;
@@ -684,6 +685,7 @@ impl WindowManager {
 
                 if let Layout::Custom(ref mut custom) = workspace.layout_mut() {
                     if matches!(axis, Axis::Horizontal) {
+                        #[allow(clippy::cast_precision_loss)]
                         let percentage = custom
                             .primary_width_percentage()
                             .unwrap_or(100.0 / (custom.len() as f32));
@@ -877,6 +879,9 @@ impl WindowManager {
             SocketMessage::ReloadConfiguration => {
                 Self::reload_configuration();
             }
+            SocketMessage::ReloadStaticConfiguration(ref pathbuf) => {
+                self.reload_static_configuration(pathbuf)?;
+            }
             SocketMessage::CompleteConfiguration => {
                 if !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
                     INITIAL_CONFIGURATION_LOADED.store(true, Ordering::SeqCst);
@@ -1108,6 +1113,25 @@ impl WindowManager {
                 let mut stream = UnixStream::connect(socket)?;
                 stream.write_all(schema.as_bytes())?;
             }
+            SocketMessage::StaticConfigSchema => {
+                let socket_message = schema_for!(StaticConfig);
+                let schema = serde_json::to_string_pretty(&socket_message)?;
+                let mut socket = DATA_DIR.clone();
+                socket.push("komorebic.sock");
+                let socket = socket.as_path();
+
+                let mut stream = UnixStream::connect(socket)?;
+                stream.write_all(schema.as_bytes())?;
+            }
+            SocketMessage::GenerateStaticConfig => {
+                let config = serde_json::to_string_pretty(&StaticConfig::from(&*self))?;
+                let mut socket = DATA_DIR.clone();
+                socket.push("komorebic.sock");
+                let socket = socket.as_path();
+
+                let mut stream = UnixStream::connect(socket)?;
+                stream.write_all(config.as_bytes())?;
+            }
             SocketMessage::RemoveTitleBar(_, ref id) => {
                 let mut identifiers = NO_TITLEBAR.lock();
                 if !identifiers.contains(id) {
@@ -1250,7 +1274,7 @@ impl WindowManager {
     }
 
     #[tracing::instrument(skip(self))]
-    fn handle_workspace_rules(
+    pub fn handle_workspace_rules(
         &mut self,
         id: &String,
         monitor_idx: usize,

komorebi/src/static_config.rs

@@ -0,0 +1,754 @@
+use crate::border::Border;
+use crate::current_virtual_desktop;
+use crate::monitor::Monitor;
+use crate::ring::Ring;
+use crate::window_manager::WindowManager;
+use crate::window_manager_event::WindowManagerEvent;
+use crate::workspace::Workspace;
+use crate::ALT_FOCUS_HACK;
+use crate::BORDER_COLOUR_CURRENT;
+use crate::BORDER_COLOUR_MONOCLE;
+use crate::BORDER_COLOUR_SINGLE;
+use crate::BORDER_COLOUR_STACK;
+use crate::BORDER_ENABLED;
+use crate::BORDER_HWND;
+use crate::BORDER_OFFSET;
+use crate::BORDER_OVERFLOW_IDENTIFIERS;
+use crate::BORDER_WIDTH;
+use crate::DATA_DIR;
+use crate::DEFAULT_CONTAINER_PADDING;
+use crate::DEFAULT_WORKSPACE_PADDING;
+use crate::FLOAT_IDENTIFIERS;
+use crate::HIDING_BEHAVIOUR;
+use crate::LAYERED_WHITELIST;
+use crate::MANAGE_IDENTIFIERS;
+use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
+use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
+use crate::WORKSPACE_RULES;
+use color_eyre::Result;
+use crossbeam_channel::Receiver;
+use dirs::home_dir;
+use hotwatch::notify::DebouncedEvent;
+use hotwatch::Hotwatch;
+use komorebi_core::config_generation::ApplicationConfigurationGenerator;
+use komorebi_core::config_generation::ApplicationOptions;
+use komorebi_core::config_generation::IdWithIdentifier;
+use komorebi_core::ApplicationIdentifier;
+use komorebi_core::DefaultLayout;
+use komorebi_core::FocusFollowsMouseImplementation;
+use komorebi_core::HidingBehaviour;
+use komorebi_core::Layout;
+use komorebi_core::MoveBehaviour;
+use komorebi_core::OperationBehaviour;
+use komorebi_core::Rect;
+use komorebi_core::SocketMessage;
+use komorebi_core::WindowContainerBehaviour;
+use parking_lot::Mutex;
+use schemars::JsonSchema;
+use serde::Deserialize;
+use serde::Serialize;
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::io::ErrorKind;
+use std::io::Write;
+use std::path::PathBuf;
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
+use uds_windows::UnixListener;
+use uds_windows::UnixStream;
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct Rgb {
+    /// Red
+    pub r: u32,
+    /// Green
+    pub g: u32,
+    /// Blue
+    pub b: u32,
+}
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct ActiveWindowBorderColours {
+    /// Border colour when the container contains a single window
+    pub single: Rgb,
+    /// Border colour when the container contains multiple windows
+    pub stack: Rgb,
+    /// Border colour when the container is in monocle mode
+    pub monocle: Rgb,
+}
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct WorkspaceConfig {
+    /// Name
+    pub name: String,
+    /// Layout (default: BSP)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub layout: Option<DefaultLayout>,
+    /// Custom Layout (default: None)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub custom_layout: Option<PathBuf>,
+    /// Layout rules (default: None)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub layout_rules: Option<HashMap<usize, DefaultLayout>>,
+    /// Layout rules (default: None)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub custom_layout_rules: Option<HashMap<usize, PathBuf>>,
+    /// Container padding (default: global)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub container_padding: Option<i32>,
+    /// Container padding (default: global)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub workspace_padding: Option<i32>,
+    /// Initial workspace application rules
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub initial_workspace_rules: Option<Vec<IdWithIdentifier>>,
+    /// Permanent workspace application rules
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub workspace_rules: Option<Vec<IdWithIdentifier>>,
+}
+
+impl From<&Workspace> for WorkspaceConfig {
+    fn from(value: &Workspace) -> Self {
+        let mut layout_rules = HashMap::new();
+        for (threshold, layout) in value.layout_rules() {
+            match layout {
+                Layout::Default(value) => {
+                    layout_rules.insert(*threshold, *value);
+                }
+                Layout::Custom(_) => {}
+            }
+        }
+
+        let workspace_rules = WORKSPACE_RULES.lock();
+        let mut initial_ws_rules = vec![];
+        let mut ws_rules = vec![];
+
+        for (identifier, (_, _, is_initial)) in &*workspace_rules {
+            if identifier.ends_with("exe") {
+                let rule = IdWithIdentifier {
+                    kind: ApplicationIdentifier::Exe,
+                    id: identifier.clone(),
+                };
+
+                if *is_initial {
+                    initial_ws_rules.push(rule);
+                } else {
+                    ws_rules.push(rule);
+                }
+            }
+        }
+
+        let initial_ws_rules = if initial_ws_rules.is_empty() {
+            None
+        } else {
+            Option::from(initial_ws_rules)
+        };
+        let ws_rules = if ws_rules.is_empty() {
+            None
+        } else {
+            Option::from(ws_rules)
+        };
+
+        let default_container_padding = DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst);
+        let default_workspace_padding = DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst);
+
+        let container_padding = value.container_padding().and_then(|container_padding| {
+            if container_padding == default_container_padding {
+                None
+            } else {
+                Option::from(container_padding)
+            }
+        });
+
+        let workspace_padding = value.workspace_padding().and_then(|workspace_padding| {
+            if workspace_padding == default_workspace_padding {
+                None
+            } else {
+                Option::from(workspace_padding)
+            }
+        });
+
+        Self {
+            name: value
+                .name()
+                .clone()
+                .unwrap_or_else(|| String::from("unnamed")),
+            layout: match value.layout() {
+                Layout::Default(layout) => Option::from(*layout),
+                // TODO: figure out how we might resolve file references in the future
+                Layout::Custom(_) => None,
+            },
+            custom_layout: None,
+            layout_rules: Option::from(layout_rules),
+            // TODO: figure out how we might resolve file references in the future
+            custom_layout_rules: None,
+            container_padding,
+            workspace_padding,
+            initial_workspace_rules: initial_ws_rules,
+            workspace_rules: ws_rules,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct MonitorConfig {
+    /// Workspace configurations
+    pub workspaces: Vec<WorkspaceConfig>,
+    /// Monitor-specific work area offset (default: None)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub work_area_offset: Option<Rect>,
+}
+
+impl From<&Monitor> for MonitorConfig {
+    fn from(value: &Monitor) -> Self {
+        let mut workspaces = vec![];
+        for w in value.workspaces() {
+            workspaces.push(WorkspaceConfig::from(w));
+        }
+
+        Self {
+            workspaces,
+            work_area_offset: value.work_area_offset(),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct StaticConfig {
+    /// Dimensions of Windows' own invisible borders; don't set these yourself unless you are told to
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub invisible_borders: Option<Rect>,
+    /// Delta to resize windows by (default 50)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub resize_delta: Option<i32>,
+    /// Determine what happens when a new window is opened (default: Create)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub window_container_behaviour: Option<WindowContainerBehaviour>,
+    /// Determine what happens when a window is moved across a monitor boundary (default: Swap)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cross_monitor_move_behaviour: Option<MoveBehaviour>,
+    /// Determine what happens when commands are sent while an unmanaged window is in the foreground (default: Op)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub unmanaged_window_operation_behaviour: Option<OperationBehaviour>,
+    /// Determine focus follows mouse implementation (default: None)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub focus_follows_mouse: Option<FocusFollowsMouseImplementation>,
+    /// Enable or disable mouse follows focus (default: true)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mouse_follows_focus: Option<bool>,
+    /// Path to applications.yaml from komorebi-application-specific-configurations (default: None)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub app_specific_configuration_path: Option<PathBuf>,
+    /// Width of the active window border (default: 20)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub border_width: Option<i32>,
+    /// Offset of the active window border (default: None)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub border_offset: Option<Rect>,
+    /// Display an active window border (default: false)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub active_window_border: Option<bool>,
+    /// Active window border colours for different container types
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub active_window_border_colours: Option<ActiveWindowBorderColours>,
+    /// Global default workspace padding (default: 10)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub default_workspace_padding: Option<i32>,
+    /// Global default container padding (default: 10)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub default_container_padding: Option<i32>,
+    /// Monitor and workspace configurations
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub monitors: Option<Vec<MonitorConfig>>,
+    /// Always send the ALT key when using focus commands (default: false)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub alt_focus_hack: Option<bool>,
+    /// Which Windows signal to use when hiding windows (default: minimize)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub window_hiding_behaviour: Option<HidingBehaviour>,
+    /// Global work area (space used for tiling) offset (default: None)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub global_work_area_offset: Option<Rect>,
+    /// Individual window floating rules
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub float_rules: Option<Vec<IdWithIdentifier>>,
+    /// Individual window force-manage rules
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub manage_rules: Option<Vec<IdWithIdentifier>>,
+    /// Identify border overflow applications
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub border_overflow_applications: Option<Vec<IdWithIdentifier>>,
+    /// Identify tray and multi-window applications
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tray_and_multi_window_applications: Option<Vec<IdWithIdentifier>>,
+    /// Identify applications that have the WS_EX_LAYERED extended window style
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub layered_applications: Option<Vec<IdWithIdentifier>>,
+    /// Identify applications that send EVENT_OBJECT_NAMECHANGE on launch (very rare)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub object_name_change_applications: Option<Vec<IdWithIdentifier>>,
+}
+
+impl From<&WindowManager> for StaticConfig {
+    fn from(value: &WindowManager) -> Self {
+        let default_invisible_borders = Rect {
+            left: 7,
+            top: 0,
+            right: 14,
+            bottom: 7,
+        };
+
+        let mut monitors = vec![];
+        for m in value.monitors() {
+            monitors.push(MonitorConfig::from(m));
+        }
+
+        let mut to_remove = vec![];
+
+        let workspace_rules = WORKSPACE_RULES.lock();
+        for (m_idx, m) in monitors.iter().enumerate() {
+            for (w_idx, w) in m.workspaces.iter().enumerate() {
+                if let Some(rules) = &w.initial_workspace_rules {
+                    for iwsr in rules {
+                        for (identifier, (monitor_idx, workspace_idx, _)) in &*workspace_rules {
+                            if iwsr.id.eq(identifier)
+                                && (*monitor_idx != m_idx || *workspace_idx != w_idx)
+                            {
+                                to_remove.push((m_idx, w_idx, iwsr.id.clone()));
+                            }
+                        }
+                    }
+                }
+
+                if let Some(rules) = &w.workspace_rules {
+                    for wsr in rules {
+                        for (identifier, (monitor_idx, workspace_idx, _)) in &*workspace_rules {
+                            if wsr.id.eq(identifier)
+                                && (*monitor_idx != m_idx || *workspace_idx != w_idx)
+                            {
+                                to_remove.push((m_idx, w_idx, wsr.id.clone()));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        for (m_idx, w_idx, id) in to_remove {
+            if let Some(monitor) = monitors.get_mut(m_idx) {
+                if let Some(workspace) = monitor.workspaces.get_mut(w_idx) {
+                    if let Some(rules) = &mut workspace.workspace_rules {
+                        rules.retain(|r| r.id != id);
+                    }
+
+                    if let Some(rules) = &mut workspace.initial_workspace_rules {
+                        rules.retain(|r| r.id != id);
+                    }
+                }
+            }
+        }
+
+        Self {
+            invisible_borders: if value.invisible_borders == default_invisible_borders {
+                None
+            } else {
+                Option::from(value.invisible_borders)
+            },
+            resize_delta: Option::from(value.resize_delta),
+            window_container_behaviour: Option::from(value.window_container_behaviour),
+            cross_monitor_move_behaviour: Option::from(value.cross_monitor_move_behaviour),
+            unmanaged_window_operation_behaviour: Option::from(
+                value.unmanaged_window_operation_behaviour,
+            ),
+            focus_follows_mouse: value.focus_follows_mouse,
+            mouse_follows_focus: Option::from(value.mouse_follows_focus),
+            app_specific_configuration_path: None,
+            border_width: Option::from(BORDER_WIDTH.load(Ordering::SeqCst)),
+            border_offset: *BORDER_OFFSET.lock(),
+            active_window_border: Option::from(BORDER_ENABLED.load(Ordering::SeqCst)),
+            active_window_border_colours: None,
+            default_workspace_padding: Option::from(
+                DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst),
+            ),
+            default_container_padding: Option::from(
+                DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst),
+            ),
+            monitors: Option::from(monitors),
+            alt_focus_hack: Option::from(ALT_FOCUS_HACK.load(Ordering::SeqCst)),
+            window_hiding_behaviour: Option::from(*HIDING_BEHAVIOUR.lock()),
+            global_work_area_offset: value.work_area_offset,
+            float_rules: None,
+            manage_rules: None,
+            border_overflow_applications: None,
+            tray_and_multi_window_applications: None,
+            layered_applications: None,
+            object_name_change_applications: None,
+        }
+    }
+}
+
+impl StaticConfig {
+    #[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
+    fn apply_globals(&self) -> Result<()> {
+        if let Some(behaviour) = self.window_hiding_behaviour {
+            let mut window_hiding_behaviour = HIDING_BEHAVIOUR.lock();
+            *window_hiding_behaviour = behaviour;
+        }
+
+        if let Some(hack) = self.alt_focus_hack {
+            ALT_FOCUS_HACK.store(hack, Ordering::SeqCst);
+        }
+
+        if let Some(container) = self.default_container_padding {
+            DEFAULT_CONTAINER_PADDING.store(container, Ordering::SeqCst);
+        }
+
+        if let Some(workspace) = self.default_workspace_padding {
+            DEFAULT_WORKSPACE_PADDING.store(workspace, Ordering::SeqCst);
+        }
+
+        if let Some(width) = self.border_width {
+            BORDER_WIDTH.store(width, Ordering::SeqCst);
+        }
+
+        if let Some(offset) = self.border_offset {
+            let mut border_offset = BORDER_OFFSET.lock();
+            *border_offset = Some(offset);
+        }
+
+        if let Some(colours) = &self.active_window_border_colours {
+            BORDER_COLOUR_SINGLE.store(
+                colours.single.r | (colours.single.g << 8) | (colours.single.b << 16),
+                Ordering::SeqCst,
+            );
+            BORDER_COLOUR_CURRENT.store(
+                colours.single.r | (colours.single.g << 8) | (colours.single.b << 16),
+                Ordering::SeqCst,
+            );
+            BORDER_COLOUR_STACK.store(
+                colours.stack.r | (colours.stack.g << 8) | (colours.stack.b << 16),
+                Ordering::SeqCst,
+            );
+            BORDER_COLOUR_MONOCLE.store(
+                colours.monocle.r | (colours.monocle.g << 8) | (colours.monocle.b << 16),
+                Ordering::SeqCst,
+            );
+        }
+
+        let mut float_identifiers = FLOAT_IDENTIFIERS.lock();
+        let mut manage_identifiers = MANAGE_IDENTIFIERS.lock();
+        let mut tray_and_multi_window_identifiers = TRAY_AND_MULTI_WINDOW_IDENTIFIERS.lock();
+        let mut border_overflow_identifiers = BORDER_OVERFLOW_IDENTIFIERS.lock();
+        let mut object_name_change_identifiers = OBJECT_NAME_CHANGE_ON_LAUNCH.lock();
+        let mut layered_identifiers = LAYERED_WHITELIST.lock();
+
+        if let Some(float) = &self.float_rules {
+            for identifier in float {
+                if !float_identifiers.contains(&identifier.id) {
+                    float_identifiers.push(identifier.id.clone());
+                }
+            }
+        }
+
+        if let Some(float) = &self.manage_rules {
+            for identifier in float {
+                if !manage_identifiers.contains(&identifier.id) {
+                    manage_identifiers.push(identifier.id.clone());
+                }
+            }
+        }
+
+        if let Some(identifiers) = &self.object_name_change_applications {
+            for identifier in identifiers {
+                if !object_name_change_identifiers.contains(&identifier.id) {
+                    object_name_change_identifiers.push(identifier.id.clone());
+                }
+            }
+        }
+
+        if let Some(identifiers) = &self.layered_applications {
+            for identifier in identifiers {
+                if !layered_identifiers.contains(&identifier.id) {
+                    layered_identifiers.push(identifier.id.clone());
+                }
+            }
+        }
+
+        if let Some(identifiers) = &self.border_overflow_applications {
+            for identifier in identifiers {
+                if !border_overflow_identifiers.contains(&identifier.id) {
+                    border_overflow_identifiers.push(identifier.id.clone());
+                }
+            }
+        }
+
+        if let Some(identifiers) = &self.tray_and_multi_window_applications {
+            for identifier in identifiers {
+                if !tray_and_multi_window_identifiers.contains(&identifier.id) {
+                    tray_and_multi_window_identifiers.push(identifier.id.clone());
+                }
+            }
+        }
+
+        if let Some(path) = &self.app_specific_configuration_path {
+            let stringified = path.to_string_lossy();
+            let stringified = stringified.replace(
+                "$Env:USERPROFILE",
+                &home_dir().expect("no home dir").to_string_lossy(),
+            );
+
+            let content = std::fs::read_to_string(stringified)?;
+            let asc = ApplicationConfigurationGenerator::load(&content)?;
+
+            for entry in asc {
+                if let Some(float) = entry.float_identifiers {
+                    for f in float {
+                        if !float_identifiers.contains(&f.id) {
+                            float_identifiers.push(f.id.clone());
+                        }
+                    }
+                }
+                if let Some(options) = entry.options {
+                    for o in options {
+                        match o {
+                            ApplicationOptions::ObjectNameChange => {
+                                if !object_name_change_identifiers.contains(&entry.identifier.id) {
+                                    object_name_change_identifiers
+                                        .push(entry.identifier.id.clone());
+                                }
+                            }
+                            ApplicationOptions::Layered => {
+                                if !layered_identifiers.contains(&entry.identifier.id) {
+                                    layered_identifiers.push(entry.identifier.id.clone());
+                                }
+                            }
+                            ApplicationOptions::BorderOverflow => {
+                                if !border_overflow_identifiers.contains(&entry.identifier.id) {
+                                    border_overflow_identifiers.push(entry.identifier.id.clone());
+                                }
+                            }
+                            ApplicationOptions::TrayAndMultiWindow => {
+                                if !tray_and_multi_window_identifiers.contains(&entry.identifier.id)
+                                {
+                                    tray_and_multi_window_identifiers
+                                        .push(entry.identifier.id.clone());
+                                }
+                            }
+                            ApplicationOptions::Force => {
+                                if !manage_identifiers.contains(&entry.identifier.id) {
+                                    manage_identifiers.push(entry.identifier.id.clone());
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_lines)]
+    pub fn preload(
+        path: &PathBuf,
+        incoming: Arc<Mutex<Receiver<WindowManagerEvent>>>,
+    ) -> Result<WindowManager> {
+        let content = std::fs::read_to_string(path)?;
+        let value: Self = serde_json::from_str(&content)?;
+        value.apply_globals()?;
+
+        let socket = DATA_DIR.join("komorebi.sock");
+
+        match std::fs::remove_file(&socket) {
+            Ok(_) => {}
+            Err(error) => match error.kind() {
+                // Doing this because ::exists() doesn't work reliably on Windows via IntelliJ
+                ErrorKind::NotFound => {}
+                _ => {
+                    return Err(error.into());
+                }
+            },
+        };
+
+        let listener = UnixListener::bind(&socket)?;
+
+        let mut wm = WindowManager {
+            monitors: Ring::default(),
+            monitor_cache: HashMap::new(),
+            incoming_events: incoming,
+            command_listener: listener,
+            is_paused: false,
+            invisible_borders: value.invisible_borders.unwrap_or(Rect {
+                left: 7,
+                top: 0,
+                right: 14,
+                bottom: 7,
+            }),
+            virtual_desktop_id: current_virtual_desktop(),
+            work_area_offset: value.global_work_area_offset,
+            window_container_behaviour: value
+                .window_container_behaviour
+                .unwrap_or(WindowContainerBehaviour::Create),
+            cross_monitor_move_behaviour: value
+                .cross_monitor_move_behaviour
+                .unwrap_or(MoveBehaviour::Swap),
+            unmanaged_window_operation_behaviour: value
+                .unmanaged_window_operation_behaviour
+                .unwrap_or(OperationBehaviour::Op),
+            resize_delta: value.resize_delta.unwrap_or(50),
+            focus_follows_mouse: value.focus_follows_mouse,
+            mouse_follows_focus: value.mouse_follows_focus.unwrap_or(true),
+            hotwatch: Hotwatch::new()?,
+            has_pending_raise_op: false,
+            pending_move_op: None,
+            already_moved_window_handles: Arc::new(Mutex::new(HashSet::new())),
+        };
+
+        let bytes = SocketMessage::ReloadStaticConfiguration(path.clone()).as_bytes()?;
+
+        wm.hotwatch.watch(path, move |event| match event {
+            // Editing in Notepad sends a NoticeWrite while editing in (Neo)Vim sends
+            // a NoticeRemove, presumably because of the use of swap files?
+            DebouncedEvent::NoticeWrite(_) | DebouncedEvent::NoticeRemove(_) => {
+                let socket = DATA_DIR.join("komorebi.sock");
+                let mut stream =
+                    UnixStream::connect(socket).expect("could not connect to komorebi.sock");
+                stream
+                    .write_all(&bytes)
+                    .expect("could not write to komorebi.sock");
+            }
+            _ => {}
+        })?;
+
+        Ok(wm)
+    }
+
+    pub fn postload(path: &PathBuf, wm: &Arc<Mutex<WindowManager>>) -> Result<()> {
+        let content = std::fs::read_to_string(path)?;
+        let value: Self = serde_json::from_str(&content)?;
+        let mut wm = wm.lock();
+
+        if let Some(monitors) = value.monitors {
+            for (i, monitor) in monitors.iter().enumerate() {
+                if let Some(m) = wm.monitors_mut().get_mut(i) {
+                    m.ensure_workspace_count(monitor.workspaces.len());
+                    m.set_work_area_offset(monitor.work_area_offset);
+
+                    for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
+                        ws.load_static_config(
+                            monitor
+                                .workspaces
+                                .get(j)
+                                .expect("no static workspace config"),
+                        )?;
+                    }
+                }
+
+                for (j, ws) in monitor.workspaces.iter().enumerate() {
+                    if let Some(rules) = &ws.workspace_rules {
+                        for r in rules {
+                            wm.handle_workspace_rules(&r.id, i, j, false)?;
+                        }
+                    }
+
+                    if let Some(rules) = &ws.initial_workspace_rules {
+                        for r in rules {
+                            wm.handle_workspace_rules(&r.id, i, j, true)?;
+                        }
+                    }
+                }
+            }
+        }
+
+        if value.active_window_border == Some(true) {
+            if BORDER_HWND.load(Ordering::SeqCst) == 0 {
+                Border::create("komorebi-border-window")?;
+            }
+
+            BORDER_ENABLED.store(true, Ordering::SeqCst);
+            wm.show_border()?;
+        }
+
+        Ok(())
+    }
+
+    pub fn reload(path: &PathBuf, wm: &mut WindowManager) -> Result<()> {
+        let content = std::fs::read_to_string(path)?;
+        let value: Self = serde_json::from_str(&content)?;
+
+        value.apply_globals()?;
+
+        if let Some(monitors) = value.monitors {
+            for (i, monitor) in monitors.iter().enumerate() {
+                if let Some(m) = wm.monitors_mut().get_mut(i) {
+                    m.ensure_workspace_count(monitor.workspaces.len());
+                    m.set_work_area_offset(monitor.work_area_offset);
+
+                    for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
+                        ws.load_static_config(
+                            monitor
+                                .workspaces
+                                .get(j)
+                                .expect("no static workspace config"),
+                        )?;
+                    }
+                }
+
+                for (j, ws) in monitor.workspaces.iter().enumerate() {
+                    if let Some(rules) = &ws.workspace_rules {
+                        for r in rules {
+                            wm.handle_workspace_rules(&r.id, i, j, false)?;
+                        }
+                    }
+
+                    if let Some(rules) = &ws.initial_workspace_rules {
+                        for r in rules {
+                            wm.handle_workspace_rules(&r.id, i, j, true)?;
+                        }
+                    }
+                }
+            }
+        }
+
+        if value.active_window_border == Some(true) {
+            if BORDER_HWND.load(Ordering::SeqCst) == 0 {
+                Border::create("komorebi-border-window")?;
+            }
+
+            BORDER_ENABLED.store(true, Ordering::SeqCst);
+            wm.show_border()?;
+        } else {
+            BORDER_ENABLED.store(false, Ordering::SeqCst);
+            wm.hide_border()?;
+        }
+
+        if let Some(val) = value.invisible_borders {
+            wm.invisible_borders = val;
+        }
+
+        if let Some(val) = value.window_container_behaviour {
+            wm.window_container_behaviour = val;
+        }
+
+        if let Some(val) = value.cross_monitor_move_behaviour {
+            wm.cross_monitor_move_behaviour = val;
+        }
+
+        if let Some(val) = value.unmanaged_window_operation_behaviour {
+            wm.unmanaged_window_operation_behaviour = val;
+        }
+
+        if let Some(val) = value.resize_delta {
+            wm.resize_delta = val;
+        }
+
+        if let Some(val) = value.mouse_follows_focus {
+            wm.mouse_follows_focus = val;
+        }
+
+        wm.work_area_offset = value.global_work_area_offset;
+        wm.focus_follows_mouse = value.focus_follows_mouse;
+
+        Ok(())
+    }
+}

komorebi/src/window_manager.rs

@@ -37,6 +37,7 @@ use crate::current_virtual_desktop;
 use crate::load_configuration;
 use crate::monitor::Monitor;
 use crate::ring::Ring;
+use crate::static_config::StaticConfig;
 use crate::window::Window;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
@@ -234,6 +235,12 @@ impl WindowManager {
         std::thread::spawn(|| load_configuration().expect("could not load configuration"));
     }
 
+    #[tracing::instrument(skip(self))]
+    pub fn reload_static_configuration(&mut self, pathbuf: &PathBuf) -> Result<()> {
+        tracing::info!("reloading static configuration");
+        StaticConfig::reload(pathbuf, self)
+    }
+
     #[tracing::instrument(skip(self))]
     pub fn watch_configuration(&mut self, enable: bool) -> Result<()> {
         let home = HOME_DIR.clone();

komorebi/src/workspace.rs

@@ -12,6 +12,7 @@ use schemars::JsonSchema;
 use serde::Serialize;
 
 use komorebi_core::Axis;
+use komorebi_core::CustomLayout;
 use komorebi_core::CycleDirection;
 use komorebi_core::DefaultLayout;
 use komorebi_core::Layout;
@@ -20,8 +21,11 @@ use komorebi_core::Rect;
 
 use crate::container::Container;
 use crate::ring::Ring;
+use crate::static_config::WorkspaceConfig;
 use crate::window::Window;
 use crate::windows_api::WindowsApi;
+use crate::DEFAULT_CONTAINER_PADDING;
+use crate::DEFAULT_WORKSPACE_PADDING;
 use crate::INITIAL_CONFIGURATION_LOADED;
 use crate::NO_TITLEBAR;
 use crate::REMOVE_TITLEBARS;
@@ -77,8 +81,8 @@ impl Default for Workspace {
             layout: Layout::Default(DefaultLayout::BSP),
             layout_rules: vec![],
             layout_flip: None,
-            workspace_padding: Option::from(10),
-            container_padding: Option::from(10),
+            workspace_padding: Option::from(DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst)),
+            container_padding: Option::from(DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst)),
             latest_layout: vec![],
             resize_dimensions: vec![],
             tile: true,
@@ -87,6 +91,46 @@ impl Default for Workspace {
 }
 
 impl Workspace {
+    pub fn load_static_config(&mut self, config: &WorkspaceConfig) -> Result<()> {
+        self.name = Option::from(config.name.clone());
+
+        if config.container_padding.is_some() {
+            self.set_container_padding(config.container_padding);
+        }
+
+        if config.workspace_padding.is_some() {
+            self.set_workspace_padding(config.workspace_padding);
+        }
+
+        if let Some(layout) = &config.layout {
+            self.layout = Layout::Default(*layout);
+        }
+
+        if let Some(pathbuf) = &config.custom_layout {
+            let layout = CustomLayout::from_path_buf(pathbuf.clone())?;
+            self.layout = Layout::Custom(layout);
+        }
+
+        if let Some(layout_rules) = &config.layout_rules {
+            let mut all_rules = vec![];
+            for (count, rule) in layout_rules {
+                all_rules.push((*count, Layout::Default(*rule)));
+            }
+
+            self.set_layout_rules(all_rules);
+        }
+
+        if let Some(layout_rules) = &config.custom_layout_rules {
+            let rules = self.layout_rules_mut();
+            for (count, pathbuf) in layout_rules {
+                let rule = CustomLayout::from_path_buf(pathbuf.clone())?;
+                rules.push((*count, Layout::Custom(rule)));
+            }
+        }
+
+        Ok(())
+    }
+
     pub fn hide(&mut self) {
         for container in self.containers_mut() {
             for window in container.windows_mut() {