termit 0.7.0

Terminal UI over crossterm
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

pub mod tty;

use super::Control;
use crate::{
    input::{async_input, DefaultStdIn},
    prelude::Point,
    Terminal,
};
use log::{trace, warn};
use rustix::fd::AsFd;
use rustix::termios::Termios;
use std::{fs, io, sync::Arc};

pub type DefaultControl = NixTty;
pub type ControlOut = fs::File;
pub type ControlIn = fs::File;

pub(crate) fn terminal() -> io::Result<Terminal<DefaultControl, DefaultStdIn, io::Stdout>> {
    let control = get_tty()?;
    Ok(Terminal::new(control, async_input(), io::stdout()))
}

/// Try to get terminal tty from well known IO handles - stdin, stdout, /dev/tty
pub fn get_tty() -> io::Result<DefaultControl> {
    let input = None
        .or_else(|| tty::is_tty(io::stdin()))
        .and_then(|stdin| stdin.as_fd().try_clone_to_owned().ok())
        .map(fs::File::from)
        .or_else(|| tty::is_tty(tty::open_tty().ok()?))
        .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "no tty was found"))?;

    let output = None
        .or_else(|| tty::is_tty(io::stdout()))
        .and_then(|stdin| stdin.as_fd().try_clone_to_owned().ok())
        .map(fs::File::from)
        .or_else(|| tty::is_tty(tty::open_tty().ok()?))
        .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "no tty was found"))?;

    NixTty::try_from((input, output))
}

/// Wraps a control to reset raw mode on drop
pub struct NixTty {
    reset: Arc<Reset>,
}
impl TryFrom<(fs::File, fs::File)> for NixTty {
    type Error = io::Error;

    fn try_from(value: (fs::File, fs::File)) -> Result<Self, Self::Error> {
        let (input, output) = value;

        let state =
            tty::get_tty_attributes(&input).or_else(|_| tty::get_tty_attributes(&output))?;

        Ok(NixTty {
            reset: Arc::new(Reset {
                state,
                input,
                output,
            }),
        })
    }
}
impl Control for NixTty {
    /// Enables ANSI code support on *nix
    ///
    /// It uses `termios::tcsetattr`
    fn enable_raw_mode(&self) -> std::io::Result<()> {
        tty::enable_raw(&self.reset.input).or_else(|_| tty::enable_raw(&self.reset.output))
    }
    /// Get terminal window size from `termios::tcgetwinsize`
    fn get_size(&self) -> std::io::Result<Point> {
        tty::size_from_fd(&self.reset.output).or_else(|_| tty::size_from_fd(&self.reset.input))
    }
    /// Check if it's a TTY, with `is_terminal`
    fn is_tty(&self) -> bool {
        tty::is_tty(&self.reset.output).is_some() || tty::is_tty(&self.reset.input).is_some()
    }
    fn is_raw(&self) -> bool {
        tty::is_raw(&self.reset.output)
            .or_else(|_| tty::is_raw(&self.reset.input))
            .unwrap_or_default()
    }
    fn is_ansi(&self) -> bool {
        tty::is_raw(&self.reset.output)
            .or_else(|_| tty::is_raw(&self.reset.input))
            .unwrap_or_default()
    }
    fn output(&self) -> &ControlOut {
        &self.reset.output
    }
    fn input(&self) -> &ControlIn {
        &self.reset.input
    }
    fn clone(&self) -> Self {
        Self {
            reset: self.reset.clone(),
        }
    }
}

/// Shared reset object - last one switch the lights off, please
struct Reset {
    state: Termios,
    input: fs::File,
    output: fs::File,
}
impl Drop for Reset {
    fn drop(&mut self) {
        reset(&self.state, &self.input, &self.output)
    }
}
fn reset(tios: &Termios, i: &fs::File, o: &fs::File) {
    trace!("Resetting tty atts for {i:?} and {o:?}");
    tty::set_tty_attributes(i, tios).unwrap_or_else(|e| warn!("could not reset in attrs - {e}"));
    tty::set_tty_attributes(o, tios).unwrap_or_else(|e| warn!("could not reset out attrs - {e}"));
}