use crate::{
CellGroup, Line, Palette,
utils::{cell_size, visual_rows},
};
use alloc::{format, rc::Rc, string::String, vec, vec::Vec};
use core::sync::atomic::{AtomicU8, Ordering::SeqCst};
use eframe::egui::{
Align, Align2, Color32, Context, Event, EventFilter, FontId, Id, Key, Painter, Pos2, Rect,
ScrollArea, Sense, Ui, Vec2, pos2, vec2,
};
static TERM_ID_CNT: AtomicU8 = AtomicU8::new(0);
pub struct Terminal {
id: Id,
prompt: Rc<[char]>,
pub palette: Palette,
grid: Vec<Line>,
records: Vec<Vec<char>>,
record_index: usize,
cursor: usize,
font_id: FontId,
cw: f32,
ch: f32,
cell_per_row: usize,
}
impl Terminal {
pub fn new(prompt: &str, palette: Palette) -> Self {
let id = TERM_ID_CNT.fetch_add(1, SeqCst);
let font_id = FontId::monospace(14.);
Self {
id: Id::new(format!("egui-simple-term-{}", id)),
prompt: prompt.chars().collect(),
palette,
grid: Vec::new(),
records: vec![vec![]],
record_index: 0,
cursor: 0,
font_id,
cw: 0.,
ch: 0.,
cell_per_row: 0,
}
}
pub fn cursor_color(&self) -> Color32 {
self.palette.cursor_color
}
pub fn prompt_color(&self) -> Color32 {
self.palette.prompt_color
}
pub fn record_color(&self) -> Color32 {
self.palette.record_color
}
fn editing(&self) -> &Vec<char> {
&self.records[self.record_index]
}
fn editing_mut(&mut self) -> &mut Vec<char> {
&mut self.records[self.record_index]
}
fn remove_editing_ch(&mut self, i: usize) -> Option<char> {
let record = self.editing_mut();
if i < record.len() {
Some(record.remove(i))
} else {
None
}
}
fn insert_editing_str(&mut self, i: usize, s: &str) -> usize {
let record = self.editing_mut();
let old_input_len = record.len();
if i <= old_input_len {
record.splice(i..i, s.chars().filter(|c| !c.is_control()));
}
record.len() - old_input_len
}
pub fn clear_grid(&mut self) {
self.grid.clear();
}
pub fn writeln_grid(&mut self, text: &str) {
let chars = text.chars().collect::<Rc<_>>();
let group = CellGroup::no_bg(chars, self.record_color());
let line = Line::Full(group);
self.grid.push(line);
}
fn prompt_input_to_line(&self) -> Line {
let prompt_seg = CellGroup::no_bg(Rc::clone(&self.prompt), self.prompt_color());
let record = self.editing();
if record.is_empty() {
Line::Full(prompt_seg)
} else {
let input_seg = CellGroup::no_bg(record.clone().into(), self.record_color());
Line::Segs([prompt_seg, input_seg].into())
}
}
fn grid_size(&self, viewport: Rect) -> Vec2 {
let record = self.editing();
let mut row_count = 0;
for row in &self.grid {
row_count += visual_rows(row.len(), self.cell_per_row);
}
row_count += visual_rows(self.prompt.len() + record.len(), self.cell_per_row);
vec2(
viewport.width(),
viewport.height().max(row_count as f32 * self.ch),
)
}
fn paint_line(&self, painter: &Painter, line: &Line, min: Pos2, cell_per_row: usize) -> usize {
let groups = line.as_slice();
let mut count = 0;
for &CellGroup { ref chars, fg, bg } in groups {
let mut rest_chars = &chars[..];
let mut consume_len;
loop {
let (row, col) = (count / cell_per_row, count % cell_per_row);
consume_len = rest_chars.len().min(cell_per_row - col);
if consume_len == 0 {
break;
}
count += consume_len;
let consume_chars = &rest_chars[..consume_len];
rest_chars = &rest_chars[consume_len..];
let left_top = min + vec2(col as f32 * self.cw, row as f32 * self.ch);
let rect =
Rect::from_min_size(left_top, vec2(consume_len as f32 * self.cw, self.ch));
if !bg.is_additive() {
painter.rect_filled(rect, 0., bg);
}
if !fg.is_additive() {
painter.text(
left_top,
Align2::LEFT_TOP,
consume_chars.iter().collect::<String>(),
self.font_id.clone(),
fg,
);
}
}
}
visual_rows(count, cell_per_row)
}
fn paint(&self, painter: &Painter, rect: Rect, focused: bool) {
let top_left = rect.min;
let mut row = 0;
for line in &self.grid {
row += self.paint_line(
painter,
line,
top_left + vec2(0., row as f32 * self.ch),
self.cell_per_row,
);
}
let input_line = self.prompt_input_to_line();
self.paint_line(
painter,
&input_line,
top_left + vec2(0., row as f32 * self.ch),
self.cell_per_row,
);
if focused {
let idx = self.prompt.len() + self.cursor;
let col = idx % self.cell_per_row;
let r = row + idx / self.cell_per_row;
let rect = Rect::from_min_size(
pos2(
top_left.x + col as f32 * self.cw,
top_left.y + r as f32 * self.ch,
),
vec2(self.cw, self.ch),
);
painter.rect_filled(rect, 0.0, self.cursor_color());
}
}
pub fn has_focus(&self, ctx: &Context) -> bool {
ctx.memory(|mem| mem.has_focus(self.id))
}
fn update_cell_size(&mut self, ctx: &Context) {
[self.cw, self.ch] = cell_size(ctx, &self.font_id);
}
fn update_cell_per_row(&mut self, width: f32) {
self.cell_per_row = ((width / self.cw).floor() as usize).max(1);
}
fn set_focus_lock_filter(&self, ctx: &Context) {
ctx.memory_mut(|mem| {
mem.set_focus_lock_filter(
self.id,
EventFilter {
tab: false,
horizontal_arrows: true,
vertical_arrows: true,
escape: false,
},
)
});
}
pub fn show(&mut self, ui: &mut Ui) -> Option<String> {
let focused = self.has_focus(ui);
let mut key_pressed = false;
let mut command = None;
if focused {
(key_pressed, command) = self.handle_input(ui);
self.set_focus_lock_filter(ui);
}
ScrollArea::vertical()
.animated(false)
.stick_to_bottom(true)
.auto_shrink([false; 2])
.show_viewport(ui, |ui, viewport| {
self.update_cell_size(ui);
self.update_cell_per_row(viewport.width());
let size = self.grid_size(viewport);
let (rect, _) = ui.allocate_exact_size(size, Sense::hover());
let resp = ui.interact(rect, self.id, Sense::click());
if resp.clicked() {
resp.request_focus();
}
let painter = ui.painter_at(rect);
self.paint(&painter, rect, focused);
if key_pressed {
ui.scroll_to_cursor(Some(Align::BOTTOM));
}
});
command
}
fn cursor_prev_record(&mut self) {
self.record_index = self.record_index.saturating_sub(1);
self.cursor = self.editing().len();
}
fn cursor_next_record(&mut self) {
self.record_index = (self.record_index + 1).min(self.records.len() - 1);
self.cursor = self.editing().len();
}
fn cursor_shl(&mut self) {
self.cursor = self.cursor.saturating_sub(1);
}
fn cursor_shr(&mut self) {
self.cursor = (self.cursor + 1).min(self.editing().len());
}
fn cursor_home(&mut self) {
self.cursor = 0;
}
fn cursor_end(&mut self) {
self.cursor = self.editing().len();
}
fn cursor_backspace(&mut self) {
if self.cursor > 0 {
self.cursor -= 1;
self.remove_editing_ch(self.cursor);
}
}
fn cursor_delete(&mut self) {
self.remove_editing_ch(self.cursor);
}
fn cursor_insert_str(&mut self, s: &str) {
let char_count = self.insert_editing_str(self.cursor, s);
self.cursor += char_count;
}
fn handle_input(&mut self, ctx: &Context) -> (bool, Option<String>) {
ctx.input(|st| {
let mut key_pressed = false;
let mut command = None;
for event in &st.events {
match event {
Event::Text(text) | Event::Paste(text) => self.cursor_insert_str(&text),
&Event::Key {
key,
pressed,
modifiers,
..
} => {
if pressed && modifiers.is_none() {
key_pressed = true;
match key {
Key::ArrowUp => self.cursor_prev_record(),
Key::ArrowDown => self.cursor_next_record(),
Key::ArrowLeft => self.cursor_shl(),
Key::ArrowRight => self.cursor_shr(),
Key::Backspace => self.cursor_backspace(),
Key::Delete => self.cursor_delete(),
Key::End => self.cursor_end(),
Key::Enter => command = Some(self.submit()),
Key::Home => self.cursor_home(),
_ => {}
};
}
}
_ => {}
};
}
(key_pressed, command)
})
}
fn submit(&mut self) -> String {
let line = self.prompt_input_to_line();
self.grid.push(line);
let command = self.editing().iter().collect();
if self.records.last().unwrap() != self.editing() {
*self.records.last_mut().unwrap() = self.editing().clone();
}
let (last_record, records) = self.records.split_last().unwrap();
if !last_record.is_empty() {
if let Some(last_history) = records.last()
&& last_record == last_history
{
self.records.last_mut().unwrap().clear();
} else {
self.records.push(Vec::new());
}
}
self.record_index = self.records.len() - 1;
self.cursor = 0;
command
}
}