tuillem-tui 0.1.2

Ratatui TUI layer for tuillem
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

pub mod app;
pub mod commands;
pub mod control;
pub mod conversation;
pub mod help;
pub mod input;
pub mod settings;
pub mod sidebar;
pub mod theme;

use std::time::Duration;

use crossterm::{
    event::{self, DisableMouseCapture, EnableMouseCapture, Event as CrosstermEvent},
    execute,
    terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
};
use ratatui::{Terminal, backend::CrosstermBackend};
use tokio::sync::mpsc;
use tuillem_core::actions::Event;

use tracing::debug;

use crate::app::App;

pub async fn run(
    mut app: App,
    mut event_rx: mpsc::UnboundedReceiver<Event>,
    mouse_enabled: bool,
) -> anyhow::Result<()> {
    // Setup terminal
    enable_raw_mode()?;
    let mut stdout = std::io::stdout();
    if mouse_enabled {
        execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
    } else {
        execute!(stdout, EnterAlternateScreen)?;
    }
    let backend = CrosstermBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;

    // Main loop
    loop {
        // Force full redraw if needed (e.g. after external editor)
        if app.needs_redraw {
            terminal.clear()?;
            app.needs_redraw = false;
        }

        // Draw
        terminal.draw(|frame| {
            app.draw(frame);
        })?;

        // Process backend events (non-blocking)
        let mut event_count = 0;
        while let Ok(event) = event_rx.try_recv() {
            debug!("TUI received event: {:?}", event);
            app.apply_event(&event);
            event_count += 1;
        }
        if event_count > 0 {
            debug!("TUI processed {} events this frame", event_count);
        }

        // Poll terminal events with 16ms timeout (~60fps)
        if event::poll(Duration::from_millis(16))? {
            match event::read()? {
                CrosstermEvent::Key(key) => {
                    app.handle_key_event(key);
                }
                CrosstermEvent::Mouse(mouse) => {
                    app.handle_mouse_event(mouse);
                }
                _ => {}
            }
        }

        if app.should_quit {
            break;
        }
    }

    // Cleanup
    disable_raw_mode()?;
    if mouse_enabled {
        execute!(
            terminal.backend_mut(),
            DisableMouseCapture,
            LeaveAlternateScreen
        )?;
    } else {
        execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
    }
    terminal.show_cursor()?;

    Ok(())
}