latchshot 0.2.4

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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

//! PNG encoding and output destinations for captured images.
//!
//! [`Target`] can save an image, stream it to standard output, or hand it to
//! `wl-copy`. [`write_to_targets`] sends the same encoded PNG to any
//! combination of targets. Applications may also use the returned
//! `image::RgbaImage` directly instead.

use std::fs;
use std::io::{self, Write};
use std::path::PathBuf;
use std::process::{Command, Stdio};

use anyhow::{Context, Result, bail};
use image::codecs::png::{CompressionType, FilterType, PngEncoder};
use image::{ExtendedColorType, ImageEncoder, RgbaImage};
use log::warn;
use notify_rust::Notification;

/// Destination for an encoded PNG screenshot.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Target {
    File(PathBuf),
    Stdout,
    Clipboard,
}

impl Target {
    fn write_png(&self, png: &[u8]) -> Result<()> {
        match self {
            Self::File(path) => fs::write(path, png)
                .with_context(|| format!("failed to write screenshot to {}", path.display())),
            Self::Stdout => {
                let stdout = io::stdout();
                let mut stdout = stdout.lock();

                stdout.write_all(png)?;
                stdout.flush()?;

                Ok(())
            }
            Self::Clipboard => {
                let mut child = Command::new("wl-copy")
                    .args(["--type", "image/png"])
                    .stdin(Stdio::piped())
                    .spawn()
                    .context("failed to start wl-copy")?;

                child
                    .stdin
                    .take()
                    .unwrap()
                    .write_all(png)
                    .context("failed to send screenshot to wl-copy")?;

                let status = child.wait()?;
                if !status.success() {
                    bail!("wl-copy exited with {status}");
                }

                Ok(())
            }
        }
    }
}

/// Encodes an image once and writes the PNG to every target in order.
pub fn write_to_targets(image: &RgbaImage, targets: &[Target]) -> Result<()> {
    if targets.is_empty() {
        return Ok(());
    }

    let mut png = Vec::new();
    PngEncoder::new_with_quality(&mut png, CompressionType::Fast, FilterType::default())
        .write_image(
            image.as_raw(),
            image.width(),
            image.height(),
            ExtendedColorType::Rgba8,
        )
        .unwrap();

    for target in targets {
        target.write_png(&png)?;
    }

    Ok(())
}

/// Sends a desktop notification without propagating failures.
pub fn notify(body: &str) {
    if let Err(error) = Notification::new()
        .appname("latchshot")
        .summary("latchshot")
        .body(body)
        .show()
    {
        warn!("failed to send a notification: {error}");
    }
}

#[cfg(test)]
mod tests {
    use std::{fs, process};

    use image::Rgba;

    use super::*;

    fn sample_image() -> RgbaImage {
        RgbaImage::from_fn(2, 1, |x, _| match x {
            0 => Rgba([1, 2, 3, 255]),
            1 => Rgba([40, 50, 60, 128]),
            _ => unreachable!(),
        })
    }

    #[test]
    fn writes_to_the_exact_requested_path() {
        let path =
            std::env::temp_dir().join(format!("latchshot-output-test-{}.png", process::id()));
        write_to_targets(&sample_image(), &[Target::File(path.clone())]).unwrap();

        let decoded = image::open(&path).unwrap().into_rgba8();
        fs::remove_file(path).unwrap();

        assert_eq!(decoded, sample_image());
    }
}