fixed async loop
This commit is contained in:
parent
2985398adc
commit
065cbcee9e
3 changed files with 137 additions and 33 deletions
1
.gitignore
vendored
1
.gitignore
vendored
|
@ -1 +1,2 @@
|
|||
target
|
||||
helix-term/rustfmt.toml
|
||||
|
|
|
@ -1,14 +1,15 @@
|
|||
use std::io::{self, stdout, Write};
|
||||
use std::path::PathBuf;
|
||||
|
||||
use crossterm::{
|
||||
cursor,
|
||||
cursor::position,
|
||||
event::{self, read, Event, KeyCode, KeyEvent},
|
||||
event::{self, read, Event, EventStream, KeyCode, KeyEvent},
|
||||
execute, queue, style,
|
||||
terminal::{self, disable_raw_mode, enable_raw_mode},
|
||||
Result,
|
||||
};
|
||||
use futures::{future::FutureExt, select, StreamExt};
|
||||
use std::io::{self, stdout, Write};
|
||||
use std::path::PathBuf;
|
||||
use std::time::Duration;
|
||||
|
||||
const HELP: &str = r#"
|
||||
- Use q to quit
|
||||
|
@ -20,40 +21,40 @@ pub struct Editor {
|
|||
}
|
||||
|
||||
impl Editor {
|
||||
pub fn read_char() -> Result<char> {
|
||||
loop {
|
||||
if let Ok(Event::Key(KeyEvent {
|
||||
code: KeyCode::Char(c),
|
||||
..
|
||||
})) = event::read()
|
||||
{
|
||||
return Ok(c);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn print_events() -> Result<()> {
|
||||
pub async fn print_events() {
|
||||
let mut reader = EventStream::new();
|
||||
loop {
|
||||
// Handle key events
|
||||
match Editor::read_char()? {
|
||||
'h' => execute!(io::stdout(), cursor::MoveLeft(1))?,
|
||||
'j' => execute!(io::stdout(), cursor::MoveDown(1))?,
|
||||
'k' => execute!(io::stdout(), cursor::MoveUp(1))?,
|
||||
'l' => execute!(io::stdout(), cursor::MoveRight(1))?,
|
||||
'q' => {
|
||||
execute!(
|
||||
io::stdout(),
|
||||
style::ResetColor,
|
||||
cursor::Show,
|
||||
terminal::LeaveAlternateScreen
|
||||
)?;
|
||||
break;
|
||||
let mut event = reader.next().await;
|
||||
match event {
|
||||
Some(Ok(x)) => {
|
||||
if let Event::Key(KeyEvent {
|
||||
code: KeyCode::Char(c),
|
||||
..
|
||||
}) = x
|
||||
{
|
||||
match c {
|
||||
'h' => execute!(io::stdout(), cursor::MoveLeft(1)).unwrap(),
|
||||
'j' => execute!(io::stdout(), cursor::MoveDown(1)).unwrap(),
|
||||
'k' => execute!(io::stdout(), cursor::MoveUp(1)).unwrap(),
|
||||
'l' => execute!(io::stdout(), cursor::MoveRight(1)).unwrap(),
|
||||
'q' => {
|
||||
execute!(
|
||||
io::stdout(),
|
||||
style::ResetColor,
|
||||
cursor::Show,
|
||||
terminal::LeaveAlternateScreen
|
||||
);
|
||||
break;
|
||||
}
|
||||
_ => println!("{:?}", x),
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => println!("use 'q' to quit."),
|
||||
Some(Err(x)) => panic!(x),
|
||||
None => break,
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn run() -> Result<()> {
|
||||
|
@ -85,6 +86,8 @@ impl Editor {
|
|||
// Send a shutdown signal.
|
||||
drop(s);
|
||||
|
||||
execute!(stdout, terminal::LeaveAlternateScreen)?;
|
||||
|
||||
// Wait for threads to finish.
|
||||
for t in threads {
|
||||
t.join().unwrap();
|
||||
|
|
100
helix-term/src/test.rs
Normal file
100
helix-term/src/test.rs
Normal file
|
@ -0,0 +1,100 @@
|
|||
//! Demonstrates how to read events asynchronously with async-std.
|
||||
//!
|
||||
//! cargo run --features="event-stream" --example event-stream-async-std
|
||||
|
||||
use std::{
|
||||
io::{stdout, Write},
|
||||
time::Duration,
|
||||
};
|
||||
|
||||
use futures::{future::FutureExt, select, StreamExt};
|
||||
use smol::Timer;
|
||||
// use futures_timer::Delay;
|
||||
|
||||
use crossterm::{
|
||||
cursor::position,
|
||||
event::{DisableMouseCapture, EnableMouseCapture, Event, EventStream, KeyCode},
|
||||
execute,
|
||||
terminal::{disable_raw_mode, enable_raw_mode},
|
||||
Result,
|
||||
};
|
||||
|
||||
const HELP: &str = r#"EventStream based on futures::Stream with async-std
|
||||
- Keyboard, mouse and terminal resize events enabled
|
||||
- Prints "." every second if there's no event
|
||||
- Hit "c" to print current cursor position
|
||||
- Use Esc to quit
|
||||
"#;
|
||||
|
||||
async fn print_events() {
|
||||
let mut reader = EventStream::new();
|
||||
|
||||
loop {
|
||||
let mut delay = Timer::after(Duration::from_millis(1_000)).fuse();
|
||||
let mut event = reader.next().fuse();
|
||||
|
||||
select! {
|
||||
_ = delay => { println!(".\r"); },
|
||||
maybe_event = event => {
|
||||
match maybe_event {
|
||||
Some(Ok(event)) => {
|
||||
println!("Event::{:?}\r", event);
|
||||
|
||||
if event == Event::Key(KeyCode::Char('c').into()) {
|
||||
println!("Cursor position: {:?}\r", position());
|
||||
|
||||
}
|
||||
|
||||
println!("test");
|
||||
|
||||
if event == Event::Key(KeyCode::Esc.into()) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Some(Err(e)) => println!("Error: {:?}\r", e),
|
||||
None => break,
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
fn main() -> Result<()> {
|
||||
println!("{}", HELP);
|
||||
|
||||
enable_raw_mode()?;
|
||||
|
||||
let mut stdout = stdout();
|
||||
execute!(stdout, EnableMouseCapture)?;
|
||||
|
||||
use std::thread;
|
||||
|
||||
// Same number of threads as there are CPU cores.
|
||||
let num_threads = num_cpus::get().max(1);
|
||||
|
||||
// A channel that sends the shutdown signal.
|
||||
let (s, r) = piper::chan::<()>(0);
|
||||
let mut threads = Vec::new();
|
||||
|
||||
// Create an executor thread pool.
|
||||
for _ in 0..num_threads {
|
||||
// Spawn an executor thread that waits for the shutdown signal.
|
||||
let r = r.clone();
|
||||
threads.push(thread::spawn(move || smol::run(r.recv())));
|
||||
}
|
||||
|
||||
// No need to `run()`, now we can just block on the main future.
|
||||
smol::block_on(print_events());
|
||||
|
||||
// Send a shutdown signal.
|
||||
drop(s);
|
||||
|
||||
// Wait for threads to finish.
|
||||
for t in threads {
|
||||
t.join().unwrap();
|
||||
}
|
||||
|
||||
execute!(stdout, DisableMouseCapture)?;
|
||||
|
||||
disable_raw_mode()
|
||||
}
|
Loading…
Reference in a new issue