use crate::{
Pager, PagerState,
error::MinusError,
hooks::Hook,
input::InputEvent,
minus_core::{
RunMode,
commands::Command,
ev_handler::handle_event,
utils::{display::draw_full, term},
},
};
use crossbeam_channel::{Receiver, Sender, TrySendError};
use crossterm::event;
use std::{
io::Write,
panic,
sync::{
Arc,
atomic::{AtomicBool, Ordering},
},
};
#[cfg(not(test))]
use std::io::stdout;
#[cfg(feature = "search")]
use parking_lot::Condvar;
use parking_lot::Mutex;
use super::{CommandQueue, RUNMODE, utils::display::draw_for_change};
#[allow(clippy::module_name_repetitions)]
#[allow(clippy::too_many_lines)]
pub fn init_core(
pager: &Pager,
rm: RunMode,
use_alternate_screen: bool,
) -> std::result::Result<(), MinusError> {
#[cfg(not(test))]
let mut out = stdout();
#[cfg(test)]
let mut out = Vec::new();
#[cfg(feature = "search")]
let input_thread_running = Arc::new((Mutex::new(true), Condvar::new()));
assert_eq!(
*super::RUNMODE.lock(),
RunMode::Uninitialized,
"Failed to set the RUNMODE. This is caused probably because another instance of minus is already running"
);
#[allow(unused_mut)]
let mut ps = crate::state::PagerState::generate_initial_state(&pager.rx)?;
*super::RUNMODE.lock() = rm;
ps.run_hooks(Hook::PrePagerStart);
#[cfg(all(feature = "static_output", not(test)))]
if *RUNMODE.lock() == RunMode::Static {
use {super::utils::display::write_raw_lines, crossterm::tty::IsTty};
if !out.is_tty() {
write_raw_lines(&mut out, &[ps.screen.orig_text], None)?;
*RUNMODE.lock() = RunMode::Uninitialized;
return Ok(());
}
if ps.screen.formatted_lines_count() <= ps.rows && !ps.run_no_overflow {
write_raw_lines(&mut out, &ps.screen.formatted_lines, Some("\r"))?;
ps.exit();
*RUNMODE.lock() = RunMode::Uninitialized;
return Ok(());
}
}
#[cfg(not(test))]
term::setup(&mut out, use_alternate_screen)?;
let is_exited = Arc::new(AtomicBool::new(false));
let is_exited2 = is_exited.clone();
{
let panic_hook = panic::take_hook();
panic::set_hook(Box::new(move |pinfo| {
is_exited2.store(true, std::sync::atomic::Ordering::SeqCst);
#[cfg(test)]
let mut out2 = Vec::new();
#[cfg(not(test))]
let mut out2 = stdout();
drop(term::cleanup(&mut out2, true, use_alternate_screen));
panic_hook(pinfo);
}));
}
let ps_mutex = Arc::new(Mutex::new(ps));
let evtx = pager.tx.clone();
let rx = pager.rx.clone();
let p1 = ps_mutex.clone();
#[cfg(feature = "search")]
let input_thread_running2 = input_thread_running.clone();
std::thread::scope(|s| -> crate::Result {
let is_exited3 = is_exited.clone();
let is_exited4 = is_exited.clone();
#[cfg(test)]
let mut out2 = Vec::new();
#[cfg(not(test))]
let mut out2 = stdout();
let t1 = s.spawn(move || {
let res = event_reader(
&evtx,
&p1,
#[cfg(feature = "search")]
&input_thread_running2,
&is_exited3,
);
if res.is_err() {
is_exited3.store(true, std::sync::atomic::Ordering::SeqCst);
}
res
});
let t2 = s.spawn(move || {
let res = start_reactor(
&rx,
&ps_mutex,
&mut out2,
#[cfg(feature = "search")]
pager,
#[cfg(feature = "search")]
&input_thread_running,
&is_exited4,
use_alternate_screen,
);
if res.is_err() {
is_exited4.store(true, std::sync::atomic::Ordering::SeqCst);
}
res
});
let r1 = t1.join().unwrap();
let r2 = t2.join().unwrap();
if r1.is_err() || r2.is_err() {
*RUNMODE.lock() = RunMode::Uninitialized;
term::cleanup(&mut out, true, use_alternate_screen)?;
}
r1?;
r2?;
Ok(())
})
}
#[allow(clippy::too_many_lines)]
fn start_reactor(
rx: &Receiver<Command>,
ps: &Arc<Mutex<PagerState>>,
mut out_lock: impl Write,
#[cfg(feature = "search")] pager: &Pager,
#[cfg(feature = "search")] input_thread_running: &Arc<(Mutex<bool>, Condvar)>,
is_exited: &Arc<AtomicBool>,
use_alternate_screen: bool,
) -> Result<(), MinusError> {
let mut command_queue = CommandQueue::new();
{
let mut p = ps.lock();
draw_full(&mut out_lock, &mut p)?;
p.run_hooks(Hook::PostPagerStart);
if p.follow_output {
draw_for_change(&mut out_lock, &mut p, &mut (usize::MAX - 1))?;
}
}
let run_mode = *RUNMODE.lock();
match run_mode {
#[cfg(feature = "dynamic_output")]
RunMode::Dynamic => loop {
if is_exited.load(Ordering::SeqCst) {
term::cleanup(&mut out_lock, true, use_alternate_screen)?;
ps.lock().run_hooks(Hook::PostPagerExit);
let mut rm = RUNMODE.lock();
*rm = RunMode::Uninitialized;
drop(rm);
break;
}
let next_command = if command_queue.is_empty() {
rx.recv()
} else {
Ok(command_queue.pop_front().unwrap())
};
let mut p = ps.lock();
if let Ok(Command::Io(ic)) = next_command {
use crate::minus_core::ev_handler::handle_io_command;
handle_io_command(
ic,
&mut out_lock,
&mut p,
&mut command_queue,
#[cfg(feature = "search")]
pager,
#[cfg(feature = "search")]
input_thread_running,
)?;
} else if let Ok(command) = next_command {
handle_event(command, &mut p, &mut command_queue, is_exited)?;
}
},
#[cfg(feature = "static_output")]
RunMode::Static => loop {
if is_exited.load(Ordering::SeqCst) {
term::cleanup(&mut out_lock, true, use_alternate_screen)?;
ps.lock().run_hooks(Hook::PostPagerExit);
let mut rm = RUNMODE.lock();
*rm = RunMode::Uninitialized;
drop(rm);
break;
}
let next_command = if command_queue.is_empty() {
rx.recv()
} else {
Ok(command_queue.pop_front().unwrap())
};
let mut p = ps.lock();
if let Ok(Command::Io(ic)) = next_command {
use crate::minus_core::ev_handler::handle_io_command;
handle_io_command(
ic,
&mut out_lock,
&mut p,
&mut command_queue,
#[cfg(feature = "search")]
pager,
#[cfg(feature = "search")]
input_thread_running,
)?;
} else if let Ok(command) = next_command {
handle_event(command, &mut p, &mut command_queue, is_exited)?;
}
},
RunMode::Uninitialized => panic!(
"Static variable RUNMODE set to uninitialized.\
This is most likely a bug. Please open an issue to the developers"
),
}
Ok(())
}
fn event_reader(
evtx: &Sender<Command>,
ps: &Arc<Mutex<PagerState>>,
#[cfg(feature = "search")] user_input_active: &Arc<(Mutex<bool>, Condvar)>,
is_exited: &Arc<AtomicBool>,
) -> Result<(), MinusError> {
loop {
if is_exited.load(Ordering::SeqCst) {
break;
}
#[cfg(feature = "search")]
{
let (lock, cvar) = (&user_input_active.0, &user_input_active.1);
cvar.wait_while(&mut lock.lock(), |pending| !*pending);
}
if event::poll(std::time::Duration::from_millis(100))
.map_err(|e| MinusError::HandleEvent(e.into()))?
{
let ev = event::read().map_err(|e| MinusError::HandleEvent(e.into()))?;
if !dispatch_input_event(
ev,
evtx,
ps,
#[cfg(feature = "search")]
user_input_active,
)? {
break;
}
}
}
Result::<(), MinusError>::Ok(())
}
fn dispatch_input_event(
ev: event::Event,
evtx: &Sender<Command>,
ps: &Arc<Mutex<PagerState>>,
#[cfg(feature = "search")] user_input_active: &Arc<(Mutex<bool>, Condvar)>,
) -> Result<bool, MinusError> {
let mut guard = ps.lock();
let input = guard.input_classifier.classify_input(ev, &guard);
if !matches!(&input, Some(InputEvent::Number(_))) {
guard.prefix_num.clear();
guard.format_prompt()?;
}
drop(guard);
if let Some(input) = input {
#[cfg(feature = "search")]
if matches!(&input, InputEvent::Search(_)) {
*user_input_active.0.lock() = false;
}
if let Err(TrySendError::Disconnected(_)) = evtx.try_send(Command::UserInput(input)) {
return Ok(false);
}
}
Ok(true)
}
#[cfg(all(test, feature = "search"))]
mod tests {
use super::dispatch_input_event;
use crate::{PagerState, SearchMode, input::InputEvent, minus_core::commands::Command};
use crossbeam_channel::unbounded;
use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
use parking_lot::{Condvar, Mutex};
use std::sync::Arc;
#[test]
fn search_pauses_the_general_event_reader_before_queueing() {
let (tx, rx) = unbounded();
let state = Arc::new(Mutex::new(PagerState::new().unwrap()));
let input_active = Arc::new((Mutex::new(true), Condvar::new()));
let connected = dispatch_input_event(
Event::Key(KeyEvent::new(KeyCode::Char('/'), KeyModifiers::NONE)),
&tx,
&state,
&input_active,
)
.unwrap();
assert!(connected);
assert!(!*input_active.0.lock());
assert!(matches!(
rx.try_recv(),
Ok(Command::UserInput(InputEvent::Search(SearchMode::Forward)))
));
}
}