feat: use ratatui included termion

Author: kamiyaa

Cargo.lock

@@ -43,7 +43,6 @@ signal-hook = "^0"
 skim = "^0"
 strfmt = "^0"
 symphonia = { version = "^0", features = ["all"] }
-termion = "^1"
 toml = "^0"
 tracing = "^0"
 tracing-subscriber = { version = "^0", features = [ "std", "env-filter" ] }

Cargo.toml

@@ -1,11 +1,11 @@
+use ratatui::termion::event::Event;
 use serde::Deserialize;
 
 use std::collections::{hash_map::Entry, HashMap};
 use std::convert::{AsMut, AsRef, From};
 
-use termion::event::Event;
 #[cfg(feature = "mouse")]
-use termion::event::MouseEvent;
+use ratatui::termion::event::MouseEvent;
 
 use dizi::error::DiziResult;
 use dizi::request::client::ClientRequest;
@@ -118,7 +118,7 @@ fn vec_to_map(vec: &[CommandKeymap]) -> HashMap<Event, CommandKeybind> {
                     Err(e) => match e {
                         KeymapError::Conflict => {
                             let events_str: Vec<String> =
-                                events.iter().map(|e| e.to_string()).collect();
+                                events.iter().map(|event| event.to_key_string()).collect();
                             eprintln!("Error: Ambiguous Keymapping: Multiple commands mapped to key sequence {:?} {}", events_str, command_str);
                         }
                     },

src/bin/client/config/keymap/keymapping.rs

@@ -9,7 +9,7 @@ use dizi::utils;
 use crate::config;
 use crate::config::option::WidgetType;
 use crate::context::{CommandLineContext, MessageQueue, ServerState, TabContext};
-use crate::event::{AppEvent, Events};
+use crate::event::{AppEvent, AppEventListener};
 use crate::util::search::SearchPattern;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -27,7 +27,7 @@ pub struct UiContext {
 pub struct AppContext {
     pub quit: QuitType,
     // event loop querying
-    pub events: Events,
+    pub event_listener: AppEventListener,
     // server unix socket
     pub stream: UnixStream,
     pub view_widget: WidgetType,
@@ -50,7 +50,7 @@ pub struct AppContext {
 
 impl AppContext {
     pub fn new(config: config::AppConfig, _cwd: PathBuf, stream: UnixStream) -> Self {
-        let events = Events::new();
+        let events = AppEventListener::new();
 
         let mut commandline_context = CommandLineContext::new();
         commandline_context.history_mut().set_max_len(20);
@@ -60,7 +60,7 @@ impl AppContext {
             config,
             stream,
             view_widget: WidgetType::FileBrowser,
-            events,
+            event_listener: events,
             commandline_context,
             search_context: None,
             tab_context: TabContext::new(),
@@ -80,13 +80,13 @@ impl AppContext {
 
     // event related
     pub fn poll_event(&self) -> Result<AppEvent, mpsc::RecvError> {
-        self.events.next()
+        self.event_listener.next()
     }
     pub fn flush_event(&self) {
-        self.events.flush();
+        self.event_listener.flush();
     }
     pub fn clone_event_tx(&self) -> mpsc::Sender<AppEvent> {
-        self.events.event_tx.clone()
+        self.event_listener.event_tx.clone()
     }
 
     pub fn config_ref(&self) -> &config::AppConfig {

src/bin/client/context/app_context.rs

@@ -1,20 +1,20 @@
 use std::io;
 use std::path;
 use std::sync::mpsc;
+use std::sync::mpsc::Sender;
 use std::thread;
 
-use signal_hook::consts::signal;
-use signal_hook::iterator::exfiltrator::SignalOnly;
-use signal_hook::iterator::SignalsInfo;
-
-use termion::event::Event;
-use termion::input::TermRead;
+use ratatui::termion::event::Event;
 
+use crate::event::input_listener::TerminalInputListener;
+use crate::event::SignalListener;
 use crate::fs::JoshutoDirList;
 
+pub type AppEventSender = Sender<AppEvent>;
+
 #[derive(Debug)]
 pub enum AppEvent {
-    Termion(Event),
+    TerminalEvent(Event),
     // preview thread events
     PreviewDir {
         path: path::PathBuf,
@@ -24,55 +24,36 @@ pub enum AppEvent {
     Server(String),
 }
 
-#[derive(Debug, Default, Clone, Copy)]
-pub struct Config {}
-
-pub struct Events {
+pub struct AppEventListener {
     pub event_tx: mpsc::Sender<AppEvent>,
     event_rx: mpsc::Receiver<AppEvent>,
     pub input_tx: mpsc::Sender<()>,
 }
 
-impl Events {
+impl AppEventListener {
     pub fn new() -> Self {
-        Events::with_config()
+        AppEventListener::with_config()
     }
 
     pub fn with_config() -> Self {
         let (input_tx, input_rx) = mpsc::channel();
         let (event_tx, event_rx) = mpsc::channel();
 
-        // edge case that starts off the input thread
-        let _ = input_tx.send(());
-
         // signal thread
-        let event_tx2 = event_tx.clone();
+        let signal_listener = SignalListener::new(event_tx.clone());
         let _ = thread::spawn(move || {
-            let sigs = vec![signal::SIGWINCH];
-            let mut signals = SignalsInfo::<SignalOnly>::new(&sigs).unwrap();
-            for signal in &mut signals {
-                if let Err(e) = event_tx2.send(AppEvent::Signal(signal)) {
-                    eprintln!("Signal thread send err: {:#?}", e);
-                    return;
-                }
-            }
+            signal_listener.run();
         });
 
+        // edge case that starts off the input thread
+        let _ = input_tx.send(());
         // input thread
-        let event_tx2 = event_tx.clone();
+        let input_listener = TerminalInputListener::new(event_tx.clone(), input_rx);
         let _ = thread::spawn(move || {
-            let stdin = io::stdin();
-            let mut events = stdin.events();
-
-            loop {
-                let _ = input_rx.recv();
-                if let Some(Ok(event)) = events.next() {
-                    let _ = event_tx2.send(AppEvent::Termion(event));
-                }
-            }
+            input_listener.run();
         });
 
-        Events {
+        AppEventListener {
             event_tx,
             event_rx,
             input_tx,

src/bin/client/event/app_event.rs

@@ -0,0 +1,33 @@
+use std::{io, sync::mpsc::Receiver};
+
+use ratatui::termion::input::TermRead;
+
+use crate::event::{AppEvent, AppEventSender};
+
+pub type InputEventReceiver = Receiver<()>;
+
+/// Listens for terminal inputs
+#[derive(Debug)]
+pub struct TerminalInputListener {
+    pub event_tx: AppEventSender,
+    // Used to make sure we only poll for terminal input when we want to
+    pub input_rx: InputEventReceiver,
+}
+
+impl TerminalInputListener {
+    pub fn new(event_tx: AppEventSender, input_rx: InputEventReceiver) -> Self {
+        Self { event_tx, input_rx }
+    }
+
+    pub fn run(self) {
+        let stdin = io::stdin();
+        let mut events = stdin.events();
+
+        loop {
+            let _ = self.input_rx.recv();
+            if let Some(Ok(event)) = events.next() {
+                let _ = self.event_tx.send(AppEvent::TerminalEvent(event));
+            }
+        }
+    }
+}

src/bin/client/event/input_listener.rs

@@ -1,4 +1,10 @@
 pub mod app_event;
 pub mod process_event;
 
+mod input_listener;
+mod signal_listener;
+
+pub use input_listener::*;
+pub use signal_listener::*;
+
 pub use self::app_event::*;

src/bin/client/event/mod.rs

@@ -2,8 +2,8 @@ use std::io;
 use std::path;
 
 use dizi::song::DiziSongEntry;
+use ratatui::termion::event::{Event, Key};
 use signal_hook::consts::signal;
-use termion::event::{Event, Key};
 
 use dizi::error::DiziResult;
 use dizi::player::PlayerStatus;
@@ -33,7 +33,7 @@ pub fn get_input_while_composite<'a>(
 
         if let Ok(event) = context.poll_event() {
             match event {
-                AppEvent::Termion(event) => {
+                AppEvent::TerminalEvent(event) => {
                     match event {
                         Event::Key(Key::Esc) => return None,
                         event => match keymap.get(&event) {

src/bin/client/event/process_event.rs

@@ -0,0 +1,27 @@
+use signal_hook::consts::signal;
+use signal_hook::iterator::exfiltrator::SignalOnly;
+use signal_hook::iterator::SignalsInfo;
+
+use crate::event::{AppEvent, AppEventSender};
+
+#[derive(Clone, Debug)]
+pub struct SignalListener {
+    pub event_tx: AppEventSender,
+}
+
+impl SignalListener {
+    pub fn new(event_tx: AppEventSender) -> Self {
+        Self { event_tx }
+    }
+
+    pub fn run(self) {
+        let sigs = vec![signal::SIGWINCH];
+        let mut signals = SignalsInfo::<SignalOnly>::new(&sigs).unwrap();
+        for signal in &mut signals {
+            if let Err(e) = self.event_tx.send(AppEvent::Signal(signal)) {
+                eprintln!("Signal thread send err: {:#?}", e);
+                return;
+            }
+        }
+    }
+}

src/bin/client/event/signal_listener.rs

@@ -1,6 +1,6 @@
 use dizi::error::DiziResult;
 use dizi::request::client::ClientRequest;
-use termion::event::Key;
+use ratatui::termion::event::Key;
 
 use crate::config::option::WidgetType;
 use crate::config::AppKeyMapping;