hal-9001 0.2.0

HAL-9001 โ€” Central TUI de Controle do Sistema & Assistente de Sistema (Rust/ratatui)
Documentation
pub mod theme;
pub mod widgets;

pub mod audio;
pub mod bluetooth;
pub mod config_modal;
pub mod display;
pub mod file_picker;
pub mod network;
pub mod overview;
pub mod power;
pub mod splash;
pub mod storage;
pub mod updates;

use ratatui::layout::{Alignment, Constraint, Layout, Rect};
use ratatui::style::{Modifier, Style};
use ratatui::text::{Line, Span};
use ratatui::widgets::{Block, Borders, Clear, Paragraph, Tabs};
use ratatui::Frame;

use crate::app::{App, Phase, Tab};
use crate::events::ToastLevel;
use theme::Palette;

pub fn draw(app: &App, f: &mut Frame) {
    let pal = Palette::from_config(&app.config);

    if app.phase == Phase::Splash {
        splash::draw(app, &pal, f, f.area());
        return;
    }

    let chunks = Layout::vertical([
        Constraint::Length(3),
        Constraint::Min(0),
        Constraint::Length(1),
    ])
    .split(f.area());

    draw_tabbar(app, &pal, f, chunks[0]);
    draw_content(app, &pal, f, chunks[1]);
    draw_statusline(app, &pal, f, chunks[2]);

    if app.active == Tab::Storage && app.storage_modal_open() {
        storage::draw_modal(app, &pal, f);
    }
    if app.show_help {
        draw_help(app, &pal, f);
    }
    if app.show_config {
        config_modal::draw(app, &pal, f);
    }

    if let Some(sudo_prompt) = &app.sudo_prompt {
        storage::draw_sudo_prompt(app, &pal, f, sudo_prompt);
    }
}

fn tab_short_label(t: &Tab, m: &'static crate::i18n::Messages) -> &'static str {
    match t {
        Tab::Overview => m.tabbar_short_overview,
        Tab::Network => m.tabbar_short_network,
        Tab::Bluetooth => m.tabbar_short_bluetooth,
        Tab::Storage => m.tabbar_short_storage,
        Tab::Audio => m.tabbar_short_audio,
        Tab::Displays => m.tabbar_short_displays,
    }
}

fn draw_tabbar(app: &App, pal: &Palette, f: &mut Frame, area: Rect) {
    let width = area.width;
    let m = app.lang.messages();

    let titles: Vec<Line> = Tab::ALL
        .iter()
        .enumerate()
        .map(|(i, t)| {
            let label = if width >= 75 {
                format!("{} {}", i + 1, t.title_in(app.lang))
            } else if width >= 58 {
                format!("{} {}", i + 1, tab_short_label(t, m))
            } else if app.active == *t {
                format!("{}:{}", i + 1, tab_short_label(t, m))
            } else {
                format!("{}", i + 1)
            };
            Line::from(Span::raw(label))
        })
        .collect();

    let title = if width < 50 {
        " HAL-9001 ".to_string()
    } else {
        match &app.system {
            Some(s) => {
                let plat = match &s.detail.cpu_arch {
                    Some(arch) => format!("{} {arch}", s.os),
                    None => s.os.clone(),
                };
                format!(" HAL-9001 ({plat}) ")
            }
            None => " HAL-9001 ".to_string(),
        }
    };

    let tabs = Tabs::new(titles)
        .select(app.active.index())
        .block(
            Block::default()
                .borders(Borders::ALL)
                .border_style(Style::default().fg(pal.dim))
                .title(Span::styled(
                    title,
                    Style::default().fg(pal.accent).add_modifier(Modifier::BOLD),
                )),
        )
        .style(Style::default().fg(pal.fg))
        .highlight_style(
            Style::default()
                .fg(pal.accent)
                .add_modifier(Modifier::BOLD | Modifier::REVERSED),
        )
        .divider(Span::styled("โ”‚", Style::default().fg(pal.dim)));

    f.render_widget(tabs, area);
}

fn draw_content(app: &App, pal: &Palette, f: &mut Frame, area: Rect) {
    match app.active {
        Tab::Overview => overview::draw(app, pal, f, area),
        Tab::Network => network::draw(app, pal, f, area),
        Tab::Bluetooth => bluetooth::draw(app, pal, f, area),
        Tab::Storage => storage::draw(app, pal, f, area),
        Tab::Audio => audio::draw(app, pal, f, area),
        Tab::Displays => display::draw(app, pal, f, area),
    }
}

fn draw_statusline(app: &App, pal: &Palette, f: &mut Frame, area: Rect) {
    if let Some((toast, _)) = &app.toast {
        let color = match toast.level {
            ToastLevel::Info => pal.accent,
            ToastLevel::Success => pal.ok,
            ToastLevel::Warning => pal.warn,
            ToastLevel::Error => pal.err,
        };
        let line = Line::from(vec![
            Span::styled(" โ–Ž", Style::default().fg(color)),
            Span::styled(toast.text.clone(), Style::default().fg(color)),
        ]);
        f.render_widget(Paragraph::new(line), area);
        return;
    }

    let m = app.lang.messages();
    let hints = if area.width < 50 {
        m.statusline_hints_narrow
    } else if area.width < 68 {
        m.statusline_hints_medium
    } else {
        m.statusline_hints_wide
    };
    let line = Line::from(Span::styled(hints, Style::default().fg(pal.dim)));
    f.render_widget(Paragraph::new(line), area);
}

fn draw_help(app: &App, pal: &Palette, f: &mut Frame) {
    let area = centered(60, 40, f.area());
    f.render_widget(Clear, area);

    let m = app.lang.messages();
    let text = vec![
        Line::from(Span::styled(
            m.help_title,
            Style::default().fg(pal.accent).add_modifier(Modifier::BOLD),
        )),
        Line::from(""),
        Line::from(m.help_line_tabs),
        Line::from(m.help_line_nav),
        Line::from(m.help_line_enter),
        Line::from(m.help_line_refresh),
        Line::from(m.help_line_detail),
        Line::from(m.help_line_config),
        Line::from(m.help_line_help),
        Line::from(m.help_line_quit),
        Line::from(""),
        Line::from(Span::styled(
            format!(
                "{} {}",
                m.help_active_tab_prefix,
                app.active.title_in(app.lang)
            ),
            Style::default().fg(pal.dim),
        )),
    ];

    let block = Block::default()
        .borders(Borders::ALL)
        .border_style(Style::default().fg(pal.accent))
        .title(" ? ");
    f.render_widget(
        Paragraph::new(text).block(block).alignment(Alignment::Left),
        area,
    );
}

fn centered(pw: u16, ph: u16, area: Rect) -> Rect {
    let v = Layout::vertical([
        Constraint::Percentage((100 - ph) / 2),
        Constraint::Percentage(ph),
        Constraint::Percentage((100 - ph) / 2),
    ])
    .split(area);
    Layout::horizontal([
        Constraint::Percentage((100 - pw) / 2),
        Constraint::Percentage(pw),
        Constraint::Percentage((100 - pw) / 2),
    ])
    .split(v[1])[1]
}

pub(crate) fn draw_pending(
    app: &App,
    pal: &Palette,
    f: &mut Frame,
    area: Rect,
    title: &str,
    service_key: &'static str,
    actions: &[&str],
) {
    let block = content_block(title, pal);
    let inner = block.inner(area);
    f.render_widget(block, area);

    let m = app.lang.messages();
    let mut lines: Vec<Line> = Vec::new();
    match app
        .services
        .get(service_key)
        .and_then(|s| s.degraded.clone())
    {
        Some(reason) => lines.push(Line::from(vec![
            Span::styled("โ— ", Style::default().fg(pal.warn)),
            Span::styled(reason, Style::default().fg(pal.warn)),
        ])),
        None => lines.push(Line::from(Span::styled(
            m.pending_initializing,
            Style::default().fg(pal.dim),
        ))),
    }
    lines.push(Line::from(""));
    lines.push(Line::from(Span::styled(
        m.pending_actions_label,
        Style::default().fg(pal.accent).add_modifier(Modifier::BOLD),
    )));
    for a in actions {
        lines.push(Line::from(vec![
            Span::styled("  ยท ", Style::default().fg(pal.dim)),
            Span::styled((*a).to_string(), Style::default().fg(pal.fg)),
        ]));
    }

    f.render_widget(Paragraph::new(lines), inner);
}

pub(crate) fn content_block(title: &str, pal: &Palette) -> Block<'static> {
    Block::default()
        .borders(Borders::ALL)
        .border_style(Style::default().fg(pal.dim))
        .title(Span::styled(
            format!(" {title} "),
            Style::default().fg(pal.accent).add_modifier(Modifier::BOLD),
        ))
}