istat 0.6.0

A lightweight and batteries-included status_command for i3 and sway
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

use std::time::Duration;

use async_trait::async_trait;
use clap::builder::StyledStr;
use futures::Future;
use serde_json::Value;
use sysinfo::{System, SystemExt};
use tokio::sync::mpsc::error::{SendError, TryRecvError};
use tokio::sync::{mpsc, oneshot};
use tokio::time::sleep;

use crate::config::AppConfig;
use crate::error::Result;
use crate::i3::bar_item::I3Item;
use crate::i3::I3ClickEvent;
use crate::util::RcCell;

#[derive(Debug)]
pub enum CustomResponse {
    Help(StyledStr),
    Json(Value),
}

#[derive(Debug)]
pub enum BarEvent {
    Click(I3ClickEvent),
    Signal,
    Custom {
        payload: Vec<String>,
        responder: oneshot::Sender<CustomResponse>,
    },
}

#[derive(Debug)]
pub struct SharedState {
    pub sys: System,
}

impl SharedState {
    pub fn new() -> RcCell<SharedState> {
        RcCell::new(SharedState {
            // this loads nothing, it's up to each item to load what it needs
            sys: System::new(),
        })
    }
}

#[derive(Debug)]
pub struct Context {
    pub config: RcCell<AppConfig>,
    pub state: RcCell<SharedState>,
    tx_item: mpsc::Sender<(I3Item, usize)>,
    rx_event: mpsc::Receiver<BarEvent>,
    index: usize,
}

impl Context {
    pub fn new(
        config: RcCell<AppConfig>,
        state: RcCell<SharedState>,
        tx_item: mpsc::Sender<(I3Item, usize)>,
        rx_event: mpsc::Receiver<BarEvent>,
        index: usize,
    ) -> Context {
        Context {
            config,
            state,
            tx_item,
            rx_event,
            index,
        }
    }

    pub async fn update_item(
        &self,
        item: I3Item,
    ) -> std::result::Result<(), SendError<(I3Item, usize)>> {
        self.tx_item.send((item, self.index)).await?;
        Ok(())
    }

    pub async fn wait_for_event(&mut self, delay: Option<Duration>) -> Option<BarEvent> {
        match delay {
            None => self.rx_event.recv().await,
            Some(delay) => tokio::select! {
                event = self.rx_event.recv() => event,
                _ = sleep(delay) => None
            },
        }
    }

    pub async fn delay_with_event_handler<F, R>(&mut self, duration: Duration, mut closure: F)
    where
        F: FnMut(BarEvent) -> R,
        R: Future<Output = ()>,
    {
        tokio::select! {
            Some(event) = self.rx_event.recv() => {
                closure(event).await;
                loop {
                    match self.rx_event.try_recv() {
                        Ok(event) => closure(event).await,
                        Err(TryRecvError::Empty) | Err(TryRecvError::Disconnected)=> break,
                    }
                }
            }
            _ = sleep(duration) => {}
        }
    }

    pub fn raw_event_rx(&mut self) -> &mut mpsc::Receiver<BarEvent> {
        &mut self.rx_event
    }
}

#[derive(Debug, Default, Copy, Clone)]
pub enum StopAction {
    /// The task finished, and the item will stay in the bar
    #[default]
    Complete,
    /// The task finished, and the item should be removed from the bar
    Remove,
    /// The task finished, and should be restarted
    Restart,
}

#[async_trait(?Send)]
pub trait BarItem: Send {
    async fn start(&self, ctx: Context) -> Result<StopAction>;
}