`c985aa3`

add delay timer, desktop notifications, and stdout output

- --delay <secs> flag for countdown before capture
- --notify flag for desktop notification on save
- -o - for stdout output mode (piping to other tools)
- Updated README with new options and libnotify dependency

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: c985aa337aeee938e6f4c13ae7e350f8163a36dc
Parents: 754344f
Tree: cd1ae40

2 changed files

Status	File	+	-
M	`README.md`	10	4
M	`garshot/src/main.rs`	278	113

README.mdmodified

  Runtime:
  - X11
  - xclip (for clipboard)
++- libnotify (for --notify, optional)
  ### Fedora/RHEL
  ```sh
--sudo dnf install libxcb-devel libX11-devel cairo-devel xclip
++sudo dnf install libxcb-devel libX11-devel cairo-devel xclip libnotify
  ```
  ### Debian/Ubuntu
  ```sh
--sudo apt install libxcb1-dev libx11-dev libcairo2-dev xclip
++sudo apt install libxcb1-dev libx11-dev libcairo2-dev xclip libnotify-bin
  ```
  ### Arch
  ```sh
--sudo pacman -S libxcb libx11 cairo xclip
++sudo pacman -S libxcb libx11 cairo xclip libnotify
  ```
  ## Build
  garshot screen -m DP-1             # Specific monitor
  garshot screen -c                  # Include cursor
  garshot screen -f jpeg -o shot.jpg # JPEG output
++garshot screen --delay 3           # 3 second countdown
++garshot screen --notify            # Desktop notification on save
++garshot screen -o - | feh -        # Pipe to viewer
  ```
  ### Interactive selection
  | Option | Description |
  |--------|-------------|
--| `-o, --output <PATH>` | Output file path |
++| `-o, --output <PATH>` | Output file path (use `-` for stdout) |
  | `-f, --format <FMT>` | png, jpeg, webp (default: png) |
  | `-c, --cursor` | Include cursor in capture |
  | `--no-clipboard` | Don't copy to clipboard |
++| `--delay <SECS>` | Delay before capture (screen/region/window) |
++| `--notify` | Show desktop notification on save |
  ## Configuration

garshot/src/main.rsmodified

  //! This is the main entry point for the garshot daemon. It can also be used
  //! for one-shot captures without running the daemon.
++use std::io::Write;
  use std::path::PathBuf;
++use std::time::Duration;
  use anyhow::Context;
  use clap::{Parser, Subcommand};
      /// Capture full screen (one-shot, no daemon required).
      Screen {
--        /// Output file path.
++        /// Output file path (use "-" for stdout).
          #[arg(short, long)]
          output: Option<PathBuf>,
          /// Don't copy to clipboard (default: copy to clipboard).
          #[arg(long)]
          no_clipboard: bool,
++
++        /// Delay in seconds before capture.
++        #[arg(long)]
++        delay: Option<u64>,
++
++        /// Show desktop notification on save.
++        #[arg(long)]
++        notify: bool,
      },
      /// Capture a region by geometry.
          #[arg(short, long)]
          geometry: String,
--        /// Output file path.
++        /// Output file path (use "-" for stdout).
          #[arg(short, long)]
          output: Option<PathBuf>,
          /// Don't copy to clipboard (default: copy to clipboard).
          #[arg(long)]
          no_clipboard: bool,
++
++        /// Delay in seconds before capture.
++        #[arg(long)]
++        delay: Option<u64>,
++
++        /// Show desktop notification on save.
++        #[arg(long)]
++        notify: bool,
      },
      /// Capture a window.
          #[arg(short, long)]
          decorations: bool,
--        /// Output file path.
++        /// Output file path (use "-" for stdout).
          #[arg(short, long)]
          output: Option<PathBuf>,
          /// Don't copy to clipboard (default: copy to clipboard).
          #[arg(long)]
          no_clipboard: bool,
++
++        /// Delay in seconds before capture.
++        #[arg(long)]
++        delay: Option<u64>,
++
++        /// Show desktop notification on save.
++        #[arg(long)]
++        notify: bool,
      },
      /// Interactive region selection with blur overlay.
      Select {
--        /// Output file path.
++        /// Output file path (use "-" for stdout).
          #[arg(short, long)]
          output: Option<PathBuf>,
          /// Don't copy to clipboard (default: copy to clipboard).
          #[arg(long)]
          no_clipboard: bool,
++
++        /// Show desktop notification on save.
++        #[arg(long)]
++        notify: bool,
      },
      /// List available monitors.
              monitor,
              cursor,
              no_clipboard,
++            delay,
++            notify,
          }) => {
--            let output = output.unwrap_or_else(|| default_output(&config, &format));
++            if let Some(secs) = delay {
--            capture_screen(&output, &format, monitor.as_deref(), cursor)?;
++                sleep_with_countdown(secs);
++            }
++            let is_stdout = output.as_ref().map(|p| p.as_os_str() == "-").unwrap_or(false);
++            let output_path = if is_stdout {
++                None
++            } else {
++                Some(output.unwrap_or_else(|| default_output(&config, &format)))
++            };
++            let (data, width, height) = capture_screen_raw(&format, monitor.as_deref(), cursor)?;
++            if let Some(ref path) = output_path {
++                save_image(&data, width, height, path, &format)?;
                  if !no_clipboard {
--                copy_to_clipboard(&output)?;
++                    copy_to_clipboard(path)?;
++                }
++                if notify {
++                    send_notification(path, width, height);
++                }
++                println!("{}", path.display());
++            } else {
++                write_stdout(&data, width, height, &format)?;
+             }
--            println!("{}", output.display());
+         }
          Some(Command::Region {
              format,
              cursor,
              no_clipboard,
++            delay,
++            notify,
          }) => {
--            let output = output.unwrap_or_else(|| default_output(&config, &format));
++            if let Some(secs) = delay {
--            capture_region_cmd(&output, &format, &geometry, cursor)?;
++                sleep_with_countdown(secs);
++            }
++            let is_stdout = output.as_ref().map(|p| p.as_os_str() == "-").unwrap_or(false);
++            let output_path = if is_stdout {
++                None
++            } else {
++                Some(output.unwrap_or_else(|| default_output(&config, &format)))
++            };
++            let (data, width, height) = capture_region_raw(&geometry, cursor)?;
++            if let Some(ref path) = output_path {
++                save_image(&data, width, height, path, &format)?;
                  if !no_clipboard {
--                copy_to_clipboard(&output)?;
++                    copy_to_clipboard(path)?;
++                }
++                if notify {
++                    send_notification(path, width, height);
++                }
++                println!("{}", path.display());
++            } else {
++                write_stdout(&data, width, height, &format)?;
+             }
--            println!("{}", output.display());
+         }
          Some(Command::Window {
              format,
              cursor,
              no_clipboard,
++            delay,
++            notify,
          }) => {
--            let output = output.unwrap_or_else(|| default_output(&config, &format));
++            if let Some(secs) = delay {
--            capture_window_cmd(&output, &format, id.as_deref(), decorations, cursor)?;
++                sleep_with_countdown(secs);
++            }
++            let is_stdout = output.as_ref().map(|p| p.as_os_str() == "-").unwrap_or(false);
++            let output_path = if is_stdout {
++                None
++            } else {
++                Some(output.unwrap_or_else(|| default_output(&config, &format)))
++            };
++            let (data, width, height) = capture_window_raw(id.as_deref(), decorations, cursor)?;
++            if let Some(ref path) = output_path {
++                save_image(&data, width, height, path, &format)?;
                  if !no_clipboard {
--                copy_to_clipboard(&output)?;
++                    copy_to_clipboard(path)?;
++                }
++                if notify {
++                    send_notification(path, width, height);
++                }
++                println!("{}", path.display());
++            } else {
++                write_stdout(&data, width, height, &format)?;
+             }
--            println!("{}", output.display());
+         }
          Some(Command::Select {
              cursor,
              blur,
              no_clipboard,
++            notify,
          }) => {
--            let output = output.unwrap_or_else(|| default_output(&config, &format));
++            let is_stdout = output.as_ref().map(|p| p.as_os_str() == "-").unwrap_or(false);
--            capture_select_cmd(&output, &format, cursor, blur)?;
++            let output_path = if is_stdout {
++                None
++            } else {
++                Some(output.unwrap_or_else(|| default_output(&config, &format)))
++            };
++            if let Some((data, width, height)) = capture_select_raw(cursor, blur)? {
++                if let Some(ref path) = output_path {
++                    save_image(&data, width, height, path, &format)?;
                      if !no_clipboard {
--                copy_to_clipboard(&output)?;
++                        copy_to_clipboard(path)?;
++                    }
++                    if notify {
++                        send_notification(path, width, height);
++                    }
++                    println!("{}", path.display());
++                } else {
++                    write_stdout(&data, width, height, &format)?;
++                }
+             }
--            println!("{}", output.display());
+         }
          Some(Command::Monitors) => {
      save_image(&result.data, result.width, result.height, output, format)
+ }
--fn capture_region_cmd(
++
++fn save_image(
++    data: &[u8],
++    width: u32,
++    height: u32,
      output: &PathBuf,
      format: &str,
++) -> anyhow::Result<()> {
++    match format {
++        "png" => encode_png(data, width, height, output).context("Failed to encode PNG")?,
++        _ => anyhow::bail!("Unsupported format: {}", format),
++    }
++    tracing::info!("Saved {}x{} to {}", width, height, output.display());
++    Ok(())
++}
++
++fn parse_window_id(s: &str) -> anyhow::Result<u32> {
++    let s = s.trim();
++    if s.starts_with("0x") || s.starts_with("0X") {
++        u32::from_str_radix(&s[2..], 16).context("Invalid hex window ID")
++    } else {
++        s.parse().context("Invalid decimal window ID")
++    }
++}
++
++fn copy_to_clipboard(path: &PathBuf) -> anyhow::Result<()> {
++    let mime_type = match path.extension().and_then(|e| e.to_str()) {
++        Some("png") => "image/png",
++        Some("jpg") | Some("jpeg") => "image/jpeg",
++        Some("webp") => "image/webp",
++        Some("ppm") | Some("pam") => "image/x-portable-pixmap",
++        _ => "image/png", // Default to PNG
++    };
++
++    // Try xclip first, then xsel
++    let result = std::process::Command::new("xclip")
++        .args(["-selection", "clipboard", "-t", mime_type, "-i"])
++        .arg(path)
++        .status();
++
++    match result {
++        Ok(status) if status.success() => {
++            tracing::debug!("Copied {} to clipboard via xclip", path.display());
++            Ok(())
++        }
++        _ => {
++            // Fallback to xsel (doesn't support MIME types as well)
++            let result = std::process::Command::new("xsel")
++                .args(["--clipboard", "--input"])
++                .stdin(std::fs::File::open(path)?)
++                .status();
++
++            match result {
++                Ok(status) if status.success() => {
++                    tracing::debug!("Copied {} to clipboard via xsel", path.display());
++                    Ok(())
++                }
++                Ok(status) => {
++                    tracing::warn!("xsel exited with status: {}", status);
++                    anyhow::bail!("Failed to copy to clipboard")
++                }
++                Err(e) => {
++                    tracing::warn!("Neither xclip nor xsel available: {}", e);
++                    anyhow::bail!("No clipboard tool available (install xclip or xsel)")
++                }
++            }
++        }
++    }
++}
++
++fn sleep_with_countdown(secs: u64) {
++    for i in (1..=secs).rev() {
++        eprint!("\rCapturing in {}... ", i);
++        std::io::stderr().flush().ok();
++        std::thread::sleep(Duration::from_secs(1));
++    }
++    eprintln!("\rCapturing now!     ");
++}
++
++fn send_notification(path: &PathBuf, width: u32, height: u32) {
++    let summary = "Screenshot saved";
++    let body = format!("{}x{} → {}", width, height, path.display());
++
++    // Try notify-send (most common)
++    let result = std::process::Command::new("notify-send")
++        .args(["-i", "camera-photo", "-a", "garshot", summary, &body])
++        .status();
++
++    if result.is_err() || !result.unwrap().success() {
++        tracing::debug!("notify-send not available or failed");
++    }
++}
++
++fn write_stdout(data: &[u8], width: u32, height: u32, format: &str) -> anyhow::Result<()> {
++    let encoded = encode_to_vec(data, width, height, format)?;
++    std::io::stdout().write_all(&encoded)?;
++    std::io::stdout().flush()?;
++    Ok(())
++}
++
++fn encode_to_vec(data: &[u8], width: u32, height: u32, format: &str) -> anyhow::Result<Vec<u8>> {
++    garshot::encode::encode_to_vec(data, width, height, format, 90)
++        .context("Failed to encode image")
++}
++
++fn capture_screen_raw(
++    _format: &str,
++    monitor: Option<&str>,
++    include_cursor: bool,
++) -> anyhow::Result<(Vec<u8>, u32, u32)> {
++    let conn = Connection::new().context("Failed to connect to X11")?;
++    let buffer_size = conn.width as usize * conn.height as usize * 4;
++    let shm = ShmCapture::new(&conn, buffer_size).context("Failed to create SHM buffer")?;
++
++    let mut result = if let Some(monitor_name) = monitor {
++        tracing::info!("Capturing monitor {}", monitor_name);
++        capture_monitor(&conn, &shm, monitor_name)?
++    } else {
++        tracing::info!("Capturing full screen");
++        let r = capture_full_screen(&conn, &shm)?;
++        garshot::capture::RegionCaptureResult {
++            data: r.data,
++            width: r.width,
++            height: r.height,
++            region: Region::new(0, 0, conn.width, conn.height),
++        }
++    };
++
++    if include_cursor {
++        if let Ok(cursor) = get_cursor_image(&conn) {
++            blend_cursor(
++                &mut result.data,
++                result.width,
++                result.height,
++                &result.region,
++                &cursor,
++            );
++        }
++    }
++
++    Ok((result.data, result.width, result.height))
++}
++
++fn capture_region_raw(
      geometry: &str,
      include_cursor: bool,
--) -> anyhow::Result<()> {
++) -> anyhow::Result<(Vec<u8>, u32, u32)> {
      let conn = Connection::new().context("Failed to connect to X11")?;
      let buffer_size = conn.width as usize * conn.height as usize * 4;
      let shm = ShmCapture::new(&conn, buffer_size).context("Failed to create SHM buffer")?;
      let region = Region::from_geometry(geometry).context("Invalid geometry")?;
      tracing::info!(
--        "Capturing region {}x{}+{}+{} to {}",
++        "Capturing region {}x{}+{}+{}",
          region.width,
          region.height,
          region.x,
--        region.y,
++        region.y
--        output.display()
      );
      let mut result = capture_region(&conn, &shm, &region)?;
+         }
+     }
--    save_image(&result.data, result.width, result.height, output, format)
++    Ok((result.data, result.width, result.height))
+ }
--fn capture_window_cmd(
++fn capture_window_raw(
--    output: &PathBuf,
--    format: &str,
      window_id: Option<&str>,
      decorations: bool,
      include_cursor: bool,
--) -> anyhow::Result<()> {
++) -> anyhow::Result<(Vec<u8>, u32, u32)> {
      use garshot::capture::{capture_active_window, capture_window, get_active_window};
      let conn = Connection::new().context("Failed to connect to X11")?;
      let mut result = if let Some(id_str) = window_id {
          let id = parse_window_id(id_str)?;
--        tracing::info!("Capturing window 0x{:x} to {}", id, output.display());
++        tracing::info!("Capturing window 0x{:x}", id);
          capture_window(&conn, &shm, id, decorations)?
      } else {
          let active = get_active_window(&conn)?;
--        tracing::info!("Capturing active window 0x{:x} to {}", active, output.display());
++        tracing::info!("Capturing active window 0x{:x}", active);
          capture_active_window(&conn, &shm, decorations)?
      };
+         }
+     }
--    save_image(&result.data, result.width, result.height, output, format)
++    Ok((result.data, result.width, result.height))
--}
--
--fn save_image(
--    data: &[u8],
--    width: u32,
--    height: u32,
--    output: &PathBuf,
--    format: &str,
--) -> anyhow::Result<()> {
--    match format {
--        "png" => encode_png(data, width, height, output).context("Failed to encode PNG")?,
--        _ => anyhow::bail!("Unsupported format: {}", format),
--    }
--    tracing::info!("Saved {}x{} to {}", width, height, output.display());
--    Ok(())
--}
--
--fn parse_window_id(s: &str) -> anyhow::Result<u32> {
--    let s = s.trim();
--    if s.starts_with("0x") || s.starts_with("0X") {
--        u32::from_str_radix(&s[2..], 16).context("Invalid hex window ID")
--    } else {
--        s.parse().context("Invalid decimal window ID")
--    }
+ }
--fn capture_select_cmd(
++fn capture_select_raw(
--    output: &PathBuf,
--    format: &str,
      include_cursor: bool,
      blur_radius: usize,
--) -> anyhow::Result<()> {
++) -> anyhow::Result<Option<(Vec<u8>, u32, u32)>> {
      let conn = Connection::new().context("Failed to connect to X11")?;
      let buffer_size = conn.width as usize * conn.height as usize * 4;
      let shm = ShmCapture::new(&conn, buffer_size).context("Failed to create SHM buffer")?;
          Some(region) => region,
          None => {
              tracing::info!("Selection cancelled");
--            return Ok(());
++            return Ok(None);
+         }
      };
          region.y
      );
--    // Capture the selected region
      let mut result = capture_region(&conn, &shm, &region)?;
      if include_cursor {
+         }
+     }
--    save_image(&result.data, result.width, result.height, output, format)
++    Ok(Some((result.data, result.width, result.height)))
--}
--
--fn copy_to_clipboard(path: &PathBuf) -> anyhow::Result<()> {
--    let mime_type = match path.extension().and_then(|e| e.to_str()) {
--        Some("png") => "image/png",
--        Some("jpg") | Some("jpeg") => "image/jpeg",
--        Some("webp") => "image/webp",
--        Some("ppm") | Some("pam") => "image/x-portable-pixmap",
--        _ => "image/png", // Default to PNG
--    };
--
--    // Try xclip first, then xsel
--    let result = std::process::Command::new("xclip")
--        .args(["-selection", "clipboard", "-t", mime_type, "-i"])
--        .arg(path)
--        .status();
--
--    match result {
--        Ok(status) if status.success() => {
--            tracing::debug!("Copied {} to clipboard via xclip", path.display());
--            Ok(())
--        }
--        _ => {
--            // Fallback to xsel (doesn't support MIME types as well)
--            let result = std::process::Command::new("xsel")
--                .args(["--clipboard", "--input"])
--                .stdin(std::fs::File::open(path)?)
--                .status();
--
--            match result {
--                Ok(status) if status.success() => {
--                    tracing::debug!("Copied {} to clipboard via xsel", path.display());
--                    Ok(())
--                }
--                Ok(status) => {
--                    tracing::warn!("xsel exited with status: {}", status);
--                    anyhow::bail!("Failed to copy to clipboard")
--                }
--                Err(e) => {
--                    tracing::warn!("Neither xclip nor xsel available: {}", e);
--                    anyhow::bail!("No clipboard tool available (install xclip or xsel)")
--                }
--            }
--        }
--    }
+ }
  fn run_daemon() -> anyhow::Result<()> {