rterm 0.0.2

A port of suckless terminal to rust.
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

use nix::sys::signal::{
    signal,
    Signal,
    SigHandler
};
use nix::sys::select::{
    select,
    FdSet,
};
use nix::errno::Errno;
use nix;
use std::sync::atomic::{
    AtomicBool,
    Ordering
};
use crate::term::Term;
use crate::win::Win;
use crate::vte::Vte;
use crate::Result;

static RUNNING: AtomicBool = AtomicBool::new(true);

fn is_running() -> bool {
    RUNNING.load(Ordering::Relaxed)
}

pub fn app_exit() {
    RUNNING.store(false, Ordering::Relaxed);
}

fn set_sigchld() {
    extern fn handle_sigchld(_signal: i32) {
        app_exit();
    }
    let handler = SigHandler::Handler(handle_sigchld);
    unsafe { signal(Signal::SIGCHLD, handler).unwrap(); }
}

// Data flow:
//
//   read pty fd --> vte parse --+--> write to pty fd
//                               |
//                               +--> update term
//                               |
//        win input -------------+--> update win

pub struct App {
    term: Term,
    win: Win,
    vte: Vte,
}

impl App {
    pub fn new(cols: usize, rows: usize, font: Option<&str>) -> Result<Self> {
        set_sigchld();

        let term = Term::new(cols, rows)?;
        Ok(App {
            win: Win::new(term.cols, term.rows, font)?,
            term: term,
            vte: Vte::new(),
         })
    }

    pub fn run(&mut self) -> Result<()> {
        let win_fd = self.win.fd();
        let pty_fd = self.term.pty.fd();
        let mut buf = [0; 8192];

        while is_running() {
            let mut rfds = FdSet::new();
            rfds.insert(pty_fd);
            rfds.insert(win_fd);

            let mut wfds = FdSet::new();
            if self.term.pty.need_flush() {
                wfds.insert(pty_fd);
            }

            match select(None, Some(&mut rfds), Some(&mut wfds), None, None) {
                Ok(_) => (),
                Err(nix::Error::Sys(Errno::EINTR)) => continue,
                Err(err) => return Err(err.into()),
            }

            if wfds.contains(pty_fd) {
                self.term.pty.flush()?;
            }

            self.win.undraw_cursor(&self.term);

            if rfds.contains(win_fd) {
                self.win.process_input(&mut self.term);
            }
            if rfds.contains(pty_fd) {
                let n = self.term.pty.read(&mut buf)?;
                self.vte.process_input(
                    &buf[..n], &mut self.win, &mut self.term
                );
            }

            self.win.draw(&mut self.term);
        }

        Ok(())
    }
}