terminal-utils 0.1.0

A collection of utilities for working with the terminal.
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

use std::fmt::Debug;
use std::fs::File;
use std::os::fd::{AsRawFd, RawFd};
use std::{io, mem};

use crate::TerminalSize;

#[derive(Clone, Copy)]
pub struct TerminalState(libc::termios);

impl Debug for TerminalState {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_tuple("TerminalState")
            .field(&self.0.c_iflag)
            .field(&self.0.c_oflag)
            .field(&self.0.c_cflag)
            .field(&self.0.c_lflag)
            .field(&self.0.c_cc)
            .field(&self.0.c_ispeed)
            .field(&self.0.c_ospeed)
            .finish()
    }
}

pub fn size() -> Result<TerminalSize, io::Error> {
    let tty = get_tty()?;
    let fd = tty.as_raw_fd();

    let info = get_winsize(fd)?;

    Ok(TerminalSize {
        width: info.ws_col,
        height: info.ws_row,

        pixel_width: info.ws_xpixel,
        pixel_height: info.ws_ypixel,
    })
}

pub fn is_raw_mode_enabled() -> Result<bool, io::Error> {
    let tty = get_tty()?;
    let fd = tty.as_raw_fd();

    let termios = get_terminal_attr(fd)?;
    Ok((termios.c_lflag & libc::ICANON) == 0)
}

pub fn enable_raw_mode() -> Result<TerminalState, io::Error> {
    let tty = get_tty()?;
    let fd = tty.as_raw_fd();

    let mut termios = get_terminal_attr(fd)?;
    let original_termios = termios;

    unsafe { libc::cfmakeraw(&mut termios) };
    set_terminal_attr(fd, &termios)?;

    Ok(TerminalState(original_termios))
}

pub fn restore_mode(original_termios: TerminalState) -> Result<(), io::Error> {
    let tty = get_tty()?;
    let fd = tty.as_raw_fd();

    set_terminal_attr(fd, &original_termios.0)?;

    Ok(())
}

#[cfg(feature = "tokio")]
pub fn spawn_on_resize_task(
    tx: tokio::sync::watch::Sender<TerminalSize>,
) -> Result<tokio::task::JoinHandle<()>, io::Error> {
    let mut signal = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::window_change())?;

    let task = tokio::spawn(async move {
        loop {
            signal.recv().await;

            if let Ok(size) = size() {
                tx.send_replace(size);
            }
        }
    });
    Ok(task)
}

fn get_tty() -> Result<File, io::Error> {
    File::open("/dev/tty")
}

fn get_winsize(fd: RawFd) -> Result<libc::winsize, io::Error> {
    let mut info: libc::winsize = unsafe { mem::zeroed() };
    wrap_error(unsafe { libc::ioctl(fd, libc::TIOCGWINSZ, &mut info) })?;

    Ok(info)
}

fn get_terminal_attr(fd: RawFd) -> Result<libc::termios, io::Error> {
    let mut termios: libc::termios = unsafe { mem::zeroed() };
    wrap_error(unsafe { libc::tcgetattr(fd, &mut termios) })?;

    Ok(termios)
}

fn set_terminal_attr(fd: RawFd, termios: &libc::termios) -> Result<(), io::Error> {
    wrap_error(unsafe { libc::tcsetattr(fd, libc::TCSANOW, termios) })?;

    Ok(())
}

fn wrap_error(result: libc::c_int) -> io::Result<()> {
    if result == -1 {
        Err(io::Error::last_os_error())
    } else {
        Ok(())
    }
}