gardesk/ers / 8871c72

 use skylight::*;

 use std::collections::HashMap;

 use std::ptr;

 use std::sync::atomic::{AtomicBool, Ordering};

 use std::sync::mpsc;

 use tracing::debug;

 /// Per-overlay state: the connection it was created on + its wid.

     wid: u32,

 }

 /// Tracks overlays for target windows.

 struct BorderMap {

     overlays: HashMap<u32, Overlay>,

             radius: 10.0,

             focused_wid: 0,

             active_color: (0.32, 0.58, 0.89, 1.0),   // #5294e2

             active_only: false,

         }

     }

     fn color_for(&self, target_wid: u32) -> (f64, f64, f64, f64) {

     }

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

     /// Add border (batch mode, uses main cid).

     fn add_batch(&mut self, target_wid: u32) {

         let color = self.color_for(target_wid);

             self.overlays.insert(target_wid, Overlay { cid, wid });

         }

     }

     /// Add border (event mode). Uses main_cid — fresh connections create

     /// invisible windows on Tahoe.

     fn add_fresh(&mut self, target_wid: u32) {

         // Filter: must be visible, owned by another process, not tiny

         let bounds = unsafe {

             let mut shown = false;

             SLSWindowIsOrderedIn(self.main_cid, target_wid, &mut shown);

             let mut wid_cid: CGSConnectionID = 0;

             SLSGetWindowOwner(self.main_cid, target_wid, &mut wid_cid);

             let mut pid: i32 = 0;

             SLSConnectionGetPID(wid_cid, &mut pid);

             let mut bounds = CGRect::default();

             SLSGetWindowBounds(self.main_cid, target_wid, &mut bounds);

             bounds

         };

         // keep the smaller one (content) and skip the larger one (container)

         let cx = bounds.origin.x + bounds.size.width / 2.0;

         let cy = bounds.origin.y + bounds.size.height / 2.0;

         for &existing_wid in self.overlays.keys() {

             unsafe {

                 let mut eb = CGRect::default();

                 let ecx = eb.origin.x + eb.size.width / 2.0;

                 let ecy = eb.origin.y + eb.size.height / 2.0;

                 if (cx - ecx).abs() < 30.0 && (cy - ecy).abs() < 30.0 {

                 }

             }

         }

         let color = self.color_for(target_wid);

             self.overlays.insert(target_wid, Overlay { cid, wid });

         }

     }

         if let Some(overlay) = self.overlays.remove(&target_wid) {

             unsafe {

                 // Move off-screen first (most reliable hide on Tahoe)

                 SLSMoveWindow(overlay.cid, overlay.wid, &offscreen);

                 SLSSetWindowAlpha(overlay.cid, overlay.wid, 0.0);

                 SLSOrderWindow(overlay.cid, overlay.wid, 0, 0);

     /// Recreate overlay at new size.

     fn recreate(&mut self, target_wid: u32) {

         self.remove(target_wid);

         self.add_fresh(target_wid);

         if self.active_only && target_wid != self.focused_wid {

     fn hide(&self, target_wid: u32) {

         if let Some(o) = self.overlays.get(&target_wid) {

         }

     }

     fn subscribe_all(&self) {

         let target_wids: Vec<u32> = self.overlays.keys().copied().collect();

         unsafe {

             SLSRequestNotificationsForWindows(

                 self.main_cid,

                 let oh = bounds.size.height + 2.0 * bw;

                 let ctx = SLWindowContextCreate(overlay.cid, overlay.wid, ptr::null());

                 let color = self.color_for(target_wid);

                 draw_border(ctx, ow, oh, bw, self.radius, color);

     /// Detect focused window and update border colors if focus changed.

     fn update_focus(&mut self) {

         let front = get_front_window(self.own_pid);

         let old = self.focused_wid;

         self.focused_wid = front;

     /// In active-only mode, ensure only the focused overlay is visible.

     fn enforce_active_only(&self) {

         for (&target_wid, o) in &self.overlays {

             if target_wid == self.focused_wid {

                 unsafe {

                     SLSOrderWindow(o.cid, o.wid, 1, target_wid);

                 }

             } else {

             }

         }

     }

         SLSGetConnectionIDForPSN(SLSMainConnectionID(), &mut psn, &mut front_cid);

         let mut front_pid: i32 = 0;

         SLSConnectionGetPID(front_cid, &mut front_pid);

         // Step 2: find the topmost layer-0 window belonging to that process

         let list = CGWindowListCopyWindowInfo(kCGWindowListOptionOnScreenOnly, kCGNullWindowID);

         let count = CFArrayGetCount(list);

         let mut front_wid: u32 = 0;

         let mut fallback_wid: u32 = 0;

         for i in 0..count {

             let dict = CFArrayGetValueAtIndex(list, i);

             let mut v: CFTypeRef = ptr::null();

             if CFDictionaryGetValueIfPresent(dict, layer_key as CFTypeRef, &mut v) {

                 CFNumberGetValue(v, kCFNumberSInt32Type, &mut layer as *mut _ as *mut _);

             }

             let mut pid: i32 = 0;

             if CFDictionaryGetValueIfPresent(dict, pid_key as CFTypeRef, &mut v) {

                 CFNumberGetValue(v, kCFNumberSInt32Type, &mut pid as *mut _ as *mut _);

             }

             let mut wid: u32 = 0;

             if CFDictionaryGetValueIfPresent(dict, wid_key as CFTypeRef, &mut v) {

                 CFNumberGetValue(v, kCFNumberSInt32Type, &mut wid as *mut _ as *mut _);

             }

             // Track first non-self window as fallback (z-order based)

             if fallback_wid == 0 {

                 fallback_wid = wid;

             }

             if pid == front_pid {

             }

         }

 /// Parse hex color string (#RRGGBB or #RRGGBBAA) to (r, g, b, a) floats.

 fn parse_color(s: &str) -> Option<(f64, f64, f64, f64)> {

     let hex = s.strip_prefix('#').unwrap_or(s);

     let r = u8::from_str_radix(&hex[0..2], 16).ok()? as f64 / 255.0;

     let g = u8::from_str_radix(&hex[2..4], 16).ok()? as f64 / 255.0;

     let b = u8::from_str_radix(&hex[4..6], 16).ok()? as f64 / 255.0;

     let a = if hex.len() == 8 {

         u8::from_str_radix(&hex[6..8], 16).ok()? as f64 / 255.0

     Some((r, g, b, a))

 }

     if borders.active_only {

         let focused = borders.focused_wid;

             .filter(|&&wid| wid != focused)

             .copied()

             .collect();

             // Promote pending creates that have waited ≥100ms (tarmac positioning time)

             let now = Instant::now();

                 .filter(|(wid, seen_at)| {

                 })

                 .map(|(wid, _)| *wid)

                 .collect();

             // If two new windows overlap closely, skip the larger one (container)

             let mut skip: std::collections::HashSet<u32> = HashSet::new();

             for i in 0..bounds_map.len() {

                     let (wid_a, a) = &bounds_map[i];

                     let (wid_b, b) = &bounds_map[j];

                     // Check if centers are close (within 30px)

                     let cy_b = b.origin.y + b.size.height / 2.0;

                     if (cx_a - cx_b).abs() < 30.0 && (cy_a - cy_b).abs() < 30.0 {

                         // Skip the larger one

                         if area_a > area_b {

                             skip.insert(*wid_a);

                         } else {

 fn setup_event_port(cid: CGSConnectionID) {

     unsafe {

         let mut port: u32 = 0;

         _CFMachPortSetOptions(cf_port, 0x40);

         let source = CFMachPortCreateRunLoopSource(ptr::null(), cf_port, 0);

         if !source.is_null() {

     }

 }

     unsafe {

         let cid = SLSMainConnectionID();

         let mut ev = SLEventCreateNextEvent(cid);

 fn discover_windows(_cid: CGSConnectionID, own_pid: i32) -> Vec<u32> {

     unsafe {

         let list = CGWindowListCopyWindowInfo(kCGWindowListOptionOnScreenOnly, kCGNullWindowID);

         let count = CFArrayGetCount(list);

         let mut wids = Vec::new();

         for i in 0..count {

             let dict = CFArrayGetValueAtIndex(list, i);

             let mut v: CFTypeRef = ptr::null();

             let mut wid: u32 = 0;

             if CFDictionaryGetValueIfPresent(dict, wid_key as CFTypeRef, &mut v) {

                 CFNumberGetValue(v, kCFNumberSInt32Type, &mut wid as *mut _ as *mut _);

             }

             let mut pid: i32 = 0;

             if CFDictionaryGetValueIfPresent(dict, pid_key as CFTypeRef, &mut v) {

                 CFNumberGetValue(v, kCFNumberSInt32Type, &mut pid as *mut _ as *mut _);

             }

             let mut layer: i32 = -1;

             if CFDictionaryGetValueIfPresent(dict, layer_key as CFTypeRef, &mut v) {

                 CFNumberGetValue(v, kCFNumberSInt32Type, &mut layer as *mut _ as *mut _);

             }

             wids.push(wid);

         }

             return None;

         }

         if bounds.size.width < 10.0 || bounds.size.height < 10.0 {

             return None;

         }

             return None;

         }

         SLSSetWindowResolution(cid, wid, 2.0);

         SLSSetWindowOpacity(cid, wid, false);

     let cid = unsafe { SLSMainConnectionID() };

     unsafe {

         let list = CGWindowListCopyWindowInfo(kCGWindowListOptionOnScreenOnly, kCGNullWindowID);

         let count = CFArrayGetCount(list);

         for i in 0..count {

             let dict = CFArrayGetValueAtIndex(list, i);

             let mut v: CFTypeRef = ptr::null();

             let mut wid: u32 = 0;

             if CFDictionaryGetValueIfPresent(dict, layer_key as CFTypeRef, &mut v) {

                 CFNumberGetValue(v, kCFNumberSInt32Type, &mut layer as *mut _ as *mut _);

             }

             let mut bounds = CGRect::default();

             SLSGetWindowBounds(cid, wid, &mut bounds);

         }

         CFRelease(wid_key as CFTypeRef);

         CFRelease(layer_key as CFTypeRef);

     }

 }