|
|
@@ -0,0 +1,1155 @@
|
|
|
+// hoardom-app: native e gui emo wrapper for the hoardom tui
|
|
|
+// spawns hoardom --tui in a pty and renders it in its own window
|
|
|
+// so it shows up with its own icon in the dock (mac) or taskbar (linux)
|
|
|
+//
|
|
|
+// built with: cargo build --features gui
|
|
|
+
|
|
|
+use eframe::egui::{self, Color32, FontId, Rect, Sense};
|
|
|
+use portable_pty::{native_pty_system, CommandBuilder, PtySize};
|
|
|
+use vte::{Params, Perform};
|
|
|
+
|
|
|
+use std::io::{Read, Write};
|
|
|
+use std::path::PathBuf;
|
|
|
+use std::sync::atomic::{AtomicBool, Ordering};
|
|
|
+use std::sync::{Arc, Mutex};
|
|
|
+use std::thread;
|
|
|
+use std::time::Duration;
|
|
|
+
|
|
|
+// ----- constants -----
|
|
|
+
|
|
|
+const FONT_SIZE: f32 = 14.0;
|
|
|
+const DEFAULT_COLS: u16 = 120;
|
|
|
+const DEFAULT_ROWS: u16 = 35;
|
|
|
+
|
|
|
+const DEFAULT_FG: Color32 = Color32::from_rgb(204, 204, 204);
|
|
|
+const DEFAULT_BG: Color32 = Color32::from_rgb(24, 24, 24);
|
|
|
+
|
|
|
+// ----- terminal colors -----
|
|
|
+
|
|
|
+#[derive(Clone, Copy, PartialEq)]
|
|
|
+enum TermColor {
|
|
|
+ Default,
|
|
|
+ Indexed(u8),
|
|
|
+ Rgb(u8, u8, u8),
|
|
|
+}
|
|
|
+
|
|
|
+fn ansi_color(idx: u8) -> Color32 {
|
|
|
+ match idx {
|
|
|
+ 0 => Color32::from_rgb(0, 0, 0),
|
|
|
+ 1 => Color32::from_rgb(170, 0, 0),
|
|
|
+ 2 => Color32::from_rgb(0, 170, 0),
|
|
|
+ 3 => Color32::from_rgb(170, 85, 0),
|
|
|
+ 4 => Color32::from_rgb(0, 0, 170),
|
|
|
+ 5 => Color32::from_rgb(170, 0, 170),
|
|
|
+ 6 => Color32::from_rgb(0, 170, 170),
|
|
|
+ 7 => Color32::from_rgb(170, 170, 170),
|
|
|
+ 8 => Color32::from_rgb(85, 85, 85),
|
|
|
+ 9 => Color32::from_rgb(255, 85, 85),
|
|
|
+ 10 => Color32::from_rgb(85, 255, 85),
|
|
|
+ 11 => Color32::from_rgb(255, 255, 85),
|
|
|
+ 12 => Color32::from_rgb(85, 85, 255),
|
|
|
+ 13 => Color32::from_rgb(255, 85, 255),
|
|
|
+ 14 => Color32::from_rgb(85, 255, 255),
|
|
|
+ 15 => Color32::from_rgb(255, 255, 255),
|
|
|
+ // 6x6x6 color cube
|
|
|
+ 16..=231 => {
|
|
|
+ let idx = (idx - 16) as u16;
|
|
|
+ let ri = idx / 36;
|
|
|
+ let gi = (idx % 36) / 6;
|
|
|
+ let bi = idx % 6;
|
|
|
+ let v = |i: u16| -> u8 {
|
|
|
+ if i == 0 { 0 } else { 55 + i as u8 * 40 }
|
|
|
+ };
|
|
|
+ Color32::from_rgb(v(ri), v(gi), v(bi))
|
|
|
+ }
|
|
|
+ // grayscale ramp
|
|
|
+ 232..=255 => {
|
|
|
+ let g = 8 + (idx - 232) * 10;
|
|
|
+ Color32::from_rgb(g, g, g)
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+fn resolve_color(c: TermColor, is_fg: bool) -> Color32 {
|
|
|
+ match c {
|
|
|
+ TermColor::Default => {
|
|
|
+ if is_fg { DEFAULT_FG } else { DEFAULT_BG }
|
|
|
+ }
|
|
|
+ TermColor::Indexed(i) => ansi_color(i),
|
|
|
+ TermColor::Rgb(r, g, b) => Color32::from_rgb(r, g, b),
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// ----- terminal cell -----
|
|
|
+
|
|
|
+#[derive(Clone, Copy)]
|
|
|
+struct Cell {
|
|
|
+ ch: char,
|
|
|
+ fg: TermColor,
|
|
|
+ bg: TermColor,
|
|
|
+ bold: bool,
|
|
|
+ reverse: bool,
|
|
|
+}
|
|
|
+
|
|
|
+impl Default for Cell {
|
|
|
+ fn default() -> Self {
|
|
|
+ Cell {
|
|
|
+ ch: ' ',
|
|
|
+ fg: TermColor::Default,
|
|
|
+ bg: TermColor::Default,
|
|
|
+ bold: false,
|
|
|
+ reverse: false,
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+impl Cell {
|
|
|
+ fn resolved_fg(&self) -> Color32 {
|
|
|
+ if self.reverse {
|
|
|
+ resolve_color(self.bg, false)
|
|
|
+ } else {
|
|
|
+ let c = resolve_color(self.fg, true);
|
|
|
+ if self.bold {
|
|
|
+ // brighten bold text a bit
|
|
|
+ let [r, g, b, a] = c.to_array();
|
|
|
+ Color32::from_rgba_premultiplied(
|
|
|
+ r.saturating_add(40),
|
|
|
+ g.saturating_add(40),
|
|
|
+ b.saturating_add(40),
|
|
|
+ a,
|
|
|
+ )
|
|
|
+ } else {
|
|
|
+ c
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn resolved_bg(&self) -> Color32 {
|
|
|
+ if self.reverse {
|
|
|
+ resolve_color(self.fg, true)
|
|
|
+ } else {
|
|
|
+ resolve_color(self.bg, false)
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// ----- terminal grid -----
|
|
|
+
|
|
|
+struct TermGrid {
|
|
|
+ cells: Vec<Vec<Cell>>,
|
|
|
+ rows: usize,
|
|
|
+ cols: usize,
|
|
|
+ cursor_row: usize,
|
|
|
+ cursor_col: usize,
|
|
|
+ cursor_visible: bool,
|
|
|
+ scroll_top: usize,
|
|
|
+ scroll_bottom: usize,
|
|
|
+
|
|
|
+ // current drawing attributes
|
|
|
+ attr_fg: TermColor,
|
|
|
+ attr_bg: TermColor,
|
|
|
+ attr_bold: bool,
|
|
|
+ attr_reverse: bool,
|
|
|
+
|
|
|
+ // saved cursor
|
|
|
+ saved_cursor: Option<(usize, usize)>,
|
|
|
+
|
|
|
+ // alternate screen buffer
|
|
|
+ alt_saved: Option<(Vec<Vec<Cell>>, usize, usize)>,
|
|
|
+
|
|
|
+ // mouse tracking modes
|
|
|
+ mouse_normal: bool, // ?1000 - normal tracking (clicks)
|
|
|
+ mouse_button: bool, // ?1002 - button-event tracking (drag)
|
|
|
+ mouse_any: bool, // ?1003 - any-event tracking (all motion)
|
|
|
+ mouse_sgr: bool, // ?1006 - SGR extended coordinates
|
|
|
+}
|
|
|
+
|
|
|
+impl TermGrid {
|
|
|
+ fn new(rows: usize, cols: usize) -> Self {
|
|
|
+ TermGrid {
|
|
|
+ cells: vec![vec![Cell::default(); cols]; rows],
|
|
|
+ rows,
|
|
|
+ cols,
|
|
|
+ cursor_row: 0,
|
|
|
+ cursor_col: 0,
|
|
|
+ cursor_visible: true,
|
|
|
+ scroll_top: 0,
|
|
|
+ scroll_bottom: rows,
|
|
|
+ attr_fg: TermColor::Default,
|
|
|
+ attr_bg: TermColor::Default,
|
|
|
+ attr_bold: false,
|
|
|
+ attr_reverse: false,
|
|
|
+ saved_cursor: None,
|
|
|
+ alt_saved: None,
|
|
|
+ mouse_normal: false,
|
|
|
+ mouse_button: false,
|
|
|
+ mouse_any: false,
|
|
|
+ mouse_sgr: false,
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn mouse_enabled(&self) -> bool {
|
|
|
+ self.mouse_normal || self.mouse_button || self.mouse_any
|
|
|
+ }
|
|
|
+
|
|
|
+ fn resize(&mut self, new_rows: usize, new_cols: usize) {
|
|
|
+ if new_rows == self.rows && new_cols == self.cols {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ for row in &mut self.cells {
|
|
|
+ row.resize(new_cols, Cell::default());
|
|
|
+ }
|
|
|
+ while self.cells.len() < new_rows {
|
|
|
+ self.cells.push(vec![Cell::default(); new_cols]);
|
|
|
+ }
|
|
|
+ self.cells.truncate(new_rows);
|
|
|
+ self.rows = new_rows;
|
|
|
+ self.cols = new_cols;
|
|
|
+ self.scroll_top = 0;
|
|
|
+ self.scroll_bottom = new_rows;
|
|
|
+ self.cursor_row = self.cursor_row.min(new_rows.saturating_sub(1));
|
|
|
+ self.cursor_col = self.cursor_col.min(new_cols.saturating_sub(1));
|
|
|
+ }
|
|
|
+
|
|
|
+ fn reset_attrs(&mut self) {
|
|
|
+ self.attr_fg = TermColor::Default;
|
|
|
+ self.attr_bg = TermColor::Default;
|
|
|
+ self.attr_bold = false;
|
|
|
+ self.attr_reverse = false;
|
|
|
+ }
|
|
|
+
|
|
|
+ fn put_char(&mut self, c: char) {
|
|
|
+ if self.cursor_col >= self.cols {
|
|
|
+ self.cursor_col = 0;
|
|
|
+ self.line_feed();
|
|
|
+ }
|
|
|
+ if self.cursor_row < self.rows && self.cursor_col < self.cols {
|
|
|
+ self.cells[self.cursor_row][self.cursor_col] = Cell {
|
|
|
+ ch: c,
|
|
|
+ fg: self.attr_fg,
|
|
|
+ bg: self.attr_bg,
|
|
|
+ bold: self.attr_bold,
|
|
|
+ reverse: self.attr_reverse,
|
|
|
+ };
|
|
|
+ }
|
|
|
+ self.cursor_col += 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ fn line_feed(&mut self) {
|
|
|
+ if self.cursor_row + 1 >= self.scroll_bottom {
|
|
|
+ self.scroll_up();
|
|
|
+ } else {
|
|
|
+ self.cursor_row += 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn scroll_up(&mut self) {
|
|
|
+ if self.scroll_top < self.scroll_bottom && self.scroll_bottom <= self.rows {
|
|
|
+ self.cells.remove(self.scroll_top);
|
|
|
+ self.cells
|
|
|
+ .insert(self.scroll_bottom - 1, vec![Cell::default(); self.cols]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn scroll_down(&mut self) {
|
|
|
+ if self.scroll_top < self.scroll_bottom && self.scroll_bottom <= self.rows {
|
|
|
+ self.cells.remove(self.scroll_bottom - 1);
|
|
|
+ self.cells
|
|
|
+ .insert(self.scroll_top, vec![Cell::default(); self.cols]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn erase_display(&mut self, mode: u16) {
|
|
|
+ match mode {
|
|
|
+ 0 => {
|
|
|
+ // cursor to end
|
|
|
+ for c in self.cursor_col..self.cols {
|
|
|
+ self.cells[self.cursor_row][c] = Cell::default();
|
|
|
+ }
|
|
|
+ for r in (self.cursor_row + 1)..self.rows {
|
|
|
+ for c in 0..self.cols {
|
|
|
+ self.cells[r][c] = Cell::default();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ 1 => {
|
|
|
+ // start to cursor
|
|
|
+ for r in 0..self.cursor_row {
|
|
|
+ for c in 0..self.cols {
|
|
|
+ self.cells[r][c] = Cell::default();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ for c in 0..=self.cursor_col.min(self.cols.saturating_sub(1)) {
|
|
|
+ self.cells[self.cursor_row][c] = Cell::default();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ 2 | 3 => {
|
|
|
+ // whole screen
|
|
|
+ for r in 0..self.rows {
|
|
|
+ for c in 0..self.cols {
|
|
|
+ self.cells[r][c] = Cell::default();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ _ => {}
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn erase_line(&mut self, mode: u16) {
|
|
|
+ let row = self.cursor_row;
|
|
|
+ if row >= self.rows {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ match mode {
|
|
|
+ 0 => {
|
|
|
+ for c in self.cursor_col..self.cols {
|
|
|
+ self.cells[row][c] = Cell::default();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ 1 => {
|
|
|
+ for c in 0..=self.cursor_col.min(self.cols.saturating_sub(1)) {
|
|
|
+ self.cells[row][c] = Cell::default();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ 2 => {
|
|
|
+ for c in 0..self.cols {
|
|
|
+ self.cells[row][c] = Cell::default();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ _ => {}
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn erase_chars(&mut self, n: usize) {
|
|
|
+ let row = self.cursor_row;
|
|
|
+ if row >= self.rows {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ for i in 0..n {
|
|
|
+ let c = self.cursor_col + i;
|
|
|
+ if c < self.cols {
|
|
|
+ self.cells[row][c] = Cell::default();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn delete_chars(&mut self, n: usize) {
|
|
|
+ let row = self.cursor_row;
|
|
|
+ if row >= self.rows {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ for _ in 0..n {
|
|
|
+ if self.cursor_col < self.cols {
|
|
|
+ self.cells[row].remove(self.cursor_col);
|
|
|
+ self.cells[row].push(Cell::default());
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn insert_chars(&mut self, n: usize) {
|
|
|
+ let row = self.cursor_row;
|
|
|
+ if row >= self.rows {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ for _ in 0..n {
|
|
|
+ if self.cursor_col < self.cols {
|
|
|
+ self.cells[row].insert(self.cursor_col, Cell::default());
|
|
|
+ self.cells[row].truncate(self.cols);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn insert_lines(&mut self, n: usize) {
|
|
|
+ for _ in 0..n {
|
|
|
+ if self.cursor_row < self.scroll_bottom {
|
|
|
+ if self.scroll_bottom <= self.rows {
|
|
|
+ self.cells.remove(self.scroll_bottom - 1);
|
|
|
+ }
|
|
|
+ self.cells
|
|
|
+ .insert(self.cursor_row, vec![Cell::default(); self.cols]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn delete_lines(&mut self, n: usize) {
|
|
|
+ for _ in 0..n {
|
|
|
+ if self.cursor_row < self.scroll_bottom && self.cursor_row < self.rows {
|
|
|
+ self.cells.remove(self.cursor_row);
|
|
|
+ let insert_at = (self.scroll_bottom - 1).min(self.cells.len());
|
|
|
+ self.cells
|
|
|
+ .insert(insert_at, vec![Cell::default(); self.cols]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn enter_alt_screen(&mut self) {
|
|
|
+ self.alt_saved = Some((self.cells.clone(), self.cursor_row, self.cursor_col));
|
|
|
+ self.erase_display(2);
|
|
|
+ self.cursor_row = 0;
|
|
|
+ self.cursor_col = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ fn leave_alt_screen(&mut self) {
|
|
|
+ if let Some((cells, row, col)) = self.alt_saved.take() {
|
|
|
+ self.cells = cells;
|
|
|
+ self.cursor_row = row;
|
|
|
+ self.cursor_col = col;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // SGR - set graphics rendition (colors and attributes)
|
|
|
+ fn sgr(&mut self, params: &[u16]) {
|
|
|
+ if params.is_empty() {
|
|
|
+ self.reset_attrs();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ let mut i = 0;
|
|
|
+ while i < params.len() {
|
|
|
+ match params[i] {
|
|
|
+ 0 => self.reset_attrs(),
|
|
|
+ 1 => self.attr_bold = true,
|
|
|
+ 7 => self.attr_reverse = true,
|
|
|
+ 22 => self.attr_bold = false,
|
|
|
+ 27 => self.attr_reverse = false,
|
|
|
+ 30..=37 => self.attr_fg = TermColor::Indexed(params[i] as u8 - 30),
|
|
|
+ 38 => {
|
|
|
+ // extended fg color
|
|
|
+ if i + 2 < params.len() && params[i + 1] == 5 {
|
|
|
+ self.attr_fg = TermColor::Indexed(params[i + 2] as u8);
|
|
|
+ i += 2;
|
|
|
+ } else if i + 4 < params.len() && params[i + 1] == 2 {
|
|
|
+ self.attr_fg = TermColor::Rgb(
|
|
|
+ params[i + 2] as u8,
|
|
|
+ params[i + 3] as u8,
|
|
|
+ params[i + 4] as u8,
|
|
|
+ );
|
|
|
+ i += 4;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ 39 => self.attr_fg = TermColor::Default,
|
|
|
+ 40..=47 => self.attr_bg = TermColor::Indexed(params[i] as u8 - 40),
|
|
|
+ 48 => {
|
|
|
+ // extended bg color
|
|
|
+ if i + 2 < params.len() && params[i + 1] == 5 {
|
|
|
+ self.attr_bg = TermColor::Indexed(params[i + 2] as u8);
|
|
|
+ i += 2;
|
|
|
+ } else if i + 4 < params.len() && params[i + 1] == 2 {
|
|
|
+ self.attr_bg = TermColor::Rgb(
|
|
|
+ params[i + 2] as u8,
|
|
|
+ params[i + 3] as u8,
|
|
|
+ params[i + 4] as u8,
|
|
|
+ );
|
|
|
+ i += 4;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ 49 => self.attr_bg = TermColor::Default,
|
|
|
+ 90..=97 => self.attr_fg = TermColor::Indexed(params[i] as u8 - 90 + 8),
|
|
|
+ 100..=107 => self.attr_bg = TermColor::Indexed(params[i] as u8 - 100 + 8),
|
|
|
+ _ => {}
|
|
|
+ }
|
|
|
+ i += 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn handle_csi(&mut self, params: &[u16], intermediates: &[u8], action: char) {
|
|
|
+ // helper: get param with default
|
|
|
+ let p = |i: usize, def: u16| -> u16 {
|
|
|
+ params.get(i).copied().filter(|&v| v > 0).unwrap_or(def)
|
|
|
+ };
|
|
|
+
|
|
|
+ let private = intermediates.contains(&b'?');
|
|
|
+
|
|
|
+ match action {
|
|
|
+ 'A' => {
|
|
|
+ let n = p(0, 1) as usize;
|
|
|
+ self.cursor_row = self.cursor_row.saturating_sub(n);
|
|
|
+ }
|
|
|
+ 'B' => {
|
|
|
+ let n = p(0, 1) as usize;
|
|
|
+ self.cursor_row = (self.cursor_row + n).min(self.rows.saturating_sub(1));
|
|
|
+ }
|
|
|
+ 'C' => {
|
|
|
+ let n = p(0, 1) as usize;
|
|
|
+ self.cursor_col = (self.cursor_col + n).min(self.cols.saturating_sub(1));
|
|
|
+ }
|
|
|
+ 'D' => {
|
|
|
+ let n = p(0, 1) as usize;
|
|
|
+ self.cursor_col = self.cursor_col.saturating_sub(n);
|
|
|
+ }
|
|
|
+ 'H' | 'f' => {
|
|
|
+ // cursor position (1-based)
|
|
|
+ let row = p(0, 1) as usize;
|
|
|
+ let col = p(1, 1) as usize;
|
|
|
+ self.cursor_row = row.saturating_sub(1).min(self.rows.saturating_sub(1));
|
|
|
+ self.cursor_col = col.saturating_sub(1).min(self.cols.saturating_sub(1));
|
|
|
+ }
|
|
|
+ 'J' => self.erase_display(p(0, 0)),
|
|
|
+ 'K' => self.erase_line(p(0, 0)),
|
|
|
+ 'L' => self.insert_lines(p(0, 1) as usize),
|
|
|
+ 'M' => self.delete_lines(p(0, 1) as usize),
|
|
|
+ 'P' => self.delete_chars(p(0, 1) as usize),
|
|
|
+ 'X' => self.erase_chars(p(0, 1) as usize),
|
|
|
+ '@' => self.insert_chars(p(0, 1) as usize),
|
|
|
+ 'G' | '`' => {
|
|
|
+ let col = p(0, 1) as usize;
|
|
|
+ self.cursor_col = col.saturating_sub(1).min(self.cols.saturating_sub(1));
|
|
|
+ }
|
|
|
+ 'd' => {
|
|
|
+ let row = p(0, 1) as usize;
|
|
|
+ self.cursor_row = row.saturating_sub(1).min(self.rows.saturating_sub(1));
|
|
|
+ }
|
|
|
+ 'S' => {
|
|
|
+ for _ in 0..p(0, 1) {
|
|
|
+ self.scroll_up();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ 'T' => {
|
|
|
+ for _ in 0..p(0, 1) {
|
|
|
+ self.scroll_down();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ 'm' => {
|
|
|
+ if params.is_empty() {
|
|
|
+ self.sgr(&[0]);
|
|
|
+ } else {
|
|
|
+ self.sgr(params);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ 'r' => {
|
|
|
+ let top = p(0, 1) as usize;
|
|
|
+ let bottom = p(1, self.rows as u16) as usize;
|
|
|
+ self.scroll_top = top.saturating_sub(1);
|
|
|
+ self.scroll_bottom = bottom.min(self.rows);
|
|
|
+ }
|
|
|
+ 's' => {
|
|
|
+ self.saved_cursor = Some((self.cursor_row, self.cursor_col));
|
|
|
+ }
|
|
|
+ 'u' => {
|
|
|
+ if let Some((r, c)) = self.saved_cursor {
|
|
|
+ self.cursor_row = r.min(self.rows.saturating_sub(1));
|
|
|
+ self.cursor_col = c.min(self.cols.saturating_sub(1));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ 'h' if private => {
|
|
|
+ for ¶m in params {
|
|
|
+ match param {
|
|
|
+ 25 => self.cursor_visible = true,
|
|
|
+ 1000 => self.mouse_normal = true,
|
|
|
+ 1002 => self.mouse_button = true,
|
|
|
+ 1003 => self.mouse_any = true,
|
|
|
+ 1006 => self.mouse_sgr = true,
|
|
|
+ 1049 => self.enter_alt_screen(),
|
|
|
+ _ => {}
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ 'l' if private => {
|
|
|
+ for ¶m in params {
|
|
|
+ match param {
|
|
|
+ 25 => self.cursor_visible = false,
|
|
|
+ 1000 => self.mouse_normal = false,
|
|
|
+ 1002 => self.mouse_button = false,
|
|
|
+ 1003 => self.mouse_any = false,
|
|
|
+ 1006 => self.mouse_sgr = false,
|
|
|
+ 1049 => self.leave_alt_screen(),
|
|
|
+ _ => {}
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ _ => {}
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// ----- vte perform implementation -----
|
|
|
+
|
|
|
+impl Perform for TermGrid {
|
|
|
+ fn print(&mut self, c: char) {
|
|
|
+ self.put_char(c);
|
|
|
+ }
|
|
|
+
|
|
|
+ fn execute(&mut self, byte: u8) {
|
|
|
+ match byte {
|
|
|
+ 0x08 => {
|
|
|
+ // backspace
|
|
|
+ self.cursor_col = self.cursor_col.saturating_sub(1);
|
|
|
+ }
|
|
|
+ 0x09 => {
|
|
|
+ // tab - next tab stop (every 8 cols)
|
|
|
+ self.cursor_col = ((self.cursor_col / 8) + 1) * 8;
|
|
|
+ if self.cursor_col >= self.cols {
|
|
|
+ self.cursor_col = self.cols.saturating_sub(1);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ 0x0A | 0x0B | 0x0C => {
|
|
|
+ // line feed
|
|
|
+ self.line_feed();
|
|
|
+ }
|
|
|
+ 0x0D => {
|
|
|
+ // carriage return
|
|
|
+ self.cursor_col = 0;
|
|
|
+ }
|
|
|
+ _ => {}
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn csi_dispatch(&mut self, params: &Params, intermediates: &[u8], ignore: bool, action: char) {
|
|
|
+ if ignore {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ let flat: Vec<u16> = params.iter().map(|sub| sub[0]).collect();
|
|
|
+ self.handle_csi(&flat, intermediates, action);
|
|
|
+ }
|
|
|
+
|
|
|
+ fn esc_dispatch(&mut self, intermediates: &[u8], _ignore: bool, byte: u8) {
|
|
|
+ if !intermediates.is_empty() {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ match byte {
|
|
|
+ b'7' => {
|
|
|
+ self.saved_cursor = Some((self.cursor_row, self.cursor_col));
|
|
|
+ }
|
|
|
+ b'8' => {
|
|
|
+ if let Some((r, c)) = self.saved_cursor {
|
|
|
+ self.cursor_row = r.min(self.rows.saturating_sub(1));
|
|
|
+ self.cursor_col = c.min(self.cols.saturating_sub(1));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ b'D' => self.line_feed(),
|
|
|
+ b'M' => {
|
|
|
+ // reverse index
|
|
|
+ if self.cursor_row == self.scroll_top {
|
|
|
+ self.scroll_down();
|
|
|
+ } else {
|
|
|
+ self.cursor_row = self.cursor_row.saturating_sub(1);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ _ => {}
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn osc_dispatch(&mut self, _params: &[&[u8]], _bell_terminated: bool) {}
|
|
|
+ fn hook(&mut self, _params: &Params, _intermediates: &[u8], _ignore: bool, _action: char) {}
|
|
|
+ fn put(&mut self, _byte: u8) {}
|
|
|
+ fn unhook(&mut self) {}
|
|
|
+}
|
|
|
+
|
|
|
+// ----- keyboard input mapping -----
|
|
|
+
|
|
|
+// map egui keys to terminal escape sequences
|
|
|
+fn special_key_bytes(key: &egui::Key, modifiers: &egui::Modifiers) -> Option<Vec<u8>> {
|
|
|
+ use egui::Key;
|
|
|
+ match key {
|
|
|
+ Key::ArrowUp => Some(b"\x1b[A".to_vec()),
|
|
|
+ Key::ArrowDown => Some(b"\x1b[B".to_vec()),
|
|
|
+ Key::ArrowRight => Some(b"\x1b[C".to_vec()),
|
|
|
+ Key::ArrowLeft => Some(b"\x1b[D".to_vec()),
|
|
|
+ Key::Home => Some(b"\x1b[H".to_vec()),
|
|
|
+ Key::End => Some(b"\x1b[F".to_vec()),
|
|
|
+ Key::PageUp => Some(b"\x1b[5~".to_vec()),
|
|
|
+ Key::PageDown => Some(b"\x1b[6~".to_vec()),
|
|
|
+ Key::Insert => Some(b"\x1b[2~".to_vec()),
|
|
|
+ Key::Delete => Some(b"\x1b[3~".to_vec()),
|
|
|
+ Key::Escape => Some(b"\x1b".to_vec()),
|
|
|
+ Key::Tab => {
|
|
|
+ if modifiers.shift {
|
|
|
+ Some(b"\x1b[Z".to_vec())
|
|
|
+ } else {
|
|
|
+ Some(b"\x09".to_vec())
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Key::Backspace => Some(b"\x7f".to_vec()),
|
|
|
+ Key::Enter => Some(b"\x0d".to_vec()),
|
|
|
+ Key::F1 => Some(b"\x1bOP".to_vec()),
|
|
|
+ Key::F2 => Some(b"\x1bOQ".to_vec()),
|
|
|
+ Key::F3 => Some(b"\x1bOR".to_vec()),
|
|
|
+ Key::F4 => Some(b"\x1bOS".to_vec()),
|
|
|
+ Key::F5 => Some(b"\x1b[15~".to_vec()),
|
|
|
+ Key::F6 => Some(b"\x1b[17~".to_vec()),
|
|
|
+ Key::F7 => Some(b"\x1b[18~".to_vec()),
|
|
|
+ Key::F8 => Some(b"\x1b[19~".to_vec()),
|
|
|
+ Key::F9 => Some(b"\x1b[20~".to_vec()),
|
|
|
+ Key::F10 => Some(b"\x1b[21~".to_vec()),
|
|
|
+ Key::F11 => Some(b"\x1b[23~".to_vec()),
|
|
|
+ Key::F12 => Some(b"\x1b[24~".to_vec()),
|
|
|
+ _ => None,
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// ctrl+letter -> control character byte
|
|
|
+fn ctrl_key_byte(key: &egui::Key) -> Option<u8> {
|
|
|
+ use egui::Key;
|
|
|
+ match key {
|
|
|
+ Key::A => Some(0x01),
|
|
|
+ Key::B => Some(0x02),
|
|
|
+ Key::C => Some(0x03),
|
|
|
+ Key::D => Some(0x04),
|
|
|
+ Key::E => Some(0x05),
|
|
|
+ Key::F => Some(0x06),
|
|
|
+ Key::G => Some(0x07),
|
|
|
+ Key::H => Some(0x08),
|
|
|
+ Key::I => Some(0x09),
|
|
|
+ Key::J => Some(0x0A),
|
|
|
+ Key::K => Some(0x0B),
|
|
|
+ Key::L => Some(0x0C),
|
|
|
+ Key::M => Some(0x0D),
|
|
|
+ Key::N => Some(0x0E),
|
|
|
+ Key::O => Some(0x0F),
|
|
|
+ Key::P => Some(0x10),
|
|
|
+ Key::Q => Some(0x11),
|
|
|
+ Key::R => Some(0x12),
|
|
|
+ Key::S => Some(0x13),
|
|
|
+ Key::T => Some(0x14),
|
|
|
+ Key::U => Some(0x15),
|
|
|
+ Key::V => Some(0x16),
|
|
|
+ Key::W => Some(0x17),
|
|
|
+ Key::X => Some(0x18),
|
|
|
+ Key::Y => Some(0x19),
|
|
|
+ Key::Z => Some(0x1A),
|
|
|
+ _ => None,
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// ----- the egui app -----
|
|
|
+
|
|
|
+struct HoardomApp {
|
|
|
+ grid: Arc<Mutex<TermGrid>>,
|
|
|
+ pty_writer: Mutex<Box<dyn Write + Send>>,
|
|
|
+ pty_master: Box<dyn portable_pty::MasterPty + Send>,
|
|
|
+ child_exited: Arc<AtomicBool>,
|
|
|
+ cell_width: f32,
|
|
|
+ cell_height: f32,
|
|
|
+ current_cols: u16,
|
|
|
+ current_rows: u16,
|
|
|
+ last_mouse_button: Option<u8>, // track held mouse button for drag/release
|
|
|
+}
|
|
|
+
|
|
|
+impl eframe::App for HoardomApp {
|
|
|
+ fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
|
|
|
+ // bail if the child process is gone
|
|
|
+ if self.child_exited.load(Ordering::Relaxed) {
|
|
|
+ ctx.send_viewport_cmd(egui::ViewportCommand::Close);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // measure cell dimensions on first frame (cant do it in creation callback)
|
|
|
+ if self.cell_width == 0.0 {
|
|
|
+ let (cw, ch) = ctx.fonts(|f| {
|
|
|
+ let fid = FontId::monospace(FONT_SIZE);
|
|
|
+ let galley = f.layout_no_wrap("M".into(), fid.clone(), DEFAULT_FG);
|
|
|
+ let row_h = f.row_height(&fid);
|
|
|
+ (galley.rect.width(), row_h)
|
|
|
+ });
|
|
|
+ self.cell_width = cw;
|
|
|
+ self.cell_height = ch;
|
|
|
+ }
|
|
|
+
|
|
|
+ // handle keyboard input
|
|
|
+ ctx.input(|input| {
|
|
|
+ for event in &input.events {
|
|
|
+ match event {
|
|
|
+ egui::Event::Text(text) => {
|
|
|
+ // only pass printable chars (specials handled via Key events)
|
|
|
+ let filtered: String = text.chars().filter(|c| !c.is_control()).collect();
|
|
|
+ if !filtered.is_empty() {
|
|
|
+ if let Ok(mut w) = self.pty_writer.lock() {
|
|
|
+ let _ = w.write_all(filtered.as_bytes());
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ egui::Event::Key {
|
|
|
+ key,
|
|
|
+ pressed: true,
|
|
|
+ modifiers,
|
|
|
+ ..
|
|
|
+ } => {
|
|
|
+ if modifiers.ctrl || modifiers.mac_cmd {
|
|
|
+ if let Some(byte) = ctrl_key_byte(key) {
|
|
|
+ if let Ok(mut w) = self.pty_writer.lock() {
|
|
|
+ let _ = w.write_all(&[byte]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else if let Some(bytes) = special_key_bytes(key, modifiers) {
|
|
|
+ if let Ok(mut w) = self.pty_writer.lock() {
|
|
|
+ let _ = w.write_all(&bytes);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ _ => {}
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ // handle mouse input
|
|
|
+ self.handle_mouse(ctx);
|
|
|
+
|
|
|
+ // check if window was resized, update pty dimensions
|
|
|
+ let avail = ctx.available_rect();
|
|
|
+ if self.cell_width > 0.0 && self.cell_height > 0.0 {
|
|
|
+ let new_cols = (avail.width() / self.cell_width).floor() as u16;
|
|
|
+ let new_rows = (avail.height() / self.cell_height).floor() as u16;
|
|
|
+ let new_cols = new_cols.max(20);
|
|
|
+ let new_rows = new_rows.max(10);
|
|
|
+
|
|
|
+ if new_cols != self.current_cols || new_rows != self.current_rows {
|
|
|
+ self.current_cols = new_cols;
|
|
|
+ self.current_rows = new_rows;
|
|
|
+ let _ = self.pty_master.resize(PtySize {
|
|
|
+ rows: new_rows,
|
|
|
+ cols: new_cols,
|
|
|
+ pixel_width: 0,
|
|
|
+ pixel_height: 0,
|
|
|
+ });
|
|
|
+ if let Ok(mut grid) = self.grid.lock() {
|
|
|
+ grid.resize(new_rows as usize, new_cols as usize);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // render the terminal grid
|
|
|
+ egui::CentralPanel::default()
|
|
|
+ .frame(egui::Frame::default().fill(DEFAULT_BG))
|
|
|
+ .show(ctx, |ui| {
|
|
|
+ self.render_grid(ui);
|
|
|
+ });
|
|
|
+
|
|
|
+ ctx.request_repaint_after(Duration::from_millis(16));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+impl HoardomApp {
|
|
|
+ // translate egui pointer events to terminal mouse sequences
|
|
|
+ fn handle_mouse(&mut self, ctx: &egui::Context) {
|
|
|
+ let (mouse_enabled, use_sgr) = {
|
|
|
+ match self.grid.lock() {
|
|
|
+ Ok(g) => (g.mouse_enabled(), g.mouse_sgr),
|
|
|
+ Err(_) => return,
|
|
|
+ }
|
|
|
+ };
|
|
|
+ if !mouse_enabled {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ let cw = self.cell_width;
|
|
|
+ let ch = self.cell_height;
|
|
|
+ if cw <= 0.0 || ch <= 0.0 {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ let avail = ctx.available_rect();
|
|
|
+
|
|
|
+ ctx.input(|input| {
|
|
|
+ if let Some(pos) = input.pointer.latest_pos() {
|
|
|
+ let col = ((pos.x - avail.min.x) / cw).floor() as i32;
|
|
|
+ let row = ((pos.y - avail.min.y) / ch).floor() as i32;
|
|
|
+ let col = col.max(0) as u16;
|
|
|
+ let row = row.max(0) as u16;
|
|
|
+
|
|
|
+ // scroll events
|
|
|
+ let scroll_y = input.raw_scroll_delta.y;
|
|
|
+ if scroll_y != 0.0 {
|
|
|
+ let button: u8 = if scroll_y > 0.0 { 64 } else { 65 };
|
|
|
+ let seq = if use_sgr {
|
|
|
+ format!("\x1b[<{};{};{}M", button, col + 1, row + 1)
|
|
|
+ } else {
|
|
|
+ let cb = (button + 32) as char;
|
|
|
+ let cx = (col + 33).min(255) as u8 as char;
|
|
|
+ let cy = (row + 33).min(255) as u8 as char;
|
|
|
+ format!("\x1b[M{}{}{}", cb, cx, cy)
|
|
|
+ };
|
|
|
+ if let Ok(mut w) = self.pty_writer.lock() {
|
|
|
+ let _ = w.write_all(seq.as_bytes());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // button press
|
|
|
+ if input.pointer.any_pressed() {
|
|
|
+ let button: u8 = if input.pointer.button_pressed(egui::PointerButton::Primary) {
|
|
|
+ 0
|
|
|
+ } else if input.pointer.button_pressed(egui::PointerButton::Middle) {
|
|
|
+ 1
|
|
|
+ } else if input.pointer.button_pressed(egui::PointerButton::Secondary) {
|
|
|
+ 2
|
|
|
+ } else {
|
|
|
+ 0
|
|
|
+ };
|
|
|
+ self.last_mouse_button = Some(button);
|
|
|
+ let seq = if use_sgr {
|
|
|
+ format!("\x1b[<{};{};{}M", button, col + 1, row + 1)
|
|
|
+ } else {
|
|
|
+ let cb = (button + 32) as char;
|
|
|
+ let cx = (col + 33).min(255) as u8 as char;
|
|
|
+ let cy = (row + 33).min(255) as u8 as char;
|
|
|
+ format!("\x1b[M{}{}{}", cb, cx, cy)
|
|
|
+ };
|
|
|
+ if let Ok(mut w) = self.pty_writer.lock() {
|
|
|
+ let _ = w.write_all(seq.as_bytes());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // button release
|
|
|
+ if input.pointer.any_released() {
|
|
|
+ let button = self.last_mouse_button.unwrap_or(0);
|
|
|
+ self.last_mouse_button = None;
|
|
|
+ let seq = if use_sgr {
|
|
|
+ format!("\x1b[<{};{};{}m", button, col + 1, row + 1)
|
|
|
+ } else {
|
|
|
+ let cb = (3u8 + 32) as char; // release = button 3 in normal mode
|
|
|
+ let cx = (col + 33).min(255) as u8 as char;
|
|
|
+ let cy = (row + 33).min(255) as u8 as char;
|
|
|
+ format!("\x1b[M{}{}{}", cb, cx, cy)
|
|
|
+ };
|
|
|
+ if let Ok(mut w) = self.pty_writer.lock() {
|
|
|
+ let _ = w.write_all(seq.as_bytes());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // drag / motion
|
|
|
+ if input.pointer.is_moving() && self.last_mouse_button.is_some() {
|
|
|
+ let button = self.last_mouse_button.unwrap_or(0) + 32; // motion flag
|
|
|
+ let seq = if use_sgr {
|
|
|
+ format!("\x1b[<{};{};{}M", button, col + 1, row + 1)
|
|
|
+ } else {
|
|
|
+ let cb = (button + 32) as char;
|
|
|
+ let cx = (col + 33).min(255) as u8 as char;
|
|
|
+ let cy = (row + 33).min(255) as u8 as char;
|
|
|
+ format!("\x1b[M{}{}{}", cb, cx, cy)
|
|
|
+ };
|
|
|
+ if let Ok(mut w) = self.pty_writer.lock() {
|
|
|
+ let _ = w.write_all(seq.as_bytes());
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ fn render_grid(&self, ui: &mut egui::Ui) {
|
|
|
+ let grid = match self.grid.lock() {
|
|
|
+ Ok(g) => g,
|
|
|
+ Err(_) => return,
|
|
|
+ };
|
|
|
+
|
|
|
+ let painter = ui.painter();
|
|
|
+ let rect = ui.available_rect_before_wrap();
|
|
|
+ let cw = self.cell_width;
|
|
|
+ let ch = self.cell_height;
|
|
|
+
|
|
|
+ // draw each row - render character by character at exact cell positions
|
|
|
+ // to keep backgrounds and text perfectly aligned
|
|
|
+ for row in 0..grid.rows {
|
|
|
+ let y = rect.min.y + row as f32 * ch;
|
|
|
+
|
|
|
+ // draw background spans (batch consecutive same-bg cells)
|
|
|
+ let mut bg_start = 0usize;
|
|
|
+ let mut current_bg = grid.cells[row][0].resolved_bg();
|
|
|
+
|
|
|
+ for col in 0..=grid.cols {
|
|
|
+ let cell_bg = if col < grid.cols {
|
|
|
+ grid.cells[row][col].resolved_bg()
|
|
|
+ } else {
|
|
|
+ Color32::TRANSPARENT // sentinel to flush last span
|
|
|
+ };
|
|
|
+
|
|
|
+ if cell_bg != current_bg || col == grid.cols {
|
|
|
+ // draw the background span
|
|
|
+ if current_bg != DEFAULT_BG {
|
|
|
+ let x0 = rect.min.x + bg_start as f32 * cw;
|
|
|
+ let x1 = rect.min.x + col as f32 * cw;
|
|
|
+ painter.rect_filled(
|
|
|
+ Rect::from_min_max(egui::pos2(x0, y), egui::pos2(x1, y + ch)),
|
|
|
+ 0.0,
|
|
|
+ current_bg,
|
|
|
+ );
|
|
|
+ }
|
|
|
+ bg_start = col;
|
|
|
+ current_bg = cell_bg;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // draw text - render each cell at its exact x position
|
|
|
+ // this prevents sub-pixel drift that causes bg/text misalignment
|
|
|
+ for col in 0..grid.cols {
|
|
|
+ let cell = &grid.cells[row][col];
|
|
|
+ if cell.ch == ' ' || cell.ch == '\0' {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ let x = rect.min.x + col as f32 * cw;
|
|
|
+ let fg = cell.resolved_fg();
|
|
|
+ let mut buf = [0u8; 4];
|
|
|
+ let s = cell.ch.encode_utf8(&mut buf);
|
|
|
+ painter.text(
|
|
|
+ egui::pos2(x, y),
|
|
|
+ egui::Align2::LEFT_TOP,
|
|
|
+ s,
|
|
|
+ FontId::monospace(FONT_SIZE),
|
|
|
+ fg,
|
|
|
+ );
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // draw cursor
|
|
|
+ if grid.cursor_visible && grid.cursor_row < grid.rows && grid.cursor_col < grid.cols {
|
|
|
+ let cx = rect.min.x + grid.cursor_col as f32 * cw;
|
|
|
+ let cy = rect.min.y + grid.cursor_row as f32 * ch;
|
|
|
+ painter.rect_filled(
|
|
|
+ Rect::from_min_size(egui::pos2(cx, cy), egui::vec2(cw, ch)),
|
|
|
+ 0.0,
|
|
|
+ Color32::from_rgba_premultiplied(180, 180, 180, 100),
|
|
|
+ );
|
|
|
+ }
|
|
|
+
|
|
|
+ // reserve the space so egui knows we used it
|
|
|
+ ui.allocate_exact_size(
|
|
|
+ egui::vec2(grid.cols as f32 * cw, grid.rows as f32 * ch),
|
|
|
+ Sense::hover(),
|
|
|
+ );
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// ----- find the hoardom binary -----
|
|
|
+
|
|
|
+fn find_hoardom() -> PathBuf {
|
|
|
+ // check same directory as ourselves
|
|
|
+ if let Ok(exe) = std::env::current_exe() {
|
|
|
+ if let Some(dir) = exe.parent() {
|
|
|
+ // check for hoardom next to us
|
|
|
+ let candidate = dir.join("hoardom");
|
|
|
+ if candidate.exists() && candidate != exe {
|
|
|
+ return candidate;
|
|
|
+ }
|
|
|
+ // in a mac .app bundle the binary might be named differently
|
|
|
+ let candidate = dir.join("hoardom-bin");
|
|
|
+ if candidate.exists() {
|
|
|
+ return candidate;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // fall back to PATH
|
|
|
+ PathBuf::from("hoardom")
|
|
|
+}
|
|
|
+
|
|
|
+// ----- main -----
|
|
|
+
|
|
|
+fn main() -> eframe::Result<()> {
|
|
|
+ let hoardom_bin = find_hoardom();
|
|
|
+
|
|
|
+ // setup pty
|
|
|
+ let pty_system = native_pty_system();
|
|
|
+ let pair = pty_system
|
|
|
+ .openpty(PtySize {
|
|
|
+ rows: DEFAULT_ROWS,
|
|
|
+ cols: DEFAULT_COLS,
|
|
|
+ pixel_width: 0,
|
|
|
+ pixel_height: 0,
|
|
|
+ })
|
|
|
+ .expect("failed to open pty");
|
|
|
+
|
|
|
+ // spawn hoardom --tui in the pty
|
|
|
+ let mut cmd = CommandBuilder::new(&hoardom_bin);
|
|
|
+ cmd.arg("--tui");
|
|
|
+ cmd.env("TERM", "xterm-256color");
|
|
|
+
|
|
|
+ let mut child = pair
|
|
|
+ .slave
|
|
|
+ .spawn_command(cmd)
|
|
|
+ .unwrap_or_else(|e| panic!("failed to spawn {:?}: {}", hoardom_bin, e));
|
|
|
+
|
|
|
+ // close the slave end in the parent so pty gets proper eof
|
|
|
+ drop(pair.slave);
|
|
|
+
|
|
|
+ let reader = pair
|
|
|
+ .master
|
|
|
+ .try_clone_reader()
|
|
|
+ .expect("failed to clone pty reader");
|
|
|
+ let writer = pair
|
|
|
+ .master
|
|
|
+ .take_writer()
|
|
|
+ .expect("failed to take pty writer");
|
|
|
+
|
|
|
+ let grid = Arc::new(Mutex::new(TermGrid::new(
|
|
|
+ DEFAULT_ROWS as usize,
|
|
|
+ DEFAULT_COLS as usize,
|
|
|
+ )));
|
|
|
+ let child_exited = Arc::new(AtomicBool::new(false));
|
|
|
+
|
|
|
+ // egui context holder so the reader thread can request repaints
|
|
|
+ let ctx_holder: Arc<Mutex<Option<egui::Context>>> = Arc::new(Mutex::new(None));
|
|
|
+
|
|
|
+ // reader thread: reads pty output and feeds it through the vt parser
|
|
|
+ let grid_clone = grid.clone();
|
|
|
+ let exited_clone = child_exited.clone();
|
|
|
+ let ctx_clone = ctx_holder.clone();
|
|
|
+ thread::spawn(move || {
|
|
|
+ let mut parser = vte::Parser::new();
|
|
|
+ let mut reader = reader;
|
|
|
+ let mut buf = [0u8; 8192];
|
|
|
+ loop {
|
|
|
+ match reader.read(&mut buf) {
|
|
|
+ Ok(0) | Err(_) => {
|
|
|
+ exited_clone.store(true, Ordering::Relaxed);
|
|
|
+ if let Ok(lock) = ctx_clone.lock() {
|
|
|
+ if let Some(ctx) = lock.as_ref() {
|
|
|
+ ctx.request_repaint();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ Ok(n) => {
|
|
|
+ if let Ok(mut g) = grid_clone.lock() {
|
|
|
+ parser.advance(&mut *g, &buf[..n]);
|
|
|
+ }
|
|
|
+ if let Ok(lock) = ctx_clone.lock() {
|
|
|
+ if let Some(ctx) = lock.as_ref() {
|
|
|
+ ctx.request_repaint();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ // child reaper thread
|
|
|
+ let exited_clone2 = child_exited.clone();
|
|
|
+ thread::spawn(move || {
|
|
|
+ let _ = child.wait();
|
|
|
+ exited_clone2.store(true, Ordering::Relaxed);
|
|
|
+ });
|
|
|
+
|
|
|
+ // calculate initial window size from cell dimensions
|
|
|
+ // (rough estimate, refined on first frame)
|
|
|
+ let est_width = DEFAULT_COLS as f32 * 8.5 + 20.0;
|
|
|
+ let est_height = DEFAULT_ROWS as f32 * 18.0 + 20.0;
|
|
|
+
|
|
|
+ let options = eframe::NativeOptions {
|
|
|
+ viewport: egui::ViewportBuilder::default()
|
|
|
+ .with_title("hoardom")
|
|
|
+ .with_inner_size([est_width, est_height])
|
|
|
+ .with_min_inner_size([300.0, 200.0]),
|
|
|
+ ..Default::default()
|
|
|
+ };
|
|
|
+
|
|
|
+ eframe::run_native(
|
|
|
+ "hoardom",
|
|
|
+ options,
|
|
|
+ Box::new(move |cc| {
|
|
|
+ // store the egui context for the reader thread
|
|
|
+ if let Ok(mut holder) = ctx_holder.lock() {
|
|
|
+ *holder = Some(cc.egui_ctx.clone());
|
|
|
+ }
|
|
|
+
|
|
|
+ cc.egui_ctx.set_visuals(egui::Visuals::dark());
|
|
|
+
|
|
|
+ Ok(Box::new(HoardomApp {
|
|
|
+ grid,
|
|
|
+ pty_writer: Mutex::new(writer),
|
|
|
+ pty_master: pair.master,
|
|
|
+ child_exited,
|
|
|
+ cell_width: 0.0, // measured on first frame
|
|
|
+ cell_height: 0.0,
|
|
|
+ current_cols: DEFAULT_COLS,
|
|
|
+ current_rows: DEFAULT_ROWS,
|
|
|
+ last_mouse_button: None,
|
|
|
+ }))
|
|
|
+ }),
|
|
|
+ )
|
|
|
+}
|
