`61997d6`

Periodically re-apply CAShapeLayer geometry to recover from sleep/wake

NSWindow.frame survives display sleep/wake correctly (placed_correctly
logs always returned true), but the CAShapeLayer's frame/path can be
reset to a small rect at the layer origin during the wake transition.
Because SLS window bounds didn't change, sync_overlay never re-applied
state — leaving a tiny border in the bottom-left corner of an
otherwise-correctly-positioned window.

Add OverlayWindow::reapply_layer (cheap — only the layer, not the
NSWindow) and call it once a second from the periodic reconcile, plus
on every CGDisplayReconfiguration hotplug.

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

SHA: 61997d6a583663ebe92d34346bb206a233aa9e2e
Parents: 55bd2f9
Tree: cf26f60

2 changed files

Status	File	+	-
M	`src/main.rs`	17	0
M	`src/nswindow_overlay.rs`	26	0

src/main.rsmodified

          changed
+     }
 +    /// Re-apply each overlay's CAShapeLayer geometry. Called on a slow
 +    /// periodic schedule (and on hotplug) to repair layer state that
 +    /// macOS occasionally resets during display sleep/wake without
 +    /// changing the NSWindow's frame — sync_overlay won't fix it on
 +    /// its own because the SLS bounds match what we already stored.
 +    fn refresh_all_layers(&self) {
 +        for overlay in self.overlays.values() {
 +            overlay.window.reapply_layer();
 +        }
 +    }
++
      /// 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)
                  if removed {
                      debug!("[timer] periodic reconcile removed stale overlays");
+                 }
 +                // Cheap: re-applies just the CAShapeLayer frame/path
 +                // for every overlay. Recovers from layer state that
 +                // macOS resets during display sleep/wake without
 +                // touching the NSWindow frame.
 +                s.borders.refresh_all_layers();
+             }
+         }
      });
      MAIN_STATE.with(|cell| {
          if let Some(s) = cell.borrow_mut().as_mut() {
              s.borders.reconcile_all_force();
 +            s.borders.refresh_all_layers();
+         }
      });
+ }

src/nswindow_overlay.rsmodified

          self.bounds_cg_h = h;
+     }
 +    /// Re-apply just the CAShapeLayer's frame and path to match the
 +    /// current stored bounds. Cheap — no NSWindow setFrame. Useful when
 +    /// macOS resets layer state during display sleep/wake but the
 +    /// NSWindow's frame survives (in which case sync_overlay won't see
 +    /// any CG bounds change and won't re-apply state on its own).
 +    pub fn reapply_layer(&self) {
 +        let outer_w = self.bounds_cg_w + 2.0 * self.border_width;
 +        let outer_h = self.bounds_cg_h + 2.0 * self.border_width;
 +        let outer_size = CGSize::new(outer_w, outer_h);
 +        unsafe {
 +            let path = objc2_core_graphics::CGPath::with_rounded_rect(
 +                inset_for_stroke(outer_size, self.border_width),
 +                self.radius,
 +                self.radius,
 +                ptr::null(),
 +            );
 +            let path_ref: *mut AnyObject =
 +                objc2_core_foundation::CFRetained::as_ptr(&path).as_ptr() as *mut AnyObject;
 +            let _: () = msg_send![&*self.border_layer, setPath: path_ref];
 +            self.border_layer.setFrame(CGRect::new(
 +                CGPoint::new(0.0, 0.0),
 +                CGSize::new(outer_w, outer_h),
 +            ));
 +        }
 +    }
++
      pub fn set_color(&self, color: (f64, f64, f64, f64)) {
          unsafe {
              let stroke = make_cgcolor(color, self.mtm);