Merge pull request #1512 from CapSoftware/external-display-niceties

Improve external display handling and target selection performance

Author: richiemcilroy

apps/desktop/src-tauri/src/camera.rs

@@ -198,7 +198,7 @@ impl InitializedCameraPreview {
             1.0
         };
 
-        let size = resize_window(&window, default_state, aspect, true)
+        let size = resize_window(&window, default_state, aspect, false)
             .context("Error resizing Tauri window")?;
 
         let (tx, rx) = oneshot::channel();

apps/desktop/src-tauri/src/fake_window.rs

@@ -1,9 +1,14 @@
-use scap_targets::bounds::LogicalBounds;
+use scap_targets::{Display, DisplayId, bounds::LogicalBounds};
 use std::{collections::HashMap, sync::Arc, time::Duration};
 use tauri::{AppHandle, Manager, WebviewWindow};
 use tokio::{sync::RwLock, time::sleep};
 use tracing::instrument;
 
+const RECORDING_CONTROLS_LABEL: &str = "in-progress-recording";
+const RECORDING_CONTROLS_WIDTH: f64 = 320.0;
+const RECORDING_CONTROLS_HEIGHT: f64 = 150.0;
+const RECORDING_CONTROLS_OFFSET_Y: f64 = 120.0;
+
 pub struct FakeWindowBounds(pub Arc<RwLock<HashMap<String, HashMap<String, LogicalBounds>>>>);
 
 #[tauri::command]
@@ -45,15 +50,50 @@ pub async fn remove_fake_window(
     Ok(())
 }
 
+fn get_display_id_for_cursor() -> Option<DisplayId> {
+    Display::get_containing_cursor().map(|d| d.id())
+}
+
+fn get_display_by_id(id: &DisplayId) -> Option<Display> {
+    Display::list().into_iter().find(|d| &d.id() == id)
+}
+
+fn calculate_bottom_center_position(display: &Display) -> Option<(f64, f64)> {
+    let bounds = display.raw_handle().logical_bounds()?;
+    let x = bounds.position().x();
+    let y = bounds.position().y();
+    let width = bounds.size().width();
+    let height = bounds.size().height();
+
+    let pos_x = x + (width - RECORDING_CONTROLS_WIDTH) / 2.0;
+    let pos_y = y + height - RECORDING_CONTROLS_HEIGHT - RECORDING_CONTROLS_OFFSET_Y;
+    Some((pos_x, pos_y))
+}
+
 pub fn spawn_fake_window_listener(app: AppHandle, window: WebviewWindow) {
     window.set_ignore_cursor_events(true).ok();
 
+    let is_recording_controls = window.label() == RECORDING_CONTROLS_LABEL;
+
     tokio::spawn(async move {
         let state = app.state::<FakeWindowBounds>();
+        let mut current_display_id: Option<DisplayId> = get_display_id_for_cursor();
 
         loop {
             sleep(Duration::from_millis(1000 / 20)).await;
 
+            if is_recording_controls && let Some(cursor_display_id) = get_display_id_for_cursor() {
+                let display_changed = current_display_id.as_ref() != Some(&cursor_display_id);
+
+                if display_changed
+                    && let Some(display) = get_display_by_id(&cursor_display_id)
+                    && let Some((pos_x, pos_y)) = calculate_bottom_center_position(&display)
+                {
+                    let _ = window.set_position(tauri::LogicalPosition::new(pos_x, pos_y));
+                    current_display_id = Some(cursor_display_id);
+                }
+            }
+
             let map = state.0.read().await;
 
             let Some(windows) = map.get(window.label()) else {
@@ -86,7 +126,6 @@ pub fn spawn_fake_window_listener(app: AppHandle, window: WebviewWindow) {
                     && mouse_position.y <= y_max
                 {
                     ignore = false;
-                    // ShowCapturesPanel.emit(&app).ok();
                     break;
                 }
             }

apps/desktop/src-tauri/src/lib.rs

@@ -901,6 +901,12 @@ pub struct RequestOpenRecordingPicker {
     pub target_mode: Option<RecordingTargetMode>,
 }
 
+#[derive(Deserialize, specta::Type, Serialize, tauri_specta::Event, Debug, Clone)]
+pub struct RequestSetTargetMode {
+    pub target_mode: Option<RecordingTargetMode>,
+    pub display_id: Option<String>,
+}
+
 #[derive(Deserialize, specta::Type, Serialize, tauri_specta::Event, Debug, Clone)]
 pub struct RequestOpenSettings {
     page: String,
@@ -2533,6 +2539,39 @@ async fn update_auth_plan(app: AppHandle) {
     AuthStore::update_auth_plan(&app).await.ok();
 }
 
+pub async fn open_target_picker(
+    app: &tauri::AppHandle,
+    target_mode: recording_settings::RecordingTargetMode,
+) {
+    use tauri::Manager;
+
+    if let Some(window) = CapWindowId::Main.get(app) {
+        window.hide().ok();
+    }
+
+    let prewarmed = app.state::<target_select_overlay::PrewarmedOverlays>();
+    let state = app.state::<target_select_overlay::WindowFocusManager>();
+    let display_id = scap_targets::Display::get_containing_cursor().map(|d| d.id().to_string());
+
+    let _ = target_select_overlay::open_target_select_overlays(
+        app.clone(),
+        state,
+        prewarmed,
+        None,
+        display_id.clone(),
+        Some(target_mode),
+    )
+    .await;
+
+    tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+
+    let _ = RequestSetTargetMode {
+        target_mode: Some(target_mode),
+        display_id,
+    }
+    .emit(app);
+}
+
 type FilteredRegistry = tracing_subscriber::layer::Layered<
     tracing_subscriber::filter::FilterFn<fn(m: &tracing::Metadata) -> bool>,
     tracing_subscriber::Registry,
@@ -2650,6 +2689,7 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
             captions::check_model_exists,
             captions::delete_whisper_model,
             captions::export_captions_srt,
+            target_select_overlay::prewarm_target_select_overlays,
             target_select_overlay::open_target_select_overlays,
             target_select_overlay::close_target_select_overlays,
             target_select_overlay::update_camera_overlay_bounds,
@@ -2673,6 +2713,7 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
             RecordingStopped,
             RequestStartRecording,
             RequestOpenRecordingPicker,
+            RequestSetTargetMode,
             RequestOpenSettings,
             RequestScreenCapturePrewarm,
             NewNotification,
@@ -2820,6 +2861,7 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
             general_settings::init(&app);
             fake_window::init(&app);
             app.manage(target_select_overlay::WindowFocusManager::default());
+            app.manage(target_select_overlay::PrewarmedOverlays::default());
             app.manage(EditorWindowIds::default());
             app.manage(ScreenshotEditorWindowIds::default());
             #[cfg(target_os = "macos")]
@@ -2831,6 +2873,19 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
 
             gpu_context::prewarm_gpu();
 
+            tokio::spawn({
+                let app = app.clone();
+                async move {
+                    tokio::time::sleep(std::time::Duration::from_millis(500)).await;
+                    let prewarmed = app.state::<target_select_overlay::PrewarmedOverlays>();
+                    let _ = target_select_overlay::prewarm_target_select_overlays(
+                        app.clone(),
+                        prewarmed,
+                    )
+                    .await;
+                }
+            });
+
             tokio::spawn({
                 let camera_feed = camera_feed.clone();
                 let app = app.clone();
@@ -2988,11 +3043,15 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
             });
 
             RequestOpenRecordingPicker::listen_any_spawn(&app, async |event, app| {
-                let _ = ShowCapWindow::Main {
-                    init_target_mode: event.target_mode,
+                if let Some(target_mode) = event.target_mode {
+                    open_target_picker(&app, target_mode).await;
+                } else {
+                    let _ = ShowCapWindow::Main {
+                        init_target_mode: None,
+                    }
+                    .show(&app)
+                    .await;
                 }
-                .show(&app)
-                .await;
             });
 
             RequestOpenSettings::listen_any_spawn(&app, async |payload, app| {

apps/desktop/src-tauri/src/screenshot_editor.rs

@@ -32,6 +32,8 @@ pub struct ScreenshotEditorInstance {
     pub config_tx: watch::Sender<ProjectConfiguration>,
     pub path: PathBuf,
     pub pretty_name: String,
+    pub image_width: u32,
+    pub image_height: u32,
 }
 
 impl ScreenshotEditorInstance {
@@ -300,6 +302,8 @@ impl ScreenshotEditorInstances {
                     config_tx,
                     path: path.clone(),
                     pretty_name: recording_meta.pretty_name.clone(),
+                    image_width: width,
+                    image_height: height,
                 });
 
                 // Spawn render loop
@@ -429,6 +433,8 @@ pub struct SerializedScreenshotEditorInstance {
     pub path: PathBuf,
     pub config: Option<ProjectConfiguration>,
     pub pretty_name: String,
+    pub image_width: u32,
+    pub image_height: u32,
 }
 
 #[tauri::command]
@@ -459,6 +465,8 @@ pub async fn create_screenshot_editor_instance(
         path: instance.path.clone(),
         config: Some(config),
         pretty_name: instance.pretty_name.clone(),
+        image_width: instance.image_width,
+        image_height: instance.image_height,
     })
 }