tkbar 0.2.0

A minimalist, hardened status bar for Wayland.
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 {
    super::Ws,
    crate::ui::CONFIG,
    hyprland::{
        data::{Workspace, Workspaces},
        dispatch::{Dispatch, DispatchType, WorkspaceIdentifierWithSpecial},
        event_listener::EventListener,
        prelude::*,
    },
};

pub(super) fn event_loop(tx: &async_channel::Sender<Vec<Ws>>) -> Result<(), String> {
    ipc_loop(tx).map_err(|e| format!("{e:?}"))
}

fn ipc_loop(tx: &async_channel::Sender<Vec<Ws>>) -> hyprland::Result<()> {
    let mut listener = EventListener::new();

    let cli_tx = tx.clone();
    listener.add_workspace_changed_handler(move |_| snapshot(&cli_tx));

    let add_tx = tx.clone();
    listener.add_workspace_added_handler(move |_| snapshot(&add_tx));

    let destroy_tx = tx.clone();
    listener.add_workspace_deleted_handler(move |_| snapshot(&destroy_tx));

    let monitor_tx = tx.clone();
    listener.add_active_monitor_changed_handler(move |_| snapshot(&monitor_tx));

    let open_tx = tx.clone();
    listener.add_window_opened_handler(move |_| snapshot(&open_tx));

    let close_tx = tx.clone();
    listener.add_window_closed_handler(move |_| snapshot(&close_tx));

    snapshot(tx);

    listener.start_listener()
}

fn snapshot(tx: &async_channel::Sender<Vec<Ws>>) {
    let list = match read_workspaces() {
        Ok(list) => list,
        Err(e) => {
            crate::log::warn("workspaces", &format!("hyprland IPC error: {e:?}"));
            return;
        },
    };
    let _ = tx.send_blocking(list);
}

fn read_workspaces() -> hyprland::Result<Vec<Ws>> {
    let focused_id = Workspace::get_active()?.id;

    let mut list: Vec<Ws> = Workspaces::get()?
        .to_vec()
        .into_iter()
        .filter_map(|wks| {
            if wks.id <= 0 {
                return None;
            }
            Some(Ws {
                id: u64::try_from(wks.id).ok()?,
                idx: u8::try_from(wks.id).ok()?,
                label: if CONFIG.security.should_allow_workspace_label {
                    wks.name
                } else {
                    wks.id.to_string()
                },
                is_active: wks.windows > 0,
                is_focused: wks.id == focused_id,
            })
        })
        .collect();

    for idx in 1..=CONFIG.behaviour.workspace_count {
        if list.iter().all(|wks| wks.id != u64::from(idx)) {
            list.push(Ws {
                id: u64::from(idx),
                idx,
                label: idx.to_string(),
                is_active: false,
                is_focused: idx == u8::try_from(focused_id).unwrap_or_default(),
            });
        }
    }


    list.sort_by_key(|wks| wks.id);
    Ok(list)
}

pub(super) fn focus_workspace(id: u64) {
    let Ok(id) = i32::try_from(id) else {
        return;
    };
    if let Err(e) = Dispatch::call(DispatchType::Workspace(WorkspaceIdentifierWithSpecial::Id(
        id,
    ))) {
        crate::log::warn("workspaces", &format!("failed to focus workspace: {e:?}"));
    }
}