Merge pull request #309 from Gigas002/feature/freeze-option

feature: add freeze option

Author: Gigas002

config.toml

@@ -3,6 +3,8 @@
 # output = "HDMI-A-1"
 # should contain cursor?
 cursor = false
+# freeze screen when selecting region (--geometry) or point (--color)? false = live selection (like --no-freeze)
+freeze = true
 # delay in milliseconds before taking the screenshot; omit or leave unset for no delay
 # delay = 0
 # should copy screenshot to clipborad?

docs/wayshot.1.scd

@@ -43,15 +43,17 @@ Wayshot - Screenshot tool for compositors implementing zwlr_screencopy_v1 such a
 	List all active toplevel windows.
 
 *--color*
-	Freeze the screen, click a pixel, and print its RGBA and hex color value.
+	Click a pixel and print its RGBA and hex color value. By default the screen is frozen first;
+	use *--no-freeze* to pick on the live display.
 
 	_Requires the_ *color_picker* _feature (enabled by default)._
 
 ## Capture target (what to capture)
 
 *-g*, *--geometry*
-	Interactively select a screen region. The screen is frozen before the selection overlay is
-	shown, giving a stable view for precise selection.
+	Interactively select a screen region. By default the screen is frozen before the selection
+	overlay is shown, giving a stable view for precise selection. Use *--no-freeze* to select on
+	the live display and capture after selection.
 
 	_Requires the_ *selector* _feature (enabled by default)._
 
@@ -73,6 +75,11 @@ Wayshot - Screenshot tool for compositors implementing zwlr_screencopy_v1 such a
 *-c*, *--cursor*
 	Include the cursor in the screenshot.
 
+*--no-freeze*
+	Do not freeze the screen when selecting a region (*--geometry*) or a point (*--color*).
+	Selection is done on the live display; the capture is taken after selection.
+	Config: *[base] freeze* (see wayshot(5)).
+
 *--delay* _MS_
 	Wait _MS_ milliseconds before taking the screenshot. No delay when omitted.
 	Config: *[base] delay* (see wayshot(5)).

docs/wayshot.5.scd

@@ -38,6 +38,15 @@ This section documents the *[base]* table of the configuration file
 
 	Default: _false_
 
+*freeze* = _true_ | _false_
+
+	When true, freeze the screen before interactive region (*--geometry*) or point (*--color*)
+	selection, giving a stable view. When false, selection is on the live display and the
+	capture is taken after selection (same as *--no-freeze*). CLI *--no-freeze* takes
+	precedence.
+
+	Default: _true_
+
 *delay* = _<integer>_ | _unset_
 
 	Number of milliseconds to wait before taking the screenshot. When unset or omitted, no delay is applied.

wayshot/src/cli.rs

@@ -96,6 +96,11 @@ pub struct Cli {
     #[arg(short, long)]
     pub cursor: bool,
 
+    /// Do not freeze the screen when selecting a region (geometry) or a point (color picker).
+    /// Selection happens on the live display; the capture is taken after selection.
+    #[arg(long)]
+    pub no_freeze: bool,
+
     /// Wait this many milliseconds before taking the screenshot. No delay when unset.
     #[arg(long, value_name = "MS")]
     pub delay: Option<u32>,

wayshot/src/color_picker.rs

@@ -2,36 +2,21 @@
 
 use eyre::Result;
 use libwayshot::WayshotConnection;
-use libwaysip::WaySip;
 
-use crate::utils::waysip_to_region;
+use crate::utils::get_region_point;
 
-/// Freeze the screen, let the user click a pixel, and print its color.
-pub fn pick(conn: &WayshotConnection) -> Result<()> {
-    let image = conn
-        .screenshot_freeze(
-            |w_conn| {
-                let info = WaySip::new()
-                    .with_connection(w_conn.conn.clone())
-                    .with_selection_type(libwaysip::SelectionType::Point)
-                    .get()
-                    .map_err(|e| libwayshot::Error::FreezeCallbackError(e.to_string()))?
-                    .ok_or_else(|| {
-                        libwayshot::Error::FreezeCallbackError(
-                            "Failed to capture the point".to_string(),
-                        )
-                    })?;
-                waysip_to_region(
-                    libwaysip::Size {
-                        width: 1,
-                        height: 1,
-                    },
-                    info.left_top_point(),
-                )
-            },
+/// Let the user click a pixel and print its color. When `freeze` is true, the screen is frozen first.
+pub fn pick(conn: &WayshotConnection, freeze: bool) -> Result<()> {
+    let image = (if freeze {
+        conn.screenshot_freeze(
+            |w_conn| get_region_point(w_conn).map_err(libwayshot::Error::FreezeCallbackError),
             false,
         )?
-        .to_rgba8();
+    } else {
+        let region = get_region_point(conn).map_err(|e| eyre::eyre!("{e}"))?;
+        conn.screenshot(region, false)?
+    })
+    .to_rgba8();
 
     let [r, g, b, a] = image.get_pixel(0, 0).0;
     println!("RGBA       : R:{r}, G:{g}, B:{b}, A:{a}");

wayshot/src/config.rs

@@ -43,6 +43,7 @@ impl Config {
 pub struct Base {
     pub output: Option<String>,
     pub cursor: Option<bool>,
+    pub freeze: Option<bool>,
     pub delay: Option<u32>,
     pub clipboard: Option<bool>,
     pub file: Option<bool>,
@@ -56,6 +57,7 @@ impl Default for Base {
         Base {
             output: None,
             cursor: Some(false),
+            freeze: Some(true),
             delay: None,
             clipboard: Some(false),
             file: Some(true),

wayshot/src/screenshot.rs

@@ -1,11 +1,8 @@
+#[cfg(feature = "selector")]
+use crate::utils::get_region_area;
 use dialoguer::{FuzzySelect, theme::ColorfulTheme};
 use eyre::{Result, bail};
 use libwayshot::WayshotConnection;
-#[cfg(feature = "selector")]
-use libwaysip::WaySip;
-
-#[cfg(feature = "selector")]
-use crate::utils::waysip_to_region;
 
 /// Describes what was captured, used to build the notification body.
 #[derive(Debug, Clone)]
@@ -39,10 +36,11 @@ pub fn capture(
     conn: &WayshotConnection,
     mode: &CaptureMode,
     cursor: bool,
+    freeze: bool,
 ) -> Result<(image::DynamicImage, ShotResult)> {
     match mode {
         #[cfg(feature = "selector")]
-        CaptureMode::Geometry => capture_geometry(conn, cursor),
+        CaptureMode::Geometry => capture_geometry(conn, cursor, freeze),
         CaptureMode::Toplevel(name) => capture_toplevel_by_name(conn, name, cursor),
         CaptureMode::ChooseToplevel => capture_toplevel_interactive(conn, cursor),
         CaptureMode::Output(name) => capture_output_by_name(conn, name, cursor),
@@ -56,21 +54,17 @@ pub fn capture(
 fn capture_geometry(
     conn: &WayshotConnection,
     cursor: bool,
+    freeze: bool,
 ) -> Result<(image::DynamicImage, ShotResult)> {
-    let image = conn.screenshot_freeze(
-        |w_conn| {
-            let info = WaySip::new()
-                .with_connection(w_conn.conn.clone())
-                .with_selection_type(libwaysip::SelectionType::Area)
-                .get()
-                .map_err(|e| libwayshot::Error::FreezeCallbackError(e.to_string()))?
-                .ok_or_else(|| {
-                    libwayshot::Error::FreezeCallbackError("No area selected".to_string())
-                })?;
-            waysip_to_region(info.size(), info.left_top_point())
-        },
-        cursor,
-    )?;
+    let image = if freeze {
+        conn.screenshot_freeze(
+            |w_conn| get_region_area(w_conn).map_err(libwayshot::Error::FreezeCallbackError),
+            cursor,
+        )?
+    } else {
+        let region = get_region_area(conn).map_err(|e| eyre::eyre!("{e}"))?;
+        conn.screenshot(region, cursor)?
+    };
     Ok((image, ShotResult::Area))
 }
 

wayshot/src/settings.rs

@@ -33,6 +33,8 @@ pub(crate) struct AppSettings {
     pub(crate) command: Command,
     /// Whether to render the cursor in the captured image.
     pub(crate) cursor: bool,
+    /// When true, freeze the screen before region/point selection; when false, select on live display.
+    pub(crate) freeze: bool,
     /// Milliseconds to wait before capturing; `None` means no delay.
     pub(crate) delay: Option<u32>,
     /// Final encoding format, after resolving extension / flag / config precedence.
@@ -61,6 +63,10 @@ impl AppSettings {
         // Either the --cursor flag or config `cursor = true` enables cursor capture.
         let cursor = cli.cursor || base.cursor.unwrap_or_default();
 
+        // ── Freeze ─────────────────────────────────────────────────────────────
+        // Freeze screen before selection; false when CLI --no-freeze or config freeze = false.
+        let freeze = !cli.no_freeze && base.freeze.unwrap_or(true);
+
         // ── Delay ─────────────────────────────────────────────────────────────
         // Wait N ms before capture; CLI overrides config; None = no delay.
         let delay = cli.delay.or(base.delay);
@@ -132,6 +138,7 @@ impl AppSettings {
         AppSettings {
             command,
             cursor,
+            freeze,
             delay,
             encoding,
             file,

wayshot/src/utils.rs

@@ -17,7 +17,7 @@ use std::{
 };
 
 use chrono::Local;
-#[cfg(feature = "selector")]
+#[cfg(any(feature = "selector", feature = "color_picker"))]
 use libwayshot::{
     Result as WayshotResult,
     region::{LogicalRegion, Position, Region, Size},
@@ -63,7 +63,7 @@ pub fn print_completions(shell: crate::cli::Shell) {
 
 // ─── Region helpers ───────────────────────────────────────────────────────────
 
-#[cfg(feature = "selector")]
+#[cfg(any(feature = "selector", feature = "color_picker"))]
 pub fn waysip_to_region(
     size: libwaysip::Size,
     position: libwaysip::Position,
@@ -87,6 +87,37 @@ pub fn waysip_to_region(
     })
 }
 
+/// Run WaySip area selection and return the chosen region. Used for both freeze and live paths.
+#[cfg(feature = "selector")]
+pub fn get_region_area(conn: &libwayshot::WayshotConnection) -> Result<LogicalRegion, String> {
+    let info = libwaysip::WaySip::new()
+        .with_connection(conn.conn.clone())
+        .with_selection_type(libwaysip::SelectionType::Area)
+        .get()
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| "No area selected".to_string())?;
+    waysip_to_region(info.size(), info.left_top_point()).map_err(|e| e.to_string())
+}
+
+/// Run WaySip point selection and return a 1×1 region. Used for both freeze and live paths.
+#[cfg(feature = "color_picker")]
+pub fn get_region_point(conn: &libwayshot::WayshotConnection) -> Result<LogicalRegion, String> {
+    let info = libwaysip::WaySip::new()
+        .with_connection(conn.conn.clone())
+        .with_selection_type(libwaysip::SelectionType::Point)
+        .get()
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| "Failed to capture the point".to_string())?;
+    waysip_to_region(
+        libwaysip::Size {
+            width: 1,
+            height: 1,
+        },
+        info.left_top_point(),
+    )
+    .map_err(|e| e.to_string())
+}
+
 // ─── Encoding format ──────────────────────────────────────────────────────────
 
 /// Supported image encoding formats.

wayshot/src/wayshot.rs

@@ -63,12 +63,12 @@ fn main() -> Result<()> {
             Ok(())
         }
         #[cfg(feature = "color_picker")]
-        Command::ColorPicker => color_picker::pick(&connection),
+        Command::ColorPicker => color_picker::pick(&connection, settings.freeze),
         Command::Screenshot(mode) => {
             if let Some(ms) = settings.delay {
                 std::thread::sleep(Duration::from_millis(ms as u64));
             }
-            let result = screenshot::capture(&connection, &mode, settings.cursor);
+            let result = screenshot::capture(&connection, &mode, settings.cursor, settings.freeze);
             match result {
                 Ok((image_buffer, shot_result)) => {
                     let encoded = utils::encode_image(