latchshot 0.1.0

A lightweight yet intelligent window-aware screenshot tool
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use std::path::PathBuf;

use anyhow::{Context, Result, bail};
use clap::{ArgGroup, Parser};
use latchshot::output::{Target, notify};
use latchshot::overlay::select;
use latchshot::{CaptureBackend, Compositor, Selection, SelectionResult};
use log::info;

#[derive(Parser)]
#[command(version, about)]
#[command(group(ArgGroup::new("destination").multiple(false)))]
#[allow(clippy::struct_excessive_bools)]
struct Args {
    /// Write the screenshot to PATH
    #[arg(short, long, value_name = "PATH", group = "destination")]
    output: Option<PathBuf>,

    /// Write PNG data to stdout
    #[arg(long, group = "destination")]
    stdout: bool,

    /// Copy the PNG to the Wayland clipboard (the default)
    #[arg(short, long, group = "destination")]
    clipboard: bool,

    /// Print the scene as JSON
    #[arg(long, conflicts_with_all = ["output", "stdout", "clipboard"])]
    windows: bool,

    /// Disable snap animation
    #[arg(long)]
    no_animation: bool,

    /// Compositor (auto-detected when omitted)
    #[arg(long)]
    compositor: Option<Compositor>,

    /// Capture backend (auto-detected when omitted)
    #[arg(long)]
    capture: Option<CaptureBackend>,
}

fn main() -> Result<()> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    let args = Args::parse();

    let compositor = args
        .compositor
        .or_else(Compositor::detect)
        .context("failed to detect a supported compositor; pass --compositor to override")?;
    info!("compositor: {compositor}");
    let scene = compositor.connect()?.scene()?;
    info!(
        "scene: {} outputs, {} windows",
        scene.outputs.len(),
        scene.windows.len()
    );

    if args.windows {
        println!("{}", serde_json::to_string_pretty(&scene).unwrap());

        return Ok(());
    }
    if scene.outputs.is_empty() {
        bail!("the compositor reported no active outputs");
    }

    let capture = args
        .capture
        .or_else(CaptureBackend::detect)
        .context("failed to detect a supported capture backend; pass --capture to override")?;
    info!("capture backend: {capture}");
    let frame = capture.connect()?.capture(&scene)?;
    let (result, frame) = select(scene, frame, !args.no_animation)?;
    let selection = match result {
        SelectionResult::Selected(selection) => selection,
        SelectionResult::Cancelled => return Ok(()),
    };
    let geometry = match selection {
        Selection::Window(geometry) | Selection::Region(geometry) => geometry,
    };

    let image = frame.crop(geometry);
    let (width, height) = image.dimensions();
    let target = if args.stdout {
        Target::Stdout
    } else if let Some(path) = args.output {
        Target::File(path)
    } else {
        Target::Clipboard
    };
    target.write(&image)?;

    match target {
        Target::File(path) => notify(&format!("Screenshot saved to {}", path.display())),
        Target::Clipboard => notify(&format!("Copied {width}×{height} screenshot to clipboard")),
        Target::Stdout => {}
    }

    Ok(())
}