onionshot 0.3.1

Screenshot utility for Hyprland
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

use super::common::Geometry;
use std::process::{Command, Stdio};

pub fn get_active_window() -> Geometry {
    let output = Command::new("hyprctl")
        .arg("-j")
        .arg("activewindow")
        .stdout(Stdio::piped())
        .output()
        .expect("Failed to spawn hyprctl");
    if !output.status.success() {
        panic!("Failed to execute hyprctl");
    }
    let Ok(data) = str::from_utf8(&output.stdout) else {
        panic!("non-utf8 fuck off");
    };

    let obj = json::parse(data).expect("hyprctl -j not returning json");
    if !obj.is_object() {
        panic!(
            "failed to parse hyprctl's active window output: not an object at top level"
        );
    }
    if !obj.has_key("at") {
        panic!(
            "failed to parse hyprctl's active window output: property `at' not found"
        );
    }
    if !obj.has_key("size") {
        panic!(
            "failed to parse hyprctl's active window output: property `size' not found"
        );
    }

    let at = &obj["at"];
    let size = &obj["size"];

    if !(at.is_array()
        && at.len() == 2
        && at.members().fold(true, |m, x| m && x.is_number()))
    {
        panic!(
            "failed to parse hyprctl's active window output: property `at' isn't an array of two numbers"
        );
    }
    if !(size.is_array()
        && size.len() == 2
        && size.members().fold(true, |m, x| m && x.is_number()))
    {
        panic!(
            "failed to parse hyprctl's active window output: property `size' isn't an array of two numbers"
        );
    }
    Geometry {
        x: at[0].as_i32().unwrap(),
        y: at[1].as_i32().unwrap(),
        w: size[0].as_u32().unwrap(),
        h: size[1].as_u32().unwrap(),
    }
}

pub fn get_active_screen() -> Geometry {
    // Get active output
    let output = Command::new("hyprctl")
        .arg("-j")
        .arg("activeworkspace")
        .stdout(Stdio::piped())
        .output()
        .expect("Failed to spawn hyprctl");
    if !output.status.success() {
        panic!("Failed to execute hyprctl");
    }
    let Ok(data) = str::from_utf8(&output.stdout) else {
        panic!("non-utf8 fuck off");
    };

    let workspace_obj =
        json::parse(data).expect("hyprctl -j not returning json");
    let monitor_id = workspace_obj["monitorID"]
        .as_usize()
        .expect("failed to parse hyprctl's active workspace output");

    // Get active output's bound
    let output = Command::new("hyprctl")
        .arg("-j")
        .arg("monitors")
        .stdout(Stdio::piped())
        .output()
        .expect("Failed to spawn hyprctl");
    if !output.status.success() {
        panic!("Failed to execute hyprctl");
    }
    let Ok(data) = str::from_utf8(&output.stdout) else {
        panic!("non-utf8 fuck off");
    };

    let monitor =
        &json::parse(data).expect("hyprctl -j not returning json")[monitor_id];

    let msg = "failed to parse hyprctl's monitor output";

    let scale = monitor["scale"].as_f32().expect(msg);
    let x = monitor["x"].as_i32().expect(msg);
    let y = monitor["y"].as_i32().expect(msg);
    let w = monitor["width"].as_f32().expect(msg) / scale;
    let h = monitor["height"].as_f32().expect(msg) / scale;

    Geometry {
        x,
        y,
        w: w as u32,
        h: h as u32,
    }
}