.gitlab-ci.yml

+image: "redoxos/redoxer"
+
+stages:
+    - build
+    - test
+
+variables:
+    REDOXER_USE_FUSE: no
+
+before_script:
+    cargo install redoxer --git "https://gitlab.redox-os.org/redox-os/redoxer.git"
+
+cache:
+    paths:
+        - target/
+
+build:linux:stable:
+    stage: build
+    script:
+        - rustup update stable
+        - cargo +stable build --verbose
+
+build:linux:
+    stage: build
+    script: cargo +nightly build --verbose
+
+build:redox:
+    stage: build
+    script: redoxer build --verbose
+
+test:linux:stable:
+    stage: test
+    dependencies:
+        - build:linux:stable
+    script:
+        - rustup update stable
+        - script -c "cargo +stable test --verbose"
+
+test:linux:
+    stage: test
+    dependencies:
+        - build:linux
+    script: script -c "cargo +nightly test --verbose"
+
+test:redox:
+    stage: test
+    dependencies:
+        - build:redox
+    script: redoxer test --verbose

.travis.yml

+language: rust
+cache: cargo
+rust:
+    - stable
+    - beta
+    - nightly
+os:
+    - linux
+    - osx
+script:
+    - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then FAKETTY="script -q /dev/null"; fi
+    - $FAKETTY cargo build --verbose
+    - $FAKETTY cargo test --verbose
+    - $FAKETTY cargo test --release --verbose

CHANGELOG.md

+# 4.0.4
+
+- Remove debug printing when parsing CSI sequences
+- Support NO\_COLOR environment variable
+
+# 4.0.3
+
+Remove unused code and update dependencies.
+
+# 4.0.2
+
+Fixes an error check in Ctrl-Arrow code, no difference in behavior. Cleaned up examples.
+
+# 4.0.1
+
+Fixes a regression in function keys F5 and above.
+
+# 4.0.0
+
+4.0.0 adds support for horizontal scrolling when working with `MouseTerminal`.
+
+## 3.0.0 to 4.0.0 guide
+
+A change is only necessary if you were matching on all variants of the `MouseEvent` enum without a wildcard.
+In this case, you need to either handle the two new variants, `MouseLeft` and `MouseRight`, or add a wildcard.
+
+# 3.0.0
+
+v3 release improves `raw` terminal API and enables support of any TTY target.
+
+## 2.0.0 to 3.0.0 guide
+
+Changes are only required if you were using `IntoRawMode` on generic terminals `W: Write`. Now, terminal
+is also required to implement [`AsFd` trait][AsFd-trait]. So replacing generic bounds with `W: Write + AsFd`
+should be sufficient.
+
+[AsFd-trait]: https://doc.rust-lang.org/std/os/fd/trait.AsFd.html
+
+# 1.0.0
+
+Termion 1.0.0 is out! This release is breaking, which is also the reason for the semver bump.
+
+## Highlights
+
+Lot'ta goodies.
+
+- **Mouse support:** If you enabled mouse mode through the `MouseTerminal` struct, you can get mouse events (thanks to IGI-111).
+- **TrueColor support:** You can now use true color, by the `Rgb` struct.
+- **A complete revision of the way escapes are handled:** Everything is now done through `Display` instead of custom traits.
+- **`isatty` wrapper:** `termion::is_tty` takes any `T: AsRawFd` and gives you a `bool`.
+- **Crates.io release:** Previously, it was distributed solely through git. This turns out to be very convinient, but quite critical whenever making breaking changes (that is, major semver bumps).
+
+## 0.1.0 to 1.0.0 guide
+
+This sample table gives an idea of how to go bu converting to the new major
+version of Termion.
+
+| 0.1.0                          | 1.0.0
+|--------------------------------|---------------------------
+| `use termion::IntoRawMode`     | `use termion::raw::IntoRawMode`
+| `stdout.color(color::Red);`    | `write!(stdout, "{}", color::Fg(color::Red));`
+| `stdout.color_bg(color::Red);` | `write!(stdout, "{}", color::Bg(color::Red));`
+| `stdout.goto(x, y);`           | `write!(stdout, "{}", cursor::Goto(x, y));`
+| `color::rgb(r, g, b);`         | `color::Rgb(r, g, b)` (truecolor)
+| `x.with_mouse()`               | `MouseTerminal::from(x)`
+
+## An example
+
+```rust
+#![feature(step_by)]
+
+extern crate termion;
+
+use termion::event::Key;
+use termion::input::TermRead;
+use termion::raw::IntoRawMode;
+use std::io::{Write, stdout, stdin};
+
+fn rainbow<W: Write>(stdout: &mut W, blue: u8) {
+    write!(stdout, "{}{}", termion::cursor::Goto(1, 1), termion::clear::All).unwrap();
+
+    for red in (0..255).step_by(8 as u8) {
+        for green in (0..255).step_by(4) {
+            write!(stdout, "{} ", termion::color::Bg(termion::color::Rgb(red, green, blue))).unwrap();
+        }
+        write!(stdout, "\n\r").unwrap();
+    }
+
+    writeln!(stdout, "{}b = {}", termion::style::Reset, blue).unwrap();
+}
+
+fn main() {
+    let stdin = stdin();
+    let mut stdout = stdout().into_raw_mode().unwrap();
+
+    writeln!(stdout, "{}{}{}Use the arrow keys to change the blue in the rainbow.",
+           termion::clear::All,
+           termion::cursor::Goto(1, 1),
+           termion::cursor::Hide).unwrap();
+
+    let mut blue = 172u8;
+
+    for c in stdin.keys() {
+        match c.unwrap() {
+            Key::Up => {
+                blue = blue.saturating_add(4);
+                rainbow(&mut stdout, blue);
+            },
+            Key::Down => {
+                blue = blue.saturating_sub(4);
+                rainbow(&mut stdout, blue);
+            },
+            Key::Char('q') => break,
+            _ => {},
+        }
+        stdout.flush().unwrap();
+    }
+
+    write!(stdout, "{}", termion::cursor::Show).unwrap();
+}
+```

Cargo.toml

 [package]
 name = "termion"
-version = "0.1.0"
-authors = ["Ticki <Ticki@users.noreply.github.com>"]
+version = "4.0.4"
+authors = [
+    "ticki <Ticki@users.noreply.github.com>",
+    "gycos <alexandre.bury@gmail.com>",
+    "IGI-111 <igi-111@protonmail.com>",
+    "Jeremy Soller <jackpot51@gmail.com>",
+]
+description = "A bindless library for manipulating terminals."
+repository = "https://gitlab.redox-os.org/redox-os/termion"
+documentation = "https://docs.rs/termion"
+license = "MIT"
+keywords = ["tty", "color", "terminal", "password", "tui"]
+exclude = ["target", "CHANGELOG.md", "image.png", "Cargo.lock"]
 
-[target.i686-unknown-linux-gnu.dependencies]
-libc = "0.2.8"
+[dependencies]
+numtoa = { version = "0.2.4"}
+serde = { version = "1.0", features = ["derive"], optional = true }
 
-[target.x86_64-unknown-linux-gnu.dependencies]
-libc = "0.2.8"
+[target.'cfg(not(target_os = "redox"))'.dependencies]
+libc = "0.2"
 
-[target.i686-unknown-linux-musl.dependencies]
-libc = "0.2.8"
-
-[target.x86_64-unknown-linux-musl.dependencies]
-libc = "0.2.8"
-
-[target.i686-apple-darwin.dependencies]
-libc = "0.2.8"
-
-[target.x86_64-apple-darwin.dependencies]
-libc = "0.2.8"
-
-[features]
-nightly = []
+[target.'cfg(target_os = "redox")'.dependencies]
+redox_termios = "0.1.3"
+libredox = "0.1.3"

FUNDING.json

+{
+  "drips": {
+    "ethereum": {
+      "ownedBy": "0x083e29156955A4c0f7eAA406e1167Bd1bE88933E"
+    }
+  }
+}

README.md

-Termion
-=======
+<p align="center">
+<img alt="Termion logo" src="https://rawgit.com/redox-os/termion/master/logo.svg" />
+</p>
 
-A pure Rust library for handling, manipulating and reading information about terminals. This provides a full-featured alternative to Termbox.
+[![Build Status](https://travis-ci.org/redox-os/termion.svg?branch=master)](https://travis-ci.org/redox-os/termion) [![Latest Version](https://img.shields.io/crates/v/termion.svg)](https://crates.io/crates/termion) | [Documentation](https://docs.rs/termion) | [Examples](https://github.com/redox-os/termion/tree/master/examples) | [Changelog](https://github.com/redox-os/termion/tree/master/CHANGELOG.md) | [Tutorial](http://ticki.github.io/blog/making-terminal-applications-in-rust-with-termion/)
+|----|----|----|----|----
 
-Supports Redox and POSIX. Untested on Windows.
 
-A note on stability
--------------------
+**Termion** is a pure Rust, bindless library for low-level handling, manipulating
+and reading information about terminals. This provides a full-featured
+alternative to Termbox.
 
-This crate is not stable, yet. However, if you do want stability, you should specify the revision (commit hash) in your `Cargo.toml`, this way builds are complete reproducible, and won't break.
+Termion aims to be simple and yet expressive. It is bindless, meaning that it
+is not a front-end to some other library (e.g., ncurses or termbox), but a
+standalone library directly talking to the TTY.
 
-Features
---------
+Termion is quite convenient, due to its complete coverage of essential TTY
+features, providing one consistent API. Termion is rather low-level containing
+only abstraction aligned with what actually happens behind the scenes. For
+something more high-level, refer to inquirer-rs, which uses Termion as backend.
+
+Termion generates escapes and API calls for the user. This makes it a whole lot
+cleaner to use escapes.
+
+Supports Redox, Mac OS X, BSD, and Linux (or, in general, ANSI terminals).
+
+## A note on stability
+
+This crate is stable.
+
+## Cargo.toml
+
+```toml
+[dependencies]
+termion = "*"
+```
+
+## 3.0.0 to 4.0.0 guide
+
+A change is only necessary if you were matching on all variants of the `MouseEvent` enum without a wildcard.
+In this case, you need to either handle the two new variants, `MouseLeft` and `MouseRight`, or add a wildcard.
+
+## 2.0.0 to 3.0.0 guide
+
+Changes are only required if you were using `IntoRawMode` on generic terminals `W: Write`. Now, terminal
+is also required to implement [`AsFd` trait][AsFd-trait]. So replacing generic bounds with `W: Write + AsFd`
+should be sufficient.
+
+[AsFd-trait]: https://doc.rust-lang.org/std/os/fd/trait.AsFd.html
+
+## 1.0.0 to 2.0.0 guide
+
+| 1.0.0                          | 2.0.0
+|--------------------------------|---------------------------
+| `AlternativeScreen::from(x)`   | `x.into_alternative_screen()`
+
+## 0.1.0 to 1.0.0 guide
+
+This sample table gives an idea of how to go about converting to the new major
+version of Termion.
+
+| 0.1.0                          | 1.0.0
+|--------------------------------|---------------------------
+| `use termion::IntoRawMode`     | `use termion::raw::IntoRawMode`
+| `use termion::TermRead`        | `use termion::input::TermRead`
+| `stdout.color(color::Red);`    | `write!(stdout, "{}", color::Fg(color::Red));`
+| `stdout.color_bg(color::Red);` | `write!(stdout, "{}", color::Bg(color::Red));`
+| `stdout.goto(x, y);`           | `write!(stdout, "{}", cursor::Goto(x, y));`
+| `color::rgb(r, g, b);`         | `color::Rgb(r, g, b)` (truecolor)
+| `x.with_mouse()`               | `MouseTerminal::from(x)`
+
+## Features
 
 - Raw mode.
+- TrueColor.
+- 256-color mode.
 - Cursor movement.
-- Color output.
 - Text formatting.
 - Console size.
+- TTY-only stream.
 - Control sequences.
 - Termios control.
 - Password input.
 - Redox support.
-- 256-color mode.
+- Safe `isatty` wrapper.
 - Panic-free error handling.
 - Special keys events (modifiers, special keys, etc.).
+- Allocation-free.
 - Asynchronous key events.
+- Mouse input.
+- Carefully tested.
+- Detailed documentation on every item.
 
 and much more.
 
-Usage
------
+## Examples
 
-See `examples/`, and the documentation, which can be rendered using `cargo doc`.
+### Style and colors.
+
+```rust
+extern crate termion;
 
-For a more complete example, see [a minesweeper implementation](https://github.com/redox-os/games-for-redox/blob/master/src/minesweeper.rs), that I made for Redox using termion.
+use termion::{color, style};
 
-![minesweeper](image.png)
+use std::io;
+
+fn main() {
+    println!("{}Red", color::Fg(color::Red));
+    println!("{}Blue", color::Fg(color::Blue));
+    println!("{}Blue'n'Bold{}", style::Bold, style::Reset);
+    println!("{}Just plain italic", style::Italic);
+}
+```
+
+### Moving the cursor
+
+```rust
+extern crate termion;
+
+fn main() {
+    print!("{}{}Stuff", termion::clear::All, termion::cursor::Goto(1, 1));
+}
+
+```
+
+### Mouse
+
+```rust
+extern crate termion;
+
+use termion::event::{Key, Event, MouseEvent};
+use termion::input::{TermRead, MouseTerminal};
+use termion::raw::IntoRawMode;
+use std::io::{Write, stdout, stdin};
+
+fn main() {
+    let stdin = stdin();
+    let mut stdout = MouseTerminal::from(stdout().into_raw_mode().unwrap());
+
+    write!(stdout, "{}{}q to exit. Click, click, click!", termion::clear::All, termion::cursor::Goto(1, 1)).unwrap();
+    stdout.flush().unwrap();
+
+    for c in stdin.events() {
+        let evt = c.unwrap();
+        match evt {
+            Event::Key(Key::Char('q')) => break,
+            Event::Mouse(me) => {
+                match me {
+                    MouseEvent::Press(_, x, y) => {
+                        write!(stdout, "{}x", termion::cursor::Goto(x, y)).unwrap();
+                    },
+                    _ => (),
+                }
+            }
+            _ => {}
+        }
+        stdout.flush().unwrap();
+    }
+}
+```
+
+### Read a password
+
+```rust
+extern crate termion;
+
+use termion::input::TermRead;
+use std::io::{Write, stdout, stdin};
+
+fn main() {
+    let stdout = stdout();
+    let mut stdout = stdout.lock();
+    let stdin = stdin();
+    let mut stdin = stdin.lock();
+
+    stdout.write_all(b"password: ").unwrap();
+    stdout.flush().unwrap();
+
+    let pass = stdin.read_passwd(&mut stdout);
+
+    if let Ok(Some(pass)) = pass {
+        stdout.write_all(pass.as_bytes()).unwrap();
+        stdout.write_all(b"\n").unwrap();
+    } else {
+        stdout.write_all(b"Error\n").unwrap();
+    }
+}
+```
+
+## Usage
+
+See `examples/`, and the documentation, which can be rendered using `cargo doc`.
 
-TODO
-----
+For a more complete example, see [a minesweeper implementation](https://github.com/redox-os/games-for-redox/blob/master/src/minesweeper/main.rs), that I made for Redox using termion.
 
-- Mouse input
+<img src="image.png" width="200">
 
-License
--------
+## License
 
-MIT.
+MIT/X11.

examples/alternate_screen.rs

+extern crate termion;
+
+use std::io::{stdout, Write};
+use std::{thread, time};
+use termion::screen::IntoAlternateScreen;
+
+fn main() {
+    {
+        let mut screen = stdout().into_alternate_screen().unwrap();
+        write!(screen, "Welcome to the alternate screen.\n\nPlease wait patiently until we arrive back at the main screen in a about three seconds.").unwrap();
+        screen.flush().unwrap();
+
+        thread::sleep(time::Duration::from_secs(3));
+    }
+
+    println!("Phew! We are back.");
+}

examples/alternate_screen_raw.rs

+extern crate termion;
+
+use std::io::{stdin, stdout, Write};
+use termion::event::Key;
+use termion::input::TermRead;
+use termion::raw::IntoRawMode;
+use termion::screen::{IntoAlternateScreen, ToAlternateScreen, ToMainScreen};
+
+fn write_alt_screen_msg<W: Write>(screen: &mut W) {
+    write!(screen, "{}{}Welcome to the alternate screen.{}Press '1' to switch to the main screen or '2' to switch to the alternate screen.{}Press 'q' to exit (and switch back to the main screen).",
+           termion::clear::All,
+           termion::cursor::Goto(1, 1),
+           termion::cursor::Goto(1, 3),
+           termion::cursor::Goto(1, 4)).unwrap();
+}
+
+fn main() {
+    let stdin = stdin();
+    let mut screen = stdout()
+        .into_raw_mode()
+        .unwrap()
+        .into_alternate_screen()
+        .unwrap();
+    write!(screen, "{}", termion::cursor::Hide).unwrap();
+    write_alt_screen_msg(&mut screen);
+
+    screen.flush().unwrap();
+
+    for c in stdin.keys() {
+        match c.unwrap() {
+            Key::Char('q') => break,
+            Key::Char('1') => {
+                write!(screen, "{}", ToMainScreen).unwrap();
+            }
+            Key::Char('2') => {
+                write!(screen, "{}", ToAlternateScreen).unwrap();
+                write_alt_screen_msg(&mut screen);
+            }
+            _ => {}
+        }
+        screen.flush().unwrap();
+    }
+    write!(screen, "{}", termion::cursor::Show).unwrap();
+}

examples/async.rs

 extern crate termion;
 
-use termion::{TermWrite, IntoRawMode, async_stdin};
-use std::io::{Read, Write, stdout, stdin};
+use std::io::{stdout, Read, Write};
 use std::thread;
 use std::time::Duration;
+use termion::async_stdin;
+use termion::raw::IntoRawMode;
 
 fn main() {
     let stdout = stdout();
     let mut stdout = stdout.lock().into_raw_mode().unwrap();
     let mut stdin = async_stdin().bytes();
 
-    stdout.clear().unwrap();
-    stdout.goto(0, 0).unwrap();
+    write!(
+        stdout,
+        "{}{}",
+        termion::clear::All,
+        termion::cursor::Goto(1, 1)
+    )
+    .unwrap();
 
     loop {
-        stdout.clear_line().unwrap();
+        write!(stdout, "{}", termion::clear::CurrentLine).unwrap();
 
         let b = stdin.next();
         write!(stdout, "\r{:?}    <- This demonstrates the async read input char. Between each update a 100 ms. is waited, simply to demonstrate the async fashion. \n\r", b).unwrap();
@@ -25,11 +31,11 @@ fn main() {
         stdout.flush().unwrap();
 
         thread::sleep(Duration::from_millis(50));
-        stdout.write(b"# ").unwrap();
+        stdout.write_all(b"# ").unwrap();
         stdout.flush().unwrap();
         thread::sleep(Duration::from_millis(50));
-        stdout.write(b"\r #").unwrap();
-        stdout.goto(0, 0).unwrap();
+        stdout.write_all(b"\r #").unwrap();
+        write!(stdout, "{}", termion::cursor::Goto(1, 1)).unwrap();
         stdout.flush().unwrap();
     }
 }

examples/click.rs

+extern crate termion;
+
+use std::io::{stdin, stdout, Write};
+use termion::event::{Event, Key, MouseEvent};
+use termion::input::{MouseTerminal, TermRead};
+use termion::raw::IntoRawMode;
+
+fn main() {
+    let stdin = stdin();
+    let mut stdout = MouseTerminal::from(stdout().into_raw_mode().unwrap());
+
+    write!(
+        stdout,
+        "{}{}q to exit. Click, click, click!",
+        termion::clear::All,
+        termion::cursor::Goto(1, 1)
+    )
+    .unwrap();
+    stdout.flush().unwrap();
+
+    for c in stdin.events() {
+        let evt = c.unwrap();
+        match evt {
+            Event::Key(Key::Char('q')) => break,
+            Event::Mouse(me) => match me {
+                MouseEvent::Press(_, x, y) => {
+                    write!(stdout, "{}x", termion::cursor::Goto(x, y)).unwrap();
+                }
+                _ => (),
+            },
+            _ => {}
+        }
+        stdout.flush().unwrap();
+    }
+}

examples/color.rs

+extern crate termion;
+
+use termion::{color, style};
+
+fn main() {
+    println!("{}Gray background", color::Bg(color::LightBlack));
+    println!("{}Red", color::Fg(color::Red));
+    println!("{}Blue", color::Fg(color::Blue));
+    println!("{}Blue'n'Bold{}", style::Bold, style::Reset);
+    println!("{}Just plain italic{}", style::Italic, style::Reset);
+}

examples/detect_color.rs

+extern crate termion;
+
+use std::io::stdout;
+use termion::color::{AnsiValue, Bg, DetectColors};
+use termion::raw::IntoRawMode;
+
+fn main() {
+    let count;
+    {
+        let mut term = stdout().into_raw_mode().unwrap();
+        count = term.available_colors().unwrap();
+    }
+
+    println!("This terminal supports {} colors.", count);
+    for i in 0..count {
+        print!("{} {}", Bg(AnsiValue(i as u8)), Bg(AnsiValue(0)));
+    }
+    println!();
+}

examples/is_tty.rs

+extern crate termion;
+
+use std::fs;
+
+fn main() {
+    if termion::is_tty(&fs::File::create("/dev/stdout").unwrap()) {
+        println!("This is a TTY!");
+    } else {
+        println!("This is not a TTY :(");
+    }
+}

examples/keys.rs

 extern crate termion;
 
+use std::io::{stdin, stdout, Write};
+use termion::event::Key;
+use termion::input::TermRead;
+use termion::raw::IntoRawMode;
 
-#[cfg(feature = "nightly")]
 fn main() {
-    use termion::{TermRead, TermWrite, IntoRawMode, Key};
-    use std::io::{Write, stdout, stdin};
-
     let stdin = stdin();
     let mut stdout = stdout().into_raw_mode().unwrap();
 
-    stdout.clear().unwrap();
-    stdout.goto(0, 0).unwrap();
-    stdout.write(b"q to exit. Type stuff, use alt, and so on.").unwrap();
-    stdout.hide_cursor().unwrap();
+    write!(
+        stdout,
+        "{}{}q to exit. Type stuff, use alt, and so on.{}",
+        termion::clear::All,
+        termion::cursor::Goto(1, 1),
+        termion::cursor::Hide
+    )
+    .unwrap();
     stdout.flush().unwrap();
 
-    for c in stdin.keys() {
-        stdout.goto(5, 5).unwrap();
-        stdout.clear_line().unwrap();
-        match c {
+    for k in stdin.keys() {
+        write!(
+            stdout,
+            "{}{}",
+            termion::cursor::Goto(1, 1),
+            termion::clear::CurrentLine
+        )
+        .unwrap();
+
+        match k.as_ref().unwrap() {
             Key::Char('q') => break,
             Key::Char(c) => println!("{}", c),
             Key::Alt(c) => println!("^{}", c),
             Key::Ctrl(c) => println!("*{}", c),
+            Key::Esc => println!("ESC"),
             Key::Left => println!("←"),
             Key::Right => println!("→"),
             Key::Up => println!("↑"),
             Key::Down => println!("↓"),
             Key::Backspace => println!("×"),
-            Key::Invalid => println!("???"),
-            Key::Error => println!("ERROR"),
-            _ => {},
+            _ => {
+                println!("{:?}", k)
+            }
         }
         stdout.flush().unwrap();
     }
 
-    stdout.show_cursor().unwrap();
-}
-#[cfg(not(feature = "nightly"))]
-fn main() {
-    println!("To run this example, you need to enable the `nightly` feature. Use Rust nightly and compile with `--features nightly`.")
+    write!(stdout, "{}", termion::cursor::Show).unwrap();
 }

examples/mouse.rs

+extern crate termion;
+
+use std::io::{self, Write};
+use termion::cursor::{self, DetectCursorPos};
+use termion::event::*;
+use termion::input::{MouseTerminal, TermRead};
+use termion::raw::IntoRawMode;
+
+fn main() {
+    let stdin = io::stdin();
+    let mut stdout = MouseTerminal::from(io::stdout().into_raw_mode().unwrap());
+
+    writeln!(
+        stdout,
+        "{}{}q to exit. Type stuff, use alt, click around...",
+        termion::clear::All,
+        termion::cursor::Goto(1, 1)
+    )
+    .unwrap();
+
+    for c in stdin.events() {
+        let evt = c.unwrap();
+        match evt {
+            Event::Key(Key::Char('q')) => break,
+            Event::Mouse(me) => match me {
+                MouseEvent::Press(_, a, b) | MouseEvent::Release(a, b) | MouseEvent::Hold(a, b) => {
+                    write!(stdout, "{}", cursor::Goto(a, b)).unwrap();
+                    let (x, y) = stdout.cursor_pos().unwrap();
+                    write!(
+                        stdout,
+                        "{}{}Cursor is at: ({},{}){}",
+                        cursor::Goto(5, 5),
+                        termion::clear::UntilNewline,
+                        x,
+                        y,
+                        cursor::Goto(a, b)
+                    )
+                    .unwrap();
+                }
+            },
+            _ => {}
+        }
+
+        stdout.flush().unwrap();
+    }
+}

examples/rainbow.rs

+extern crate termion;
+
+use std::io::{stdin, stdout, Write};
+use termion::event::Key;
+use termion::input::TermRead;
+use termion::raw::IntoRawMode;
+
+fn rainbow<W: Write>(stdout: &mut W, blue: u8) {
+    write!(
+        stdout,
+        "{}{}",
+        termion::cursor::Goto(1, 1),
+        termion::clear::All
+    )
+    .unwrap();
+
+    for red in 0..32 {
+        let red = red * 8;
+        for green in 0..64 {
+            let green = green * 4;
+            write!(
+                stdout,
+                "{} ",
+                termion::color::Bg(termion::color::Rgb(red, green, blue))
+            )
+            .unwrap();
+        }
+        write!(stdout, "\n\r").unwrap();
+    }
+
+    writeln!(stdout, "{}b = {}", termion::style::Reset, blue).unwrap();
+}
+
+fn main() {
+    let stdin = stdin();
+    let mut stdout = stdout().into_raw_mode().unwrap();
+
+    writeln!(
+        stdout,
+        "{}{}{}Use the up/down arrow keys to change the blue in the rainbow.",
+        termion::clear::All,
+        termion::cursor::Goto(1, 1),
+        termion::cursor::Hide
+    )
+    .unwrap();
+
+    let mut blue = 172u8;
+
+    for c in stdin.keys() {
+        match c.unwrap() {
+            Key::Up => {
+                blue = blue.saturating_add(4);
+                rainbow(&mut stdout, blue);
+            }
+            Key::Down => {
+                blue = blue.saturating_sub(4);
+                rainbow(&mut stdout, blue);
+            }
+            Key::Char('q') => break,
+            _ => {}
+        }
+        stdout.flush().unwrap();
+    }
+
+    write!(stdout, "{}", termion::cursor::Show).unwrap();
+}

examples/read.rs

 extern crate termion;
 
-use termion::TermRead;
-use std::io::{Write, stdout, stdin};
+use std::io::{stdin, stdout, Write};
+use termion::input::TermRead;
 
 fn main() {
     let stdout = stdout();
@@ -9,15 +9,15 @@ fn main() {
     let stdin = stdin();
     let mut stdin = stdin.lock();
 
-    stdout.write(b"password: ").unwrap();
+    stdout.write_all(b"password: ").unwrap();
     stdout.flush().unwrap();
 
     let pass = stdin.read_passwd(&mut stdout);
 
     if let Ok(Some(pass)) = pass {
-        stdout.write(pass.as_bytes()).unwrap();
-        stdout.write(b"\n").unwrap();
+        stdout.write_all(pass.as_bytes()).unwrap();
+        stdout.write_all(b"\n").unwrap();
     } else {
-        stdout.write(b"Error\n").unwrap();
+        stdout.write_all(b"Error\n").unwrap();
     }
 }

examples/rustc_fun.rs

+extern crate termion;
+
+use termion::{color, style};
+
+fn main() {
+    println!("{lighgreen}-- src/test/ui/borrow-errors.rs at 82:18 --\n\
+              {red}error: {reset}{bold}two closures require unique access to `vec` at the same time {reset}{bold}{magenta}[E0524]{reset}\n\
+              {line_num_fg}{line_num_bg}79 {reset}     let append = |e| {{\n\
+              {line_num_fg}{line_num_bg}{info_line}{reset}                  {red}^^^{reset} {error_fg}first closure is constructed here\n\
+              {line_num_fg}{line_num_bg}80 {reset}         vec.push(e)\n\
+              {line_num_fg}{line_num_bg}{info_line}{reset}                 {red}^^^{reset} {error_fg}previous borrow occurs due to use of `vec` in closure\n\
+              {line_num_fg}{line_num_bg}84 {reset}     }};\n\
+              {line_num_fg}{line_num_bg}85 {reset} }}\n\
+              {line_num_fg}{line_num_bg}{info_line}{reset} {red}^{reset} {error_fg}borrow from first closure ends here",
+             lighgreen = color::Fg(color::LightGreen),
+             red = color::Fg(color::Red),
+             bold = style::Bold,
+             reset = style::Reset,
+             magenta = color::Fg(color::Magenta),
+             line_num_bg = color::Bg(color::AnsiValue::grayscale(3)),
+             line_num_fg = color::Fg(color::AnsiValue::grayscale(18)),
+             info_line = "|  ",
+             error_fg = color::Fg(color::AnsiValue::grayscale(17)))
+}

examples/simple.rs

 extern crate termion;
 
-use termion::{TermWrite, IntoRawMode, Color, Style};
-use std::io::{Read, Write, stdout, stdin};
+use std::io::{stdin, stdout, Read, Write};
+use termion::color;
+use termion::raw::IntoRawMode;
 
 fn main() {
+    // Initialize 'em all.
     let stdout = stdout();
     let mut stdout = stdout.lock().into_raw_mode().unwrap();
     let stdin = stdin();
     let stdin = stdin.lock();
 
-    stdout.goto(5, 5).unwrap();
-    stdout.clear().unwrap();
-    stdout.style(Style::Bold).unwrap();
-    stdout.write(b"yo, 'q' will exit.").unwrap();
-    stdout.reset().unwrap();
+    write!(
+        stdout,
+        "{}{}{}yo, 'q' will exit.{}{}",
+        termion::clear::All,
+        termion::cursor::Goto(5, 5),
+        termion::style::Bold,
+        termion::style::Reset,
+        termion::cursor::Goto(20, 10)
+    )
+    .unwrap();
     stdout.flush().unwrap();
-    stdout.goto(20, 10).unwrap();
 
     let mut bytes = stdin.bytes();
     loop {
         let b = bytes.next().unwrap().unwrap();
 
         match b {
+            // Quit
             b'q' => return,
-            b'c' => stdout.clear(),
-            b'r' => stdout.color(Color::Rgb(5, 0, 0)),
-            a => stdout.write(&[a]),
-        }.unwrap();
+            // Clear the screen
+            b'c' => write!(stdout, "{}", termion::clear::All),
+            // Set red color
+            b'r' => write!(stdout, "{}", color::Fg(color::Rgb(255, 0, 0))),
+            // Write it to stdout.
+            a => write!(stdout, "{}", a),
+        }
+        .unwrap();
 
         stdout.flush().unwrap();
     }

examples/truecolor.rs

+extern crate termion;
+
+use std::{thread, time};
+use termion::{clear, color, cursor};
+
+fn main() {
+    for r in 0..255 {
+        let c = color::Rgb(r, !r, 2 * ((r % 128) as i8 - 64).abs() as u8);
+        println!("{}{}{}wow", cursor::Goto(1, 1), color::Bg(c), clear::All);
+        thread::sleep(time::Duration::from_millis(100));
+    }
+}