Fix up vendor for... linux?

vendor/crossterm/examples/README.md

@@ -1,40 +1,40 @@
-![Lines of Code][s7] [![MIT][s2]][l2] [![Join us on Discord][s5]][l5]
-
-# Crossterm Examples
-
-The examples are compatible with the latest release.  
-
-## Structure
-
-```
-├── examples
-│   └── interactive-test
-│   └── event-*
-│   └── stderr
-```
-| File Name                   | Description                    | Topics                                    |
-|:----------------------------|:-------------------------------|:------------------------------------------|
-| `examples/interactive-test` | interactive, walk through, demo | cursor, style, event                      |
-| `event-*`                   | event reading demos            | (async) event reading                     |
-| `stderr`                    | crossterm over stderr demo     | raw mode, alternate screen, custom output |
-| `is_tty`                    | Is this instance a tty ?       | tty                                       |
-
-## Run examples
-
-```bash
-$ cargo run --example [file name]
-```
-
-To run the interactive-demo go into the folder `examples/interactive-demo` and run `cargo run`.
-
-## License
-
-This project is licensed under the MIT License - see the [LICENSE.md](LICENSE) file for details.
-
-[s2]: https://img.shields.io/badge/license-MIT-blue.svg
-[l2]: LICENSE
-
-[s5]: https://img.shields.io/discord/560857607196377088.svg?logo=discord
-[l5]: https://discord.gg/K4nyTDB
-
-[s7]: https://travis-ci.org/crossterm-rs/examples.svg?branch=master
+![Lines of Code][s7] [![MIT][s2]][l2] [![Join us on Discord][s5]][l5]
+
+# Crossterm Examples
+
+The examples are compatible with the latest release.  
+
+## Structure
+
+```
+├── examples
+│   └── interactive-test
+│   └── event-*
+│   └── stderr
+```
+| File Name                   | Description                    | Topics                                    |
+|:----------------------------|:-------------------------------|:------------------------------------------|
+| `examples/interactive-test` | interactive, walk through, demo | cursor, style, event                      |
+| `event-*`                   | event reading demos            | (async) event reading                     |
+| `stderr`                    | crossterm over stderr demo     | raw mode, alternate screen, custom output |
+| `is_tty`                    | Is this instance a tty ?       | tty                                       |
+
+## Run examples
+
+```bash
+$ cargo run --example [file name]
+```
+
+To run the interactive-demo go into the folder `examples/interactive-demo` and run `cargo run`.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE.md](LICENSE) file for details.
+
+[s2]: https://img.shields.io/badge/license-MIT-blue.svg
+[l2]: LICENSE
+
+[s5]: https://img.shields.io/discord/560857607196377088.svg?logo=discord
+[l5]: https://discord.gg/K4nyTDB
+
+[s7]: https://travis-ci.org/crossterm-rs/examples.svg?branch=master

vendor/crossterm/examples/event-match-modifiers.rs

@@ -1,68 +1,68 @@
-//! Demonstrates how to match on modifiers like: Control, alt, shift.
-//!
-//! cargo run --example event-match-modifiers
-
-use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
-
-fn match_event(read_event: Event) {
-    match read_event {
-        // Match one one modifier:
-        Event::Key(KeyEvent {
-            modifiers: KeyModifiers::CONTROL,
-            code,
-            ..
-        }) => {
-            println!("Control + {:?}", code);
-        }
-        Event::Key(KeyEvent {
-            modifiers: KeyModifiers::SHIFT,
-            code,
-            ..
-        }) => {
-            println!("Shift + {:?}", code);
-        }
-        Event::Key(KeyEvent {
-            modifiers: KeyModifiers::ALT,
-            code,
-            ..
-        }) => {
-            println!("Alt + {:?}", code);
-        }
-
-        // Match on multiple modifiers:
-        Event::Key(KeyEvent {
-            code, modifiers, ..
-        }) => {
-            if modifiers == (KeyModifiers::ALT | KeyModifiers::SHIFT) {
-                println!("Alt + Shift {:?}", code);
-            } else {
-                println!("({:?}) with key: {:?}", modifiers, code)
-            }
-        }
-
-        _ => {}
-    }
-}
-
-fn main() {
-    match_event(Event::Key(KeyEvent::new(
-        KeyCode::Char('z'),
-        KeyModifiers::CONTROL,
-    )));
-    match_event(Event::Key(KeyEvent::new(
-        KeyCode::Left,
-        KeyModifiers::SHIFT,
-    )));
-    match_event(Event::Key(KeyEvent::new(
-        KeyCode::Delete,
-        KeyModifiers::ALT,
-    )));
-    match_event(Event::Key(KeyEvent::new(
-        KeyCode::Right,
-        KeyModifiers::ALT | KeyModifiers::SHIFT,
-    )));
-    match_event(Event::Key(KeyEvent::new(
-        KeyCode::Home,
-        KeyModifiers::ALT | KeyModifiers::CONTROL,
-    )));
-}
+//! Demonstrates how to match on modifiers like: Control, alt, shift.
+//!
+//! cargo run --example event-match-modifiers
+
+use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
+
+fn match_event(read_event: Event) {
+    match read_event {
+        // Match one one modifier:
+        Event::Key(KeyEvent {
+            modifiers: KeyModifiers::CONTROL,
+            code,
+            ..
+        }) => {
+            println!("Control + {:?}", code);
+        }
+        Event::Key(KeyEvent {
+            modifiers: KeyModifiers::SHIFT,
+            code,
+            ..
+        }) => {
+            println!("Shift + {:?}", code);
+        }
+        Event::Key(KeyEvent {
+            modifiers: KeyModifiers::ALT,
+            code,
+            ..
+        }) => {
+            println!("Alt + {:?}", code);
+        }
+
+        // Match on multiple modifiers:
+        Event::Key(KeyEvent {
+            code, modifiers, ..
+        }) => {
+            if modifiers == (KeyModifiers::ALT | KeyModifiers::SHIFT) {
+                println!("Alt + Shift {:?}", code);
+            } else {
+                println!("({:?}) with key: {:?}", modifiers, code)
+            }
+        }
+
+        _ => {}
+    }
+}
+
+fn main() {
+    match_event(Event::Key(KeyEvent::new(
+        KeyCode::Char('z'),
+        KeyModifiers::CONTROL,
+    )));
+    match_event(Event::Key(KeyEvent::new(
+        KeyCode::Left,
+        KeyModifiers::SHIFT,
+    )));
+    match_event(Event::Key(KeyEvent::new(
+        KeyCode::Delete,
+        KeyModifiers::ALT,
+    )));
+    match_event(Event::Key(KeyEvent::new(
+        KeyCode::Right,
+        KeyModifiers::ALT | KeyModifiers::SHIFT,
+    )));
+    match_event(Event::Key(KeyEvent::new(
+        KeyCode::Home,
+        KeyModifiers::ALT | KeyModifiers::CONTROL,
+    )));
+}

vendor/crossterm/examples/event-poll-read.rs

@@ -1,62 +1,62 @@
-//! Demonstrates how to match on modifiers like: Control, alt, shift.
-//!
-//! cargo run --example event-poll-read
-
-use std::{io::stdout, time::Duration};
-
-use crossterm::{
-    cursor::position,
-    event::{poll, read, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode},
-    Result,
-};
-
-const HELP: &str = r#"Blocking poll() & non-blocking read()
- - 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
-"#;
-
-fn print_events() -> Result<()> {
-    loop {
-        // Wait up to 1s for another event
-        if poll(Duration::from_millis(1_000))? {
-            // It's guaranteed that read() won't block if `poll` returns `Ok(true)`
-            let event = read()?;
-
-            println!("Event::{:?}\r", event);
-
-            if event == Event::Key(KeyCode::Char('c').into()) {
-                println!("Cursor position: {:?}\r", position());
-            }
-
-            if event == Event::Key(KeyCode::Esc.into()) {
-                break;
-            }
-        } else {
-            // Timeout expired, no event for 1s
-            println!(".\r");
-        }
-    }
-
-    Ok(())
-}
-
-fn main() -> Result<()> {
-    println!("{}", HELP);
-
-    enable_raw_mode()?;
-
-    let mut stdout = stdout();
-    execute!(stdout, EnableMouseCapture)?;
-
-    if let Err(e) = print_events() {
-        println!("Error: {:?}\r", e);
-    }
-
-    execute!(stdout, DisableMouseCapture)?;
-
-    disable_raw_mode()
-}
+//! Demonstrates how to match on modifiers like: Control, alt, shift.
+//!
+//! cargo run --example event-poll-read
+
+use std::{io::stdout, time::Duration};
+
+use crossterm::{
+    cursor::position,
+    event::{poll, read, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
+    execute,
+    terminal::{disable_raw_mode, enable_raw_mode},
+    Result,
+};
+
+const HELP: &str = r#"Blocking poll() & non-blocking read()
+ - 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
+"#;
+
+fn print_events() -> Result<()> {
+    loop {
+        // Wait up to 1s for another event
+        if poll(Duration::from_millis(1_000))? {
+            // It's guaranteed that read() won't block if `poll` returns `Ok(true)`
+            let event = read()?;
+
+            println!("Event::{:?}\r", event);
+
+            if event == Event::Key(KeyCode::Char('c').into()) {
+                println!("Cursor position: {:?}\r", position());
+            }
+
+            if event == Event::Key(KeyCode::Esc.into()) {
+                break;
+            }
+        } else {
+            // Timeout expired, no event for 1s
+            println!(".\r");
+        }
+    }
+
+    Ok(())
+}
+
+fn main() -> Result<()> {
+    println!("{}", HELP);
+
+    enable_raw_mode()?;
+
+    let mut stdout = stdout();
+    execute!(stdout, EnableMouseCapture)?;
+
+    if let Err(e) = print_events() {
+        println!("Error: {:?}\r", e);
+    }
+
+    execute!(stdout, DisableMouseCapture)?;
+
+    disable_raw_mode()
+}

vendor/crossterm/examples/event-read-char-line.rs

@@ -1,45 +1,45 @@
-//! Demonstrates how to block read characters or a full line.
-//! Just note that crossterm is not required to do this and can be done with `io::stdin()`.
-//!
-//! cargo run --example event-read-char-line
-
-use crossterm::{
-    event::{self, Event, KeyCode, KeyEvent},
-    Result,
-};
-
-pub fn read_char() -> Result<char> {
-    loop {
-        if let Event::Key(KeyEvent {
-            code: KeyCode::Char(c),
-            ..
-        }) = event::read()?
-        {
-            return Ok(c);
-        }
-    }
-}
-
-pub fn read_line() -> Result<String> {
-    let mut line = String::new();
-    while let Event::Key(KeyEvent { code, .. }) = event::read()? {
-        match code {
-            KeyCode::Enter => {
-                break;
-            }
-            KeyCode::Char(c) => {
-                line.push(c);
-            }
-            _ => {}
-        }
-    }
-
-    Ok(line)
-}
-
-fn main() {
-    println!("read line:");
-    println!("{:?}", read_line());
-    println!("read char:");
-    println!("{:?}", read_char());
-}
+//! Demonstrates how to block read characters or a full line.
+//! Just note that crossterm is not required to do this and can be done with `io::stdin()`.
+//!
+//! cargo run --example event-read-char-line
+
+use crossterm::{
+    event::{self, Event, KeyCode, KeyEvent},
+    Result,
+};
+
+pub fn read_char() -> Result<char> {
+    loop {
+        if let Event::Key(KeyEvent {
+            code: KeyCode::Char(c),
+            ..
+        }) = event::read()?
+        {
+            return Ok(c);
+        }
+    }
+}
+
+pub fn read_line() -> Result<String> {
+    let mut line = String::new();
+    while let Event::Key(KeyEvent { code, .. }) = event::read()? {
+        match code {
+            KeyCode::Enter => {
+                break;
+            }
+            KeyCode::Char(c) => {
+                line.push(c);
+            }
+            _ => {}
+        }
+    }
+
+    Ok(line)
+}
+
+fn main() {
+    println!("read line:");
+    println!("{:?}", read_line());
+    println!("read char:");
+    println!("{:?}", read_char());
+}

vendor/crossterm/examples/event-read.rs

@@ -1,97 +1,97 @@
-//! Demonstrates how to block read events.
-//!
-//! cargo run --example event-read
-
-use std::io::stdout;
-
-use crossterm::event::{
-    poll, KeyboardEnhancementFlags, PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
-};
-use crossterm::{
-    cursor::position,
-    event::{
-        read, DisableBracketedPaste, DisableFocusChange, DisableMouseCapture, EnableBracketedPaste,
-        EnableFocusChange, EnableMouseCapture, Event, KeyCode,
-    },
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode},
-    Result,
-};
-use std::time::Duration;
-
-const HELP: &str = r#"Blocking read()
- - Keyboard, mouse, focus and terminal resize events enabled
- - Hit "c" to print current cursor position
- - Use Esc to quit
-"#;
-
-fn print_events() -> Result<()> {
-    loop {
-        // Blocking read
-        let event = read()?;
-
-        println!("Event: {:?}\r", event);
-
-        if event == Event::Key(KeyCode::Char('c').into()) {
-            println!("Cursor position: {:?}\r", position());
-        }
-
-        if let Event::Resize(x, y) = event {
-            let (original_size, new_size) = flush_resize_events((x, y));
-            println!("Resize from: {:?}, to: {:?}\r", original_size, new_size);
-        }
-
-        if event == Event::Key(KeyCode::Esc.into()) {
-            break;
-        }
-    }
-
-    Ok(())
-}
-
-// Resize events can occur in batches.
-// With a simple loop they can be flushed.
-// This function will keep the first and last resize event.
-fn flush_resize_events(first_resize: (u16, u16)) -> ((u16, u16), (u16, u16)) {
-    let mut last_resize = first_resize;
-    while let Ok(true) = poll(Duration::from_millis(50)) {
-        if let Ok(Event::Resize(x, y)) = read() {
-            last_resize = (x, y);
-        }
-    }
-
-    return (first_resize, last_resize);
-}
-
-fn main() -> Result<()> {
-    println!("{}", HELP);
-
-    enable_raw_mode()?;
-
-    let mut stdout = stdout();
-    execute!(
-        stdout,
-        EnableBracketedPaste,
-        EnableFocusChange,
-        EnableMouseCapture,
-        PushKeyboardEnhancementFlags(
-            KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES
-                | KeyboardEnhancementFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES
-                | KeyboardEnhancementFlags::REPORT_EVENT_TYPES
-        )
-    )?;
-
-    if let Err(e) = print_events() {
-        println!("Error: {:?}\r", e);
-    }
-
-    execute!(
-        stdout,
-        DisableBracketedPaste,
-        PopKeyboardEnhancementFlags,
-        DisableFocusChange,
-        DisableMouseCapture
-    )?;
-
-    disable_raw_mode()
-}
+//! Demonstrates how to block read events.
+//!
+//! cargo run --example event-read
+
+use std::io::stdout;
+
+use crossterm::event::{
+    poll, KeyboardEnhancementFlags, PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
+};
+use crossterm::{
+    cursor::position,
+    event::{
+        read, DisableBracketedPaste, DisableFocusChange, DisableMouseCapture, EnableBracketedPaste,
+        EnableFocusChange, EnableMouseCapture, Event, KeyCode,
+    },
+    execute,
+    terminal::{disable_raw_mode, enable_raw_mode},
+    Result,
+};
+use std::time::Duration;
+
+const HELP: &str = r#"Blocking read()
+ - Keyboard, mouse, focus and terminal resize events enabled
+ - Hit "c" to print current cursor position
+ - Use Esc to quit
+"#;
+
+fn print_events() -> Result<()> {
+    loop {
+        // Blocking read
+        let event = read()?;
+
+        println!("Event: {:?}\r", event);
+
+        if event == Event::Key(KeyCode::Char('c').into()) {
+            println!("Cursor position: {:?}\r", position());
+        }
+
+        if let Event::Resize(x, y) = event {
+            let (original_size, new_size) = flush_resize_events((x, y));
+            println!("Resize from: {:?}, to: {:?}\r", original_size, new_size);
+        }
+
+        if event == Event::Key(KeyCode::Esc.into()) {
+            break;
+        }
+    }
+
+    Ok(())
+}
+
+// Resize events can occur in batches.
+// With a simple loop they can be flushed.
+// This function will keep the first and last resize event.
+fn flush_resize_events(first_resize: (u16, u16)) -> ((u16, u16), (u16, u16)) {
+    let mut last_resize = first_resize;
+    while let Ok(true) = poll(Duration::from_millis(50)) {
+        if let Ok(Event::Resize(x, y)) = read() {
+            last_resize = (x, y);
+        }
+    }
+
+    return (first_resize, last_resize);
+}
+
+fn main() -> Result<()> {
+    println!("{}", HELP);
+
+    enable_raw_mode()?;
+
+    let mut stdout = stdout();
+    execute!(
+        stdout,
+        EnableBracketedPaste,
+        EnableFocusChange,
+        EnableMouseCapture,
+        PushKeyboardEnhancementFlags(
+            KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES
+                | KeyboardEnhancementFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES
+                | KeyboardEnhancementFlags::REPORT_EVENT_TYPES
+        )
+    )?;
+
+    if let Err(e) = print_events() {
+        println!("Error: {:?}\r", e);
+    }
+
+    execute!(
+        stdout,
+        DisableBracketedPaste,
+        PopKeyboardEnhancementFlags,
+        DisableFocusChange,
+        DisableMouseCapture
+    )?;
+
+    disable_raw_mode()
+}

vendor/crossterm/examples/event-stream-async-std.rs

@@ -1,68 +1,68 @@
-//! Demonstrates how to read events asynchronously with async-std.
-//!
-//! cargo run --features="event-stream" --example event-stream-async-std
-
-use std::{io::stdout, time::Duration};
-
-use futures::{future::FutureExt, select, StreamExt};
-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_util::stream::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 = Delay::new(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());
-                        }
-
-                        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)?;
-
-    async_std::task::block_on(print_events());
-
-    execute!(stdout, DisableMouseCapture)?;
-
-    disable_raw_mode()
-}
+//! Demonstrates how to read events asynchronously with async-std.
+//!
+//! cargo run --features="event-stream" --example event-stream-async-std
+
+use std::{io::stdout, time::Duration};
+
+use futures::{future::FutureExt, select, StreamExt};
+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_util::stream::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 = Delay::new(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());
+                        }
+
+                        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)?;
+
+    async_std::task::block_on(print_events());
+
+    execute!(stdout, DisableMouseCapture)?;
+
+    disable_raw_mode()
+}

vendor/crossterm/examples/event-stream-tokio.rs

@@ -1,69 +1,69 @@
-//! Demonstrates how to read events asynchronously with tokio.
-//!
-//! cargo run --features="event-stream" --example event-stream-tokio
-
-use std::{io::stdout, time::Duration};
-
-use futures::{future::FutureExt, select, StreamExt};
-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_util::Stream with tokio
- - 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 = Delay::new(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());
-                        }
-
-                        if event == Event::Key(KeyCode::Esc.into()) {
-                            break;
-                        }
-                    }
-                    Some(Err(e)) => println!("Error: {:?}\r", e),
-                    None => break,
-                }
-            }
-        };
-    }
-}
-
-#[tokio::main]
-async fn main() -> Result<()> {
-    println!("{}", HELP);
-
-    enable_raw_mode()?;
-
-    let mut stdout = stdout();
-    execute!(stdout, EnableMouseCapture)?;
-
-    print_events().await;
-
-    execute!(stdout, DisableMouseCapture)?;
-
-    disable_raw_mode()
-}
+//! Demonstrates how to read events asynchronously with tokio.
+//!
+//! cargo run --features="event-stream" --example event-stream-tokio
+
+use std::{io::stdout, time::Duration};
+
+use futures::{future::FutureExt, select, StreamExt};
+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_util::Stream with tokio
+ - 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 = Delay::new(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());
+                        }
+
+                        if event == Event::Key(KeyCode::Esc.into()) {
+                            break;
+                        }
+                    }
+                    Some(Err(e)) => println!("Error: {:?}\r", e),
+                    None => break,
+                }
+            }
+        };
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    println!("{}", HELP);
+
+    enable_raw_mode()?;
+
+    let mut stdout = stdout();
+    execute!(stdout, EnableMouseCapture)?;
+
+    print_events().await;
+
+    execute!(stdout, DisableMouseCapture)?;
+
+    disable_raw_mode()
+}

vendor/crossterm/examples/is_tty.rs

@@ -1,18 +1,18 @@
-use crossterm::{
-    execute,
-    terminal::{size, SetSize},
-    tty::IsTty,
-};
-use std::io::{stdin, stdout};
-
-pub fn main() {
-    println!("{:?}", size().unwrap());
-    execute!(stdout(), SetSize(10, 10)).unwrap();
-    println!("{:?}", size().unwrap());
-
-    if stdin().is_tty() {
-        println!("Is TTY");
-    } else {
-        println!("Is not TTY");
-    }
-}
+use crossterm::{
+    execute,
+    terminal::{size, SetSize},
+    tty::IsTty,
+};
+use std::io::{stdin, stdout};
+
+pub fn main() {
+    println!("{:?}", size().unwrap());
+    execute!(stdout(), SetSize(10, 10)).unwrap();
+    println!("{:?}", size().unwrap());
+
+    if stdin().is_tty() {
+        println!("Is TTY");
+    } else {
+        println!("Is not TTY");
+    }
+}

vendor/crossterm/examples/stderr.rs

@@ -1,96 +1,96 @@
-//! This shows how an application can write on stderr
-//! instead of stdout, thus making it possible to
-//! the command API instead of the "old style" direct
-//! unbuffered API.
-//!
-//! This particular example is only suited to Unix
-//! for now.
-//!
-//! cargo run --example stderr
-
-use std::io::{stderr, Write};
-
-use crossterm::{
-    cursor::{Hide, MoveTo, Show},
-    event,
-    event::{Event, KeyCode, KeyEvent},
-    execute, queue,
-    style::Print,
-    terminal::{self, EnterAlternateScreen, LeaveAlternateScreen},
-    Result,
-};
-
-const TEXT: &str = r#"
-This screen is ran on stderr.
-And when you hit enter, it prints on stdout.
-This makes it possible to run an application and choose what will
-be sent to any application calling yours.
-
-For example, assuming you build this example with
-
-    cargo build --bin stderr
-
-and then you run it with
-
-    cd "$(target/debug/stderr)"
-
-what the application prints on stdout is used as argument to cd.
-
-Try it out.
-
-Hit any key to quit this screen:
-
-1 will print `..`
-2 will print `/`
-3 will print `~`
-Any other key will print this text (so that you may copy-paste)
-"#;
-
-fn run_app<W>(write: &mut W) -> Result<char>
-where
-    W: Write,
-{
-    queue!(
-        write,
-        EnterAlternateScreen, // enter alternate screen
-        Hide                  // hide the cursor
-    )?;
-
-    let mut y = 1;
-    for line in TEXT.split('\n') {
-        queue!(write, MoveTo(1, y), Print(line.to_string()))?;
-        y += 1;
-    }
-
-    write.flush()?;
-
-    terminal::enable_raw_mode()?;
-    let user_char = read_char()?; // we wait for the user to hit a key
-    execute!(write, Show, LeaveAlternateScreen)?; // restore the cursor and leave the alternate screen
-
-    terminal::disable_raw_mode()?;
-
-    Ok(user_char)
-}
-
-pub fn read_char() -> Result<char> {
-    loop {
-        if let Event::Key(KeyEvent {
-            code: KeyCode::Char(c),
-            ..
-        }) = event::read()?
-        {
-            return Ok(c);
-        }
-    }
-}
-
-// cargo run --example stderr
-fn main() {
-    match run_app(&mut stderr()).unwrap() {
-        '1' => print!(".."),
-        '2' => print!("/"),
-        '3' => print!("~"),
-        _ => println!("{}", TEXT),
-    }
-}
+//! This shows how an application can write on stderr
+//! instead of stdout, thus making it possible to
+//! the command API instead of the "old style" direct
+//! unbuffered API.
+//!
+//! This particular example is only suited to Unix
+//! for now.
+//!
+//! cargo run --example stderr
+
+use std::io::{stderr, Write};
+
+use crossterm::{
+    cursor::{Hide, MoveTo, Show},
+    event,
+    event::{Event, KeyCode, KeyEvent},
+    execute, queue,
+    style::Print,
+    terminal::{self, EnterAlternateScreen, LeaveAlternateScreen},
+    Result,
+};
+
+const TEXT: &str = r#"
+This screen is ran on stderr.
+And when you hit enter, it prints on stdout.
+This makes it possible to run an application and choose what will
+be sent to any application calling yours.
+
+For example, assuming you build this example with
+
+    cargo build --bin stderr
+
+and then you run it with
+
+    cd "$(target/debug/stderr)"
+
+what the application prints on stdout is used as argument to cd.
+
+Try it out.
+
+Hit any key to quit this screen:
+
+1 will print `..`
+2 will print `/`
+3 will print `~`
+Any other key will print this text (so that you may copy-paste)
+"#;
+
+fn run_app<W>(write: &mut W) -> Result<char>
+where
+    W: Write,
+{
+    queue!(
+        write,
+        EnterAlternateScreen, // enter alternate screen
+        Hide                  // hide the cursor
+    )?;
+
+    let mut y = 1;
+    for line in TEXT.split('\n') {
+        queue!(write, MoveTo(1, y), Print(line.to_string()))?;
+        y += 1;
+    }
+
+    write.flush()?;
+
+    terminal::enable_raw_mode()?;
+    let user_char = read_char()?; // we wait for the user to hit a key
+    execute!(write, Show, LeaveAlternateScreen)?; // restore the cursor and leave the alternate screen
+
+    terminal::disable_raw_mode()?;
+
+    Ok(user_char)
+}
+
+pub fn read_char() -> Result<char> {
+    loop {
+        if let Event::Key(KeyEvent {
+            code: KeyCode::Char(c),
+            ..
+        }) = event::read()?
+        {
+            return Ok(c);
+        }
+    }
+}
+
+// cargo run --example stderr
+fn main() {
+    match run_app(&mut stderr()).unwrap() {
+        '1' => print!(".."),
+        '2' => print!("/"),
+        '3' => print!("~"),
+        _ => println!("{}", TEXT),
+    }
+}