Merge branch 'main' into improve-area-select2

Author: oscartbeaumont

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

@@ -116,8 +116,6 @@ pub struct GeneralSettingsStore {
     pub enable_new_recording_flow: bool,
     #[serde(default)]
     pub post_deletion_behaviour: PostDeletionBehaviour,
-    #[serde(default = "default_enable_new_uploader", skip_serializing_if = "no")]
-    pub enable_new_uploader: bool,
     #[serde(default = "default_excluded_windows")]
     pub excluded_windows: Vec<WindowExclusion>,
     #[serde(default)]
@@ -133,10 +131,6 @@ fn default_enable_new_recording_flow() -> bool {
     cfg!(debug_assertions)
 }
 
-fn default_enable_new_uploader() -> bool {
-    true
-}
-
 fn no(_: &bool) -> bool {
     false
 }
@@ -184,7 +178,6 @@ impl Default for GeneralSettingsStore {
             auto_zoom_on_clicks: false,
             enable_new_recording_flow: default_enable_new_recording_flow(),
             post_deletion_behaviour: PostDeletionBehaviour::DoNothing,
-            enable_new_uploader: default_enable_new_uploader(),
             excluded_windows: default_excluded_windows(),
             delete_instant_recordings_after_upload: false,
         }

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

@@ -2216,21 +2216,10 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
             tokio::spawn({
                 let app = app.clone();
                 async move {
-                    let is_new_uploader_enabled = GeneralSettingsStore::get(&app)
-                        .map_err(|err| {
-                            error!(
-                                "Error checking status of new uploader flow from settings: {err}"
-                            )
-                        })
-                        .ok()
-                        .and_then(|v| v.map(|v| v.enable_new_uploader))
-                        .unwrap_or(false);
-                    if is_new_uploader_enabled {
-                        resume_uploads(app)
-                            .await
-                            .map_err(|err| warn!("Error resuming uploads: {err}"))
-                            .ok();
-                    }
+                    resume_uploads(app)
+                        .await
+                        .map_err(|err| warn!("Error resuming uploads: {err}"))
+                        .ok();
                 }
             });
 
@@ -2386,10 +2375,34 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
                                 window_ids.ids.lock().unwrap().retain(|(_, _id)| *_id != id);
 
                                 tokio::spawn(EditorInstances::remove(window.clone()));
+
+                                #[cfg(target_os = "windows")]
+                                if CapWindowId::Settings.get(&app).is_none() {
+                                    reopen_main_window(&app);
+                                }
+                            }
+                            CapWindowId::Settings => {
+                                for (label, window) in app.webview_windows() {
+                                    if let Ok(id) = CapWindowId::from_str(&label)
+                                        && matches!(
+                                            id,
+                                            CapWindowId::TargetSelectOverlay { .. }
+                                                | CapWindowId::Main
+                                                | CapWindowId::Camera
+                                        )
+                                    {
+                                        let _ = window.show();
+                                    }
+                                }
+
+                                #[cfg(target_os = "windows")]
+                                if !has_open_editor_window(&app) {
+                                    reopen_main_window(&app);
+                                }
+
+                                return;
                             }
-                            CapWindowId::Settings
-                            | CapWindowId::Upgrade
-                            | CapWindowId::ModeSelect => {
+                            CapWindowId::Upgrade | CapWindowId::ModeSelect => {
                                 for (label, window) in app.webview_windows() {
                                     if let Ok(id) = CapWindowId::from_str(&label)
                                         && matches!(
@@ -2508,6 +2521,30 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
         });
 }
 
+#[cfg(target_os = "windows")]
+fn has_open_editor_window(app: &AppHandle) -> bool {
+    app.webview_windows()
+        .keys()
+        .any(|label| matches!(CapWindowId::from_str(label), Ok(CapWindowId::Editor { .. })))
+}
+
+#[cfg(target_os = "windows")]
+fn reopen_main_window(app: &AppHandle) {
+    if let Some(main) = CapWindowId::Main.get(app) {
+        let _ = main.show();
+        let _ = main.set_focus();
+    } else {
+        let handle = app.clone();
+        tokio::spawn(async move {
+            let _ = ShowCapWindow::Main {
+                init_target_mode: None,
+            }
+            .show(&handle)
+            .await;
+        });
+    }
+}
+
 async fn resume_uploads(app: AppHandle) -> Result<(), String> {
     let recordings_dir = recordings_path(&app);
     if !recordings_dir.exists() {

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

@@ -6,6 +6,7 @@ use std::{
 };
 
 use base64::prelude::*;
+use cap_recording::screen_capture::ScreenCaptureTarget;
 
 use crate::windows::{CapWindowId, ShowCapWindow};
 use scap_targets::{
@@ -46,6 +47,7 @@ pub struct DisplayInformation {
 pub async fn open_target_select_overlays(
     app: AppHandle,
     state: tauri::State<'_, WindowFocusManager>,
+    focused_target: Option<ScreenCaptureTarget>,
 ) -> Result<(), String> {
     let displays = scap_targets::Display::list()
         .into_iter()
@@ -59,11 +61,18 @@ pub async fn open_target_select_overlays(
 
     let handle = tokio::spawn({
         let app = app.clone();
+
         async move {
             loop {
                 {
-                    let display = scap_targets::Display::get_containing_cursor();
-                    let window = scap_targets::Window::get_topmost_at_cursor();
+                    let display = focused_target
+                        .as_ref()
+                        .map(|v| v.display())
+                        .unwrap_or_else(|| scap_targets::Display::get_containing_cursor());
+                    let window = focused_target
+                        .as_ref()
+                        .map(|v| v.window().and_then(|id| scap_targets::Window::from_id(&id)))
+                        .unwrap_or_else(|| scap_targets::Window::get_topmost_at_cursor());
 
                     let _ = TargetUnderCursor {
                         display_id: display.map(|d| d.id()),
@@ -171,13 +180,30 @@ pub async fn focus_window(window_id: WindowId) -> Result<(), String> {
     #[cfg(target_os = "windows")]
     {
         use windows::Win32::UI::WindowsAndMessaging::{
-            SW_RESTORE, SetForegroundWindow, ShowWindow,
+            GetWindowPlacement, IsIconic, SW_RESTORE, SetForegroundWindow, SetWindowPlacement,
+            ShowWindow, WINDOWPLACEMENT,
         };
 
         let hwnd = window.raw_handle().inner();
 
         unsafe {
-            ShowWindow(hwnd, SW_RESTORE);
+            // Only restore if the window is actually minimized
+            if IsIconic(hwnd).as_bool() {
+                // Get current window placement to preserve size/position
+                let mut wp = WINDOWPLACEMENT::default();
+                wp.length = std::mem::size_of::<WINDOWPLACEMENT>() as u32;
+
+                if GetWindowPlacement(hwnd, &mut wp).is_ok() {
+                    // Restore using the previous placement to avoid resizing
+                    wp.showCmd = SW_RESTORE.0 as u32;
+                    SetWindowPlacement(hwnd, &wp);
+                } else {
+                    // Fallback to simple restore if placement fails
+                    ShowWindow(hwnd, SW_RESTORE);
+                }
+            }
+
+            // Always try to bring to foreground
             SetForegroundWindow(hwnd);
         }
     }

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

@@ -3,9 +3,7 @@
 use crate::{
     UploadProgress, VideoUploadInfo,
     api::{self, PresignedS3PutRequest, PresignedS3PutRequestMethod, S3VideoMeta, UploadedPart},
-    general_settings::GeneralSettingsStore,
     posthog::{PostHogEvent, async_capture_event},
-    upload_legacy,
     web_api::{AuthedApiError, ManagerExt},
 };
 use async_stream::{stream, try_stream};
@@ -68,29 +66,6 @@ pub async fn upload_video(
     channel: Option<Channel<UploadProgress>>,
 ) -> Result<UploadedItem, AuthedApiError> {
     println!("Uploading video {video_id}...");
-    let is_new_uploader_enabled = GeneralSettingsStore::get(&app)
-        .map_err(|err| error!("Error checking status of new uploader flow from settings: {err}"))
-        .ok()
-        .and_then(|v| v.map(|v| v.enable_new_uploader))
-        .unwrap_or(false);
-    info!("uploader_video: is new uploader enabled? {is_new_uploader_enabled}");
-    if !is_new_uploader_enabled {
-        return upload_legacy::upload_video(
-            app,
-            video_id,
-            file_path,
-            None,
-            Some(screenshot_path),
-            Some(meta),
-            channel,
-        )
-        .await
-        .map(|v| UploadedItem {
-            link: v.link,
-            id: v.id,
-        });
-    }
-
     info!("Uploading video {video_id}...");
 
     let start = Instant::now();
@@ -187,22 +162,6 @@ pub async fn upload_image(
     app: &AppHandle,
     file_path: PathBuf,
 ) -> Result<UploadedItem, AuthedApiError> {
-    let is_new_uploader_enabled = GeneralSettingsStore::get(app)
-        .map_err(|err| error!("Error checking status of new uploader flow from settings: {err}"))
-        .ok()
-        .and_then(|v| v.map(|v| v.enable_new_uploader))
-        .unwrap_or(false);
-    info!("upload_image: is new uploader enabled? {is_new_uploader_enabled}");
-    if !is_new_uploader_enabled {
-        return upload_legacy::upload_image(app, file_path)
-            .await
-            .map(|v| UploadedItem {
-                link: v.link,
-                id: v.id,
-            })
-            .map_err(Into::into);
-    }
-
     let file_name = file_path
         .file_name()
         .and_then(|name| name.to_str())
@@ -395,26 +354,6 @@ impl InstantMultipartUpload {
         realtime_video_done: Option<Receiver<()>>,
         recording_dir: PathBuf,
     ) -> Result<(), AuthedApiError> {
-        let is_new_uploader_enabled = GeneralSettingsStore::get(&app)
-            .map_err(|err| {
-                error!("Error checking status of new uploader flow from settings: {err}")
-            })
-            .ok()
-            .and_then(|v| v.map(|v| v.enable_new_uploader))
-            .unwrap_or(false);
-        info!("InstantMultipartUpload::run: is new uploader enabled? {is_new_uploader_enabled}");
-        if !is_new_uploader_enabled {
-            return upload_legacy::InstantMultipartUpload::run(
-                app,
-                pre_created_video.id.clone(),
-                file_path,
-                pre_created_video,
-                realtime_video_done,
-            )
-            .await
-            .map_err(Into::into);
-        }
-
         let video_id = pre_created_video.id.clone();
         debug!("Initiating multipart upload for {video_id}...");
 

apps/desktop/src/routes/(window-chrome)/new-main/index.tsx

@@ -195,8 +195,8 @@ function TargetMenuPanel(props: TargetMenuPanelProps & SharedTargetMenuProps) {
 			<div class="flex gap-3 justify-between items-center mt-3">
 				<div
 					onClick={() => props.onBack()}
-					class="flex gap-1 items-center rounded-md px-1.5 text-xs 
-					text-gray-11 transition-opacity hover:opacity-70 hover:text-gray-12 
+					class="flex gap-1 items-center rounded-md px-1.5 text-xs
+					text-gray-11 transition-opacity hover:opacity-70 hover:text-gray-12
 					focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-blue-9 focus-visible:ring-offset-2 focus-visible:ring-offset-gray-1"
 				>
 					<IconLucideArrowLeft class="size-3 text-gray-11" />
@@ -383,6 +383,7 @@ function Page() {
 			reconcile({ variant: "display", id: target.id }),
 		);
 		setOptions("targetMode", "display");
+		commands.openTargetSelectOverlays(rawOptions.captureTarget);
 		setDisplayMenuOpen(false);
 		displayTriggerRef?.focus();
 	};
@@ -393,6 +394,7 @@ function Page() {
 			reconcile({ variant: "window", id: target.id }),
 		);
 		setOptions("targetMode", "window");
+		commands.openTargetSelectOverlays(rawOptions.captureTarget);
 		setWindowMenuOpen(false);
 		windowTriggerRef?.focus();
 
@@ -412,7 +414,10 @@ function Page() {
 	createUpdateCheck();
 
 	onMount(async () => {
-		setOptions({ targetMode: (window as any).__CAP__.initialTargetMode });
+		const targetMode = (window as any).__CAP__.initialTargetMode;
+		setOptions({ targetMode });
+		if (rawOptions.targetMode) commands.openTargetSelectOverlays(null);
+		else commands.closeTargetSelectOverlays();
 
 		const currentWindow = getCurrentWindow();
 
@@ -444,11 +449,6 @@ function Page() {
 		if (!monitor) return;
 	});
 
-	createEffect(() => {
-		if (rawOptions.targetMode) commands.openTargetSelectOverlays();
-		else commands.closeTargetSelectOverlays();
-	});
-
 	const cameras = useQuery(() => listVideoDevices);
 	const mics = useQuery(() => listAudioDevices);
 
@@ -649,6 +649,9 @@ function Page() {
 								setOptions("targetMode", (v) =>
 									v === "display" ? null : "display",
 								);
+								if (rawOptions.targetMode)
+									commands.openTargetSelectOverlays(null);
+								else commands.closeTargetSelectOverlays();
 							}}
 							name="Display"
 							class="flex-1 rounded-none focus-visible:ring-0 focus-visible:ring-offset-0"
@@ -691,6 +694,9 @@ function Page() {
 								setOptions("targetMode", (v) =>
 									v === "window" ? null : "window",
 								);
+								if (rawOptions.targetMode)
+									commands.openTargetSelectOverlays(null);
+								else commands.closeTargetSelectOverlays();
 							}}
 							name="Window"
 							class="flex-1 rounded-none focus-visible:ring-0 focus-visible:ring-offset-0"
@@ -724,6 +730,9 @@ function Page() {
 						onClick={() => {
 							if (isRecording()) return;
 							setOptions("targetMode", (v) => (v === "area" ? null : "area"));
+							if (rawOptions.targetMode)
+								commands.openTargetSelectOverlays(null);
+							else commands.closeTargetSelectOverlays();
 						}}
 						name="Area"
 					/>

apps/desktop/src/routes/(window-chrome)/settings/experimental.tsx

@@ -26,7 +26,6 @@ function Inner(props: { initialStore: GeneralSettingsStore | null }) {
 			enableNewRecordingFlow: false,
 			autoZoomOnClicks: false,
 			custom_cursor_capture2: true,
-			enableNewUploader: false,
 		},
 	);
 
@@ -97,19 +96,6 @@ function Inner(props: { initialStore: GeneralSettingsStore | null }) {
 								);
 							}}
 						/>
-						<ToggleSettingItem
-							label="New uploader"
-							description="Improved uploader for faster and more reliable uploads!"
-							value={!!settings.enableNewUploader}
-							onChange={(value) => {
-								handleChange("enableNewUploader", value);
-								// This is bad code, but I just want the UI to not jank and can't seem to find the issue.
-								setTimeout(
-									() => window.scrollTo({ top: 0, behavior: "instant" }),
-									5,
-								);
-							}}
-						/>
 					</div>
 				</div>
 			</div>

apps/desktop/src/routes/(window-chrome)/settings/general.tsx

@@ -70,7 +70,6 @@ const createDefaultGeneralSettings = (): GeneralSettingsStore => ({
 	enableNewRecordingFlow: false,
 	autoZoomOnClicks: false,
 	custom_cursor_capture2: true,
-	enableNewUploader: false,
 	excludedWindows: [],
 });