docs(wm): border renames and aliases, ahk example

This commit renames a number of border-related code refs, removing the
ActiveWindow prefix since these borders are no longer just for the
active window.

Aliases have been added to preserve backwards compat for existing
configs.

An example AHK configuration file has been added to the Common Workflows
section of the docs site.

A link to the docs site has been added to the output of komorebic start.

A note has been added recommending that users disable system animations
for the best experience in the Getting Started guide.

komorebi/src/border_manager/border.rs

@@ -12,7 +12,7 @@ use crate::border_manager::Z_ORDER;
 use crate::WindowsApi;
 use crate::WINDOWS_11;
 
-use komorebi_core::ActiveWindowBorderStyle;
+use komorebi_core::BorderStyle;
 use komorebi_core::Rect;
 
 use std::sync::atomic::Ordering;
@@ -195,17 +195,17 @@ impl Border {
                         // wrong size.  In the future we should read the DWM properties
                         // of windows and attempt to match appropriately.
                         match *STYLE.lock() {
-                            ActiveWindowBorderStyle::System => {
+                            BorderStyle::System => {
                                 if *WINDOWS_11 {
                                     RoundRect(hdc, 0, 0, rect.right, rect.bottom, 20, 20);
                                 } else {
                                     Rectangle(hdc, 0, 0, rect.right, rect.bottom);
                                 }
                             }
-                            ActiveWindowBorderStyle::Rounded => {
+                            BorderStyle::Rounded => {
                                 RoundRect(hdc, 0, 0, rect.right, rect.bottom, 20, 20);
                             }
-                            ActiveWindowBorderStyle::Square => {
+                            BorderStyle::Square => {
                                 Rectangle(hdc, 0, 0, rect.right, rect.bottom);
                             }
                         }

komorebi/src/border_manager/mod.rs

@@ -5,7 +5,7 @@ mod border;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_utils::atomic::AtomicConsume;
-use komorebi_core::ActiveWindowBorderStyle;
+use komorebi_core::BorderStyle;
 use lazy_static::lazy_static;
 use parking_lot::Mutex;
 use schemars::JsonSchema;
@@ -39,8 +39,7 @@ pub static BORDER_ENABLED: AtomicBool = AtomicBool::new(true);
 
 lazy_static! {
     pub static ref Z_ORDER: Arc<Mutex<ZOrder>> = Arc::new(Mutex::new(ZOrder::Bottom));
-    pub static ref STYLE: Arc<Mutex<ActiveWindowBorderStyle>> =
-        Arc::new(Mutex::new(ActiveWindowBorderStyle::System));
+    pub static ref STYLE: Arc<Mutex<BorderStyle>> = Arc::new(Mutex::new(BorderStyle::System));
     pub static ref FOCUSED: AtomicU32 =
         AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(66, 165, 245))));
     pub static ref UNFOCUSED: AtomicU32 =

komorebi/src/process_command.rs

@@ -1205,10 +1205,10 @@ impl WindowManager {
             SocketMessage::UnmanagedWindowOperationBehaviour(behaviour) => {
                 self.unmanaged_window_operation_behaviour = behaviour;
             }
-            SocketMessage::ActiveWindowBorder(enable) => {
+            SocketMessage::Border(enable) => {
                 border_manager::BORDER_ENABLED.store(enable, Ordering::SeqCst);
             }
-            SocketMessage::ActiveWindowBorderColour(kind, r, g, b) => match kind {
+            SocketMessage::BorderColour(kind, r, g, b) => match kind {
                 WindowKind::Single => {
                     border_manager::FOCUSED.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
                 }
@@ -1222,9 +1222,9 @@ impl WindowManager {
                     border_manager::UNFOCUSED.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
                 }
             },
-            SocketMessage::ActiveWindowBorderStyle(style) => {
-                let mut active_window_border_style = STYLE.lock();
-                *active_window_border_style = style;
+            SocketMessage::BorderStyle(style) => {
+                let mut border_style = STYLE.lock();
+                *border_style = style;
             }
             SocketMessage::BorderWidth(width) => {
                 border_manager::BORDER_WIDTH.store(width, Ordering::SeqCst);

komorebi/src/static_config.rs

@@ -42,8 +42,8 @@ use komorebi_core::config_generation::IdWithIdentifier;
 use komorebi_core::config_generation::MatchingRule;
 use komorebi_core::config_generation::MatchingStrategy;
 use komorebi_core::resolve_home_path;
-use komorebi_core::ActiveWindowBorderStyle;
 use komorebi_core::ApplicationIdentifier;
+use komorebi_core::BorderStyle;
 use komorebi_core::DefaultLayout;
 use komorebi_core::FocusFollowsMouseImplementation;
 use komorebi_core::HidingBehaviour;
@@ -69,7 +69,7 @@ use uds_windows::UnixListener;
 use uds_windows::UnixStream;
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
-pub struct ActiveWindowBorderColours {
+pub struct BorderColours {
     /// Border colour when the container contains a single window
     pub single: Option<Colour>,
     /// Border colour when the container contains multiple windows
@@ -262,16 +262,19 @@ pub struct StaticConfig {
     pub border_offset: Option<i32>,
     /// Display an active window border (default: false)
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub active_window_border: Option<bool>,
+    #[serde(alias = "active_window_border")]
+    pub 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>,
+    #[serde(alias = "active_window_border_colours")]
+    pub border_colours: Option<BorderColours>,
     /// Active window border style (default: System)
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub active_window_border_style: Option<ActiveWindowBorderStyle>,
+    #[serde(alias = "active_window_border_style")]
+    pub border_style: Option<BorderStyle>,
     /// Active window border z-order (default: System)
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub active_window_border_z_order: Option<ZOrder>,
+    pub border_z_order: Option<ZOrder>,
     /// Global default workspace padding (default: 10)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub default_workspace_padding: Option<i32>,
@@ -394,7 +397,7 @@ impl From<&WindowManager> for StaticConfig {
         let border_colours = if border_manager::FOCUSED.load(Ordering::SeqCst) == 0 {
             None
         } else {
-            Option::from(ActiveWindowBorderColours {
+            Option::from(BorderColours {
                 single: Option::from(Colour::from(border_manager::FOCUSED.load(Ordering::SeqCst))),
                 stack: Option::from(Colour::from(border_manager::STACK.load(Ordering::SeqCst))),
                 monocle: Option::from(Colour::from(border_manager::MONOCLE.load(Ordering::SeqCst))),
@@ -417,12 +420,10 @@ impl From<&WindowManager> for StaticConfig {
             app_specific_configuration_path: None,
             border_width: Option::from(border_manager::BORDER_WIDTH.load(Ordering::SeqCst)),
             border_offset: Option::from(border_manager::BORDER_OFFSET.load(Ordering::SeqCst)),
-            active_window_border: Option::from(
-                border_manager::BORDER_ENABLED.load(Ordering::SeqCst),
-            ),
-            active_window_border_colours: border_colours,
-            active_window_border_style: Option::from(*STYLE.lock()),
-            active_window_border_z_order: Option::from(*Z_ORDER.lock()),
+            border: Option::from(border_manager::BORDER_ENABLED.load(Ordering::SeqCst)),
+            border_colours,
+            border_style: Option::from(*STYLE.lock()),
+            border_z_order: Option::from(*Z_ORDER.lock()),
             default_workspace_padding: Option::from(
                 DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst),
             ),
@@ -474,11 +475,11 @@ impl StaticConfig {
         border_manager::BORDER_WIDTH.store(self.border_width.unwrap_or(8), Ordering::SeqCst);
         border_manager::BORDER_OFFSET.store(self.border_offset.unwrap_or(-1), Ordering::SeqCst);
 
-        if let Some(enabled) = &self.active_window_border {
+        if let Some(enabled) = &self.border {
             border_manager::BORDER_ENABLED.store(*enabled, Ordering::SeqCst);
         }
 
-        if let Some(colours) = &self.active_window_border_colours {
+        if let Some(colours) = &self.border_colours {
             if let Some(single) = colours.single {
                 border_manager::FOCUSED.store(u32::from(single), Ordering::SeqCst);
             }
@@ -496,8 +497,8 @@ impl StaticConfig {
             }
         }
 
-        let active_window_border_style = self.active_window_border_style.unwrap_or_default();
-        *STYLE.lock() = active_window_border_style;
+        let border_style = self.border_style.unwrap_or_default();
+        *STYLE.lock() = border_style;
 
         let mut float_identifiers = FLOAT_IDENTIFIERS.lock();
         let mut regex_identifiers = REGEX_IDENTIFIERS.lock();
@@ -733,7 +734,7 @@ impl StaticConfig {
             }
         }
 
-        if value.active_window_border == Some(true) {
+        if value.border == Some(true) {
             border_manager::BORDER_ENABLED.store(true, Ordering::SeqCst);
         }
 
@@ -792,7 +793,7 @@ impl StaticConfig {
             }
         }
 
-        if let Some(enabled) = value.active_window_border {
+        if let Some(enabled) = value.border {
             border_manager::BORDER_ENABLED.store(enabled, Ordering::SeqCst);
         }
 

komorebi/src/window_manager.rs

@@ -24,9 +24,9 @@ use uds_windows::UnixListener;
 
 use komorebi_core::config_generation::MatchingRule;
 use komorebi_core::custom_layout::CustomLayout;
-use komorebi_core::ActiveWindowBorderStyle;
 use komorebi_core::Arrangement;
 use komorebi_core::Axis;
+use komorebi_core::BorderStyle;
 use komorebi_core::CycleDirection;
 use komorebi_core::DefaultLayout;
 use komorebi_core::FocusFollowsMouseImplementation;
@@ -52,7 +52,7 @@ use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::winevent_listener;
 use crate::workspace::Workspace;
-use crate::ActiveWindowBorderColours;
+use crate::BorderColours;
 use crate::Colour;
 use crate::Rgb;
 use crate::WorkspaceRule;
@@ -117,9 +117,9 @@ pub struct State {
 #[allow(clippy::struct_excessive_bools)]
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct GlobalState {
-    pub active_window_border_enabled: bool,
-    pub active_window_border_colours: ActiveWindowBorderColours,
-    pub active_window_border_style: ActiveWindowBorderStyle,
+    pub border_enabled: bool,
+    pub border_colours: BorderColours,
+    pub border_style: BorderStyle,
     pub border_offset: i32,
     pub border_width: i32,
     pub stackbar_mode: StackbarMode,
@@ -146,8 +146,8 @@ pub struct GlobalState {
 impl Default for GlobalState {
     fn default() -> Self {
         Self {
-            active_window_border_enabled: border_manager::BORDER_ENABLED.load(Ordering::SeqCst),
-            active_window_border_colours: ActiveWindowBorderColours {
+            border_enabled: border_manager::BORDER_ENABLED.load(Ordering::SeqCst),
+            border_colours: BorderColours {
                 single: Option::from(Colour::Rgb(Rgb::from(
                     border_manager::FOCUSED.load(Ordering::SeqCst),
                 ))),
@@ -161,7 +161,7 @@ impl Default for GlobalState {
                     border_manager::UNFOCUSED.load(Ordering::SeqCst),
                 ))),
             },
-            active_window_border_style: *STYLE.lock(),
+            border_style: *STYLE.lock(),
             border_offset: border_manager::BORDER_OFFSET.load(Ordering::SeqCst),
             border_width: border_manager::BORDER_WIDTH.load(Ordering::SeqCst),
             stackbar_mode: *STACKBAR_MODE.lock(),