ratada 0.5.0

A ratatui widget toolkit: driver, modals, forms, pickers, theming
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
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
134
135
136
137
138
139
140
141

//! Key dispatch for the colour picker: moving focus, editing a channel or the
//! hex field, and picking a preset.

use crossterm::event::{KeyCode, KeyModifiers};

use super::{Focus, Outcome, State};
use crate::{clipboard, input, nav, overlay::PopupFlow, theme::parse_color};

/// Routes a key press to the focused control.
pub(super) fn handle(
    state: &mut State,
    key: crossterm::event::KeyEvent,
) -> PopupFlow<Outcome> {
    match key.code {
        KeyCode::Enter => {
            return PopupFlow::Done(Outcome::Done(state.current_color()));
        }
        KeyCode::Esc => {
            return PopupFlow::Done(Outcome::Back(state.current_color()));
        }
        KeyCode::Tab | KeyCode::Down => {
            state.cycle_focus(1);
            return PopupFlow::Continue;
        }
        KeyCode::BackTab | KeyCode::Up => {
            state.cycle_focus(-1);
            return PopupFlow::Continue;
        }
        _ => {}
    }
    match state.focus {
        Focus::Hex => handle_hex(state, key),
        Focus::Channel(index) => handle_channel(state, index, key),
        Focus::Presets => handle_presets(state, key),
    }
}

/// Edits the hex field; a valid entry updates the channels live.
fn handle_hex(
    state: &mut State,
    key: crossterm::event::KeyEvent,
) -> PopupFlow<Outcome> {
    if state.hex.handle_key(key)
        && let Some(color) = parse_color(state.hex.value())
    {
        state.adopt(color);
    }
    PopupFlow::Continue
}

/// Routes a paste to the hex field, but only while it is focused; a valid entry
/// updates the channels live, like [`handle_hex`].
pub(super) fn handle_paste(
    state: &mut State,
    text: &str,
) -> PopupFlow<Outcome> {
    if state.focus == Focus::Hex {
        state.hex.paste(text);
        if let Some(color) = parse_color(state.hex.value()) {
            state.adopt(color);
        }
    }
    PopupFlow::Continue
}

/// Adjusts the focused channel, or handles the model/copy chords.
fn handle_channel(
    state: &mut State,
    index: usize,
    key: crossterm::event::KeyEvent,
) -> PopupFlow<Outcome> {
    // This control binds no Ctrl chord of its own, so one must not reach the
    // bare keys below (Ctrl+Y would copy, Ctrl+S leave for the swatches).
    // `Shift` stays honoured: it only picks the fine step.
    if input::is_command(key) {
        return PopupFlow::Continue;
    }
    let channel = state.model.channels()[index];
    let step = if key.modifiers.contains(KeyModifiers::SHIFT) {
        1.0
    } else {
        channel.coarse
    };
    match key.code {
        KeyCode::Left | KeyCode::Char('h') => state.adjust(index, -step),
        KeyCode::Right | KeyCode::Char('l') => state.adjust(index, step),
        KeyCode::Home => state.set(index, channel.min),
        KeyCode::End => state.set(index, channel.max),
        KeyCode::PageUp => state.adjust(index, -channel.page()),
        KeyCode::PageDown => state.adjust(index, channel.page()),
        KeyCode::Char('m') => state.set_model(state.model.next()),
        KeyCode::Char('y') => copy_hex(state),
        KeyCode::Char('s') => {
            return PopupFlow::Done(Outcome::Swatches(state.current_color()));
        }
        _ => {}
    }
    PopupFlow::Continue
}

/// Picks a preset (live) or handles the model/copy chords.
fn handle_presets(
    state: &mut State,
    key: crossterm::event::KeyEvent,
) -> PopupFlow<Outcome> {
    // This control binds no Ctrl chord of its own, so one must not reach the
    // bare keys below (Ctrl+Y would copy, Ctrl+S leave for the swatches).
    if input::is_command(key) {
        return PopupFlow::Continue;
    }
    let count = state.presets.len();
    match key.code {
        KeyCode::Left | KeyCode::Char('h') => {
            select_preset(state, nav::cycle(state.preset, count, -1));
        }
        KeyCode::Right | KeyCode::Char('l') => {
            select_preset(state, nav::cycle(state.preset, count, 1));
        }
        KeyCode::Home => select_preset(state, 0),
        KeyCode::End => select_preset(state, count.saturating_sub(1)),
        KeyCode::Char('m') => state.set_model(state.model.next()),
        KeyCode::Char('y') => copy_hex(state),
        KeyCode::Char('s') => {
            return PopupFlow::Done(Outcome::Swatches(state.current_color()));
        }
        _ => {}
    }
    PopupFlow::Continue
}

/// Adopts the preset at `index` as the live color and refreshes the hex field.
fn select_preset(state: &mut State, index: usize) {
    state.preset = index;
    state.adopt(state.presets[index]);
    state.sync_hex();
}

/// Copies the current color's hex code to the clipboard (best effort).
fn copy_hex(state: &State) {
    let _ = clipboard::copy(&state.current_color().to_hex());
}