monospace 0.1.1

Interactive terminal editor for ASCII and Unicode box-drawing diagrams
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

//! The chrome's own state: the bar, the keyboard, and what a press lands on.
//!
//! **The bar and the keyboard are one thing** (rule 1 of #189): the drop-down is the bar's, so a
//! menu that stays open implies the bar holds the keyboard, and a meaning carried out closes the
//! one and gives the other back together. [`Chrome`] owns the pair so that no module can do half
//! of it.
//!
//! **The leaf is not a meaning** (D1 of #189): a press, `F10`, `Alt` plus a label's character and
//! the `Esc` that closes nothing move the keyboard where they are read, and none of them becomes
//! an action. [`Target`] is the one answer to where a press landed, and [`Keyboard`] is the only
//! thing that moves the leaf.

use monospace_core::Offset;
use rat_widget::menu::MenubarState;

/// Which leaf of the chrome holds the keyboard.
///
/// **The bar and the region are the two leaves** (rule 1 of #189): the status line is not one, and
/// a control inside a leaf — a label, an entry, the dialog's button — never holds the keyboard on
/// its own. The dialog is an overlay and runs its own focus while it is up; the application's leaf
/// stays where it was, which is what makes closing the dialog give the keyboard back unchanged.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum Focus {
    /// The menu bar, and the drop-down it opens: the pop-up is the bar's.
    Bar,

    /// The diagram region, border included.
    Region,
}

/// The keyboard, and the ways it moves.
///
/// **The leaf is not a meaning** (D1 of #189): a press, `F10`, `Alt` plus a label's character and
/// the `Esc` that closes nothing move the keyboard where they are read, and none of them becomes
/// an action. **The moves are named here so that no module writes the leaf**: the bar asks for the
/// keyboard and gives it back, and a press addresses it by its target.
///
/// **A move says whether it moved**, which is what owes the frame: a key that asks for the leaf
/// already held changes nothing on the screen.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Keyboard {
    leaf: Focus,
}

impl Keyboard {
    /// A keyboard on the region, which is where an application starts (D1 of #189).
    fn region() -> Self {
        Self {
            leaf: Focus::Region,
        }
    }

    /// The leaf that holds it.
    fn leaf(self) -> Focus {
        self.leaf
    }

    /// Whether the bar holds it.
    fn is_bar(self) -> bool {
        self.leaf == Focus::Bar
    }

    /// The bar asks for the keyboard, saying whether it moved.
    fn move_to_bar(&mut self) -> bool {
        let moved = self.leaf != Focus::Bar;
        self.leaf = Focus::Bar;
        moved
    }

    /// The bar gives the keyboard back, saying whether it moved.
    fn move_to_region(&mut self) -> bool {
        let moved = self.leaf != Focus::Region;
        self.leaf = Focus::Region;
        moved
    }

    /// A move to the leaf the target names, saying whether it moved.
    ///
    /// **A target in neither leaf leaves it alone**: the status line and empty space are not
    /// destinations for the keyboard.
    fn move_to(&mut self, target: Target) -> bool {
        match target {
            Target::Bar => self.move_to_bar(),
            Target::Border | Target::Interior(_) => self.move_to_region(),
            Target::Nothing => false,
        }
    }
}

/// The chrome's own state: the bar and the keyboard.
///
/// **The pair is one thing** (rule 1 of #189): the drop-down is the bar's, so a menu that stays
/// open implies the bar holds the keyboard, and a meaning carried out closes the one and gives the
/// other back together. They travel together so that a handler cannot be handed a bar with the
/// keyboard somewhere else, and so that the closing has one home.
pub(crate) struct Chrome {
    menu: MenubarState,

    keyboard: Keyboard,
}

impl Chrome {
    /// The chrome of an application that starts on the region (D1 of #189).
    pub(crate) fn new() -> Self {
        Self {
            menu: MenubarState::default(),
            keyboard: Keyboard::region(),
        }
    }

    /// The bar's own state, for the frame that paints it and the test that reads it.
    pub(crate) fn menu(&self) -> &MenubarState {
        &self.menu
    }

    /// The bar's own state, for the widget that answers its events and the frame that draws it.
    ///
    /// **The mutable door is the widget's and the frame's**: `rat-menu` opens and closes the
    /// drop-down itself, and the frame hands it the state to paint. What the application does
    /// about the pair is [`Self::close`].
    pub(crate) fn menu_mut(&mut self) -> &mut MenubarState {
        &mut self.menu
    }

    /// Whether the drop-down is open.
    pub(crate) fn popup_active(&self) -> bool {
        self.menu.popup_active()
    }

    /// The drop-down closes while the bar keeps the keyboard.
    ///
    /// **An entry taken is this and not [`Self::close`]**: the meaning is carried out afterwards,
    /// and that is what gives the keyboard back.
    pub(crate) fn close_popup(&mut self) {
        self.menu.set_popup_active(false);
    }

    /// The bar asks for the keyboard, saying whether it moved.
    pub(crate) fn move_to_bar(&mut self) -> bool {
        self.keyboard.move_to_bar()
    }

    /// The bar gives the keyboard back, saying whether it moved.
    pub(crate) fn move_to_region(&mut self) -> bool {
        self.keyboard.move_to_region()
    }

    /// The leaf that holds the keyboard.
    pub(crate) fn leaf(&self) -> Focus {
        self.keyboard.leaf()
    }

    /// Whether the bar holds the keyboard.
    pub(crate) fn is_bar(&self) -> bool {
        self.keyboard.is_bar()
    }

    /// A move to the leaf the target names, saying whether it moved.
    pub(crate) fn move_to(&mut self, target: Target) -> bool {
        self.keyboard.move_to(target)
    }

    /// **A meaning carried out closes the drop-down and gives the keyboard back together**
    /// (rule 13 of #189): what a person took from the bar is done, and what is left to do is in
    /// the drawing. **The two are one operation** because a menu nobody holds the keyboard on is
    /// not open, and doing one without the other is the state this type exists to prevent.
    pub(crate) fn close(&mut self) {
        self.close_popup();
        self.keyboard.move_to_region();
    }
}

/// What a left press lands on.
///
/// **One answer, decided once.** The leaf the keyboard moves to and the cell of the drawing under
/// the pointer are two readings of the same press, so they are taken together: a rectangle cannot
/// belong to one reading and not to the other. The drop-down is asked about before the region
/// (rule 1 of #189), and the region's border is the keyboard's without being a cell of the
/// drawing (rule 2).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum Target {
    /// The bar, its labels, and the drop-down it opens.
    Bar,

    /// The region's border: the keyboard's, with no cell of the drawing under it.
    Border,

    /// The diagram's interior, at this cell of its window.
    Interior(Offset),

    /// Neither leaf: the status line, or a rectangle no frame drew into.
    Nothing,
}