`1319fb0`

Fix close-persistence and new-window race

Two bugs from user testing:

1. Spawning a new terminal made the border disappear until the next
focus move. Cause: focus moves to the new wid before its SLS state
passes the add_fresh filter (SLSWindowIsOrderedIn race). The
focus-changed branch attempted add_fresh once and gave up; the
focus-unchanged branch returned early, never retrying.

Fix: in update_focus, when front == focused_wid AND the focused
wid still has no overlay, retry add_fresh on every poll. The
filter passes once the new window settles (typically 1-2 ticks).

2. Closing the only window on a workspace left a phantom border.
Cause: sync_overlay returned early on SLSGetWindowBounds failure
(which is what happens for a destroyed wid) without removing the
overlay. The Drop never fired, so NSWindow.orderOut never ran.

Fix: on SLSGetWindowBounds failure, treat the window as gone and
call remove() to drop the overlay.

Also: timer's idle branch now runs reconcile_tracked once per second
as a safety net for any other class of missed Close/Destroy event.

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

SHA: 1319fb0360ef7bd78ea9b104a1e38fdd30d97cc8
Parents: 2ee2632
Tree: 4acaa8a

1 changed file

Status	File	+	-
M	`src/main.rs`	46	4

src/main.rsmodified

+     }
      fn remove(&mut self, target_wid: u32) {
 -        // OverlayWindow's Drop closes the NSWindow.
 -        self.overlays.remove(&target_wid);
 +        if let Some(overlay) = self.overlays.remove(&target_wid) {
 +            debug!(
 +                "[remove] target={} overlay_wid={} dropping NSWindow",
 +                target_wid,
 +                overlay.wid()
 +            );
 +            // OverlayWindow's Drop runs orderOut + close.
 +            drop(overlay);
 +        } else {
 +            debug!("[remove] target={} not tracked", target_wid);
 +        }
+     }
      /// Reconcile a tracked overlay against its target window.
          let mut bounds = CGRect::default();
          unsafe {
              if SLSGetWindowBounds(self.main_cid, target_wid, &mut bounds) != kCGErrorSuccess {
 -                return false;
 +                // Window is gone (destroyed). Reap the overlay.
 +                debug!(
 +                    "[sync_overlay] target={} SLSGetWindowBounds failed — reaping overlay",
 +                    target_wid
 +                );
 +                self.remove(target_wid);
 +                return true;
+             }
              if !is_suitable_window(self.main_cid, target_wid) {
      /// Detect focused window and update border colors if focus changed.
      fn update_focus(&mut self) {
          let front = get_front_window(self.own_pid);
 -        if front == 0 || front == self.focused_wid {
 +        if front == 0 {
 +            return;
 +        }
 +        if front == self.focused_wid {
 +            // Same focus as last poll. But a freshly-spawned window may
 +            // have been focused before its SLS state was complete enough
 +            // to pass the add_fresh filter — retry on every poll until
 +            // it sticks.
 +            if !self.overlays.contains_key(&front) {
 +                debug!("[focus-retry] front={} still untracked, retrying add_fresh", front);
 +                self.add_fresh(front);
 +                if self.overlays.contains_key(&front) {
 +                    self.subscribe_target(front);
 +                    if self.active_only {
 +                        self.unhide(front);
 +                    }
 +                }
 +            }
              return;
+         }
              // FrontChange notification doesn't strand the active border.
              // Cheap operation when focus hasn't changed.
              s.borders.update_focus();
 +            // Once per second, reconcile tracked overlays against
 +            // current SLS state. Catches missed Close/Destroy events
 +            // that would otherwise leave a dead border on screen.
 +            if tick % 60 == 0 && tick > 0 {
 +                let removed = s.borders.reconcile_tracked();
 +                if removed {
 +                    debug!("[timer] periodic reconcile removed stale overlays");
 +                }
 +            }
+         }
      });
+ }
+             }
              Event::Close(wid) | Event::Destroy(wid) => {
                  if !borders.is_overlay(wid) {
 +                    debug!("[event] Close/Destroy target_wid={}", wid);
                      destroyed.insert(wid);
                      pending.remove(&wid);
+                 }