Allow rsnap windows to be externally capturable

packages/rsnap-overlay/src/overlay.rs

@@ -865,6 +865,7 @@ pub struct OverlaySession {
 	window_list_refresh_interval: Duration,
 	last_live_bg_request_at: Instant,
 	live_bg_request_interval: Duration,
+	freeze_capture_send_full_count: u64,
 	hit_test_send_full_count: u64,
 	hit_test_send_disconnected_count: u64,
 	hit_test_request_id: u64,
@@ -1088,6 +1089,7 @@ impl OverlaySession {
 			window_list_refresh_interval: Duration::ZERO,
 			last_live_bg_request_at: Instant::now(),
 			live_bg_request_interval: Duration::ZERO,
+			freeze_capture_send_full_count: 0,
 			hit_test_send_full_count: 0,
 			hit_test_send_disconnected_count: 0,
 			hit_test_request_id: 0,
@@ -1490,20 +1492,7 @@ impl OverlaySession {
 	}
 
 	#[cfg(target_os = "macos")]
-	fn try_latest_live_freeze_preview(&mut self, monitor: MonitorRect) -> Option<RgbaImage> {
-		if self.state.live_bg_monitor == Some(monitor)
-			&& let Some(image) = self.state.live_bg_image.take()
-		{
-			return Some(image);
-		}
-
-		self.live_sample_stream
-			.as_ref()
-			.and_then(|stream| stream.peek_latest_rgba_snapshot(monitor))
-			.map(|snapshot| snapshot.image.as_ref().clone())
-	}
-
-	#[cfg(target_os = "macos")]
+	#[allow(dead_code)]
 	fn commit_frozen_preview(
 		&mut self,
 		monitor: MonitorRect,
@@ -1665,6 +1654,7 @@ impl OverlaySession {
 		self.pending_freeze_capture_armed = false;
 		self.inflight_freeze_capture = None;
 		self.authoritative_frozen_capture_ready = false;
+		self.freeze_capture_send_full_count = 0;
 		self.pending_window_freeze_capture = window_target;
 		self.inflight_window_freeze_capture = None;
 		self.frozen_window_image = None;
@@ -1678,17 +1668,14 @@ impl OverlaySession {
 
 		#[cfg(target_os = "macos")]
 		{
-			if let Some(image) = self.try_latest_live_freeze_preview(monitor) {
-				self.state.live_bg_monitor = None;
-				self.state.live_bg_image = None;
+			let _ = cursor;
 
-				self.commit_frozen_preview(monitor, image, cursor);
-				self.force_apply_pending_toolbar_window_move();
-			} else {
-				self.state.live_bg_monitor = None;
-				self.state.live_bg_image = None;
-				self.capture_windows_hidden = true;
-			}
+			self.state.live_bg_monitor = None;
+			self.state.live_bg_image = None;
+			self.capture_windows_hidden = true;
+			self.pending_freeze_capture_armed = true;
+
+			self.hide_capture_windows();
 		}
 		#[cfg(not(target_os = "macos"))]
 		{
@@ -4728,7 +4715,11 @@ impl OverlaySession {
 			}
 
 			self.state.finish_freeze(monitor, frozen_preview_image);
+			#[cfg(target_os = "macos")]
+			self.destroy_live_only_aux_windows();
 			self.restore_capture_windows_visibility();
+			#[cfg(target_os = "macos")]
+			self.request_aux_window_creation_if_needed();
 
 			self.toolbar_state.needs_redraw = true;
 
@@ -5242,6 +5233,13 @@ impl OverlaySession {
 				return;
 			};
 
+			#[cfg(target_os = "macos")]
+			if self.loupe_window.is_none() {
+				self.request_aux_window_creation_if_needed();
+
+				return;
+			}
+
 			self.maybe_apply_pending_startup_aux_live_stream_filter_upgrade(monitor);
 
 			let visible = self.update_loupe_window_position(monitor);
@@ -6747,6 +6745,11 @@ impl OverlaySession {
 			{
 				self.toolbar_state.visible = !self.toolbar_state.visible;
 
+				#[cfg(target_os = "macos")]
+				if self.toolbar_state.visible {
+					self.request_aux_window_creation_if_needed();
+				}
+
 				self.request_redraw_all();
 
 				OverlayControl::Continue
@@ -7265,6 +7268,7 @@ impl OverlaySession {
 				"Entered scroll-capture mode."
 			);
 
+			self.request_aux_window_creation_if_needed();
 			self.sync_frozen_toolbar_state();
 			self.refresh_scroll_preview_committed_image();
 			self.refresh_scroll_preview_display_image();
@@ -7983,43 +7987,40 @@ impl OverlaySession {
 		overlay_monitor: MonitorRect,
 		draw_toolbar: bool,
 	) -> OverlayControl {
-		if self.should_dispatch_pending_freeze_capture(overlay_monitor)
-			&& let Some(worker) = &self.worker
-		{
+		if self.should_dispatch_pending_freeze_capture(overlay_monitor) {
 			let pending_window_target = self
 				.pending_window_freeze_capture
 				.filter(|target| target.monitor == overlay_monitor);
 			let freeze_target = pending_window_target
 				.map_or(FreezeCaptureTarget::Monitor, |target| FreezeCaptureTarget::Window {
 					window_id: target.window_id,
 				});
-
 			#[cfg(target_os = "macos")]
-			{
-				if worker.request_freeze_capture(overlay_monitor, freeze_target) {
-					self.pending_freeze_capture = None;
-					self.pending_freeze_capture_armed = false;
-					self.inflight_freeze_capture = Some(overlay_monitor);
-					self.inflight_window_freeze_capture = pending_window_target;
-					self.pending_window_freeze_capture = None;
-				} else {
-					self.request_redraw_for_monitor(overlay_monitor);
-				}
-			}
+			let _ = (&freeze_target, &pending_window_target, &overlay_monitor);
+
 			#[cfg(not(target_os = "macos"))]
 			{
 				// Capture must happen on a post-hide redraw so the HUD/loupe are not included.
 				if self.pending_freeze_capture_armed {
-					if worker.request_freeze_capture(overlay_monitor, freeze_target) {
-						self.pending_freeze_capture = None;
-						self.pending_freeze_capture_armed = false;
-						self.inflight_freeze_capture = Some(overlay_monitor);
-						self.inflight_window_freeze_capture = pending_window_target;
-						self.pending_window_freeze_capture = None;
-					} else {
-						self.request_redraw_for_monitor(overlay_monitor);
+					let Some(worker) = &self.worker else {
+						self.abort_pending_freeze_capture("Capture worker is unavailable.");
+
+						return OverlayControl::Continue;
+					};
+
+					match worker.request_freeze_capture(overlay_monitor, freeze_target) {
+						Ok(()) => {
+							self.note_freeze_capture_request_started(
+								overlay_monitor,
+								pending_window_target,
+							);
+						},
+						Err(err) => {
+							self.handle_freeze_capture_request_send_error(overlay_monitor, err);
+						},
 					}
 				} else {
+					self.freeze_capture_send_full_count = 0;
 					self.pending_freeze_capture_armed = true;
 
 					#[cfg(not(target_os = "macos"))]
@@ -8231,6 +8232,10 @@ impl OverlaySession {
 		self.event_loop_last_progress_monitor_id = None;
 		self.event_loop_last_progress_detail = None;
 		self.event_loop_last_stall_warn_at = None;
+
+		#[cfg(target_os = "macos")]
+		self.macos_hud_window_config_cache.clear();
+
 		self.toolbar_left_button_down = false;
 		self.toolbar_left_button_went_down = false;
 		self.toolbar_left_button_went_up = false;
@@ -9071,8 +9076,6 @@ fn macos_configure_overlay_window_mouse_moved_events(window: &Window) {
 
 		let _: () = objc::msg_send![ns_window, setOpaque: false];
 		let _: () = objc::msg_send![ns_window, setHasShadow: false];
-		let sharing_type_none = 0_u64;
-		let _: () = objc::msg_send![ns_window, setSharingType: sharing_type_none];
 		let clear: *mut Object = objc::msg_send![objc::class!(NSColor), clearColor];
 		let _: () = objc::msg_send![ns_window, setBackgroundColor: clear];
 		let _: () = objc::msg_send![ns_window, setLevel: MACOS_OVERLAY_WINDOW_LEVEL];
@@ -9134,8 +9137,6 @@ fn macos_configure_hud_window(
 		let _: () = objc::msg_send![ns_window, setHasShadow: false];
 		let _: () = objc::msg_send![ns_window, setAcceptsMouseMovedEvents: YES];
 		let _: () = objc::msg_send![ns_window, setLevel: MACOS_HUD_WINDOW_LEVEL];
-		let sharing_type_none = 0_u64;
-		let _: () = objc::msg_send![ns_window, setSharingType: sharing_type_none];
 		let clear: *mut Object = objc::msg_send![objc::class!(NSColor), clearColor];
 		let _: () = objc::msg_send![ns_window, setBackgroundColor: clear];
 		let content_view: *mut Object = objc::msg_send![ns_window, contentView];

packages/rsnap-overlay/src/overlay/aux_window_runtime.rs

@@ -64,6 +64,8 @@ impl OverlaySession {
 		self.maybe_log_event_loop_stall(now);
 		self.mark_progress(OverlayEventLoopPhase::AboutToWait);
 		self.maybe_clear_loupe_activation_after_focus_loss();
+		#[cfg(target_os = "macos")]
+		self.maybe_dispatch_armed_freeze_capture();
 		self.maybe_request_keepalive_redraw();
 		self.maybe_keep_selection_flow_repaint();
 		self.maybe_keep_frozen_text_caret_repaint();

packages/rsnap-overlay/src/overlay/capture_window_runtime.rs

@@ -1,12 +1,48 @@
 #[allow(unused_imports)]
-use crate::overlay::{GlobalPoint, MonitorRect, OverlayMode, OverlaySession};
+use crate::overlay::{GlobalPoint, Instant, MonitorRect, OverlayMode, OverlaySession};
 
 impl OverlaySession {
 	pub(super) fn update_cursor_state(&mut self, monitor: MonitorRect, cursor: GlobalPoint) {
 		self.cursor_monitor = Some(monitor);
 		self.state.cursor = Some(cursor);
 	}
 
+	#[cfg(target_os = "macos")]
+	pub(super) fn hide_capture_windows(&mut self) {
+		self.capture_windows_hidden = true;
+
+		for overlay_window in self.windows.values() {
+			overlay_window.window.set_visible(false);
+		}
+
+		if let Some(hud_window) = &self.hud_window {
+			hud_window.window.set_visible(false);
+		}
+
+		self.hud_window_visible = false;
+
+		if let Some(loupe_window) = &self.loupe_window {
+			loupe_window.window.set_visible(false);
+		}
+
+		self.loupe_window_visible = false;
+
+		self.reset_loupe_window_warmup_redraws();
+
+		if let Some(toolbar_window) = &self.toolbar_window {
+			toolbar_window.window.set_visible(false);
+		}
+
+		self.toolbar_window_visible = false;
+		self.toolbar_window_warmup_redraws_remaining = 0;
+
+		if let Some(preview_window) = &self.scroll_preview_window {
+			preview_window.window.set_visible(false);
+		}
+
+		self.last_present_at = Instant::now();
+	}
+
 	#[cfg(not(target_os = "macos"))]
 	pub(super) fn hide_capture_windows(&mut self) {
 		self.capture_windows_hidden = true;
@@ -28,6 +64,58 @@ impl OverlaySession {
 		}
 
 		self.capture_windows_hidden = false;
+		#[cfg(target_os = "macos")]
+		{
+			for overlay_window in self.windows.values() {
+				overlay_window.window.set_visible(true);
+				overlay_window.window.request_redraw();
+			}
+
+			if matches!(self.state.mode, OverlayMode::Live) {
+				if let Some(hud_window) = &self.hud_window {
+					hud_window.window.set_visible(true);
+					hud_window.window.request_redraw();
+				}
+
+				self.hud_window_visible = self.hud_window.is_some();
+
+				if let Some(loupe_window) = &self.loupe_window {
+					loupe_window.window.set_visible(self.state.alt_held);
+					loupe_window.window.request_redraw();
+				}
+
+				self.loupe_window_visible = self.state.alt_held && self.loupe_window.is_some();
+
+				return;
+			}
+
+			self.hud_window_visible = false;
+			self.loupe_window_visible = false;
+
+			if let Some(toolbar_window) = &self.toolbar_window {
+				let show_toolbar = matches!(self.state.mode, OverlayMode::Frozen)
+					&& self.toolbar_state.visible
+					&& self.authoritative_frozen_capture_ready
+					&& self.state.frozen_image.is_some();
+
+				toolbar_window.window.set_visible(show_toolbar);
+
+				if show_toolbar {
+					toolbar_window.window.request_redraw();
+				}
+
+				self.toolbar_window_visible = show_toolbar;
+			} else {
+				self.toolbar_window_visible = false;
+			}
+			if let Some(preview_window) = &self.scroll_preview_window {
+				preview_window.window.set_visible(self.scroll_capture.active);
+
+				if self.scroll_capture.active {
+					preview_window.window.request_redraw();
+				}
+			}
+		}
 		#[cfg(not(target_os = "macos"))]
 		{
 			if matches!(self.state.mode, OverlayMode::Live) {
@@ -59,4 +147,18 @@ impl OverlaySession {
 			loupe_window.window.focus_window();
 		}
 	}
+
+	#[cfg(target_os = "macos")]
+	pub(super) fn destroy_live_only_aux_windows(&mut self) {
+		if let Some(loupe_window) = self.loupe_window.take() {
+			self.remove_macos_hud_window_config_cache_entry(loupe_window.window.id());
+		}
+
+		self.loupe_inner_size_points = None;
+		self.loupe_outer_pos = None;
+		self.pending_loupe_outer_pos = None;
+		self.loupe_window_visible = false;
+
+		self.reset_loupe_window_warmup_redraws();
+	}
 }