`40e1370`

Exclude overlays from screen capture via donut bounds path

Replaces the overlay's bounds region with a CGPath containing an outer
rect and an inner cutout. SLS evaluates the path with even-odd winding,
so the interior is treated as outside the window: screenshots taken
inside the bordered area capture the underlying app window instead of
the overlay. Pairs with SharingState/ClientPerceivedType advisories for
capture clients that honor them.

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 2 weeks ago

SHA: 40e13701b51ec1a6d45cfaf3aba3eb2f935fa825
Parents: f34604f
Tree: fdbee2a

2 changed files

Status	File	+	-
M	`src/main.rs`	30	0
M	`src/skylight.rs`	28	0

src/main.rsmodified

+         }
          SLSSetWindowEventMask(cid, wid, 0);
 +        // Capture-exclusion advisories. Tahoe's screen-capture picker
 +        // ignores both for SLS overlays but they're harmless and may help
 +        // capture clients that do honor them.
 +        SLSSetWindowSharingState(cid, wid, 0);
 +        SLSSetWindowClientPerceivedType(cid, wid, 2);
++
 +        // Replace the window's bounds region with a donut path: outer
 +        // rect plus an inner subpath for the interior. SLS interprets
 +        // the path with even-odd winding so the interior is *not* part
 +        // of the window — the screenshot picker hit-tests through to
 +        // the underlying app window. Done via SLSTransaction because
 +        // SLSTransactionSetWindowBoundsPath is the only path-based bounds
 +        // API exported on Tahoe; CGS region union APIs aren't linkable.
 +        let interior = CGRect::new(bw, bw, (ow - 2.0 * bw).max(0.0), (oh - 2.0 * bw).max(0.0));
 +        if interior.size.width > 0.0 && interior.size.height > 0.0 {
 +            let path = CGPathCreateMutable();
 +            if !path.is_null() {
 +                let outer = CGRect::new(0.0, 0.0, ow, oh);
 +                CGPathAddRect(path, ptr::null(), outer);
 +                CGPathAddRect(path, ptr::null(), interior);
 +                let txn = SLSTransactionCreate(cid);
 +                if !txn.is_null() {
 +                    SLSTransactionSetWindowBoundsPath(txn, cid, wid, path as CGPathRef);
 +                    SLSTransactionCommit(txn, 1);
 +                    CFRelease(txn);
 +                }
 +                CGPathRelease(path as CGPathRef);
 +            }
 +        }
++
          Some((cid, wid, bounds, scale))
+     }
+ }

src/skylight.rsmodified

      /// through to the window beneath. Equivalent to NSWindow's
      /// `setIgnoresMouseEvents(true)` at the SLS layer.
      pub fn SLSSetWindowEventShape(cid: CGSConnectionID, wid: u32, shape: CFTypeRef) -> CGError;
 +    /// NSWindowSharingType for the SLS window: 0 = None (excluded from
 +    /// screen capture / picker / recording), 1 = ReadOnly, 2 = ReadWrite.
 +    /// Tahoe's exported symbol is `SLSSetWindowSharingState` (not `Type`).
 +    /// Setting 0 makes the overlay invisible to ScreenCaptureKit, the
 +    /// cmd+shift+4 + space picker, etc., so user screenshots fall through
 +    /// to the underlying app window.
 +    pub fn SLSSetWindowSharingState(cid: CGSConnectionID, wid: u32, state: u32) -> CGError;
 +    /// Marks the SLS window as a non-standard "perceived type" so that
 +    /// screen-capture clients can choose to skip it. Yabai/skhd use this
 +    /// to keep borders out of screenshots without poisoning SLSNewWindow
 +    /// (unlike tag bits). Type 2 = "popup", 13/14 = system overlays.
 +    pub fn SLSSetWindowClientPerceivedType(
 +        cid: CGSConnectionID,
 +        wid: u32,
 +        kind: u32,
 +    ) -> CGError;
      pub fn SLSSetWindowAlpha(cid: CGSConnectionID, wid: u32, alpha: f32) -> CGError;
      pub fn SLSSetWindowBackgroundBlurRadius(cid: CGSConnectionID, wid: u32, radius: u32)
      -> CGError;
          y_offset: f32,
          shape: CFTypeRef,
      ) -> CGError;
 +    /// Sets a window's actual bounds region (what the window-server
 +    /// considers part of the window for hit-testing, capture, and
 +    /// rendering) using a CGPath instead of a CGS region. Lets us
 +    /// install a donut-shaped region without needing a multi-rect
 +    /// region constructor — none of which exist in linkable form on
 +    /// Tahoe except `CGSNewRegionWithRect` (single rect).
 +    pub fn SLSTransactionSetWindowBoundsPath(
 +        transaction: CFTypeRef,
 +        cid: CGSConnectionID,
 +        wid: u32,
 +        path: CGPathRef,
 +    ) -> CGError;
      // Flicker suppression
      pub fn SLSDisableUpdate(cid: CGSConnectionID) -> CGError;