soe 0.6.0

Scott's Own Editor — a built-in TUI text editor for CLI tools, no vim required
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

//! RAII terminal guard for crossterm + ratatui.

use std::io;
use std::sync::{Arc, Mutex};

use crossterm::event::{DisableFocusChange, DisableMouseCapture, EnableFocusChange, EnableMouseCapture};
use crossterm::terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode};
use ratatui::backend::CrosstermBackend;
use ratatui::Terminal;

type PanicHook = Box<dyn Fn(&std::panic::PanicHookInfo<'_>) + Send + Sync>;

/// RAII guard that ensures the terminal is restored to its original state,
/// even if an error occurs or a panic is caught.
#[must_use]
pub(crate) struct TerminalGuard {
    terminal: Terminal<CrosstermBackend<io::Stdout>>,
    mouse_captured: bool,
    original_hook: Arc<Mutex<Option<PanicHook>>>,
}

impl TerminalGuard {
    /// Enter raw mode, alternate screen, and optionally enable mouse capture.
    pub fn new(enable_mouse: bool) -> anyhow::Result<Self> {
        let original_hook: Arc<Mutex<Option<PanicHook>>> =
            Arc::new(Mutex::new(Some(std::panic::take_hook())));

        let hook_ref = Arc::clone(&original_hook);
        let mouse = enable_mouse;
        std::panic::set_hook(Box::new(move |panic_info| {
            let _ = disable_raw_mode();
            if mouse {
                let _ = crossterm::execute!(
                    io::stdout(),
                    DisableMouseCapture,
                    DisableFocusChange,
                    LeaveAlternateScreen
                );
            } else {
                let _ = crossterm::execute!(io::stdout(), DisableFocusChange, LeaveAlternateScreen);
            }
            if let Some(hook) = hook_ref.lock().ok().and_then(|mut h| h.take()) {
                hook(panic_info);
            }
        }));

        enable_raw_mode()?;
        let mut stdout = io::stdout();
        if enable_mouse {
            crossterm::execute!(
                stdout,
                EnterAlternateScreen,
                EnableMouseCapture,
                EnableFocusChange
            )?;
        } else {
            crossterm::execute!(stdout, EnterAlternateScreen, EnableFocusChange)?;
        }
        let backend = CrosstermBackend::new(stdout);
        let terminal = Terminal::new(backend)?;

        Ok(Self {
            terminal,
            mouse_captured: enable_mouse,
            original_hook,
        })
    }

    pub fn terminal_mut(&mut self) -> &mut Terminal<CrosstermBackend<io::Stdout>> {
        &mut self.terminal
    }
}

impl Drop for TerminalGuard {
    fn drop(&mut self) {
        let _ = disable_raw_mode();
        if self.mouse_captured {
            let _ = crossterm::execute!(
                self.terminal.backend_mut(),
                DisableMouseCapture,
                DisableFocusChange,
                LeaveAlternateScreen
            );
        } else {
            let _ = crossterm::execute!(
                self.terminal.backend_mut(),
                DisableFocusChange,
                LeaveAlternateScreen
            );
        }
        let _ = self.terminal.show_cursor();

        if let Some(hook) = self.original_hook.lock().ok().and_then(|mut h| h.take()) {
            std::panic::set_hook(hook);
        }
    }
}