pyroclear 0.2.0

Watch your terminal go up in flames! A fire animation for clearing your terminal.
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

// win.rs — hand-rolled Win32 console bindings (Windows only, zero deps).
// The few pieces of the Windows console pyroclear needs: raw mode,
// terminal size, and Ctrl+C. Everything else is plain ANSI output, which
// works because virtual-terminal (VT) processing is enabled here.

#![allow(non_snake_case)]

use std::ffi::c_void;
use std::io;

const STD_INPUT_HANDLE: u32 = (-10i32) as u32;
const STD_OUTPUT_HANDLE: u32 = (-11i32) as u32;

const ENABLE_PROCESSED_INPUT: u32 = 0x0001;
const ENABLE_LINE_INPUT: u32 = 0x0002;
const ENABLE_ECHO_INPUT: u32 = 0x0004;
const ENABLE_VIRTUAL_TERMINAL_INPUT: u32 = 0x0200;
const ENABLE_VIRTUAL_TERMINAL_PROCESSING: u32 = 0x0004;

#[repr(C)]
struct Coord {
    x: i16,
    y: i16,
}

#[repr(C)]
struct SmallRect {
    left: i16,
    top: i16,
    right: i16,
    bottom: i16,
}

#[repr(C)]
struct ConsoleScreenBufferInfo {
    dw_size: Coord,
    dw_cursor_position: Coord,
    w_attributes: u16,
    sr_window: SmallRect,
    dw_maximum_window_size: Coord,
}

extern "system" {
    fn GetStdHandle(n_std_handle: u32) -> *mut c_void;
    fn GetConsoleMode(h_console: *mut c_void, lp_mode: *mut u32) -> i32;
    fn SetConsoleMode(h_console: *mut c_void, dw_mode: u32) -> i32;
    fn GetConsoleScreenBufferInfo(
        h_console: *mut c_void,
        lp_info: *mut ConsoleScreenBufferInfo,
    ) -> i32;
    pub fn SetConsoleCtrlHandler(handler: unsafe extern "system" fn(u32) -> i32, add: i32) -> i32;
}

// ── Raw mode ──────────────────────────────────────────────────────────

pub struct RawConsole {
    in_mode: u32,
    out_mode: u32,
    out_saved: bool,
}

pub fn enter_raw() -> io::Result<RawConsole> {
    unsafe {
        let hin = GetStdHandle(STD_INPUT_HANDLE);
        let hout = GetStdHandle(STD_OUTPUT_HANDLE);

        let mut in_mode = 0u32;
        if GetConsoleMode(hin, &mut in_mode) == 0 {
            return Err(io::Error::last_os_error());
        }
        let raw = in_mode & !(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT | ENABLE_PROCESSED_INPUT)
            | ENABLE_VIRTUAL_TERMINAL_INPUT;
        if SetConsoleMode(hin, raw) == 0 {
            return Err(io::Error::last_os_error());
        }

        // Let conhost interpret ANSI escapes; Windows Terminal does anyway.
        let mut out_mode = 0u32;
        let out_saved = GetConsoleMode(hout, &mut out_mode) != 0;
        if out_saved {
            SetConsoleMode(hout, out_mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING);
        }

        Ok(RawConsole {
            in_mode,
            out_mode,
            out_saved,
        })
    }
}

pub fn leave_raw(saved: &RawConsole) {
    unsafe {
        SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), saved.in_mode);
        if saved.out_saved {
            SetConsoleMode(GetStdHandle(STD_OUTPUT_HANDLE), saved.out_mode);
        }
    }
}

// ── Terminal size ─────────────────────────────────────────────────────

pub fn terminal_size() -> Option<(usize, usize)> {
    unsafe {
        let h = GetStdHandle(STD_OUTPUT_HANDLE);
        let mut info: ConsoleScreenBufferInfo = std::mem::zeroed();
        if GetConsoleScreenBufferInfo(h, &mut info) == 0 {
            return None;
        }
        let w = info.sr_window.right - info.sr_window.left + 1;
        let h_ = info.sr_window.bottom - info.sr_window.top + 1;
        if w > 0 && h_ > 0 {
            Some((w as usize, h_ as usize))
        } else {
            None
        }
    }
}