`72f721e`

Re-log layout and force-resync overlays on display hotplug

Register CGDisplayRegisterReconfigurationCallback so a monitor plug
or resolution change re-fetches every overlay's bounds and re-applies
set_bounds. Without this, overlays whose CG bounds didn't change but
whose cocoa frame depends on the new primary screen height stayed at
their pre-hotplug positions until the next SLS Move event.

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 1 week ago

SHA: 72f721e7809c9a63e23e533ef91afc7ade3df6a2
Parents: e9322b0
Tree: dd4eb46

2 changed files

Status	File	+	-
M	`src/main.rs`	62	0
M	`src/skylight.rs`	11	0

src/main.rsmodified

          changed
+     }
 +    /// Re-apply set_bounds for every tracked overlay even when the
 +    /// stored CG bounds match the current SLS bounds. After a display
 +    /// reconfiguration the cocoa frame depends on the (possibly new)
 +    /// primary screen height, so unchanged CG bounds still need their
 +    /// cocoa frame recomputed.
 +    fn reconcile_all_force(&mut self) {
 +        let tracked: Vec<u32> = self.overlays.keys().copied().collect();
 +        let active_only = self.active_only;
 +        let focused = self.focused_wid;
 +        for wid in tracked {
 +            let mut bounds = CGRect::default();
 +            unsafe {
 +                if SLSGetWindowBounds(self.main_cid, wid, &mut bounds) != kCGErrorSuccess {
 +                    self.remove(wid);
 +                    continue;
 +                }
 +            }
 +            if let Some(overlay) = self.overlays.get_mut(&wid) {
 +                overlay.window.set_bounds(
 +                    bounds.origin.x,
 +                    bounds.origin.y,
 +                    bounds.size.width,
 +                    bounds.size.height,
 +                );
 +                if !active_only || wid == focused {
 +                    overlay.window.order_above(wid);
 +                }
 +            }
 +        }
 +    }
++
      /// With NSWindow.setFrame_display we no longer need a destroy-and-
      /// recreate path on resize. Kept as a thin alias so existing call
      /// sites keep working.
      // require a main-thread context.
      let mtm = nswindow_overlay::init_application();
      nswindow_overlay::log_screens(mtm);
 +    register_display_hotplug_callback();
      let cid = unsafe { SLSMainConnectionID() };
      let own_pid = unsafe {
      borders.enforce_active_only();
+ }
 +/// Re-log the screen layout when the display configuration changes
 +/// (monitor plug/unplug, resolution change). The callback also nudges
 +/// every tracked overlay to re-fetch its bounds so any cached cocoa Y
 +/// computed against the old primary height gets refreshed.
 +unsafe extern "C" fn display_reconfig_callback(
 +    display_id: u32,
 +    flags: u32,
 +    _user_info: *mut std::ffi::c_void,
 +) {
 +    debug!(display_id, flags, "[hotplug] CGDisplay reconfiguration");
 +    if let Some(mtm) = objc2::MainThreadMarker::new() {
 +        nswindow_overlay::log_screens(mtm);
 +    }
 +    MAIN_STATE.with(|cell| {
 +        if let Some(s) = cell.borrow_mut().as_mut() {
 +            s.borders.reconcile_all_force();
 +        }
 +    });
 +}
++
 +fn register_display_hotplug_callback() {
 +    unsafe {
 +        let rc = CGDisplayRegisterReconfigurationCallback(
 +            Some(display_reconfig_callback),
 +            std::ptr::null_mut(),
 +        );
 +        debug!("[hotplug] register CGDisplayReconfiguration rc={}", rc);
 +    }
 +}
++
  fn setup_event_port(cid: CGSConnectionID) {
      unsafe {
          let mut port: u32 = 0;

src/skylight.rsmodified

      pub static mach_task_self_: u32;
+ }
 +// --- CGDisplay hotplug callback ---
++
 +unsafe extern "C" {
 +    pub fn CGDisplayRegisterReconfigurationCallback(
 +        callback: Option<
 +            unsafe extern "C" fn(display: u32, flags: u32, user_info: *mut std::ffi::c_void),
 +        >,
 +        user_info: *mut std::ffi::c_void,
 +    ) -> i32;
 +}
++
  pub fn mach_task_self() -> u32 {
      unsafe { mach_task_self_ }
+ }