feat(wm): use monitor hardware ids where available

This commit pulls in changes to win32-display-data which provide the
monitor hardware serial number id taken from WmiMonitorID where
available.

No work has yet been done to integrate this with options such as
display_index_preferences.

Cargo.toml

@@ -19,7 +19,7 @@ crossbeam-utils = "0.8"
 color-eyre = "0.6"
 eframe = "0.30"
 egui_extras = "0.30"
-dirs = "6"
+dirs = "5"
 dunce = "1"
 hotwatch = "0.5"
 schemars = "0.8"
@@ -33,31 +33,27 @@ tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 paste = "1"
 sysinfo = "0.33"
 uds_windows = "1"
-win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data", rev = "376523b9e1321e033b0b0ed0e6fa75a072b46ad9" }
-windows-numerics = { version = "0.1" }
-windows-implement = { version = "0.59" }
-windows-interface = { version = "0.59" }
-windows-core = { version = "0.60" }
-shadow-rs = "0.38"
+win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data", rev = "75286e77c068a89d12adcd6404c9c4874a60acf5" }
+windows-implement = { version = "0.58" }
+windows-interface = { version = "0.58" }
+windows-core = { version = "0.58" }
+shadow-rs = "0.37"
 which = "7"
 
 [workspace.dependencies.windows]
-version = "0.60"
+version = "0.58"
 features = [
+    "implement",
     "Foundation_Numerics",
-    "Win32_Devices",
-    "Win32_Devices_Display",
     "Win32_System_Com",
     "Win32_UI_Shell_Common", # for IObjectArray
     "Win32_Foundation",
-    "Win32_Globalization",
     "Win32_Graphics_Dwm",
     "Win32_Graphics_Gdi",
     "Win32_Graphics_Direct2D",
     "Win32_Graphics_Direct2D_Common",
     "Win32_Graphics_Dxgi_Common",
     "Win32_System_LibraryLoader",
-    "Win32_System_Power",
     "Win32_System_RemoteDesktop",
     "Win32_System_Threading",
     "Win32_UI_Accessibility",

README.md

@@ -389,7 +389,7 @@ every `WindowManagerEvent` and `SocketMessage` handled by `komorebi` in a Rust c
 Below is a simple example of how to use `komorebi-client` in a basic Rust application.
 
 ```rust
-// komorebi-client = { git = "https://github.com/LGUG2Z/komorebi", tag = "v0.1.34"}
+// komorebi-client = { git = "https://github.com/LGUG2Z/komorebi", tag = "v0.1.33"}
 
 use anyhow::Result;
 use komorebi_client::Notification;

docs/cli/flip-layout.md

@@ -1,7 +1,7 @@
 # flip-layout
 
 ```
-Flip the layout on the focused workspace
+Flip the layout on the focused workspace (BSP only)
 
 Usage: komorebic.exe flip-layout <AXIS>
 

docs/cli/focus-monitor-at-cursor.md

@@ -1,12 +0,0 @@
-# focus-monitor-at-cursor
-
-```
-Focus the monitor at the current cursor location
-
-Usage: komorebic.exe focus-monitor-at-cursor
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/query.md

@@ -7,7 +7,7 @@ Usage: komorebic.exe query <STATE_QUERY>
 
 Arguments:
   <STATE_QUERY>
-          [possible values: focused-monitor-index, focused-workspace-index, focused-container-index, focused-window-index, focused-workspace-name]
+          [possible values: focused-monitor-index, focused-workspace-index, focused-container-index, focused-window-index]
 
 Options:
   -h, --help

docs/cli/toggle-window-based-work-area-offset.md

@@ -1,12 +0,0 @@
-# toggle-window-based-work-area-offset
-
-```
-Toggle application of the window-based work area offset for the focused workspace
-
-Usage: komorebic.exe toggle-window-based-work-area-offset
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/toggle-workspace-layer.md

@@ -1,12 +0,0 @@
-# toggle-workspace-layer
-
-```
-Toggle between the Tiling and Floating layers on the focused workspace
-
-Usage: komorebic.exe toggle-workspace-layer
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/example-configurations.md

@@ -75,7 +75,7 @@ solo developer.
 
 If you choose to use the active window border, you can set different colours to
 give you visual queues when you are focused on a single window, a stack of
-windows, or a window that is in monocle mode.
+windows, or a window that is in monocole mode.
 
 The example colours given are blue single, green for stack and pink for
 monocle.
@@ -254,5 +254,5 @@ stackbars as well as the status bar.
 If set in `komorebi.bar.json`, the theme will only be applied to the status bar.
 
 All [Catppuccin palette variants](https://catppuccin.com/)
-and [most Base16 palette variants](https://tinted-theming.github.io/tinted-gallery/)
+and [most Base16 palette variants](https://tinted-theming.github.io/base16-gallery/)
 are available as themes.

docs/komorebi.bar.example.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.34/schema.bar.json",
+  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.33/schema.bar.json",
   "monitor": 0,
   "font_family": "JetBrains Mono",
   "theme": {

docs/komorebi.example.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.34/schema.json",
+  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.33/schema.json",
   "app_specific_configuration_path": "$Env:USERPROFILE/applications.json",
   "window_hiding_behaviour": "Cloak",
   "cross_monitor_move_behaviour": "Insert",

justfile

@@ -24,15 +24,6 @@ install-target target:
 install:
     just install-targets komorebic komorebic-no-console komorebi komorebi-bar komorebi-gui
 
-build-targets *targets:
-    "{{ targets }}" -split ' ' | ForEach-Object { just build-target $_ }
-
-build-target target:
-    cargo +stable build --release --package {{ target }} --locked
-
-build:
-    just build-targets komorebic komorebic-no-console komorebi komorebi-bar komorebi-gui
-
 run target:
     cargo +stable run --bin {{ target }} --locked
 

komorebi-bar/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-bar"
-version = "0.1.35"
+version = "0.1.34"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -34,5 +34,4 @@ sysinfo = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 windows = { workspace = true }
-windows-core = { workspace = true }
 windows-icons = { git = "https://github.com/LGUG2Z/windows-icons", rev = "d67cc9920aa9b4883393e411fb4fa2ddd4c498b5" }

komorebi-bar/src/bar.rs

@@ -60,9 +60,8 @@ use std::sync::Arc;
 
 pub struct Komobar {
     pub hwnd: Option<isize>,
-    pub monitor_index: Option<usize>,
-    pub disabled: bool,
-    pub config: KomobarConfig,
+    pub monitor_index: usize,
+    pub config: Arc<KomobarConfig>,
     pub render_config: Rc<RefCell<RenderConfig>>,
     pub komorebi_notification_state: Option<Rc<RefCell<KomorebiNotificationState>>>,
     pub left_widgets: Vec<Box<dyn BarWidget>>,
@@ -195,45 +194,46 @@ impl Komobar {
     pub fn apply_config(
         &mut self,
         ctx: &Context,
+        config: &KomobarConfig,
         previous_notification_state: Option<Rc<RefCell<KomorebiNotificationState>>>,
     ) {
         MAX_LABEL_WIDTH.store(
-            self.config.max_label_width.unwrap_or(400.0) as i32,
+            config.max_label_width.unwrap_or(400.0) as i32,
             Ordering::SeqCst,
         );
 
-        if let Some(font_family) = &self.config.font_family {
+        if let Some(font_family) = &config.font_family {
             tracing::info!("attempting to add custom font family: {font_family}");
             Self::add_custom_font(ctx, font_family);
         }
 
         // Update the `size_rect` so that the bar position can be changed on the EGUI update
         // function
-        self.update_size_rect();
+        self.update_size_rect(config);
 
-        self.try_apply_theme(ctx);
+        self.try_apply_theme(config, ctx);
 
-        if let Some(font_size) = &self.config.font_size {
+        if let Some(font_size) = &config.font_size {
             tracing::info!("attempting to set custom font size: {font_size}");
             Self::set_font_size(ctx, *font_size);
         }
 
-        self.render_config.replace((&self.config).new_renderconfig(
+        self.render_config.replace(config.new_renderconfig(
             ctx,
             *self.bg_color.borrow(),
-            self.config.icon_scale,
+            config.icon_scale,
         ));
 
         let mut komorebi_notification_state = previous_notification_state;
         let mut komorebi_widgets = Vec::new();
 
-        for (idx, widget_config) in self.config.left_widgets.iter().enumerate() {
+        for (idx, widget_config) in config.left_widgets.iter().enumerate() {
             if let WidgetConfig::Komorebi(config) = widget_config {
                 komorebi_widgets.push((Komorebi::from(config), idx, Alignment::Left));
             }
         }
 
-        if let Some(center_widgets) = &self.config.center_widgets {
+        if let Some(center_widgets) = &config.center_widgets {
             for (idx, widget_config) in center_widgets.iter().enumerate() {
                 if let WidgetConfig::Komorebi(config) = widget_config {
                     komorebi_widgets.push((Komorebi::from(config), idx, Alignment::Center));
@@ -241,21 +241,20 @@ impl Komobar {
             }
         }
 
-        for (idx, widget_config) in self.config.right_widgets.iter().enumerate() {
+        for (idx, widget_config) in config.right_widgets.iter().enumerate() {
             if let WidgetConfig::Komorebi(config) = widget_config {
                 komorebi_widgets.push((Komorebi::from(config), idx, Alignment::Right));
             }
         }
 
-        let mut left_widgets = self
-            .config
+        let mut left_widgets = config
             .left_widgets
             .iter()
             .filter(|config| config.enabled())
             .map(|config| config.as_boxed_bar_widget())
             .collect::<Vec<Box<dyn BarWidget>>>();
 
-        let mut center_widgets = match &self.config.center_widgets {
+        let mut center_widgets = match &config.center_widgets {
             Some(center_widgets) => center_widgets
                 .iter()
                 .filter(|config| config.enabled())
@@ -264,8 +263,7 @@ impl Komobar {
             None => vec![],
         };
 
-        let mut right_widgets = self
-            .config
+        let mut right_widgets = config
             .right_widgets
             .iter()
             .filter(|config| config.enabled())
@@ -307,87 +305,79 @@ impl Komobar {
         self.center_widgets = center_widgets;
         self.right_widgets = right_widgets;
 
-        let (usr_monitor_index, config_work_area_offset) = match &self.config.monitor {
+        let (monitor_index, config_work_area_offset) = match &config.monitor {
             MonitorConfigOrIndex::MonitorConfig(monitor_config) => {
                 (monitor_config.index, monitor_config.work_area_offset)
             }
             MonitorConfigOrIndex::Index(idx) => (*idx, None),
         };
-        let monitor_index = self.komorebi_notification_state.as_ref().and_then(|state| {
-            state
-                .borrow()
-                .monitor_usr_idx_map
-                .get(&usr_monitor_index)
-                .copied()
-        });
-
         self.monitor_index = monitor_index;
 
-        if let Some(monitor_index) = self.monitor_index {
-            if let (prev_rect, Some(new_rect)) = (&self.work_area_offset, &config_work_area_offset)
-            {
-                if new_rect != prev_rect {
-                    self.work_area_offset = *new_rect;
-                    if let Err(error) = komorebi_client::send_message(
-                        &SocketMessage::MonitorWorkAreaOffset(monitor_index, *new_rect),
-                    ) {
-                        tracing::error!(
-                            "error applying work area offset to monitor '{}': {}",
-                            monitor_index,
-                            error,
-                        );
-                    } else {
-                        tracing::info!("work area offset applied to monitor: {}", monitor_index);
-                    }
-                }
-            } else if let Some(height) = self.config.height.or(Some(BAR_HEIGHT)) {
-                // We only add the `bottom_margin` to the work_area_offset since the top margin is
-                // already considered on the `size_rect.top`
-                let bottom_margin = self
-                    .config
-                    .margin
-                    .as_ref()
-                    .map_or(0, |v| v.to_individual(0.0).bottom as i32);
-                let new_rect = komorebi_client::Rect {
-                    left: 0,
-                    top: (height as i32)
-                        + (self.size_rect.top - MONITOR_TOP.load(Ordering::SeqCst))
-                        + bottom_margin,
-                    right: 0,
-                    bottom: (height as i32)
-                        + (self.size_rect.top - MONITOR_TOP.load(Ordering::SeqCst))
-                        + bottom_margin,
-                };
-
-                if new_rect != self.work_area_offset {
-                    self.work_area_offset = new_rect;
-                    if let Err(error) = komorebi_client::send_message(
-                        &SocketMessage::MonitorWorkAreaOffset(monitor_index, new_rect),
-                    ) {
-                        tracing::error!(
-                            "error applying work area offset to monitor '{}': {}",
-                            monitor_index,
-                            error,
-                        );
-                    }
+        if let (prev_rect, Some(new_rect)) = (&self.work_area_offset, &config_work_area_offset) {
+            if new_rect != prev_rect {
+                self.work_area_offset = *new_rect;
+                if let Err(error) = komorebi_client::send_message(
+                    &SocketMessage::MonitorWorkAreaOffset(self.monitor_index, *new_rect),
+                ) {
+                    tracing::error!(
+                        "error applying work area offset to monitor '{}': {}",
+                        self.monitor_index,
+                        error,
+                    );
+                } else {
+                    tracing::info!(
+                        "work area offset applied to monitor: {}",
+                        self.monitor_index
+                    );
+                }
+            }
+        } else if let Some(height) = config.height.or(Some(BAR_HEIGHT)) {
+            // We only add the `bottom_margin` to the work_area_offset since the top margin is
+            // already considered on the `size_rect.top`
+            let bottom_margin = config
+                .margin
+                .as_ref()
+                .map_or(0, |v| v.to_individual(0.0).bottom as i32);
+            let new_rect = komorebi_client::Rect {
+                left: 0,
+                top: (height as i32)
+                    + (self.size_rect.top - MONITOR_TOP.load(Ordering::SeqCst))
+                    + bottom_margin,
+                right: 0,
+                bottom: (height as i32)
+                    + (self.size_rect.top - MONITOR_TOP.load(Ordering::SeqCst))
+                    + bottom_margin,
+            };
+
+            if new_rect != self.work_area_offset {
+                self.work_area_offset = new_rect;
+                if let Err(error) = komorebi_client::send_message(
+                    &SocketMessage::MonitorWorkAreaOffset(self.monitor_index, new_rect),
+                ) {
+                    tracing::error!(
+                        "error applying work area offset to monitor '{}': {}",
+                        self.monitor_index,
+                        error,
+                    );
+                } else {
+                    tracing::info!(
+                        "work area offset applied to monitor: {}",
+                        self.monitor_index
+                    );
                 }
             }
-        } else if self.komorebi_notification_state.is_some() && !self.disabled {
-            tracing::warn!("couldn't find the monitor index of this bar! Disabling the bar until the monitor connects...");
-            self.disabled = true;
-        } else {
-            tracing::warn!("couldn't find the monitor index of this bar, if the bar is starting up this is normal until it receives the first state from komorebi.");
-            self.disabled = true;
         }
 
         tracing::info!("widget configuration options applied");
 
         self.komorebi_notification_state = komorebi_notification_state;
+
+        self.config = config.clone().into();
     }
 
     /// Updates the `size_rect` field. Returns a bool indicating if the field was changed or not
-    fn update_size_rect(&mut self) {
-        let position = self.config.position.clone().unwrap_or(PositionConfig {
+    fn update_size_rect(&mut self, config: &KomobarConfig) {
+        let position = config.position.clone().unwrap_or(PositionConfig {
             start: Some(Position {
                 x: MONITOR_LEFT.load(Ordering::SeqCst) as f32,
                 y: MONITOR_TOP.load(Ordering::SeqCst) as f32,
@@ -408,11 +398,11 @@ impl Komobar {
             y: BAR_HEIGHT,
         });
 
-        if let Some(height) = self.config.height {
+        if let Some(height) = config.height {
             end.y = height;
         }
 
-        let margin = get_individual_spacing(0.0, &self.config.margin);
+        let margin = get_individual_spacing(0.0, &config.margin);
 
         start.y += margin.top;
         start.x += margin.left;
@@ -430,16 +420,16 @@ impl Komobar {
         };
     }
 
-    fn try_apply_theme(&mut self, ctx: &Context) {
-        match self.config.theme {
+    fn try_apply_theme(&mut self, config: &KomobarConfig, ctx: &Context) {
+        match config.theme {
             Some(theme) => {
                 apply_theme(
                     ctx,
                     theme,
                     self.bg_color.clone(),
                     self.bg_color_with_alpha.clone(),
-                    self.config.transparency_alpha,
-                    self.config.grouping,
+                    config.transparency_alpha,
+                    config.grouping,
                     self.render_config.clone(),
                 );
             }
@@ -457,8 +447,8 @@ impl Komobar {
                     },
                 );
 
-                let bar_transparency_alpha = self.config.transparency_alpha;
-                let bar_grouping = self.config.grouping;
+                let bar_transparency_alpha = config.transparency_alpha;
+                let bar_grouping = config.grouping;
                 let config = home_dir.join("komorebi.json");
                 match komorebi_client::StaticConfig::read(&config) {
                     Ok(config) => {
@@ -520,13 +510,12 @@ impl Komobar {
         cc: &eframe::CreationContext<'_>,
         rx_gui: Receiver<KomorebiEvent>,
         rx_config: Receiver<KomobarConfig>,
-        config: KomobarConfig,
+        config: Arc<KomobarConfig>,
     ) -> Self {
         let mut komobar = Self {
             hwnd: process_hwnd(),
-            monitor_index: None,
-            disabled: false,
-            config,
+            monitor_index: 0,
+            config: config.clone(),
             render_config: Rc::new(RefCell::new(RenderConfig::new())),
             komorebi_notification_state: None,
             left_widgets: vec![],
@@ -542,9 +531,9 @@ impl Komobar {
             applied_theme_on_first_frame: false,
         };
 
-        komobar.apply_config(&cc.egui_ctx, None);
+        komobar.apply_config(&cc.egui_ctx, &config, None);
         // needs a double apply the first time for some reason
-        komobar.apply_config(&cc.egui_ctx, None);
+        komobar.apply_config(&cc.egui_ctx, &config, None);
 
         komobar
     }
@@ -582,7 +571,6 @@ impl Komobar {
 
         fallbacks.insert("Microsoft YaHei", "C:\\Windows\\Fonts\\msyh.ttc"); // chinese
         fallbacks.insert("Malgun Gothic", "C:\\Windows\\Fonts\\malgun.ttf"); // korean
-        fallbacks.insert("Leelawadee UI", "C:\\Windows\\Fonts\\LeelawUI.ttf"); // thai
 
         for (name, path) in fallbacks {
             if let Ok(bytes) = std::fs::read(path) {
@@ -619,32 +607,6 @@ impl Komobar {
         // Tell egui to use these fonts:
         ctx.set_fonts(fonts);
     }
-
-    pub fn position_bar(&self) {
-        if let Some(hwnd) = self.hwnd {
-            let window = komorebi_client::Window::from(hwnd);
-            if let Err(error) = window.set_position(&self.size_rect, false) {
-                tracing::error!("{}", error.to_string())
-            }
-        }
-    }
-
-    fn update_monitor_coordinates(&mut self, monitor_size: &komorebi_client::Rect) {
-        // Store the new monitor coordinates
-        MONITOR_TOP.store(monitor_size.top, Ordering::SeqCst);
-        MONITOR_LEFT.store(monitor_size.left, Ordering::SeqCst);
-        MONITOR_RIGHT.store(monitor_size.right, Ordering::SeqCst);
-
-        // Since the `config.position` is changed on `main.rs` we need to update it here.
-        // If the user had set up some `start` position, that will be overriden here
-        // since we have no way to know what was that value since it might have been
-        // changed on `main.rs`. However if the users use the new configs this won't be
-        // a problem for them.
-        if let Some(start) = self.config.position.as_mut().and_then(|p| p.start.as_mut()) {
-            start.x = monitor_size.left as f32;
-            start.y = monitor_size.top as f32;
-        }
-    }
 }
 impl eframe::App for Komobar {
     // Needed for transparency
@@ -659,12 +621,19 @@ impl eframe::App for Komobar {
 
         if self.scale_factor != ctx.native_pixels_per_point().unwrap_or(1.0) {
             self.scale_factor = ctx.native_pixels_per_point().unwrap_or(1.0);
-            self.apply_config(ctx, self.komorebi_notification_state.clone());
+            self.apply_config(
+                ctx,
+                &self.config.clone(),
+                self.komorebi_notification_state.clone(),
+            );
         }
 
         if let Ok(updated_config) = self.rx_config.try_recv() {
-            self.config = updated_config;
-            self.apply_config(ctx, self.komorebi_notification_state.clone());
+            self.apply_config(
+                ctx,
+                &updated_config,
+                self.komorebi_notification_state.clone(),
+            );
         }
 
         match self.rx_gui.try_recv() {
@@ -677,87 +646,32 @@ impl eframe::App for Komobar {
                 }
             },
             Ok(KomorebiEvent::Notification(notification)) => {
-                let state = &notification.state;
-                let usr_monitor_index = match &self.config.monitor {
-                    MonitorConfigOrIndex::MonitorConfig(monitor_config) => monitor_config.index,
-                    MonitorConfigOrIndex::Index(idx) => *idx,
-                };
-                let monitor_index = state.monitor_usr_idx_map.get(&usr_monitor_index).copied();
-                self.monitor_index = monitor_index;
-                let mut should_apply_config = false;
-
-                if self.monitor_index.is_none()
-                    || self
-                        .monitor_index
-                        .is_some_and(|idx| idx >= state.monitors.elements().len())
-                {
-                    if !self.disabled {
-                        // Monitor for this bar got disconnected lets disable the bar until it
-                        // reconnects
-                        self.disabled = true;
-                        tracing::warn!(
-                            "This bar's monitor got disconnected. The bar will be disabled until it reconnects..."
-                        );
-                    }
-                    return;
-                } else {
-                    if self.disabled {
-                        tracing::info!("Found this bar's monitor. The bar will be enabled!");
-
-                        // Restore the bar in case it has been minimized when the monitor
-                        // disconnected
-                        if let Some(hwnd) = self.hwnd {
-                            let window = komorebi_client::Window::from(hwnd);
-                            if window.is_miminized() {
-                                komorebi_client::WindowsApi::restore_window(hwnd);
-                            }
-                        }
-
-                        should_apply_config = true;
-                    }
-                    self.disabled = false;
-                }
-
-                if matches!(
+                let should_apply_config = if matches!(
                     notification.event,
                     NotificationEvent::Monitor(MonitorNotification::DisplayConnectionChange)
                 ) {
-                    let monitor_index = self.monitor_index.expect("should have a monitor index");
+                    let state = &notification.state;
 
-                    let monitor_size = state.monitors.elements()[monitor_index].size();
+                    // Store the monitor coordinates in case they've changed
+                    MONITOR_RIGHT.store(
+                        state.monitors.elements()[self.monitor_index].size().right,
+                        Ordering::SeqCst,
+                    );
 
-                    self.update_monitor_coordinates(monitor_size);
+                    MONITOR_TOP.store(
+                        state.monitors.elements()[self.monitor_index].size().top,
+                        Ordering::SeqCst,
+                    );
 
-                    should_apply_config = true;
-                }
+                    MONITOR_LEFT.store(
+                        state.monitors.elements()[self.monitor_index].size().left,
+                        Ordering::SeqCst,
+                    );
 
-                if self.disabled {
-                    return;
-                }
-
-                // Check if monitor coordinates/size has changed
-                if let Some(monitor_index) = self.monitor_index {
-                    let monitor_size = state.monitors.elements()[monitor_index].size();
-                    let top = MONITOR_TOP.load(Ordering::SeqCst);
-                    let left = MONITOR_LEFT.load(Ordering::SeqCst);
-                    let right = MONITOR_RIGHT.load(Ordering::SeqCst);
-                    let rect = komorebi_client::Rect {
-                        top,
-                        left,
-                        bottom: monitor_size.bottom,
-                        right,
-                    };
-                    if *monitor_size != rect {
-                        tracing::info!(
-                            "Monitor coordinates/size has changed, storing new coordinates: {:#?}",
-                            monitor_size
-                        );
-
-                        self.update_monitor_coordinates(monitor_size);
-
-                        should_apply_config = true;
-                    }
-                }
+                    true
+                } else {
+                    false
+                };
 
                 if let Some(komorebi_notification_state) = &self.komorebi_notification_state {
                     komorebi_notification_state
@@ -776,37 +690,36 @@ impl eframe::App for Komobar {
                 }
 
                 if should_apply_config {
-                    self.apply_config(ctx, self.komorebi_notification_state.clone());
-
-                    // Reposition the Bar
-                    self.position_bar();
+                    self.apply_config(
+                        ctx,
+                        &self.config.clone(),
+                        self.komorebi_notification_state.clone(),
+                    );
                 }
             }
             Ok(KomorebiEvent::Reconnect) => {
-                if let Some(monitor_index) = self.monitor_index {
-                    if let Err(error) = komorebi_client::send_message(
-                        &SocketMessage::MonitorWorkAreaOffset(monitor_index, self.work_area_offset),
-                    ) {
-                        tracing::error!(
-                            "error applying work area offset to monitor '{}': {}",
-                            monitor_index,
-                            error,
-                        );
-                    } else {
-                        tracing::info!("work area offset applied to monitor: {}", monitor_index);
-                    }
+                if let Err(error) =
+                    komorebi_client::send_message(&SocketMessage::MonitorWorkAreaOffset(
+                        self.monitor_index,
+                        self.work_area_offset,
+                    ))
+                {
+                    tracing::error!(
+                        "error applying work area offset to monitor '{}': {}",
+                        self.monitor_index,
+                        error,
+                    );
+                } else {
+                    tracing::info!(
+                        "work area offset applied to monitor: {}",
+                        self.monitor_index
+                    );
                 }
             }
         }
 
-        if self.disabled {
-            // The check for disabled is performed above, if we get here and the bar is still
-            // disabled then we should return without drawing anything.
-            return;
-        }
-
         if !self.applied_theme_on_first_frame {
-            self.try_apply_theme(ctx);
+            self.try_apply_theme(&self.config.clone(), ctx);
             self.applied_theme_on_first_frame = true;
         }
 
@@ -821,7 +734,17 @@ impl eframe::App for Komobar {
             };
 
             if self.size_rect != current_rect {
-                self.position_bar();
+                if let Some(hwnd) = self.hwnd {
+                    let window = komorebi_client::Window::from(hwnd);
+                    match window.set_position(&self.size_rect, false) {
+                        Ok(_) => {
+                            tracing::info!("updated bar position");
+                        }
+                        Err(error) => {
+                            tracing::error!("{}", error.to_string())
+                        }
+                    }
+                }
             }
         }
 

komorebi-bar/src/config.rs

@@ -13,7 +13,7 @@ use std::collections::HashMap;
 use std::path::PathBuf;
 
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-/// The `komorebi.bar.json` configuration file reference for `v0.1.35`
+/// The `komorebi.bar.json` configuration file reference for `v0.1.34`
 pub struct KomobarConfig {
     /// Bar height (default: 50)
     pub height: Option<f32>,
@@ -366,7 +366,7 @@ pub enum KomobarTheme {
     },
     /// A theme from base16-egui-themes
     Base16 {
-        /// Name of the Base16 theme (theme previews: https://tinted-theming.github.io/tinted-gallery/)
+        /// Name of the Base16 theme (theme previews: https://tinted-theming.github.io/base16-gallery)
         name: komorebi_themes::Base16,
         accent: Option<komorebi_themes::Base16Value>,
     },

komorebi-bar/src/keyboard.rs

@@ -1,177 +0,0 @@
-use crate::config::LabelPrefix;
-use crate::render::RenderConfig;
-use crate::widget::BarWidget;
-use eframe::egui::text::LayoutJob;
-use eframe::egui::Align;
-use eframe::egui::Context;
-use eframe::egui::Label;
-use eframe::egui::TextFormat;
-use eframe::egui::Ui;
-use eframe::egui::WidgetText;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-use std::time::Duration;
-use std::time::Instant;
-use windows::Win32::Globalization::LCIDToLocaleName;
-use windows::Win32::Globalization::LOCALE_ALLOW_NEUTRAL_NAMES;
-use windows::Win32::System::SystemServices::LOCALE_NAME_MAX_LENGTH;
-use windows::Win32::UI::Input::KeyboardAndMouse::GetKeyboardLayout;
-use windows::Win32::UI::WindowsAndMessaging::GetForegroundWindow;
-use windows::Win32::UI::WindowsAndMessaging::GetWindowThreadProcessId;
-
-const DEFAULT_DATA_REFRESH_INTERVAL: u64 = 1;
-const ERROR_TEXT: &str = "Error";
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct KeyboardConfig {
-    /// Enable the Input widget
-    pub enable: bool,
-    /// Data refresh interval (default: 1 second)
-    pub data_refresh_interval: Option<u64>,
-    /// Display label prefix
-    pub label_prefix: Option<LabelPrefix>,
-}
-
-impl From<KeyboardConfig> for Keyboard {
-    fn from(value: KeyboardConfig) -> Self {
-        let data_refresh_interval = value
-            .data_refresh_interval
-            .unwrap_or(DEFAULT_DATA_REFRESH_INTERVAL);
-
-        Self {
-            enable: value.enable,
-            data_refresh_interval,
-            label_prefix: value.label_prefix.unwrap_or(LabelPrefix::IconAndText),
-            last_updated: Instant::now(),
-            lang_name: get_lang(),
-        }
-    }
-}
-
-pub struct Keyboard {
-    pub enable: bool,
-    data_refresh_interval: u64,
-    label_prefix: LabelPrefix,
-    last_updated: Instant,
-    lang_name: String,
-}
-
-/// Retrieves the name of the active keyboard layout for the current foreground window.
-///
-/// This function determines the active keyboard layout by querying the system for the
-/// foreground window's thread ID and its associated keyboard layout. It then attempts
-/// to retrieve the locale name corresponding to the keyboard layout.
-///
-/// # Failure Cases
-///
-/// This function can fail in two distinct scenarios:
-///
-/// 1. **Failure to Retrieve the Locale Name**:
-///    If the system fails to retrieve the locale name (e.g., due to an invalid or unsupported
-///    language identifier), the function will return `Err(())`.
-///
-/// 2. **Invalid UTF-16 Characters in the Locale Name**:
-///    If the retrieved locale name contains invalid UTF-16 sequences, the conversion to a Rust
-///    `String` will fail, and the function will return `Err(())`.
-///
-/// # Returns
-///
-/// - `Ok(String)`: The name of the active keyboard layout as a valid UTF-8 string.
-/// - `Err(())`: Indicates that the function failed to retrieve the locale name or encountered
-///   invalid UTF-16 characters during conversion.
-fn get_active_keyboard_layout() -> Result<String, ()> {
-    let foreground_window_tid = unsafe { GetWindowThreadProcessId(GetForegroundWindow(), None) };
-    let lcid = unsafe { GetKeyboardLayout(foreground_window_tid) };
-
-    // Extract the low word (language identifier) from the keyboard layout handle.
-    let lang_id = (lcid.0 as u32) & 0xFFFF;
-    let mut locale_name_buffer = [0; LOCALE_NAME_MAX_LENGTH as usize];
-    let char_count = unsafe {
-        LCIDToLocaleName(
-            lang_id,
-            Some(&mut locale_name_buffer),
-            LOCALE_ALLOW_NEUTRAL_NAMES,
-        )
-    };
-
-    match char_count {
-        0 => Err(()),
-        _ => String::from_utf16(&locale_name_buffer[..char_count as usize]).map_err(|_| ()),
-    }
-}
-
-/// Retrieves the name of the active keyboard layout or a fallback error message.
-///
-/// # Behavior
-///
-/// - **Success Case**:
-///   If [`get_active_keyboard_layout`] succeeds, this function returns the retrieved keyboard
-///   layout name as a `String`.
-///
-/// - **Failure Case**:
-///   If [`get_active_keyboard_layout`] fails, this function returns the value of `ERROR_TEXT`
-///   as a fallback message. This ensures that the function always returns a valid `String`,
-///   even in error scenarios.
-///
-/// # Returns
-///
-/// A `String` representing either:
-/// - The name of the active keyboard layout, or
-/// - The fallback error message (`ERROR_TEXT`) if the layout name cannot be retrieved.
-fn get_lang() -> String {
-    get_active_keyboard_layout()
-        .map(|l| l.trim_end_matches('\0').to_string())
-        .unwrap_or_else(|_| ERROR_TEXT.to_string())
-}
-
-impl Keyboard {
-    fn output(&mut self) -> String {
-        let now = Instant::now();
-        if now.duration_since(self.last_updated) > Duration::from_secs(self.data_refresh_interval) {
-            self.last_updated = now;
-            self.lang_name = get_lang();
-        }
-
-        match self.label_prefix {
-            LabelPrefix::Text | LabelPrefix::IconAndText => format!("KB: {}", self.lang_name),
-            LabelPrefix::None | LabelPrefix::Icon => self.lang_name.clone(),
-        }
-    }
-}
-
-impl BarWidget for Keyboard {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui, config: &mut RenderConfig) {
-        if self.enable {
-            let output = self.output();
-            if !output.is_empty() {
-                let mut layout_job = LayoutJob::simple(
-                    match self.label_prefix {
-                        LabelPrefix::Icon | LabelPrefix::IconAndText => {
-                            egui_phosphor::regular::KEYBOARD.to_string()
-                        }
-                        LabelPrefix::None | LabelPrefix::Text => String::new(),
-                    },
-                    config.icon_font_id.clone(),
-                    ctx.style().visuals.selection.stroke.color,
-                    100.0,
-                );
-
-                layout_job.append(
-                    &output,
-                    10.0,
-                    TextFormat {
-                        font_id: config.text_font_id.clone(),
-                        color: ctx.style().visuals.text_color(),
-                        valign: Align::Center,
-                        ..Default::default()
-                    },
-                );
-
-                config.apply_on_widget(true, ui, |ui| {
-                    ui.add(Label::new(WidgetText::LayoutJob(layout_job.clone())).selectable(false))
-                });
-            }
-        }
-    }
-}

komorebi-bar/src/komorebi.rs

@@ -33,13 +33,11 @@ use komorebi_client::Rect;
 use komorebi_client::SocketMessage;
 use komorebi_client::Window;
 use komorebi_client::Workspace;
-use komorebi_client::WorkspaceLayer;
 use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::cell::RefCell;
 use std::collections::BTreeMap;
-use std::collections::HashMap;
 use std::path::PathBuf;
 use std::rc::Rc;
 use std::sync::atomic::Ordering;
@@ -50,8 +48,6 @@ pub struct KomorebiConfig {
     pub workspaces: Option<KomorebiWorkspacesConfig>,
     /// Configure the Layout widget
     pub layout: Option<KomorebiLayoutConfig>,
-    /// Configure the Workspace Layer widget
-    pub workspace_layer: Option<KomorebiWorkspaceLayerConfig>,
     /// Configure the Focused Window widget
     pub focused_window: Option<KomorebiFocusedWindowConfig>,
     /// Configure the Configuration Switcher widget
@@ -78,12 +74,6 @@ pub struct KomorebiLayoutConfig {
     pub display: Option<DisplayFormat>,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct KomorebiWorkspaceLayerConfig {
-    /// Enable the Komorebi Workspace Layer widget
-    pub enable: bool,
-}
-
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct KomorebiFocusedWindowConfig {
     /// Enable the Komorebi Focused Window widget
@@ -131,12 +121,10 @@ impl From<&KomorebiConfig> for Komorebi {
                 focused_container_information: KomorebiNotificationStateContainerInformation::EMPTY,
                 stack_accent: None,
                 monitor_index: MONITOR_INDEX.load(Ordering::SeqCst),
-                monitor_usr_idx_map: HashMap::new(),
             })),
             workspaces: value.workspaces,
             layout: value.layout.clone(),
             focused_window: value.focused_window,
-            workspace_layer: value.workspace_layer,
             configuration_switcher,
         }
     }
@@ -148,7 +136,6 @@ pub struct Komorebi {
     pub workspaces: Option<KomorebiWorkspacesConfig>,
     pub layout: Option<KomorebiLayoutConfig>,
     pub focused_window: Option<KomorebiFocusedWindowConfig>,
-    pub workspace_layer: Option<KomorebiWorkspaceLayerConfig>,
     pub configuration_switcher: Option<KomorebiConfigurationSwitcherConfig>,
 }
 
@@ -165,7 +152,7 @@ impl BarWidget for Komorebi {
                     let format = workspaces.display.unwrap_or(DisplayFormat::Text);
 
                     config.apply_on_widget(false, ui, |ui| {
-                        for (i, (ws, container_information, _)) in
+                        for (i, (ws, container_information)) in
                             komorebi_notification_state.workspaces.iter().enumerate()
                         {
                             if SelectableFrame::new(
@@ -292,42 +279,6 @@ impl BarWidget for Komorebi {
             }
         }
 
-        if let Some(layer_config) = &self.workspace_layer {
-            if layer_config.enable {
-                let layer = komorebi_notification_state
-                    .workspaces
-                    .iter()
-                    .find(|o| komorebi_notification_state.selected_workspace.eq(&o.0))
-                    .map(|(_, _, layer)| layer);
-
-                if let Some(layer) = layer {
-                    let name = layer.to_string();
-                    config.apply_on_widget(false, ui, |ui| {
-                        if SelectableFrame::new(false)
-                            .show(ui, |ui| ui.add(Label::new(name).selectable(false)))
-                            .clicked()
-                            && komorebi_client::send_batch([
-                                SocketMessage::MouseFollowsFocus(false),
-                                SocketMessage::ToggleWorkspaceLayer,
-                                SocketMessage::MouseFollowsFocus(
-                                    komorebi_notification_state.mouse_follows_focus,
-                                ),
-                            ])
-                            .is_err()
-                        {
-                            tracing::error!(
-                                "could not send the following batch of messages to komorebi:\n\
-                                            MouseFollowsFocus(false),
-                                            ToggleWorkspaceLayer,
-                                            MouseFollowsFocus({})",
-                                komorebi_notification_state.mouse_follows_focus,
-                            );
-                        }
-                    });
-                }
-            }
-        }
-
         if let Some(layout_config) = &self.layout {
             if layout_config.enable {
                 let workspace_idx: Option<usize> = komorebi_notification_state
@@ -523,11 +474,7 @@ fn img_to_texture(ctx: &Context, rgba_image: &RgbaImage) -> TextureHandle {
 
 #[derive(Clone, Debug)]
 pub struct KomorebiNotificationState {
-    pub workspaces: Vec<(
-        String,
-        KomorebiNotificationStateContainerInformation,
-        WorkspaceLayer,
-    )>,
+    pub workspaces: Vec<(String, KomorebiNotificationStateContainerInformation)>,
     pub selected_workspace: String,
     pub focused_container_information: KomorebiNotificationStateContainerInformation,
     pub layout: KomorebiLayout,
@@ -536,7 +483,6 @@ pub struct KomorebiNotificationState {
     pub work_area_offset: Option<Rect>,
     pub stack_accent: Option<Color32>,
     pub monitor_index: usize,
-    pub monitor_usr_idx_map: HashMap<usize, usize>,
 }
 
 impl KomorebiNotificationState {
@@ -548,7 +494,7 @@ impl KomorebiNotificationState {
     pub fn handle_notification(
         &mut self,
         ctx: &Context,
-        monitor_index: Option<usize>,
+        monitor_index: usize,
         notification: komorebi_client::Notification,
         bg_color: Rc<RefCell<Color32>>,
         bg_color_with_alpha: Rc<RefCell<Color32>>,
@@ -606,16 +552,6 @@ impl KomorebiNotificationState {
             },
         }
 
-        self.monitor_usr_idx_map = notification.state.monitor_usr_idx_map.clone();
-
-        if monitor_index.is_none()
-            || monitor_index.is_some_and(|idx| idx >= notification.state.monitors.elements().len())
-        {
-            // The bar's monitor is diconnected, so the bar is disabled no need to check anything
-            // any further otherwise we'll get `OutOfBounds` panics.
-            return;
-        }
-        let monitor_index = monitor_index.expect("should have a monitor index");
         self.monitor_index = monitor_index;
 
         self.mouse_follows_focus = notification.state.mouse_follows_focus;
@@ -634,7 +570,11 @@ impl KomorebiNotificationState {
 
         for (i, ws) in monitor.workspaces().iter().enumerate() {
             let should_show = if self.hide_empty_workspaces {
-                focused_workspace_idx == i || !ws.is_empty()
+                focused_workspace_idx == i
+                    || !ws.containers().is_empty()
+                    || !ws.floating_windows().is_empty()
+                    || ws.monocle_container().is_some()
+                    || ws.maximized_window().is_some()
             } else {
                 true
             };
@@ -643,7 +583,6 @@ impl KomorebiNotificationState {
                 workspaces.push((
                     ws.name().to_owned().unwrap_or_else(|| format!("{}", i + 1)),
                     ws.into(),
-                    ws.layer().to_owned(),
                 ));
             }
         }

komorebi-bar/src/main.rs

@@ -3,7 +3,6 @@ mod battery;
 mod config;
 mod cpu;
 mod date;
-mod keyboard;
 mod komorebi;
 mod komorebi_layout;
 mod media;
@@ -38,10 +37,12 @@ use std::path::PathBuf;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
 use std::sync::LazyLock;
 use std::sync::Mutex;
 use std::time::Duration;
 use tracing_subscriber::EnvFilter;
+use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
 use windows::Win32::System::Threading::GetCurrentProcessId;
@@ -50,7 +51,6 @@ use windows::Win32::UI::HiDpi::SetProcessDpiAwarenessContext;
 use windows::Win32::UI::HiDpi::DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2;
 use windows::Win32::UI::WindowsAndMessaging::EnumThreadWindows;
 use windows::Win32::UI::WindowsAndMessaging::GetWindowThreadProcessId;
-use windows_core::BOOL;
 
 pub static MAX_LABEL_WIDTH: AtomicI32 = AtomicI32::new(400);
 pub static MONITOR_LEFT: AtomicI32 = AtomicI32::new(0);
@@ -237,16 +237,12 @@ fn main() -> color_eyre::Result<()> {
         &SocketMessage::State,
     )?)?;
 
-    let (usr_monitor_index, work_area_offset) = match &config.monitor {
+    let (monitor_index, work_area_offset) = match &config.monitor {
         MonitorConfigOrIndex::MonitorConfig(monitor_config) => {
             (monitor_config.index, monitor_config.work_area_offset)
         }
         MonitorConfigOrIndex::Index(idx) => (*idx, None),
     };
-    let monitor_index = state
-        .monitor_usr_idx_map
-        .get(&usr_monitor_index)
-        .map_or(usr_monitor_index, |i| *i);
 
     MONITOR_RIGHT.store(
         state.monitors.elements()[monitor_index].size().right,
@@ -337,6 +333,7 @@ fn main() -> color_eyre::Result<()> {
 
     tracing::info!("watching configuration file for changes");
 
+    let config_arc = Arc::new(config);
     eframe::run_native(
         "komorebi-bar",
         native_options,
@@ -424,7 +421,7 @@ fn main() -> color_eyre::Result<()> {
                 }
             });
 
-            Ok(Box::new(Komobar::new(cc, rx_gui, rx_config, config)))
+            Ok(Box::new(Komobar::new(cc, rx_gui, rx_config, config_arc)))
         }),
     )
     .map_err(|error| color_eyre::eyre::Error::msg(error.to_string()))

komorebi-bar/src/network.rs

@@ -148,7 +148,7 @@ impl Network {
             LabelPrefix::None | LabelPrefix::Icon => match reading.format {
                 NetworkReadingFormat::Speed => (
                     format!(
-                        "{: >width$}/s ",
+                        "{: >width$}/s | ",
                         reading.received_text,
                         width = self.network_activity_fill_characters
                     ),
@@ -159,14 +159,14 @@ impl Network {
                     ),
                 ),
                 NetworkReadingFormat::Total => (
-                    format!("{} ", reading.received_text),
+                    format!("{} | ", reading.received_text),
                     reading.transmitted_text,
                 ),
             },
             LabelPrefix::Text | LabelPrefix::IconAndText => match reading.format {
                 NetworkReadingFormat::Speed => (
                     format!(
-                        "DOWN: {: >width$}/s ",
+                        "DOWN: {: >width$}/s | ",
                         reading.received_text,
                         width = self.network_activity_fill_characters
                     ),
@@ -177,7 +177,7 @@ impl Network {
                     ),
                 ),
                 NetworkReadingFormat::Total => (
-                    format!("\u{2211}DOWN: {}/s ", reading.received_text),
+                    format!("\u{2211}DOWN: {}/s | ", reading.received_text),
                     format!("\u{2211}UP: {}/s", reading.transmitted_text),
                 ),
             },

komorebi-bar/src/widget.rs

@@ -4,8 +4,6 @@ use crate::cpu::Cpu;
 use crate::cpu::CpuConfig;
 use crate::date::Date;
 use crate::date::DateConfig;
-use crate::keyboard::Keyboard;
-use crate::keyboard::KeyboardConfig;
 use crate::komorebi::Komorebi;
 use crate::komorebi::KomorebiConfig;
 use crate::media::Media;
@@ -36,7 +34,6 @@ pub enum WidgetConfig {
     Battery(BatteryConfig),
     Cpu(CpuConfig),
     Date(DateConfig),
-    Keyboard(KeyboardConfig),
     Komorebi(KomorebiConfig),
     Media(MediaConfig),
     Memory(MemoryConfig),
@@ -52,7 +49,6 @@ impl WidgetConfig {
             WidgetConfig::Battery(config) => Box::new(Battery::from(*config)),
             WidgetConfig::Cpu(config) => Box::new(Cpu::from(*config)),
             WidgetConfig::Date(config) => Box::new(Date::from(config.clone())),
-            WidgetConfig::Keyboard(config) => Box::new(Keyboard::from(*config)),
             WidgetConfig::Komorebi(config) => Box::new(Komorebi::from(config)),
             WidgetConfig::Media(config) => Box::new(Media::from(*config)),
             WidgetConfig::Memory(config) => Box::new(Memory::from(*config)),
@@ -68,7 +64,6 @@ impl WidgetConfig {
             WidgetConfig::Battery(config) => config.enable,
             WidgetConfig::Cpu(config) => config.enable,
             WidgetConfig::Date(config) => config.enable,
-            WidgetConfig::Keyboard(config) => config.enable,
             WidgetConfig::Komorebi(config) => {
                 config.workspaces.as_ref().is_some_and(|w| w.enable)
                     || config.layout.as_ref().is_some_and(|w| w.enable)

komorebi-client/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-client"
-version = "0.1.35"
+version = "0.1.34"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

komorebi-client/src/lib.rs

@@ -2,15 +2,10 @@
 #![allow(clippy::missing_errors_doc)]
 
 pub use komorebi::animation::prefix::AnimationPrefix;
-pub use komorebi::animation::PerAnimationPrefixConfig;
 pub use komorebi::asc::ApplicationSpecificConfiguration;
 pub use komorebi::colour::Colour;
 pub use komorebi::colour::Rgb;
 pub use komorebi::config_generation::ApplicationConfiguration;
-pub use komorebi::config_generation::IdWithIdentifier;
-pub use komorebi::config_generation::IdWithIdentifierAndComment;
-pub use komorebi::config_generation::MatchingRule;
-pub use komorebi::config_generation::MatchingStrategy;
 pub use komorebi::container::Container;
 pub use komorebi::core::config_generation::ApplicationConfigurationGenerator;
 pub use komorebi::core::resolve_home_path;
@@ -20,10 +15,6 @@ pub use komorebi::core::Arrangement;
 pub use komorebi::core::Axis;
 pub use komorebi::core::BorderImplementation;
 pub use komorebi::core::BorderStyle;
-pub use komorebi::core::Column;
-pub use komorebi::core::ColumnSplit;
-pub use komorebi::core::ColumnSplitWithCapacity;
-pub use komorebi::core::ColumnWidth;
 pub use komorebi::core::CustomLayout;
 pub use komorebi::core::CycleDirection;
 pub use komorebi::core::DefaultLayout;
@@ -48,26 +39,17 @@ pub use komorebi::ring::Ring;
 pub use komorebi::window::Window;
 pub use komorebi::window_manager_event::WindowManagerEvent;
 pub use komorebi::workspace::Workspace;
-pub use komorebi::workspace::WorkspaceLayer;
-pub use komorebi::AnimationsConfig;
-pub use komorebi::AspectRatio;
 pub use komorebi::BorderColours;
-pub use komorebi::CrossBoundaryBehaviour;
 pub use komorebi::GlobalState;
 pub use komorebi::KomorebiTheme;
-pub use komorebi::MonitorConfig;
 pub use komorebi::Notification;
 pub use komorebi::NotificationEvent;
-pub use komorebi::PredefinedAspectRatio;
 pub use komorebi::RuleDebug;
 pub use komorebi::StackbarConfig;
 pub use komorebi::State;
 pub use komorebi::StaticConfig;
 pub use komorebi::SubscribeOptions;
 pub use komorebi::TabsConfig;
-pub use komorebi::WindowContainerBehaviour;
-pub use komorebi::WindowsApi;
-pub use komorebi::WorkspaceConfig;
 
 use komorebi::DATA_DIR;
 

komorebi-gui/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-gui"
-version = "0.1.35"
+version = "0.1.34"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -10,7 +10,6 @@ komorebi-client = { path = "../komorebi-client" }
 
 eframe = { workspace = true }
 egui_extras = { workspace = true }
-random_word = { version = "0.4", features = ["en"] }
+random_word = { version = "0.4.3", features = ["en"] }
 serde_json = { workspace = true }
-windows-core = { workspace = true }
 windows = { workspace = true }

komorebi-gui/src/main.rs

@@ -215,7 +215,7 @@ impl KomorebiGui {
 extern "system" fn enum_window(
     hwnd: windows::Win32::Foundation::HWND,
     lparam: windows::Win32::Foundation::LPARAM,
-) -> windows_core::BOOL {
+) -> windows::Win32::Foundation::BOOL {
     let windows = unsafe { &mut *(lparam.0 as *mut Vec<Window>) };
     let window = Window::from(hwnd.0 as isize);
 

komorebi-themes/Cargo.toml

@@ -1,14 +1,14 @@
 [package]
 name = "komorebi-themes"
-version = "0.1.35"
+version = "0.1.34"
 edition = "2021"
 
 [dependencies]
-base16-egui-themes = { git = "https://github.com/LGUG2Z/base16-egui-themes", rev = "911079d" }
+base16-egui-themes = { git = "https://github.com/LGUG2Z/base16-egui-themes", rev = "24362c4" }
 catppuccin-egui = { git = "https://github.com/LGUG2Z/catppuccin-egui", rev = "f85cc3c", default-features = false, features = ["egui30"] }
 #catppuccin-egui = { version = "5", default-features = false, features = ["egui30"] }
 eframe = { workspace = true }
 schemars = { workspace = true }
 serde = { workspace = true }
 serde_variant = "0.1"
-strum = "0.26"
+strum = "0.26"

komorebi-themes/src/lib.rs

@@ -4,7 +4,6 @@
 use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
-use strum::Display;
 use strum::IntoEnumIterator;
 
 pub use base16_egui_themes::Base16;
@@ -12,7 +11,7 @@ pub use catppuccin_egui;
 pub use eframe::egui::Color32;
 use serde_variant::to_variant_name;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(tag = "type")]
 pub enum Theme {
     /// A theme from catppuccin-egui
@@ -49,7 +48,7 @@ impl Theme {
     }
 }
 
-#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema, Display, PartialEq)]
+#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
 pub enum Base16Value {
     Base00,
     Base01,
@@ -93,7 +92,7 @@ impl Base16Value {
     }
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, Display, PartialEq)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub enum Catppuccin {
     Frappe,
     Latte,
@@ -118,7 +117,7 @@ impl From<Catppuccin> for catppuccin_egui::Theme {
     }
 }
 
-#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema, Display, PartialEq)]
+#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
 pub enum CatppuccinValue {
     Rosewater,
     Flamingo,

komorebi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi"
-version = "0.1.35"
+version = "0.1.34"
 description = "A tiling window manager for Windows"
 repository = "https://github.com/LGUG2Z/komorebi"
 edition = "2021"
@@ -25,7 +25,7 @@ lazy_static = { workspace = true }
 miow = "0.6"
 nanoid = "0.4"
 net2 = "0.2"
-os_info = "3.10"
+os_info = "3.8"
 parking_lot = "0.12"
 paste = { workspace = true }
 regex = "1"
@@ -44,7 +44,6 @@ which = { workspace = true }
 win32-display-data = { workspace = true }
 windows = { workspace = true }
 windows-core = { workspace = true }
-windows-numerics = { workspace = true }
 windows-implement = { workspace = true }
 windows-interface = { workspace = true }
 winput = "0.2"

komorebi/src/animation/mod.rs

@@ -22,7 +22,7 @@ use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(untagged)]
 pub enum PerAnimationPrefixConfig<T> {
     Prefix(HashMap<AnimationPrefix, T>),

komorebi/src/border_manager/border.rs

@@ -1,5 +1,4 @@
 use crate::border_manager::window_kind_colour;
-use crate::border_manager::RenderTarget;
 use crate::border_manager::WindowKind;
 use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
@@ -18,6 +17,8 @@ use std::sync::atomic::Ordering;
 use std::sync::mpsc;
 use std::sync::LazyLock;
 use std::sync::OnceLock;
+use windows::Foundation::Numerics::Matrix3x2;
+use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::FALSE;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
@@ -31,6 +32,7 @@ use windows::Win32::Graphics::Direct2D::Common::D2D_RECT_F;
 use windows::Win32::Graphics::Direct2D::Common::D2D_SIZE_U;
 use windows::Win32::Graphics::Direct2D::D2D1CreateFactory;
 use windows::Win32::Graphics::Direct2D::ID2D1Factory;
+use windows::Win32::Graphics::Direct2D::ID2D1HwndRenderTarget;
 use windows::Win32::Graphics::Direct2D::ID2D1SolidColorBrush;
 use windows::Win32::Graphics::Direct2D::D2D1_ANTIALIAS_MODE_PER_PRIMITIVE;
 use windows::Win32::Graphics::Direct2D::D2D1_BRUSH_PROPERTIES;
@@ -66,29 +68,13 @@ use windows::Win32::UI::WindowsAndMessaging::WM_CREATE;
 use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
 use windows::Win32::UI::WindowsAndMessaging::WM_PAINT;
 use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
-use windows_core::BOOL;
 use windows_core::PCWSTR;
-use windows_numerics::Matrix3x2;
-
-pub struct RenderFactory(ID2D1Factory);
-unsafe impl Sync for RenderFactory {}
-unsafe impl Send for RenderFactory {}
-
-impl Deref for RenderFactory {
-    type Target = ID2D1Factory;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
 
 #[allow(clippy::expect_used)]
-static RENDER_FACTORY: LazyLock<RenderFactory> = unsafe {
+static RENDER_FACTORY: LazyLock<ID2D1Factory> = unsafe {
     LazyLock::new(|| {
-        RenderFactory(
-            D2D1CreateFactory::<ID2D1Factory>(D2D1_FACTORY_TYPE_MULTI_THREADED, None)
-                .expect("creating RENDER_FACTORY failed"),
-        )
+        D2D1CreateFactory::<ID2D1Factory>(D2D1_FACTORY_TYPE_MULTI_THREADED, None)
+            .expect("creating RENDER_FACTORY failed")
     })
 };
 
@@ -114,7 +100,7 @@ pub extern "system" fn border_hwnds(hwnd: HWND, lparam: LPARAM) -> BOOL {
 #[derive(Debug, Clone)]
 pub struct Border {
     pub hwnd: isize,
-    pub render_target: OnceLock<RenderTarget>,
+    pub render_target: OnceLock<ID2D1HwndRenderTarget>,
     pub tracking_hwnd: isize,
     pub window_rect: Rect,
     pub window_kind: WindowKind,
@@ -194,7 +180,7 @@ impl Border {
 
             loop {
                 unsafe {
-                    if !GetMessageW(&mut msg, None, 0, 0).as_bool() {
+                    if !GetMessageW(&mut msg, HWND::default(), 0, 0).as_bool() {
                         tracing::debug!("border window event processing thread shutdown");
                         break;
                     };
@@ -275,11 +261,7 @@ impl Border {
 
                 render_target.SetAntialiasMode(D2D1_ANTIALIAS_MODE_PER_PRIMITIVE);
 
-                if border
-                    .render_target
-                    .set(RenderTarget(render_target.clone()))
-                    .is_err()
-                {
+                if border.render_target.set(render_target.clone()).is_err() {
                     return Err(anyhow!("could not store border render target"));
                 }
 
@@ -293,7 +275,7 @@ impl Border {
                 };
 
                 let mut render_targets = RENDER_TARGETS.lock();
-                render_targets.insert(border.hwnd, RenderTarget(render_target));
+                render_targets.insert(border.hwnd, render_target);
                 Ok(border.clone())
             },
             Err(error) => Err(error.into()),
@@ -318,7 +300,7 @@ impl Border {
 
     // this triggers WM_PAINT in the callback below
     pub fn invalidate(&self) {
-        let _ = unsafe { InvalidateRect(Option::from(self.hwnd()), None, false) };
+        let _ = unsafe { InvalidateRect(self.hwnd(), None, false) };
     }
 
     pub extern "system" fn callback(
@@ -526,7 +508,7 @@ impl Border {
                             }
                         }
                     }
-                    let _ = ValidateRect(Option::from(window), None);
+                    let _ = ValidateRect(window, None);
                     LRESULT(0)
                 }
                 WM_DESTROY => {

komorebi/src/border_manager/mod.rs

@@ -23,14 +23,12 @@ use serde::Deserialize;
 use serde::Serialize;
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
-use std::ops::Deref;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicU32;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::sync::OnceLock;
-use strum::Display;
 use windows::Win32::Graphics::Direct2D::ID2D1HwndRenderTarget;
 
 pub static BORDER_WIDTH: AtomicI32 = AtomicI32::new(8);
@@ -58,19 +56,8 @@ lazy_static! {
     static ref BORDER_STATE: Mutex<HashMap<String, Border>> = Mutex::new(HashMap::new());
     static ref WINDOWS_BORDERS: Mutex<HashMap<isize, Border>> = Mutex::new(HashMap::new());
     static ref FOCUS_STATE: Mutex<HashMap<isize, WindowKind>> = Mutex::new(HashMap::new());
-    static ref RENDER_TARGETS: Mutex<HashMap<isize, RenderTarget>> = Mutex::new(HashMap::new());
-}
-
-#[derive(Debug, Clone)]
-pub struct RenderTarget(pub ID2D1HwndRenderTarget);
-unsafe impl Send for RenderTarget {}
-
-impl Deref for RenderTarget {
-    type Target = ID2D1HwndRenderTarget;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
+    static ref RENDER_TARGETS: Mutex<HashMap<isize, ID2D1HwndRenderTarget>> =
+        Mutex::new(HashMap::new());
 }
 
 pub struct Notification(pub Option<isize>);
@@ -224,16 +211,6 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 .unwrap_or_default()
                                 .set_accent(window_kind_colour(window_kind))?;
                         }
-
-                        for window in ws.floating_windows() {
-                            let mut window_kind = WindowKind::Unfocused;
-
-                            if foreground_window == window.hwnd {
-                                window_kind = WindowKind::Floating;
-                            }
-
-                            window.set_accent(window_kind_colour(window_kind))?;
-                        }
                     }
                 }
             }
@@ -274,7 +251,6 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         .map(|b| b.window_kind == WindowKind::Floating)
                         .unwrap_or_default())
                 });
-
                 if !should_process_notification && switch_focus_to_from_floating_window {
                     should_process_notification = true;
                 }
@@ -512,7 +488,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 Some(last_focus_state) => last_focus_state != new_focus_state,
                             };
 
-                            if new_border || should_invalidate {
+                            if new_border {
                                 border.set_position(&rect, reference_hwnd)?;
                             }
 
@@ -592,7 +568,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
     Ok(())
 }
 
-#[derive(Debug, Copy, Clone, Display, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
 pub enum ZOrder {
     Top,
     NoTopMost,

komorebi/src/colour.rs

@@ -8,7 +8,7 @@ use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
 #[serde(untagged)]
 pub enum Colour {
     /// Colour represented as RGB
@@ -51,7 +51,7 @@ impl From<Colour> for Color32 {
     }
 }
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
 pub struct Hex(HexColor);
 
 impl JsonSchema for Hex {
@@ -78,7 +78,7 @@ impl From<Colour> for u32 {
     }
 }
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
 pub struct Rgb {
     /// Red
     pub r: u32,
@@ -120,8 +120,8 @@ impl From<u32> for Rgb {
     fn from(value: u32) -> Self {
         Self {
             r: value & 0xff,
-            g: (value >> 8) & 0xff,
-            b: (value >> 16) & 0xff,
+            g: value >> 8 & 0xff,
+            b: value >> 16 & 0xff,
         }
     }
 }

komorebi/src/com/interfaces.rs

@@ -13,11 +13,11 @@ use windows::core::HRESULT;
 use windows::core::HSTRING;
 use windows::core::PCWSTR;
 use windows::core::PWSTR;
+use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::RECT;
 use windows::Win32::Foundation::SIZE;
 use windows::Win32::UI::Shell::Common::IObjectArray;
-use windows_core::BOOL;
 
 type DesktopID = GUID;
 

komorebi/src/core/animation.rs

@@ -6,16 +6,7 @@ use strum::Display;
 use strum::EnumString;
 
 #[derive(
-    Copy,
-    Clone,
-    Debug,
-    Serialize,
-    Deserialize,
-    Display,
-    EnumString,
-    ValueEnum,
-    JsonSchema,
-    PartialEq,
+    Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
 )]
 pub enum AnimationStyle {
     Linear,

komorebi/src/core/config_generation.rs

@@ -75,7 +75,7 @@ pub struct IdWithIdentifier {
     pub matching_strategy: Option<MatchingStrategy>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Display, JsonSchema)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub enum MatchingStrategy {
     Legacy,
     Equals,

komorebi/src/core/mod.rs

@@ -19,10 +19,6 @@ use crate::KomorebiTheme;
 pub use animation::AnimationStyle;
 pub use arrangement::Arrangement;
 pub use arrangement::Axis;
-pub use custom_layout::Column;
-pub use custom_layout::ColumnSplit;
-pub use custom_layout::ColumnSplitWithCapacity;
-pub use custom_layout::ColumnWidth;
 pub use custom_layout::CustomLayout;
 pub use cycle_direction::CycleDirection;
 pub use default_layout::DefaultLayout;
@@ -123,7 +119,6 @@ pub enum SocketMessage {
     CycleFocusMonitor(CycleDirection),
     CycleFocusWorkspace(CycleDirection),
     FocusMonitorNumber(usize),
-    FocusMonitorAtCursor,
     FocusLastWorkspace,
     CloseWorkspace,
     FocusWorkspaceNumber(usize),
@@ -149,7 +144,6 @@ pub enum SocketMessage {
     NamedWorkspaceLayoutCustomRule(String, usize, PathBuf),
     ClearWorkspaceLayoutRules(usize, usize),
     ClearNamedWorkspaceLayoutRules(String),
-    ToggleWorkspaceLayer,
     // Configuration
     ReloadConfiguration,
     ReplaceConfiguration(PathBuf),
@@ -186,7 +180,6 @@ pub enum SocketMessage {
     StackbarFontFamily(Option<String>),
     WorkAreaOffset(Rect),
     MonitorWorkAreaOffset(usize, Rect),
-    ToggleWindowBasedWorkAreaOffset,
     ResizeDelta(i32),
     InitialWorkspaceRule(ApplicationIdentifier, String, usize, usize),
     InitialNamedWorkspaceRule(ApplicationIdentifier, String, String),
@@ -438,16 +431,7 @@ pub enum MoveBehaviour {
 }
 
 #[derive(
-    Clone,
-    Copy,
-    Debug,
-    Serialize,
-    Deserialize,
-    Display,
-    EnumString,
-    ValueEnum,
-    JsonSchema,
-    PartialEq,
+    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
 )]
 pub enum CrossBoundaryBehaviour {
     /// Attempt to perform actions across a workspace boundary
@@ -457,16 +441,7 @@ pub enum CrossBoundaryBehaviour {
 }
 
 #[derive(
-    Copy,
-    Clone,
-    Debug,
-    Serialize,
-    Deserialize,
-    Display,
-    EnumString,
-    ValueEnum,
-    JsonSchema,
-    PartialEq,
+    Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
 )]
 pub enum HidingBehaviour {
     /// Use the SW_HIDE flag to hide windows when switching workspaces (has issues with Electron apps)

komorebi/src/lib.rs

@@ -182,7 +182,7 @@ lazy_static! {
     static ref TCP_CONNECTIONS: Arc<Mutex<HashMap<String, TcpStream>>> =
         Arc::new(Mutex::new(HashMap::new()));
     static ref HIDING_BEHAVIOUR: Arc<Mutex<HidingBehaviour>> =
-        Arc::new(Mutex::new(HidingBehaviour::Cloak));
+        Arc::new(Mutex::new(HidingBehaviour::Minimize));
     pub static ref HOME_DIR: PathBuf = {
         std::env::var("KOMOREBI_CONFIG_HOME").map_or_else(|_| dirs::home_dir().expect("there is no home directory"), |home_path| {
             let home = PathBuf::from(&home_path);

komorebi/src/main.rs

@@ -176,7 +176,7 @@ fn main() -> Result<()> {
     let session_id = WindowsApi::process_id_to_session_id()?;
     SESSION_ID.store(session_id, Ordering::SeqCst);
 
-    let mut system = sysinfo::System::new();
+    let mut system = sysinfo::System::new_all();
     system.refresh_processes(ProcessesToUpdate::All, true);
 
     let matched_procs: Vec<&Process> = system.processes_by_name("komorebi.exe".as_ref()).collect();
@@ -268,14 +268,8 @@ fn main() -> Result<()> {
     let dumped_state = temp_dir().join("komorebi.state.json");
 
     if !opts.clean_state && dumped_state.is_file() {
-        if let Ok(state) = serde_json::from_str(&std::fs::read_to_string(&dumped_state)?) {
-            wm.lock().apply_state(state);
-        } else {
-            tracing::warn!(
-                "cannot apply state from {}; state struct is not up to date",
-                dumped_state.display()
-            );
-        }
+        let state: State = serde_json::from_str(&std::fs::read_to_string(&dumped_state)?)?;
+        wm.lock().apply_state(state);
     }
 
     wm.lock().retile_all(false)?;
@@ -291,7 +285,7 @@ fn main() -> Result<()> {
     transparency_manager::listen_for_notifications(wm.clone());
     workspace_reconciliator::listen_for_notifications(wm.clone());
     monitor_reconciliator::listen_for_notifications(wm.clone())?;
-    reaper::listen_for_notifications(wm.clone());
+    reaper::watch_for_orphans(wm.clone());
     focus_manager::listen_for_notifications(wm.clone());
     theme_manager::listen_for_notifications();
 

komorebi/src/monitor.rs

@@ -36,31 +36,31 @@ use crate::WindowsApi;
 )]
 pub struct Monitor {
     #[getset(get_copy = "pub", set = "pub")]
-    pub id: isize,
+    id: isize,
     #[getset(get = "pub", set = "pub")]
-    pub name: String,
+    name: String,
     #[getset(get = "pub", set = "pub")]
-    pub device: String,
+    device: String,
     #[getset(get = "pub", set = "pub")]
-    pub device_id: String,
+    device_id: String,
     #[getset(get = "pub", set = "pub")]
-    pub serial_number_id: Option<String>,
+    serial_number_id: Option<String>,
     #[getset(get = "pub", set = "pub")]
-    pub size: Rect,
+    size: Rect,
     #[getset(get = "pub", set = "pub")]
-    pub work_area_size: Rect,
+    work_area_size: Rect,
     #[getset(get_copy = "pub", set = "pub")]
-    pub work_area_offset: Option<Rect>,
+    work_area_offset: Option<Rect>,
     #[getset(get_copy = "pub", set = "pub")]
-    pub window_based_work_area_offset: Option<Rect>,
+    window_based_work_area_offset: Option<Rect>,
     #[getset(get_copy = "pub", set = "pub")]
-    pub window_based_work_area_offset_limit: isize,
-    pub workspaces: Ring<Workspace>,
+    window_based_work_area_offset_limit: isize,
+    workspaces: Ring<Workspace>,
     #[serde(skip_serializing_if = "Option::is_none")]
     #[getset(get_copy = "pub", set = "pub")]
-    pub last_focused_workspace: Option<usize>,
+    last_focused_workspace: Option<usize>,
     #[getset(get_mut = "pub")]
-    pub workspace_names: HashMap<usize, String>,
+    workspace_names: HashMap<usize, String>,
 }
 
 impl_ring_elements!(Monitor, Workspace);
@@ -118,26 +118,6 @@ pub fn new(
 }
 
 impl Monitor {
-    pub fn new(
-        id: isize,
-        size: Rect,
-        work_area_size: Rect,
-        name: String,
-        device: String,
-        device_id: String,
-        serial_number_id: Option<String>,
-    ) -> Self {
-        new(
-            id,
-            size,
-            work_area_size,
-            name,
-            device,
-            device_id,
-            serial_number_id,
-        )
-    }
-
     pub fn placeholder() -> Self {
         Self {
             id: 0,

komorebi/src/monitor_reconciliator/hidden.rs

@@ -2,33 +2,21 @@ use std::sync::mpsc;
 use std::time::Duration;
 
 use windows::core::PCWSTR;
-use windows::Win32::Devices::Display::GUID_DEVINTERFACE_DISPLAY_ADAPTER;
-use windows::Win32::Devices::Display::GUID_DEVINTERFACE_MONITOR;
-use windows::Win32::Devices::Display::GUID_DEVINTERFACE_VIDEO_OUTPUT_ARRIVAL;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
 use windows::Win32::Foundation::LRESULT;
 use windows::Win32::Foundation::WPARAM;
-use windows::Win32::System::Power::POWERBROADCAST_SETTING;
-use windows::Win32::System::SystemServices::GUID_LIDSWITCH_STATE_CHANGE;
 use windows::Win32::UI::WindowsAndMessaging::DefWindowProcW;
 use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
 use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
 use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
 use windows::Win32::UI::WindowsAndMessaging::CS_HREDRAW;
 use windows::Win32::UI::WindowsAndMessaging::CS_VREDRAW;
-use windows::Win32::UI::WindowsAndMessaging::DBT_CONFIGCHANGED;
-use windows::Win32::UI::WindowsAndMessaging::DBT_DEVICEARRIVAL;
-use windows::Win32::UI::WindowsAndMessaging::DBT_DEVICEREMOVECOMPLETE;
 use windows::Win32::UI::WindowsAndMessaging::DBT_DEVNODES_CHANGED;
-use windows::Win32::UI::WindowsAndMessaging::DBT_DEVTYP_DEVICEINTERFACE;
-use windows::Win32::UI::WindowsAndMessaging::DEV_BROADCAST_DEVICEINTERFACE_W;
 use windows::Win32::UI::WindowsAndMessaging::MSG;
 use windows::Win32::UI::WindowsAndMessaging::PBT_APMRESUMEAUTOMATIC;
 use windows::Win32::UI::WindowsAndMessaging::PBT_APMRESUMESUSPEND;
 use windows::Win32::UI::WindowsAndMessaging::PBT_APMSUSPEND;
-use windows::Win32::UI::WindowsAndMessaging::PBT_POWERSETTINGCHANGE;
-use windows::Win32::UI::WindowsAndMessaging::REGISTER_NOTIFICATION_FLAGS;
 use windows::Win32::UI::WindowsAndMessaging::SPI_SETWORKAREA;
 use windows::Win32::UI::WindowsAndMessaging::WM_DEVICECHANGE;
 use windows::Win32::UI::WindowsAndMessaging::WM_DISPLAYCHANGE;
@@ -87,7 +75,7 @@ impl Hidden {
 
             loop {
                 unsafe {
-                    if !GetMessageW(&mut msg, None, 0, 0).as_bool() {
+                    if !GetMessageW(&mut msg, HWND::default(), 0, 0).as_bool() {
                         tracing::debug!("hidden window event processing thread shutdown");
                         break;
                     };
@@ -104,57 +92,8 @@ impl Hidden {
 
         let hwnd = hwnd_receiver.recv()?;
 
-        // Register Session Lock/Unlock events
         WindowsApi::wts_register_session_notification(hwnd)?;
 
-        // Register Laptop lid open/close events
-        WindowsApi::register_power_setting_notification(
-            hwnd,
-            &GUID_LIDSWITCH_STATE_CHANGE,
-            REGISTER_NOTIFICATION_FLAGS(0),
-        )?;
-
-        // Register device interface events for multiple display related devices. Some of this
-        // device interfaces might not be needed but it doesn't hurt to have them in case some user
-        // uses some output device as monitor that falls into one of these device interface class
-        // GUID.
-        let monitor_filter = DEV_BROADCAST_DEVICEINTERFACE_W {
-            dbcc_size: std::mem::size_of::<DEV_BROADCAST_DEVICEINTERFACE_W>() as u32,
-            dbcc_devicetype: DBT_DEVTYP_DEVICEINTERFACE.0,
-            dbcc_reserved: 0,
-            dbcc_classguid: GUID_DEVINTERFACE_MONITOR,
-            dbcc_name: [0; 1],
-        };
-        let display_adapter_filter = DEV_BROADCAST_DEVICEINTERFACE_W {
-            dbcc_size: std::mem::size_of::<DEV_BROADCAST_DEVICEINTERFACE_W>() as u32,
-            dbcc_devicetype: DBT_DEVTYP_DEVICEINTERFACE.0,
-            dbcc_reserved: 0,
-            dbcc_classguid: GUID_DEVINTERFACE_DISPLAY_ADAPTER,
-            dbcc_name: [0; 1],
-        };
-        let video_output_filter = DEV_BROADCAST_DEVICEINTERFACE_W {
-            dbcc_size: std::mem::size_of::<DEV_BROADCAST_DEVICEINTERFACE_W>() as u32,
-            dbcc_devicetype: DBT_DEVTYP_DEVICEINTERFACE.0,
-            dbcc_reserved: 0,
-            dbcc_classguid: GUID_DEVINTERFACE_VIDEO_OUTPUT_ARRIVAL,
-            dbcc_name: [0; 1],
-        };
-        WindowsApi::register_device_notification(
-            hwnd,
-            monitor_filter,
-            REGISTER_NOTIFICATION_FLAGS(0),
-        )?;
-        WindowsApi::register_device_notification(
-            hwnd,
-            display_adapter_filter,
-            REGISTER_NOTIFICATION_FLAGS(0),
-        )?;
-        WindowsApi::register_device_notification(
-            hwnd,
-            video_output_filter,
-            REGISTER_NOTIFICATION_FLAGS(0),
-        )?;
-
         Ok(Self { hwnd })
     }
 
@@ -189,35 +128,6 @@ impl Hidden {
                             );
                             LRESULT(0)
                         }
-                        // Monitor change power status
-                        PBT_POWERSETTINGCHANGE => {
-                            if let POWERBROADCAST_SETTING {
-                                PowerSetting: GUID_LIDSWITCH_STATE_CHANGE,
-                                DataLength: _,
-                                Data: [0],
-                            } = *(lparam.0 as *const POWERBROADCAST_SETTING)
-                            {
-                                tracing::debug!(
-                                    "WM_POWERBROADCAST event received - laptop lid closed"
-                                );
-                                monitor_reconciliator::send_notification(
-                                    monitor_reconciliator::MonitorNotification::DisplayConnectionChange,
-                                );
-                            } else if let POWERBROADCAST_SETTING {
-                                PowerSetting: GUID_LIDSWITCH_STATE_CHANGE,
-                                DataLength: _,
-                                Data: [1],
-                            } = *(lparam.0 as *const POWERBROADCAST_SETTING)
-                            {
-                                tracing::debug!(
-                                    "WM_POWERBROADCAST event received - laptop lid opened"
-                                );
-                                monitor_reconciliator::send_notification(
-                                    monitor_reconciliator::MonitorNotification::DisplayConnectionChange,
-                                );
-                            }
-                            LRESULT(0)
-                        }
                         _ => LRESULT(0),
                     }
                 }
@@ -278,15 +188,10 @@ impl Hidden {
                 // Original idea from https://stackoverflow.com/a/33762334
                 WM_DEVICECHANGE => {
                     #[allow(clippy::cast_possible_truncation)]
-                    let event = wparam.0 as u32;
-                    if event == DBT_DEVNODES_CHANGED
-                        || event == DBT_CONFIGCHANGED
-                        || event == DBT_DEVICEARRIVAL
-                        || event == DBT_DEVICEREMOVECOMPLETE
-                    {
+                    if wparam.0 as u32 == DBT_DEVNODES_CHANGED {
                         tracing::debug!(
-                            "WM_DEVICECHANGE event received with one of [DBT_DEVNODES_CHANGED, DBT_CONFIGCHANGED, DBT_DEVICEARRIVAL, DBT_DEVICEREMOVECOMPLETE] - display added or removed"
-                        );
+                                "WM_DEVICECHANGE event received with DBT_DEVNODES_CHANGED - display added or removed"
+                            );
                         monitor_reconciliator::send_notification(
                             monitor_reconciliator::MonitorNotification::DisplayConnectionChange,
                         );

komorebi/src/monitor_reconciliator/mod.rs

@@ -1,18 +1,17 @@
 #![deny(clippy::unwrap_used, clippy::expect_used)]
 
 use crate::border_manager;
-use crate::config_generation::WorkspaceMatchingRule;
 use crate::core::Rect;
 use crate::monitor;
 use crate::monitor::Monitor;
 use crate::monitor_reconciliator::hidden::Hidden;
 use crate::notify_subscribers;
+use crate::MonitorConfig;
 use crate::Notification;
 use crate::NotificationEvent;
 use crate::State;
 use crate::WindowManager;
 use crate::WindowsApi;
-use crate::WORKSPACE_MATCHING_RULES;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_utils::atomic::AtomicConsume;
@@ -45,10 +44,10 @@ static ACTIVE: AtomicBool = AtomicBool::new(true);
 static CHANNEL: OnceLock<(Sender<MonitorNotification>, Receiver<MonitorNotification>)> =
     OnceLock::new();
 
-static MONITOR_CACHE: OnceLock<Mutex<HashMap<String, Monitor>>> = OnceLock::new();
+static MONITOR_CACHE: OnceLock<Mutex<HashMap<String, MonitorConfig>>> = OnceLock::new();
 
 pub fn channel() -> &'static (Sender<MonitorNotification>, Receiver<MonitorNotification>) {
-    CHANNEL.get_or_init(|| crossbeam_channel::bounded(20))
+    CHANNEL.get_or_init(|| crossbeam_channel::bounded(1))
 }
 
 fn event_tx() -> Sender<MonitorNotification> {
@@ -65,12 +64,12 @@ pub fn send_notification(notification: MonitorNotification) {
     }
 }
 
-pub fn insert_in_monitor_cache(serial_or_device_id: &str, monitor: Monitor) {
+pub fn insert_in_monitor_cache(device_id: &str, config: MonitorConfig) {
     let mut monitor_cache = MONITOR_CACHE
         .get_or_init(|| Mutex::new(HashMap::new()))
         .lock();
 
-    monitor_cache.insert(serial_or_device_id.to_string(), monitor);
+    monitor_cache.insert(device_id.to_string(), config);
 }
 
 pub fn attached_display_devices() -> color_eyre::Result<Vec<Monitor>> {
@@ -136,19 +135,21 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
     let receiver = event_rx();
 
     'receiver: for notification in receiver {
-        if !ACTIVE.load_consume()
-            && matches!(
+        if !ACTIVE.load_consume() {
+            if matches!(
                 notification,
                 MonitorNotification::ResumingFromSuspendedState
                     | MonitorNotification::SessionUnlocked
-            )
-        {
-            tracing::debug!(
-                "reactivating reconciliator - system has resumed from suspended state or session has been unlocked"
-            );
+            ) {
+                tracing::debug!(
+                    "reactivating reconciliator - system has resumed from suspended state or session has been unlocked"
+                );
 
-            ACTIVE.store(true, Ordering::SeqCst);
-            border_manager::send_notification(None);
+                ACTIVE.store(true, Ordering::SeqCst);
+                border_manager::send_notification(None);
+            }
+
+            continue 'receiver;
         }
 
         let mut wm = wm.lock();
@@ -162,6 +163,10 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                 );
                 ACTIVE.store(false, Ordering::SeqCst);
             }
+            MonitorNotification::ResumingFromSuspendedState
+            | MonitorNotification::SessionUnlocked => {
+                // this is only handled above if the reconciliator is paused
+            }
             MonitorNotification::WorkAreaChanged => {
                 tracing::debug!("handling work area changed notification");
                 let offset = wm.work_area_offset;
@@ -241,12 +246,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     }
                 }
             }
-            // this is handled above if the reconciliator is paused but we should still check if
-            // there were any changes to the connected monitors while the system was
-            // suspended/locked.
-            MonitorNotification::ResumingFromSuspendedState
-            | MonitorNotification::SessionUnlocked
-            | MonitorNotification::DisplayConnectionChange => {
+            MonitorNotification::DisplayConnectionChange => {
                 tracing::debug!("handling display connection change notification");
                 let mut monitor_cache = MONITOR_CACHE
                     .get_or_init(|| Mutex::new(HashMap::new()))
@@ -260,12 +260,8 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                 // Make sure that in our state any attached displays have the latest Win32 data
                 for monitor in wm.monitors_mut() {
                     for attached in &attached_devices {
-                        if attached.serial_number_id().eq(monitor.serial_number_id())
-                            || attached.device_id().eq(monitor.device_id())
-                        {
+                        if attached.device_id().eq(monitor.device_id()) {
                             monitor.set_id(attached.id());
-                            monitor.set_device_id(attached.device_id().clone());
-                            monitor.set_serial_number_id(attached.serial_number_id().clone());
                             monitor.set_name(attached.name().clone());
                             monitor.set_size(*attached.size());
                             monitor.set_work_area_size(*attached.work_area_size());
@@ -275,7 +271,6 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
 
                 if initial_monitor_count == attached_devices.len() {
                     tracing::debug!("monitor counts match, reconciliation not required");
-                    drop(wm);
                     continue 'receiver;
                 }
 
@@ -283,7 +278,6 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     tracing::debug!(
                         "no devices found, skipping reconciliation to avoid breaking state"
                     );
-                    drop(wm);
                     continue 'receiver;
                 }
 
@@ -293,108 +287,41 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         attached_devices.len()
                     );
 
-                    // Windows to remove from `known_hwnds`
-                    let mut windows_to_remove = Vec::new();
+                    // Gather all the containers that will be orphaned from disconnected and invalid displays
+                    let mut orphaned_containers = vec![];
 
                     // Collect the ids in our state which aren't in the current attached display ids
                     // These are monitors that have been removed
                     let mut newly_removed_displays = vec![];
 
-                    for (m_idx, m) in wm.monitors().iter().enumerate() {
-                        if !attached_devices.iter().any(|attached| {
-                            attached.serial_number_id().eq(m.serial_number_id())
-                                || attached.device_id().eq(m.device_id())
-                        }) {
-                            let id = m
-                                .serial_number_id()
-                                .as_ref()
-                                .map_or(m.device_id().clone(), |sn| sn.clone());
-
-                            newly_removed_displays.push(id.clone());
-
-                            let focused_workspace_idx = m.focused_workspace_idx();
-
-                            for (idx, workspace) in m.workspaces().iter().enumerate() {
-                                let is_focused_workspace = idx == focused_workspace_idx;
-                                let focused_container_idx = workspace.focused_container_idx();
-                                for (c_idx, container) in workspace.containers().iter().enumerate()
-                                {
-                                    let focused_window_idx = container.focused_window_idx();
-                                    for (w_idx, window) in container.windows().iter().enumerate() {
-                                        windows_to_remove.push(window.hwnd);
-                                        if is_focused_workspace
-                                            && c_idx == focused_container_idx
-                                            && w_idx == focused_window_idx
-                                        {
-                                            // Minimize the focused window since Windows might try
-                                            // to move it to another monitor if it was focused.
-                                            if window.is_focused() {
-                                                window.minimize();
-                                            }
-                                        }
-                                    }
+                    for m in wm.monitors().iter() {
+                        if !attached_devices
+                            .iter()
+                            .any(|attached| attached.device_id().eq(m.device_id()))
+                        {
+                            newly_removed_displays.push(m.device_id().clone());
+                            for workspace in m.workspaces() {
+                                for container in workspace.containers() {
+                                    // Save the orphaned containers from the removed monitor
+                                    orphaned_containers.push(container.clone());
                                 }
-
-                                if let Some(maximized) = workspace.maximized_window() {
-                                    windows_to_remove.push(maximized.hwnd);
-                                    // Minimize the focused window since Windows might try
-                                    // to move it to another monitor if it was focused.
-                                    if maximized.is_focused() {
-                                        maximized.minimize();
-                                    }
-                                }
-
-                                if let Some(container) = workspace.monocle_container() {
-                                    for window in container.windows() {
-                                        windows_to_remove.push(window.hwnd);
-                                    }
-                                    if let Some(window) = container.focused_window() {
-                                        // Minimize the focused window since Windows might try
-                                        // to move it to another monitor if it was focused.
-                                        if window.is_focused() {
-                                            window.minimize();
-                                        }
-                                    }
-                                }
-
-                                for window in workspace.floating_windows() {
-                                    windows_to_remove.push(window.hwnd);
-                                    // Minimize the focused window since Windows might try
-                                    // to move it to another monitor if it was focused.
-                                    if window.is_focused() {
-                                        window.minimize();
-                                    }
-                                }
-                            }
-
-                            // Remove any workspace_rules for this specific monitor
-                            let mut workspace_rules = WORKSPACE_MATCHING_RULES.lock();
-                            let mut rules_to_remove = Vec::new();
-                            for (i, rule) in workspace_rules.iter().enumerate().rev() {
-                                if rule.monitor_index == m_idx {
-                                    rules_to_remove.push(i);
-                                }
-                            }
-                            for i in rules_to_remove {
-                                workspace_rules.remove(i);
                             }
 
                             // Let's add their state to the cache for later
-                            monitor_cache.insert(id, m.clone());
+                            monitor_cache.insert(m.device_id().clone(), m.into());
                         }
                     }
 
-                    // Update known_hwnds
-                    wm.known_hwnds.retain(|i, _| !windows_to_remove.contains(i));
+                    if !orphaned_containers.is_empty() {
+                        tracing::info!(
+                            "removed orphaned containers from: {newly_removed_displays:?}"
+                        );
+                    }
 
                     if !newly_removed_displays.is_empty() {
                         // After we have cached them, remove them from our state
-                        wm.monitors_mut().retain(|m| {
-                            !newly_removed_displays.iter().any(|id| {
-                                m.serial_number_id().as_ref().is_some_and(|sn| sn == id)
-                                    || m.device_id() == id
-                            })
-                        });
+                        wm.monitors_mut()
+                            .retain(|m| !newly_removed_displays.contains(m.device_id()));
                     }
 
                     let post_removal_monitor_count = wm.monitors().len();
@@ -403,6 +330,24 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         wm.focus_monitor(0)?;
                     }
 
+                    if !orphaned_containers.is_empty() {
+                        if let Some(primary) = wm.monitors_mut().front_mut() {
+                            if let Some(focused_ws) = primary.focused_workspace_mut() {
+                                let focused_container_idx = focused_ws.focused_container_idx();
+
+                                // Put the orphaned containers somewhere visible
+                                for container in orphaned_containers {
+                                    focused_ws.add_container_to_back(container);
+                                }
+
+                                // Gotta reset the focus or the movement will feel "off"
+                                if initial_monitor_count != post_removal_monitor_count {
+                                    focused_ws.focus_container(focused_container_idx);
+                                }
+                            }
+                        }
+                    }
+
                     let offset = wm.work_area_offset;
 
                     for monitor in wm.monitors_mut() {
@@ -415,11 +360,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
 
                 let post_removal_monitor_count = wm.monitors().len();
 
-                // This is the list of device ids after we have removed detached displays. We can
-                // keep this with just the device_ids without the serial numbers since this is used
-                // only to check which one is the newly added monitor below if there is a new
-                // monitor. Everything done after with said new monitor will again consider both
-                // serial number and device ids.
+                // This is the list of device ids after we have removed detached displays
                 let post_removal_device_ids = wm
                     .monitors()
                     .iter()
@@ -429,7 +370,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
 
                 // Check for and add any new monitors that may have been plugged in
                 // Monitor and display index preferences get applied in this function
-                WindowsApi::load_monitor_information(&mut wm)?;
+                WindowsApi::load_monitor_information(&mut wm.monitors)?;
 
                 let post_addition_monitor_count = wm.monitors().len();
 
@@ -438,181 +379,42 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         "monitor count mismatch ({post_removal_monitor_count} vs {post_addition_monitor_count}), adding connected monitors",
                     );
 
-                    let known_hwnds = wm.known_hwnds.clone();
-                    let offset = wm.work_area_offset;
-                    let mouse_follows_focus = wm.mouse_follows_focus;
-                    let focused_monitor_idx = wm.focused_monitor_idx();
-                    let focused_workspace_idx = wm.focused_workspace_idx()?;
-
                     // Look in the updated state for new monitors
-                    for (i, m) in wm.monitors_mut().iter_mut().enumerate() {
-                        let device_id = m.device_id();
+                    for m in wm.monitors_mut() {
+                        let device_id = m.device_id().clone();
                         // We identify a new monitor when we encounter a new device id
-                        if !post_removal_device_ids.contains(device_id) {
+                        if !post_removal_device_ids.contains(&device_id) {
                             let mut cache_hit = false;
-                            let mut cached_id = String::new();
                             // Check if that device id exists in the cache for this session
-                            if let Some((id, cached)) = monitor_cache.get_key_value(device_id).or(m
-                                .serial_number_id()
-                                .as_ref()
-                                .and_then(|sn| monitor_cache.get_key_value(sn)))
-                            {
+                            if let Some(cached) = monitor_cache.get(&device_id) {
                                 cache_hit = true;
-                                cached_id = id.clone();
 
-                                tracing::info!("found monitor and workspace configuration for {id} in the monitor cache, applying");
+                                tracing::info!("found monitor and workspace configuration for {device_id} in the monitor cache, applying");
 
-                                // If it does, load the monitor removing any window that has since
-                                // been closed or moved to another workspace
-                                *m = cached.clone();
+                                // If it does, load all the monitor settings from the cache entry
+                                m.ensure_workspace_count(cached.workspaces.len());
+                                m.set_work_area_offset(cached.work_area_offset);
+                                m.set_window_based_work_area_offset(
+                                    cached.window_based_work_area_offset,
+                                );
+                                m.set_window_based_work_area_offset_limit(
+                                    cached.window_based_work_area_offset_limit.unwrap_or(1),
+                                );
 
-                                let focused_workspace_idx = m.focused_workspace_idx();
-
-                                for (j, workspace) in m.workspaces_mut().iter_mut().enumerate() {
-                                    // If this is the focused workspace we need to show (restore) all
-                                    // windows that were visible since they were probably minimized by
-                                    // Windows.
-                                    let is_focused_workspace = j == focused_workspace_idx;
-                                    let focused_container_idx = workspace.focused_container_idx();
-
-                                    let mut empty_containers = Vec::new();
-                                    for (idx, container) in
-                                        workspace.containers_mut().iter_mut().enumerate()
-                                    {
-                                        container.windows_mut().retain(|window| {
-                                            window.exe().is_ok()
-                                                && !known_hwnds.contains_key(&window.hwnd)
-                                        });
-
-                                        if container.windows().is_empty() {
-                                            empty_containers.push(idx);
-                                        }
-
-                                        if is_focused_workspace {
-                                            if let Some(window) = container.focused_window() {
-                                                tracing::debug!(
-                                                    "restoring window: {}",
-                                                    window.hwnd
-                                                );
-                                                WindowsApi::restore_window(window.hwnd);
-                                            } else {
-                                                // If the focused window was moved or removed by
-                                                // the user after the disconnect then focus the
-                                                // first window and show that one
-                                                container.focus_window(0);
-
-                                                if let Some(window) = container.focused_window() {
-                                                    WindowsApi::restore_window(window.hwnd);
-                                                }
-                                            }
-                                        }
-                                    }
-
-                                    // Remove empty containers
-                                    for empty_idx in empty_containers {
-                                        if empty_idx == focused_container_idx {
-                                            workspace.remove_container(empty_idx);
-                                        } else {
-                                            workspace.remove_container_by_idx(empty_idx);
-                                        }
-                                    }
-
-                                    if let Some(window) = workspace.maximized_window() {
-                                        if window.exe().is_err()
-                                            || known_hwnds.contains_key(&window.hwnd)
-                                        {
-                                            workspace.set_maximized_window(None);
-                                        } else if is_focused_workspace {
-                                            WindowsApi::restore_window(window.hwnd);
-                                        }
-                                    }
-
-                                    if let Some(container) = workspace.monocle_container_mut() {
-                                        container.windows_mut().retain(|window| {
-                                            window.exe().is_ok()
-                                                && !known_hwnds.contains_key(&window.hwnd)
-                                        });
-
-                                        if container.windows().is_empty() {
-                                            workspace.set_monocle_container(None);
-                                        } else if is_focused_workspace {
-                                            if let Some(window) = container.focused_window() {
-                                                WindowsApi::restore_window(window.hwnd);
-                                            } else {
-                                                // If the focused window was moved or removed by
-                                                // the user after the disconnect then focus the
-                                                // first window and show that one
-                                                container.focus_window(0);
-
-                                                if let Some(window) = container.focused_window() {
-                                                    WindowsApi::restore_window(window.hwnd);
-                                                }
-                                            }
-                                        }
-                                    }
-
-                                    workspace.floating_windows_mut().retain(|window| {
-                                        window.exe().is_ok()
-                                            && !known_hwnds.contains_key(&window.hwnd)
-                                    });
-
-                                    if is_focused_workspace {
-                                        for window in workspace.floating_windows() {
-                                            WindowsApi::restore_window(window.hwnd);
-                                        }
-                                    }
-
-                                    // Apply workspace rules
-                                    let mut workspace_matching_rules =
-                                        WORKSPACE_MATCHING_RULES.lock();
-                                    if let Some(rules) = workspace
-                                        .workspace_config()
-                                        .as_ref()
-                                        .and_then(|c| c.workspace_rules.as_ref())
-                                    {
-                                        for r in rules {
-                                            workspace_matching_rules.push(WorkspaceMatchingRule {
-                                                monitor_index: i,
-                                                workspace_index: j,
-                                                matching_rule: r.clone(),
-                                                initial_only: false,
-                                            });
-                                        }
-                                    }
-
-                                    if let Some(rules) = workspace
-                                        .workspace_config()
-                                        .as_ref()
-                                        .and_then(|c| c.initial_workspace_rules.as_ref())
-                                    {
-                                        for r in rules {
-                                            workspace_matching_rules.push(WorkspaceMatchingRule {
-                                                monitor_index: i,
-                                                workspace_index: j,
-                                                matching_rule: r.clone(),
-                                                initial_only: true,
-                                            });
-                                        }
+                                for (w_idx, workspace) in m.workspaces_mut().iter_mut().enumerate()
+                                {
+                                    if let Some(cached_workspace) = cached.workspaces.get(w_idx) {
+                                        workspace.load_static_config(cached_workspace)?;
                                     }
                                 }
-
-                                // Restore windows from new monitor and update the focused
-                                // workspace
-                                m.load_focused_workspace(mouse_follows_focus)?;
-                                m.update_focused_workspace(offset)?;
                             }
 
                             // Entries in the cache should only be used once; remove the entry there was a cache hit
-                            if cache_hit && !cached_id.is_empty() {
-                                monitor_cache.remove(&cached_id);
+                            if cache_hit {
+                                monitor_cache.remove(&device_id);
                             }
                         }
                     }
-
-                    // Refocus the previously focused monitor since the code above might
-                    // steal the focus away.
-                    wm.focus_monitor(focused_monitor_idx)?;
-                    wm.focus_workspace(focused_workspace_idx)?;
                 }
 
                 let final_count = wm.monitors().len();

komorebi/src/process_command.rs

@@ -66,7 +66,6 @@ use crate::window_manager;
 use crate::window_manager::WindowManager;
 use crate::windows_api::WindowsApi;
 use crate::winevent_listener;
-use crate::workspace::WorkspaceLayer;
 use crate::workspace::WorkspaceWindowLocation;
 use crate::GlobalState;
 use crate::Notification;
@@ -292,37 +291,13 @@ impl WindowManager {
                 }
             }
             SocketMessage::FocusWindow(direction) => {
-                let focused_workspace = self.focused_workspace()?;
-                match focused_workspace.layer() {
-                    WorkspaceLayer::Tiling => {
-                        self.focus_container_in_direction(direction)?;
-                    }
-                    WorkspaceLayer::Floating => {
-                        self.focus_floating_window_in_direction(direction)?;
-                    }
-                }
+                self.focus_container_in_direction(direction)?;
             }
             SocketMessage::MoveWindow(direction) => {
-                let focused_workspace = self.focused_workspace()?;
-                match focused_workspace.layer() {
-                    WorkspaceLayer::Tiling => {
-                        self.move_container_in_direction(direction)?;
-                    }
-                    WorkspaceLayer::Floating => {
-                        self.move_floating_window_in_direction(direction)?;
-                    }
-                }
+                self.move_container_in_direction(direction)?;
             }
             SocketMessage::CycleFocusWindow(direction) => {
-                let focused_workspace = self.focused_workspace()?;
-                match focused_workspace.layer() {
-                    WorkspaceLayer::Tiling => {
-                        self.focus_container_in_cycle_direction(direction)?;
-                    }
-                    WorkspaceLayer::Floating => {
-                        self.focus_floating_window_in_cycle_direction(direction)?;
-                    }
-                }
+                self.focus_container_in_cycle_direction(direction)?;
             }
             SocketMessage::CycleMoveWindow(direction) => {
                 self.move_container_in_cycle_direction(direction)?;
@@ -760,11 +735,6 @@ impl WindowManager {
                 self.focus_monitor(monitor_idx)?;
                 self.update_focused_workspace(self.mouse_follows_focus, true)?;
             }
-            SocketMessage::FocusMonitorAtCursor => {
-                if let Some(monitor_idx) = self.monitor_idx_from_current_pos() {
-                    self.focus_monitor(monitor_idx)?;
-                }
-            }
             SocketMessage::Retile => {
                 border_manager::destroy_all_borders()?;
                 self.retile_all(false)?
@@ -878,15 +848,7 @@ impl WindowManager {
                 // secondary monitor where the cursor is focused will be used as the target for
                 // the workspace switch op
                 if let Some(monitor_idx) = self.monitor_idx_from_current_pos() {
-                    if monitor_idx != self.focused_monitor_idx() {
-                        if let Some(monitor) = self.monitors().get(monitor_idx) {
-                            if let Some(workspace) = monitor.focused_workspace() {
-                                if workspace.is_empty() {
-                                    self.focus_monitor(monitor_idx)?;
-                                }
-                            }
-                        }
-                    }
+                    self.focus_monitor(monitor_idx)?;
                 }
 
                 let focused_monitor = self
@@ -909,15 +871,7 @@ impl WindowManager {
                 // secondary monitor where the cursor is focused will be used as the target for
                 // the workspace switch op
                 if let Some(monitor_idx) = self.monitor_idx_from_current_pos() {
-                    if monitor_idx != self.focused_monitor_idx() {
-                        if let Some(monitor) = self.monitors().get(monitor_idx) {
-                            if let Some(workspace) = monitor.focused_workspace() {
-                                if workspace.is_empty() {
-                                    self.focus_monitor(monitor_idx)?;
-                                }
-                            }
-                        }
-                    }
+                    self.focus_monitor(monitor_idx)?;
                 }
 
                 let mut can_close = false;
@@ -953,15 +907,7 @@ impl WindowManager {
                 // secondary monitor where the cursor is focused will be used as the target for
                 // the workspace switch op
                 if let Some(monitor_idx) = self.monitor_idx_from_current_pos() {
-                    if monitor_idx != self.focused_monitor_idx() {
-                        if let Some(monitor) = self.monitors().get(monitor_idx) {
-                            if let Some(workspace) = monitor.focused_workspace() {
-                                if workspace.is_empty() {
-                                    self.focus_monitor(monitor_idx)?;
-                                }
-                            }
-                        }
-                    }
+                    self.focus_monitor(monitor_idx)?;
                 }
 
                 let idx = self
@@ -984,15 +930,7 @@ impl WindowManager {
                 // secondary monitor where the cursor is focused will be used as the target for
                 // the workspace switch op
                 if let Some(monitor_idx) = self.monitor_idx_from_current_pos() {
-                    if monitor_idx != self.focused_monitor_idx() {
-                        if let Some(monitor) = self.monitors().get(monitor_idx) {
-                            if let Some(workspace) = monitor.focused_workspace() {
-                                if workspace.is_empty() {
-                                    self.focus_monitor(monitor_idx)?;
-                                }
-                            }
-                        }
-                    }
+                    self.focus_monitor(monitor_idx)?;
                 }
 
                 if self.focused_workspace_idx().unwrap_or_default() != workspace_idx {
@@ -1004,15 +942,7 @@ impl WindowManager {
                 // secondary monitor where the cursor is focused will be used as the target for
                 // the workspace switch op
                 if let Some(monitor_idx) = self.monitor_idx_from_current_pos() {
-                    if monitor_idx != self.focused_monitor_idx() {
-                        if let Some(monitor) = self.monitors().get(monitor_idx) {
-                            if let Some(workspace) = monitor.focused_workspace() {
-                                if workspace.is_empty() {
-                                    self.focus_monitor(monitor_idx)?;
-                                }
-                            }
-                        }
-                    }
+                    self.focus_monitor(monitor_idx)?;
                 }
 
                 let focused_monitor_idx = self.focused_monitor_idx();
@@ -1045,29 +975,6 @@ impl WindowManager {
                     self.focus_workspace(workspace_idx)?;
                 }
             }
-            SocketMessage::ToggleWorkspaceLayer => {
-                let mouse_follows_focus = self.mouse_follows_focus;
-                let workspace = self.focused_workspace_mut()?;
-
-                match workspace.layer() {
-                    WorkspaceLayer::Tiling => {
-                        workspace.set_layer(WorkspaceLayer::Floating);
-
-                        if let Some(first) = workspace.floating_windows().first() {
-                            first.focus(mouse_follows_focus)?;
-                        }
-                    }
-                    WorkspaceLayer::Floating => {
-                        workspace.set_layer(WorkspaceLayer::Tiling);
-
-                        if let Some(container) = workspace.focused_container() {
-                            if let Some(window) = container.focused_window() {
-                                window.focus(mouse_follows_focus)?;
-                            }
-                        }
-                    }
-                };
-            }
             SocketMessage::Stop => {
                 self.stop(false)?;
             }
@@ -1506,14 +1413,6 @@ impl WindowManager {
                     self.retile_all(false)?;
                 }
             }
-            SocketMessage::ToggleWindowBasedWorkAreaOffset => {
-                let workspace = self.focused_workspace_mut()?;
-                workspace.set_apply_window_based_work_area_offset(
-                    !workspace.apply_window_based_work_area_offset(),
-                );
-
-                self.retile_all(false)?;
-            }
             SocketMessage::QuickSave => {
                 let workspace = self.focused_workspace()?;
                 let resize = workspace.resize_dimensions();
@@ -1883,9 +1782,6 @@ impl WindowManager {
             | SocketMessage::IdentifyBorderOverflowApplication(_, _) => {}
         };
 
-        // Update list of known_hwnds and their monitor/workspace index pair
-        self.update_known_hwnds();
-
         notify_subscribers(
             Notification {
                 event: NotificationEvent::Socket(message.clone()),

komorebi/src/process_event.rs

@@ -1,3 +1,4 @@
+use std::fs::OpenOptions;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::time::Duration;
@@ -32,6 +33,7 @@ use crate::workspace_reconciliator::ALT_TAB_HWND_INSTANT;
 use crate::Notification;
 use crate::NotificationEvent;
 use crate::State;
+use crate::DATA_DIR;
 use crate::FLOATING_APPLICATIONS;
 use crate::HIDDEN_HWNDS;
 use crate::REGEX_IDENTIFIERS;
@@ -252,12 +254,7 @@ impl WindowManager {
                 already_moved_window_handles.remove(&window.hwnd);
             }
             WindowManagerEvent::FocusChange(_, window) => {
-                // 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
-                if !self.focused_workspace()?.containers().is_empty() {
-                    self.update_focused_workspace(self.mouse_follows_focus, false)?;
-                }
+                self.update_focused_workspace(self.mouse_follows_focus, false)?;
 
                 let workspace = self.focused_workspace_mut()?;
                 let floating_window_idx = workspace
@@ -305,28 +302,30 @@ impl WindowManager {
 
                     let mut needs_reconciliation = false;
 
-                    if let Some((m_idx, w_idx)) = self.known_hwnds.get(&window.hwnd) {
-                        if focused_pair != (*m_idx, *w_idx) {
-                            // At this point we know we are going to send a notification to the workspace reconciliator
-                            // So we get the topmost window returned by EnumWindows, which is almost always the window
-                            // that has been selected by alt-tab
-                            if let Ok(alt_tab_windows) = WindowsApi::alt_tab_windows() {
-                                if let Some(first) =
-                                    alt_tab_windows.iter().find(|w| w.title().is_ok())
-                                {
-                                    // If our record of this HWND hasn't been updated in over a minute
-                                    let mut instant = ALT_TAB_HWND_INSTANT.lock();
-                                    if instant.elapsed().gt(&Duration::from_secs(1)) {
-                                        // Update our record with the HWND we just found
-                                        ALT_TAB_HWND.store(Some(first.hwnd));
-                                        // Update the timestamp of our record
-                                        *instant = Instant::now();
+                    for (i, monitors) in self.monitors().iter().enumerate() {
+                        for (j, workspace) in monitors.workspaces().iter().enumerate() {
+                            if workspace.contains_window(window.hwnd) && focused_pair != (i, j) {
+                                // At this point we know we are going to send a notification to the workspace reconciliator
+                                // So we get the topmost window returned by EnumWindows, which is almost always the window
+                                // that has been selected by alt-tab
+                                if let Ok(alt_tab_windows) = WindowsApi::alt_tab_windows() {
+                                    if let Some(first) =
+                                        alt_tab_windows.iter().find(|w| w.title().is_ok())
+                                    {
+                                        // If our record of this HWND hasn't been updated in over a minute
+                                        let mut instant = ALT_TAB_HWND_INSTANT.lock();
+                                        if instant.elapsed().gt(&Duration::from_secs(1)) {
+                                            // Update our record with the HWND we just found
+                                            ALT_TAB_HWND.store(Some(first.hwnd));
+                                            // Update the timestamp of our record
+                                            *instant = Instant::now();
+                                        }
                                     }
                                 }
-                            }
 
-                            workspace_reconciliator::send_notification(*m_idx, *w_idx);
-                            needs_reconciliation = true;
+                                workspace_reconciliator::send_notification(i, j);
+                                needs_reconciliation = true;
+                            }
                         }
                     }
 
@@ -337,14 +336,11 @@ impl WindowManager {
                     // duplicates across multiple workspaces, as it results in ghost layout tiles.
                     let mut proceed = true;
 
-                    if let Some((m_idx, w_idx)) = self.known_hwnds.get(&window.hwnd) {
-                        if let Some(focused_workspace_idx) = self
-                            .monitors()
-                            .get(*m_idx)
-                            .map(|m| m.focused_workspace_idx())
-                        {
-                            if *m_idx != self.focused_monitor_idx()
-                                && *w_idx != focused_workspace_idx
+                    for (i, monitor) in self.monitors().iter().enumerate() {
+                        for (j, workspace) in monitor.workspaces().iter().enumerate() {
+                            if workspace.contains_window(window.hwnd)
+                                && i != self.focused_monitor_idx()
+                                && j != monitor.focused_workspace_idx()
                             {
                                 tracing::debug!(
                                     "ignoring show event for window already associated with another workspace"
@@ -503,9 +499,15 @@ impl WindowManager {
                 // This will be true if we have moved to another monitor
                 let mut moved_across_monitors = false;
 
-                if let Some((m_idx, _)) = self.known_hwnds.get(&window.hwnd) {
-                    if *m_idx != target_monitor_idx {
-                        moved_across_monitors = true;
+                for (i, monitors) in self.monitors().iter().enumerate() {
+                    for workspace in monitors.workspaces() {
+                        if workspace.contains_window(window.hwnd) && i != target_monitor_idx {
+                            moved_across_monitors = true;
+                            break;
+                        }
+                    }
+                    if moved_across_monitors {
+                        break;
                     }
                 }
 
@@ -709,8 +711,40 @@ impl WindowManager {
             window.center(&self.focused_monitor_work_area()?)?;
         }
 
-        // Update list of known_hwnds and their monitor/workspace index pair
-        self.update_known_hwnds();
+        tracing::trace!("updating list of known hwnds");
+        let mut known_hwnds = vec![];
+        for monitor in self.monitors() {
+            for workspace in monitor.workspaces() {
+                for container in workspace.containers() {
+                    for window in container.windows() {
+                        known_hwnds.push(window.hwnd);
+                    }
+                }
+
+                for window in workspace.floating_windows() {
+                    known_hwnds.push(window.hwnd);
+                }
+
+                if let Some(window) = workspace.maximized_window() {
+                    known_hwnds.push(window.hwnd);
+                }
+
+                if let Some(container) = workspace.monocle_container() {
+                    for window in container.windows() {
+                        known_hwnds.push(window.hwnd);
+                    }
+                }
+            }
+        }
+
+        let hwnd_json = DATA_DIR.join("komorebi.hwnd.json");
+        let file = OpenOptions::new()
+            .write(true)
+            .truncate(true)
+            .create(true)
+            .open(hwnd_json)?;
+
+        serde_json::to_writer_pretty(&file, &known_hwnds)?;
 
         notify_subscribers(
             Notification {

komorebi/src/reaper.rs

@@ -1,164 +1,14 @@
 #![deny(clippy::unwrap_used, clippy::expect_used)]
 
 use crate::border_manager;
-use crate::notify_subscribers;
-use crate::winevent::WinEvent;
-use crate::NotificationEvent;
-use crate::Window;
 use crate::WindowManager;
-use crate::WindowManagerEvent;
-use crate::DATA_DIR;
-
-use crossbeam_channel::Receiver;
-use crossbeam_channel::Sender;
-use lazy_static::lazy_static;
 use parking_lot::Mutex;
-use std::collections::HashMap;
-use std::fs::OpenOptions;
 use std::sync::Arc;
-use std::sync::OnceLock;
 use std::time::Duration;
 
-lazy_static! {
-    pub static ref HWNDS_CACHE: Arc<Mutex<HashMap<isize, (usize, usize)>>> =
-        Arc::new(Mutex::new(HashMap::new()));
-}
-
-pub struct ReaperNotification(pub HashMap<isize, (usize, usize)>);
-
-static CHANNEL: OnceLock<(Sender<ReaperNotification>, Receiver<ReaperNotification>)> =
-    OnceLock::new();
-
-pub fn channel() -> &'static (Sender<ReaperNotification>, Receiver<ReaperNotification>) {
-    CHANNEL.get_or_init(|| crossbeam_channel::bounded(50))
-}
-
-fn event_tx() -> Sender<ReaperNotification> {
-    channel().0.clone()
-}
-
-fn event_rx() -> Receiver<ReaperNotification> {
-    channel().1.clone()
-}
-
-pub fn send_notification(hwnds: HashMap<isize, (usize, usize)>) {
-    if event_tx().try_send(ReaperNotification(hwnds)).is_err() {
-        tracing::warn!("channel is full; dropping notification")
-    }
-}
-
-pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) {
-    watch_for_orphans(wm.clone());
-
+pub fn watch_for_orphans(wm: Arc<Mutex<WindowManager>>) {
     std::thread::spawn(move || loop {
-        match handle_notifications(wm.clone()) {
-            Ok(()) => {
-                tracing::warn!("restarting finished thread");
-            }
-            Err(error) => {
-                tracing::warn!("restarting failed thread: {}", error);
-            }
-        }
-    });
-}
-
-fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
-    tracing::info!("listening");
-
-    let receiver = event_rx();
-
-    for notification in receiver {
-        let orphan_hwnds = notification.0;
-        let mut wm = wm.lock();
-        let offset = wm.work_area_offset;
-
-        let mut update_borders = false;
-
-        for (hwnd, (m_idx, w_idx)) in orphan_hwnds.iter() {
-            if let Some(monitor) = wm.monitors_mut().get_mut(*m_idx) {
-                let focused_workspace_idx = monitor.focused_workspace_idx();
-                let work_area = *monitor.work_area_size();
-                let window_based_work_area_offset = (
-                    monitor.window_based_work_area_offset_limit(),
-                    monitor.window_based_work_area_offset(),
-                );
-
-                let offset = if monitor.work_area_offset().is_some() {
-                    monitor.work_area_offset()
-                } else {
-                    offset
-                };
-
-                if let Some(workspace) = monitor.workspaces_mut().get_mut(*w_idx) {
-                    // Remove orphan window
-                    if let Err(error) = workspace.remove_window(*hwnd) {
-                        tracing::warn!(
-                            "error reaping orphan window ({}) on monitor: {}, workspace: {}. Error: {}",
-                            hwnd,
-                            m_idx,
-                            w_idx,
-                            error,
-                        );
-                    }
-
-                    if focused_workspace_idx == *w_idx {
-                        // If this is not a focused workspace there is no need to update the
-                        // workspace or the borders. That will already be done when the user
-                        // changes to this workspace.
-                        workspace.update(&work_area, offset, window_based_work_area_offset)?;
-                        update_borders = true;
-                    }
-                    tracing::info!(
-                        "reaped orphan window ({}) on monitor: {}, workspace: {}",
-                        hwnd,
-                        m_idx,
-                        w_idx,
-                    );
-                }
-            }
-
-            wm.known_hwnds.remove(hwnd);
-
-            let window = Window::from(*hwnd);
-            notify_subscribers(
-                crate::Notification {
-                    event: NotificationEvent::WindowManager(WindowManagerEvent::Destroy(
-                        WinEvent::ObjectDestroy,
-                        window,
-                    )),
-                    state: wm.as_ref().into(),
-                },
-                true,
-            )?;
-        }
-
-        if update_borders {
-            border_manager::send_notification(None);
-        }
-
-        // Save to file
-        let hwnd_json = DATA_DIR.join("komorebi.hwnd.json");
-        let file = OpenOptions::new()
-            .write(true)
-            .truncate(true)
-            .create(true)
-            .open(hwnd_json)?;
-
-        serde_json::to_writer_pretty(&file, &wm.known_hwnds.keys().collect::<Vec<_>>())?;
-    }
-
-    Ok(())
-}
-
-fn watch_for_orphans(wm: Arc<Mutex<WindowManager>>) {
-    // Cache current hwnds
-    {
-        let mut cache = HWNDS_CACHE.lock();
-        *cache = wm.lock().known_hwnds.clone();
-    }
-
-    std::thread::spawn(move || loop {
-        match find_orphans() {
+        match find_orphans(wm.clone()) {
             Ok(()) => {
                 tracing::warn!("restarting finished thread");
             }
@@ -173,37 +23,50 @@ fn watch_for_orphans(wm: Arc<Mutex<WindowManager>>) {
     });
 }
 
-fn find_orphans() -> color_eyre::Result<()> {
+pub fn find_orphans(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
     tracing::info!("watching");
 
+    let arc = wm.clone();
+
     loop {
-        std::thread::sleep(Duration::from_millis(20));
+        std::thread::sleep(Duration::from_secs(1));
 
-        let mut cache = HWNDS_CACHE.lock();
-        let mut orphan_hwnds = HashMap::new();
+        let mut wm = arc.lock();
+        let offset = wm.work_area_offset;
 
-        for (hwnd, (m_idx, w_idx)) in cache.iter() {
-            let window = Window::from(*hwnd);
+        let mut update_borders = false;
 
-            if !window.is_window()
-                // This one is a hack because WINWORD.EXE is an absolute trainwreck of an app
-                // when multiple docs are open, it keeps open an invisible window, with WS_EX_LAYERED
-                // (A STYLE THAT THE REGULAR WINDOWS NEED IN ORDER TO BE MANAGED!) when one of the
-                // docs is closed
-                //
-                // I hate every single person who worked on Microsoft Office 365, especially Word
-                || !window.is_visible()
-            {
-                orphan_hwnds.insert(window.hwnd, (*m_idx, *w_idx));
+        for (i, monitor) in wm.monitors_mut().iter_mut().enumerate() {
+            let work_area = *monitor.work_area_size();
+            let window_based_work_area_offset = (
+                monitor.window_based_work_area_offset_limit(),
+                monitor.window_based_work_area_offset(),
+            );
+
+            let offset = if monitor.work_area_offset().is_some() {
+                monitor.work_area_offset()
+            } else {
+                offset
+            };
+
+            for (j, workspace) in monitor.workspaces_mut().iter_mut().enumerate() {
+                let reaped_orphans = workspace.reap_orphans()?;
+                if reaped_orphans.0 > 0 || reaped_orphans.1 > 0 {
+                    workspace.update(&work_area, offset, window_based_work_area_offset)?;
+                    update_borders = true;
+                    tracing::info!(
+                        "reaped {} orphan window(s) and {} orphaned container(s) on monitor: {}, workspace: {}",
+                        reaped_orphans.0,
+                        reaped_orphans.1,
+                        i,
+                        j
+                    );
+                }
             }
         }
 
-        if !orphan_hwnds.is_empty() {
-            // Update reaper cache
-            cache.retain(|h, _| !orphan_hwnds.contains_key(h));
-
-            // Send handles to remove
-            event_tx().send(ReaperNotification(orphan_hwnds))?;
+        if update_borders {
+            border_manager::send_notification(None);
         }
     }
 }

komorebi/src/stackbar_manager/stackbar.rs

@@ -123,7 +123,7 @@ impl Stackbar {
                     0,
                     None,
                     None,
-                    Option::from(HINSTANCE(windows_api::as_ptr!(instance))),
+                    HINSTANCE(windows_api::as_ptr!(instance)),
                     None,
                 )?;
 
@@ -133,7 +133,7 @@ impl Stackbar {
                 let mut msg: MSG = MSG::default();
 
                 loop {
-                    if !GetMessageW(&mut msg, None, 0, 0).as_bool() {
+                    if !GetMessageW(&mut msg, HWND::default(), 0, 0).as_bool() {
                         tracing::debug!("stackbar window event processing thread shutdown");
                         break;
                     };
@@ -183,13 +183,13 @@ impl Stackbar {
         WindowsApi::position_window(self.hwnd, &layout, false)?;
 
         unsafe {
-            let hdc = GetDC(Option::from(self.hwnd()));
+            let hdc = GetDC(self.hwnd());
 
             let hpen = CreatePen(PS_SOLID, 0, COLORREF(background));
             let hbrush = CreateSolidBrush(COLORREF(background));
 
-            SelectObject(hdc, hpen.into());
-            SelectObject(hdc, hbrush.into());
+            SelectObject(hdc, hpen);
+            SelectObject(hdc, hbrush);
             SetBkColor(hdc, COLORREF(background));
 
             let mut logfont = LOGFONTW {
@@ -209,14 +209,14 @@ impl Stackbar {
             let logical_height = -MulDiv(
                 STACKBAR_FONT_SIZE.load(Ordering::SeqCst),
                 72,
-                GetDeviceCaps(Option::from(hdc), LOGPIXELSY),
+                GetDeviceCaps(hdc, LOGPIXELSY),
             );
 
             logfont.lfHeight = logical_height;
 
             let hfont = CreateFontIndirectW(&logfont);
 
-            SelectObject(hdc, hfont.into());
+            SelectObject(hdc, hfont);
 
             for (i, window) in container.windows().iter().enumerate() {
                 if window.hwnd == container.focused_window().copied().unwrap_or_default().hwnd {
@@ -283,13 +283,13 @@ impl Stackbar {
                 );
             }
 
-            ReleaseDC(Option::from(self.hwnd()), hdc);
+            ReleaseDC(self.hwnd(), hdc);
             // TODO: error handling
-            let _ = DeleteObject(hpen.into());
+            let _ = DeleteObject(hpen);
             // TODO: error handling
-            let _ = DeleteObject(hbrush.into());
+            let _ = DeleteObject(hbrush);
             // TODO: error handling
-            let _ = DeleteObject(hfont.into());
+            let _ = DeleteObject(hfont);
         }
 
         Ok(())

komorebi/src/static_config.rs

@@ -16,7 +16,6 @@ use crate::core::BorderImplementation;
 use crate::core::StackbarLabel;
 use crate::core::StackbarMode;
 use crate::current_virtual_desktop;
-use crate::monitor;
 use crate::monitor::Monitor;
 use crate::monitor_reconciliator;
 use crate::ring::Ring;
@@ -102,26 +101,21 @@ use std::sync::Arc;
 use uds_windows::UnixListener;
 use uds_windows::UnixStream;
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct BorderColours {
     /// Border colour when the container contains a single window
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub single: Option<Colour>,
     /// Border colour when the container contains multiple windows
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub stack: Option<Colour>,
     /// Border colour when the container is in monocle mode
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub monocle: Option<Colour>,
     /// Border colour when the container is in floating mode
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub floating: Option<Colour>,
     /// Border colour when the container is unfocused
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub unfocused: Option<Colour>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 pub struct WorkspaceConfig {
     /// Name
     pub name: String,
@@ -131,7 +125,7 @@ pub struct WorkspaceConfig {
     /// END OF LIFE FEATURE: Custom Layout (default: None)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub custom_layout: Option<PathBuf>,
-    /// Layout rules in the format of threshold => layout (default: None)
+    /// Layout rules (default: None)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub layout_rules: Option<HashMap<usize, DefaultLayout>>,
     /// END OF LIFE FEATURE: Custom layout rules (default: None)
@@ -155,10 +149,8 @@ pub struct WorkspaceConfig {
     /// Determine what happens when a new window is opened (default: Create)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub window_container_behaviour: Option<WindowContainerBehaviour>,
-    /// Window container behaviour rules in the format of threshold => behaviour (default: None)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub window_container_behaviour_rules: Option<HashMap<usize, WindowContainerBehaviour>>,
-    /// Enable or disable float override, which makes it so every new window opens in floating mode (default: false)
+    /// Enable or disable float override, which makes it so every new window opens in floating mode
+    /// (default: false)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub float_override: Option<bool>,
     /// Specify an axis on which to flip the selected layout (default: None)
@@ -177,12 +169,6 @@ impl From<&Workspace> for WorkspaceConfig {
                 Layout::Custom(_) => {}
             }
         }
-        let layout_rules = (!layout_rules.is_empty()).then_some(layout_rules);
-
-        let mut window_container_behaviour_rules = HashMap::new();
-        for (threshold, behaviour) in value.window_container_behaviour_rules().iter().flatten() {
-            window_container_behaviour_rules.insert(*threshold, *behaviour);
-        }
 
         let default_container_padding = DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst);
         let default_workspace_padding = DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst);
@@ -208,42 +194,28 @@ impl From<&Workspace> for WorkspaceConfig {
                 .name()
                 .clone()
                 .unwrap_or_else(|| String::from("unnamed")),
-            layout: value
-                .tile()
-                .then_some(match value.layout() {
-                    Layout::Default(layout) => Option::from(*layout),
-                    Layout::Custom(_) => None,
-                })
-                .flatten(),
-            custom_layout: value
-                .workspace_config()
-                .as_ref()
-                .and_then(|c| c.custom_layout.clone()),
-            layout_rules,
-            custom_layout_rules: value
-                .workspace_config()
-                .as_ref()
-                .and_then(|c| c.custom_layout_rules.clone()),
+            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: value
-                .workspace_config()
-                .as_ref()
-                .and_then(|c| c.initial_workspace_rules.clone()),
-            workspace_rules: value
-                .workspace_config()
-                .as_ref()
-                .and_then(|c| c.workspace_rules.clone()),
+            initial_workspace_rules: None,
+            workspace_rules: None,
             apply_window_based_work_area_offset: Some(value.apply_window_based_work_area_offset()),
             window_container_behaviour: *value.window_container_behaviour(),
-            window_container_behaviour_rules: Option::from(window_container_behaviour_rules),
             float_override: *value.float_override(),
             layout_flip: value.layout_flip(),
         }
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 pub struct MonitorConfig {
     /// Workspace configurations
     pub workspaces: Vec<WorkspaceConfig>,
@@ -274,8 +246,8 @@ impl From<&Monitor> for MonitorConfig {
     }
 }
 
-#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema, PartialEq)]
-/// The `komorebi.json` static configuration file reference for `v0.1.35`
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+/// The `komorebi.json` static configuration file reference for `v0.1.34`
 pub struct StaticConfig {
     /// DEPRECATED from v0.1.22: no longer required
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -411,8 +383,8 @@ pub struct StaticConfig {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub slow_application_compensation_time: Option<u64>,
     /// Komorebi status bar configuration files for multiple instances on different monitors
-    // this option is a little special because it is only consumed by komorebic
     #[serde(skip_serializing_if = "Option::is_none")]
+    // this option is a little special because it is only consumed by komorebic
     pub bar_configurations: Option<Vec<PathBuf>>,
     /// HEAVILY DISCOURAGED: Identify applications for which komorebi should forcibly remove title bars
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -422,22 +394,18 @@ pub struct StaticConfig {
     pub floating_window_aspect_ratio: Option<AspectRatio>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct AnimationsConfig {
     /// Enable or disable animations (default: false)
-    pub enabled: PerAnimationPrefixConfig<bool>,
+    enabled: PerAnimationPrefixConfig<bool>,
     /// Set the animation duration in ms (default: 250)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub duration: Option<PerAnimationPrefixConfig<u64>>,
+    duration: Option<PerAnimationPrefixConfig<u64>>,
     /// Set the animation style (default: Linear)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub style: Option<PerAnimationPrefixConfig<AnimationStyle>>,
+    style: Option<PerAnimationPrefixConfig<AnimationStyle>>,
     /// Set the animation FPS (default: 60)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub fps: Option<u64>,
+    fps: Option<u64>,
 }
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(tag = "palette")]
 pub enum KomorebiTheme {
     /// A theme from catppuccin-egui
@@ -445,63 +413,45 @@ pub enum KomorebiTheme {
         /// Name of the Catppuccin theme (theme previews: https://github.com/catppuccin/catppuccin)
         name: komorebi_themes::Catppuccin,
         /// Border colour when the container contains a single window (default: Blue)
-        #[serde(skip_serializing_if = "Option::is_none")]
         single_border: Option<komorebi_themes::CatppuccinValue>,
         /// Border colour when the container contains multiple windows (default: Green)
-        #[serde(skip_serializing_if = "Option::is_none")]
         stack_border: Option<komorebi_themes::CatppuccinValue>,
         /// Border colour when the container is in monocle mode (default: Pink)
-        #[serde(skip_serializing_if = "Option::is_none")]
         monocle_border: Option<komorebi_themes::CatppuccinValue>,
         /// Border colour when the window is floating (default: Yellow)
-        #[serde(skip_serializing_if = "Option::is_none")]
         floating_border: Option<komorebi_themes::CatppuccinValue>,
         /// Border colour when the container is unfocused (default: Base)
-        #[serde(skip_serializing_if = "Option::is_none")]
         unfocused_border: Option<komorebi_themes::CatppuccinValue>,
         /// Stackbar focused tab text colour (default: Green)
-        #[serde(skip_serializing_if = "Option::is_none")]
         stackbar_focused_text: Option<komorebi_themes::CatppuccinValue>,
         /// Stackbar unfocused tab text colour (default: Text)
-        #[serde(skip_serializing_if = "Option::is_none")]
         stackbar_unfocused_text: Option<komorebi_themes::CatppuccinValue>,
         /// Stackbar tab background colour (default: Base)
-        #[serde(skip_serializing_if = "Option::is_none")]
         stackbar_background: Option<komorebi_themes::CatppuccinValue>,
         /// Komorebi status bar accent (default: Blue)
-        #[serde(skip_serializing_if = "Option::is_none")]
         bar_accent: Option<komorebi_themes::CatppuccinValue>,
     },
     /// A theme from base16-egui-themes
     Base16 {
-        /// Name of the Base16 theme (theme previews: https://tinted-theming.github.io/tinted-gallery/)
+        /// Name of the Base16 theme (theme previews: https://tinted-theming.github.io/base16-gallery)
         name: komorebi_themes::Base16,
         /// Border colour when the container contains a single window (default: Base0D)
-        #[serde(skip_serializing_if = "Option::is_none")]
         single_border: Option<komorebi_themes::Base16Value>,
         /// Border colour when the container contains multiple windows (default: Base0B)
-        #[serde(skip_serializing_if = "Option::is_none")]
         stack_border: Option<komorebi_themes::Base16Value>,
         /// Border colour when the container is in monocle mode (default: Base0F)
-        #[serde(skip_serializing_if = "Option::is_none")]
         monocle_border: Option<komorebi_themes::Base16Value>,
         /// Border colour when the window is floating (default: Base09)
-        #[serde(skip_serializing_if = "Option::is_none")]
         floating_border: Option<komorebi_themes::Base16Value>,
         /// Border colour when the container is unfocused (default: Base01)
-        #[serde(skip_serializing_if = "Option::is_none")]
         unfocused_border: Option<komorebi_themes::Base16Value>,
         /// Stackbar focused tab text colour (default: Base0B)
-        #[serde(skip_serializing_if = "Option::is_none")]
         stackbar_focused_text: Option<komorebi_themes::Base16Value>,
         /// Stackbar unfocused tab text colour (default: Base05)
-        #[serde(skip_serializing_if = "Option::is_none")]
         stackbar_unfocused_text: Option<komorebi_themes::Base16Value>,
         /// Stackbar tab background colour (default: Base01)
-        #[serde(skip_serializing_if = "Option::is_none")]
         stackbar_background: Option<komorebi_themes::Base16Value>,
         /// Komorebi status bar accent (default: Base0D)
-        #[serde(skip_serializing_if = "Option::is_none")]
         bar_accent: Option<komorebi_themes::Base16Value>,
     },
 }
@@ -587,41 +537,31 @@ impl StaticConfig {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct TabsConfig {
     /// Width of a stackbar tab
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub width: Option<i32>,
+    width: Option<i32>,
     /// Focused tab text colour
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub focused_text: Option<Colour>,
+    focused_text: Option<Colour>,
     /// Unfocused tab text colour
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub unfocused_text: Option<Colour>,
+    unfocused_text: Option<Colour>,
     /// Tab background colour
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub background: Option<Colour>,
+    background: Option<Colour>,
     /// Font family
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub font_family: Option<String>,
+    font_family: Option<String>,
     /// Font size
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub font_size: Option<i32>,
+    font_size: Option<i32>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct StackbarConfig {
     /// Stackbar height
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub height: Option<i32>,
     /// Stackbar label
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub label: Option<StackbarLabel>,
     /// Stackbar mode
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub mode: Option<StackbarMode>,
     /// Stackbar tab configuration options
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub tabs: Option<TabsConfig>,
 }
 
@@ -1179,7 +1119,6 @@ impl StaticConfig {
 
         let mut wm = WindowManager {
             monitors: Ring::default(),
-            monitor_usr_idx_map: HashMap::new(),
             incoming_events: incoming,
             command_listener: listener,
             is_paused: false,
@@ -1208,7 +1147,6 @@ impl StaticConfig {
             pending_move_op: Arc::new(None),
             already_moved_window_handles: Arc::new(Mutex::new(HashSet::new())),
             uncloack_to_ignore: 0,
-            known_hwnds: HashMap::new(),
         };
 
         match value.focus_follows_mouse {
@@ -1242,78 +1180,32 @@ impl StaticConfig {
         let value = Self::read(path)?;
         let mut wm = wm.lock();
 
-        let configs_with_preference: Vec<_> =
-            DISPLAY_INDEX_PREFERENCES.lock().keys().copied().collect();
-        let mut configs_used = Vec::new();
-
-        let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
-        workspace_matching_rules.clear();
-        drop(workspace_matching_rules);
-
-        for (i, monitor) in wm.monitors_mut().iter_mut().enumerate() {
-            let preferred_config_idx = {
-                let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
-                let c_idx = display_index_preferences.iter().find_map(|(c_idx, id)| {
-                    (monitor
-                        .serial_number_id()
-                        .as_ref()
-                        .is_some_and(|sn| sn == id)
-                        || monitor.device_id() == id)
-                        .then_some(*c_idx)
-                });
-                c_idx
-            };
-            let idx = preferred_config_idx.or({
-                // Monitor without preferred config idx.
-                // Get index of first config that is not a preferred config of some other monitor
-                // and that has not been used yet. This might return `None` as well, in that case
-                // this monitor won't have a config tied to it and will use the default values.
-                let m_config_count = value
-                    .monitors
-                    .as_ref()
-                    .map(|ms| ms.len())
-                    .unwrap_or_default();
-                (0..m_config_count)
-                    .find(|i| !configs_with_preference.contains(i) && !configs_used.contains(i))
-            });
-            if let Some(monitor_config) = value
-                .monitors
-                .as_ref()
-                .and_then(|ms| idx.and_then(|i| ms.get(i)))
-            {
-                if let Some(used_config_idx) = idx {
-                    configs_used.push(used_config_idx);
-                }
-
-                monitor.ensure_workspace_count(monitor_config.workspaces.len());
-                monitor.set_work_area_offset(monitor_config.work_area_offset);
-                monitor.set_window_based_work_area_offset(
-                    monitor_config.window_based_work_area_offset,
-                );
-                monitor.set_window_based_work_area_offset_limit(
-                    monitor_config
-                        .window_based_work_area_offset_limit
-                        .unwrap_or(1),
-                );
-
-                for (j, ws) in monitor.workspaces_mut().iter_mut().enumerate() {
-                    if let Some(workspace_config) = monitor_config.workspaces.get(j) {
-                        ws.load_static_config(workspace_config)?;
+        if let Some(monitors) = value.monitors {
+            for (i, monitor) in monitors.iter().enumerate() {
+                {
+                    let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
+                    if let Some(device_id) = display_index_preferences.get(&i) {
+                        monitor_reconciliator::insert_in_monitor_cache(device_id, monitor.clone());
                     }
                 }
 
-                // Check if this monitor config is the preferred config for this monitor and store
-                // a copy of the monitor itself on the monitor cache if it is.
-                if idx == preferred_config_idx {
-                    let id = monitor
-                        .serial_number_id()
-                        .as_ref()
-                        .map_or(monitor.device_id(), |sn| sn);
-                    monitor_reconciliator::insert_in_monitor_cache(id, monitor.clone());
+                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);
+                    m.set_window_based_work_area_offset(monitor.window_based_work_area_offset);
+                    m.set_window_based_work_area_offset_limit(
+                        monitor.window_based_work_area_offset_limit.unwrap_or(1),
+                    );
+
+                    for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
+                        if let Some(workspace_config) = monitor.workspaces.get(j) {
+                            ws.load_static_config(workspace_config)?;
+                        }
+                    }
                 }
 
                 let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
-                for (j, ws) in monitor_config.workspaces.iter().enumerate() {
+                for (j, ws) in monitor.workspaces.iter().enumerate() {
                     if let Some(rules) = &ws.workspace_rules {
                         for r in rules {
                             workspace_matching_rules.push(WorkspaceMatchingRule {
@@ -1339,56 +1231,6 @@ impl StaticConfig {
             }
         }
 
-        // Check for configs that should be tied to a specific display that isn't loaded right now
-        // and cache a monitor with those configs with the specific `serial_number_id` so that when
-        // those devices are connected later we can use the correct config from the cache.
-        if configs_with_preference.len() > configs_used.len() {
-            for i in configs_with_preference
-                .iter()
-                .filter(|i| !configs_used.contains(i))
-            {
-                let id = {
-                    let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
-                    display_index_preferences.get(i).cloned()
-                };
-                if let (Some(id), Some(monitor_config)) =
-                    (id, value.monitors.as_ref().and_then(|ms| ms.get(*i)))
-                {
-                    // The name, device, device_id and serial_number_id can be empty here since
-                    // once the monitor with this preferred index actually connects the
-                    // `load_monitor_information` function will update these fields.
-                    let mut m = monitor::new(
-                        0,
-                        Rect::default(),
-                        Rect::default(),
-                        "".into(),
-                        "".into(),
-                        "".into(),
-                        None,
-                    );
-
-                    m.ensure_workspace_count(monitor_config.workspaces.len());
-                    m.set_work_area_offset(monitor_config.work_area_offset);
-                    m.set_window_based_work_area_offset(
-                        monitor_config.window_based_work_area_offset,
-                    );
-                    m.set_window_based_work_area_offset_limit(
-                        monitor_config
-                            .window_based_work_area_offset_limit
-                            .unwrap_or(1),
-                    );
-
-                    for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
-                        if let Some(workspace_config) = monitor_config.workspaces.get(j) {
-                            ws.load_static_config(workspace_config)?;
-                        }
-                    }
-
-                    monitor_reconciliator::insert_in_monitor_cache(&id, m);
-                }
-            }
-        }
-
         wm.enforce_workspace_rules()?;
 
         if value.border == Some(true) {
@@ -1403,80 +1245,29 @@ impl StaticConfig {
 
         value.apply_globals()?;
 
-        let configs_with_preference: Vec<_> =
-            DISPLAY_INDEX_PREFERENCES.lock().keys().copied().collect();
-        let mut configs_used = Vec::new();
+        if let Some(monitors) = value.monitors {
+            let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
+            workspace_matching_rules.clear();
 
-        let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
-        workspace_matching_rules.clear();
-        drop(workspace_matching_rules);
+            for (i, monitor) in monitors.iter().enumerate() {
+                if let Some(m) = wm.monitors_mut().get_mut(i) {
+                    m.ensure_workspace_count(monitor.workspaces.len());
+                    if m.work_area_offset().is_none() {
+                        m.set_work_area_offset(monitor.work_area_offset);
+                    }
+                    m.set_window_based_work_area_offset(monitor.window_based_work_area_offset);
+                    m.set_window_based_work_area_offset_limit(
+                        monitor.window_based_work_area_offset_limit.unwrap_or(1),
+                    );
 
-        for (i, monitor) in wm.monitors_mut().iter_mut().enumerate() {
-            let preferred_config_idx = {
-                let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
-                let c_idx = display_index_preferences.iter().find_map(|(c_idx, id)| {
-                    (monitor
-                        .serial_number_id()
-                        .as_ref()
-                        .is_some_and(|sn| sn == id)
-                        || monitor.device_id() == id)
-                        .then_some(*c_idx)
-                });
-                c_idx
-            };
-            let idx = preferred_config_idx.or({
-                // Monitor without preferred config idx.
-                // Get index of first config that is not a preferred config of some other monitor
-                // and that has not been used yet. This might return `None` as well, in that case
-                // this monitor won't have a config tied to it and will use the default values.
-                let m_config_count = value
-                    .monitors
-                    .as_ref()
-                    .map(|ms| ms.len())
-                    .unwrap_or_default();
-                (0..m_config_count)
-                    .find(|i| !configs_with_preference.contains(i) && !configs_used.contains(i))
-            });
-            if let Some(monitor_config) = value
-                .monitors
-                .as_ref()
-                .and_then(|ms| idx.and_then(|i| ms.get(i)))
-            {
-                if let Some(used_config_idx) = idx {
-                    configs_used.push(used_config_idx);
-                }
-
-                monitor.ensure_workspace_count(monitor_config.workspaces.len());
-                if monitor.work_area_offset().is_none() {
-                    monitor.set_work_area_offset(monitor_config.work_area_offset);
-                }
-                monitor.set_window_based_work_area_offset(
-                    monitor_config.window_based_work_area_offset,
-                );
-                monitor.set_window_based_work_area_offset_limit(
-                    monitor_config
-                        .window_based_work_area_offset_limit
-                        .unwrap_or(1),
-                );
-
-                for (j, ws) in monitor.workspaces_mut().iter_mut().enumerate() {
-                    if let Some(workspace_config) = monitor_config.workspaces.get(j) {
-                        ws.load_static_config(workspace_config)?;
+                    for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
+                        if let Some(workspace_config) = monitor.workspaces.get(j) {
+                            ws.load_static_config(workspace_config)?;
+                        }
                     }
                 }
 
-                // Check if this monitor config is the preferred config for this monitor and store
-                // a copy of the monitor itself on the monitor cache if it is.
-                if idx == preferred_config_idx {
-                    let id = monitor
-                        .serial_number_id()
-                        .as_ref()
-                        .map_or(monitor.device_id(), |sn| sn);
-                    monitor_reconciliator::insert_in_monitor_cache(id, monitor.clone());
-                }
-
-                let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
-                for (j, ws) in monitor_config.workspaces.iter().enumerate() {
+                for (j, ws) in monitor.workspaces.iter().enumerate() {
                     if let Some(rules) = &ws.workspace_rules {
                         for r in rules {
                             workspace_matching_rules.push(WorkspaceMatchingRule {
@@ -1502,56 +1293,6 @@ impl StaticConfig {
             }
         }
 
-        // Check for configs that should be tied to a specific display that isn't loaded right now
-        // and cache a monitor with those configs with the specific `serial_number_id` so that when
-        // those devices are connected later we can use the correct config from the cache.
-        if configs_with_preference.len() > configs_used.len() {
-            for i in configs_with_preference
-                .iter()
-                .filter(|i| !configs_used.contains(i))
-            {
-                let id = {
-                    let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
-                    display_index_preferences.get(i).cloned()
-                };
-                if let (Some(id), Some(monitor_config)) =
-                    (id, value.monitors.as_ref().and_then(|ms| ms.get(*i)))
-                {
-                    // The name, device, device_id and serial_number_id can be empty here since
-                    // once the monitor with this preferred index actually connects the
-                    // `load_monitor_information` function will update these fields.
-                    let mut m = monitor::new(
-                        0,
-                        Rect::default(),
-                        Rect::default(),
-                        "".into(),
-                        "".into(),
-                        "".into(),
-                        None,
-                    );
-
-                    m.ensure_workspace_count(monitor_config.workspaces.len());
-                    m.set_work_area_offset(monitor_config.work_area_offset);
-                    m.set_window_based_work_area_offset(
-                        monitor_config.window_based_work_area_offset,
-                    );
-                    m.set_window_based_work_area_offset_limit(
-                        monitor_config
-                            .window_based_work_area_offset_limit
-                            .unwrap_or(1),
-                    );
-
-                    for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
-                        if let Some(workspace_config) = monitor_config.workspaces.get(j) {
-                            ws.load_static_config(workspace_config)?;
-                        }
-                    }
-
-                    monitor_reconciliator::insert_in_monitor_cache(&id, m);
-                }
-            }
-        }
-
         wm.enforce_workspace_rules()?;
 
         if let Some(enabled) = value.border {

komorebi/src/window.rs

@@ -40,8 +40,6 @@ use serde::ser::SerializeStruct;
 use serde::Deserialize;
 use serde::Serialize;
 use serde::Serializer;
-use strum::Display;
-use strum::EnumString;
 use windows::Win32::Foundation::HWND;
 
 use crate::core::ApplicationIdentifier;
@@ -299,9 +297,7 @@ impl RenderDispatcher for TransparencyRenderDispatcher {
     }
 }
 
-#[derive(
-    Copy, Clone, Debug, Display, EnumString, Serialize, Deserialize, JsonSchema, PartialEq,
-)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(untagged)]
 pub enum AspectRatio {
     /// A predefined aspect ratio
@@ -310,22 +306,13 @@ pub enum AspectRatio {
     Custom(i32, i32),
 }
 
-impl Default for AspectRatio {
-    fn default() -> Self {
-        AspectRatio::Predefined(PredefinedAspectRatio::default())
-    }
-}
-
-#[derive(
-    Copy, Clone, Debug, Default, Display, EnumString, Serialize, Deserialize, JsonSchema, PartialEq,
-)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub enum PredefinedAspectRatio {
     /// 21:9
     Ultrawide,
     /// 16:9
     Widescreen,
     /// 4:3
-    #[default]
     Standard,
 }
 

komorebi/src/window_manager.rs

@@ -2,7 +2,6 @@ use std::collections::HashMap;
 use std::collections::HashSet;
 use std::collections::VecDeque;
 use std::env::temp_dir;
-use std::fs::OpenOptions;
 use std::io::ErrorKind;
 use std::net::Shutdown;
 use std::num::NonZeroUsize;
@@ -49,8 +48,6 @@ use crate::core::WindowContainerBehaviour;
 use crate::core::WindowManagementBehaviour;
 
 use crate::border_manager;
-use crate::border_manager::BORDER_OFFSET;
-use crate::border_manager::BORDER_WIDTH;
 use crate::border_manager::STYLE;
 use crate::config_generation::WorkspaceMatchingRule;
 use crate::container::Container;
@@ -77,7 +74,6 @@ use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::winevent_listener;
 use crate::workspace::Workspace;
-use crate::workspace::WorkspaceLayer;
 use crate::BorderColours;
 use crate::Colour;
 use crate::CrossBoundaryBehaviour;
@@ -103,7 +99,6 @@ use crate::WORKSPACE_MATCHING_RULES;
 #[derive(Debug)]
 pub struct WindowManager {
     pub monitors: Ring<Monitor>,
-    pub monitor_usr_idx_map: HashMap<usize, usize>,
     pub incoming_events: Receiver<WindowManagerEvent>,
     pub command_listener: UnixListener,
     pub is_paused: bool,
@@ -121,15 +116,12 @@ pub struct WindowManager {
     pub pending_move_op: Arc<Option<(usize, usize, isize)>>,
     pub already_moved_window_handles: Arc<Mutex<HashSet<isize>>>,
     pub uncloack_to_ignore: usize,
-    /// Maps each known window hwnd to the (monitor, workspace) index pair managing it
-    pub known_hwnds: HashMap<isize, (usize, usize)>,
 }
 
 #[allow(clippy::struct_excessive_bools)]
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct State {
     pub monitors: Ring<Monitor>,
-    pub monitor_usr_idx_map: HashMap<usize, usize>,
     pub is_paused: bool,
     pub resize_delta: i32,
     pub new_window_behaviour: WindowContainerBehaviour,
@@ -289,69 +281,8 @@ impl AsRef<Self> for WindowManager {
 
 impl From<&WindowManager> for State {
     fn from(wm: &WindowManager) -> Self {
-        // This is used to remove any information that doesn't need to be passed on to subscribers
-        // or to be shown with the `komorebic state` command. Currently it is only removing the
-        // `workspace_config` field from every workspace, but more stripping can be added later if
-        // needed.
-        let mut stripped_monitors = Ring::default();
-        *stripped_monitors.elements_mut() = wm
-            .monitors()
-            .iter()
-            .map(|monitor| Monitor {
-                id: monitor.id,
-                name: monitor.name.clone(),
-                device: monitor.device.clone(),
-                device_id: monitor.device_id.clone(),
-                serial_number_id: monitor.serial_number_id.clone(),
-                size: monitor.size,
-                work_area_size: monitor.work_area_size,
-                work_area_offset: monitor.work_area_offset,
-                window_based_work_area_offset: monitor.window_based_work_area_offset,
-                window_based_work_area_offset_limit: monitor.window_based_work_area_offset_limit,
-                workspaces: {
-                    let mut ws = Ring::default();
-                    *ws.elements_mut() = monitor
-                        .workspaces()
-                        .iter()
-                        .map(|workspace| Workspace {
-                            name: workspace.name.clone(),
-                            containers: workspace.containers.clone(),
-                            monocle_container: workspace.monocle_container.clone(),
-                            monocle_container_restore_idx: workspace.monocle_container_restore_idx,
-                            maximized_window: workspace.maximized_window,
-                            maximized_window_restore_idx: workspace.maximized_window_restore_idx,
-                            floating_windows: workspace.floating_windows.clone(),
-                            layout: workspace.layout.clone(),
-                            layout_rules: workspace.layout_rules.clone(),
-                            layout_flip: workspace.layout_flip,
-                            workspace_padding: workspace.workspace_padding,
-                            container_padding: workspace.container_padding,
-                            latest_layout: workspace.latest_layout.clone(),
-                            resize_dimensions: workspace.resize_dimensions.clone(),
-                            tile: workspace.tile,
-                            apply_window_based_work_area_offset: workspace
-                                .apply_window_based_work_area_offset,
-                            window_container_behaviour: workspace.window_container_behaviour,
-                            window_container_behaviour_rules: workspace
-                                .window_container_behaviour_rules
-                                .clone(),
-                            float_override: workspace.float_override,
-                            layer: workspace.layer,
-                            workspace_config: None,
-                        })
-                        .collect::<VecDeque<_>>();
-                    ws.focus(monitor.workspaces.focused_idx());
-                    ws
-                },
-                last_focused_workspace: monitor.last_focused_workspace,
-                workspace_names: monitor.workspace_names.clone(),
-            })
-            .collect::<VecDeque<_>>();
-        stripped_monitors.focus(wm.monitors.focused_idx());
-
         Self {
-            monitors: stripped_monitors,
-            monitor_usr_idx_map: wm.monitor_usr_idx_map.clone(),
+            monitors: wm.monitors.clone(),
             is_paused: wm.is_paused,
             work_area_offset: wm.work_area_offset,
             resize_delta: wm.resize_delta,
@@ -412,7 +343,6 @@ impl WindowManager {
 
         Ok(Self {
             monitors: Ring::default(),
-            monitor_usr_idx_map: HashMap::new(),
             incoming_events: incoming,
             command_listener: listener,
             is_paused: false,
@@ -430,14 +360,13 @@ impl WindowManager {
             pending_move_op: Arc::new(None),
             already_moved_window_handles: Arc::new(Mutex::new(HashSet::new())),
             uncloack_to_ignore: 0,
-            known_hwnds: HashMap::new(),
         })
     }
 
     #[tracing::instrument(skip(self))]
     pub fn init(&mut self) -> Result<()> {
         tracing::info!("initialising");
-        WindowsApi::load_monitor_information(self)?;
+        WindowsApi::load_monitor_information(&mut self.monitors)?;
         WindowsApi::load_workspace_information(&mut self.monitors)
     }
 
@@ -1396,168 +1325,86 @@ impl WindowManager {
         delta: i32,
         update: bool,
     ) -> Result<()> {
-        let mouse_follows_focus = self.mouse_follows_focus;
-        let mut focused_monitor_work_area = self.focused_monitor_work_area()?;
+        let work_area = self.focused_monitor_work_area()?;
         let workspace = self.focused_workspace_mut()?;
 
-        match workspace.layer() {
-            WorkspaceLayer::Floating => {
-                let workspace = self.focused_workspace()?;
-                let focused_hwnd = WindowsApi::foreground_window()?;
+        match workspace.layout() {
+            Layout::Default(layout) => {
+                tracing::info!("resizing window");
+                let len = NonZeroUsize::new(workspace.containers().len())
+                    .ok_or_else(|| anyhow!("there must be at least one container"))?;
+                let focused_idx = workspace.focused_container_idx();
+                let focused_idx_resize = workspace
+                    .resize_dimensions()
+                    .get(focused_idx)
+                    .ok_or_else(|| anyhow!("there is no resize adjustment for this container"))?;
 
-                let border_offset = BORDER_OFFSET.load(Ordering::SeqCst);
-                let border_width = BORDER_WIDTH.load(Ordering::SeqCst);
-                focused_monitor_work_area.left += border_offset;
-                focused_monitor_work_area.left += border_width;
-                focused_monitor_work_area.top += border_offset;
-                focused_monitor_work_area.top += border_width;
-                focused_monitor_work_area.right -= border_offset;
-                focused_monitor_work_area.right -= border_width;
-                focused_monitor_work_area.bottom -= border_offset;
-                focused_monitor_work_area.bottom -= border_width;
+                if direction
+                    .destination(
+                        workspace.layout().as_boxed_direction().as_ref(),
+                        workspace.layout_flip(),
+                        focused_idx,
+                        len,
+                    )
+                    .is_some()
+                {
+                    let unaltered = layout.calculate(
+                        &work_area,
+                        len,
+                        workspace.container_padding(),
+                        workspace.layout_flip(),
+                        &[],
+                    );
 
-                for window in workspace.floating_windows().iter() {
-                    if window.hwnd == focused_hwnd {
-                        let mut rect = WindowsApi::window_rect(window.hwnd)?;
-                        match (direction, sizing) {
-                            (OperationDirection::Left, Sizing::Increase) => {
-                                if rect.left - delta < focused_monitor_work_area.left {
-                                    rect.left = focused_monitor_work_area.left;
-                                } else {
-                                    rect.left -= delta;
-                                }
-                            }
-                            (OperationDirection::Left, Sizing::Decrease) => {
-                                rect.left += delta;
-                            }
-                            (OperationDirection::Right, Sizing::Increase) => {
-                                if rect.left + rect.right + delta * 2
-                                    > focused_monitor_work_area.right
+                    let mut direction = direction;
+
+                    // We only ever want to operate on the unflipped Rect positions when resizing, then we
+                    // can flip them however they need to be flipped once the resizing has been done
+                    if let Some(flip) = workspace.layout_flip() {
+                        match flip {
+                            Axis::Horizontal => {
+                                if matches!(direction, OperationDirection::Left)
+                                    || matches!(direction, OperationDirection::Right)
                                 {
-                                    rect.right = focused_monitor_work_area.right - rect.left;
-                                } else {
-                                    rect.right += delta * 2;
+                                    direction = direction.opposite();
                                 }
                             }
-                            (OperationDirection::Right, Sizing::Decrease) => {
-                                rect.right -= delta * 2;
-                            }
-                            (OperationDirection::Up, Sizing::Increase) => {
-                                if rect.top - delta < focused_monitor_work_area.top {
-                                    rect.top = focused_monitor_work_area.top;
-                                } else {
-                                    rect.top -= delta;
-                                }
-                            }
-                            (OperationDirection::Up, Sizing::Decrease) => {
-                                rect.top += delta;
-                            }
-                            (OperationDirection::Down, Sizing::Increase) => {
-                                if rect.top + rect.bottom + delta * 2
-                                    > focused_monitor_work_area.bottom
+                            Axis::Vertical => {
+                                if matches!(direction, OperationDirection::Up)
+                                    || matches!(direction, OperationDirection::Down)
                                 {
-                                    rect.bottom = focused_monitor_work_area.bottom - rect.top;
-                                } else {
-                                    rect.bottom += delta * 2;
+                                    direction = direction.opposite();
                                 }
                             }
-                            (OperationDirection::Down, Sizing::Decrease) => {
-                                rect.bottom -= delta * 2;
-                            }
+                            Axis::HorizontalAndVertical => direction = direction.opposite(),
                         }
-
-                        WindowsApi::position_window(window.hwnd, &rect, false)?;
-                        if mouse_follows_focus {
-                            WindowsApi::center_cursor_in_rect(&rect)?;
-                        }
-
-                        break;
                     }
-                }
-            }
-            WorkspaceLayer::Tiling => {
-                match workspace.layout() {
-                    Layout::Default(layout) => {
-                        tracing::info!("resizing window");
-                        let len = NonZeroUsize::new(workspace.containers().len())
-                            .ok_or_else(|| anyhow!("there must be at least one container"))?;
-                        let focused_idx = workspace.focused_container_idx();
-                        let focused_idx_resize = workspace
-                            .resize_dimensions()
+
+                    let resize = layout.resize(
+                        unaltered
                             .get(focused_idx)
-                            .ok_or_else(|| {
-                                anyhow!("there is no resize adjustment for this container")
-                            })?;
+                            .ok_or_else(|| anyhow!("there is no last layout"))?,
+                        focused_idx_resize,
+                        direction,
+                        sizing,
+                        delta,
+                    );
 
-                        if direction
-                            .destination(
-                                workspace.layout().as_boxed_direction().as_ref(),
-                                workspace.layout_flip(),
-                                focused_idx,
-                                len,
-                            )
-                            .is_some()
-                        {
-                            let unaltered = layout.calculate(
-                                &focused_monitor_work_area,
-                                len,
-                                workspace.container_padding(),
-                                workspace.layout_flip(),
-                                &[],
-                            );
+                    workspace.resize_dimensions_mut()[focused_idx] = resize;
 
-                            let mut direction = direction;
-
-                            // We only ever want to operate on the unflipped Rect positions when resizing, then we
-                            // can flip them however they need to be flipped once the resizing has been done
-                            if let Some(flip) = workspace.layout_flip() {
-                                match flip {
-                                    Axis::Horizontal => {
-                                        if matches!(direction, OperationDirection::Left)
-                                            || matches!(direction, OperationDirection::Right)
-                                        {
-                                            direction = direction.opposite();
-                                        }
-                                    }
-                                    Axis::Vertical => {
-                                        if matches!(direction, OperationDirection::Up)
-                                            || matches!(direction, OperationDirection::Down)
-                                        {
-                                            direction = direction.opposite();
-                                        }
-                                    }
-                                    Axis::HorizontalAndVertical => direction = direction.opposite(),
-                                }
-                            }
-
-                            let resize = layout.resize(
-                                unaltered
-                                    .get(focused_idx)
-                                    .ok_or_else(|| anyhow!("there is no last layout"))?,
-                                focused_idx_resize,
-                                direction,
-                                sizing,
-                                delta,
-                            );
-
-                            workspace.resize_dimensions_mut()[focused_idx] = resize;
-
-                            return if update {
-                                self.update_focused_workspace(false, false)
-                            } else {
-                                Ok(())
-                            };
-                        }
-
-                        tracing::warn!("cannot resize container in this direction");
-                    }
-                    Layout::Custom(_) => {
-                        tracing::warn!("containers cannot be resized when using custom layouts");
-                    }
+                    return if update {
+                        self.update_focused_workspace(false, false)
+                    } else {
+                        Ok(())
+                    };
                 }
+
+                tracing::warn!("cannot resize container in this direction");
+            }
+            Layout::Custom(_) => {
+                tracing::warn!("containers cannot be resized when using custom layouts");
             }
         }
-
         Ok(())
     }
 
@@ -1946,56 +1793,6 @@ impl WindowManager {
         self.update_focused_workspace(mouse_follows_focus, true)
     }
 
-    #[tracing::instrument(skip(self))]
-    pub fn focus_floating_window_in_direction(
-        &mut self,
-        direction: OperationDirection,
-    ) -> Result<()> {
-        let mouse_follows_focus = self.mouse_follows_focus;
-        let focused_workspace = self.focused_workspace()?;
-
-        let mut target_idx = None;
-        let len = focused_workspace.floating_windows().len();
-
-        if len > 1 {
-            let focused_hwnd = WindowsApi::foreground_window()?;
-            for (idx, window) in focused_workspace.floating_windows().iter().enumerate() {
-                if window.hwnd == focused_hwnd {
-                    match direction {
-                        OperationDirection::Left => {}
-                        OperationDirection::Right => {}
-                        OperationDirection::Up => {
-                            if idx == len - 1 {
-                                target_idx = Some(0)
-                            } else {
-                                target_idx = Some(idx + 1)
-                            }
-                        }
-                        OperationDirection::Down => {
-                            if idx == 0 {
-                                target_idx = Some(len - 1)
-                            } else {
-                                target_idx = Some(idx - 1)
-                            }
-                        }
-                    }
-                }
-            }
-
-            if target_idx.is_none() {
-                target_idx = Some(0);
-            }
-        }
-
-        if let Some(idx) = target_idx {
-            if let Some(window) = focused_workspace.floating_windows().get(idx) {
-                window.focus(mouse_follows_focus)?;
-            }
-        }
-
-        Ok(())
-    }
-
     #[tracing::instrument(skip(self))]
     pub fn focus_container_in_direction(&mut self, direction: OperationDirection) -> Result<()> {
         self.handle_unmanaged_window_behaviour()?;
@@ -2141,75 +1938,6 @@ impl WindowManager {
         Ok(())
     }
 
-    #[tracing::instrument(skip(self))]
-    pub fn move_floating_window_in_direction(
-        &mut self,
-        direction: OperationDirection,
-    ) -> Result<()> {
-        let mouse_follows_focus = self.mouse_follows_focus;
-
-        let mut focused_monitor_work_area = self.focused_monitor_work_area()?;
-        let border_offset = BORDER_OFFSET.load(Ordering::SeqCst);
-        let border_width = BORDER_WIDTH.load(Ordering::SeqCst);
-        focused_monitor_work_area.left += border_offset;
-        focused_monitor_work_area.left += border_width;
-        focused_monitor_work_area.top += border_offset;
-        focused_monitor_work_area.top += border_width;
-        focused_monitor_work_area.right -= border_offset;
-        focused_monitor_work_area.right -= border_width;
-        focused_monitor_work_area.bottom -= border_offset;
-        focused_monitor_work_area.bottom -= border_width;
-
-        let focused_workspace = self.focused_workspace()?;
-        let delta = self.resize_delta;
-
-        let focused_hwnd = WindowsApi::foreground_window()?;
-        for window in focused_workspace.floating_windows().iter() {
-            if window.hwnd == focused_hwnd {
-                let mut rect = WindowsApi::window_rect(window.hwnd)?;
-                match direction {
-                    OperationDirection::Left => {
-                        if rect.left - delta < focused_monitor_work_area.left {
-                            rect.left = focused_monitor_work_area.left;
-                        } else {
-                            rect.left -= delta;
-                        }
-                    }
-                    OperationDirection::Right => {
-                        if rect.left + delta + rect.right > focused_monitor_work_area.right {
-                            rect.left = focused_monitor_work_area.right - rect.right;
-                        } else {
-                            rect.left += delta;
-                        }
-                    }
-                    OperationDirection::Up => {
-                        if rect.top - delta < focused_monitor_work_area.top {
-                            rect.top = focused_monitor_work_area.top;
-                        } else {
-                            rect.top -= delta;
-                        }
-                    }
-                    OperationDirection::Down => {
-                        if rect.top + delta + rect.bottom > focused_monitor_work_area.bottom {
-                            rect.top = focused_monitor_work_area.bottom - rect.bottom;
-                        } else {
-                            rect.top += delta;
-                        }
-                    }
-                }
-
-                WindowsApi::position_window(window.hwnd, &rect, false)?;
-                if mouse_follows_focus {
-                    WindowsApi::center_cursor_in_rect(&rect)?;
-                }
-
-                break;
-            }
-        }
-
-        Ok(())
-    }
-
     #[tracing::instrument(skip(self))]
     pub fn move_container_in_direction(&mut self, direction: OperationDirection) -> Result<()> {
         self.handle_unmanaged_window_behaviour()?;
@@ -2386,54 +2114,6 @@ impl WindowManager {
         Ok(())
     }
 
-    #[tracing::instrument(skip(self))]
-    pub fn focus_floating_window_in_cycle_direction(
-        &mut self,
-        direction: CycleDirection,
-    ) -> Result<()> {
-        let mouse_follows_focus = self.mouse_follows_focus;
-        let focused_workspace = self.focused_workspace()?;
-
-        let mut target_idx = None;
-        let len = focused_workspace.floating_windows().len();
-
-        if len > 1 {
-            let focused_hwnd = WindowsApi::foreground_window()?;
-            for (idx, window) in focused_workspace.floating_windows().iter().enumerate() {
-                if window.hwnd == focused_hwnd {
-                    match direction {
-                        CycleDirection::Previous => {
-                            if idx == 0 {
-                                target_idx = Some(len - 1)
-                            } else {
-                                target_idx = Some(idx - 1)
-                            }
-                        }
-                        CycleDirection::Next => {
-                            if idx == len - 1 {
-                                target_idx = Some(0)
-                            } else {
-                                target_idx = Some(idx - 1)
-                            }
-                        }
-                    }
-                }
-            }
-
-            if target_idx.is_none() {
-                target_idx = Some(0);
-            }
-        }
-
-        if let Some(idx) = target_idx {
-            if let Some(window) = focused_workspace.floating_windows().get(idx) {
-                window.focus(mouse_follows_focus)?;
-            }
-        }
-
-        Ok(())
-    }
-
     #[tracing::instrument(skip(self))]
     pub fn focus_container_in_cycle_direction(&mut self, direction: CycleDirection) -> Result<()> {
         self.handle_unmanaged_window_behaviour()?;
@@ -3616,66 +3296,4 @@ impl WindowManager {
             .focused_window_mut()
             .ok_or_else(|| anyhow!("there is no window"))
     }
-
-    /// Updates the list of `known_hwnds` and their monitor/workspace index pair
-    ///
-    /// [`known_hwnds`]: `Self.known_hwnds`
-    pub fn update_known_hwnds(&mut self) {
-        tracing::trace!("updating list of known hwnds");
-        let mut known_hwnds = HashMap::new();
-        for (m_idx, monitor) in self.monitors().iter().enumerate() {
-            for (w_idx, workspace) in monitor.workspaces().iter().enumerate() {
-                for container in workspace.containers() {
-                    for window in container.windows() {
-                        known_hwnds.insert(window.hwnd, (m_idx, w_idx));
-                    }
-                }
-
-                for window in workspace.floating_windows() {
-                    known_hwnds.insert(window.hwnd, (m_idx, w_idx));
-                }
-
-                if let Some(window) = workspace.maximized_window() {
-                    known_hwnds.insert(window.hwnd, (m_idx, w_idx));
-                }
-
-                if let Some(container) = workspace.monocle_container() {
-                    for window in container.windows() {
-                        known_hwnds.insert(window.hwnd, (m_idx, w_idx));
-                    }
-                }
-            }
-        }
-
-        if self.known_hwnds != known_hwnds {
-            // Update reaper cache
-            {
-                let mut reaper_cache = crate::reaper::HWNDS_CACHE.lock();
-                *reaper_cache = known_hwnds.clone();
-            }
-
-            // Save to file
-            let hwnd_json = DATA_DIR.join("komorebi.hwnd.json");
-            match OpenOptions::new()
-                .write(true)
-                .truncate(true)
-                .create(true)
-                .open(hwnd_json)
-            {
-                Ok(file) => {
-                    if let Err(error) =
-                        serde_json::to_writer_pretty(&file, &known_hwnds.keys().collect::<Vec<_>>())
-                    {
-                        tracing::error!("Failed to save list of known_hwnds on file: {}", error);
-                    }
-                }
-                Err(error) => {
-                    tracing::error!("Failed to save list of known_hwnds on file: {}", error);
-                }
-            }
-
-            // Store new hwnds
-            self.known_hwnds = known_hwnds;
-        }
-    }
 }

komorebi/src/windows_api.rs

@@ -1,7 +1,6 @@
-use core::ffi::c_void;
-use std::collections::HashMap;
 use std::collections::VecDeque;
 use std::convert::TryFrom;
+use std::ffi::c_void;
 use std::mem::size_of;
 
 use color_eyre::eyre::anyhow;
@@ -12,6 +11,7 @@ use windows::core::Result as WindowsCrateResult;
 use windows::core::PCWSTR;
 use windows::core::PWSTR;
 use windows::Win32::Foundation::CloseHandle;
+use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::COLORREF;
 use windows::Win32::Foundation::HANDLE;
 use windows::Win32::Foundation::HINSTANCE;
@@ -48,8 +48,6 @@ use windows::Win32::Graphics::Gdi::MONITORENUMPROC;
 use windows::Win32::Graphics::Gdi::MONITORINFOEXW;
 use windows::Win32::Graphics::Gdi::MONITOR_DEFAULTTONEAREST;
 use windows::Win32::System::LibraryLoader::GetModuleHandleW;
-use windows::Win32::System::Power::RegisterPowerSettingNotification;
-use windows::Win32::System::Power::HPOWERNOTIFY;
 use windows::Win32::System::RemoteDesktop::ProcessIdToSessionId;
 use windows::Win32::System::RemoteDesktop::WTSRegisterSessionNotification;
 use windows::Win32::System::Threading::GetCurrentProcessId;
@@ -94,7 +92,6 @@ use windows::Win32::UI::WindowsAndMessaging::MoveWindow;
 use windows::Win32::UI::WindowsAndMessaging::PostMessageW;
 use windows::Win32::UI::WindowsAndMessaging::RealGetWindowClassW;
 use windows::Win32::UI::WindowsAndMessaging::RegisterClassW;
-use windows::Win32::UI::WindowsAndMessaging::RegisterDeviceNotificationW;
 use windows::Win32::UI::WindowsAndMessaging::SetCursorPos;
 use windows::Win32::UI::WindowsAndMessaging::SetForegroundWindow;
 use windows::Win32::UI::WindowsAndMessaging::SetLayeredWindowAttributes;
@@ -104,14 +101,11 @@ use windows::Win32::UI::WindowsAndMessaging::ShowWindow;
 use windows::Win32::UI::WindowsAndMessaging::SystemParametersInfoW;
 use windows::Win32::UI::WindowsAndMessaging::WindowFromPoint;
 use windows::Win32::UI::WindowsAndMessaging::CW_USEDEFAULT;
-use windows::Win32::UI::WindowsAndMessaging::DEV_BROADCAST_DEVICEINTERFACE_W;
 use windows::Win32::UI::WindowsAndMessaging::GWL_EXSTYLE;
 use windows::Win32::UI::WindowsAndMessaging::GWL_STYLE;
 use windows::Win32::UI::WindowsAndMessaging::GW_HWNDNEXT;
-use windows::Win32::UI::WindowsAndMessaging::HDEVNOTIFY;
 use windows::Win32::UI::WindowsAndMessaging::HWND_TOP;
 use windows::Win32::UI::WindowsAndMessaging::LWA_ALPHA;
-use windows::Win32::UI::WindowsAndMessaging::REGISTER_NOTIFICATION_FLAGS;
 use windows::Win32::UI::WindowsAndMessaging::SET_WINDOW_POS_FLAGS;
 use windows::Win32::UI::WindowsAndMessaging::SHOW_WINDOW_CMD;
 use windows::Win32::UI::WindowsAndMessaging::SPIF_SENDCHANGE;
@@ -139,7 +133,6 @@ use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOOLWINDOW;
 use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOPMOST;
 use windows::Win32::UI::WindowsAndMessaging::WS_POPUP;
 use windows::Win32::UI::WindowsAndMessaging::WS_SYSMENU;
-use windows_core::BOOL;
 
 use crate::core::Rect;
 
@@ -150,7 +143,6 @@ use crate::ring::Ring;
 use crate::set_window_position::SetWindowPosition;
 use crate::windows_callbacks;
 use crate::Window;
-use crate::WindowManager;
 use crate::DISPLAY_INDEX_PREFERENCES;
 use crate::MONITOR_INDEX_PREFERENCES;
 
@@ -236,9 +228,16 @@ impl WindowsApi {
         callback: MONITORENUMPROC,
         callback_data_address: isize,
     ) -> Result<()> {
-        unsafe { EnumDisplayMonitors(None, None, callback, LPARAM(callback_data_address)) }
-            .ok()
-            .process()
+        unsafe {
+            EnumDisplayMonitors(
+                HDC(std::ptr::null_mut()),
+                None,
+                callback,
+                LPARAM(callback_data_address),
+            )
+        }
+        .ok()
+        .process()
     }
 
     pub fn valid_hmonitors() -> Result<Vec<(String, isize)>> {
@@ -253,10 +252,7 @@ impl WindowsApi {
             .collect::<Vec<_>>())
     }
 
-    pub fn load_monitor_information(wm: &mut WindowManager) -> Result<()> {
-        let monitors = &mut wm.monitors;
-        let monitor_usr_idx_map = &mut wm.monitor_usr_idx_map;
-
+    pub fn load_monitor_information(monitors: &mut Ring<Monitor>) -> Result<()> {
         'read: for display in win32_display_data::connected_displays_all().flatten() {
             let path = display.device_path.clone();
 
@@ -300,8 +296,7 @@ impl WindowsApi {
 
             let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
             for (index, id) in &*display_index_preferences {
-                if m.serial_number_id().as_ref().is_some_and(|sn| sn == id) || id.eq(m.device_id())
-                {
+                if id.eq(m.device_id()) {
                     index_preference = Option::from(index);
                 }
             }
@@ -330,40 +325,6 @@ impl WindowsApi {
             .elements_mut()
             .retain(|m| m.name().ne("PLACEHOLDER"));
 
-        // Rebuild monitor index map
-        *monitor_usr_idx_map = HashMap::new();
-        let mut added_monitor_idxs = Vec::new();
-        for (index, id) in &*DISPLAY_INDEX_PREFERENCES.lock() {
-            if let Some(m_idx) = monitors.elements().iter().position(|m| {
-                m.serial_number_id().as_ref().is_some_and(|sn| sn == id) || m.device_id() == id
-            }) {
-                monitor_usr_idx_map.insert(*index, m_idx);
-                added_monitor_idxs.push(m_idx);
-            }
-        }
-
-        let max_usr_idx = monitors
-            .elements()
-            .len()
-            .max(monitor_usr_idx_map.keys().max().map_or(0, |v| *v));
-
-        let mut available_usr_idxs = (0..max_usr_idx)
-            .filter(|i| !monitor_usr_idx_map.contains_key(i))
-            .collect::<Vec<_>>();
-
-        let not_added_monitor_idxs = (0..monitors.elements().len())
-            .filter(|i| !added_monitor_idxs.contains(i))
-            .collect::<Vec<_>>();
-
-        for i in not_added_monitor_idxs {
-            if let Some(next_usr_idx) = available_usr_idxs.first() {
-                monitor_usr_idx_map.insert(*next_usr_idx, i);
-                available_usr_idxs.remove(0);
-            } else if let Some(idx) = monitor_usr_idx_map.keys().max() {
-                monitor_usr_idx_map.insert(*idx, i);
-            }
-        }
-
         Ok(())
     }
 
@@ -512,7 +473,7 @@ impl WindowsApi {
         unsafe {
             SetWindowPos(
                 hwnd,
-                Option::from(position),
+                position,
                 layout.left,
                 layout.top,
                 layout.right,
@@ -550,7 +511,7 @@ impl WindowsApi {
     }
 
     fn post_message(hwnd: HWND, message: u32, wparam: WPARAM, lparam: LPARAM) -> Result<()> {
-        unsafe { PostMessageW(Option::from(hwnd), message, wparam, lparam) }.process()
+        unsafe { PostMessageW(hwnd, message, wparam, lparam) }.process()
     }
 
     pub fn close_window(hwnd: isize) -> Result<()> {
@@ -593,7 +554,7 @@ impl WindowsApi {
             // Error ignored, as the operation is not always necessary.
             let _ = SetWindowPos(
                 HWND(as_ptr!(hwnd)),
-                Option::from(HWND_TOP),
+                HWND_TOP,
                 0,
                 0,
                 0,
@@ -609,7 +570,7 @@ impl WindowsApi {
 
     #[allow(dead_code)]
     pub fn top_window() -> Result<isize> {
-        unsafe { GetTopWindow(None)? }.process()
+        unsafe { GetTopWindow(HWND::default())? }.process()
     }
 
     pub fn desktop_window() -> Result<isize> {
@@ -925,7 +886,7 @@ impl WindowsApi {
     }
 
     pub fn is_window(hwnd: isize) -> bool {
-        unsafe { IsWindow(Option::from(HWND(as_ptr!(hwnd)))) }.into()
+        unsafe { IsWindow(HWND(as_ptr!(hwnd))) }.into()
     }
 
     pub fn is_window_visible(hwnd: isize) -> bool {
@@ -1153,7 +1114,7 @@ impl WindowsApi {
                 CW_USEDEFAULT,
                 None,
                 None,
-                Option::from(HINSTANCE(as_ptr!(instance))),
+                HINSTANCE(as_ptr!(instance)),
                 Some(border as _),
             )?
         }
@@ -1202,35 +1163,16 @@ impl WindowsApi {
                 CW_USEDEFAULT,
                 None,
                 None,
-                Option::from(HINSTANCE(as_ptr!(instance))),
+                HINSTANCE(as_ptr!(instance)),
                 None,
             )?
         }
         .process()
     }
 
-    pub fn register_power_setting_notification(
-        hwnd: isize,
-        guid: &windows_core::GUID,
-        flags: REGISTER_NOTIFICATION_FLAGS,
-    ) -> WindowsCrateResult<HPOWERNOTIFY> {
-        unsafe { RegisterPowerSettingNotification(HANDLE::from(HWND(as_ptr!(hwnd))), guid, flags) }
-    }
-
-    pub fn register_device_notification(
-        hwnd: isize,
-        mut filter: DEV_BROADCAST_DEVICEINTERFACE_W,
-        flags: REGISTER_NOTIFICATION_FLAGS,
-    ) -> WindowsCrateResult<HDEVNOTIFY> {
-        unsafe {
-            let state_ptr: *const c_void = &mut filter as *mut _ as *const c_void;
-            RegisterDeviceNotificationW(HANDLE::from(HWND(as_ptr!(hwnd))), state_ptr, flags)
-        }
-    }
-
     pub fn invalidate_rect(hwnd: isize, rect: Option<&Rect>, erase: bool) -> bool {
         let rect = rect.map(|rect| &rect.rect() as *const RECT);
-        unsafe { InvalidateRect(Option::from(HWND(as_ptr!(hwnd))), rect, erase) }.as_bool()
+        unsafe { InvalidateRect(HWND(as_ptr!(hwnd)), rect, erase) }.as_bool()
     }
 
     pub fn alt_is_pressed() -> bool {

komorebi/src/windows_callbacks.rs

@@ -8,6 +8,7 @@ use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::winevent::WinEvent;
 use crate::winevent_listener;
+use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
 use windows::Win32::Foundation::WPARAM;
@@ -20,7 +21,6 @@ use windows::Win32::UI::WindowsAndMessaging::OBJID_WINDOW;
 use windows::Win32::UI::WindowsAndMessaging::WS_CHILD;
 use windows::Win32::UI::WindowsAndMessaging::WS_EX_NOACTIVATE;
 use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOOLWINDOW;
-use windows_core::BOOL;
 
 pub extern "system" fn enum_window(hwnd: HWND, lparam: LPARAM) -> BOOL {
     let containers = unsafe { &mut *(lparam.0 as *mut VecDeque<Container>) };
@@ -115,16 +115,6 @@ pub extern "system" fn win_event_hook(
         }
     }
 
-    // sometimes the border focus state and colors don't get updated because this event comes too
-    // slow for the value of GetForegroundWindow to be up to date by the time it is inspected in
-    // the border manager to determine if a window show have its border show as "focused"
-    //
-    // so here we can just fire another event at the border manager when the system has finally
-    // registered the new foreground window and this time the correct border colors will be applied
-    if matches!(winevent, WinEvent::SystemForeground) && !has_filtered_style(hwnd) {
-        border_manager::send_notification(Some(hwnd.0 as isize));
-    }
-
     let event_type = match WindowManagerEvent::from_win_event(winevent, window) {
         None => {
             tracing::trace!(

komorebi/src/winevent_listener.rs

@@ -3,6 +3,7 @@ use std::time::Duration;
 
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
+use windows::Win32::Foundation::HWND;
 use windows::Win32::UI::Accessibility::SetWinEventHook;
 use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
 use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
@@ -40,7 +41,7 @@ pub fn start() {
 
             loop {
                 unsafe {
-                    if !GetMessageW(&mut msg, None, 0, 0).as_bool() {
+                    if !GetMessageW(&mut msg, HWND(std::ptr::null_mut()), 0, 0).as_bool() {
                         tracing::debug!("windows event processing thread shutdown");
                         break;
                     };

komorebi/src/workspace.rs

@@ -1,6 +1,4 @@
 use std::collections::VecDeque;
-use std::fmt::Display;
-use std::fmt::Formatter;
 use std::num::NonZeroUsize;
 use std::sync::atomic::Ordering;
 
@@ -56,65 +54,42 @@ use crate::REMOVE_TITLEBARS;
 )]
 pub struct Workspace {
     #[getset(get = "pub", set = "pub")]
-    pub name: Option<String>,
-    pub containers: Ring<Container>,
+    name: Option<String>,
+    containers: Ring<Container>,
     #[getset(get = "pub", get_mut = "pub", set = "pub")]
-    pub monocle_container: Option<Container>,
+    monocle_container: Option<Container>,
     #[serde(skip_serializing_if = "Option::is_none")]
     #[getset(get_copy = "pub", set = "pub")]
-    pub monocle_container_restore_idx: Option<usize>,
+    monocle_container_restore_idx: Option<usize>,
     #[getset(get = "pub", get_mut = "pub", set = "pub")]
-    pub maximized_window: Option<Window>,
+    maximized_window: Option<Window>,
     #[serde(skip_serializing_if = "Option::is_none")]
     #[getset(get_copy = "pub", set = "pub")]
-    pub maximized_window_restore_idx: Option<usize>,
+    maximized_window_restore_idx: Option<usize>,
     #[getset(get = "pub", get_mut = "pub")]
-    pub floating_windows: Vec<Window>,
+    floating_windows: Vec<Window>,
     #[getset(get = "pub", get_mut = "pub", set = "pub")]
-    pub layout: Layout,
+    layout: Layout,
     #[getset(get = "pub", get_mut = "pub", set = "pub")]
-    pub layout_rules: Vec<(usize, Layout)>,
+    layout_rules: Vec<(usize, Layout)>,
     #[getset(get_copy = "pub", set = "pub")]
-    pub layout_flip: Option<Axis>,
+    layout_flip: Option<Axis>,
     #[getset(get_copy = "pub", set = "pub")]
-    pub workspace_padding: Option<i32>,
+    workspace_padding: Option<i32>,
     #[getset(get_copy = "pub", set = "pub")]
-    pub container_padding: Option<i32>,
+    container_padding: Option<i32>,
     #[getset(get = "pub", set = "pub")]
-    pub latest_layout: Vec<Rect>,
+    latest_layout: Vec<Rect>,
     #[getset(get = "pub", get_mut = "pub", set = "pub")]
-    pub resize_dimensions: Vec<Option<Rect>>,
+    resize_dimensions: Vec<Option<Rect>>,
     #[getset(get = "pub", set = "pub")]
-    pub tile: bool,
+    tile: bool,
     #[getset(get_copy = "pub", set = "pub")]
-    pub apply_window_based_work_area_offset: bool,
+    apply_window_based_work_area_offset: bool,
     #[getset(get = "pub", get_mut = "pub", set = "pub")]
-    pub window_container_behaviour: Option<WindowContainerBehaviour>,
+    window_container_behaviour: Option<WindowContainerBehaviour>,
     #[getset(get = "pub", get_mut = "pub", set = "pub")]
-    pub window_container_behaviour_rules: Option<Vec<(usize, WindowContainerBehaviour)>>,
-    #[getset(get = "pub", get_mut = "pub", set = "pub")]
-    pub float_override: Option<bool>,
-    #[getset(get = "pub", get_mut = "pub", set = "pub")]
-    pub layer: WorkspaceLayer,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    #[getset(get = "pub", set = "pub")]
-    pub workspace_config: Option<WorkspaceConfig>,
-}
-
-#[derive(Debug, Default, Copy, Clone, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
-pub enum WorkspaceLayer {
-    #[default]
-    Tiling,
-    Floating,
-}
-
-impl Display for WorkspaceLayer {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            WorkspaceLayer::Tiling => write!(f, "Tiling"),
-            WorkspaceLayer::Floating => write!(f, "Floating"),
-        }
-    }
+    float_override: Option<bool>,
 }
 
 impl_ring_elements!(Workspace, Container);
@@ -139,10 +114,7 @@ impl Default for Workspace {
             tile: true,
             apply_window_based_work_area_offset: true,
             window_container_behaviour: None,
-            window_container_behaviour_rules: None,
             float_override: None,
-            workspace_config: None,
-            layer: Default::default(),
         }
     }
 }
@@ -186,55 +158,42 @@ impl Workspace {
             self.tile = false;
         }
 
-        let mut all_layout_rules = vec![];
         if let Some(layout_rules) = &config.layout_rules {
+            let mut all_rules = vec![];
             for (count, rule) in layout_rules {
-                all_layout_rules.push((*count, Layout::Default(*rule)));
+                all_rules.push((*count, Layout::Default(*rule)));
             }
 
-            all_layout_rules.sort_by_key(|(i, _)| *i);
+            self.set_layout_rules(all_rules);
+
             self.tile = true;
         }
 
-        self.set_layout_rules(all_layout_rules.clone());
-
         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(pathbuf)?;
-                all_layout_rules.push((*count, Layout::Custom(rule)));
+                rules.push((*count, Layout::Custom(rule)));
             }
 
-            all_layout_rules.sort_by_key(|(i, _)| *i);
             self.tile = true;
-            self.set_layout_rules(all_layout_rules);
         }
 
         self.set_apply_window_based_work_area_offset(
             config.apply_window_based_work_area_offset.unwrap_or(true),
         );
 
-        self.set_window_container_behaviour(config.window_container_behaviour);
-
-        if let Some(window_container_behaviour_rules) = &config.window_container_behaviour_rules {
-            if window_container_behaviour_rules.is_empty() {
-                self.set_window_container_behaviour_rules(None);
-            } else {
-                let mut all_rules = vec![];
-                for (count, behaviour) in window_container_behaviour_rules {
-                    all_rules.push((*count, *behaviour));
-                }
-
-                all_rules.sort_by_key(|(i, _)| *i);
-                self.set_window_container_behaviour_rules(Some(all_rules));
-            }
-        } else {
-            self.set_window_container_behaviour_rules(None);
+        if config.window_container_behaviour.is_some() {
+            self.set_window_container_behaviour(config.window_container_behaviour);
         }
 
-        self.set_float_override(config.float_override);
-        self.set_layout_flip(config.layout_flip);
+        if config.float_override.is_some() {
+            self.set_float_override(config.float_override);
+        }
 
-        self.set_workspace_config(Some(config.clone()));
+        if config.layout_flip.is_some() {
+            self.set_layout_flip(config.layout_flip);
+        }
 
         Ok(())
     }
@@ -367,9 +326,9 @@ impl Workspace {
         if !self.layout_rules().is_empty() {
             let mut updated_layout = None;
 
-            for (threshold, layout) in self.layout_rules() {
-                if self.containers().len() >= *threshold {
-                    updated_layout = Option::from(layout.clone());
+            for rule in self.layout_rules() {
+                if self.containers().len() >= rule.0 {
+                    updated_layout = Option::from(rule.1.clone());
                 }
             }
 
@@ -378,17 +337,6 @@ impl Workspace {
             }
         }
 
-        if let Some(window_container_behaviour_rules) = self.window_container_behaviour_rules() {
-            let mut updated_behaviour = None;
-            for (threshold, behaviour) in window_container_behaviour_rules {
-                if self.containers().len() >= *threshold {
-                    updated_behaviour = Option::from(*behaviour);
-                }
-            }
-
-            self.set_window_container_behaviour(updated_behaviour);
-        }
-
         let managed_maximized_window = self.maximized_window().is_some();
 
         if *self.tile() {
@@ -485,16 +433,7 @@ impl Workspace {
         // number of layouts / containers. This should never actually truncate as the remove_window
         // function takes care of cleaning up resize dimensions when destroying empty containers
         let container_count = self.containers().len();
-
-        // since monocle is a toggle, we never want to truncate the resize dimensions since it will
-        // almost always be toggled off and the container will be reintegrated into layout
-        //
-        // without this check, if there are exactly two containers, when one is toggled to monocle
-        // the resize dimensions will be truncated to len == 1, and when it is reintegrated, if it
-        // had a resize adjustment before, that will have been lost
-        if self.monocle_container().is_none() {
-            self.resize_dimensions_mut().resize(container_count, None);
-        }
+        self.resize_dimensions_mut().resize(container_count, None);
 
         Ok(())
     }
@@ -526,15 +465,7 @@ impl Workspace {
         }
 
         for window in self.visible_windows().into_iter().flatten() {
-            if !window.is_window()
-                // This one is a hack because WINWORD.EXE is an absolute trainwreck of an app
-                // when multiple docs are open, it keeps open an invisible window, with WS_EX_LAYERED
-                // (A STYLE THAT THE REGULAR WINDOWS NEED IN ORDER TO BE MANAGED!) when one of the
-                // docs is closed
-                //
-                // I hate every single person who worked on Microsoft Office 365, especially Word
-                || !window.is_visible()
-            {
+            if !window.is_window() {
                 hwnds.push(window.hwnd);
             }
         }

komorebic-no-console/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebic-no-console"
-version = "0.1.35"
+version = "0.1.34"
 description = "The command-line interface (without a console) for Komorebi, a tiling window manager for Windows"
 repository = "https://github.com/LGUG2Z/komorebi"
 edition = "2021"

komorebic/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebic"
-version = "0.1.35"
+version = "0.1.34"
 description = "The command-line interface for Komorebi, a tiling window manager for Windows"
 repository = "https://github.com/LGUG2Z/komorebi"
 edition = "2021"
@@ -24,10 +24,13 @@ reqwest = { version = "0.12", features = ["blocking"] }
 schemars = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+serde_yaml = "0.9"
 shadow-rs = { workspace = true }
 sysinfo = { workspace = true }
 thiserror = "2"
+uds_windows = { workspace = true }
 which = { workspace = true }
+win32-display-data = { workspace = true }
 windows = { workspace = true }
 
 [build-dependencies]

komorebic/src/main.rs

@@ -1108,8 +1108,6 @@ enum SubCommand {
     /// 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
@@ -1155,8 +1153,6 @@ enum SubCommand {
     /// Set offsets for a monitor to exclude parts of the work area from tiling
     #[clap(arg_required_else_help = true)]
     MonitorWorkAreaOffset(MonitorWorkAreaOffset),
-    /// 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),
@@ -1269,8 +1265,6 @@ enum SubCommand {
     /// 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 window tiling on the focused workspace
     TogglePause,
     /// Toggle window tiling on the focused workspace
@@ -1882,9 +1876,6 @@ fn main() -> Result<()> {
                 bottom: arg.bottom,
             }))?;
         }
-        SubCommand::ToggleWindowBasedWorkAreaOffset => {
-            send_message(&SocketMessage::ToggleWindowBasedWorkAreaOffset)?;
-        }
         SubCommand::ContainerPadding(arg) => {
             send_message(&SocketMessage::ContainerPadding(
                 arg.monitor,
@@ -2597,9 +2588,6 @@ if (Get-Command Get-CimInstance -ErrorAction SilentlyContinue) {
         SubCommand::FocusMonitor(arg) => {
             send_message(&SocketMessage::FocusMonitorNumber(arg.target))?;
         }
-        SubCommand::FocusMonitorAtCursor => {
-            send_message(&SocketMessage::FocusMonitorAtCursor)?;
-        }
         SubCommand::FocusLastWorkspace => {
             send_message(&SocketMessage::FocusLastWorkspace)?;
         }
@@ -2856,9 +2844,6 @@ if (Get-Command Get-CimInstance -ErrorAction SilentlyContinue) {
         SubCommand::ToggleWorkspaceFloatOverride => {
             send_message(&SocketMessage::ToggleWorkspaceFloatOverride)?;
         }
-        SubCommand::ToggleWorkspaceLayer => {
-            send_message(&SocketMessage::ToggleWorkspaceLayer)?;
-        }
         SubCommand::WindowHidingBehaviour(arg) => {
             send_message(&SocketMessage::WindowHidingBehaviour(arg.hiding_behaviour))?;
         }

mkdocs.yml

@@ -127,7 +127,6 @@ nav:
       - cli/send-to-monitor-workspace.md
       - cli/move-to-monitor-workspace.md
       - cli/focus-monitor.md
-      - cli/focus-monitor-at-cursor.md
       - cli/focus-last-workspace.md
       - cli/focus-workspace.md
       - cli/focus-workspaces.md
@@ -144,7 +143,6 @@ nav:
       - cli/invisible-borders.md
       - cli/global-work-area-offset.md
       - cli/monitor-work-area-offset.md
-      - cli/toggle-window-based-work-area-offset.md
       - cli/focused-workspace-container-padding.md
       - cli/focused-workspace-padding.md
       - cli/adjust-container-padding.md
@@ -177,7 +175,6 @@ nav:
       - cli/toggle-float-override.md
       - cli/toggle-workspace-window-container-behaviour.md
       - cli/toggle-workspace-float-override.md
-      - cli/toggle-workspace-layer.md
       - cli/toggle-pause.md
       - cli/toggle-tiling.md
       - cli/toggle-float.md

schema.bar.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "KomobarConfig",
-  "description": "The `komorebi.bar.json` configuration file reference for `v0.1.35`",
+  "description": "The `komorebi.bar.json` configuration file reference for `v0.1.34`",
   "type": "object",
   "required": [
     "left_widgets",
@@ -271,66 +271,6 @@
             },
             "additionalProperties": false
           },
-          {
-            "type": "object",
-            "required": [
-              "Keyboard"
-            ],
-            "properties": {
-              "Keyboard": {
-                "type": "object",
-                "required": [
-                  "enable"
-                ],
-                "properties": {
-                  "data_refresh_interval": {
-                    "description": "Data refresh interval (default: 1 second)",
-                    "type": "integer",
-                    "format": "uint64",
-                    "minimum": 0.0
-                  },
-                  "enable": {
-                    "description": "Enable the Input widget",
-                    "type": "boolean"
-                  },
-                  "label_prefix": {
-                    "description": "Display label prefix",
-                    "oneOf": [
-                      {
-                        "description": "Show no prefix",
-                        "type": "string",
-                        "enum": [
-                          "None"
-                        ]
-                      },
-                      {
-                        "description": "Show an icon",
-                        "type": "string",
-                        "enum": [
-                          "Icon"
-                        ]
-                      },
-                      {
-                        "description": "Show text",
-                        "type": "string",
-                        "enum": [
-                          "Text"
-                        ]
-                      },
-                      {
-                        "description": "Show an icon and text",
-                        "type": "string",
-                        "enum": [
-                          "IconAndText"
-                        ]
-                      }
-                    ]
-                  }
-                }
-              }
-            },
-            "additionalProperties": false
-          },
           {
             "type": "object",
             "required": [
@@ -504,19 +444,6 @@
                       }
                     }
                   },
-                  "workspace_layer": {
-                    "description": "Configure the Workspace Layer widget",
-                    "type": "object",
-                    "required": [
-                      "enable"
-                    ],
-                    "properties": {
-                      "enable": {
-                        "description": "Enable the Komorebi Workspace Layer widget",
-                        "type": "boolean"
-                      }
-                    }
-                  },
                   "workspaces": {
                     "description": "Configure the Workspaces widget",
                     "type": "object",
@@ -1591,66 +1518,6 @@
             },
             "additionalProperties": false
           },
-          {
-            "type": "object",
-            "required": [
-              "Keyboard"
-            ],
-            "properties": {
-              "Keyboard": {
-                "type": "object",
-                "required": [
-                  "enable"
-                ],
-                "properties": {
-                  "data_refresh_interval": {
-                    "description": "Data refresh interval (default: 1 second)",
-                    "type": "integer",
-                    "format": "uint64",
-                    "minimum": 0.0
-                  },
-                  "enable": {
-                    "description": "Enable the Input widget",
-                    "type": "boolean"
-                  },
-                  "label_prefix": {
-                    "description": "Display label prefix",
-                    "oneOf": [
-                      {
-                        "description": "Show no prefix",
-                        "type": "string",
-                        "enum": [
-                          "None"
-                        ]
-                      },
-                      {
-                        "description": "Show an icon",
-                        "type": "string",
-                        "enum": [
-                          "Icon"
-                        ]
-                      },
-                      {
-                        "description": "Show text",
-                        "type": "string",
-                        "enum": [
-                          "Text"
-                        ]
-                      },
-                      {
-                        "description": "Show an icon and text",
-                        "type": "string",
-                        "enum": [
-                          "IconAndText"
-                        ]
-                      }
-                    ]
-                  }
-                }
-              }
-            },
-            "additionalProperties": false
-          },
           {
             "type": "object",
             "required": [
@@ -1824,19 +1691,6 @@
                       }
                     }
                   },
-                  "workspace_layer": {
-                    "description": "Configure the Workspace Layer widget",
-                    "type": "object",
-                    "required": [
-                      "enable"
-                    ],
-                    "properties": {
-                      "enable": {
-                        "description": "Enable the Komorebi Workspace Layer widget",
-                        "type": "boolean"
-                      }
-                    }
-                  },
                   "workspaces": {
                     "description": "Configure the Workspaces widget",
                     "type": "object",
@@ -2844,66 +2698,6 @@
             },
             "additionalProperties": false
           },
-          {
-            "type": "object",
-            "required": [
-              "Keyboard"
-            ],
-            "properties": {
-              "Keyboard": {
-                "type": "object",
-                "required": [
-                  "enable"
-                ],
-                "properties": {
-                  "data_refresh_interval": {
-                    "description": "Data refresh interval (default: 1 second)",
-                    "type": "integer",
-                    "format": "uint64",
-                    "minimum": 0.0
-                  },
-                  "enable": {
-                    "description": "Enable the Input widget",
-                    "type": "boolean"
-                  },
-                  "label_prefix": {
-                    "description": "Display label prefix",
-                    "oneOf": [
-                      {
-                        "description": "Show no prefix",
-                        "type": "string",
-                        "enum": [
-                          "None"
-                        ]
-                      },
-                      {
-                        "description": "Show an icon",
-                        "type": "string",
-                        "enum": [
-                          "Icon"
-                        ]
-                      },
-                      {
-                        "description": "Show text",
-                        "type": "string",
-                        "enum": [
-                          "Text"
-                        ]
-                      },
-                      {
-                        "description": "Show an icon and text",
-                        "type": "string",
-                        "enum": [
-                          "IconAndText"
-                        ]
-                      }
-                    ]
-                  }
-                }
-              }
-            },
-            "additionalProperties": false
-          },
           {
             "type": "object",
             "required": [
@@ -3077,19 +2871,6 @@
                       }
                     }
                   },
-                  "workspace_layer": {
-                    "description": "Configure the Workspace Layer widget",
-                    "type": "object",
-                    "required": [
-                      "enable"
-                    ],
-                    "properties": {
-                      "enable": {
-                        "description": "Enable the Komorebi Workspace Layer widget",
-                        "type": "boolean"
-                      }
-                    }
-                  },
                   "workspaces": {
                     "description": "Configure the Workspaces widget",
                     "type": "object",
@@ -3642,7 +3423,7 @@
               ]
             },
             "name": {
-              "description": "Name of the Base16 theme (theme previews: https://tinted-theming.github.io/tinted-gallery/)",
+              "description": "Name of the Base16 theme (theme previews: https://tinted-theming.github.io/base16-gallery)",
               "type": "string",
               "enum": [
                 "3024",

schema.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "StaticConfig",
-  "description": "The `komorebi.json` static configuration file reference for `v0.1.35`",
+  "description": "The `komorebi.json` static configuration file reference for `v0.1.34`",
   "type": "object",
   "properties": {
     "animation": {
@@ -1284,7 +1284,7 @@
                   ]
                 },
                 "layout_rules": {
-                  "description": "Layout rules in the format of threshold => layout (default: None)",
+                  "description": "Layout rules (default: None)",
                   "type": "object",
                   "additionalProperties": {
                     "type": "string",
@@ -1323,28 +1323,6 @@
                     }
                   ]
                 },
-                "window_container_behaviour_rules": {
-                  "description": "Window container behaviour rules in the format of threshold => behaviour (default: None)",
-                  "type": "object",
-                  "additionalProperties": {
-                    "oneOf": [
-                      {
-                        "description": "Create a new container for each new window",
-                        "type": "string",
-                        "enum": [
-                          "Create"
-                        ]
-                      },
-                      {
-                        "description": "Append new windows to the focused window container",
-                        "type": "string",
-                        "enum": [
-                          "Append"
-                        ]
-                      }
-                    ]
-                  }
-                },
                 "workspace_padding": {
                   "description": "Container padding (default: global)",
                   "type": "integer",
@@ -2267,7 +2245,7 @@
               ]
             },
             "name": {
-              "description": "Name of the Base16 theme (theme previews: https://tinted-theming.github.io/tinted-gallery/)",
+              "description": "Name of the Base16 theme (theme previews: https://tinted-theming.github.io/base16-gallery)",
               "type": "string",
               "enum": [
                 "3024",