clippy

Author: richiemcilroy

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

@@ -151,50 +151,6 @@ impl CameraPreviewManager {
         }
     }
 
-    // Resumes a paused camera preview. Uses window.show() which is safe, unlike
-    // panel.order_front_regardless() which causes crashes after repeated use.
-    pub fn resume(&mut self, window: &WebviewWindow) {
-        if let Some(preview) = &mut self.preview
-            && preview.is_paused
-        {
-            preview.is_paused = false;
-            preview
-                .reconfigure
-                .send(ReconfigureEvent::Resume)
-                .map_err(|err| error!("Error sending camera preview resume event: {err}"))
-                .ok();
-            window
-                .run_on_main_thread({
-                    let window = window.clone();
-                    move || {
-                        let _ = window.show();
-                    }
-                })
-                .ok();
-        }
-    }
-
-    pub fn is_paused(&self) -> bool {
-        self.preview.as_ref().is_some_and(|p| p.is_paused)
-    }
-
-    pub fn begin_shutdown_for_session(
-        &mut self,
-        expected_session_id: u64,
-    ) -> Option<oneshot::Receiver<()>> {
-        if let Some(preview) = &self.preview
-            && preview.session_id != expected_session_id
-        {
-            info!(
-                "Skipping camera preview close: session mismatch (expected {}, current {})",
-                expected_session_id, preview.session_id
-            );
-            return None;
-        }
-
-        self.begin_shutdown()
-    }
-
     pub fn begin_shutdown(&mut self) -> Option<oneshot::Receiver<()>> {
         let preview = self.preview.take()?;
         info!(
@@ -304,14 +260,6 @@ impl CameraPreviewManager {
 
         Ok(())
     }
-
-    pub fn on_window_close_for_session(&mut self, expected_session_id: u64) {
-        let _ = self.begin_shutdown_for_session(expected_session_id);
-    }
-
-    pub fn on_window_close(&mut self) {
-        let _ = self.begin_shutdown();
-    }
 }
 
 // Internal events for the persistent camera renderer architecture.
@@ -874,7 +822,7 @@ impl Renderer {
         let _ = self.device.poll(wgpu::PollType::Wait);
 
         drop(std::mem::take(&mut self.texture));
-        drop(std::mem::take(&mut self.aspect_ratio));
+        self.aspect_ratio = Cached::default();
 
         let surface = self.surface.take();
         let (drop_tx, drop_rx) = oneshot::channel();

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

@@ -6,38 +6,26 @@ use tokio::sync::RwLock;
 use tracing::{debug, info, trace, warn};
 
 #[cfg(target_os = "macos")]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
 pub enum PanelState {
+    #[default]
     None,
     Creating,
     Ready,
     Destroying,
 }
 
-#[cfg(target_os = "macos")]
-impl Default for PanelState {
-    fn default() -> Self {
-        Self::None
-    }
-}
-
 #[cfg(target_os = "macos")]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum PanelWindowType {
     Camera,
-    Main,
-    TargetSelectOverlay,
-    InProgressRecording,
 }
 
 #[cfg(target_os = "macos")]
 impl std::fmt::Display for PanelWindowType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::Camera => write!(f, "Camera"),
-            Self::Main => write!(f, "Main"),
-            Self::TargetSelectOverlay => write!(f, "TargetSelectOverlay"),
-            Self::InProgressRecording => write!(f, "InProgressRecording"),
         }
     }
 }
@@ -107,7 +95,6 @@ impl PanelManager {
                     window_type, op_id
                 );
                 Some(PanelOperationGuard {
-                    window_type,
                     operation_id: op_id,
                     completed: false,
                 })
@@ -136,87 +123,6 @@ impl PanelManager {
         }
     }
 
-    pub async fn try_begin_show(
-        &self,
-        window_type: PanelWindowType,
-    ) -> Option<PanelOperationGuard> {
-        let mut panels = self.panels.write().await;
-        let entry = panels.entry(window_type).or_default();
-
-        match entry.state {
-            PanelState::Ready => {
-                let op_id = self
-                    .operation_counter
-                    .fetch_add(1, std::sync::atomic::Ordering::SeqCst);
-                debug!(
-                    "Panel {}: beginning show operation (op_id={})",
-                    window_type, op_id
-                );
-                Some(PanelOperationGuard {
-                    window_type,
-                    operation_id: op_id,
-                    completed: true,
-                })
-            }
-            PanelState::None => {
-                debug!("Panel {}: show blocked - window doesn't exist", window_type);
-                None
-            }
-            PanelState::Creating => {
-                debug!(
-                    "Panel {}: show blocked - currently creating (op_id={})",
-                    window_type, entry.operation_id
-                );
-                None
-            }
-            PanelState::Destroying => {
-                debug!(
-                    "Panel {}: show blocked - currently destroying (op_id={})",
-                    window_type, entry.operation_id
-                );
-                None
-            }
-        }
-    }
-
-    pub async fn try_begin_destroy(
-        &self,
-        window_type: PanelWindowType,
-    ) -> Option<PanelOperationGuard> {
-        let mut panels = self.panels.write().await;
-        let entry = panels.entry(window_type).or_default();
-
-        match entry.state {
-            PanelState::Ready | PanelState::Creating => {
-                let op_id = self
-                    .operation_counter
-                    .fetch_add(1, std::sync::atomic::Ordering::SeqCst);
-                entry.state = PanelState::Destroying;
-                entry.operation_id = op_id;
-                debug!(
-                    "Panel {}: beginning destroy operation (op_id={})",
-                    window_type, op_id
-                );
-                Some(PanelOperationGuard {
-                    window_type,
-                    operation_id: op_id,
-                    completed: false,
-                })
-            }
-            PanelState::None => {
-                debug!("Panel {}: destroy skipped - already destroyed", window_type);
-                None
-            }
-            PanelState::Destroying => {
-                debug!(
-                    "Panel {}: destroy blocked - already destroying (op_id={})",
-                    window_type, entry.operation_id
-                );
-                None
-            }
-        }
-    }
-
     pub async fn mark_ready(&self, window_type: PanelWindowType, operation_id: u64) {
         let mut panels = self.panels.write().await;
         if let Some(entry) = panels.get_mut(&window_type) {
@@ -235,24 +141,6 @@ impl PanelManager {
         }
     }
 
-    pub async fn mark_destroyed(&self, window_type: PanelWindowType, operation_id: u64) {
-        let mut panels = self.panels.write().await;
-        if let Some(entry) = panels.get_mut(&window_type) {
-            if entry.operation_id == operation_id && entry.state == PanelState::Destroying {
-                entry.state = PanelState::None;
-                info!(
-                    "Panel {}: marked destroyed (op_id={})",
-                    window_type, operation_id
-                );
-            } else {
-                warn!(
-                    "Panel {}: mark_destroyed ignored - state mismatch (current state={:?}, current op={}, requested op={})",
-                    window_type, entry.state, entry.operation_id, operation_id
-                );
-            }
-        }
-    }
-
     pub async fn force_reset(&self, window_type: PanelWindowType) {
         let mut panels = self.panels.write().await;
         if let Some(entry) = panels.get_mut(&window_type) {
@@ -293,7 +181,6 @@ impl PanelManager {
 
 #[cfg(target_os = "macos")]
 pub struct PanelOperationGuard {
-    pub window_type: PanelWindowType,
     pub operation_id: u64,
     completed: bool,
 }
@@ -303,10 +190,6 @@ impl PanelOperationGuard {
     pub fn mark_completed(&mut self) {
         self.completed = true;
     }
-
-    pub fn is_completed(&self) -> bool {
-        self.completed
-    }
 }
 
 #[cfg(target_os = "macos")]

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

@@ -886,11 +886,6 @@ impl ShowCapWindow {
                 None
             };
 
-            match self {
-                Self::Main { .. } => {}
-                _ => {}
-            }
-
             if let Self::Main {
                 init_target_mode: Some(target_mode),
             } = self