337 lines
10 KiB
Rust
337 lines
10 KiB
Rust
mod chat;
|
|
mod chat2;
|
|
mod euph;
|
|
mod input;
|
|
mod rooms;
|
|
mod util;
|
|
mod util2;
|
|
mod widgets;
|
|
mod widgets2;
|
|
|
|
use std::convert::Infallible;
|
|
use std::io;
|
|
use std::sync::{Arc, Weak};
|
|
use std::time::{Duration, Instant};
|
|
|
|
use parking_lot::FairMutex;
|
|
use tokio::sync::mpsc::error::TryRecvError;
|
|
use tokio::sync::mpsc::{self, UnboundedReceiver, UnboundedSender};
|
|
use tokio::task;
|
|
use toss::widgets::BoxedAsync;
|
|
use toss::{Terminal, WidgetExt};
|
|
|
|
use crate::config::Config;
|
|
use crate::logger::{LogMsg, Logger};
|
|
use crate::macros::{logging_unwrap, ok_or_return, some_or_return};
|
|
use crate::util::InfallibleExt;
|
|
use crate::vault::Vault;
|
|
|
|
pub use self::chat2::ChatMsg;
|
|
use self::chat2::ChatState;
|
|
use self::input::{key, InputEvent, KeyBindingsList};
|
|
use self::rooms::Rooms;
|
|
use self::widgets2::ListState;
|
|
|
|
/// Time to spend batch processing events before redrawing the screen.
|
|
const EVENT_PROCESSING_TIME: Duration = Duration::from_millis(1000 / 15); // 15 fps
|
|
|
|
/// Error for anything that can go wrong while rendering.
|
|
#[derive(Debug, thiserror::Error)]
|
|
pub enum UiError {
|
|
#[error("{0}")]
|
|
Vault(#[from] vault::tokio::Error),
|
|
#[error("{0}")]
|
|
Io(#[from] io::Error),
|
|
}
|
|
|
|
impl From<Infallible> for UiError {
|
|
fn from(value: Infallible) -> Self {
|
|
Err(value).infallible()
|
|
}
|
|
}
|
|
|
|
pub enum UiEvent {
|
|
GraphemeWidthsChanged,
|
|
LogChanged,
|
|
Term(crossterm::event::Event),
|
|
Euph(euphoxide::bot::instance::Event),
|
|
}
|
|
|
|
enum EventHandleResult {
|
|
Redraw,
|
|
Continue,
|
|
Stop,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
enum Mode {
|
|
Main,
|
|
Log,
|
|
}
|
|
|
|
pub struct Ui {
|
|
event_tx: UnboundedSender<UiEvent>,
|
|
|
|
mode: Mode,
|
|
|
|
rooms: Rooms,
|
|
log_chat: ChatState<LogMsg, Logger>,
|
|
key_bindings_list: Option<ListState<Infallible>>,
|
|
}
|
|
|
|
impl Ui {
|
|
const POLL_DURATION: Duration = Duration::from_millis(100);
|
|
|
|
pub async fn run(
|
|
config: &'static Config,
|
|
terminal: &mut Terminal,
|
|
vault: Vault,
|
|
logger: Logger,
|
|
logger_rx: UnboundedReceiver<()>,
|
|
) -> anyhow::Result<()> {
|
|
let (event_tx, event_rx) = mpsc::unbounded_channel();
|
|
let crossterm_lock = Arc::new(FairMutex::new(()));
|
|
|
|
// Prepare and start crossterm event polling task
|
|
let weak_crossterm_lock = Arc::downgrade(&crossterm_lock);
|
|
let event_tx_clone = event_tx.clone();
|
|
let crossterm_event_task = task::spawn_blocking(|| {
|
|
Self::poll_crossterm_events(event_tx_clone, weak_crossterm_lock)
|
|
});
|
|
|
|
// Run main UI.
|
|
//
|
|
// If the run_main method exits at any point or if this `run` method is
|
|
// not awaited any more, the crossterm_lock Arc should be deallocated,
|
|
// meaning the crossterm_event_task will also stop after at most
|
|
// `Self::POLL_DURATION`.
|
|
//
|
|
// On the other hand, if the crossterm_event_task stops for any reason,
|
|
// the rest of the UI is also shut down and the client stops.
|
|
let mut ui = Self {
|
|
event_tx: event_tx.clone(),
|
|
mode: Mode::Main,
|
|
rooms: Rooms::new(config, vault, event_tx.clone()).await,
|
|
log_chat: ChatState::new(logger),
|
|
key_bindings_list: None,
|
|
};
|
|
tokio::select! {
|
|
e = ui.run_main(terminal, event_rx, crossterm_lock) => e?,
|
|
_ = Self::update_on_log_event(logger_rx, &event_tx) => (),
|
|
e = crossterm_event_task => e??,
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn poll_crossterm_events(
|
|
tx: UnboundedSender<UiEvent>,
|
|
lock: Weak<FairMutex<()>>,
|
|
) -> crossterm::Result<()> {
|
|
loop {
|
|
let lock = some_or_return!(lock.upgrade(), Ok(()));
|
|
let _guard = lock.lock();
|
|
if crossterm::event::poll(Self::POLL_DURATION)? {
|
|
let event = crossterm::event::read()?;
|
|
ok_or_return!(tx.send(UiEvent::Term(event)), Ok(()));
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn update_on_log_event(
|
|
mut logger_rx: UnboundedReceiver<()>,
|
|
event_tx: &UnboundedSender<UiEvent>,
|
|
) {
|
|
loop {
|
|
some_or_return!(logger_rx.recv().await);
|
|
ok_or_return!(event_tx.send(UiEvent::LogChanged));
|
|
}
|
|
}
|
|
|
|
async fn run_main(
|
|
&mut self,
|
|
terminal: &mut Terminal,
|
|
mut event_rx: UnboundedReceiver<UiEvent>,
|
|
crossterm_lock: Arc<FairMutex<()>>,
|
|
) -> Result<(), UiError> {
|
|
let mut redraw = true;
|
|
|
|
loop {
|
|
// Redraw if necessary
|
|
if redraw {
|
|
redraw = false;
|
|
terminal.present_async_widget(self.widget().await).await?;
|
|
|
|
if terminal.measuring_required() {
|
|
let _guard = crossterm_lock.lock();
|
|
terminal.measure_widths()?;
|
|
ok_or_return!(self.event_tx.send(UiEvent::GraphemeWidthsChanged), Ok(()));
|
|
}
|
|
}
|
|
|
|
// Handle events (in batches)
|
|
let mut event = match event_rx.recv().await {
|
|
Some(event) => event,
|
|
None => return Ok(()),
|
|
};
|
|
let end_time = Instant::now() + EVENT_PROCESSING_TIME;
|
|
loop {
|
|
match self.handle_event(terminal, &crossterm_lock, event).await {
|
|
EventHandleResult::Redraw => redraw = true,
|
|
EventHandleResult::Continue => {}
|
|
EventHandleResult::Stop => return Ok(()),
|
|
}
|
|
if Instant::now() >= end_time {
|
|
break;
|
|
}
|
|
event = match event_rx.try_recv() {
|
|
Ok(event) => event,
|
|
Err(TryRecvError::Empty) => break,
|
|
Err(TryRecvError::Disconnected) => return Ok(()),
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn widget(&mut self) -> BoxedAsync<'_, UiError> {
|
|
let key_bindings_list = if self.key_bindings_list.is_some() {
|
|
let mut bindings = KeyBindingsList::new();
|
|
self.list_key_bindings(&mut bindings).await;
|
|
Some(bindings)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let widget = match self.mode {
|
|
Mode::Main => self.rooms.widget().await,
|
|
Mode::Log => self.log_chat.widget(String::new(), true),
|
|
};
|
|
|
|
if let Some(key_bindings_list) = key_bindings_list {
|
|
// We checked whether this was Some earlier.
|
|
let list_state = self.key_bindings_list.as_mut().unwrap();
|
|
|
|
key_bindings_list
|
|
.widget(list_state)
|
|
.above(widget)
|
|
.boxed_async()
|
|
} else {
|
|
widget
|
|
}
|
|
}
|
|
|
|
fn show_key_bindings(&mut self) {
|
|
if self.key_bindings_list.is_none() {
|
|
self.key_bindings_list = Some(ListState::new())
|
|
}
|
|
}
|
|
|
|
async fn list_key_bindings(&self, bindings: &mut KeyBindingsList) {
|
|
bindings.binding("ctrl+c", "quit cove");
|
|
bindings.binding("F1, ?", "show this menu");
|
|
bindings.binding("F12", "toggle log");
|
|
bindings.empty();
|
|
match self.mode {
|
|
Mode::Main => self.rooms.list_key_bindings(bindings).await,
|
|
Mode::Log => self.log_chat.list_key_bindings(bindings, false).await,
|
|
}
|
|
}
|
|
|
|
async fn handle_event(
|
|
&mut self,
|
|
terminal: &mut Terminal,
|
|
crossterm_lock: &Arc<FairMutex<()>>,
|
|
event: UiEvent,
|
|
) -> EventHandleResult {
|
|
match event {
|
|
UiEvent::GraphemeWidthsChanged => EventHandleResult::Redraw,
|
|
UiEvent::LogChanged if self.mode == Mode::Log => EventHandleResult::Redraw,
|
|
UiEvent::LogChanged => EventHandleResult::Continue,
|
|
UiEvent::Term(crossterm::event::Event::Resize(_, _)) => EventHandleResult::Redraw,
|
|
UiEvent::Term(event) => {
|
|
self.handle_term_event(terminal, crossterm_lock, event)
|
|
.await
|
|
}
|
|
UiEvent::Euph(event) => {
|
|
if self.rooms.handle_euph_event(event).await {
|
|
EventHandleResult::Redraw
|
|
} else {
|
|
EventHandleResult::Continue
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn handle_term_event(
|
|
&mut self,
|
|
terminal: &mut Terminal,
|
|
crossterm_lock: &Arc<FairMutex<()>>,
|
|
event: crossterm::event::Event,
|
|
) -> EventHandleResult {
|
|
let event = some_or_return!(InputEvent::from_event(event), EventHandleResult::Continue);
|
|
|
|
if let key!(Ctrl + 'c') = event {
|
|
// Exit unconditionally on ctrl+c. Previously, shift+q would also
|
|
// unconditionally exit, but that interfered with typing text in
|
|
// inline editors.
|
|
return EventHandleResult::Stop;
|
|
}
|
|
|
|
// Key bindings list overrides any other bindings if visible
|
|
if let Some(key_bindings_list) = &mut self.key_bindings_list {
|
|
match event {
|
|
key!(Esc) | key!(F 1) | key!('?') => self.key_bindings_list = None,
|
|
key!('k') | key!(Up) => key_bindings_list.scroll_up(1),
|
|
key!('j') | key!(Down) => key_bindings_list.scroll_down(1),
|
|
_ => return EventHandleResult::Continue,
|
|
}
|
|
return EventHandleResult::Redraw;
|
|
}
|
|
|
|
match event {
|
|
key!(F 1) => {
|
|
self.key_bindings_list = Some(ListState::new());
|
|
return EventHandleResult::Redraw;
|
|
}
|
|
key!(F 12) => {
|
|
self.mode = match self.mode {
|
|
Mode::Main => Mode::Log,
|
|
Mode::Log => Mode::Main,
|
|
};
|
|
return EventHandleResult::Redraw;
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
let mut handled = match self.mode {
|
|
Mode::Main => {
|
|
self.rooms
|
|
.handle_input_event(terminal, crossterm_lock, &event)
|
|
.await
|
|
}
|
|
Mode::Log => {
|
|
let reaction = self
|
|
.log_chat
|
|
.handle_input_event(terminal, crossterm_lock, &event, false)
|
|
.await;
|
|
let reaction = logging_unwrap!(reaction);
|
|
reaction.handled()
|
|
}
|
|
};
|
|
|
|
// Pressing '?' should only open the key bindings list if it doesn't
|
|
// interfere with any part of the main UI, such as entering text in a
|
|
// text editor.
|
|
if !handled {
|
|
if let key!('?') = event {
|
|
self.show_key_bindings();
|
|
handled = true;
|
|
}
|
|
}
|
|
|
|
if handled {
|
|
EventHandleResult::Redraw
|
|
} else {
|
|
EventHandleResult::Continue
|
|
}
|
|
}
|
|
}
|