gardesk/tarmac / ae35f6c

             .position(|m| m.active_workspace == ws_idx)

     }

     pub fn discover_and_observe(&mut self) {

         // Discover all displays

         let mut displays = crate::platform::display::discover_displays();

         for (mi, ws_idx) in monitor_assignments.into_iter().enumerate() {

             let ws_idx = ws_idx.unwrap_or(0);

             self.monitors[mi].active_workspace = ws_idx;

             self.workspaces.get_mut(ws_idx).last_monitor = Some(mi);

             self.workspaces.get_mut(ws_idx).last_display_id = Some(self.monitors[mi].id);

         }

         tracing::info!(

             monitors = self.monitors.len(),

                     "show floating"

                 );

                 self.show_window(fw.id, fw.geometry);

             }

         }

     }

             .collect();

         // Track workspaces we've already fully processed to avoid infinite loops.

         let mut processed: Vec<usize> = Vec::new();

         while let Some(ws_idx) = pending.pop() {

             if processed.contains(&ws_idx) {

                 continue;

                 .monitor_showing_workspace(ws_idx)

                 .map(|mi| self.monitor_rect(mi))

                 .unwrap_or_else(|| self.focused_rect());

             // Phase 1: Swap oversized windows into larger tiles.

             // Batch all swaps using BSP geometry (no AX calls), then apply layout

                         .workspaces

                         .get(ws_idx)

                         .tree

                     if geometries.is_empty() {

                         break;

                     }

                 // settling. The settled set prevents ping-pong.

             }

             loop {

                 let geometries = self

                     .workspaces

                     .get(ws_idx)

                     .tree

                 if geometries.is_empty() {

                     break;

                 }

                     None => break,

                 };

                 tracing::info!(

                     id = oversized_wid,

                     min_w,

                     min_h,

                 );

                 }

                 self.apply_layout();

             }

             processed.push(ws_idx);

         }

     }

     // --- Window operations ---

     pub fn focus_direction(&mut self, direction: super::tree::Direction) {

         let ws = self.active_workspace();

         let focused = ws.focused;

         let sr = self.focused_rect();

         // Try intra-workspace navigation first (only if we have a focused window)

         if let Some(from) = focused {

             // Check if focused window is at the monitor edge in the requested

             // direction. If so, cross monitors instead of spiraling into the BSP tree.

         if let Some(new_mi) = new_mi {

             self.focused_monitor = new_mi;

             let target_sr = self.focused_rect();

             if let Some(wid) =

                 Node::nearest_to_edge(&target_geoms, direction).or(self.active_workspace().focused)

             None => return,

         };

         let sr = self.focused_rect();

         // Check if the focused window touches the monitor edge in the

         // requested direction. If so, skip intra-workspace swap and move

         // workspace might be different from the window's workspace.

         let old_focused = if let Some(ws_idx) = self.workspaces.find_window(id) {

             let old = self.workspaces.get(ws_idx).focused;

             self.workspaces.get_mut(ws_idx).record_focus(id);

             old

         } else {

             let old = self.active_workspace().focused;

             self.active_workspace_mut().record_focus(id);

             old

         };

         // Update border colors on focus change

         if self.borders.is_enabled() && old_focused != Some(id) {

     /// Re-apply SkyLight window levels for all floating windows.

     /// Called after every focus change since app activation can reset ordering.

         use crate::platform::skylight::{K_CG_FLOATING_WINDOW_LEVEL, set_window_level};

             set_window_level(fw.id, K_CG_FLOATING_WINDOW_LEVEL);

         }

     }

         let window_under = if let Some(special_idx) = special_ws_idx {

             let sr = self.monitor_rect(mi);

             let ws = self.workspaces.get(special_idx);

             // Look up config for this special workspace's overlay rect

             let special_name = match &ws.id {

                 // Check tiled windows within the overlay rect

                 let geoms = ws.tree.calculate_geometries_with_gaps(

                     overlay_rect,

                     true,

                 );

                 geoms

             }

         } else {

             let ws = self.active_workspace();

             // Check floating windows first -- they're visually on top

             let floating_under = ws

                 // Check tiled windows using gap-aware geometry matching actual layout

                 let geoms = ws.tree.calculate_geometries_with_gaps(

                     self.focused_rect(),

                     true,

                 );

                 geoms

                 // Set window level to floating so it stays above all normal windows

                 use crate::platform::skylight::{K_CG_FLOATING_WINDOW_LEVEL, set_window_level};

                 set_window_level(focused, K_CG_FLOATING_WINDOW_LEVEL);

                 tracing::info!(id = focused, "window floated (level=floating)");

             } else {

                 // Restore to normal window level

     pub fn click_to_focus(&mut self, x: f64, y: f64) {

         let ws = self.active_workspace();

         // Check floating first

         let floating_hit = ws

         } else {

             let geoms = ws.tree.calculate_geometries_with_gaps(

                 self.focused_rect(),

                 true,

             );

             geoms

                 // Warp to the focused WINDOW center (not monitor center)

                 if self.mouse_follows_focus {

                     let sr = self.focused_rect();

                     let geoms = self

                         .workspaces

                         .get(target_idx)

                         .tree

                     if let Some((_, rect)) = geoms.iter().find(|(id, _)| *id == wid) {

                         warp_mouse_to_center(rect);

                     } else {

         // Hide the workspace currently on the target monitor

         let displaced_idx = self.monitors[show_on_monitor].active_workspace;

         self.hide_workspace_windows(displaced_idx, show_on_monitor);

         // If the displaced workspace is empty, unassign it from the monitor

         if self.workspaces.get(displaced_idx).is_empty() {

             self.workspaces.get_mut(displaced_idx).last_monitor = None;

         // Show target workspace on the chosen monitor

         self.monitors[show_on_monitor].active_workspace = target_idx;

         self.workspaces.get_mut(target_idx).last_monitor = Some(show_on_monitor);

         self.workspaces.get_mut(target_idx).last_display_id =

             Some(self.monitors[show_on_monitor].id);

         self.focused_monitor = show_on_monitor;

         // Apply layout with double-apply for cross-monitor moves

         self.apply_layout();

             self.focus_window(wid);

             if self.mouse_follows_focus {

                 let sr = self.focused_rect();

                 let geoms = self

                     .workspaces

                     .get(target_idx)

                     .tree

                 if let Some((_, rect)) = geoms.iter().find(|(id, _)| *id == wid) {

                     warp_mouse_to_center(rect);

                 } else {

     fn enforce_hidden_workspaces(&self) {

         for ws_idx in 0..self.workspaces.count() {

                 continue;

             }

             for wid in self.workspaces.get(ws_idx).all_window_ids() {

             pid = window.app_pid,

             app = %window.app_name,

             workspace = ws_idx.map(|idx| idx + 1),

             group_ids = ?group_ids,

             on_screen_count = on_screen.len(),

             "hidden window diagnostics"

             // Currently shown → hide

             self.active_specials[mi] = None;

             let wids = self.workspaces.get(special_idx).all_window_ids();

             for wid in wids {

                 self.hide_window(wid);

             }

             // Dismiss any other active special on this monitor first

             if let Some(old_idx) = self.active_specials[mi] {

                 let old_wids = self.workspaces.get(old_idx).all_window_ids();

                 for wid in old_wids {

                     self.hide_window(wid);

                 }

             self.active_specials[mi] = Some(special_idx);

             {

                 let ws = self.workspaces.get_mut(special_idx);

                 ws.last_monitor = Some(mi);

             }

             let sr = self.monitor_rect(mi);

             let ws = self.workspaces.get(special_idx);

             let overlay_rect = Rect::new(overlay_x, overlay_y, overlay_w, overlay_h);

             // Compute geometries and collect data before calling self methods

             let floating_data: Vec<(WindowId, Rect)> =

                 ws.floating.iter().map(|fw| (fw.id, fw.geometry)).collect();

             let focus_target = ws.focused.or_else(|| geoms.first().map(|(id, _)| *id));

         let is_visible = self.active_specials[self.focused_monitor] == Some(special_idx);

         if !is_visible {

             self.hide_window(focused);

         }

         // Retile the source workspace

             self.focus_window(wid);

             if self.mouse_follows_focus {

                 let sr = self.focused_rect();

                 if let Some((_, rect)) = geoms.iter().find(|(id, _)| *id == wid) {

                     warp_mouse_to_center(rect);

                 } else {

             self.focus_window(wid);

             if self.mouse_follows_focus {

                 let sr = self.focused_rect();

                 if let Some((_, rect)) = geoms.iter().find(|(id, _)| *id == wid) {

                     warp_mouse_to_center(rect);

                 } else {

         // Get target monitor's screen rect for layout

         let target_rect = self.monitor_rect(target_mi);

         // Find which workspace the window is actually on

         let current_idx = match self.workspaces.find_window(focused) {

         // Apply layout on target monitor using its screen rect

         let geoms = target.tree.calculate_geometries_with_gaps(

             target_rect,

             true,

         );

         for (wid, rect) in &geoms {

         });

         let old_count = self.monitors.len();

         let old_focused_display_id = self.monitors.get(self.focused_monitor).map(|m| m.id);

         // Collect old display IDs for orphan detection

                 );

                 self.hide_workspace_windows_immediate(ws_idx);

                 let ws = self.workspaces.get_mut(ws_idx);

                 ws.last_monitor = None;

                 // Keep last_display_id intact for reconnection

             }

             let ws_idx = (0..self.workspaces.count())

                 .find(|&i| {

                     !used_ws.get(i).copied().unwrap_or(false)

                         && self.workspace_prefs(i).and_then(|prefs| {

                             prefs.monitor.as_ref().map(|monitor| monitor.display_id)

                         }) == Some(nd.id)

                 .or_else(|| {

                     (0..self.workspaces.count()).find(|&i| {

                         !used_ws.get(i).copied().unwrap_or(false)

                             && self.workspaces.get(i).last_display_id == Some(nd.id)

                     })

                 })

                     // Next preference: first hidden workspace assigned to no specific monitor.

                     (0..self.workspaces.count()).find(|&i| {

                         !used_ws.get(i).copied().unwrap_or(false)

                             && self

                                 .workspace_prefs(i)

                                 .and_then(|prefs| {

                 })

                 .or_else(|| {

                     (0..self.workspaces.count()).find(|&i| {

                     })

                 })

                 .unwrap_or_else(|| {

             m.active_workspace = ws_idx;

             let ws = self.workspaces.get_mut(ws_idx);

             ws.last_monitor = Some(new_idx);

             ws.last_display_id = Some(nd.id);

         }

         // --- Phase 4: Replace monitors, recover focus ---

         self.monitors = new_monitors;

         // Map old focused_monitor through display ID → new index

         if let Some(old_did) = old_focused_display_id {

         {

             // Dismiss the special workspace since we're taking its window

             self.active_specials[mi] = None;

             // Hide any remaining windows on the special workspace

             let remaining = self.workspaces.get(special_idx).all_window_ids();

             for wid in remaining {

         target_ws.record_focus(focused);

         // If target is not visible, hide the window

             self.hide_window(focused);

         }

             .workspaces

             .get(ws_idx)

             .tree

         let (_min_w, _min_h) = match geometries.iter().find(|(wid, _)| *wid == moved_wid) {

             Some((_, rect)) => {

                 .workspaces

                 .get(ws_idx)

                 .tree

             if geoms.is_empty() {

                 break;

             }

     pub fn is_window_hidden(&self, wid: u32) -> bool {

         let id = wid as WindowId;

         if let Some(ws_idx) = self.workspaces.find_window(id) {

         } else {

             false

         }

         assert_eq!(hide_x, -979.0);

         assert_eq!(hide_y, 6107.0);

     }

 }

         self.focused = Some(window_id);

     }

     /// Pop the most recent focus and return the new focused window.

     pub fn pop_focus(&mut self) -> Option<WindowId> {

         self.focus_history.pop();

         // Subscribe to all notification types on the app element

         let notifications = [

             AX_WINDOW_CREATED,

             AX_FOCUSED_WINDOW_CHANGED,

             AX_WINDOW_MOVED,

             AX_WINDOW_RESIZED,