Add optional exit-after-capture config

Author: devmobasa

config.example.toml

@@ -332,6 +332,9 @@ format = "png"
 # Shortcut-specific actions may override this
 copy_to_clipboard = true
 
+# Exit overlay after a capture completes
+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(
+                    "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,9 @@ format = "png"
 
 # Copy captures to clipboard in addition to saving files
 copy_to_clipboard = true
+
+# Exit the overlay after a capture completes
+exit_after_capture = false
 ```
 
 **Tips:**

src/backend/mod.rs

@@ -10,8 +10,14 @@ pub mod wayland;
 /// # 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` - Whether to exit the overlay after a capture completes
+pub fn run_wayland(
+    initial_mode: Option<String>,
+    freeze_on_start: bool,
+    exit_after_capture: bool,
+) -> Result<()> {
+    let mut backend =
+        wayland::WaylandBackend::new(initial_mode, freeze_on_start, exit_after_capture)?;
     backend.init()?;
     backend.show()?; // show() calls run() internally
     backend.hide()?;
@@ -27,6 +33,6 @@ 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, false).expect("Wayland backend should start");
     }
 }

src/backend/wayland/backend.rs

@@ -139,17 +139,23 @@ fn resume_override_from_env() -> Option<bool> {
 pub struct WaylandBackend {
     initial_mode: Option<String>,
     freeze_on_start: bool,
+    exit_after_capture_override: bool,
     /// 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_override: bool,
+    ) -> 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_override,
             tokio_runtime,
         })
     }
@@ -259,6 +265,8 @@ impl WaylandBackend {
                 (Config::default(), ConfigSource::Default)
             }
         };
+        let exit_after_capture =
+            self.exit_after_capture_override || config.capture.exit_after_capture;
 
         info!("Configuration loaded");
         debug!("  Color: {:?}", config.drawing.default_color);
@@ -514,6 +522,7 @@ impl WaylandBackend {
             capture_manager,
             session_options,
             tokio_handle,
+            exit_after_capture,
             frozen_enabled: frozen_supported,
             preferred_output_identity,
             xdg_fullscreen,
@@ -773,6 +782,8 @@ impl WaylandBackend {
                 state.show_overlay();
                 state.capture.clear_in_progress();
 
+                let exit_on_success =
+                    state.exit_after_capture && matches!(&outcome, CaptureOutcome::Success(_));
                 match outcome {
                     CaptureOutcome::Success(result) => {
                         // Build notification message
@@ -821,6 +832,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/state.rs

@@ -109,6 +109,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: bool,
     pub frozen_enabled: bool,
     pub preferred_output_identity: Option<String>,
     pub xdg_fullscreen: bool,
@@ -150,6 +151,9 @@ pub(super) struct WaylandState {
     pub(super) frozen: FrozenState,
     pub(super) zoom: ZoomState,
 
+    // Overlay behavior
+    pub(super) exit_after_capture: bool,
+
     // Pointer cursor
     pub(super) themed_pointer: Option<ThemedPointer<PointerData>>,
     pub(super) locked_pointer: Option<ZwpLockedPointerV1>,

src/config/types.rs

@@ -767,6 +767,10 @@ pub struct CaptureConfig {
     /// Automatically copy screenshots to clipboard
     #[serde(default = "default_capture_clipboard")]
     pub copy_to_clipboard: bool,
+
+    /// Exit the overlay after a capture completes
+    #[serde(default = "default_capture_exit_after")]
+    pub exit_after_capture: bool,
 }
 
 impl Default for CaptureConfig {
@@ -777,6 +781,7 @@ impl Default for CaptureConfig {
             filename_template: default_capture_filename(),
             format: default_capture_format(),
             copy_to_clipboard: default_capture_clipboard(),
+            exit_after_capture: default_capture_exit_after(),
         }
     }
 }
@@ -802,6 +807,10 @@ fn default_capture_clipboard() -> bool {
     true
 }
 
+fn default_capture_exit_after() -> bool {
+    false
+}
+
 /// Session persistence configuration.
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 pub struct SessionConfig {

src/main.rs

@@ -97,6 +97,10 @@ struct Cli {
     )]
     freeze: bool,
 
+    /// Exit the overlay after a capture completes
+    #[arg(long, action = ArgAction::SetTrue)]
+    exit_after_capture: bool,
+
     /// Force session resume on (persist/restore all boards + history/tool state)
     #[arg(long, action = ArgAction::SetTrue, conflicts_with = "no_resume_session")]
     resume_session: bool,
@@ -211,7 +215,7 @@ fn run() -> anyhow::Result<()> {
         set_runtime_session_override(session_override);
 
         // Run Wayland backend
-        backend::run_wayland(cli.mode, cli.freeze)?;
+        backend::run_wayland(cli.mode, cli.freeze, cli.exit_after_capture)?;
 
         log::info!("Annotation overlay closed.");
     } else {
@@ -223,13 +227,14 @@ fn run() -> anyhow::Result<()> {
             "  wayscriber -d, --daemon      Run as background daemon (bind a toggle like Super+D)"
         );
         println!("  wayscriber -a, --active      Show overlay immediately (one-shot mode)");
+        println!("  wayscriber --freeze          Start overlay already frozen");
+        println!("  wayscriber --exit-after-capture  Exit overlay after a capture completes");
         println!("  wayscriber --no-tray         Skip system tray (headless daemon)");
         println!("  wayscriber --about           Show the About window");
         println!(
             "  wayscriber --resume-session  Force session resume on (all boards/history/tool state)"
         );
         println!("  wayscriber --no-resume-session  Disable session resume for this run");
-        println!("  wayscriber --freeze          Start overlay already frozen");
         println!("  wayscriber -h, --help        Show help");
         println!();
         println!("Daemon mode (recommended). Example Hyprland setup:");