New recording flow

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

@@ -104,8 +104,7 @@ fn default_enable_native_camera_preview() -> bool {
 }
 
 fn default_enable_new_recording_flow() -> bool {
-    false
-    // cfg!(debug_assertions)
+    cfg!(debug_assertions)
 }
 
 fn no(_: &bool) -> bool {

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

@@ -1983,6 +1983,7 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
             captions::export_captions_srt,
             target_select_overlay::open_target_select_overlays,
             target_select_overlay::close_target_select_overlays,
+            target_select_overlay::display_information,
         ])
         .events(tauri_specta::collect_events![
             RecordingOptionsChanged,

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

@@ -9,7 +9,7 @@ use base64::prelude::*;
 
 use crate::windows::{CapWindowId, ShowCapWindow};
 use cap_displays::{
-    DisplayId, WindowId,
+    Display, DisplayId, WindowId,
     bounds::{LogicalBounds, PhysicalSize},
 };
 use serde::Serialize;
@@ -24,7 +24,6 @@ use tracing::error;
 pub struct TargetUnderCursor {
     display_id: Option<DisplayId>,
     window: Option<WindowUnderCursor>,
-    screen: Option<ScreenUnderCursor>,
 }
 
 #[derive(Serialize, Type, Clone)]
@@ -36,9 +35,9 @@ pub struct WindowUnderCursor {
 }
 
 #[derive(Serialize, Type, Clone)]
-pub struct ScreenUnderCursor {
-    name: String,
-    physical_size: PhysicalSize,
+pub struct DisplayInformation {
+    name: Option<String>,
+    physical_size: Option<PhysicalSize>,
     refresh_rate: String,
 }
 
@@ -77,13 +76,6 @@ pub async fn open_target_select_overlays(
                             }),
                         })
                     }),
-                    screen: display.and_then(|d| {
-                        Some(ScreenUnderCursor {
-                            name: d.name().unwrap_or_default(),
-                            physical_size: d.physical_size()?,
-                            refresh_rate: d.refresh_rate().to_string(),
-                        })
-                    }),
                 }
                 .emit(&app);
 
@@ -112,10 +104,7 @@ pub async fn open_target_select_overlays(
 
 #[specta::specta]
 #[tauri::command]
-pub async fn close_target_select_overlays(
-    app: AppHandle,
-    // state: tauri::State<'_, WindowFocusManager>,
-) -> Result<(), String> {
+pub async fn close_target_select_overlays(app: AppHandle) -> Result<(), String> {
     for (id, window) in app.webview_windows() {
         if let Ok(CapWindowId::TargetSelectOverlay { .. }) = CapWindowId::from_str(&id) {
             let _ = window.close();
@@ -125,6 +114,21 @@ pub async fn close_target_select_overlays(
     Ok(())
 }
 
+#[specta::specta]
+#[tauri::command]
+pub async fn display_information(display_id: &str) -> Result<DisplayInformation, String> {
+    let display_id = display_id
+        .parse::<DisplayId>()
+        .map_err(|err| format!("Invalid display ID: {}", err))?;
+    let display = Display::from_id(&display_id).ok_or("Display not found")?;
+
+    Ok(DisplayInformation {
+        name: display.name(),
+        physical_size: display.physical_size(),
+        refresh_rate: display.refresh_rate().to_string(),
+    })
+}
+
 // Windows doesn't have a proper concept of window z-index's so we implement them in userspace :(
 #[derive(Default)]
 pub struct WindowFocusManager {

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

@@ -256,16 +256,6 @@ impl ShowCapWindow {
                     return Err(tauri::Error::WindowNotFound);
                 };
 
-                #[cfg(target_os = "macos")]
-                let position = display.raw_handle().logical_position();
-                #[cfg(target_os = "macos")]
-                let size = display.logical_size().unwrap();
-
-                #[cfg(windows)]
-                let position = display.raw_handle().physical_position().unwrap();
-                #[cfg(windows)]
-                let size = display.physical_size().unwrap();
-
                 let mut window_builder = self
                     .window_builder(
                         app,
@@ -275,15 +265,52 @@ impl ShowCapWindow {
                     .resizable(false)
                     .fullscreen(false)
                     .shadow(false)
-                    .always_on_top(cfg!(target_os = "macos"))
+                    .content_protected(true)
+                    .always_on_top(true)
                     .visible_on_all_workspaces(true)
                     .skip_taskbar(true)
-                    .inner_size(size.width(), size.height())
-                    .position(position.x(), position.y())
                     .transparent(true);
 
+                #[cfg(target_os = "macos")]
+                {
+                    let position = display.raw_handle().logical_position();
+                    let size = display.logical_size().unwrap();
+
+                    window_builder = window_builder
+                        .inner_size(size.width(), size.height())
+                        .position(position.x(), position.y());
+                }
+
+                #[cfg(windows)]
+                {
+                    window_builder = window_builder.inner_size(100.0, 100.0).position(0.0, 0.0);
+                }
+
                 let window = window_builder.build()?;
 
+                #[cfg(windows)]
+                {
+                    let position = display.raw_handle().physical_position().unwrap();
+                    let logical_size = display.logical_size().unwrap();
+                    let physical_size = display.physical_size().unwrap();
+                    use tauri::{LogicalSize, PhysicalPosition, PhysicalSize};
+                    let _ = window.set_size(LogicalSize::new(
+                        logical_size.width(),
+                        logical_size.height(),
+                    ));
+                    let _ = window.set_position(PhysicalPosition::new(position.x(), position.y()));
+                    tokio::time::sleep(std::time::Duration::from_millis(5)).await;
+
+                    let actual_physical_size = window.inner_size().unwrap();
+                    // this third time makes it work when the resulting size is wrong, god knows why
+                    if physical_size.width() != actual_physical_size.width as f64 {
+                        let _ = window.set_size(LogicalSize::new(
+                            logical_size.width(),
+                            logical_size.height(),
+                        ));
+                    }
+                }
+
                 app.state::<WindowFocusManager>()
                     .spawn(display_id, window.clone());
 

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

@@ -81,7 +81,7 @@ function Header() {
 		<header
 			class={cx(
 				"flex items-center space-x-1 h-9 select-none shrink-0 bg-gray-2",
-				isWindows ? "flex-row" : "flex-row-reverse pl-[5rem]",
+				isWindows ? "flex-row" : "flex-row-reverse pl-[4.2rem]",
 			)}
 			data-tauri-drag-region
 		>