chore(deps): bump starship-battery from 0.10.3 to 0.11.0

Bumps [starship-battery](https://github.com/starship/rust-battery) from 0.10.3 to 0.11.0.
- [Release notes](https://github.com/starship/rust-battery/releases)
- [Changelog](https://github.com/starship/rust-battery/blob/main/CHANGELOG.md)
- [Commits](https://github.com/starship/rust-battery/compare/v0.10.3...v0.11.0)

---
updated-dependencies:
- dependency-name: starship-battery
  dependency-version: 0.11.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

komorebi-bar/Cargo.toml

@@ -34,7 +34,7 @@ reqwest = { version = "0.12", features = ["blocking"] }
 schemars = { workspace = true, optional = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-starship-battery = "0.10"
+starship-battery = "0.11"
 sysinfo = { workspace = true }
 systray-util = "0.2.0"
 tokio = { version = "1", features = ["rt", "sync", "time"] }

komorebi-client/src/lib.rs

@@ -57,6 +57,7 @@ pub use komorebi::core::FloatingLayerBehaviour;
 pub use komorebi::core::FocusFollowsMouseImplementation;
 pub use komorebi::core::HidingBehaviour;
 pub use komorebi::core::Layout;
+pub use komorebi::core::MonocleFocusBehaviour;
 pub use komorebi::core::MoveBehaviour;
 pub use komorebi::core::OperationBehaviour;
 pub use komorebi::core::OperationDirection;

komorebi/Cargo.toml

@@ -24,7 +24,7 @@ ed25519-dalek = "2"
 hotwatch = { workspace = true }
 lazy_static = { workspace = true }
 miow = "0.6"
-nanoid = "0.4"
+nanoid = "0.5"
 net2 = "0.2"
 os_info = "3.10"
 parking_lot = { workspace = true }

komorebi/src/animation/mod.rs

@@ -60,7 +60,7 @@ pub const DEFAULT_ANIMATION_ENABLED: bool = false;
 pub const DEFAULT_ANIMATION_STYLE: AnimationStyle = AnimationStyle::Linear;
 pub const DEFAULT_ANIMATION_DURATION: u64 = 250;
 pub const DEFAULT_ANIMATION_FPS: u64 = 60;
-pub const DEFAULT_GHOST_MOVEMENT: bool = true;
+pub const DEFAULT_GHOST_MOVEMENT: bool = false;
 
 lazy_static! {
     pub static ref ANIMATION_MANAGER: Arc<Mutex<AnimationManager>> =

komorebi/src/core/mod.rs

@@ -113,6 +113,8 @@ pub enum SocketMessage {
     WindowHidingBehaviour(HidingBehaviour),
     ToggleCrossMonitorMoveBehaviour,
     CrossMonitorMoveBehaviour(MoveBehaviour),
+    ToggleMonocleFocusBehaviour,
+    MonocleFocusBehaviour(MonocleFocusBehaviour),
     UnmanagedWindowOperationBehaviour(OperationBehaviour),
     // Current Workspace Commands
     ManageFocusedWindow,
@@ -530,6 +532,19 @@ pub enum CrossBoundaryBehaviour {
     Monitor,
 }
 
+#[derive(
+    Clone, Copy, Debug, Default, Serialize, Deserialize, Display, EnumString, ValueEnum, PartialEq,
+)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+/// Behaviour when focusing in a direction while a monocle container is active
+pub enum MonocleFocusBehaviour {
+    /// Cycle the monocle container to the next/previous container in the workspace
+    Cycle,
+    /// Do nothing, allowing focus to fall through to cross-monitor logic
+    #[default]
+    NoOp,
+}
+
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, PartialEq)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 /// Window hiding behaviour

komorebi/src/process_command.rs

@@ -61,6 +61,7 @@ use crate::core::BorderImplementation;
 use crate::core::FocusFollowsMouseImplementation;
 use crate::core::Layout;
 use crate::core::LayoutOptions;
+use crate::core::MonocleFocusBehaviour;
 use crate::core::MoveBehaviour;
 use crate::core::OperationDirection;
 use crate::core::Rect;
@@ -2068,6 +2069,15 @@ if (!(Get-Process komorebi-bar -ErrorAction SilentlyContinue))
             SocketMessage::CrossMonitorMoveBehaviour(behaviour) => {
                 self.cross_monitor_move_behaviour = behaviour;
             }
+            SocketMessage::ToggleMonocleFocusBehaviour => {
+                self.monocle_focus_behaviour = match self.monocle_focus_behaviour {
+                    MonocleFocusBehaviour::Cycle => MonocleFocusBehaviour::NoOp,
+                    MonocleFocusBehaviour::NoOp => MonocleFocusBehaviour::Cycle,
+                };
+            }
+            SocketMessage::MonocleFocusBehaviour(behaviour) => {
+                self.monocle_focus_behaviour = behaviour;
+            }
             SocketMessage::UnmanagedWindowOperationBehaviour(behaviour) => {
                 self.unmanaged_window_operation_behaviour = behaviour;
             }

komorebi/src/process_event.rs

@@ -41,6 +41,30 @@ use crate::windows_api::WindowsApi;
 use crate::winevent::WinEvent;
 use crate::workspace::WorkspaceLayer;
 
+fn should_skip_focus_change(foreground_hwnd: Option<isize>, window_hwnd: isize) -> bool {
+    matches!(foreground_hwnd, Some(hwnd) if hwnd != window_hwnd)
+}
+
+#[cfg(test)]
+mod focus_change_tests {
+    use super::should_skip_focus_change;
+
+    #[test]
+    fn skips_focus_change_from_background_window() {
+        assert!(should_skip_focus_change(Some(1), 2));
+    }
+
+    #[test]
+    fn allows_focus_change_for_foreground_window() {
+        assert!(!should_skip_focus_change(Some(1), 1));
+    }
+
+    #[test]
+    fn allows_focus_change_when_foreground_unknown() {
+        assert!(!should_skip_focus_change(None, 1));
+    }
+}
+
 #[tracing::instrument]
 pub fn listen_for_events(wm: Arc<Mutex<WindowManager>>) {
     let receiver = wm.lock().incoming_events.clone();
@@ -341,6 +365,13 @@ impl WindowManager {
                 already_moved_window_handles.remove(&window.hwnd);
             }
             WindowManagerEvent::FocusChange(_, window) => {
+                if should_skip_focus_change(WindowsApi::foreground_window().ok(), window.hwnd) {
+                    tracing::debug!(
+                        "ignoring stale focus change for hwnd {} as it is not the foreground window",
+                        window.hwnd
+                    );
+                    return Ok(());
+                }
                 // don't want to trigger the full workspace updates when there are no managed
                 // containers - this makes floating windows on empty workspaces go into very
                 // annoying focus change loops which prevents users from interacting with them

komorebi/src/state.rs

@@ -13,6 +13,7 @@ use crate::IGNORE_IDENTIFIERS;
 use crate::LAYERED_WHITELIST;
 use crate::MANAGE_IDENTIFIERS;
 use crate::MONITOR_INDEX_PREFERENCES;
+use crate::MonocleFocusBehaviour;
 use crate::MoveBehaviour;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::OperationBehaviour;
@@ -61,6 +62,7 @@ pub struct State {
     pub new_window_behaviour: WindowContainerBehaviour,
     pub float_override: bool,
     pub cross_monitor_move_behaviour: MoveBehaviour,
+    pub monocle_focus_behaviour: MonocleFocusBehaviour,
     pub unmanaged_window_operation_behaviour: OperationBehaviour,
     pub work_area_offset: Option<Rect>,
     pub focus_follows_mouse: Option<FocusFollowsMouseImplementation>,
@@ -93,6 +95,10 @@ impl State {
             return true;
         }
 
+        if self.monocle_focus_behaviour != new.monocle_focus_behaviour {
+            return true;
+        }
+
         if self.unmanaged_window_operation_behaviour != new.unmanaged_window_operation_behaviour {
             return true;
         }
@@ -301,6 +307,7 @@ impl From<&WindowManager> for State {
             new_window_behaviour: wm.window_management_behaviour.current_behaviour,
             float_override: wm.window_management_behaviour.float_override,
             cross_monitor_move_behaviour: wm.cross_monitor_move_behaviour,
+            monocle_focus_behaviour: wm.monocle_focus_behaviour,
             focus_follows_mouse: wm.focus_follows_mouse,
             mouse_follows_focus: wm.mouse_follows_focus,
             has_pending_raise_op: wm.has_pending_raise_op,

komorebi/src/static_config.rs

@@ -58,6 +58,7 @@ use crate::core::HidingBehaviour;
 use crate::core::Layout;
 use crate::core::LayoutDefaultEntry;
 use crate::core::LayoutOptions;
+use crate::core::MonocleFocusBehaviour;
 use crate::core::MoveBehaviour;
 use crate::core::OperationBehaviour;
 use crate::core::Rect;
@@ -529,6 +530,10 @@ pub struct StaticConfig {
     #[serde(skip_serializing_if = "Option::is_none")]
     #[cfg_attr(feature = "schemars", schemars(extend("default" = CrossBoundaryBehaviour::Monitor)))]
     pub cross_boundary_behaviour: Option<CrossBoundaryBehaviour>,
+    /// Determine what happens when focusing in a direction while a monocle container is active
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[cfg_attr(feature = "schemars", schemars(extend("default" = MonocleFocusBehaviour::NoOp)))]
+    pub monocle_focus_behaviour: Option<MonocleFocusBehaviour>,
     /// Determine what happens when commands are sent while an unmanaged window is in the foreground
     #[serde(skip_serializing_if = "Option::is_none")]
     #[cfg_attr(feature = "schemars", schemars(extend("default" = OperationBehaviour::Op)))]
@@ -700,7 +705,7 @@ pub struct AnimationsConfig {
     /// Render movement animations on a GPU-composited ghost surface (recommended).
     /// When false, falls back to the legacy per-frame MoveWindow path.
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[cfg_attr(feature = "schemars", schemars(extend("default" = true)))]
+    #[cfg_attr(feature = "schemars", schemars(extend("default" = false)))]
     pub ghost_movement: Option<bool>,
 }
 
@@ -886,6 +891,7 @@ impl From<&WindowManager> for StaticConfig {
             ),
             cross_monitor_move_behaviour: Option::from(value.cross_monitor_move_behaviour),
             cross_boundary_behaviour: Option::from(value.cross_boundary_behaviour),
+            monocle_focus_behaviour: Option::from(value.monocle_focus_behaviour),
             unmanaged_window_operation_behaviour: Option::from(
                 value.unmanaged_window_operation_behaviour,
             ),
@@ -1348,6 +1354,7 @@ impl StaticConfig {
             cross_boundary_behaviour: value
                 .cross_boundary_behaviour
                 .unwrap_or(CrossBoundaryBehaviour::Monitor),
+            monocle_focus_behaviour: value.monocle_focus_behaviour.unwrap_or_default(),
             unmanaged_window_operation_behaviour: value
                 .unmanaged_window_operation_behaviour
                 .unwrap_or(OperationBehaviour::Op),
@@ -1749,6 +1756,7 @@ impl StaticConfig {
             value.float_rule_placement.unwrap_or(Placement::None);
         wm.cross_monitor_move_behaviour = value.cross_monitor_move_behaviour.unwrap_or_default();
         wm.cross_boundary_behaviour = value.cross_boundary_behaviour.unwrap_or_default();
+        wm.monocle_focus_behaviour = value.monocle_focus_behaviour.unwrap_or_default();
         wm.unmanaged_window_operation_behaviour = value
             .unmanaged_window_operation_behaviour
             .unwrap_or_default();

komorebi/src/window_manager.rs

@@ -33,6 +33,7 @@ use crate::core::CycleDirection;
 use crate::core::DefaultLayout;
 use crate::core::FocusFollowsMouseImplementation;
 use crate::core::Layout;
+use crate::core::MonocleFocusBehaviour;
 use crate::core::MoveBehaviour;
 use crate::core::OperationBehaviour;
 use crate::core::OperationDirection;
@@ -81,6 +82,7 @@ pub struct WindowManager {
     pub window_management_behaviour: WindowManagementBehaviour,
     pub cross_monitor_move_behaviour: MoveBehaviour,
     pub cross_boundary_behaviour: CrossBoundaryBehaviour,
+    pub monocle_focus_behaviour: MonocleFocusBehaviour,
     pub unmanaged_window_operation_behaviour: OperationBehaviour,
     pub focus_follows_mouse: Option<FocusFollowsMouseImplementation>,
     pub mouse_follows_focus: bool,
@@ -158,6 +160,7 @@ impl WindowManager {
             window_management_behaviour: WindowManagementBehaviour::default(),
             cross_monitor_move_behaviour: MoveBehaviour::Swap,
             cross_boundary_behaviour: CrossBoundaryBehaviour::Monitor,
+            monocle_focus_behaviour: MonocleFocusBehaviour::default(),
             unmanaged_window_operation_behaviour: OperationBehaviour::Op,
             resize_delta: 50,
             focus_follows_mouse: None,
@@ -2110,7 +2113,9 @@ impl WindowManager {
 
         tracing::info!("focusing container");
 
-        if workspace.monocle_container.is_some() {
+        if workspace.monocle_container.is_some()
+            && matches!(self.monocle_focus_behaviour, MonocleFocusBehaviour::Cycle)
+        {
             let cycle_direction = match direction {
                 OperationDirection::Left | OperationDirection::Down => CycleDirection::Previous,
                 OperationDirection::Right | OperationDirection::Up => CycleDirection::Next,
@@ -2118,11 +2123,12 @@ impl WindowManager {
             return self.cycle_monocle(cycle_direction);
         }
 
-        let new_idx = if workspace.maximized_window.is_some() {
+        let new_idx =
-            None
+            if workspace.maximized_window.is_some() || workspace.monocle_container.is_some() {
-        } else {
+                None
-            workspace.new_idx_for_direction(direction)
+            } else {
-        };
+                workspace.new_idx_for_direction(direction)
+            };
 
         let mut cross_monitor_monocle_or_max = false;
 

komorebic/src/main.rs

@@ -737,6 +737,13 @@ struct BorderStyle {
     style: komorebi_client::BorderStyle,
 }
 
+#[derive(Parser)]
+struct MonocleFocusBehaviour {
+    /// Desired monocle focus behaviour
+    #[clap(value_enum)]
+    behaviour: komorebi_client::MonocleFocusBehaviour,
+}
+
 #[derive(Parser)]
 struct BorderImplementation {
     /// Desired border implementation
@@ -1418,6 +1425,11 @@ enum SubCommand {
     CrossMonitorMoveBehaviour(CrossMonitorMoveBehaviour),
     /// Toggle the behaviour when moving windows across monitor boundaries
     ToggleCrossMonitorMoveBehaviour,
+    /// Set the behaviour when focusing in a direction while a monocle container is active
+    #[clap(arg_required_else_help = true)]
+    MonocleFocusBehaviour(MonocleFocusBehaviour),
+    /// Toggle the behaviour when focusing in a direction while a monocle container is active
+    ToggleMonocleFocusBehaviour,
     /// Set the operation behaviour when the focused window is not managed
     #[clap(arg_required_else_help = true)]
     UnmanagedWindowOperationBehaviour(UnmanagedWindowOperationBehaviour),
@@ -3251,6 +3263,12 @@ if (Get-Command Get-CimInstance -ErrorAction SilentlyContinue) {
         SubCommand::ToggleCrossMonitorMoveBehaviour => {
             send_message(&SocketMessage::ToggleCrossMonitorMoveBehaviour)?;
         }
+        SubCommand::MonocleFocusBehaviour(args) => {
+            send_message(&SocketMessage::MonocleFocusBehaviour(args.behaviour))?;
+        }
+        SubCommand::ToggleMonocleFocusBehaviour => {
+            send_message(&SocketMessage::ToggleMonocleFocusBehaviour)?;
+        }
         SubCommand::UnmanagedWindowOperationBehaviour(args) => {
             send_message(&SocketMessage::UnmanagedWindowOperationBehaviour(
                 args.operation_behaviour,