`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));
 -            capture_screen(&output, &format, monitor.as_deref(), cursor)?;
 -            if !no_clipboard {
 -                copy_to_clipboard(&output)?;
 +            if let Some(secs) = delay {
 +                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(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));
 -            capture_region_cmd(&output, &format, &geometry, cursor)?;
 -            if !no_clipboard {
 -                copy_to_clipboard(&output)?;
 +            if let Some(secs) = delay {
 +                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(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));
 -            capture_window_cmd(&output, &format, id.as_deref(), decorations, cursor)?;
 -            if !no_clipboard {
 -                copy_to_clipboard(&output)?;
 +            if let Some(secs) = delay {
 +                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(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));
 -            capture_select_cmd(&output, &format, cursor, blur)?;
 -            if !no_clipboard {
 -                copy_to_clipboard(&output)?;
 +            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)))
 +            };
 +            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(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,
 -        output.display()
 +        region.y
      );
      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(
 -    output: &PathBuf,
 -    format: &str,
 +fn capture_window_raw(
      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)
 -}
+-
 -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(())
 +    Ok((result.data, result.width, result.height))
+ }
 -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(
 -    output: &PathBuf,
 -    format: &str,
 +fn capture_select_raw(
      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)
 -}
+-
 -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)")
 -                }
 -            }
 -        }
 -    }
 +    Ok(Some((result.data, result.width, result.height)))
+ }
  fn run_daemon() -> anyhow::Result<()> {