Merge pull request #60 from devmobasa/fix-capture

Fix capture (screenshot, region)

Author: devmobasa

config.example.toml

@@ -332,6 +332,11 @@ format = "png"
 # Shortcut-specific actions may override this
 copy_to_clipboard = true
 
+# Exit overlay after any capture completes (forces exit for all capture types)
+# When false, clipboard-only captures still auto-exit by default.
+# Use --no-exit-after-capture to keep the overlay open for a run.
+exit_after_capture = false
+
 # ═══════════════════════════════════════════════════════════════════════════════
 # SESSION PERSISTENCE
 # ═══════════════════════════════════════════════════════════════════════════════

configurator/src/app.rs

@@ -937,6 +937,12 @@ impl ConfiguratorApp {
                     self.draft.capture_copy_to_clipboard,
                     self.defaults.capture_copy_to_clipboard,
                     ToggleField::CaptureCopyToClipboard,
+                ),
+                toggle_row(
+                    "Always exit overlay after capture",
+                    self.draft.capture_exit_after,
+                    self.defaults.capture_exit_after,
+                    ToggleField::CaptureExitAfter,
                 )
             ]
             .spacing(12),

configurator/src/models/config.rs

@@ -66,6 +66,7 @@ pub struct ConfigDraft {
     pub capture_filename_template: String,
     pub capture_format: String,
     pub capture_copy_to_clipboard: bool,
+    pub capture_exit_after: bool,
 
     pub session_persist_transparent: bool,
     pub session_persist_whiteboard: bool,
@@ -151,6 +152,7 @@ impl ConfigDraft {
             capture_filename_template: config.capture.filename_template.clone(),
             capture_format: config.capture.format.clone(),
             capture_copy_to_clipboard: config.capture.copy_to_clipboard,
+            capture_exit_after: config.capture.exit_after_capture,
 
             session_persist_transparent: config.session.persist_transparent,
             session_persist_whiteboard: config.session.persist_whiteboard,
@@ -369,6 +371,7 @@ impl ConfigDraft {
         config.capture.filename_template = self.capture_filename_template.clone();
         config.capture.format = self.capture_format.clone();
         config.capture.copy_to_clipboard = self.capture_copy_to_clipboard;
+        config.capture.exit_after_capture = self.capture_exit_after;
 
         config.session.persist_transparent = self.session_persist_transparent;
         config.session.persist_whiteboard = self.session_persist_whiteboard;
@@ -434,6 +437,7 @@ impl ConfigDraft {
             ToggleField::BoardAutoAdjust => self.board_auto_adjust_pen = value,
             ToggleField::CaptureEnabled => self.capture_enabled = value,
             ToggleField::CaptureCopyToClipboard => self.capture_copy_to_clipboard = value,
+            ToggleField::CaptureExitAfter => self.capture_exit_after = value,
             ToggleField::SessionPersistTransparent => {
                 self.session_persist_transparent = value;
             }

configurator/src/models/fields.rs

@@ -229,6 +229,7 @@ pub enum ToggleField {
     BoardAutoAdjust,
     CaptureEnabled,
     CaptureCopyToClipboard,
+    CaptureExitAfter,
     SessionPersistTransparent,
     SessionPersistWhiteboard,
     SessionPersistBlackboard,

docs/CONFIG.md

@@ -333,6 +333,11 @@ format = "png"
 
 # Copy captures to clipboard in addition to saving files
 copy_to_clipboard = true
+
+# Exit the overlay after any capture completes (forces exit for all capture types)
+# When false, clipboard-only captures still auto-exit by default.
+# Use --no-exit-after-capture to keep the overlay open for a run.
+exit_after_capture = false
 ```
 
 **Tips:**

src/backend/mod.rs

@@ -5,13 +5,26 @@ pub mod wayland;
 // Removed: Backend trait - no longer needed with single backend
 // Removed: BackendChoice enum - Wayland is the only backend
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ExitAfterCaptureMode {
+    Auto,
+    Always,
+    Never,
+}
+
 /// Run Wayland backend with full event loop
 ///
 /// # Arguments
 /// * `initial_mode` - Optional board mode to start in (overrides config default)
 /// * `freeze_on_start` - Whether to start with the overlay frozen for immediate capture pause
-pub fn run_wayland(initial_mode: Option<String>, freeze_on_start: bool) -> Result<()> {
-    let mut backend = wayland::WaylandBackend::new(initial_mode, freeze_on_start)?;
+/// * `exit_after_capture_mode` - Exit behavior after a capture completes
+pub fn run_wayland(
+    initial_mode: Option<String>,
+    freeze_on_start: bool,
+    exit_after_capture_mode: ExitAfterCaptureMode,
+) -> Result<()> {
+    let mut backend =
+        wayland::WaylandBackend::new(initial_mode, freeze_on_start, exit_after_capture_mode)?;
     backend.init()?;
     backend.show()?; // show() calls run() internally
     backend.hide()?;
@@ -27,6 +40,7 @@ mod tests {
             eprintln!("WAYLAND_DISPLAY not set; skipping Wayland smoke test");
             return;
         }
-        super::run_wayland(None, false).expect("Wayland backend should start");
+        super::run_wayland(None, false, super::ExitAfterCaptureMode::Never)
+            .expect("Wayland backend should start");
     }
 }

src/backend/wayland/backend.rs

@@ -43,6 +43,7 @@ use wayland_protocols_wlr::screencopy::v1::client::zwlr_screencopy_manager_v1::Z
 use super::state::{OverlaySuppression, WaylandGlobals, WaylandState, WaylandStateInit};
 use crate::{
     RESUME_SESSION_ENV,
+    backend::ExitAfterCaptureMode,
     capture::{CaptureManager, CaptureOutcome},
     config::{Action, Config, ConfigSource},
     input::{BoardMode, ClickHighlightSettings, InputState},
@@ -139,17 +140,23 @@ fn resume_override_from_env() -> Option<bool> {
 pub struct WaylandBackend {
     initial_mode: Option<String>,
     freeze_on_start: bool,
+    exit_after_capture_mode: ExitAfterCaptureMode,
     /// Tokio runtime for async capture operations
     tokio_runtime: tokio::runtime::Runtime,
 }
 
 impl WaylandBackend {
-    pub fn new(initial_mode: Option<String>, freeze_on_start: bool) -> Result<Self> {
+    pub fn new(
+        initial_mode: Option<String>,
+        freeze_on_start: bool,
+        exit_after_capture_mode: ExitAfterCaptureMode,
+    ) -> Result<Self> {
         let tokio_runtime = tokio::runtime::Runtime::new()
             .context("Failed to create Tokio runtime for capture operations")?;
         Ok(Self {
             initial_mode,
             freeze_on_start,
+            exit_after_capture_mode,
             tokio_runtime,
         })
     }
@@ -259,6 +266,12 @@ impl WaylandBackend {
                 (Config::default(), ConfigSource::Default)
             }
         };
+        let exit_after_capture_mode = match self.exit_after_capture_mode {
+            ExitAfterCaptureMode::Auto if config.capture.exit_after_capture => {
+                ExitAfterCaptureMode::Always
+            }
+            other => other,
+        };
 
         info!("Configuration loaded");
         debug!("  Color: {:?}", config.drawing.default_color);
@@ -514,6 +527,7 @@ impl WaylandBackend {
             capture_manager,
             session_options,
             tokio_handle,
+            exit_after_capture_mode,
             frozen_enabled: frozen_supported,
             preferred_output_identity,
             xdg_fullscreen,
@@ -773,6 +787,8 @@ impl WaylandBackend {
                 state.show_overlay();
                 state.capture.clear_in_progress();
 
+                let exit_on_success = state.capture.take_exit_on_success()
+                    && matches!(&outcome, CaptureOutcome::Success(_));
                 match outcome {
                     CaptureOutcome::Success(result) => {
                         // Build notification message
@@ -821,6 +837,9 @@ impl WaylandBackend {
                         log::info!("Capture cancelled: {}", reason);
                     }
                 }
+                if exit_on_success {
+                    state.input_state.should_exit = true;
+                }
             }
 
             // Render if configured and needs redraw, but only if no frame callback pending

src/backend/wayland/capture.rs

@@ -8,6 +8,7 @@ use crate::capture::CaptureManager;
 pub struct CaptureState {
     manager: CaptureManager,
     in_progress: bool,
+    exit_on_success: bool,
 }
 
 impl CaptureState {
@@ -16,6 +17,7 @@ impl CaptureState {
         Self {
             manager,
             in_progress: false,
+            exit_on_success: false,
         }
     }
 
@@ -38,4 +40,21 @@ impl CaptureState {
     pub fn clear_in_progress(&mut self) {
         self.in_progress = false;
     }
+
+    /// Marks whether the current capture should exit the overlay on success.
+    pub fn set_exit_on_success(&mut self, value: bool) {
+        self.exit_on_success = value;
+    }
+
+    /// Clears any pending exit request for the current capture.
+    pub fn clear_exit_on_success(&mut self) {
+        self.exit_on_success = false;
+    }
+
+    /// Returns and clears the exit-on-success flag for the last capture.
+    pub fn take_exit_on_success(&mut self) -> bool {
+        let value = self.exit_on_success;
+        self.exit_on_success = false;
+        value
+    }
 }

src/backend/wayland/state.rs

@@ -45,6 +45,7 @@ use wayland_protocols::wp::{
 #[cfg(tablet)]
 use crate::input::tablet::TabletSettings;
 use crate::{
+    backend::ExitAfterCaptureMode,
     capture::{
         CaptureDestination, CaptureManager,
         file::{FileSaveConfig, expand_tilde},
@@ -109,6 +110,7 @@ pub(in crate::backend::wayland) struct WaylandStateInit {
     pub capture_manager: CaptureManager,
     pub session_options: Option<SessionOptions>,
     pub tokio_handle: tokio::runtime::Handle,
+    pub exit_after_capture_mode: ExitAfterCaptureMode,
     pub frozen_enabled: bool,
     pub preferred_output_identity: Option<String>,
     pub xdg_fullscreen: bool,
@@ -150,6 +152,9 @@ pub(super) struct WaylandState {
     pub(super) frozen: FrozenState,
     pub(super) zoom: ZoomState,
 
+    // Overlay behavior
+    pub(super) exit_after_capture_mode: ExitAfterCaptureMode,
+
     // Pointer cursor
     pub(super) themed_pointer: Option<ThemedPointer<PointerData>>,
     pub(super) locked_pointer: Option<ZwpLockedPointerV1>,

src/backend/wayland/state/capture.rs

@@ -1,6 +1,15 @@
 use super::*;
 
 impl WaylandState {
+    fn should_exit_after_capture(&self, destination: CaptureDestination) -> bool {
+        let is_clipboard_only = matches!(destination, CaptureDestination::ClipboardOnly);
+        match self.exit_after_capture_mode {
+            ExitAfterCaptureMode::Always => true,
+            ExitAfterCaptureMode::Never => false,
+            ExitAfterCaptureMode::Auto => is_clipboard_only,
+        }
+    }
+
     pub(in crate::backend::wayland) fn apply_capture_completion(&mut self) {
         if self.frozen.take_capture_done() {
             self.exit_overlay_suppression(OverlaySuppression::Frozen);
@@ -117,6 +126,9 @@ impl WaylandState {
             })
         };
 
+        let exit_on_success = self.should_exit_after_capture(destination);
+        self.capture.set_exit_on_success(exit_on_success);
+
         // Suppress overlay before capture to prevent capturing the overlay itself
         self.enter_overlay_suppression(OverlaySuppression::Capture);
         self.capture.mark_in_progress();
@@ -133,6 +145,7 @@ impl WaylandState {
             // Restore overlay on error
             self.show_overlay();
             self.capture.clear_in_progress();
+            self.capture.clear_exit_on_success();
         }
     }
 }