feat(reaper): rework reaper logic to make it faster

# This is a combination of 4 commits.
# This is the 1st commit message:

This commit changes the way the reaper works.

First this commit changed the `known_hwnds` held by the `WindowManager`
to be a HashMap of window handles (isize) to a pair of monitor_idx,
workspace_idx (usize, usize).

This commit then changes the reaper to have a cache of hwnds which is
updated by the `WindowManager` when they change. The reaper has a thread
that is continuously checking this cache to see if there is any window
handle that no longer exists. When it finds them, the thread sends a
notification to a channel which is then received by the reaper on
another thread that actually does the work on the `WindowManager` by
removing said windows.

This means that the reaper no longer tries to access and lock the
`WindowManager` every second like it used to, but instead it only does
it when it actually needs, when a window actually needs to be reaped.
This means that we can make the thread that checks for orphan windows
run much more frequently since it won't influence the rest of komorebi.

# This is the commit message n.2:

refactor(wm): move update of known_hwnds to a function

# This is the commit message n.3:

feat(wm): update known_hwnds on process_command

# This is the commit message n.4:

refactor(wm): simplify loops on monitor/workspaces

This commit uses the new `known_hwnds` hashmap to simplify looking for
windows on all the monitors and all the workspaces. Since now the
`known_hwnds` have the monitor/workspace index pair of the window we can
simply get that info from the map and immediately access that
monitor/workspace or use that index info. This commit already does this
on some situations from the `process_event`.

Author: alex-ds13

komorebi/src/main.rs

@@ -291,7 +291,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::watch_for_orphans(wm.clone());
+    reaper::listen_for_notifications(wm.clone());
     focus_manager::listen_for_notifications(wm.clone());
     theme_manager::listen_for_notifications();
 

komorebi/src/monitor_reconciliator/mod.rs

@@ -385,7 +385,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     }
 
                     // Update known_hwnds
-                    wm.known_hwnds.retain(|i| !windows_to_remove.contains(i));
+                    wm.known_hwnds.retain(|i, _| !windows_to_remove.contains(i));
 
                     if !newly_removed_displays.is_empty() {
                         // After we have cached them, remove them from our state
@@ -481,7 +481,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                     {
                                         container.windows_mut().retain(|window| {
                                             window.exe().is_ok()
-                                                && !known_hwnds.contains(&window.hwnd)
+                                                && !known_hwnds.contains_key(&window.hwnd)
                                         });
 
                                         if container.windows().is_empty() {
@@ -519,7 +519,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
 
                                     if let Some(window) = workspace.maximized_window() {
                                         if window.exe().is_err()
-                                            || known_hwnds.contains(&window.hwnd)
+                                            || known_hwnds.contains_key(&window.hwnd)
                                         {
                                             workspace.set_maximized_window(None);
                                         } else if is_focused_workspace {
@@ -530,7 +530,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                     if let Some(container) = workspace.monocle_container_mut() {
                                         container.windows_mut().retain(|window| {
                                             window.exe().is_ok()
-                                                && !known_hwnds.contains(&window.hwnd)
+                                                && !known_hwnds.contains_key(&window.hwnd)
                                         });
 
                                         if container.windows().is_empty() {
@@ -552,7 +552,8 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                     }
 
                                     workspace.floating_windows_mut().retain(|window| {
-                                        window.exe().is_ok() && !known_hwnds.contains(&window.hwnd)
+                                        window.exe().is_ok()
+                                            && !known_hwnds.contains_key(&window.hwnd)
                                     });
 
                                     if is_focused_workspace {

komorebi/src/process_command.rs

@@ -1835,6 +1835,9 @@ 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,4 +1,3 @@
-use std::fs::OpenOptions;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::time::Duration;
@@ -33,7 +32,6 @@ 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;
@@ -307,30 +305,28 @@ impl WindowManager {
 
                     let mut needs_reconciliation = false;
 
-                    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();
-                                        }
+                    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();
                                     }
                                 }
-
-                                workspace_reconciliator::send_notification(i, j);
-                                needs_reconciliation = true;
                             }
+
+                            workspace_reconciliator::send_notification(*m_idx, *w_idx);
+                            needs_reconciliation = true;
                         }
                     }
 
@@ -341,11 +337,14 @@ impl WindowManager {
                     // duplicates across multiple workspaces, as it results in ghost layout tiles.
                     let mut proceed = true;
 
-                    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()
+                    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
                             {
                                 tracing::debug!(
                                     "ignoring show event for window already associated with another workspace"
@@ -504,15 +503,9 @@ impl WindowManager {
                 // This will be true if we have moved to another monitor
                 let mut moved_across_monitors = false;
 
-                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;
+                if let Some((m_idx, _)) = self.known_hwnds.get(&window.hwnd) {
+                    if *m_idx != target_monitor_idx {
+                        moved_across_monitors = true;
                     }
                 }
 
@@ -716,42 +709,8 @@ impl WindowManager {
             window.center(&self.focused_monitor_work_area()?)?;
         }
 
-        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)?;
-
-        self.known_hwnds = known_hwnds;
+        // Update list of known_hwnds and their monitor/workspace index pair
+        self.update_known_hwnds();
 
         notify_subscribers(
             Notification {