satty 0.22.0

Modern Screenshot Annotation.
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

use relm4::gtk::gio::{FileIcon, Icon};
use relm4::gtk::gio::{Notification, prelude::ApplicationExt};

use crate::TEMP_DIR;
use crate::configuration::APP_CONFIG;
use relm4::gtk::gdk_pixbuf::{InterpType, Pixbuf};
use relm4::gtk::prelude::Cast;
use relm4::gtk::{IconLookupFlags, IconTheme, TextDirection, gio};
use satty_cli::command_line::NotificationThumbnail;
use tempfile::NamedTempFile;

pub fn log_result(msg: &str, notify: bool) {
    eprintln!("{msg}");
    if notify && !APP_CONFIG.read().disable_notifications() {
        show_notification(msg, None);
    }
}

pub fn log_result_with_pixbuf(msg: &str, pixbuf: Pixbuf) {
    eprintln!("{msg}");

    if APP_CONFIG.read().disable_notifications() {
        return;
    }

    let notification_icon_kind = APP_CONFIG.read().notification_thumbnail();

    let pixbuf = match notification_icon_kind {
        NotificationThumbnail::AppIcon => None,
        _ => {
            let src_w = pixbuf.width();
            let src_h = pixbuf.height();

            if src_w == 0 || src_h == 0 {
                None
            } else {
                let scale = f64::min(96.0 / src_w as f64, 96.0 / src_h as f64);

                let new_w = ((src_w as f64) * scale).round().max(1.0) as i32;
                let new_h = ((src_h as f64) * scale).round().max(1.0) as i32;

                pixbuf.scale_simple(new_w, new_h, InterpType::Bilinear)
            }
        }
    };

    // we can't just use a tempfile here because we need the path for the FileIcon.
    // Also, we can't just use NamedTempFile with cleanup, because it gets dropped
    // at the end of this function, which can be too early for the notification daemon.
    let tempfile: Option<NamedTempFile> = match TEMP_DIR.read() {
        Ok(guard) => match &*guard {
            Some(d) if pixbuf.is_some() => {
                if let Ok(tf) = tempfile::Builder::new()
                    .disable_cleanup(true)
                    .suffix(".png")
                    .tempfile_in(d.path())
                {
                    Some(tf)
                } else {
                    eprintln!("Could not create temporary file");
                    None
                }
            }
            _ => None,
        },
        Err(e) => {
            eprintln!("Error acquiring read guard for temp directory: {}", e);
            None
        }
    };

    let icon = match tempfile.as_ref() {
        Some(f) => {
            // this unwrap is safe because tempfile would not be Some otherwise, see above
            if pixbuf.unwrap().savev(f, "png", &[]).is_ok() {
                let file = gio::File::for_path(f);
                Some(FileIcon::new(&file).upcast::<Icon>())
            } else {
                None
            }
        }
        _ => None,
    };

    show_notification(msg, icon);
}

fn show_notification(msg: &str, icon: Option<Icon>) {
    // construct
    let notification = Notification::new("Satty");
    notification.set_body(Some(msg));

    if let Some(i) = icon {
        notification.set_icon(&i);
    } else {
        // lookup sattys icon
        let theme = IconTheme::default();
        if theme.has_icon("satty")
            && let Some(icon_file) = theme
                .lookup_icon(
                    "satty",
                    &[],
                    96,
                    1,
                    TextDirection::Ltr,
                    IconLookupFlags::empty(),
                )
                .file()
        {
            notification.set_icon(&FileIcon::new(&icon_file));
        }
    }

    // send notification
    relm4::main_application().send_notification(None, &notification);
}