lernie 0.1.110

lernie: the operator seat — the window and wire client for a yog server
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230

//! The anatomy on the glass: a row's words, ink, rule and tint; a block's
//! rule; a section's word; a field's ring and glow.

use super::{elbow, empty, prose, rail, row, ruled, section};
use crate::paint_probe::frame::Window;
use crate::test_support::window::{click, seen};
use crate::ui::theme::{BRAND, INK, INK_WEAK, RAISED, RULE, State, accent, type_scale};

/// The two fields that take text, split at the cap.
mod field;
/// The hover wash, and the mark inside a link.
mod hover;
/// The slider's trough and its ring.
mod knob;

/// Every fill that reached the glass, widest first.
fn fills(window: &Window, body: impl FnMut(&egui::Context)) -> Vec<(egui::Rect, egui::Color32)> {
    crate::paint_probe::fills_of(&window.frame(Vec::new(), body))
}

/// **A row's words reach the glass in the ink it was given, elided at its
/// width**, and its state stands as a rule at its left edge.
#[test]
fn a_row_paints_its_words_in_its_ink_and_its_state_as_a_rule() {
    let window = Window::sized(200.0, 100.0);
    let body = |ctx: &egui::Context| {
        egui::CentralPanel::default().show(ctx, |ui| {
            row(
                ui,
                "a conversation whose name is far too long for two hundred points",
                INK_WEAK,
                Some(accent(State::Attention)),
                false,
                0.0,
                "a row",
            );
        });
    };
    let glyphs = seen(&window, body);
    let run = glyphs.first().expect("the words reached the glass");
    assert!(run.text.ends_with('…'), "elided: {:?}", run.text);
    assert_eq!(run.ink, INK_WEAK);
    let rule = fills(&window, body)
        .into_iter()
        .find(|(rect, ink)| *ink == accent(State::Attention) && rect.width() <= RULE + 0.5);
    assert!(rule.is_some(), "the attention rule stands at the edge");
}

/// **A chosen row is raised and wears the brand**, whatever its state says —
/// the selection is where the operator is.
#[test]
fn a_chosen_row_is_raised_and_wears_the_brand() {
    let window = Window::sized(300.0, 100.0);
    let body = |ctx: &egui::Context| {
        egui::CentralPanel::default().show(ctx, |ui| {
            row(
                ui,
                "chosen",
                INK,
                Some(accent(State::Error)),
                true,
                0.0,
                "chosen",
            );
        });
    };
    let fills = fills(&window, body);
    assert!(fills.iter().any(|(_, ink)| *ink == RAISED), "raised");
    assert!(fills.iter().any(|(_, ink)| *ink == BRAND), "the brand rule");
    assert!(
        !fills.iter().any(|(_, ink)| *ink == accent(State::Error)),
        "and not the state's"
    );
}

/// **The row that holds the keyboard wears the brand ring** (bl-2d6b), and a
/// row at rest wears no stroke at all.
#[test]
fn a_row_rings_while_it_holds_the_keyboard_and_not_otherwise() {
    let window = Window::sized(300.0, 100.0);
    let mut body = |ctx: &egui::Context| {
        egui::CentralPanel::default().show(ctx, |ui| {
            row(ui, "first", INK, None, false, 0.0, "first");
            row(ui, "second", INK, None, false, 0.0, "second");
        });
    };
    let ringed = |output: &egui::FullOutput| {
        crate::paint_probe::strokes_of(output)
            .into_iter()
            .filter(|(_, ink)| *ink == BRAND)
            .count()
    };
    assert_eq!(ringed(&window.frame(Vec::new(), &mut body)), 0, "at rest");
    window.frame(
        vec![crate::paint_probe::frame::press(egui::Key::Tab)],
        &mut body,
    );
    let output = window.frame(Vec::new(), &mut body);
    assert_eq!(ringed(&output), 1, "one row holds the keyboard");
    let ring = crate::paint_probe::strokes_of(&output)
        .into_iter()
        .find(|(_, ink)| *ink == BRAND)
        .map(|(rect, _)| rect)
        .expect("the ring");
    let first = seen(&window, &mut body)
        .into_iter()
        .find(|run| run.text == "first")
        .expect("the first row");
    assert!(
        ring.contains_rect(first.laid),
        "the ring is around the first row"
    );
}

/// **A row is a control**: a click on its words lands on it.
#[test]
fn a_row_takes_a_click_on_its_words() {
    let window = Window::sized(300.0, 100.0);
    let mut clicked = false;
    click(&window, "take me", |ctx| {
        egui::CentralPanel::default().show(ctx, |ui| {
            clicked |= row(ui, "take me", INK, None, false, 0.0, "takes").clicked();
        });
    });
    assert!(clicked);
}

/// **A ruled block's rule spans its body**, and a section's word is on the
/// glass in weak ink under its hairline.
#[test]
fn a_block_is_ruled_and_a_section_is_worded() {
    let window = Window::sized(300.0, 300.0);
    let body = |ctx: &egui::Context| {
        egui::CentralPanel::default().show(ctx, |ui| {
            ruled(ui, BRAND, |ui| {
                ui.label("first line");
                ui.label("second line");
            });
            section(ui, "steps");
            rail(ui, 4.0, 0.0, 10.0);
            elbow(ui, 4.0, 0.0, 5.0, 12.0);
        });
    };
    let glyphs = seen(&window, body);
    let first = glyphs
        .iter()
        .find(|run| run.text == "first line")
        .expect("first");
    let second = glyphs
        .iter()
        .find(|run| run.text == "second line")
        .expect("second");
    let rule = fills(&window, body)
        .into_iter()
        .find(|(rect, ink)| *ink == BRAND && rect.width() <= RULE + 0.5)
        .expect("the rule is on the glass");
    assert!(rule.0.min.y <= first.laid.min.y + 1.0 && rule.0.max.y >= second.laid.max.y - 1.0);
    let word = glyphs
        .iter()
        .find(|run| run.text == "steps")
        .expect("the section's word");
    assert_eq!(word.ink, INK_WEAK);
}

/// **Prose is laid at the leading** (bl-f251): a paragraph that wraps to
/// two lines stands two leadings tall on the glass, where a label of the
/// same words stands two font heights — and the words reach the glass in
/// the ink they were given.
#[test]
fn prose_is_laid_at_the_leading_and_a_label_is_not() {
    let window = Window::sized(200.0, 200.0);
    let words = "a paragraph long enough that two hundred points cannot hold it on one line";
    let body = |ctx: &egui::Context| {
        egui::CentralPanel::default().show(ctx, |ui| {
            prose(ui, words, INK_WEAK);
            ui.label(words);
        });
    };
    let glyphs = seen(&window, body);
    let (paragraph, label) = (&glyphs[0], &glyphs[1]);
    assert_eq!(paragraph.ink, INK_WEAK);
    assert!(
        paragraph.laid.height() >= 2.0 * type_scale::LEADING - 1.0,
        "{:?}",
        paragraph.laid
    );
    assert!(
        paragraph.laid.height() > label.laid.height() + type_scale::LEADING - type_scale::BODY,
        "prose {:?} over label {:?}",
        paragraph.laid,
        label.laid
    );
}

/// **An empty state is one weak sentence that wraps** (bl-f251, item 5):
/// on the glass in `INK_WEAK`, and at a width that cannot hold it on one
/// line it stands more than one line tall rather than running off the edge.
#[test]
fn an_empty_state_is_one_weak_sentence_that_wraps() {
    let window = Window::sized(160.0, 200.0);
    let sentence = "no conversations here yet — begin one in the box below";
    let glyphs = seen(&window, |ctx| {
        egui::CentralPanel::default().show(ctx, |ui| {
            empty(ui, sentence);
        });
    });
    let run = glyphs.first().expect("the sentence reached the glass");
    assert_eq!(run.ink, INK_WEAK);
    assert!(run.laid.height() > 1.5 * type_scale::BODY, "{:?}", run.laid);
    assert!(run.laid.max.x <= 160.0, "{:?}", run.laid);
}

/// **A row past the clip paints nothing**: in a window too short for the
/// list, the rows beyond the scroll's edge are laid and not painted — their
/// words are not on the glass, and the first row's are.
#[test]
fn a_row_past_the_clip_paints_nothing() {
    let window = Window::sized(300.0, 60.0);
    let runs = seen(&window, |ctx| {
        egui::CentralPanel::default().show(ctx, |ui| {
            egui::ScrollArea::vertical().show(ui, |ui| {
                for i in 0..30 {
                    row(ui, &format!("row {i}"), INK, None, false, 0.0, "a row");
                }
            });
        });
    });
    assert!(runs.iter().any(|run| run.text == "row 0"), "{runs:?}");
    assert!(!runs.iter().any(|run| run.text == "row 29"), "{runs:?}");
}