Handle CPR sequence

Author: pvolok

Cargo.lock

@@ -55,7 +55,7 @@ which = "6.0.1"
 xdg = "2.5.2"
 termwiz = "0.23.3"
 bitflags = { version = "2.3.3", features = ["serde"] }
-compact_str = { version = "0.7.1", features = ["serde"] }
+compact_str = { version = "0.9.0", features = ["serde"] }
 bincode = "1.3.3"
 tokio-util = { version = "0.7.8", features = ["full"] }
 bytes = "1.5.0"

src/Cargo.toml

@@ -1,6 +1,6 @@
 use super::{
   msg::{ProcCmd, ProcEvent},
-  CopyMode, Proc,
+  CopyMode, Proc, ReplySender,
 };
 
 use std::time::Instant;
@@ -42,7 +42,7 @@ impl ProcHandle {
   }
 
   pub fn rename(&mut self, name: &str) {
-    self.name.replace_range(.., &name);
+    self.name.replace_range(.., name);
   }
 
   pub fn id(&self) -> usize {
@@ -60,7 +60,7 @@ impl ProcHandle {
         .vt
         .read()
         .map_or(ProcViewFrame::Empty, |vt| ProcViewFrame::Vt(vt)),
-      super::ProcState::Error(err) => ProcViewFrame::Err(&err),
+      super::ProcState::Error(err) => ProcViewFrame::Err(err),
     }
   }
 
@@ -131,12 +131,15 @@ impl ProcHandle {
         self.last_start = Some(Instant::now());
         self.is_up = true;
       }
+      ProcEvent::TermReply(s) => {
+        self.send(ProcCmd::SendRaw(s));
+      }
     }
   }
 }
 
 pub enum ProcViewFrame<'a> {
   Empty,
-  Vt(std::sync::RwLockReadGuard<'a, vt100::Parser>),
+  Vt(std::sync::RwLockReadGuard<'a, vt100::Parser<ReplySender>>),
   Err(&'a str),
 }

src/proc/handle.rs

@@ -9,14 +9,15 @@ use std::time::Duration;
 
 use anyhow::bail;
 use assert_matches::assert_matches;
+use compact_str::CompactString;
 use crossterm::event::{MouseButton, MouseEventKind};
 use portable_pty::MasterPty;
 use portable_pty::{native_pty_system, ChildKiller, CommandBuilder, PtySize};
 use serde::{Deserialize, Serialize};
 use tokio::sync::mpsc::UnboundedSender;
 use tokio::task::spawn_blocking;
 use tui::layout::Rect;
-use vt100::MouseProtocolMode;
+use vt100::{MouseProtocolMode, TermReplySender};
 
 use crate::config::ProcConfig;
 use crate::encode_term::{encode_key, encode_mouse_event, KeyCodeEncodeModes};
@@ -48,7 +49,7 @@ impl Debug for Inst {
   }
 }
 
-pub type VtWrap = Arc<RwLock<vt100::Parser>>;
+pub type VtWrap = Arc<RwLock<vt100::Parser<ReplySender>>>;
 
 impl Inst {
   fn spawn(
@@ -58,7 +59,15 @@ impl Inst {
     size: &Size,
     scrollback_len: usize,
   ) -> anyhow::Result<Self> {
-    let vt = vt100::Parser::new(size.height, size.width, scrollback_len);
+    let vt = vt100::Parser::new(
+      size.height,
+      size.width,
+      scrollback_len,
+      ReplySender {
+        proc_id: id,
+        sender: tx.clone(),
+      },
+    );
     let vt = Arc::new(RwLock::new(vt));
 
     let pty_system = native_pty_system();
@@ -309,7 +318,7 @@ impl Proc {
 
   pub fn lock_vt(
     &self,
-  ) -> Option<std::sync::RwLockReadGuard<'_, vt100::Parser>> {
+  ) -> Option<std::sync::RwLockReadGuard<'_, vt100::Parser<ReplySender>>> {
     match &self.inst {
       ProcState::None => None,
       ProcState::Some(inst) => inst.vt.read().ok(),
@@ -319,7 +328,7 @@ impl Proc {
 
   pub fn lock_vt_mut(
     &mut self,
-  ) -> Option<std::sync::RwLockWriteGuard<'_, vt100::Parser>> {
+  ) -> Option<std::sync::RwLockWriteGuard<'_, vt100::Parser<ReplySender>>> {
     match &self.inst {
       ProcState::None => None,
       ProcState::Some(inst) => inst.vt.write().ok(),
@@ -430,12 +439,12 @@ impl Proc {
     }
   }
 
-  fn scroll_vt_up(vt: &mut vt100::Parser, n: usize) {
+  fn scroll_vt_up(vt: &mut vt100::Parser<ReplySender>, n: usize) {
     let pos = usize::saturating_add(vt.screen().scrollback(), n);
     vt.set_scrollback(pos);
   }
 
-  fn scroll_screen_up(screen: &mut vt100::Screen, n: usize) {
+  fn scroll_screen_up(screen: &mut vt100::Screen<ReplySender>, n: usize) {
     let pos = usize::saturating_add(screen.scrollback(), n);
     screen.set_scrollback(pos);
   }
@@ -453,12 +462,12 @@ impl Proc {
     }
   }
 
-  fn scroll_vt_down(vt: &mut vt100::Parser, n: usize) {
+  fn scroll_vt_down(vt: &mut vt100::Parser<ReplySender>, n: usize) {
     let pos = usize::saturating_sub(vt.screen().scrollback(), n);
     vt.set_scrollback(pos);
   }
 
-  fn scroll_screen_down(screen: &mut vt100::Screen, n: usize) {
+  fn scroll_screen_down(screen: &mut vt100::Screen<ReplySender>, n: usize) {
     let pos = usize::saturating_sub(screen.scrollback(), n);
     screen.set_scrollback(pos);
   }
@@ -602,6 +611,13 @@ impl Proc {
 
       ProcCmd::SendKey(key) => self.send_key(&key),
       ProcCmd::SendMouse(event) => self.handle_mouse(event),
+      ProcCmd::SendRaw(s) => match &mut self.inst {
+        ProcState::None => (),
+        ProcState::Some(inst) => {
+          let _ = inst.master.write_all(s.as_bytes());
+        }
+        ProcState::Error(_) => (),
+      },
 
       ProcCmd::ScrollUp => self.scroll_half_screen_up(),
       ProcCmd::ScrollDown => self.scroll_half_screen_down(),
@@ -708,8 +724,8 @@ impl Size {
 
 pub enum CopyMode {
   None(Option<Pos>),
-  Start(vt100::Screen, Pos),
-  Range(vt100::Screen, Pos, Pos),
+  Start(vt100::Screen<ReplySender>, Pos),
+  Range(vt100::Screen<ReplySender>, Pos, Pos),
 }
 
 impl Default for CopyMode {
@@ -762,3 +778,15 @@ impl Pos {
     }
   }
 }
+
+#[derive(Clone)]
+pub struct ReplySender {
+  proc_id: usize,
+  sender: UnboundedSender<(usize, ProcEvent)>,
+}
+
+impl TermReplySender for ReplySender {
+  fn reply(&self, s: CompactString) {
+    let _ = self.sender.send((self.proc_id, ProcEvent::TermReply(s)));
+  }
+}

src/proc/mod.rs

@@ -1,3 +1,5 @@
+use compact_str::CompactString;
+
 use crate::{event::CopyMove, key::Key, mouse::MouseEvent};
 
 #[derive(Debug)]
@@ -8,6 +10,7 @@ pub enum ProcCmd {
 
   SendKey(Key),
   SendMouse(MouseEvent),
+  SendRaw(CompactString),
 
   ScrollUp,
   ScrollDown,
@@ -28,4 +31,5 @@ pub enum ProcEvent {
   Render,
   Stopped(u32),
   Started,
+  TermReply(CompactString),
 }

src/proc/msg.rs

@@ -8,7 +8,7 @@ use tui::{
 };
 
 use crate::{
-  proc::{handle::ProcViewFrame, CopyMode, Pos},
+  proc::{handle::ProcViewFrame, CopyMode, Pos, ReplySender},
   state::{Scope, State},
   theme::Theme,
 };
@@ -102,12 +102,15 @@ pub fn render_term(
 }
 
 pub struct UiTerm<'a> {
-  screen: &'a vt100::Screen,
+  screen: &'a vt100::Screen<ReplySender>,
   copy_mode: &'a CopyMode,
 }
 
 impl<'a> UiTerm<'a> {
-  pub fn new(screen: &'a vt100::Screen, copy_mode: &'a CopyMode) -> Self {
+  pub fn new(
+    screen: &'a vt100::Screen<ReplySender>,
+    copy_mode: &'a CopyMode,
+  ) -> Self {
     UiTerm { screen, copy_mode }
   }
 }

src/ui_term.rs

@@ -54,9 +54,11 @@ mod row;
 mod screen;
 mod size;
 mod term;
+mod term_reply;
 
 pub use attrs::Color;
 pub use cell::Cell;
 pub use parser::Parser;
 pub use screen::{MouseProtocolEncoding, MouseProtocolMode, Screen};
 pub use size::Size;
+pub use term_reply::TermReplySender;

vendor/vt100/src/lib.rs

@@ -1,23 +1,31 @@
 use std::sync::{Arc, Mutex};
 
+use crate::TermReplySender;
+
 /// A parser for terminal output which produces an in-memory representation of
 /// the terminal contents.
-pub struct Parser {
+pub struct Parser<Reply: TermReplySender + Clone> {
   parser: Arc<Mutex<termwiz::escape::parser::Parser>>,
-  screen: crate::screen::Screen,
+  screen: crate::screen::Screen<Reply>,
 }
 
-impl Parser {
+impl<Reply: TermReplySender + Clone> Parser<Reply> {
   /// Creates a new terminal parser of the given size and with the given
   /// amount of scrollback.
   #[must_use]
-  pub fn new(rows: u16, cols: u16, scrollback_len: usize) -> Self {
+  pub fn new(
+    rows: u16,
+    cols: u16,
+    scrollback_len: usize,
+    reply_sender: Reply,
+  ) -> Self {
     let parser = Arc::new(Mutex::new(termwiz::escape::parser::Parser::new()));
     Self {
       parser,
       screen: crate::screen::Screen::new(
         crate::grid::Size { rows, cols },
         scrollback_len,
+        reply_sender,
       ),
     }
   }
@@ -53,19 +61,12 @@ impl Parser {
   /// Returns a reference to a `Screen` object containing the terminal
   /// state.
   #[must_use]
-  pub fn screen(&self) -> &crate::screen::Screen {
+  pub fn screen(&self) -> &crate::screen::Screen<Reply> {
     &self.screen
   }
 }
 
-impl Default for Parser {
-  /// Returns a parser with dimensions 80x24 and no scrollback.
-  fn default() -> Self {
-    Self::new(24, 80, 0)
-  }
-}
-
-impl std::io::Write for Parser {
+impl<Reply: TermReplySender + Clone> std::io::Write for Parser<Reply> {
   fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
     self.process(buf);
     Ok(buf.len())