ddctui 1.0.0

Terminal UI for controlling DDC/CI monitor properties
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

mod app;
mod cli;
mod config;
mod ddc;
mod ffi;
mod ui;

use anyhow::Result;
use app::{App, Focus, Mode};
use clap::Parser;
use cli::Cli;
use config::Favorites;
use crossterm::event::{self, Event, KeyCode, KeyEventKind};
use std::time::Duration;

fn main() -> Result<()> {
    let cli = Cli::parse();

    ddc::init()?;

    let config_dir = match &cli.config_dir {
        Some(dir) => dir.clone(),
        None => config::config_dir()?,
    };
    let favorites = Favorites::load(&config_dir)?;

    let monitors = ddc::detect_monitors()?;
    if monitors.is_empty() {
        println!("No DDC/CI capable monitors detected.");
        return Ok(());
    }

    let mut app = App::new(monitors, favorites)?;

    let mut terminal = ratatui::try_init()?;
    let result = run_event_loop(&mut terminal, &mut app);
    ratatui::try_restore()?;
    result
}

fn run_event_loop(terminal: &mut ratatui::DefaultTerminal, app: &mut App) -> Result<()> {
    while !app.should_quit {
        terminal.draw(|frame| ui::draw(frame, app))?;

        // While there are still feature values to fetch from the hardware, poll for input
        // instead of blocking on it, so the UI stays responsive and streams values in as they
        // arrive rather than freezing until every feature has been read.
        if app.has_pending_value_fetch() {
            if event::poll(Duration::from_millis(0))? {
                dispatch_event(app, event::read()?);
            } else {
                app.step_value_fetch();
            }
        } else {
            dispatch_event(app, event::read()?);
        }
    }
    Ok(())
}

fn dispatch_event(app: &mut App, event: Event) {
    let Event::Key(key) = event else {
        return;
    };
    if key.kind != KeyEventKind::Press {
        return;
    }
    match &app.mode {
        Mode::Normal => handle_normal_key(app, key.code),
        Mode::EditContinuous { .. } | Mode::EditChoice { .. } => handle_edit_key(app, key.code),
    }
}

fn handle_normal_key(app: &mut App, code: KeyCode) {
    app.status = None;
    match code {
        KeyCode::Char('q') | KeyCode::Esc => app.should_quit = true,
        KeyCode::Tab => app.toggle_focus(),
        KeyCode::Left => app.focus = Focus::Monitors,
        KeyCode::Right => app.focus = Focus::Capabilities,
        KeyCode::Char('j') | KeyCode::Down => match app.focus {
            Focus::Monitors => app.move_monitor(1),
            Focus::Capabilities => app.move_capability(1),
        },
        KeyCode::Char('k') | KeyCode::Up => match app.focus {
            Focus::Monitors => app.move_monitor(-1),
            Focus::Capabilities => app.move_capability(-1),
        },
        KeyCode::Char('f') => {
            if app.focus == Focus::Capabilities {
                app.toggle_favorite();
            }
        }
        KeyCode::Char('r') => app.refresh_current_values(),
        KeyCode::Enter => {
            if app.focus == Focus::Capabilities {
                app.start_edit();
            }
        }
        _ => {}
    }
}

fn handle_edit_key(app: &mut App, code: KeyCode) {
    match code {
        KeyCode::Esc => app.cancel_edit(),
        KeyCode::Enter => app.confirm_edit(),
        _ => {
            if let Some(delta) = edit_delta(&app.mode, code) {
                app.adjust_edit(delta);
            }
        }
    }
}

/// Continuous features use a horizontal slider (Left/Down decrease, Right/Up increase, matching
/// a volume-slider feel). Choice popups are a vertical list, so Up/Down must match this app's
/// other lists (Down moves to the next item, Up to the previous).
fn edit_delta(mode: &Mode, code: KeyCode) -> Option<i32> {
    match mode {
        Mode::EditContinuous { .. } => match code {
            KeyCode::Left | KeyCode::Char('h') | KeyCode::Down | KeyCode::Char('j') => Some(-1),
            KeyCode::Right | KeyCode::Char('l') | KeyCode::Up | KeyCode::Char('k') => Some(1),
            _ => None,
        },
        Mode::EditChoice { .. } => match code {
            KeyCode::Up | KeyCode::Char('k') | KeyCode::Left | KeyCode::Char('h') => Some(-1),
            KeyCode::Down | KeyCode::Char('j') | KeyCode::Right | KeyCode::Char('l') => Some(1),
            _ => None,
        },
        Mode::Normal => None,
    }
}