Smooth frozen selection drag interactions

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

@@ -302,6 +302,7 @@ impl OverlaySession {
 
 		self.maybe_apply_pending_hud_window_move(now);
 		self.maybe_apply_pending_loupe_window_move(now);
+		self.maybe_apply_pending_toolbar_window_move(now);
 	}
 
 	pub(super) fn maybe_apply_pending_hud_window_move(&mut self, now: Instant) {
@@ -354,6 +355,7 @@ impl OverlaySession {
 	pub(super) fn force_apply_pending_hud_and_loupe_moves(&mut self) {
 		self.force_apply_pending_hud_window_move();
 		self.force_apply_pending_loupe_window_move();
+		self.force_apply_pending_toolbar_window_move();
 	}
 
 	pub(super) fn maybe_apply_pending_loupe_window_move(&mut self, now: Instant) {
@@ -410,6 +412,65 @@ impl OverlaySession {
 		self.last_loupe_window_move_at = now;
 	}
 
+	pub(super) fn maybe_apply_pending_toolbar_window_move(&mut self, now: Instant) {
+		self.apply_pending_toolbar_window_move(now, false);
+	}
+
+	pub(super) fn force_apply_pending_toolbar_window_move(&mut self) {
+		self.apply_pending_toolbar_window_move(Instant::now(), true);
+	}
+
+	pub(super) fn apply_pending_toolbar_window_move(&mut self, now: Instant, force: bool) {
+		let Some(desired) = self.pending_toolbar_outer_pos else {
+			return;
+		};
+
+		if self.frozen_selection_drag_hides_auxiliary_windows() {
+			return;
+		}
+
+		let elapsed = now.duration_since(self.last_toolbar_window_move_at);
+		let interval = self
+			.repaint_interval_for_monitor(self.state.monitor.or(self.active_cursor_monitor()))
+			.max(HUD_LOUPE_MOVE_INTERVAL_MIN);
+
+		if !force && elapsed < interval {
+			let delay = interval.saturating_sub(elapsed);
+
+			self.schedule_egui_repaint_after(delay);
+
+			return;
+		}
+
+		let Some(toolbar_window) = self.toolbar_window.as_ref() else {
+			return;
+		};
+		let started_at = Instant::now();
+
+		toolbar_window
+			.window
+			.set_outer_position(LogicalPosition::new(desired.x as f64, desired.y as f64));
+
+		let elapsed = started_at.elapsed();
+
+		self.slow_op_logger.warn_if_slow(
+			"overlay.toolbar_window_set_outer_position",
+			elapsed,
+			SLOW_OP_WARN_OUTER_POSITION,
+			|| {
+				format!(
+					"window_id={:?} pos=({}, {})",
+					toolbar_window.window.id(),
+					desired.x,
+					desired.y
+				)
+			},
+		);
+
+		self.pending_toolbar_outer_pos = None;
+		self.last_toolbar_window_move_at = now;
+	}
+
 	pub(super) fn schedule_egui_repaint_after(&self, delay: Duration) {
 		let deadline = Instant::now() + delay;
 		let mut next_repaint =

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

@@ -33,6 +33,18 @@ impl OverlaySession {
 	}
 
 	pub(super) fn maybe_skip_hud_redraw(&mut self) -> Option<OverlayControl> {
+		if self.frozen_selection_drag_hides_auxiliary_windows() {
+			if let Some(hud_window) = self.hud_window.as_ref()
+				&& self.hud_window_visible
+			{
+				hud_window.window.set_visible(false);
+			}
+
+			self.hud_window_visible = false;
+			self.last_present_at = Instant::now();
+
+			return Some(OverlayControl::Continue);
+		}
 		if self.scroll_capture.active {
 			if let Some(hud_window) = self.hud_window.as_ref()
 				&& self.hud_window_visible
@@ -327,7 +339,8 @@ impl OverlaySession {
 	}
 
 	pub(super) fn should_skip_loupe_redraw(&self) -> bool {
-		self.scroll_capture.active
+		self.frozen_selection_drag_hides_auxiliary_windows()
+			|| self.scroll_capture.active
 			|| self.capture_windows_hidden
 			|| !self.state.alt_held
 			|| (matches!(self.state.mode, OverlayMode::Live) && self.live_loupe_uses_hud_window())

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

@@ -142,16 +142,19 @@ impl OverlaySession {
 	}
 
 	pub(super) fn handle_scroll_preview_redraw_requested(&mut self) -> OverlayControl {
+		let should_hide_preview = self.should_hide_scroll_preview_window();
 		let Some(preview_window) = self.scroll_preview_window.as_mut() else {
 			return OverlayControl::Continue;
 		};
 
-		if !self.scroll_capture.active {
+		if should_hide_preview {
 			preview_window.window.set_visible(false);
 
 			return OverlayControl::Continue;
 		}
 
+		preview_window.window.set_visible(true);
+
 		let theme =
 			hud_helpers::effective_hud_theme(self.config.theme_mode, preview_window.window.theme());
 		let view = ScrollPreviewView { paused: self.scroll_capture.paused, theme };
@@ -165,6 +168,10 @@ impl OverlaySession {
 		}
 	}
 
+	pub(super) fn should_hide_scroll_preview_window(&self) -> bool {
+		self.frozen_selection_drag_hides_auxiliary_windows() || !self.scroll_capture.active
+	}
+
 	#[cfg(target_os = "macos")]
 	pub(super) fn position_scroll_preview_window(&self, monitor: MonitorRect) {
 		let Some(preview_window) = self.scroll_preview_window.as_ref() else {

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

@@ -118,6 +118,17 @@ pub(super) struct CursorMoveTrace {
 	pub(super) source: DeviceCursorPointSource,
 }
 
+#[derive(Clone, Copy)]
+pub(super) struct FrozenSelectionDragCursorMoveTiming {
+	pub(super) cursor_update_elapsed: Duration,
+	pub(super) live_drag_update_elapsed: Duration,
+	pub(super) frozen_drag_update_elapsed: Duration,
+	pub(super) frozen_rect_changed: bool,
+	pub(super) sync_cursor_icons_elapsed: Duration,
+	pub(super) request_samples_elapsed: Duration,
+	pub(super) total_elapsed: Duration,
+}
+
 #[derive(Clone, Copy, Debug)]
 pub(super) struct HudDrawConfig {
 	pub(super) can_draw_hud: bool,

packages/rsnap-overlay/src/overlay/tests/rendering_behaviors.rs

@@ -8,10 +8,10 @@ use winit::window::CursorIcon;
 use crate::OverlayControl;
 #[allow(unused_imports)]
 use crate::overlay::tests::{
-	self, ElementState, FrozenCaptureSource, FrozenSelectionDragState, FrozenToolbarState,
-	FrozenToolbarTool, GlobalPoint, HUD_LOUPE_STRIP_GAP_POINTS, HudTheme, MonitorRect,
-	MonitorRectPoints, MouseButton, OverlayMode, OverlaySession, OverlayState, PngAction, Pos2,
-	RawInput, Rect, RectPoints, Rgba, SELECTION_DASHED_BORDER_DASH_LENGTH_PX,
+	self, Duration, ElementState, FrozenCaptureSource, FrozenSelectionDragState,
+	FrozenToolbarState, FrozenToolbarTool, GlobalPoint, HUD_LOUPE_STRIP_GAP_POINTS, HudTheme,
+	MonitorRect, MonitorRectPoints, MouseButton, OverlayMode, OverlaySession, OverlayState,
+	PngAction, Pos2, RawInput, Rect, RectPoints, Rgba, SELECTION_DASHED_BORDER_DASH_LENGTH_PX,
 	SELECTION_DASHED_BORDER_GAP_LENGTH_PX, SELECTION_DASHED_BORDER_WIDTH_PX,
 	SELECTION_SIZE_BADGE_GAP_PX, SELECTION_SIZE_BADGE_INSIDE_MARGIN_PX,
 	SELECTION_SIZE_BADGE_SCREEN_MARGIN_PX, ScrollSession, SelectionDashedBorderCache,
@@ -221,6 +221,114 @@ fn frozen_selection_drag_updates_capture_rect_and_toolbar_position() {
 	assert_eq!(session.toolbar_state.floating_position, Some(expected_toolbar_pos));
 }
 
+#[test]
+fn frozen_selection_drag_hides_auxiliary_windows_while_active() {
+	let monitor = tests::test_monitor();
+	let capture_rect = RectPoints::new(100, 120, 200, 240);
+	let mut session = OverlaySession::new();
+
+	session.state.begin_freeze(monitor);
+	session.state.finish_freeze(monitor, tests::test_frozen_image());
+
+	session.state.frozen_capture_rect = Some(capture_rect);
+	session.frozen_capture_source = FrozenCaptureSource::DragRegion;
+	session.toolbar_state.visible = true;
+	session.hud_window_visible = true;
+	session.loupe_window_visible = true;
+	session.toolbar_window_visible = true;
+
+	assert!(!session.frozen_selection_drag_hides_auxiliary_windows());
+	assert!(!session.should_hide_toolbar_window(monitor));
+	assert!(session.should_hide_scroll_preview_window());
+	assert!(session.begin_frozen_selection_drag(GlobalPoint::new(150, 180)));
+	assert!(session.frozen_selection_drag_hides_auxiliary_windows());
+	assert!(!session.hud_window_visible);
+	assert!(!session.loupe_window_visible);
+	assert!(!session.toolbar_window_visible);
+	assert!(session.skip_toolbar_focus_on_next_show);
+	assert!(session.should_hide_toolbar_window(monitor));
+	assert!(!session.should_focus_frozen_toolbar_window_on_show());
+
+	session.stop_frozen_selection_drag();
+
+	assert!(!session.frozen_selection_drag_hides_auxiliary_windows());
+	assert!(!session.should_hide_toolbar_window(monitor));
+	assert!(!session.should_focus_frozen_toolbar_window_on_show());
+}
+
+#[test]
+fn frozen_selection_drag_releases_scroll_preview_hide_after_drag_stops() {
+	let monitor = tests::test_monitor();
+	let capture_rect = RectPoints::new(100, 120, 200, 240);
+	let mut session = OverlaySession::new();
+
+	session.state.begin_freeze(monitor);
+	session.state.finish_freeze(monitor, tests::test_frozen_image());
+
+	session.state.frozen_capture_rect = Some(capture_rect);
+	session.frozen_capture_source = FrozenCaptureSource::DragRegion;
+
+	assert!(session.begin_frozen_selection_drag(GlobalPoint::new(150, 180)));
+
+	session.scroll_capture.active = true;
+
+	assert!(session.should_hide_scroll_preview_window());
+
+	session.stop_frozen_selection_drag();
+
+	assert!(!session.should_hide_scroll_preview_window());
+}
+
+#[test]
+fn frozen_selection_drag_defers_pending_toolbar_window_move() {
+	let monitor = tests::test_monitor();
+	let capture_rect = RectPoints::new(100, 120, 200, 240);
+	let mut session = OverlaySession::new();
+
+	session.state.begin_freeze(monitor);
+	session.state.finish_freeze(monitor, tests::test_frozen_image());
+
+	session.state.frozen_capture_rect = Some(capture_rect);
+	session.frozen_capture_source = FrozenCaptureSource::DragRegion;
+
+	assert!(session.begin_frozen_selection_drag(GlobalPoint::new(150, 180)));
+
+	let last_move_at = session.last_toolbar_window_move_at;
+
+	session.pending_toolbar_outer_pos = Some(GlobalPoint::new(220, 260));
+
+	session.maybe_apply_pending_toolbar_window_move(last_move_at + Duration::from_millis(32));
+
+	assert_eq!(session.pending_toolbar_outer_pos, Some(GlobalPoint::new(220, 260)));
+	assert_eq!(session.last_toolbar_window_move_at, last_move_at);
+}
+
+#[test]
+fn frozen_selection_drag_skips_toolbar_focus_even_before_first_show() {
+	let monitor = tests::test_monitor();
+	let capture_rect = RectPoints::new(100, 120, 200, 240);
+	let mut session = OverlaySession::new();
+
+	session.state.begin_freeze(monitor);
+	session.state.finish_freeze(monitor, tests::test_frozen_image());
+
+	session.state.frozen_capture_rect = Some(capture_rect);
+	session.frozen_capture_source = FrozenCaptureSource::DragRegion;
+	session.toolbar_state.visible = true;
+
+	assert!(!session.toolbar_window_visible);
+	assert!(!session.skip_toolbar_focus_on_next_show);
+	assert!(session.should_focus_frozen_toolbar_window_on_show());
+	assert!(session.begin_frozen_selection_drag(GlobalPoint::new(150, 180)));
+	assert!(session.skip_toolbar_focus_on_next_show);
+	assert!(!session.should_focus_frozen_toolbar_window_on_show());
+
+	session.stop_frozen_selection_drag();
+
+	assert!(session.skip_toolbar_focus_on_next_show);
+	assert!(!session.should_focus_frozen_toolbar_window_on_show());
+}
+
 #[test]
 fn frozen_selection_resize_updates_capture_rect_and_toolbar_position() {
 	let monitor = tests::test_monitor();
@@ -246,6 +354,19 @@ fn frozen_selection_resize_updates_capture_rect_and_toolbar_position() {
 	assert_eq!(session.toolbar_state.floating_position, Some(expected_toolbar_pos));
 }
 
+#[test]
+fn toolbar_position_update_queues_pending_move_without_window() {
+	let monitor = tests::test_monitor();
+	let mut session = OverlaySession::new();
+
+	session.toolbar_inner_size_points = Some((460, 54));
+
+	assert!(session.update_toolbar_outer_position(monitor, Pos2::new(120.0, 160.0)));
+	assert_eq!(session.toolbar_state.floating_position, Some(Pos2::new(120.0, 160.0)));
+	assert_eq!(session.toolbar_outer_pos, Some(GlobalPoint::new(120, 160)));
+	assert_eq!(session.pending_toolbar_outer_pos, Some(GlobalPoint::new(120, 160)));
+}
+
 #[test]
 fn frozen_selection_resize_preserves_handle_press_offset() {
 	let monitor = tests::test_monitor();
@@ -438,7 +559,7 @@ fn frozen_selection_cursor_icon_uses_corner_resize_hover() {
 
 	session.state.cursor = Some(GlobalPoint::new(150, 180));
 
-	assert_eq!(session.frozen_selection_cursor_icon_for_monitor(monitor), CursorIcon::Default);
+	assert_eq!(session.frozen_selection_cursor_icon_for_monitor(monitor), CursorIcon::Grab);
 }
 
 #[test]
@@ -465,6 +586,30 @@ fn frozen_selection_cursor_icon_tracks_active_resize_drag() {
 	assert_eq!(session.frozen_selection_cursor_icon_for_monitor(monitor), CursorIcon::SeResize);
 }
 
+#[test]
+fn frozen_selection_cursor_icon_tracks_active_move_drag() {
+	let monitor = tests::test_monitor();
+	let capture_rect = RectPoints::new(100, 120, 200, 240);
+	let mut session = OverlaySession::new();
+
+	session.state.begin_freeze(monitor);
+	session.state.finish_freeze(monitor, tests::test_frozen_image());
+
+	session.state.frozen_capture_rect = Some(capture_rect);
+	session.frozen_capture_source = FrozenCaptureSource::DragRegion;
+	session.frozen_selection_drag = FrozenSelectionDragState {
+		active: true,
+		interaction: FrozenSelectionInteractionKind::Move,
+		anchor_rect: capture_rect,
+		pointer_offset_x: 50,
+		pointer_offset_y: 60,
+		press_cursor_x: 150,
+		press_cursor_y: 180,
+	};
+
+	assert_eq!(session.frozen_selection_cursor_icon_for_monitor(monitor), CursorIcon::Grabbing);
+}
+
 #[test]
 fn frozen_toolbar_default_position_centers_on_capture_rect_midpoint() {
 	let monitor = tests::test_monitor_with_scale(400, 300, 2_000);