leenfetch 1.2.1

Fast, minimal, customizable system info tool in Rust (Neofetch alternative)
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
129
130
131
132

use std::{env, fs};

#[cfg(feature = "x11")]
mod x11 {
    use libc::{c_char, c_int, c_ulong};
    use std::ptr;

    #[repr(C)]
    struct XRRScreenConfiguration {
        _private: [u8; 0],
    }

    #[repr(C)]
    pub struct Display {
        _private: [u8; 0],
    }

    type Window = c_ulong;

    #[link(name = "X11")]
    #[link(name = "Xrandr")]
    unsafe extern "C" {
        fn XOpenDisplay(display_name: *const c_char) -> *mut Display;
        fn XCloseDisplay(display: *mut Display);
        fn XDefaultScreen(display: *mut Display) -> c_int;
        fn XDisplayWidth(display: *mut Display, screen_number: c_int) -> c_int;
        fn XDisplayHeight(display: *mut Display, screen_number: c_int) -> c_int;

        fn XRRGetScreenInfo(display: *mut Display, window: Window) -> *mut XRRScreenConfiguration;
        fn XRRFreeScreenConfigInfo(config: *mut XRRScreenConfiguration);
        fn XRRConfigCurrentRate(config: *mut XRRScreenConfiguration) -> i16;
        fn XRootWindow(display: *mut Display, screen_number: c_int) -> Window;
    }

    pub fn try_x11(refresh_rate: bool) -> Option<String> {
        unsafe {
            let display = XOpenDisplay(ptr::null());
            if display.is_null() {
                return None;
            }

            let screen = XDefaultScreen(display);
            let width = XDisplayWidth(display, screen);
            let height = XDisplayHeight(display, screen);
            let mut result = format!("{}x{}", width, height);

            if refresh_rate {
                let root = XRootWindow(display, screen);
                let config = XRRGetScreenInfo(display, root);
                if !config.is_null() {
                    let rate = XRRConfigCurrentRate(config);
                    result = format!("{} @ {}Hz", result, rate);
                    XRRFreeScreenConfigInfo(config);
                }
            }

            XCloseDisplay(display);
            Some(result)
        }
    }
}

#[cfg(not(feature = "x11"))]
mod x11 {
    pub fn try_x11(_refresh_rate: bool) -> Option<String> {
        None
    }
}

use x11::try_x11;

pub fn get_resolution(refresh_rate: bool) -> Option<String> {
    // X11 path
    if env::var("DISPLAY").is_ok() {
        if let Some(res) = try_x11(refresh_rate) {
            return Some(res);
        }
    }

    // DRM/KMS path
    if let Some(res) = try_drm(refresh_rate) {
        return Some(res);
    }

    // Framebuffer path
    if let Some(res) = try_fb() {
        return Some(res);
    }

    // Wayland path (unsupported without compositor protocol)
    if env::var("WAYLAND_DISPLAY").is_ok() {
        return Some("Wayland: resolution unavailable (restricted by compositor)".to_string());
    }

    None
}

fn try_drm(refresh_rate: bool) -> Option<String> {
    let entries = fs::read_dir("/sys/class/drm/").ok()?;

    for entry in entries.flatten() {
        let path = entry.path();
        if path.file_name()?.to_str()?.contains("card") && path.join("status").exists() {
            let status = fs::read_to_string(path.join("status")).ok()?;
            if status.trim() != "connected" {
                continue;
            }

            let mode_path = path.join("modes");
            if mode_path.exists() {
                let mode = fs::read_to_string(mode_path)
                    .ok()?
                    .lines()
                    .next()?
                    .to_string();
                return Some(if refresh_rate {
                    format!("{} @ 60Hz", mode) // Fallback rate assumption
                } else {
                    mode
                });
            }
        }
    }

    None
}

fn try_fb() -> Option<String> {
    let contents = fs::read_to_string("/sys/class/graphics/fb0/virtual_size").ok()?;
    let (w, h) = contents.trim().split_once(',')?;
    Some(format!("{}x{}", w.trim(), h.trim()))
}