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/process_event.rs

@@ -305,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;
                         }
                     }
 
@@ -339,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"
@@ -502,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;
                     }
                 }